Changeset 86554e7 in mainline for uspace/srv/pci/serial.c

Timestamp:

2009-11-16T15:21:44Z (14 years ago)

Author:

Lenka Trochtova <trochtova.lenka@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f052c57

Parents:

8344d0a

Message:

serial port now uses interrupts for receiving data

File:

• uspace/srv/pci/serial.c (modified) (17 diffs)

uspace/srv/pci/serial.c

@@ -18 +18 @@
 #include "isa.h"
 #include "serial.h"
+#include "pic.h"
 
 #define NAME "serial"
@@ -24 +25 @@
 
 #define MAX_NAME_LEN 8
+#define BUF_LEN 256  // the length of the input buffer
+
+struct cyclic_buffer {
+        uint8_t buf[BUF_LEN];  // cyclic buffer 
+        int start;
+        int cnt;
+};
+
+typedef struct cyclic_buffer cyclic_buffer_t;
+
+// returns false if the buffer is full
+static bool buf_push_back(cyclic_buffer_t *buf, uint8_t item) 
+{
+        if (buf->cnt >= BUF_LEN) {
+                return false;
+        }
+        
+        int pos = (buf->start + buf->cnt) % BUF_LEN;
+        buf->buf[pos] = item;
+        buf->cnt++;
+        return true;
+}
+
+static bool buf_is_empty(cyclic_buffer_t *buf) 
+{
+        return buf->cnt == 0;
+}
+
+// call it on non empty buffer!
+static uint8_t buf_pop_front(cyclic_buffer_t *buf) 
+{
+        assert(!buf_is_empty(buf));
+        
+        uint8_t res = buf->buf[buf->start];
+        buf->start = (buf->start + 1) % BUF_LEN;        
+        buf->cnt--;
+        return res;
+}
+
+static void buf_clear(cyclic_buffer_t *buf) 
+{
+        buf->cnt = 0;
+}
 
 struct serial_dev {
         link_t link;
         char name[MAX_NAME_LEN];
-        int handle;
+        int handle; // devmapper device handle
+        int devno; // unique device number; used in irq registration (cannot be handle used instead of it?) 
         bool client_connected;
         ioport8_t *port;
         void *phys_addr;
+        int irq;
         bridge_to_isa_t *parent;
+        cyclic_buffer_t input_buffer;
+        futex_t futex;
 };
 
 typedef struct serial_dev serial_dev_t;
 
+static irq_cmd_t serial_cmds[] = {
+        {
+                .cmd = CMD_ACCEPT
+        }
+};
+
+static irq_code_t serial_pseudocode = {
+        sizeof(serial_cmds) / sizeof(irq_cmd_t),
+        serial_cmds
+};
+
 static void * serial_phys_addresses[] = { (void *)0x3F8, (void *)0x2F8 };
+static int serial_irqs[] = { 4, 3 }; // TODO - what about if there were more than two serial ports?
 static int serial_phys_addr_cnt = sizeof(serial_phys_addresses)/sizeof(void *);
+static int serial_irq_cnt = sizeof(serial_irqs)/sizeof(int);
+
 // number, which should be assigned to a newly found serial device - increment first, then assign to the device
 static int serial_idx = 0; 
@@ -61 +123 @@
 static void serial_getchar(serial_dev_t *dev, ipc_callid_t rid);
 static void serial_client_conn(ipc_callid_t iid, ipc_call_t *icall);
+static void serial_irq_handler(ipc_callid_t iid, ipc_call_t *icall);
+static serial_dev_t * serial_devno_to_dev(int devno);
+static serial_dev_t * serial_handle_to_dev(int handle);
+static void serial_enable_interrupt(serial_dev_t *dev);
 
 static isa_drv_ops_t serial_isa_ops = {
@@ -77 +143 @@
     if (serial_driver_phone < 0) {
                 printf(NAME ": Unable to register driver\n");
-                return false;
-        }
+                return 0;
+        }
+        
+        // register irq handler
+        printf(NAME ": Registering interrup notification callback function.\n");
+        async_set_interrupt_received(serial_irq_handler);
            
         // register this driver by generic isa bus driver       
@@ -92 +162 @@
 static uint8_t serial_read_8(ioport8_t *port) 
 {
-        while (!serial_received(port)) 
-                ;
-
-        uint8_t c = pio_read_8(port);
-        return c;
+        return pio_read_8(port);
 }
 
@@ -120 +186 @@
         pio_write_8(port + 3, 0x07);    // 8 bits, no parity, two stop bits
         pio_write_8(port + 2, 0xC7);    // Enable FIFO, clear them, with 14-byte threshold
-        pio_write_8(port + 4, 0x0B);    // RTS/DSR set (Request to Send and Data Terminal Ready lines enabled), Aux Output2 set 
+        pio_write_8(port + 4, 0x0B);    // RTS/DSR set (Request to Send and Data Terminal Ready lines enabled), 
+                                                                        // Aux Output2 set - needed for interrupts
+         
+}
+
+static void serial_enable_interrupt(serial_dev_t *dev)
+{
+        futex_down(&(dev->futex));
+        // TODO do not call pic directly, do it more generally
+        pic_enable_interrupt(dev->irq);
+        pio_write_8(dev->port + 1 , 0x01);   // Interrupt when data received
+        pio_write_8(dev->port + 4, 0x0B);
+        futex_up(&(dev->futex));
 }
 
@@ -137 +215 @@
         dev->parent = parent;
         dev->phys_addr = dev->parent->ops->absolutize(serial_phys_addresses[idx % serial_phys_addr_cnt]);
+        dev->irq = serial_irqs[idx % serial_irq_cnt];
         snprintf(dev->name, MAX_NAME_LEN, "com%d", idx + 1);
-        dev->client_connected = false;  
+        dev->devno = -1;
+        dev->client_connected = false;
+        futex_initialize(&(dev->futex), 1);
 }
 
@@ -145 +226 @@
         assert(dev != NULL);
         
-        printf(NAME " driver: probing %s \n", dev->name);
         return (dev->port = (ioport8_t *)serial_probe_port(dev->phys_addr)) != NULL;    
 }
@@ -160 +240 @@
         
         int i;
-        for (i = 0; i < serial_phys_addr_cnt; i++) {            
+        for (i = 0; i < serial_phys_addr_cnt; i++) {                    
                 serial_init_dev(dev, parent, serial_idx);
+                printf(NAME ": probing %s. \n", dev->name);
                 if (serial_probe_dev(dev)) {
                         printf(NAME " driver: initializing %s.\n", dev->name);
                         serial_init_port(dev->port);
                         if (EOK != serial_device_register(serial_driver_phone, dev->name, &(dev->handle))) {
-                                printf(NAME ": Unable to register device %s\n", dev->name);
-                        }       
-                        list_append(&(dev->link), &serial_devices_list);
-                        dev = serial_alloc_dev();
+                                printf(NAME ": unable to register device %s\n", dev->name);
+                        } else {
+                                dev->devno = device_assign_devno();
+                                
+                                // 3rd argument called method is equal devno,this enables us to identify the device 
+                                // which caused the interrupt in the irq notification callback function
+                                printf(NAME ": registering irq = %d for %s.\n", dev->irq, dev->name);
+                                ipc_register_irq(dev->irq, dev->devno, dev->devno, &serial_pseudocode);  
+                                list_append(&(dev->link), &serial_devices_list);
+                                printf(NAME ": enabling irq = %d for %s.\n", dev->irq, dev->name);
+                                serial_enable_interrupt(dev);
+                                dev = serial_alloc_dev();
+                        }
                 } else {
                         printf(NAME " driver: %s is not present \n", dev->name);
@@ -210 +300 @@
 {
         int c = IPC_GET_ARG1(*request);
+        futex_down(&(dev->futex));
         serial_write_8(dev->port, (uint8_t)c);  
+        futex_up(&(dev->futex));
         ipc_answer_0(rid, EOK);
 }
@@ -216 +308 @@
 static void serial_getchar(serial_dev_t *dev, ipc_callid_t rid)
 {
-        uint8_t c = serial_read_8(dev->port);   
+        uint8_t c;
+        printf(NAME ": trying to read from serial port %s\n", dev->name);
+        while (true) {  // TODO: fix it - the queue of requests to read ?
+                futex_down(&(dev->futex));
+                if (!buf_is_empty(&(dev->input_buffer))) {
+                        c = buf_pop_front(&(dev->input_buffer));
+                        futex_up(&(dev->futex));
+                        break;
+                }
+                //printf(NAME "no data ready, trying to read again after some while.\n", dev->name);
+                futex_up(&(dev->futex));
+                async_usleep(10000);
+        }
+        printf(NAME ": serial_getchar: sending characer %c read from %s to client.\n", c, dev->name);
         ipc_answer_1(rid, EOK, c);              
 }
 
-static serial_dev_t * serial_handle_to_dev(int handle) {
-        
+static serial_dev_t * serial_handle_to_dev(int handle) 
+{       
         futex_down(&serial_futex);      
         
@@ -230 +335 @@
                 dev = list_get_instance(item, serial_dev_t, link);
                 if (dev->handle == handle) {
+                        futex_up(&serial_futex);
+                        return dev;
+                }
+                item = item->next;
+        }
+        
+        futex_up(&serial_futex);
+        return NULL;
+}
+
+static serial_dev_t * serial_devno_to_dev(int devno)
+{               
+        futex_down(&serial_futex);      
+        
+        link_t *item = serial_devices_list.next;
+        serial_dev_t *dev = NULL; 
+        
+        while (item != &serial_devices_list) {
+                dev = list_get_instance(item, serial_dev_t, link);
+                if (dev->devno == devno) {
                         futex_up(&serial_futex);
                         return dev;
@@ -262 +387 @@
                 return;
         }
-        
+                
+        buf_clear(&(dev->input_buffer));  // synchronization with interrupt service routine ?
         dev->client_connected = true;
         ipc_answer_0(iid, EOK);
@@ -310 +436 @@
         while (phone < 0) {
                 usleep(10000);
-                phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
-                    DEVMAP_DRIVER, 0);
+                phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
         }
         
@@ -336 +461 @@
         aid_t req;
         ipc_call_t answer;
+        
+        if (handle != NULL) {
+                *handle = -1;
+        }
 
         req = async_send_2(driver_phone, DEVMAP_DEVICE_REGISTER, 0, 0, &answer);
@@ -347 +476 @@
 
         async_wait_for(req, &retval);
-
-        if (handle != NULL)
-                *handle = -1;
         
         if (EOK == retval) {
@@ -358 +484 @@
         return retval;
 }
+
+static void serial_read_from_device(serial_dev_t *dev)
+{       
+        bool cont = true;
+        
+        while (cont) {  
+                futex_down(&(dev->futex));
+                if (cont = serial_received(dev->port)) {
+                        uint8_t val = serial_read_8(dev->port);
+                        printf(NAME ": character %c read from %s.\n", val, dev->name);
+                        if (dev->client_connected) {
+                                if (!buf_push_back(&(dev->input_buffer), val)) {
+                                        printf(NAME ": buffer overflow on %s.\n", dev->name);
+                                } else {
+                                        printf(NAME ": the character %c saved to the buffer of %s.\n", val, dev->name);
+                                }
+                        } else {
+                                printf(NAME ": no client is connected to %s, discarding the character which was read.\n", dev->name);
+                        }
+                }
+                futex_up(&(dev->futex));
+                usleep(10000);
+        }       
+}
+
+// TODO - this is the only irq handling function registered by this task.
+// (A task can register only one such function.)
+// If more drivers within the task needed to handle interrupts, 
+// there will have to be one generic handler redistributing
+// irq notification messages among them. 
+// Or the change of ansync framework will be needed.
+static void serial_irq_handler(ipc_callid_t iid, ipc_call_t *icall)
+{
+        printf(NAME ": irq handler\n");
+        int devno = IPC_GET_METHOD(*icall);
+        serial_dev_t *dev = serial_devno_to_dev(devno);
+        serial_read_from_device(dev);   
+}
+