WebSVN – HelenOS – Diff – /trunk/kernel/genarch/src/drivers/via-cuda/cuda.c

 #include <arch/asm.h>
 #include <mm/slab.h>
 #include <ddi/device.h>
 #include <synch/spinlock.h>
-static void cuda_packet_handle(cuda_instance_t *instance, size_t len);
+static void cuda_packet_handle(cuda_instance_t *instance, uint8_t *buf, size_t len);
+static void cuda_irq_listen(irq_t *irq);
+static void cuda_irq_receive(irq_t *irq);
+static void cuda_irq_rcv_end(irq_t *irq, void *buf, size_t *len);
 /** B register fields */
 enum {
     TREQ    = 0x08,
     TACK    = 0x10,
     TIP = 0x20
 };
 /** IER register fields */
 enum {
+    IER_CLR = 0x00,
     IER_SET = 0x80,
-    SR_INT  = 0x04
+    SR_INT  = 0x04,
+    ALL_INT = 0x7f
+};
+/** ACR register fields */
+enum {
+    SR_OUT  = 0x10
 };
+#include <print.h>
 static irq_ownership_t cuda_claim(irq_t *irq)
+{
     cuda_instance_t *instance = irq->instance;
     cuda_t *dev = instance->cuda;
     uint8_t ifr;
     ifr = pio_read_8(&dev->ifr);
-    if ((ifr & SR_INT) != 0)
+    if ((ifr & SR_INT) == 0)
-        return IRQ_ACCEPT;
-    else
         return IRQ_DECLINE;
+    return IRQ_ACCEPT;
+}
 static void cuda_irq_handler(irq_t *irq)
+{
     cuda_instance_t *instance = irq->instance;
-    cuda_t *dev = instance->cuda;
+    uint8_t rbuf[CUDA_RCV_BUF_SIZE];
+    size_t len;
+    bool handle;
-    uint8_t b, data;
+    handle = false;
-    size_t pos;
+    len = 0;
     spinlock_lock(&instance->dev_lock);
-    /* We have received one or more CUDA packets. Process them all. */
+    /* Lower IFR.SR_INT so that CUDA can generate next int by raising it. */
-    while (true) {
-        b = pio_read_8(&dev->b);
+    pio_write_8(&instance->cuda->ifr, SR_INT);
-        if ((b & TREQ) != 0)
+    switch (instance->xstate) {
+    case cx_listen: cuda_irq_listen(irq); break;
+    case cx_receive: cuda_irq_receive(irq); break;
+    case cx_rcv_end: cuda_irq_rcv_end(irq, rbuf, &len);
-            break;  /* No data */
+        handle = true; break;
+    }
-        pio_write_8(&dev->b, b & ~TIP);
+    spinlock_unlock(&instance->dev_lock);
-        /* Read one packet. */
+    /* Handle an incoming packet. */
+    if (handle)
+        cuda_packet_handle(instance, rbuf, len);
+}
-        pos = 0;
+/** Interrupt in listen state.
-        do {
+ *
-            data = pio_read_8(&dev->sr);
+ * Start packet reception.
-            b = pio_read_8(&dev->b);
+ */
-            pio_write_8(&dev->b, b ^ TACK);
+static void cuda_irq_listen(irq_t *irq)
+{
-            if (pos < CUDA_RCV_BUF_SIZE)
+    cuda_instance_t *instance = irq->instance;
-                instance->rcv_buf[pos++] = data;
+    cuda_t *dev = instance->cuda;
-        } while ((b & TREQ) == 0);
+    uint8_t b;
-        pio_write_8(&dev->b, b | TACK | TIP);
+    b = pio_read_8(&dev->b);
+    if ((b & TREQ) != 0) {
-        cuda_packet_handle(instance, pos);
+        printf("cuda_irq_listen: no TREQ?!\n");
+        return;
+    }
+    pio_read_8(&dev->sr);
+    pio_write_8(&dev->b, pio_read_8(&dev->b) & ~TIP);
-    spinlock_unlock(&instance->dev_lock);
+    instance->xstate = cx_receive;
+}
+/** Interrupt in receive state.
+ *
+ * Receive next byte of packet.
+ */
-static void cuda_packet_handle(cuda_instance_t *instance, size_t len)
+static void cuda_irq_receive(irq_t *irq)
+{
+    cuda_instance_t *instance = irq->instance;
-    uint8_t *data = instance->rcv_buf;
+    cuda_t *dev = instance->cuda;
+    uint8_t b, data;
+    data = pio_read_8(&dev->sr);
+    if (instance->bidx < CUDA_RCV_BUF_SIZE)
+        instance->rcv_buf[instance->bidx++] = data;
+    b = pio_read_8(&dev->b);
+    if ((b & TREQ) == 0) {
+        pio_write_8(&dev->b, b ^ TACK);
+    } else {
+        pio_write_8(&dev->b, b | TACK | TIP);
+        instance->xstate = cx_rcv_end;
+    }
+}
+/** Interrupt in rcv_end state.
+ *
+ * Terminate packet reception. Either go back to listen state or start
+ * receiving another packet if CUDA has one for us.
+ */
+static void cuda_irq_rcv_end(irq_t *irq, void *buf, size_t *len)
+{
+    cuda_instance_t *instance = irq->instance;
+    cuda_t *dev = instance->cuda;
+    uint8_t data, b;
+    b = pio_read_8(&dev->b);
+    data = pio_read_8(&dev->sr);
+    instance->xstate = cx_listen;
+    if ((b & TREQ) == 0) {
+        instance->xstate = cx_receive;
+        pio_write_8(&dev->b, b & ~TIP);
+    } else {
+        instance->xstate = cx_listen;
+    }
+        memcpy(buf, instance->rcv_buf, instance->bidx);
+        *len = instance->bidx;
+    instance->bidx = 0;
+}
+static void cuda_packet_handle(cuda_instance_t *instance, uint8_t *data, size_t len)
+{
-    if (data[0] != 0x00 || data[1] != 0x40 || data[2] != 0x2c)
+    if (data[0] != 0x00 || data[1] != 0x40 || (data[2] != 0x2c
+        && data[2] != 0x8c))
         return;
     /* The packet contains one or two scancodes. */
     if (data[3] != 0xff)
         indev_push_character(instance->kbrdin, data[3]);
     cuda_instance_t *instance
         = malloc(sizeof(cuda_instance_t), FRAME_ATOMIC);
     if (instance) {
         instance->cuda = dev;
         instance->kbrdin = NULL;
+        instance->xstate = cx_listen;
+        instance->bidx = 0;
         spinlock_initialize(&instance->dev_lock, "cuda_dev");
+        /* Disable all interrupts from CUDA. */
+        pio_write_8(&dev->ier, IER_CLR | ALL_INT);
         irq_initialize(&instance->irq);
         instance->irq.devno = device_assign_devno();
         instance->irq.inr = inr;
         instance->irq.claim = cuda_claim;
         instance->irq.handler = cuda_irq_handler;
         instance->irq.instance = instance;
         instance->irq.cir = cir;
         instance->irq.cir_arg = cir_arg;
+        instance->irq.preack = true;
+    }
     return instance;
+}
 void cuda_wire(cuda_instance_t *instance, indev_t *kbrdin)
+{
+    cuda_t *dev = instance->cuda;
     ASSERT(instance);
     ASSERT(kbrdin);
     instance->kbrdin = kbrdin;
     irq_register(&instance->irq);
     /* Enable SR interrupt. */
+    pio_write_8(&dev->ier, TIP | TREQ);
-    pio_write_8(&instance->cuda->ier, IER_SET | SR_INT);
+    pio_write_8(&dev->ier, IER_SET | SR_INT);
+}
 /** @}
  */

Subversion Repositories HelenOS

(root)/trunk/kernel/genarch/src/drivers/via-cuda/cuda.c – Rev 4610 → 4626