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

 /*
  * Copyright (c) 2006 Martin Decky
  * Copyright (c) 2009 Jiri Svoboda
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  * - Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
  * - Redistributions in binary form must reproduce the above copyright
  *   notice, this list of conditions and the following disclaimer in the
  *   documentation and/or other materials provided with the distribution.
  * - The name of the author may not be used to endorse or promote products
  *   derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup genarch
  * @{
  */
 /** @file
  */
 #include <genarch/drivers/via-cuda/cuda.h>
 #include <console/chardev.h>
 #include <ddi/irq.h>
 #include <arch/asm.h>
 #include <mm/slab.h>
 #include <ddi/device.h>
 #include <synch/spinlock.h>
+static irq_ownership_t cuda_claim(irq_t *irq);
-static void cuda_packet_handle(cuda_instance_t *instance, uint8_t *buf, size_t len);
+static void cuda_irq_handler(irq_t *irq);
 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);
+static void cuda_irq_send_start(irq_t *irq);
+static void cuda_irq_send(irq_t *irq);
+static void cuda_packet_handle(cuda_instance_t *instance, uint8_t *buf, size_t len);
+static void cuda_send_start(cuda_instance_t *instance);
+static void cuda_autopoll_set(cuda_instance_t *instance, bool enable);
 /** B register fields */
 enum {
     TREQ    = 0x08,
     TACK    = 0x10,
     TIP = 0x20
 };
 /** IER register fields */
 enum {
     IER_CLR = 0x00,
     IER_SET = 0x80,
     SR_INT  = 0x04,
     ALL_INT = 0x7f
 };
 /** ACR register fields */
 enum {
     SR_OUT  = 0x10
 };
+/** Packet types */
+enum {
+    PT_ADB  = 0x00,
+    PT_CUDA = 0x01
+};
+/** CUDA packet types */
+enum {
+    CPT_AUTOPOLL    = 0x01
+};
+cuda_instance_t *cuda_init(cuda_t *dev, inr_t inr, cir_t cir, void *cir_arg)
+{
+    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;
+        instance->snd_bytes = 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;
+}
 #include <print.h>
+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(&dev->ier, IER_SET | SR_INT);
+    /* Enable ADB autopolling. */
+    cuda_autopoll_set(instance, true);
+}
 static irq_ownership_t cuda_claim(irq_t *irq)
+{
     cuda_instance_t *instance = irq->instance;
     cuda_t *dev = instance->cuda;
     uint8_t ifr;
+    spinlock_lock(&instance->dev_lock);
     ifr = pio_read_8(&dev->ifr);
+    spinlock_unlock(&instance->dev_lock);
     if ((ifr & SR_INT) == 0)
         return IRQ_DECLINE;
     return IRQ_ACCEPT;
+}
 static void cuda_irq_handler(irq_t *irq)
+{
     cuda_instance_t *instance = irq->instance;
     uint8_t rbuf[CUDA_RCV_BUF_SIZE];
     size_t len;
     bool handle;
     handle = false;
     len = 0;
     spinlock_lock(&instance->dev_lock);
     /* Lower IFR.SR_INT so that CUDA can generate next int by raising it. */
     pio_write_8(&instance->cuda->ifr, SR_INT);
     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);
         handle = true; break;
+    case cx_send_start: cuda_irq_send_start(irq); break;
+    case cx_send: cuda_irq_send(irq); break;
+    }
     spinlock_unlock(&instance->dev_lock);
     /* Handle an incoming packet. */
     if (handle)
         cuda_packet_handle(instance, rbuf, len);
+}
 /** Interrupt in listen state.
+ *
  * Start packet reception.
  */
 static void cuda_irq_listen(irq_t *irq)
+{
     cuda_instance_t *instance = irq->instance;
     cuda_t *dev = instance->cuda;
     uint8_t b;
     b = pio_read_8(&dev->b);
     if ((b & TREQ) != 0) {
         printf("cuda_irq_listen: no TREQ?!\n");
         return;
+    }
     pio_read_8(&dev->sr);
     pio_write_8(&dev->b, pio_read_8(&dev->b) & ~TIP);
     instance->xstate = cx_receive;
+}
 /** Interrupt in receive state.
+ *
  * Receive next byte of packet.
  */
 static void cuda_irq_receive(irq_t *irq)
+{
     cuda_instance_t *instance = irq->instance;
     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;
+        cuda_send_start(instance);
+    }
         memcpy(buf, instance->rcv_buf, instance->bidx);
         *len = instance->bidx;
     instance->bidx = 0;
+}
+/** Interrupt in send_start state.
+ *
+ * Process result of sending first byte (and send second on success).
+ */
+static void cuda_irq_send_start(irq_t *irq)
+{
+    cuda_instance_t *instance = irq->instance;
+    cuda_t *dev = instance->cuda;
+    uint8_t b;
+    b = pio_read_8(&dev->b);
+    if ((b & TREQ) == 0) {
+        /* Collision */
+        pio_write_8(&dev->acr, pio_read_8(&dev->acr) & ~SR_OUT);
+        pio_read_8(&dev->sr);
+        pio_write_8(&dev->b, pio_read_8(&dev->b) | TIP | TACK);
+        instance->xstate = cx_listen;
+        return;
+    }
+    pio_write_8(&dev->sr, instance->snd_buf[1]);
+    pio_write_8(&dev->b, pio_read_8(&dev->b) ^ TACK);
+    instance->bidx = 2;
+    instance->xstate = cx_send;
+}
+/** Interrupt in send state.
+ *
+ * Send next byte or terminate transmission.
+ */
+static void cuda_irq_send(irq_t *irq)
+{
+    cuda_instance_t *instance = irq->instance;
+    cuda_t *dev = instance->cuda;
+    if (instance->bidx < instance->snd_bytes) {
+        /* Send next byte. */
+        pio_write_8(&dev->sr, instance->snd_buf[instance->bidx++]);
+        pio_write_8(&dev->b, pio_read_8(&dev->b) ^ TACK);
+        return;
+    }
+    /* End transfer. */
+    instance->snd_bytes = 0;
+    instance->bidx = 0;
+    pio_write_8(&dev->acr, pio_read_8(&dev->acr) & ~SR_OUT);
+    pio_read_8(&dev->sr);
+    pio_write_8(&dev->b, pio_read_8(&dev->b) | TACK | TIP);
+    instance->xstate = cx_listen;
+    /* TODO: Match reply with request. */
+}
 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
         && data[2] != 0x8c))
         return;
     /* The packet contains one or two scancodes. */
     if (data[3] != 0xff)
         indev_push_character(instance->kbrdin, data[3]);
     if (data[4] != 0xff)
         indev_push_character(instance->kbrdin, data[4]);
+}
-cuda_instance_t *cuda_init(cuda_t *dev, inr_t inr, cir_t cir, void *cir_arg)
+static void cuda_autopoll_set(cuda_instance_t *instance, bool enable)
+{
-    cuda_instance_t *instance
+    instance->snd_buf[0] = PT_CUDA;
-        = malloc(sizeof(cuda_instance_t), FRAME_ATOMIC);
-    if (instance) {
-        instance->cuda = dev;
+    instance->snd_buf[1] = CPT_AUTOPOLL;
-        instance->kbrdin = NULL;
+    instance->snd_buf[2] = enable ? 0x01 : 0x00;
-        instance->xstate = cx_listen;
+    instance->snd_bytes = 3;
-        instance->bidx = 0;
+    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;
+    cuda_send_start(instance);
+}
-void cuda_wire(cuda_instance_t *instance, indev_t *kbrdin)
+static void cuda_send_start(cuda_instance_t *instance)
+{
     cuda_t *dev = instance->cuda;
-    ASSERT(instance);
+    ASSERT(instance->xstate == cx_listen);
-    ASSERT(kbrdin);
-    instance->kbrdin = kbrdin;
+    if (instance->snd_bytes == 0)
-    irq_register(&instance->irq);
+        return;
-    /* Enable SR interrupt. */
+    /* Check for incoming data. */
-    pio_write_8(&dev->ier, TIP | TREQ);
+    if ((pio_read_8(&dev->b) & TREQ) == 0)
+        return;
+    pio_write_8(&dev->acr, pio_read_8(&dev->acr) | SR_OUT);
-    pio_write_8(&dev->ier, IER_SET | SR_INT);
+    pio_write_8(&dev->sr, instance->snd_buf[0]);
+    pio_write_8(&dev->b, pio_read_8(&dev->b) & ~TIP);
+    instance->xstate = cx_send_start;
+}
 /** @}
  */

Subversion Repositories HelenOS

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