Index: kernel/arch/sparc64/src/drivers/niagara.c =================================================================== --- kernel/arch/sparc64/src/drivers/niagara.c (revision adfdbd51f9cd406c1bbdfba5c7e33ab7300f0398) +++ kernel/arch/sparc64/src/drivers/niagara.c (revision b511c2003b4475be254644e2e4cc4462936e14b7) @@ -32,5 +32,5 @@ /** * @file - * @brief Niagara input/output driver based on hypervisor calls. + * @brief Niagara input/output driver based on hypervisor calls. */ @@ -52,13 +52,13 @@ #include -/* polling interval in miliseconds */ +/* Polling interval in miliseconds */ #define POLL_INTERVAL 10000 -/* device instance */ +/* Device instance */ static niagara_instance_t *instance = NULL; -static void niagara_putchar(outdev_t *, const wchar_t, bool); - -/** character device operations */ +static void niagara_putchar(outdev_t *, const wchar_t); + +/** Character device operations */ static outdev_operations_t niagara_ops = { .write = niagara_putchar, @@ -66,103 +66,115 @@ }; -/* +/** * The driver uses hypercalls to print characters to the console. Since the * hypercall cannot be performed from the userspace, we do this: - * The kernel "little brother" driver (which will be present no matter what the - * DDI architecture is - as we need the kernel part for the kconsole) + * + * The kernel "little brother" driver (which will be present no matter what + * the DDI architecture is -- as we need the kernel part for the kconsole) * defines a shared buffer. Kernel walks through the buffer (in the same thread * which is used for polling the keyboard) and prints any pending characters - * to the console (using hypercalls). The userspace fb server maps this shared - * buffer to its address space and output operation it does is performed using - * the mapped buffer. The shared buffer definition follows. - */ -#define OUTPUT_BUFFER_SIZE ((PAGE_SIZE) - 2 * 8) + * to the console (using hypercalls). + * + * The userspace fb server maps this shared buffer to its address space and + * output operation it does is performed using the mapped buffer. The shared + * buffer definition follows. + */ +#define OUTPUT_BUFFER_SIZE ((PAGE_SIZE) - 2 * 8) + static volatile struct { uint64_t read_ptr; uint64_t write_ptr; char data[OUTPUT_BUFFER_SIZE]; -} - __attribute__ ((packed)) - __attribute__ ((aligned(PAGE_SIZE))) - output_buffer; +} __attribute__ ((packed)) __attribute__ ((aligned(PAGE_SIZE))) output_buffer; + +static parea_t outbuf_parea; /** * Analogous to the output_buffer, see the previous definition. */ -#define INPUT_BUFFER_SIZE ((PAGE_SIZE) - 2 * 8) +#define INPUT_BUFFER_SIZE ((PAGE_SIZE) - 2 * 8) + static volatile struct { uint64_t write_ptr; uint64_t read_ptr; char data[INPUT_BUFFER_SIZE]; -} - __attribute__ ((packed)) - __attribute__ ((aligned(PAGE_SIZE))) - input_buffer; - - -/** Writes a single character to the standard output. */ +} __attribute__ ((packed)) __attribute__ ((aligned(PAGE_SIZE))) input_buffer; + +static parea_t inbuf_parea; + +/** Write a single character to the standard output. */ static inline void do_putchar(const char c) { - /* repeat until the buffer is non-full */ - while (__hypercall_fast1(CONS_PUTCHAR, c) == HV_EWOULDBLOCK) - ; -} - -/** Writes a single character to the standard output. */ -static void niagara_putchar(outdev_t *dev, const wchar_t ch, bool silent) -{ - if (silent) - return; - - do_putchar(ch); - if (ch == '\n') - do_putchar('\r'); -} - -/** - * Function regularly called by the keyboard polling thread. Asks the - * hypervisor whether there is any unread character. If so, it picks it up - * and sends it to the upper layers of HelenOS. - * - * Apart from that, it also checks whether the userspace output driver has - * pushed any characters to the output buffer. If so, it prints them. - */ -static void niagara_poll(niagara_instance_t *instance) -{ - /* print any pending characters from the shared buffer to the console */ + /* Repeat until the buffer is non-full */ + while (__hypercall_fast1(CONS_PUTCHAR, c) == HV_EWOULDBLOCK); +} + +/** Write a single character to the standard output. */ +static void niagara_putchar(outdev_t *dev, const wchar_t ch) +{ + if ((!outbuf_parea.mapped) || (console_override)) { + do_putchar(ch); + if (ch == '\n') + do_putchar('\r'); + } +} + +/** Poll keyboard and print pending characters. + * + * Ask the hypervisor whether there is any unread character. If so, + * pick it up and send it to the indev layer. + * + * Check whether the userspace output driver has pushed any + * characters to the output buffer and eventually print them. + * + */ +static void niagara_poll(void) +{ + /* + * Print any pending characters from the + * shared buffer to the console. + */ + while (output_buffer.read_ptr != output_buffer.write_ptr) { do_putchar(output_buffer.data[output_buffer.read_ptr]); output_buffer.read_ptr = - ((output_buffer.read_ptr) + 1) % OUTPUT_BUFFER_SIZE; - } - + ((output_buffer.read_ptr) + 1) % OUTPUT_BUFFER_SIZE; + } + + /* + * Read character from keyboard. + */ + uint64_t c; - - /* read character from keyboard, send it to upper layers of HelenOS */ if (__hypercall_fast_ret1(0, 0, 0, 0, 0, CONS_GETCHAR, &c) == HV_EOK) { - if (!silent) { - /* kconsole active, send the character to kernel */ + if ((!inbuf_parea.mapped) || (console_override)) { + /* + * Kernel console is active, send + * the character to kernel. + */ indev_push_character(instance->srlnin, c); } else { - /* kconsole inactive, send the character to uspace driver */ + /* + * Kernel console is inactive, send + * the character to uspace driver. + */ input_buffer.data[input_buffer.write_ptr] = (char) c; input_buffer.write_ptr = - ((input_buffer.write_ptr) + 1) % INPUT_BUFFER_SIZE; + ((input_buffer.write_ptr) + 1) % INPUT_BUFFER_SIZE; } } } -/** - * Polling thread function. - */ -static void kniagarapoll(void *instance) { +/** Polling thread function. + * + */ +static void kniagarapoll(void *arg) { while (true) { - niagara_poll(instance); + niagara_poll(); thread_usleep(POLL_INTERVAL); } } -/** - * Initializes the input/output subsystem so that the Niagara standard - * input/output is used. +/** Initialize the input/output subsystem + * */ static void niagara_init(void) @@ -172,57 +184,54 @@ instance = malloc(sizeof(niagara_instance_t), FRAME_ATOMIC); - - if (instance) { - instance->thread = thread_create(kniagarapoll, instance, TASK, 0, - "kniagarapoll", true); - - if (!instance->thread) { - free(instance); - instance = NULL; - return; - } - } - + instance->thread = thread_create(kniagarapoll, NULL, TASK, 0, + "kniagarapoll", true); + + if (!instance->thread) { + free(instance); + instance = NULL; + return; + } + instance->srlnin = NULL; - + output_buffer.read_ptr = 0; output_buffer.write_ptr = 0; input_buffer.write_ptr = 0; input_buffer.read_ptr = 0; - + /* * Set sysinfos and pareas so that the userspace counterpart of the * niagara fb and kbd driver can communicate with kernel using shared * buffers. - */ - + */ + sysinfo_set_item_val("fb.kind", NULL, 5); - + sysinfo_set_item_val("niagara.outbuf.address", NULL, - KA2PA(&output_buffer)); + KA2PA(&output_buffer)); sysinfo_set_item_val("niagara.outbuf.size", NULL, - PAGE_SIZE); + PAGE_SIZE); sysinfo_set_item_val("niagara.outbuf.datasize", NULL, - OUTPUT_BUFFER_SIZE); - + OUTPUT_BUFFER_SIZE); + sysinfo_set_item_val("niagara.inbuf.address", NULL, - KA2PA(&input_buffer)); + KA2PA(&input_buffer)); sysinfo_set_item_val("niagara.inbuf.size", NULL, - PAGE_SIZE); + PAGE_SIZE); sysinfo_set_item_val("niagara.inbuf.datasize", NULL, - INPUT_BUFFER_SIZE); - - static parea_t outbuf_parea; + INPUT_BUFFER_SIZE); + outbuf_parea.pbase = (uintptr_t) (KA2PA(&output_buffer)); outbuf_parea.frames = 1; outbuf_parea.unpriv = false; + outbuf_parea.mapped = false; ddi_parea_register(&outbuf_parea); - - static parea_t inbuf_parea; + inbuf_parea.pbase = (uintptr_t) (KA2PA(&input_buffer)); inbuf_parea.frames = 1; inbuf_parea.unpriv = false; + inbuf_parea.mapped = false; ddi_parea_register(&inbuf_parea); - + outdev_t *niagara_dev = malloc(sizeof(outdev_t), FRAME_ATOMIC); outdev_initialize("niagara_dev", niagara_dev, &niagara_ops); @@ -230,11 +239,11 @@ } -/** - * A public function which initializes input from the Niagara console. +/** Initialize input from the Niagara console. + * */ niagara_instance_t *niagarain_init(void) { niagara_init(); - + if (instance) { srln_instance_t *srln_instance = srln_init(); @@ -242,10 +251,10 @@ indev_t *sink = stdin_wire(); indev_t *srln = srln_wire(srln_instance, sink); - - // wire std. input to niagara + instance->srlnin = srln; thread_ready(instance->thread); } } + return instance; } Index: kernel/arch/sparc64/src/drivers/sgcn.c =================================================================== --- kernel/arch/sparc64/src/drivers/sgcn.c (revision adfdbd51f9cd406c1bbdfba5c7e33ab7300f0398) +++ kernel/arch/sparc64/src/drivers/sgcn.c (revision b511c2003b4475be254644e2e4cc4462936e14b7) @@ -102,5 +102,5 @@ #define SGCN_BUFFER_HEADER (SGCN_BUFFER(sgcn_buffer_header_t, 0)) -static void sgcn_putchar(outdev_t *, const wchar_t, bool); +static void sgcn_putchar(outdev_t *, const wchar_t); static outdev_operations_t sgcndev_ops = { @@ -111,16 +111,5 @@ static sgcn_instance_t *instance = NULL; -/** - * Set some sysinfo values (SRAM address and SRAM size). - */ -static void register_sram(uintptr_t sram_begin_physical) -{ - sysinfo_set_item_val("sram.area.size", NULL, MAPPED_AREA_SIZE); - sysinfo_set_item_val("sram.address.physical", NULL, - sram_begin_physical); -} - -/** - * Initializes the starting address of SRAM. +/** Initialize the starting address of SRAM. * * The SRAM starts 0x900000 + C bytes behind the SBBC start in the @@ -129,4 +118,5 @@ * be set to the virtual address which maps to the SRAM physical * address. + * */ static void init_sram_begin(void) @@ -149,11 +139,20 @@ instance->sram_begin = hw_map(sram_begin_physical, MAPPED_AREA_SIZE); - register_sram(sram_begin_physical); -} - -/** - * 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. + link_initialize(&instance->parea.link); + instance->parea.pbase = sram_begin_physical; + instance->parea.frames = SIZE2FRAMES(MAPPED_AREA_SIZE); + instance->parea.unpriv = false; + instance->parea.mapped = false; + ddi_parea_register(&instance->parea); + + sysinfo_set_item_val("sram.area.size", NULL, MAPPED_AREA_SIZE); + sysinfo_set_item_val("sram.address.physical", NULL, + sram_begin_physical); +} + +/** Get unread characters from the input queue. + * + * Check for unread characters in the input queue. + * */ static void sgcn_poll(sgcn_instance_t *instance) @@ -163,10 +162,10 @@ uint32_t size = end - begin; - if (silent) + if ((instance->parea.mapped) && (!console_override)) return; spinlock_lock(&instance->input_lock); - /* we need pointers to volatile variables */ + /* We need pointers to volatile variables */ volatile char *buf_ptr = (volatile char *) SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr); @@ -186,26 +185,24 @@ } -/** - * Polling thread function. +/** Polling thread function. + * */ static void ksgcnpoll(void *instance) { while (true) { - if (!silent) - sgcn_poll(instance); - + sgcn_poll(instance); thread_usleep(POLL_INTERVAL); } } -/** - * Initializes the starting address of the SGCN buffer. +/** Initialize 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. + * console buffer -- this one will be used as the SGCN buffer. * * This function also writes the offset of the SGCN buffer within SRAM * under the sram.buffer.offset sysinfo key. + * */ static void sgcn_init(void) @@ -248,8 +245,10 @@ } -/** - * Writes a single character to the SGCN (circular) output buffer - * and updates the output write pointer so that SGCN gets to know +/** Write a single character to the SGCN output buffer + * + * Write a single character to the SGCN (circular) output buffer + * and update the output write pointer so that SGCN gets to know * that the character has been written. + * */ static void sgcn_do_putchar(const char c) @@ -286,11 +285,13 @@ } -/** - * SGCN output operation. Prints a single character to the SGCN. Newline +/** SGCN output operation + * + * Print a single character to the SGCN. Newline * character is converted to CRLF. - */ -static void sgcn_putchar(outdev_t *dev, const wchar_t ch, bool silent) -{ - if (!silent) { + * + */ +static void sgcn_putchar(outdev_t *dev, const wchar_t ch) +{ + if ((!instance->parea.mapped) || (console_override)) { spinlock_lock(&instance->output_lock); @@ -306,6 +307,6 @@ } -/** - * A public function which initializes input from the Serengeti console. +/** Initialize input from the Serengeti console. + * */ sgcn_instance_t *sgcnin_init(void) @@ -326,6 +327,6 @@ } -/** - * A public function which initializes output to the Serengeti console. +/** Initialize output to the Serengeti console. + * */ outdev_t *sgcnout_init(void)