WebSVN – HelenOS – Diff – /trunk/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.h>
#include <arch/drivers/sgcn.h>
#include <arch/drivers/kbd.h>
#include <genarch/ofw/ofw_tree.h>
#include <debug.h>
#include <string.h>
#include <print.h>
#include <mm/page.h>
#include <proc/thread.h>
#include <console/chardev.h>
#include <console/console.h>
#include <sysinfo/sysinfo.h>
#include <synch/spinlock.h>
 
#define POLL_INTERVAL       10000
 
/*
 * 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
 
/* size (in bytes) of the physical memory area which will be mapped */
#define MAPPED_AREA_SIZE    (128 * 1024)
 
/* 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 necessary arrangements 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))
 
/** defined in drivers/kbd.c */
extern kbd_type_t kbd_type;
 
/** 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;
 
/* true iff the kernel driver should ignore pressed keys */
static bool kbd_disabled;
 
/*
 * Ensures that writing to the buffer and consequent update of the write pointer
 * are together one atomic operation.
 */
SPINLOCK_INITIALIZE(sgcn_output_lock);
 
/*
 * Prevents the input buffer read/write pointers from getting to inconsistent
 * state.
 */
SPINLOCK_INITIALIZE(sgcn_input_lock);
 
 
/* functions referenced from definitions of I/O operations structures */
 
static void sgcn_putchar(outdev_t *, const char, bool);
 
 
/** SGCN output device operations */
static outdev_operations_t sgcnout_ops = {
 
 
 
    .write = sgcn_putchar
};
 
/** SGCN input device operations */
static indev_operations_t sgcnin_ops = {
    .poll = NULL
};
 
static indev_t sgcnin;      /**< SGCN input device. */
static outdev_t sgcnout;    /**< SGCN output device. */
 
/**
 * 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.
 *
 * 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;
    uintptr_t sram_begin_physical;
 
    chosen = ofw_tree_lookup("/chosen");
    if (!chosen)
        panic("Cannot find '/chosen'.");
 
    iosram_toc = ofw_tree_getprop(chosen, "iosram-toc");
    if (!iosram_toc)
        panic("Cannot find property 'iosram-toc'.");
    if (!iosram_toc->value)
        panic("Cannot find SRAM TOC.");
 
    sram_begin_physical = SBBC_START + SBBC_SRAM_OFFSET
        + *((uint32_t *) iosram_toc->value);
    sram_begin = hw_map(sram_begin_physical, MAPPED_AREA_SIZE);
   
    register_sram(sram_begin_physical);
}
 
/**
 * 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.
 *
 * This function also writes the offset of the SGCN buffer within SRAM
 * under the sram.buffer.offset sysinfo key.
 */
static void sgcn_buffer_begin_init(void)
{
    static bool initialized;
   
    if (initialized)
        return;
 
    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;
   
    sysinfo_set_item_val("sram.buffer.offset", NULL,
        SRAM_TOC->keys[i].offset);
   
 
 
 
 
    initialized = true;
 
}
 
/**
 * 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(outdev_t *od, const char c, bool silent)
{
    if (!silent) {
        spinlock_lock(&sgcn_output_lock);
       
        sgcn_do_putchar(c);
        if (c == '\n')
            sgcn_do_putchar('\r');
       
        spinlock_unlock(&sgcn_output_lock);
    }
}
 
/**
 
 
 
 
 
 
 
 
 * Grabs the input for kernel.
 */
void sgcn_grab(void)
{
    kbd_disabled = true;
}
 
/**
 * Releases the input so that userspace can use it.
 */
void sgcn_release(void)
{
    kbd_disabled = true;
}
 
/**
 * 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.
 */
static void sgcn_poll()
{
    uint32_t begin = SGCN_BUFFER_HEADER->in_begin;
    uint32_t end = SGCN_BUFFER_HEADER->in_end;
    uint32_t size = end - begin;
 
    if (kbd_disabled)
        return;
 
    spinlock_lock(&sgcn_input_lock);
   
    /* 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) {
       
        buf_ptr = (volatile char *)
            SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
        char c = *buf_ptr;
        *in_rdptr_ptr = (((*in_rdptr_ptr) - begin + 1) % size) + begin;
           
 
        indev_push_character(&sgcnin, c);  
    }  
 
    spinlock_unlock(&sgcn_input_lock);
}
 
/**
 * Polling thread function.
 */
static void kkbdpoll(void *arg) {
    while (1) {
        if (!silent) {
            sgcn_poll();
        }
        thread_usleep(POLL_INTERVAL);
    }
}
 
/**
 * A public function which initializes input from the Serengeti console.
 
 */
indev_t *sgcnin_init(void)
{
    sgcn_buffer_begin_init();
 
    kbd_type = KBD_SGCN;
 
    sysinfo_set_item_val("kbd", NULL, true);
    sysinfo_set_item_val("kbd.type", NULL, KBD_SGCN);
 
 
    thread_t *t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
    if (!t)
        panic("Cannot create kkbdpoll.");
    thread_ready(t);
   
    indev_initialize("sgcnin", &sgcnin, &sgcnin_ops);
 
    return &sgcnin;
}
 
/**
 * A public function which initializes output to the Serengeti console.
 */
void sgcnout_init(void)
{
    sgcn_buffer_begin_init();
 
    sysinfo_set_item_val("fb.kind", NULL, 4);
 
    outdev_initialize("sgcnout", &sgcnout, &sgcnout_ops);  
    stdout = &sgcnout;
}
 
/** @}
 */
 

Rev 4071	Rev 4111
1	/*	1	/*
2	* Copyright (c) 2008 Pavel Rimsky	2	* Copyright (c) 2008 Pavel Rimsky
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup sparc64	29	/** @addtogroup sparc64
30	* @{	30	* @{
31	*/	31	*/
32	/**	32	/**
33	* @file	33	* @file
34	* @brief SGCN driver.	34	* @brief SGCN driver.
35	*/	35	*/
36		36
37	#include <arch.h>	37	#include <arch.h>
38	#include <arch/drivers/sgcn.h>	38	#include <arch/drivers/sgcn.h>
39	#include <arch/drivers/kbd.h>	39	#include <arch/drivers/kbd.h>
40	#include <genarch/ofw/ofw_tree.h>	40	#include <genarch/ofw/ofw_tree.h>
41	#include <debug.h>	41	#include <debug.h>
42	#include <string.h>	42	#include <string.h>
43	#include <print.h>	43	#include <print.h>
44	#include <mm/page.h>	44	#include <mm/page.h>
45	#include <proc/thread.h>	45	#include <proc/thread.h>
46	#include <console/chardev.h>	46	#include <console/chardev.h>
47	#include <console/console.h>	47	#include <console/console.h>
48	#include <sysinfo/sysinfo.h>	48	#include <sysinfo/sysinfo.h>
49	#include <synch/spinlock.h>	49	#include <synch/spinlock.h>
50		50
51	#define POLL_INTERVAL 10000	51	#define POLL_INTERVAL 10000
52		52
53	/*	53	/*
54	* Physical address at which the SBBC starts. This value has been obtained	54	* Physical address at which the SBBC starts. This value has been obtained
55	* by inspecting (using Simics) memory accesses made by OBP. It is valid	55	* by inspecting (using Simics) memory accesses made by OBP. It is valid
56	* for the Simics-simulated Serengeti machine. The author of this code is	56	* for the Simics-simulated Serengeti machine. The author of this code is
57	* not sure whether this value is valid generally.	57	* not sure whether this value is valid generally.
58	*/	58	*/
59	#define SBBC_START 0x63000000000	59	#define SBBC_START 0x63000000000
60		60
61	/* offset of SRAM within the SBBC memory */	61	/* offset of SRAM within the SBBC memory */
62	#define SBBC_SRAM_OFFSET 0x900000	62	#define SBBC_SRAM_OFFSET 0x900000
63		63
64	/* size (in bytes) of the physical memory area which will be mapped */	64	/* size (in bytes) of the physical memory area which will be mapped */
65	#define MAPPED_AREA_SIZE (128 * 1024)	65	#define MAPPED_AREA_SIZE (128 * 1024)
66		66
67	/* magic string contained at the beginning of SRAM */	67	/* magic string contained at the beginning of SRAM */
68	#define SRAM_TOC_MAGIC "TOCSRAM"	68	#define SRAM_TOC_MAGIC "TOCSRAM"
69		69
70	/*	70	/*
71	* Key into the SRAM table of contents which identifies the entry	71	* Key into the SRAM table of contents which identifies the entry
72	* describing the OBP console buffer. It is worth mentioning	72	* describing the OBP console buffer. It is worth mentioning
73	* that the OBP console buffer is not the only console buffer	73	* that the OBP console buffer is not the only console buffer
74	* which can be used. It is, however, used because when the kernel	74	* which can be used. It is, however, used because when the kernel
75	* is running, the OBP buffer is not used by OBP any more but OBP	75	* is running, the OBP buffer is not used by OBP any more but OBP
76	* has already made necessary arrangements so that the output will	76	* has already made necessary arrangements so that the output will
77	* be read from the OBP buffer and input will go to the OBP buffer.	77	* be read from the OBP buffer and input will go to the OBP buffer.
78	* Therefore HelenOS needs to make no such arrangements any more.	78	* Therefore HelenOS needs to make no such arrangements any more.
79	*/	79	*/
80	#define CONSOLE_KEY "OBPCONS"	80	#define CONSOLE_KEY "OBPCONS"
81		81
82	/* magic string contained at the beginning of the console buffer */	82	/* magic string contained at the beginning of the console buffer */
83	#define SGCN_BUFFER_MAGIC "CON"	83	#define SGCN_BUFFER_MAGIC "CON"
84		84
85	/*	85	/*
86	* Returns a pointer to the object of a given type which is placed at the given	86	* Returns a pointer to the object of a given type which is placed at the given
87	* offset from the SRAM beginning.	87	* offset from the SRAM beginning.
88	*/	88	*/
89	#define SRAM(type, offset) ((type *) (sram_begin + (offset)))	89	#define SRAM(type, offset) ((type *) (sram_begin + (offset)))
90		90
91	/* Returns a pointer to the SRAM table of contents. */	91	/* Returns a pointer to the SRAM table of contents. */
92	#define SRAM_TOC (SRAM(iosram_toc_t, 0))	92	#define SRAM_TOC (SRAM(iosram_toc_t, 0))
93		93
94	/*	94	/*
95	* Returns a pointer to the object of a given type which is placed at the given	95	* Returns a pointer to the object of a given type which is placed at the given
96	* offset from the console buffer beginning.	96	* offset from the console buffer beginning.
97	*/	97	*/
98	#define SGCN_BUFFER(type, offset) \	98	#define SGCN_BUFFER(type, offset) \
99	((type *) (sgcn_buffer_begin + (offset)))	99	((type *) (sgcn_buffer_begin + (offset)))
100		100
101	/** Returns a pointer to the console buffer header. */	101	/** Returns a pointer to the console buffer header. */
102	#define SGCN_BUFFER_HEADER (SGCN_BUFFER(sgcn_buffer_header_t, 0))	102	#define SGCN_BUFFER_HEADER (SGCN_BUFFER(sgcn_buffer_header_t, 0))
103		103
104	/** defined in drivers/kbd.c */	104	/** defined in drivers/kbd.c */
105	extern kbd_type_t kbd_type;	105	extern kbd_type_t kbd_type;
106		106
107	/** starting address of SRAM, will be set by the init_sram_begin function */	107	/** starting address of SRAM, will be set by the init_sram_begin function */
108	static uintptr_t sram_begin;	108	static uintptr_t sram_begin;
109		109
110	/**	110	/**
111	* starting address of the SGCN buffer, will be set by the	111	* starting address of the SGCN buffer, will be set by the
112	* init_sgcn_buffer_begin function	112	* init_sgcn_buffer_begin function
113	*/	113	*/
114	static uintptr_t sgcn_buffer_begin;	114	static uintptr_t sgcn_buffer_begin;
115		115
116	/* true iff the kernel driver should ignore pressed keys */	116	/* true iff the kernel driver should ignore pressed keys */
117	static bool kbd_disabled;	117	static bool kbd_disabled;
118		118
119	/*	119	/*
120	* Ensures that writing to the buffer and consequent update of the write pointer	120	* Ensures that writing to the buffer and consequent update of the write pointer
121	* are together one atomic operation.	121	* are together one atomic operation.
122	*/	122	*/
123	SPINLOCK_INITIALIZE(sgcn_output_lock);	123	SPINLOCK_INITIALIZE(sgcn_output_lock);
124		124
125	/*	125	/*
126	* Prevents the input buffer read/write pointers from getting to inconsistent	126	* Prevents the input buffer read/write pointers from getting to inconsistent
127	* state.	127	* state.
128	*/	128	*/
129	SPINLOCK_INITIALIZE(sgcn_input_lock);	129	SPINLOCK_INITIALIZE(sgcn_input_lock);
130		130
131		131
132	/* functions referenced from definitions of I/O operations structures */	132	/* functions referenced from definitions of I/O operations structures */
133	static void sgcn_noop(chardev_t *);	-
134	static void sgcn_putchar(chardev_t *, const char, bool);	133	static void sgcn_putchar(outdev_t *, const char, bool);
135	static char sgcn_key_read(chardev_t *);	-
136		134
137	/** character device operations */	135	/** SGCN output device operations */
138	static chardev_operations_t sgcn_ops = {	136	static outdev_operations_t sgcnout_ops = {
139	.suspend = sgcn_noop,	-
140	.resume = sgcn_noop,	-
141	.read = sgcn_key_read,	-
142	.write = sgcn_putchar	137	.write = sgcn_putchar
143	};	138	};
144		139
145	/** SGCN character device */	140	/** SGCN input device operations */
146	chardev_t sgcn_io;	141	static indev_operations_t sgcnin_ops = {
-		142	.poll = NULL
-		143	};
147		144
148	/** Address of the chardev, which is connected to SGCN. */	145	static indev_t sgcnin; /*< SGCN input device. /
149	static chardev_t *sgcnout;	146	static outdev_t sgcnout; /*< SGCN output device. /
150		147
151	/**	148	/**
152	* Set some sysinfo values (SRAM address and SRAM size).	149	* Set some sysinfo values (SRAM address and SRAM size).
153	*/	150	*/
154	static void register_sram(uintptr_t sram_begin_physical)	151	static void register_sram(uintptr_t sram_begin_physical)
155	{	152	{
156	sysinfo_set_item_val("sram.area.size", NULL, MAPPED_AREA_SIZE);	153	sysinfo_set_item_val("sram.area.size", NULL, MAPPED_AREA_SIZE);
157	sysinfo_set_item_val("sram.address.physical", NULL,	154	sysinfo_set_item_val("sram.address.physical", NULL,
158	sram_begin_physical);	155	sram_begin_physical);
159	}	156	}
160		157
161	/**	158	/**
162	* Initializes the starting address of SRAM.	159	* Initializes the starting address of SRAM.
163	*	160	*
164	* The SRAM starts 0x900000 + C bytes behind the SBBC start in the	161	* The SRAM starts 0x900000 + C bytes behind the SBBC start in the
165	* physical memory, where C is the value read from the "iosram-toc"	162	* physical memory, where C is the value read from the "iosram-toc"
166	* property of the "/chosen" OBP node. The sram_begin variable will	163	* property of the "/chosen" OBP node. The sram_begin variable will
167	* be set to the virtual address which maps to the SRAM physical	164	* be set to the virtual address which maps to the SRAM physical
168	* address.	165	* address.
169	*/	166	*/
170	static void init_sram_begin(void)	167	static void init_sram_begin(void)
171	{	168	{
172	ofw_tree_node_t *chosen;	169	ofw_tree_node_t *chosen;
173	ofw_tree_property_t *iosram_toc;	170	ofw_tree_property_t *iosram_toc;
174	uintptr_t sram_begin_physical;	171	uintptr_t sram_begin_physical;
175		172
176	chosen = ofw_tree_lookup("/chosen");	173	chosen = ofw_tree_lookup("/chosen");
177	if (!chosen)	174	if (!chosen)
178	panic("Cannot find '/chosen'.");	175	panic("Cannot find '/chosen'.");
179		176
180	iosram_toc = ofw_tree_getprop(chosen, "iosram-toc");	177	iosram_toc = ofw_tree_getprop(chosen, "iosram-toc");
181	if (!iosram_toc)	178	if (!iosram_toc)
182	panic("Cannot find property 'iosram-toc'.");	179	panic("Cannot find property 'iosram-toc'.");
183	if (!iosram_toc->value)	180	if (!iosram_toc->value)
184	panic("Cannot find SRAM TOC.");	181	panic("Cannot find SRAM TOC.");
185		182
186	sram_begin_physical = SBBC_START + SBBC_SRAM_OFFSET	183	sram_begin_physical = SBBC_START + SBBC_SRAM_OFFSET
187	+ ((uint32_t ) iosram_toc->value);	184	+ ((uint32_t ) iosram_toc->value);
188	sram_begin = hw_map(sram_begin_physical, MAPPED_AREA_SIZE);	185	sram_begin = hw_map(sram_begin_physical, MAPPED_AREA_SIZE);
189		186
190	register_sram(sram_begin_physical);	187	register_sram(sram_begin_physical);
191	}	188	}
192		189
193	/**	190	/**
194	* Initializes the starting address of the SGCN buffer.	191	* Initializes the starting address of the SGCN buffer.
195	*	192	*
196	* The offset of the SGCN buffer within SRAM is obtained from the	193	* The offset of the SGCN buffer within SRAM is obtained from the
197	* SRAM table of contents. The table of contents contains	194	* SRAM table of contents. The table of contents contains
198	* information about several buffers, among which there is an OBP	195	* information about several buffers, among which there is an OBP
199	* console buffer - this one will be used as the SGCN buffer.	196	* console buffer - this one will be used as the SGCN buffer.
200	*	197	*
201	* This function also writes the offset of the SGCN buffer within SRAM	198	* This function also writes the offset of the SGCN buffer within SRAM
202	* under the sram.buffer.offset sysinfo key.	199	* under the sram.buffer.offset sysinfo key.
203	*/	200	*/
204	static void sgcn_buffer_begin_init(void)	201	static void sgcn_buffer_begin_init(void)
205	{	202	{
-		203	static bool initialized;
-		204
-		205	if (initialized)
-		206	return;
-		207
206	init_sram_begin();	208	init_sram_begin();
207		209
208	ASSERT(strcmp(SRAM_TOC->magic, SRAM_TOC_MAGIC) == 0);	210	ASSERT(strcmp(SRAM_TOC->magic, SRAM_TOC_MAGIC) == 0);
209		211
210	/* lookup TOC entry with the correct key */	212	/* lookup TOC entry with the correct key */
211	uint32_t i;	213	uint32_t i;
212	for (i = 0; i < MAX_TOC_ENTRIES; i++) {	214	for (i = 0; i < MAX_TOC_ENTRIES; i++) {
213	if (strcmp(SRAM_TOC->keys[i].key, CONSOLE_KEY) == 0)	215	if (strcmp(SRAM_TOC->keys[i].key, CONSOLE_KEY) == 0)
214	break;	216	break;
215	}	217	}
216	ASSERT(i < MAX_TOC_ENTRIES);	218	ASSERT(i < MAX_TOC_ENTRIES);
217		219
218	sgcn_buffer_begin = sram_begin + SRAM_TOC->keys[i].offset;	220	sgcn_buffer_begin = sram_begin + SRAM_TOC->keys[i].offset;
219		221
220	sysinfo_set_item_val("sram.buffer.offset", NULL,	222	sysinfo_set_item_val("sram.buffer.offset", NULL,
221	SRAM_TOC->keys[i].offset);	223	SRAM_TOC->keys[i].offset);
222	}	224
223		-
224	/**	-
225	* Default suspend/resume operation for the input device.	-
226	*/	-
227	static void sgcn_noop(chardev_t *d)	225	initialized = true;
228	{	-
229	}	226	}
230		227
231	/**	228	/**
232	* Writes a single character to the SGCN (circular) output buffer	229	* Writes a single character to the SGCN (circular) output buffer
233	* and updates the output write pointer so that SGCN gets to know	230	* and updates the output write pointer so that SGCN gets to know
234	* that the character has been written.	231	* that the character has been written.
235	*/	232	*/
236	static void sgcn_do_putchar(const char c)	233	static void sgcn_do_putchar(const char c)
237	{	234	{
238	uint32_t begin = SGCN_BUFFER_HEADER->out_begin;	235	uint32_t begin = SGCN_BUFFER_HEADER->out_begin;
239	uint32_t end = SGCN_BUFFER_HEADER->out_end;	236	uint32_t end = SGCN_BUFFER_HEADER->out_end;
240	uint32_t size = end - begin;	237	uint32_t size = end - begin;
241		238
242	/* we need pointers to volatile variables */	239	/* we need pointers to volatile variables */
243	volatile char buf_ptr = (volatile char )	240	volatile char buf_ptr = (volatile char )
244	SGCN_BUFFER(char, SGCN_BUFFER_HEADER->out_wrptr);	241	SGCN_BUFFER(char, SGCN_BUFFER_HEADER->out_wrptr);
245	volatile uint32_t *out_wrptr_ptr = &(SGCN_BUFFER_HEADER->out_wrptr);	242	volatile uint32_t *out_wrptr_ptr = &(SGCN_BUFFER_HEADER->out_wrptr);
246	volatile uint32_t *out_rdptr_ptr = &(SGCN_BUFFER_HEADER->out_rdptr);	243	volatile uint32_t *out_rdptr_ptr = &(SGCN_BUFFER_HEADER->out_rdptr);
247		244
248	/*	245	/*
249	* Write the character and increment the write pointer modulo the	246	* Write the character and increment the write pointer modulo the
250	* output buffer size. Note that if we are to rewrite a character	247	* output buffer size. Note that if we are to rewrite a character
251	* which has not been read by the SGCN controller yet (i.e. the output	248	* which has not been read by the SGCN controller yet (i.e. the output
252	* buffer is full), we need to wait until the controller reads some more	249	* buffer is full), we need to wait until the controller reads some more
253	* characters. We wait actively, which means that all threads waiting	250	* characters. We wait actively, which means that all threads waiting
254	* for the lock are blocked. However, this situation is	251	* for the lock are blocked. However, this situation is
255	* 1) rare - the output buffer is big, so filling the whole	252	* 1) rare - the output buffer is big, so filling the whole
256	* output buffer is improbable	253	* output buffer is improbable
257	* 2) short-lasting - it will take the controller only a fraction	254	* 2) short-lasting - it will take the controller only a fraction
258	* of millisecond to pick the unread characters up	255	* of millisecond to pick the unread characters up
259	* 3) not serious - the blocked threads are those that print something	256	* 3) not serious - the blocked threads are those that print something
260	* to user console, which is not a time-critical operation	257	* to user console, which is not a time-critical operation
261	*/	258	*/
262	uint32_t new_wrptr = (((*out_wrptr_ptr) - begin + 1) % size) + begin;	259	uint32_t new_wrptr = (((*out_wrptr_ptr) - begin + 1) % size) + begin;
263	while (*out_rdptr_ptr == new_wrptr)	260	while (*out_rdptr_ptr == new_wrptr)
264	;	261	;
265	*buf_ptr = c;	262	*buf_ptr = c;
266	*out_wrptr_ptr = new_wrptr;	263	*out_wrptr_ptr = new_wrptr;
267	}	264	}
268		265
269	/**	266	/**
270	* SGCN output operation. Prints a single character to the SGCN. If the line	267	* SGCN output operation. Prints a single character to the SGCN. If the line
271	* feed character is written ('\n'), the carriage return character ('\r') is	268	* feed character is written ('\n'), the carriage return character ('\r') is
272	* written straight away.	269	* written straight away.
273	*/	270	*/
274	static void sgcn_putchar(struct chardev * cd, const char c, bool silent)	271	static void sgcn_putchar(outdev_t *od, const char c, bool silent)
275	{	272	{
276	if (!silent) {	273	if (!silent) {
277	spinlock_lock(&sgcn_output_lock);	274	spinlock_lock(&sgcn_output_lock);
278		275
279	sgcn_do_putchar(c);	276	sgcn_do_putchar(c);
280	if (c == '\n')	277	if (c == '\n')
281	sgcn_do_putchar('\r');	278	sgcn_do_putchar('\r');
282		279
283	spinlock_unlock(&sgcn_output_lock);	280	spinlock_unlock(&sgcn_output_lock);
284	}	281	}
285	}	282	}
286		283
287	/**	284	/**
288	* Called when actively reading the character. Not implemented yet.	-
289	*/	-
290	static char sgcn_key_read(chardev_t *d)	-
291	{	-
292	return (char) 0;	-
293	}	-
294		-
295	/**	-
296	* Grabs the input for kernel.	285	* Grabs the input for kernel.
297	*/	286	*/
298	void sgcn_grab(void)	287	void sgcn_grab(void)
299	{	288	{
300	kbd_disabled = true;	289	kbd_disabled = true;
301	}	290	}
302		291
303	/**	292	/**
304	* Releases the input so that userspace can use it.	293	* Releases the input so that userspace can use it.
305	*/	294	*/
306	void sgcn_release(void)	295	void sgcn_release(void)
307	{	296	{
308	kbd_disabled = true;	297	kbd_disabled = true;
309	}	298	}
310		299
311	/**	300	/**
312	* Function regularly called by the keyboard polling thread. Finds out whether	301	* Function regularly called by the keyboard polling thread. Finds out whether
313	* there are some unread characters in the input queue. If so, it picks them up	302	* there are some unread characters in the input queue. If so, it picks them up
314	* and sends them to the upper layers of HelenOS.	303	* and sends them to the upper layers of HelenOS.
315	*/	304	*/
316	static void sgcn_poll()	305	static void sgcn_poll()
317	{	306	{
318	uint32_t begin = SGCN_BUFFER_HEADER->in_begin;	307	uint32_t begin = SGCN_BUFFER_HEADER->in_begin;
319	uint32_t end = SGCN_BUFFER_HEADER->in_end;	308	uint32_t end = SGCN_BUFFER_HEADER->in_end;
320	uint32_t size = end - begin;	309	uint32_t size = end - begin;
321		310
322	if (kbd_disabled)	311	if (kbd_disabled)
323	return;	312	return;
324		313
325	spinlock_lock(&sgcn_input_lock);	314	spinlock_lock(&sgcn_input_lock);
326		315
327	/* we need pointers to volatile variables */	316	/* we need pointers to volatile variables */
328	volatile char buf_ptr = (volatile char )	317	volatile char buf_ptr = (volatile char )
329	SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);	318	SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
330	volatile uint32_t *in_wrptr_ptr = &(SGCN_BUFFER_HEADER->in_wrptr);	319	volatile uint32_t *in_wrptr_ptr = &(SGCN_BUFFER_HEADER->in_wrptr);
331	volatile uint32_t *in_rdptr_ptr = &(SGCN_BUFFER_HEADER->in_rdptr);	320	volatile uint32_t *in_rdptr_ptr = &(SGCN_BUFFER_HEADER->in_rdptr);
332		321
333	while (in_rdptr_ptr != in_wrptr_ptr) {	322	while (in_rdptr_ptr != in_wrptr_ptr) {
334		323
335	buf_ptr = (volatile char *)	324	buf_ptr = (volatile char *)
336	SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);	325	SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
337	char c = *buf_ptr;	326	char c = *buf_ptr;
338	in_rdptr_ptr = (((in_rdptr_ptr) - begin + 1) % size) + begin;	327	in_rdptr_ptr = (((in_rdptr_ptr) - begin + 1) % size) + begin;
339		328
340	if (sgcnout)	-
341	chardev_push_character(sgcnout, c);	329	indev_push_character(&sgcnin, c);
342	}	330	}
343		331
344	spinlock_unlock(&sgcn_input_lock);	332	spinlock_unlock(&sgcn_input_lock);
345	}	333	}
346		334
347	/**	335	/**
348	* Polling thread function.	336	* Polling thread function.
349	*/	337	*/
350	static void kkbdpoll(void *arg) {	338	static void kkbdpoll(void *arg) {
351	while (1) {	339	while (1) {
352	if (!silent) {	340	if (!silent) {
353	sgcn_poll();	341	sgcn_poll();
354	}	342	}
355	thread_usleep(POLL_INTERVAL);	343	thread_usleep(POLL_INTERVAL);
356	}	344	}
357	}	345	}
358		346
359	/**	347	/**
360	* A public function which initializes I/O from/to Serengeti console	348	* A public function which initializes input from the Serengeti console.
361	* and sets it as a default input/output.	-
362	*/	349	*/
363	void sgcn_init(chardev_t *devout)	350	indev_t *sgcnin_init(void)
364	{	351	{
365	sgcn_buffer_begin_init();	352	sgcn_buffer_begin_init();
366		353
367	kbd_type = KBD_SGCN;	354	kbd_type = KBD_SGCN;
368		355
369	sysinfo_set_item_val("kbd", NULL, true);	356	sysinfo_set_item_val("kbd", NULL, true);
370	sysinfo_set_item_val("kbd.type", NULL, KBD_SGCN);	357	sysinfo_set_item_val("kbd.type", NULL, KBD_SGCN);
371	sysinfo_set_item_val("fb.kind", NULL, 4);	-
372		358
373	thread_t *t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);	359	thread_t *t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
374	if (!t)	360	if (!t)
375	panic("Cannot create kkbdpoll.");	361	panic("Cannot create kkbdpoll.");
376	thread_ready(t);	362	thread_ready(t);
377		363
378	chardev_initialize("sgcn_io", &sgcn_io, &sgcn_ops);	364	indev_initialize("sgcnin", &sgcnin, &sgcnin_ops);
-		365
379	stdout = &sgcn_io;	366	return &sgcnin;
-		367	}
-		368
-		369	/**
-		370	* A public function which initializes output to the Serengeti console.
-		371	*/
-		372	void sgcnout_init(void)
-		373	{
-		374	sgcn_buffer_begin_init();
-		375
-		376	sysinfo_set_item_val("fb.kind", NULL, 4);
380		377
-		378	outdev_initialize("sgcnout", &sgcnout, &sgcnout_ops);
381	sgcnout = devout;	379	stdout = &sgcnout;
382	}	380	}
383		381
384	/** @}	382	/** @}
385	*/	383	*/
386		384

Subversion Repositories HelenOS

(root)/trunk/kernel/arch/sparc64/src/drivers/sgcn.c @ 4746 – Rev 4071 → 4111