projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ar71x: use raw squashfs images for TP-Link boards
[openwrt.git] / target / linux / ubicom32 / files / drivers / serial / ubi32_serdes.c
1 /*
2 * drivers/serial/ubi32_serdes.c
3 * Ubicom32 On-Chip Serial Driver
4 *
5 * (C) Copyright 2009, Ubicom, Inc.
6 *
7 * This file is part of the Ubicom32 Linux Kernel Port.
8 *
9 * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10 * it and/or modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation, either version 2 of the
12 * License, or (at your option) any later version.
13 *
14 * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with the Ubicom32 Linux Kernel Port. If not,
21 * see <http://www.gnu.org/licenses/>.
22 *
23 * Ubicom32 implementation derived from (with many thanks):
24 * arch/m68knommu
25 * arch/blackfin
26 * arch/parisc
27 */
28 #include <linux/module.h>
29 #include <linux/ioport.h>
30 #include <linux/init.h>
31 #include <linux/console.h>
32 #include <linux/sysrq.h>
33 #include <linux/platform_device.h>
34 #include <linux/tty.h>
35 #include <linux/tty_flip.h>
36 #include <linux/serial_core.h>
37
38 #include <asm/ip5000.h>
39 #include <asm/ubicom32suart.h>
40
41
42 #define SERIAL_UBICOM_PIN_RXD (1 << 0)
43 #define SERIAL_UBICOM_PIN_TXD (1 << 6)
44 #define SERIAL_UBICOM_CTL0 0x8b300000
45 #define SERIAL_UBICOM_CTL1 0x00000009
46
47 #define SERIAL_UBICOM_DATA_BIT 8 /* Fixed parameter - do not change */
48 #define SERIAL_UBICOM_PAR_BIT 0 /* Fixed parameter - do not change */
49 #define SERIAL_UBICOM_STOP_BIT 1 /* Fixed parameter - do not change */
50
51 /* UART name and device definitions */
52 #define UBI32_SERDES_NAME "ttyUS" // XXX
53 #define UBI32_SERDES_MAJOR 206 // XXX
54 #define UBI32_SERDES_MINOR 64 // XXX
55
56 #define PORT_UBI32_SERDES 1234
57 #define NR_PORTS 1
58
59 struct uart_port ubi32_serdes_ports[NR_PORTS];
60
61 struct ubi32_serdes_resource {
62 void *uart_base_addr;
63 int uart_irq;
64 int uart_clock;
65 } ubi32_serdes_resource[NR_PORTS] = {
66 /*
67 * Get params from kernel command line (required for early printk)
68 * or from platform resources.
69 */
70 {0, 0, 0}
71 };
72
73 /*
74 * Can get overridden by 'serdes=' kernel command line.
75 */
76 static int ubi32_serdes_default_baud_rate = 115200;
77
78
79 #define IO_PORT(port) ((struct ubicom32_io_port *)port->membase)
80 #define IO_PORT_INT_STATUS(port) (IO_PORT(port)->int_status)
81 #define IO_PORT_INT_MASK(port) (IO_PORT(port)->int_mask)
82 #define IO_PORT_INT_CLR(port) (IO_PORT(port)->int_clr)
83
84
85 /*
86 * ubi32_serdes_get_char()
87 */
88 static u8_t ubi32_serdes_get_char(struct ubicom32_io_port *io_port)
89 {
90 /*
91 * Read from hardware (forced 32-bit atomic read).
92 */
93 u32_t data = 0;
94
95 if ( io_port ) {
96 io_port->int_clr = IO_PORTX_INT_SERDES_RXBF;
97 asm volatile (
98 "move.4 %0, %1 \n\t"
99 : "=r" (data)
100 : "m" (*(u32_t *)&(io_port->rx_fifo))
101 );
102 }
103
104 return (u8_t)(data & 0x000000ff);
105 }
106
107 /*
108 * ubi32_serdes_put_char()
109 */
110 static void ubi32_serdes_put_char(struct ubicom32_io_port *io_port, u8_t c)
111 {
112 u32_t data = 0x0000fe00 | (c << 1);
113
114 if ( io_port ) {
115 /*
116 * Fixed data format:
117 * [LSB]1 start bit - 8 data bits - no parity - 1 stop bit[MSB]
118 */
119 io_port->int_clr = IO_PORTX_INT_SERDES_TXBE;
120 io_port->ctl2 = data;
121 io_port->int_set = IO_PORTX_INT_SERDES_TXBUF_VALID;
122 }
123 }
124
125 static void ubi32_serdes_hw_init(struct uart_port *port, int baud)
126 {
127 struct ubicom32_io_port *io_port = IO_PORT(port);
128
129 if ( io_port ) {
130 /*
131 * Put port functions 1-4 into reset state.
132 * Function 0 (GPIO) does not need or have a reset bit.
133 *
134 * Select SERDES function for restart below.
135 */
136 io_port->function =
137 IO_FUNC_FUNCTION_RESET(1) | IO_FUNC_FUNCTION_RESET(2) |
138 IO_FUNC_FUNCTION_RESET(3) | IO_FUNC_FUNCTION_RESET(4) |
139 IO_PORTX_FUNC_SERDES;
140
141 /*
142 * Configure SERDES baudrate
143 */
144 if ( baud == 0 ) {
145 baud = ubi32_serdes_default_baud_rate;
146 }
147
148 io_port->ctl0 =
149 SERIAL_UBICOM_CTL0 |
150 ((port->uartclk / (16 * baud)) - 1);
151
152 io_port->ctl1 =
153 SERIAL_UBICOM_CTL1;
154
155 /*
156 * don't interrupt until startup and start_tx
157 */
158 io_port->int_mask = 0;
159
160 /*
161 * Set TXD pin output, RXD input and prevent GPIO
162 * override on the TXD & RXD pins
163 */
164 io_port->gpio_ctl &= ~SERIAL_UBICOM_PIN_RXD;
165 io_port->gpio_ctl |= SERIAL_UBICOM_PIN_TXD;
166 io_port->gpio_mask &= ~(SERIAL_UBICOM_PIN_RXD | SERIAL_UBICOM_PIN_TXD);
167
168 /*
169 * Restart (un-reset) the port's SERDES function.
170 */
171 io_port->function &= ~(IO_FUNC_FUNCTION_RESET(IO_PORTX_FUNC_SERDES));
172 }
173 }
174
175 #define ULITE_STATUS_RXVALID IO_PORTX_INT_SERDES_RXBF
176 #define ULITE_STATUS_OVERRUN 0
177 #define ULITE_STATUS_FRAME 0
178 #define ULITE_STATUS_PARITY 0
179 #define ULITE_STATUS_TXEMPTY IO_PORTX_INT_SERDES_TXBE
180 #define ULITE_STATUS_TXFULL 0
181
182 static int ubi32_serdes_receive(struct uart_port *port, int stat)
183 {
184 struct tty_struct *tty = port->info->port.tty;
185 unsigned char ch = 0;
186 char flag = TTY_NORMAL;
187
188 if ((stat & (ULITE_STATUS_RXVALID | ULITE_STATUS_OVERRUN
189 | ULITE_STATUS_FRAME)) == 0)
190 return 0;
191
192 /* stats */
193 if (stat & ULITE_STATUS_RXVALID) {
194 port->icount.rx++;
195 ch = ubi32_serdes_get_char((struct ubicom32_io_port *)port->membase);
196
197 if (stat & ULITE_STATUS_PARITY)
198 port->icount.parity++;
199 }
200
201 if (stat & ULITE_STATUS_OVERRUN)
202 port->icount.overrun++;
203
204 if (stat & ULITE_STATUS_FRAME)
205 port->icount.frame++;
206
207
208 /* drop byte with parity error if IGNPAR specificed */
209 if (stat & port->ignore_status_mask & ULITE_STATUS_PARITY)
210 stat &= ~ULITE_STATUS_RXVALID;
211
212 stat &= port->read_status_mask;
213
214 if (stat & ULITE_STATUS_PARITY)
215 flag = TTY_PARITY;
216
217 stat &= ~port->ignore_status_mask;
218
219 if (stat & ULITE_STATUS_RXVALID)
220 tty_insert_flip_char(tty, ch, flag);
221
222 if (stat & ULITE_STATUS_FRAME)
223 tty_insert_flip_char(tty, 0, TTY_FRAME);
224
225 if (stat & ULITE_STATUS_OVERRUN)
226 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
227
228 return 1;
229 }
230
231 /*
232 * interrupts are disabled on entry
233 */
234 static void ubi32_serdes_stop_tx(struct uart_port *port)
235 {
236 IO_PORT_INT_MASK(port) = IO_PORT_INT_MASK(port) & ~IO_PORTX_INT_SERDES_TXBE;
237 }
238
239 static int ubi32_serdes_transmit(struct uart_port *port, int stat)
240 {
241 struct circ_buf *xmit = &port->info->xmit;
242
243 if (!(stat & IO_PORTX_INT_SERDES_TXBE))
244 return 0;
245
246 if (port->x_char) {
247 ubi32_serdes_put_char(IO_PORT(port), port->x_char);
248 port->x_char = 0;
249 port->icount.tx++;
250 return 1;
251 }
252
253 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
254 ubi32_serdes_stop_tx(port);
255 return 0;
256 }
257
258 ubi32_serdes_put_char(IO_PORT(port), xmit->buf[xmit->tail]);
259 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE-1);
260 port->icount.tx++;
261
262 /* wake up */
263 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
264 uart_write_wakeup(port);
265
266 if (uart_circ_empty(xmit))
267 ubi32_serdes_stop_tx(port);
268
269 return 1;
270 }
271
272 /*
273 * port is locked and interrupts are disabled
274 */
275 static void ubi32_serdes_start_tx(struct uart_port *port)
276 {
277 IO_PORT_INT_MASK(port) = IO_PORT_INT_MASK(port) | IO_PORTX_INT_SERDES_TXBE;
278 ubi32_serdes_transmit(port, IO_PORT_INT_STATUS(port));
279 }
280
281 /*
282 * Interrupts are enabled
283 */
284 static void ubi32_serdes_stop_rx(struct uart_port *port)
285 {
286 /* don't forward any more data (like !CREAD) */
287 port->ignore_status_mask = IO_PORTX_INT_SERDES_RXBF;
288 }
289
290 /*
291 * Set the modem control timer to fire immediately.
292 */
293 static void ubi32_serdes_enable_ms(struct uart_port *port)
294 {
295 /* N/A */
296 }
297
298 static irqreturn_t ubi32_serdes_isr(int irq, void *dev_id)
299 {
300 struct uart_port *port = dev_id;
301 int busy;
302
303 spin_lock(&port->lock);
304
305 do {
306 int stat = IO_PORT_INT_STATUS(port);
307 busy = ubi32_serdes_receive(port, stat);
308 busy |= ubi32_serdes_transmit(port, stat);
309 } while (busy);
310
311 tty_flip_buffer_push(port->info->port.tty);
312
313 spin_unlock(&port->lock);
314
315 return IRQ_HANDLED;
316 }
317
318 /*
319 * Return TIOCSER_TEMT when transmitter is not busy.
320 */
321 static unsigned int ubi32_serdes_tx_empty(struct uart_port *port)
322 {
323 unsigned long flags;
324 unsigned int ret;
325
326 spin_lock_irqsave(&port->lock, flags);
327 ret = IO_PORT_INT_STATUS(port);
328 spin_unlock_irqrestore(&port->lock, flags);
329
330 return ret & ULITE_STATUS_TXEMPTY ? TIOCSER_TEMT : 0;
331 }
332
333 static unsigned int ubi32_serdes_get_mctrl(struct uart_port *port)
334 {
335 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
336 }
337
338 static void ubi32_serdes_set_mctrl(struct uart_port *port, unsigned int mctrl)
339 {
340 /* N/A */
341 }
342
343 /*
344 * Interrupts are always disabled.
345 */
346 static void ubi32_serdes_break_ctl(struct uart_port *port, int break_state)
347 {
348 /* N/A */
349 }
350
351 static int ubi32_serdes_startup(struct uart_port *port)
352 {
353 if (request_irq(port->irq, ubi32_serdes_isr, IRQF_DISABLED,
354 "UBI32_SERDES", port)) {
355 printk(KERN_NOTICE "Unable to attach port interrupt\n");
356 return -EBUSY;
357 }
358
359 IO_PORT_INT_CLR(port) = IO_PORTX_INT_SERDES_RXBF;
360 IO_PORT_INT_MASK(port) = IO_PORTX_INT_SERDES_RXBF;
361 return 0;
362 }
363
364 static void ubi32_serdes_shutdown(struct uart_port *port)
365 {
366 struct ubi32_serdes_port *uart = (struct ubi32_serdes_port *)port;
367
368 IO_PORT_INT_MASK(port) = 0;
369 free_irq(port->irq, uart);
370 }
371
372 static void
373 ubi32_serdes_set_termios(struct uart_port *port, struct ktermios *termios,
374 struct ktermios *old)
375 {
376 unsigned long flags;
377 unsigned int baud;
378
379 spin_lock_irqsave(&port->lock, flags);
380
381 port->read_status_mask = ULITE_STATUS_RXVALID | ULITE_STATUS_OVERRUN
382 | ULITE_STATUS_TXFULL;
383
384 if (termios->c_iflag & INPCK)
385 port->read_status_mask |=
386 ULITE_STATUS_PARITY | ULITE_STATUS_FRAME;
387
388 port->ignore_status_mask = 0;
389 if (termios->c_iflag & IGNPAR)
390 port->ignore_status_mask |= ULITE_STATUS_PARITY
391 | ULITE_STATUS_FRAME | ULITE_STATUS_OVERRUN;
392
393 /* ignore all characters if CREAD is not set */
394 if ((termios->c_cflag & CREAD) == 0)
395 port->ignore_status_mask |=
396 ULITE_STATUS_RXVALID | ULITE_STATUS_PARITY
397 | ULITE_STATUS_FRAME | ULITE_STATUS_OVERRUN;
398
399 /* update timeout */
400 baud = uart_get_baud_rate(port, termios, old, 0, 460800);
401 uart_update_timeout(port, termios->c_cflag, baud);
402
403 IO_PORT(port)->ctl0 = SERIAL_UBICOM_CTL0 |
404 ((port->uartclk / (16 * baud)) - 1);
405
406 spin_unlock_irqrestore(&port->lock, flags);
407 }
408
409 static const char *ubi32_serdes_type(struct uart_port *port)
410 {
411 return port->type == PORT_UBI32_SERDES ? "UBI32_SERDES" : NULL;
412 }
413
414 /*
415 * Release the memory region(s) being used by 'port'.
416 */
417 static void ubi32_serdes_release_port(struct uart_port *port)
418 {
419 }
420
421 /*
422 * Request the memory region(s) being used by 'port'.
423 */
424 static int ubi32_serdes_request_port(struct uart_port *port)
425 {
426 return 0;
427 }
428
429 /*
430 * Configure/autoconfigure the port.
431 */
432 static void ubi32_serdes_config_port(struct uart_port *port, int flags)
433 {
434 if (flags & UART_CONFIG_TYPE &&
435 ubi32_serdes_request_port(port) == 0)
436 port->type = PORT_UBI32_SERDES;
437 }
438
439 /*
440 * Verify the new serial_struct (for TIOCSSERIAL).
441 * The only change we allow are to the flags and type, and
442 * even then only between PORT_UBI32_SERDES and PORT_UNKNOWN
443 */
444 static int
445 ubi32_serdes_verify_port(struct uart_port *port, struct serial_struct *ser)
446 {
447 return 0;
448 }
449
450 static struct uart_ops ubi32_serdes_pops = {
451 .tx_empty = ubi32_serdes_tx_empty,
452 .set_mctrl = ubi32_serdes_set_mctrl,
453 .get_mctrl = ubi32_serdes_get_mctrl,
454 .stop_tx = ubi32_serdes_stop_tx,
455 .start_tx = ubi32_serdes_start_tx,
456 .stop_rx = ubi32_serdes_stop_rx,
457 .enable_ms = ubi32_serdes_enable_ms,
458 .break_ctl = ubi32_serdes_break_ctl,
459 .startup = ubi32_serdes_startup,
460 .shutdown = ubi32_serdes_shutdown,
461 .set_termios = ubi32_serdes_set_termios,
462 .type = ubi32_serdes_type,
463 .release_port = ubi32_serdes_release_port,
464 .request_port = ubi32_serdes_request_port,
465 .config_port = ubi32_serdes_config_port,
466 .verify_port = ubi32_serdes_verify_port,
467 };
468
469 static void __init ubi32_serdes_init_ports(void)
470 {
471 int i;
472
473 for (i = 0; i < NR_PORTS; i++) {
474 ubi32_serdes_ports[i].uartclk = ubi32_serdes_resource[i].uart_clock;
475 ubi32_serdes_ports[i].ops = &ubi32_serdes_pops;
476 ubi32_serdes_ports[i].line = i;
477 ubi32_serdes_ports[i].iotype = UPIO_MEM;
478 ubi32_serdes_ports[i].membase =
479 (void __iomem *)ubi32_serdes_resource[i].uart_base_addr;
480 ubi32_serdes_ports[i].mapbase =
481 (resource_size_t)ubi32_serdes_resource[i].uart_base_addr;
482 ubi32_serdes_ports[i].irq =
483 ubi32_serdes_resource[i].uart_irq;
484 ubi32_serdes_ports[i].flags = UPF_BOOT_AUTOCONF;
485
486 ubi32_serdes_hw_init(&ubi32_serdes_ports[i], 0);
487 }
488
489 }
490
491 #ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
492 /*
493 * If the port was already initialised (eg, by a boot loader),
494 * try to determine the current setup.
495 */
496 static void __init
497 ubi32_serdes_console_get_options(struct uart_port *port, int *baud)
498 {
499 u32 round_to = 1200;
500 u32 real_baud;
501
502 /*
503 * We might get called before platform init and with no
504 * kernel command line options, so port might be NULL.
505 */
506 *baud = ubi32_serdes_default_baud_rate;;
507 if ( IO_PORT(port) == 0 )
508 return;
509
510 real_baud = port->uartclk
511 / (16 * ((IO_PORT(port)->ctl0 & ~SERIAL_UBICOM_CTL0) + 1));
512
513 *baud = ((real_baud + round_to - 1) / round_to) * round_to;
514
515 pr_debug("%s:baud = %d, real_baud = %d\n", __FUNCTION__, *baud, real_baud);
516 }
517 #endif
518
519 #if defined(CONFIG_SERIAL_UBI32_SERDES_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
520 static struct uart_driver ubi32_serdes_reg;
521
522 static int __init
523 ubi32_serdes_console_setup(struct console *co, char *options)
524 {
525 struct uart_port *port;
526 #ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
527 int baud = ubi32_serdes_default_baud_rate;
528 int bits = 8;
529 int parity = 'n';
530 int flow = 'n';
531 #endif
532
533 /*
534 * Check whether an invalid uart number has been specified, and
535 * if so, search for the first available port that does have
536 * console support.
537 */
538 if (co->index == -1 || co->index >= NR_PORTS)
539 co->index = 0;
540 port = &ubi32_serdes_ports[co->index];
541
542 #ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
543 if (options) {
544 uart_parse_options(options, &baud, &parity, &bits, &flow);
545 ubi32_serdes_hw_init(port, baud);
546 }
547 else
548 ubi32_serdes_console_get_options(port, &baud);
549
550 return uart_set_options(port, co, baud, parity, bits, flow);
551 #else
552 return 0;
553 #endif
554 }
555 #endif /* defined (CONFIG_SERIAL_UBI32_SERDES_CONSOLE) ||
556 defined (CONFIG_EARLY_PRINTK) */
557
558 #ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
559 static void
560 ubi32_serdes_console_putchar(struct uart_port *port, int ch)
561 {
562 if ( IO_PORT(port) ) {
563 while (!(IO_PORT_INT_STATUS(port) & IO_PORTX_INT_SERDES_TXBE))
564 barrier();
565 ubi32_serdes_put_char(IO_PORT(port), ch);
566 }
567 }
568
569 /*
570 * Interrupts are disabled on entering
571 */
572 static void
573 ubi32_serdes_console_write(struct console *co, const char *s, unsigned int count)
574 {
575 struct uart_port *port = &ubi32_serdes_ports[co->index];
576 unsigned long flags = 0;
577
578 spin_lock_irqsave(&port->lock, flags);
579 uart_console_write(port, s, count, ubi32_serdes_console_putchar);
580 spin_unlock_irqrestore(&port->lock, flags);
581
582 }
583
584 static struct console ubi32_serdes_console = {
585 .name = UBI32_SERDES_NAME,
586 .write = ubi32_serdes_console_write,
587 .device = uart_console_device,
588 .setup = ubi32_serdes_console_setup,
589 .flags = CON_PRINTBUFFER,
590 .index = -1,
591 .data = &ubi32_serdes_reg,
592 };
593
594 static int __init ubi32_serdes_console_init(void)
595 {
596 ubi32_serdes_init_ports();
597 register_console(&ubi32_serdes_console);
598 return 0;
599 }
600 console_initcall(ubi32_serdes_console_init);
601
602 #define UBI32_SERDES_CONSOLE &ubi32_serdes_console
603 #else
604 #define UBI32_SERDES_CONSOLE NULL
605 #endif /* CONFIG_SERIAL_UBI32_SERDES_CONSOLE */
606
607
608 #ifdef CONFIG_EARLY_PRINTK
609 static __init void ubi32_serdes_early_putc(struct uart_port *port, int ch)
610 {
611 unsigned timeout = 0xffff;
612
613 while ((!(IO_PORT_INT_STATUS(port) & IO_PORTX_INT_SERDES_TXBE)) && --timeout)
614 cpu_relax();
615 ubi32_serdes_put_char(IO_PORT(port), ch);
616 }
617
618 static __init void ubi32_serdes_early_write(struct console *con, const char *s,
619 unsigned int n)
620 {
621 struct uart_port *port = &ubi32_serdes_ports[con->index];
622 unsigned int i;
623
624 for (i = 0; i < n; i++, s++) {
625 if (*s == '\n')
626 ubi32_serdes_early_putc(port, '\r');
627 ubi32_serdes_early_putc(port, *s);
628 }
629 }
630
631 static struct __init console ubi32_serdes_early_console = {
632 .name = "early_US",
633 .write = ubi32_serdes_early_write,
634 .device = uart_console_device,
635 .flags = CON_PRINTBUFFER,
636 .setup = ubi32_serdes_console_setup,
637 .index = -1,
638 .data = &ubi32_serdes_reg,
639 };
640
641 /*
642 * XXX Unused in our driver. Need to find out what the termios initialization is good/needed for.
643 */
644 struct console __init *ubi32_serdes_early_init(unsigned int port_index,
645 unsigned int cflag)
646 {
647 struct uart_port *uart;
648 struct ktermios t;
649
650 if (port_index == -1 || port_index >= NR_PORTS)
651 port_index = 0;
652 ubi32_serdes_init_ports();
653 ubi32_serdes_early_console.index = port_index;
654 uart = &ubi32_serdes_ports[port_index];
655 t.c_cflag = cflag;
656 t.c_iflag = 0;
657 t.c_oflag = 0;
658 t.c_lflag = ICANON;
659 t.c_line = port_index;
660 ubi32_serdes_set_termios(uart, &t, &t);
661 return &ubi32_serdes_early_console;
662 }
663
664 #endif /* CONFIG_SERIAL_UBI32_SERDES_CONSOLE */
665
666 static struct uart_driver ubi32_serdes_reg = {
667 .owner = THIS_MODULE,
668 .driver_name = "ubi32_serdes",
669 .dev_name = UBI32_SERDES_NAME,
670 .major = UBI32_SERDES_MAJOR,
671 .minor = UBI32_SERDES_MINOR,
672 .nr = NR_PORTS,
673 .cons = UBI32_SERDES_CONSOLE,
674 };
675
676 static int ubi32_serdes_suspend(struct platform_device *dev, pm_message_t state)
677 {
678 struct uart_port *port = platform_get_drvdata(dev);
679
680 if (port)
681 uart_suspend_port(&ubi32_serdes_reg, port);
682
683 return 0;
684 }
685
686 static int ubi32_serdes_resume(struct platform_device *dev)
687 {
688 struct uart_port *port = platform_get_drvdata(dev);
689
690 if (port)
691 uart_resume_port(&ubi32_serdes_reg, port);
692
693 return 0;
694 }
695
696 static int ubi32_serdes_probe(struct platform_device *dev)
697 {
698 struct resource *res = dev->resource;
699 int i;
700
701 for (i = 0; i < dev->num_resources; i++, res++) {
702 if (res->flags & IORESOURCE_MEM) {
703 ubi32_serdes_resource[0].uart_base_addr = (void *) res->start;
704 }
705 else if (res->flags & IORESOURCE_IRQ) {
706 ubi32_serdes_resource[0].uart_irq = res->start;
707 }
708 else if (res->flags & UBICOM32_SUART_IORESOURCE_CLOCK) {
709 ubi32_serdes_resource[0].uart_clock = res->start;
710 }
711 }
712
713 ubi32_serdes_init_ports();
714
715 return 0;
716 }
717
718 static int ubi32_serdes_remove(struct platform_device *pdev)
719 {
720 struct uart_port *port = platform_get_drvdata(pdev);
721
722 platform_set_drvdata(pdev, NULL);
723
724 if (port)
725 uart_remove_one_port(&ubi32_serdes_reg, port);
726
727 return 0;
728 }
729
730 static struct platform_driver ubi32_serdes_driver = {
731 .remove = ubi32_serdes_remove,
732 .suspend = ubi32_serdes_suspend,
733 .resume = ubi32_serdes_resume,
734 .driver = {
735 .name = "ubicom32suart",
736 .owner = THIS_MODULE,
737 },
738 };
739
740
741 #ifndef MODULE
742 /*
743 * Called at boot time.
744 *
745 * You can specify IO base, IRQ, and clock for the serdes serial port
746 * using kernel command line "serdes=0xiobase,irq,clock". Values
747 * specified will be overwritten by platform device data, if present.
748 */
749 static int __init ubi32_serdes_setup(char *str)
750 {
751 #define N_PARMS (4+1)
752 int ints[N_PARMS];
753 int i;
754
755 str = get_options(str, ARRAY_SIZE(ints), ints);
756
757 for (i = 0; i < N_PARMS; i++) {
758 if (i < ints[0]) {
759 if (i == 0) {
760 ubi32_serdes_resource[0].uart_base_addr = (void *) ints[i+1];
761 }
762 else if (i == 1) {
763 ubi32_serdes_resource[0].uart_irq = ints[i+1];
764 }
765 else if (i == 2) {
766 ubi32_serdes_resource[0].uart_clock = ints[i+1];
767 }
768 else if (i == 3) {
769 ubi32_serdes_default_baud_rate = ints[i+1];
770 }
771 }
772 }
773 return 1;
774 }
775
776 __setup("serdes=", ubi32_serdes_setup);
777 #endif
778
779 static int __init ubi32_serdes_init(void)
780 {
781 int ret;
782
783 pr_info("Serial: Ubicom32 serdes uart serial driver\n");
784
785 ret = platform_driver_probe(&ubi32_serdes_driver, ubi32_serdes_probe);
786 if (ret != 0) {
787 printk(KERN_INFO "serdes platform_driver_probe() failed: %d\n", ret);
788 return ret;
789 }
790
791 ubi32_serdes_init_ports();
792
793 ret = uart_register_driver(&ubi32_serdes_reg);
794 if ( ret == 0 ) {
795 ret = uart_add_one_port(&ubi32_serdes_reg, &ubi32_serdes_ports[0]);
796 if ( ret != 0 ) {
797 uart_unregister_driver(&ubi32_serdes_reg);
798 }
799 }
800
801 return ret;
802 }
803
804 static void __exit ubi32_serdes_exit(void)
805 {
806 platform_driver_unregister(&ubi32_serdes_driver);
807 uart_unregister_driver(&ubi32_serdes_reg);
808 }
809
810 module_init(ubi32_serdes_init);
811 module_exit(ubi32_serdes_exit);
812
813 MODULE_AUTHOR("Rainer Keller <rkeller@ubicom.com>");
814 MODULE_DESCRIPTION("Ubicom generic serial port driver");
815 MODULE_LICENSE("GPL");
816 MODULE_ALIAS_CHARDEV_MAJOR(UBI32_SERDES_MAJOR);
817 MODULE_ALIAS("platform:ubi32_serdes");
Personal OpenWRT clone
This page took 0.085223 seconds and 5 git commands to generate.