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