WebSVN – HelenOS – Diff – /branches/dynload/kernel/arch/ia64/src/ski/ski.c


/*
 * Copyright (C) 2005 Jakub Jermar
 * 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.
 */
 
#include <arch/ski/ski.h>
#include <console/console.h>
#include <console/chardev.h>
 
static chardev_t ski_console;
static bool kb_disable;
 
static void ski_putchar(chardev_t *d, const char ch);
static __s32 ski_getchar(void);
 
/** Display character on debug console
 *
 * Use SSC (Simulator System Call) to
 * display character on debug console.
 *
 * @param d Character device.
 * @param ch Character to be printed.
 */
void ski_putchar(chardev_t *d, const char ch)
{
    __asm__ volatile (
        "mov r15=%0\n"
        "mov r32=%1\n"      /* r32 is in0 */
        "break 0x80000\n"   /* modifies r8 */
        :
        : "i" (SKI_PUTCHAR), "r" (ch)
        : "r15", "in0", "r8"
    );
   
    if (ch == '\n')
        ski_putchar(d, '\r');
}
 
/** Ask debug console if a key was pressed.
 *
 * Use SSC (Simulator System Call) to
 * get character from debug console.
 *
 * This call is non-blocking.
 *
 * @return ASCII code of pressed key or 0 if no key pressed.
 */
__s32 ski_getchar(void)
{
    __u64 ch;
   
    __asm__ volatile (
        "mov r15=%1\n"
        "break 0x80000;;\n" /* modifies r8 */
        "mov %0=r8;;\n"    
 
        : "=r" (ch)
        : "i" (SKI_GETCHAR)
        : "r15",  "r8"
    );
 
    return (__s32) ch;
}
 
/**
    This is blocking wrap function of ski_getchar
    It active waits ... for using with non-stable kernel
*/
static char ski_getchar_blocking(chardev_t *d)
{
    volatile int ch;
    while(!(ch=ski_getchar()));
    if(ch == '\r') ch = '\n';
    return (char) ch;
}
 
 
/** Ask keyboard if a key was pressed. */
void poll_keyboard(void)
{
    char ch;
 
    if (kb_disable)
        return;
 
    ch = ski_getchar();
    if(ch == '\r')
        ch = '\n';
    if (ch)
        chardev_push_character(&ski_console, ch);
}
 
/* Called from getc(). */
static void ski_kb_enable(chardev_t *d)
{
    kb_disable = false;
}
 
/* Called from getc(). */
static void ski_kb_disable(chardev_t *d)
{
    kb_disable = true; 
}
 
 
static chardev_operations_t ski_ops = {
    .resume = ski_kb_enable,
    .suspend = ski_kb_disable,
    .write = ski_putchar,
    .read = ski_getchar_blocking
};
 
 
/** Initialize debug console
 *
 * Issue SSC (Simulator System Call) to
 * to open debug console.
 */
void ski_init_console(void)
{
    __asm__ volatile (
        "mov r15=%0\n"
        "break 0x80000\n"
        :
        : "i" (SKI_INIT_CONSOLE)
        : "r15", "r8"
    );
 
    chardev_initialize("ski_console", &ski_console, &ski_ops);
    stdin = &ski_console;
    stdout = &ski_console;
}
 

Rev 586	Rev 892
1	/*	1	/*
2	* Copyright (C) 2005 Jakub Jermar	2	* Copyright (C) 2005 Jakub Jermar
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	#include <arch/ski/ski.h>	29	#include <arch/ski/ski.h>
30	#include <console/console.h>	30	#include <console/console.h>
31	#include <console/chardev.h>	31	#include <console/chardev.h>
32		32
33	static chardev_t ski_console;	33	static chardev_t ski_console;
34	static bool kb_disable;	34	static bool kb_disable;
35		35
36	static void ski_putchar(chardev_t *d, const char ch);	36	static void ski_putchar(chardev_t *d, const char ch);
37	static __s32 ski_getchar(void);	37	static __s32 ski_getchar(void);
38		38
39	/** Display character on debug console	39	/** Display character on debug console
40	*	40	*
41	* Use SSC (Simulator System Call) to	41	* Use SSC (Simulator System Call) to
42	* display character on debug console.	42	* display character on debug console.
43	*	43	*
44	* @param d Character device.	44	* @param d Character device.
45	* @param ch Character to be printed.	45	* @param ch Character to be printed.
46	*/	46	*/
47	void ski_putchar(chardev_t *d, const char ch)	47	void ski_putchar(chardev_t *d, const char ch)
48	{	48	{
49	__asm__ (	49	__asm__ volatile (
50	"mov r15=%0\n"	50	"mov r15=%0\n"
51	"mov r32=%1\n" /* r32 is in0 */	51	"mov r32=%1\n" /* r32 is in0 */
52	"break 0x80000\n" /* modifies r8 */	52	"break 0x80000\n" /* modifies r8 */
53	:	53	:
54	: "i" (SKI_PUTCHAR), "r" (ch)	54	: "i" (SKI_PUTCHAR), "r" (ch)
55	: "r15", "in0", "r8"	55	: "r15", "in0", "r8"
56	);	56	);
57		57
58	if (ch == '\n')	58	if (ch == '\n')
59	ski_putchar(d, '\r');	59	ski_putchar(d, '\r');
60	}	60	}
61		61
62	/** Ask debug console if a key was pressed.	62	/** Ask debug console if a key was pressed.
63	*	63	*
64	* Use SSC (Simulator System Call) to	64	* Use SSC (Simulator System Call) to
65	* get character from debug console.	65	* get character from debug console.
66	*	66	*
67	* This call is non-blocking.	67	* This call is non-blocking.
68	*	68	*
69	* @return ASCII code of pressed key or 0 if no key pressed.	69	* @return ASCII code of pressed key or 0 if no key pressed.
70	*/	70	*/
71	__s32 ski_getchar(void)	71	__s32 ski_getchar(void)
72	{	72	{
73	__u64 ch;	73	__u64 ch;
74		74
75	__asm__ (	75	__asm__ volatile (
76	"mov r15=%1\n"	76	"mov r15=%1\n"
77	"break 0x80000;;\n" /* modifies r8 */	77	"break 0x80000;;\n" /* modifies r8 */
78	"mov %0=r8;;\n"	78	"mov %0=r8;;\n"
79		79
80	: "=r" (ch)	80	: "=r" (ch)
81	: "i" (SKI_GETCHAR)	81	: "i" (SKI_GETCHAR)
82	: "r15", "r8"	82	: "r15", "r8"
83	);	83	);
84		84
85	return (__s32) ch;	85	return (__s32) ch;
86	}	86	}
87		87
-		88	/**
-		89	This is blocking wrap function of ski_getchar
-		90	It active waits ... for using with non-stable kernel
-		91	*/
-		92	static char ski_getchar_blocking(chardev_t *d)
-		93	{
-		94	volatile int ch;
-		95	while(!(ch=ski_getchar()));
-		96	if(ch == '\r') ch = '\n';
-		97	return (char) ch;
-		98	}
-		99
-		100
88	/** Ask keyboard if a key was pressed. */	101	/** Ask keyboard if a key was pressed. */
89	void poll_keyboard(void)	102	void poll_keyboard(void)
90	{	103	{
91	char ch;	104	char ch;
92		105
93	if (kb_disable)	106	if (kb_disable)
94	return;	107	return;
95		108
96	ch = ski_getchar();	109	ch = ski_getchar();
97	if(ch == '\r')	110	if(ch == '\r')
98	ch = '\n';	111	ch = '\n';
99	if (ch)	112	if (ch)
100	chardev_push_character(&ski_console, ch);	113	chardev_push_character(&ski_console, ch);
101	}	114	}
102		115
103	/* Called from getc(). */	116	/* Called from getc(). */
104	static void ski_kb_enable(chardev_t *d)	117	static void ski_kb_enable(chardev_t *d)
105	{	118	{
106	kb_disable = false;	119	kb_disable = false;
107	}	120	}
108		121
109	/* Called from getc(). */	122	/* Called from getc(). */
110	static void ski_kb_disable(chardev_t *d)	123	static void ski_kb_disable(chardev_t *d)
111	{	124	{
112	kb_disable = true;	125	kb_disable = true;
113	}	126	}
114		127
115		128
116	static chardev_operations_t ski_ops = {	129	static chardev_operations_t ski_ops = {
117	.resume = ski_kb_enable,	130	.resume = ski_kb_enable,
118	.suspend = ski_kb_disable,	131	.suspend = ski_kb_disable,
119	.write = ski_putchar	132	.write = ski_putchar,
-		133	.read = ski_getchar_blocking
120	};	134	};
121		135
122		136
123	/** Initialize debug console	137	/** Initialize debug console
124	*	138	*
125	* Issue SSC (Simulator System Call) to	139	* Issue SSC (Simulator System Call) to
126	* to open debug console.	140	* to open debug console.
127	*/	141	*/
128	void ski_init_console(void)	142	void ski_init_console(void)
129	{	143	{
130	__asm__ (	144	__asm__ volatile (
131	"mov r15=%0\n"	145	"mov r15=%0\n"
132	"break 0x80000\n"	146	"break 0x80000\n"
133	:	147	:
134	: "i" (SKI_INIT_CONSOLE)	148	: "i" (SKI_INIT_CONSOLE)
135	: "r15", "r8"	149	: "r15", "r8"
136	);	150	);
137		151
138	chardev_initialize("ski_console", &ski_console, &ski_ops);	152	chardev_initialize("ski_console", &ski_console, &ski_ops);
139	stdin = &ski_console;	153	stdin = &ski_console;
140	stdout = &ski_console;	154	stdout = &ski_console;
141	}	155	}
142		156

Subversion Repositories HelenOS

(root)/branches/dynload/kernel/arch/ia64/src/ski/ski.c @ 4343 – Rev 586 → 892