WebSVN – HelenOS – Diff – /branches/sparc/kernel/arch/sparc64/src/drivers/sgcn.c

 /*
  * Copyright (c) 2008 Pavel Rimsky
  * 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 sparc64
  * @{
  */
 /**
  * @file
  * @brief   SGCN driver.
  */
 #include <arch/drivers/sgcn.h>
 #include <genarch/ofw/ofw_tree.h>
 #include <debug.h>
 #include <func.h>
 #include <print.h>
 #include <mm/page.h>
 #include <console/chardev.h>
 #include <console/console.h>
 #include <synch/spinlock.h>
 /*
  * Physical address at which the SBBC starts. This value has been obtained
  * by inspecting (using Simics) memory accesses made by OBP. It is valid
  * for the Simics-simulated Serengeti machine. The author of this code is
  * not sure whether this value is valid generally.
  */
 #define SBBC_START      0x63000000000
 /* offset of SRAM within the SBBC memory */
 #define SBBC_SRAM_OFFSET    0x900000
 /* magic string contained at the beginning of SRAM */
 #define SRAM_TOC_MAGIC      "TOCSRAM"
 /*
  * Key into the SRAM table of contents which identifies the entry
  * describing the OBP console buffer. It is worth mentioning
  * that the OBP console buffer is not the only console buffer
  * which can be used. It is, however, used because when the kernel
  * is running, the OBP buffer is not used by OBP any more but OBP
  * has already made neccessary arangements so that the output will
  * be read from the OBP buffer and input will go to the OBP buffer.
  * Therefore HelenOS needs to make no such arrangements any more.
  */
 #define CONSOLE_KEY     "OBPCONS"
 /* magic string contained at the beginning of the console buffer */
 #define SGCN_BUFFER_MAGIC   "CON"
 /*
  * Returns a pointer to the object of a given type which is placed at the given
  * offset from the SRAM beginning.
  */
 #define SRAM(type, offset)  ((type *) (sram_begin + (offset)))
 /* Returns a pointer to the SRAM table of contents. */
 #define SRAM_TOC        (SRAM(iosram_toc_t, 0))
 /*
  * Returns a pointer to the object of a given type which is placed at the given
  * offset from the console buffer beginning.
  */
 #define SGCN_BUFFER(type, offset) \
                 ((type *) (sgcn_buffer_begin + (offset)))
 /* Returns a pointer to the console buffer header. */
 #define SGCN_BUFFER_HEADER  (SGCN_BUFFER(sgcn_buffer_header_t, 0))
 /* starting address of SRAM, will be set by the init_sram_begin function */
 static uintptr_t sram_begin;
 /*
  * starting address of the SGCN buffer, will be set by the
  * init_sgcn_buffer_begin function
  */
 static uintptr_t sgcn_buffer_begin;
 /*
  * Ensures that writing to the buffer and consequent update of the write pointer
  * are together one atomic operation.
  */
 SPINLOCK_INITIALIZE(sgcn_output_lock);
+/*
+ * Ensures that reading from the buffer and consequent update of the read
+ * pointer are together one atomic operation.
+ */
+SPINLOCK_INITIALIZE(sgcn_input_lock);
-static void sgcn_putchar(struct chardev * cd, const char c);
+/* functions referenced from definitions of I/O operations structures */
+static void sgcn_noop(chardev_t *);
+static void sgcn_putchar(chardev_t *, const char);
+static char sgcn_key_read(chardev_t *);
-/** character device operations */
+/** character device output operations */
-static chardev_operations_t sgcn_ops = {
+static chardev_operations_t sgcn_output_ops = {
-    .suspend = NULL,
+    .suspend = sgcn_noop,
-    .resume = NULL,
+    .resume = sgcn_noop,
     .write = sgcn_putchar,
     .read = NULL
 };
+/** character device input operations */
+static chardev_operations_t sgcn_input_ops = {
+    .suspend = sgcn_noop,
+    .resume = sgcn_noop,
+    .read = sgcn_key_read
+};
-/** SGCN character device */
+/** SGCN character output device */
 chardev_t sgcn_stdout;
+/** SGCN character input device */
+chardev_t sgcn_input;
 /**
  * Initializes the starting address of SRAM.
+ *
  * The SRAM starts 0x900000 + C bytes behind the SBBC start in the
  * physical memory, where C is the value read from the "iosram-toc"
  * property of the "/chosen" OBP node. The sram_begin variable will
  * be set to the virtual address which maps to the SRAM physical
  * address.
  */
 static void init_sram_begin(void)
+{
     ofw_tree_node_t *chosen;
     ofw_tree_property_t *iosram_toc;
     chosen = ofw_tree_lookup("/chosen");
     if (!chosen)
         panic("Can't find /chosen.\n");
     iosram_toc = ofw_tree_getprop(chosen, "iosram-toc");
     if (!iosram_toc)
         panic("Can't find property \"iosram-toc\".\n");
     if (!iosram_toc->value)
         panic("Can't find SRAM TOC.\n");
     sram_begin = hw_map(
         SBBC_START + SBBC_SRAM_OFFSET
         + *((uint32_t *) iosram_toc->value),
 * 1024);
+}
 /**
  * Initializes the starting address of the SGCN buffer.
+ *
  * The offset of the SGCN buffer within SRAM is obtained from the
  * SRAM table of contents. The table of contents contains
  * information about several buffers, among which there is an OBP
  * console buffer - this one will be used as the SGCN buffer.
  */
 static void sgcn_buffer_begin_init(void)
+{
     init_sram_begin();
     ASSERT(strcmp(SRAM_TOC->magic, SRAM_TOC_MAGIC) == 0);
     /* lookup TOC entry with the correct key */
     uint32_t i;
     for (i = 0; i < MAX_TOC_ENTRIES; i++) {
         if (strcmp(SRAM_TOC->keys[i].key, CONSOLE_KEY) == 0)
             break;
+    }
     ASSERT(i < MAX_TOC_ENTRIES);
     sgcn_buffer_begin = sram_begin + SRAM_TOC->keys[i].offset;
+}
 /**
+ * Default suspend/resume operation for the input device.
+ */
+static void sgcn_noop(chardev_t *d)
+{
+}
+/**
  * Writes a single character to the SGCN (circular) output buffer
  * and updates the output write pointer so that SGCN gets to know
  * that the character has been written.
  */
 static void sgcn_do_putchar(const char c)
+{
     uint32_t begin = SGCN_BUFFER_HEADER->out_begin;
     uint32_t end = SGCN_BUFFER_HEADER->out_end;
     uint32_t size = end - begin;
     /* we need pointers to volatile variables */
     volatile char *buf_ptr = (volatile char *)
         SGCN_BUFFER(char, SGCN_BUFFER_HEADER->out_wrptr);
     volatile uint32_t *out_wrptr_ptr = &(SGCN_BUFFER_HEADER->out_wrptr);
     volatile uint32_t *out_rdptr_ptr = &(SGCN_BUFFER_HEADER->out_rdptr);
     /*
      * Write the character and increment the write pointer modulo the
      * output buffer size. Note that if we are to rewrite a character
      * which has not been read by the SGCN controller yet (i.e. the output
      * buffer is full), we need to wait until the controller reads some more
      * characters. We wait actively, which means that all threads waiting
      * for the lock are blocked. However, this situation is
      *   1) rare - the output buffer is big, so filling the whole
      *             output buffer is improbable
      *   2) short-lasting - it will take the controller only a fraction
      *             of millisecond to pick the unread characters up
      *   3) not serious - the blocked threads are those that print something
      *             to user console, which is not a time-critical operation
      */
     uint32_t new_wrptr = (((*out_wrptr_ptr) - begin + 1) % size) + begin;
     while (*out_rdptr_ptr == new_wrptr)
+        ;
     *buf_ptr = c;
     *out_wrptr_ptr = new_wrptr;
+}
 /**
  * SGCN output operation. Prints a single character to the SGCN. If the line
  * feed character is written ('\n'), the carriage return character ('\r') is
  * written straight away.
  */
 static void sgcn_putchar(struct chardev * cd, const char c)
+{
     spinlock_lock(&sgcn_output_lock);
     sgcn_do_putchar(c);
     if (c == '\n') {
         sgcn_do_putchar('\r');
+    }
     spinlock_unlock(&sgcn_output_lock);
+}
 /**
+ * Called when actively reading the character. Not implemented yet.
+ */
+static char sgcn_key_read(chardev_t *d)
+{
+    return (char) 0;
+}
+/**
+ * Function regularly called by the keyboard polling thread. Finds out whether
+ * there are some unread characters in the input queue. If so, it picks them up
+ * and sends them to the upper layers of HelenOS.
+ */
+void sgcn_poll(void)
+{
+    spinlock_lock(&sgcn_input_lock);
+    char c;
+    uint32_t begin = SGCN_BUFFER_HEADER->in_begin;
+    uint32_t end = SGCN_BUFFER_HEADER->in_end;
+    uint32_t size = end - begin;
+    /* we need pointers to volatile variables */
+    volatile char *buf_ptr = (volatile char *)
+        SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
+    volatile uint32_t *in_wrptr_ptr = &(SGCN_BUFFER_HEADER->in_wrptr);
+    volatile uint32_t *in_rdptr_ptr = &(SGCN_BUFFER_HEADER->in_rdptr);
+    while (*in_rdptr_ptr != *in_wrptr_ptr) {
+        c = *buf_ptr;
+        *in_rdptr_ptr = (((*in_rdptr_ptr) - begin + 1) % size) + begin;
+        buf_ptr = (volatile char *)
+            SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
+        chardev_push_character(&sgcn_input, c);
+        if (c == '\r')
+            chardev_push_character(&sgcn_input, '\n');
+    }
+    spinlock_unlock(&sgcn_input_lock);
+}
+/**
  * A public function which initializes I/O from/to Serengeti console
  * and sets it as a default input/output.
  */
 void sgcn_init(void)
+{
     sgcn_buffer_begin_init();
-    chardev_initialize("sgcn_output", &sgcn_stdout, &sgcn_ops);
+    chardev_initialize("sgcn_output", &sgcn_stdout, &sgcn_output_ops);
     stdout = &sgcn_stdout;
-    printf("SGCN buffer begin = %d, in read ptr = %" PRIu32 ".", sgcn_buffer_begin, SGCN_BUFFER_HEADER->in_wrptr);
+    chardev_initialize("sgcn_input", &sgcn_input, &sgcn_input_ops);
+    stdin = &sgcn_input;
+}
 /** @}
  */

Subversion Repositories HelenOS

(root)/branches/sparc/kernel/arch/sparc64/src/drivers/sgcn.c – Rev 3502 → 3514