1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/console.h>
17#include <linux/init.h>
18#include <linux/major.h>
19#include <linux/delay.h>
20#include <linux/tty.h>
21#include <asm/system.h>
22#include <arch/svinto.h>
23#include <asm/io.h>
24
25extern void reset_watchdog(void);
26
27struct dbg_port
28{
29 unsigned int index;
30 const volatile unsigned* read;
31 volatile char* write;
32 volatile unsigned* xoff;
33 volatile char* baud;
34 volatile char* tr_ctrl;
35 volatile char* rec_ctrl;
36 unsigned long irq;
37 unsigned int started;
38 unsigned long baudrate;
39 unsigned char parity;
40 unsigned int bits;
41};
42
43struct dbg_port ports[]=
44{
45 {
46 0,
47 R_SERIAL0_READ,
48 R_SERIAL0_TR_DATA,
49 R_SERIAL0_XOFF,
50 R_SERIAL0_BAUD,
51 R_SERIAL0_TR_CTRL,
52 R_SERIAL0_REC_CTRL,
53 IO_STATE(R_IRQ_MASK1_SET, ser0_data, set),
54 0,
55 115200,
56 'N',
57 8
58 },
59 {
60 1,
61 R_SERIAL1_READ,
62 R_SERIAL1_TR_DATA,
63 R_SERIAL1_XOFF,
64 R_SERIAL1_BAUD,
65 R_SERIAL1_TR_CTRL,
66 R_SERIAL1_REC_CTRL,
67 IO_STATE(R_IRQ_MASK1_SET, ser1_data, set),
68 0,
69 115200,
70 'N',
71 8
72 },
73 {
74 2,
75 R_SERIAL2_READ,
76 R_SERIAL2_TR_DATA,
77 R_SERIAL2_XOFF,
78 R_SERIAL2_BAUD,
79 R_SERIAL2_TR_CTRL,
80 R_SERIAL2_REC_CTRL,
81 IO_STATE(R_IRQ_MASK1_SET, ser2_data, set),
82 0,
83 115200,
84 'N',
85 8
86 },
87 {
88 3,
89 R_SERIAL3_READ,
90 R_SERIAL3_TR_DATA,
91 R_SERIAL3_XOFF,
92 R_SERIAL3_BAUD,
93 R_SERIAL3_TR_CTRL,
94 R_SERIAL3_REC_CTRL,
95 IO_STATE(R_IRQ_MASK1_SET, ser3_data, set),
96 0,
97 115200,
98 'N',
99 8
100 }
101};
102
103#ifdef CONFIG_ETRAX_SERIAL
104extern struct tty_driver *serial_driver;
105#endif
106
107struct dbg_port* port =
108#if defined(CONFIG_ETRAX_DEBUG_PORT0)
109 &ports[0];
110#elif defined(CONFIG_ETRAX_DEBUG_PORT1)
111 &ports[1];
112#elif defined(CONFIG_ETRAX_DEBUG_PORT2)
113 &ports[2];
114#elif defined(CONFIG_ETRAX_DEBUG_PORT3)
115 &ports[3];
116#else
117 NULL;
118#endif
119
120static struct dbg_port* kgdb_port =
121#if defined(CONFIG_ETRAX_KGDB_PORT0)
122 &ports[0];
123#elif defined(CONFIG_ETRAX_KGDB_PORT1)
124 &ports[1];
125#elif defined(CONFIG_ETRAX_KGDB_PORT2)
126 &ports[2];
127#elif defined(CONFIG_ETRAX_KGDB_PORT3)
128 &ports[3];
129#else
130 NULL;
131#endif
132
133static void
134start_port(struct dbg_port* p)
135{
136 unsigned long rec_ctrl = 0;
137 unsigned long tr_ctrl = 0;
138
139 if (!p)
140 return;
141
142 if (p->started)
143 return;
144 p->started = 1;
145
146 if (p->index == 0)
147 {
148 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma6);
149 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma6, unused);
150 }
151 else if (p->index == 1)
152 {
153 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma8);
154 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma8, usb);
155 }
156 else if (p->index == 2)
157 {
158 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma2);
159 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma2, par0);
160 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma3);
161 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma3, par0);
162 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, ser2, select);
163 }
164 else
165 {
166 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma4);
167 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma4, par1);
168 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma5);
169 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma5, par1);
170 genconfig_shadow |= IO_STATE(R_GEN_CONFIG, ser3, select);
171 }
172
173 *R_GEN_CONFIG = genconfig_shadow;
174
175 *p->xoff =
176 IO_STATE(R_SERIAL0_XOFF, tx_stop, enable) |
177 IO_STATE(R_SERIAL0_XOFF, auto_xoff, disable) |
178 IO_FIELD(R_SERIAL0_XOFF, xoff_char, 0);
179
180 switch (p->baudrate)
181 {
182 case 0:
183 case 115200:
184 *p->baud =
185 IO_STATE(R_SERIAL0_BAUD, tr_baud, c115k2Hz) |
186 IO_STATE(R_SERIAL0_BAUD, rec_baud, c115k2Hz);
187 break;
188 case 1200:
189 *p->baud =
190 IO_STATE(R_SERIAL0_BAUD, tr_baud, c1200Hz) |
191 IO_STATE(R_SERIAL0_BAUD, rec_baud, c1200Hz);
192 break;
193 case 2400:
194 *p->baud =
195 IO_STATE(R_SERIAL0_BAUD, tr_baud, c2400Hz) |
196 IO_STATE(R_SERIAL0_BAUD, rec_baud, c2400Hz);
197 break;
198 case 4800:
199 *p->baud =
200 IO_STATE(R_SERIAL0_BAUD, tr_baud, c4800Hz) |
201 IO_STATE(R_SERIAL0_BAUD, rec_baud, c4800Hz);
202 break;
203 case 9600:
204 *p->baud =
205 IO_STATE(R_SERIAL0_BAUD, tr_baud, c9600Hz) |
206 IO_STATE(R_SERIAL0_BAUD, rec_baud, c9600Hz);
207 break;
208 case 19200:
209 *p->baud =
210 IO_STATE(R_SERIAL0_BAUD, tr_baud, c19k2Hz) |
211 IO_STATE(R_SERIAL0_BAUD, rec_baud, c19k2Hz);
212 break;
213 case 38400:
214 *p->baud =
215 IO_STATE(R_SERIAL0_BAUD, tr_baud, c38k4Hz) |
216 IO_STATE(R_SERIAL0_BAUD, rec_baud, c38k4Hz);
217 break;
218 case 57600:
219 *p->baud =
220 IO_STATE(R_SERIAL0_BAUD, tr_baud, c57k6Hz) |
221 IO_STATE(R_SERIAL0_BAUD, rec_baud, c57k6Hz);
222 break;
223 default:
224 *p->baud =
225 IO_STATE(R_SERIAL0_BAUD, tr_baud, c115k2Hz) |
226 IO_STATE(R_SERIAL0_BAUD, rec_baud, c115k2Hz);
227 break;
228 }
229
230 if (p->parity == 'E') {
231 rec_ctrl =
232 IO_STATE(R_SERIAL0_REC_CTRL, rec_par, even) |
233 IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, enable);
234 tr_ctrl =
235 IO_STATE(R_SERIAL0_TR_CTRL, tr_par, even) |
236 IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, enable);
237 } else if (p->parity == 'O') {
238 rec_ctrl =
239 IO_STATE(R_SERIAL0_REC_CTRL, rec_par, odd) |
240 IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, enable);
241 tr_ctrl =
242 IO_STATE(R_SERIAL0_TR_CTRL, tr_par, odd) |
243 IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, enable);
244 } else {
245 rec_ctrl =
246 IO_STATE(R_SERIAL0_REC_CTRL, rec_par, even) |
247 IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, disable);
248 tr_ctrl =
249 IO_STATE(R_SERIAL0_TR_CTRL, tr_par, even) |
250 IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, disable);
251 }
252 if (p->bits == 7)
253 {
254 rec_ctrl |= IO_STATE(R_SERIAL0_REC_CTRL, rec_bitnr, rec_7bit);
255 tr_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, tr_bitnr, tr_7bit);
256 }
257 else
258 {
259 rec_ctrl |= IO_STATE(R_SERIAL0_REC_CTRL, rec_bitnr, rec_8bit);
260 tr_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, tr_bitnr, tr_8bit);
261 }
262
263 *p->rec_ctrl =
264 IO_STATE(R_SERIAL0_REC_CTRL, dma_err, stop) |
265 IO_STATE(R_SERIAL0_REC_CTRL, rec_enable, enable) |
266 IO_STATE(R_SERIAL0_REC_CTRL, rts_, active) |
267 IO_STATE(R_SERIAL0_REC_CTRL, sampling, middle) |
268 IO_STATE(R_SERIAL0_REC_CTRL, rec_stick_par, normal) |
269 rec_ctrl;
270
271 *p->tr_ctrl =
272 IO_FIELD(R_SERIAL0_TR_CTRL, txd, 0) |
273 IO_STATE(R_SERIAL0_TR_CTRL, tr_enable, enable) |
274 IO_STATE(R_SERIAL0_TR_CTRL, auto_cts, disabled) |
275 IO_STATE(R_SERIAL0_TR_CTRL, stop_bits, one_bit) |
276 IO_STATE(R_SERIAL0_TR_CTRL, tr_stick_par, normal) |
277 tr_ctrl;
278}
279
280static void
281console_write_direct(struct console *co, const char *buf, unsigned int len)
282{
283 int i;
284 unsigned long flags;
285
286 if (!port)
287 return;
288
289 local_irq_save(flags);
290
291
292 for (i = 0; i < len; i++) {
293
294 if (buf[i] == '\n') {
295 while (!(*port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
296 ;
297 *port->write = '\r';
298 }
299
300 while (!(*port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
301 ;
302 *port->write = buf[i];
303 }
304
305
306
307
308
309
310
311 reset_watchdog();
312
313 local_irq_restore(flags);
314}
315
316static void
317console_write(struct console *co, const char *buf, unsigned int len)
318{
319 if (!port)
320 return;
321
322#ifdef CONFIG_SVINTO_SIM
323
324 SIMCOUT(buf, len);
325 return;
326#endif
327
328 console_write_direct(co, buf, len);
329}
330
331
332
333void
334console_print_etrax(const char *buf)
335{
336 console_write(NULL, buf, strlen(buf));
337}
338
339
340
341int
342getDebugChar(void)
343{
344 unsigned long readval;
345
346 if (!kgdb_port)
347 return 0;
348
349 do {
350 readval = *kgdb_port->read;
351 } while (!(readval & IO_MASK(R_SERIAL0_READ, data_avail)));
352
353 return (readval & IO_MASK(R_SERIAL0_READ, data_in));
354}
355
356
357
358void
359putDebugChar(int val)
360{
361 if (!kgdb_port)
362 return;
363
364 while (!(*kgdb_port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
365 ;
366 *kgdb_port->write = val;
367}
368
369
370
371void
372enableDebugIRQ(void)
373{
374 if (!kgdb_port)
375 return;
376
377 *R_IRQ_MASK1_SET = kgdb_port->irq;
378
379
380
381 *R_VECT_MASK_SET = IO_STATE(R_VECT_MASK_SET, serial, set);
382
383 *kgdb_port->rec_ctrl = IO_STATE(R_SERIAL0_REC_CTRL, rec_enable, enable);
384}
385
386static int __init
387console_setup(struct console *co, char *options)
388{
389 char* s;
390
391 if (options) {
392 port = &ports[co->index];
393 port->baudrate = 115200;
394 port->parity = 'N';
395 port->bits = 8;
396 port->baudrate = simple_strtoul(options, NULL, 10);
397 s = options;
398 while(*s >= '0' && *s <= '9')
399 s++;
400 if (*s) port->parity = *s++;
401 if (*s) port->bits = *s++ - '0';
402 port->started = 0;
403 start_port(0);
404 }
405 return 0;
406}
407
408
409
410
411
412static struct tty_driver dummy_driver;
413
414static int dummy_open(struct tty_struct *tty, struct file * filp)
415{
416 return 0;
417}
418
419static void dummy_close(struct tty_struct *tty, struct file * filp)
420{
421}
422
423static int dummy_write(struct tty_struct * tty,
424 const unsigned char *buf, int count)
425{
426 return count;
427}
428
429static int dummy_write_room(struct tty_struct *tty)
430{
431 return 8192;
432}
433
434static const struct tty_operations dummy_ops = {
435 .open = dummy_open,
436 .close = dummy_close,
437 .write = dummy_write,
438 .write_room = dummy_write_room,
439};
440
441void __init
442init_dummy_console(void)
443{
444 memset(&dummy_driver, 0, sizeof(struct tty_driver));
445 dummy_driver.driver_name = "serial";
446 dummy_driver.name = "ttyS";
447 dummy_driver.major = TTY_MAJOR;
448 dummy_driver.minor_start = 68;
449 dummy_driver.num = 1;
450 dummy_driver.type = TTY_DRIVER_TYPE_SERIAL;
451 dummy_driver.subtype = SERIAL_TYPE_NORMAL;
452 dummy_driver.init_termios = tty_std_termios;
453
454 dummy_driver.init_termios.c_cflag =
455 B115200 | CS8 | CREAD | HUPCL | CLOCAL;
456 dummy_driver.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
457 dummy_driver.init_termios.c_ispeed = 115200;
458 dummy_driver.init_termios.c_ospeed = 115200;
459
460 dummy_driver.ops = &dummy_ops;
461 if (tty_register_driver(&dummy_driver))
462 panic("Couldn't register dummy serial driver\n");
463}
464
465static struct tty_driver*
466etrax_console_device(struct console* co, int *index)
467{
468 if (port)
469 *index = port->index;
470 else
471 *index = 0;
472#ifdef CONFIG_ETRAX_SERIAL
473 return port ? serial_driver : &dummy_driver;
474#else
475 return &dummy_driver;
476#endif
477}
478
479static struct console sercons = {
480 name : "ttyS",
481 write: console_write,
482 read : NULL,
483 device : etrax_console_device,
484 unblank : NULL,
485 setup : console_setup,
486 flags : CON_PRINTBUFFER,
487 index : -1,
488 cflag : 0,
489 next : NULL
490};
491static struct console sercons0 = {
492 name : "ttyS",
493 write: console_write,
494 read : NULL,
495 device : etrax_console_device,
496 unblank : NULL,
497 setup : console_setup,
498 flags : CON_PRINTBUFFER,
499 index : 0,
500 cflag : 0,
501 next : NULL
502};
503
504static struct console sercons1 = {
505 name : "ttyS",
506 write: console_write,
507 read : NULL,
508 device : etrax_console_device,
509 unblank : NULL,
510 setup : console_setup,
511 flags : CON_PRINTBUFFER,
512 index : 1,
513 cflag : 0,
514 next : NULL
515};
516static struct console sercons2 = {
517 name : "ttyS",
518 write: console_write,
519 read : NULL,
520 device : etrax_console_device,
521 unblank : NULL,
522 setup : console_setup,
523 flags : CON_PRINTBUFFER,
524 index : 2,
525 cflag : 0,
526 next : NULL
527};
528static struct console sercons3 = {
529 name : "ttyS",
530 write: console_write,
531 read : NULL,
532 device : etrax_console_device,
533 unblank : NULL,
534 setup : console_setup,
535 flags : CON_PRINTBUFFER,
536 index : 3,
537 cflag : 0,
538 next : NULL
539};
540
541
542
543
544int __init
545init_etrax_debug(void)
546{
547 static int first = 1;
548
549 if (!first) {
550 unregister_console(&sercons);
551 register_console(&sercons0);
552 register_console(&sercons1);
553 register_console(&sercons2);
554 register_console(&sercons3);
555 init_dummy_console();
556 return 0;
557 }
558
559 first = 0;
560 register_console(&sercons);
561 start_port(port);
562#ifdef CONFIG_ETRAX_KGDB
563 start_port(kgdb_port);
564#endif
565 return 0;
566}
567__initcall(init_etrax_debug);
568
