Loading...
1/*
2 * ARAnyM console driver
3 *
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file COPYING in the main directory of this archive
6 * for more details.
7 */
8
9#include <linux/module.h>
10#include <linux/init.h>
11#include <linux/console.h>
12#include <linux/tty.h>
13#include <linux/tty_driver.h>
14#include <linux/tty_flip.h>
15#include <linux/slab.h>
16#include <linux/err.h>
17#include <linux/uaccess.h>
18#include <linux/io.h>
19
20#include <asm/natfeat.h>
21
22static int stderr_id;
23static struct tty_port nfcon_tty_port;
24static struct tty_driver *nfcon_tty_driver;
25
26static void nfputs(const char *str, unsigned int count)
27{
28 char buf[68];
29 unsigned long phys = virt_to_phys(buf);
30
31 buf[64] = 0;
32 while (count > 64) {
33 memcpy(buf, str, 64);
34 nf_call(stderr_id, phys);
35 str += 64;
36 count -= 64;
37 }
38 memcpy(buf, str, count);
39 buf[count] = 0;
40 nf_call(stderr_id, phys);
41}
42
43static void nfcon_write(struct console *con, const char *str,
44 unsigned int count)
45{
46 nfputs(str, count);
47}
48
49static struct tty_driver *nfcon_device(struct console *con, int *index)
50{
51 *index = 0;
52 return console_is_registered(con) ? nfcon_tty_driver : NULL;
53}
54
55static struct console nf_console = {
56 .name = "nfcon",
57 .write = nfcon_write,
58 .device = nfcon_device,
59 .flags = CON_PRINTBUFFER,
60 .index = -1,
61};
62
63
64static int nfcon_tty_open(struct tty_struct *tty, struct file *filp)
65{
66 return 0;
67}
68
69static void nfcon_tty_close(struct tty_struct *tty, struct file *filp)
70{
71}
72
73static int nfcon_tty_write(struct tty_struct *tty, const unsigned char *buf,
74 int count)
75{
76 nfputs(buf, count);
77 return count;
78}
79
80static int nfcon_tty_put_char(struct tty_struct *tty, unsigned char ch)
81{
82 char temp[2] = { ch, 0 };
83
84 nf_call(stderr_id, virt_to_phys(temp));
85 return 1;
86}
87
88static unsigned int nfcon_tty_write_room(struct tty_struct *tty)
89{
90 return 64;
91}
92
93static const struct tty_operations nfcon_tty_ops = {
94 .open = nfcon_tty_open,
95 .close = nfcon_tty_close,
96 .write = nfcon_tty_write,
97 .put_char = nfcon_tty_put_char,
98 .write_room = nfcon_tty_write_room,
99};
100
101#ifndef MODULE
102
103static int __init nf_debug_setup(char *arg)
104{
105 if (strcmp(arg, "nfcon"))
106 return 0;
107
108 stderr_id = nf_get_id("NF_STDERR");
109 if (stderr_id) {
110 /*
111 * The console will be enabled when debug=nfcon is specified
112 * as a kernel parameter. Since this is a non-standard way
113 * of enabling consoles, it must be explicitly enabled.
114 */
115 nf_console.flags |= CON_ENABLED;
116 register_console(&nf_console);
117 }
118
119 return 0;
120}
121
122early_param("debug", nf_debug_setup);
123
124#endif /* !MODULE */
125
126static int __init nfcon_init(void)
127{
128 struct tty_driver *driver;
129 int res;
130
131 stderr_id = nf_get_id("NF_STDERR");
132 if (!stderr_id)
133 return -ENODEV;
134
135 driver = tty_alloc_driver(1, TTY_DRIVER_REAL_RAW);
136 if (IS_ERR(driver))
137 return PTR_ERR(driver);
138
139 tty_port_init(&nfcon_tty_port);
140
141 driver->driver_name = "nfcon";
142 driver->name = "nfcon";
143 driver->type = TTY_DRIVER_TYPE_SYSTEM;
144 driver->subtype = SYSTEM_TYPE_TTY;
145 driver->init_termios = tty_std_termios;
146
147 tty_set_operations(driver, &nfcon_tty_ops);
148 tty_port_link_device(&nfcon_tty_port, driver, 0);
149 res = tty_register_driver(driver);
150 if (res) {
151 pr_err("failed to register nfcon tty driver\n");
152 tty_driver_kref_put(driver);
153 tty_port_destroy(&nfcon_tty_port);
154 return res;
155 }
156
157 nfcon_tty_driver = driver;
158
159 if (!console_is_registered(&nf_console))
160 register_console(&nf_console);
161
162 return 0;
163}
164
165static void __exit nfcon_exit(void)
166{
167 unregister_console(&nf_console);
168 tty_unregister_driver(nfcon_tty_driver);
169 tty_driver_kref_put(nfcon_tty_driver);
170 tty_port_destroy(&nfcon_tty_port);
171}
172
173module_init(nfcon_init);
174module_exit(nfcon_exit);
175
176MODULE_LICENSE("GPL");
1/*
2 * ARAnyM console driver
3 *
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file COPYING in the main directory of this archive
6 * for more details.
7 */
8
9#include <linux/module.h>
10#include <linux/init.h>
11#include <linux/console.h>
12#include <linux/tty.h>
13#include <linux/tty_driver.h>
14#include <linux/tty_flip.h>
15#include <linux/slab.h>
16#include <linux/err.h>
17#include <linux/uaccess.h>
18
19#include <asm/natfeat.h>
20
21static int stderr_id;
22static struct tty_driver *nfcon_tty_driver;
23
24static void nfputs(const char *str, unsigned int count)
25{
26 char buf[68];
27
28 buf[64] = 0;
29 while (count > 64) {
30 memcpy(buf, str, 64);
31 nf_call(stderr_id, buf);
32 str += 64;
33 count -= 64;
34 }
35 memcpy(buf, str, count);
36 buf[count] = 0;
37 nf_call(stderr_id, buf);
38}
39
40static void nfcon_write(struct console *con, const char *str,
41 unsigned int count)
42{
43 nfputs(str, count);
44}
45
46static struct tty_driver *nfcon_device(struct console *con, int *index)
47{
48 *index = 0;
49 return (con->flags & CON_ENABLED) ? nfcon_tty_driver : NULL;
50}
51
52static struct console nf_console = {
53 .name = "nfcon",
54 .write = nfcon_write,
55 .device = nfcon_device,
56 .flags = CON_PRINTBUFFER,
57 .index = -1,
58};
59
60
61static int nfcon_tty_open(struct tty_struct *tty, struct file *filp)
62{
63 return 0;
64}
65
66static void nfcon_tty_close(struct tty_struct *tty, struct file *filp)
67{
68}
69
70static int nfcon_tty_write(struct tty_struct *tty, const unsigned char *buf,
71 int count)
72{
73 nfputs(buf, count);
74 return count;
75}
76
77static int nfcon_tty_put_char(struct tty_struct *tty, unsigned char ch)
78{
79 char temp[2] = { ch, 0 };
80
81 nf_call(stderr_id, temp);
82 return 1;
83}
84
85static int nfcon_tty_write_room(struct tty_struct *tty)
86{
87 return 64;
88}
89
90static const struct tty_operations nfcon_tty_ops = {
91 .open = nfcon_tty_open,
92 .close = nfcon_tty_close,
93 .write = nfcon_tty_write,
94 .put_char = nfcon_tty_put_char,
95 .write_room = nfcon_tty_write_room,
96};
97
98#ifndef MODULE
99
100static int __init nf_debug_setup(char *arg)
101{
102 if (strcmp(arg, "nfcon"))
103 return 0;
104
105 stderr_id = nf_get_id("NF_STDERR");
106 if (stderr_id) {
107 nf_console.flags |= CON_ENABLED;
108 register_console(&nf_console);
109 }
110
111 return 0;
112}
113
114early_param("debug", nf_debug_setup);
115
116#endif /* !MODULE */
117
118static int __init nfcon_init(void)
119{
120 int res;
121
122 stderr_id = nf_get_id("NF_STDERR");
123 if (!stderr_id)
124 return -ENODEV;
125
126 nfcon_tty_driver = alloc_tty_driver(1);
127 if (!nfcon_tty_driver)
128 return -ENOMEM;
129
130 nfcon_tty_driver->owner = THIS_MODULE;
131 nfcon_tty_driver->driver_name = "nfcon";
132 nfcon_tty_driver->name = "nfcon";
133 nfcon_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM;
134 nfcon_tty_driver->subtype = SYSTEM_TYPE_TTY;
135 nfcon_tty_driver->init_termios = tty_std_termios;
136 nfcon_tty_driver->flags = TTY_DRIVER_REAL_RAW;
137
138 tty_set_operations(nfcon_tty_driver, &nfcon_tty_ops);
139 res = tty_register_driver(nfcon_tty_driver);
140 if (res) {
141 pr_err("failed to register nfcon tty driver\n");
142 put_tty_driver(nfcon_tty_driver);
143 return res;
144 }
145
146 if (!(nf_console.flags & CON_ENABLED))
147 register_console(&nf_console);
148
149 return 0;
150}
151
152static void __exit nfcon_exit(void)
153{
154 unregister_console(&nf_console);
155 tty_unregister_driver(nfcon_tty_driver);
156 put_tty_driver(nfcon_tty_driver);
157}
158
159module_init(nfcon_init);
160module_exit(nfcon_exit);
161
162MODULE_LICENSE("GPL");