[PATCH] IB/mthca: map context for RDMA responder in mem-free mode
[linux-2.6] / drivers / serial / serial_lh7a40x.c
1 /* drivers/serial/serial_lh7a40x.c
2  *
3  *  Copyright (C) 2004 Coastal Environmental Systems
4  *
5  *  This program is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU General Public License
7  *  version 2 as published by the Free Software Foundation.
8  *
9  */
10
11 /* Driver for Sharp LH7A40X embedded serial ports
12  *
13  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
14  *  Based on drivers/serial/amba.c, by Deep Blue Solutions Ltd.
15  *
16  *  ---
17  *
18  * This driver supports the embedded UARTs of the Sharp LH7A40X series
19  * CPUs.  While similar to the 16550 and other UART chips, there is
20  * nothing close to register compatibility.  Moreover, some of the
21  * modem control lines are not available, either in the chip or they
22  * are lacking in the board-level implementation.
23  *
24  * - Use of SIRDIS
25  *   For simplicity, we disable the IR functions of any UART whenever
26  *   we enable it.
27  *
28  */
29
30 #include <linux/config.h>
31
32 #if defined(CONFIG_SERIAL_LH7A40X_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
33 #define SUPPORT_SYSRQ
34 #endif
35
36 #include <linux/module.h>
37 #include <linux/ioport.h>
38 #include <linux/init.h>
39 #include <linux/console.h>
40 #include <linux/sysrq.h>
41 #include <linux/tty.h>
42 #include <linux/tty_flip.h>
43 #include <linux/serial_core.h>
44 #include <linux/serial.h>
45
46 #include <asm/io.h>
47 #include <asm/irq.h>
48
49 #define DEV_MAJOR       204
50 #define DEV_MINOR       16
51 #define DEV_NR          3
52
53 #define ISR_LOOP_LIMIT  256
54
55 #define UR(p,o) _UR ((p)->membase, o)
56 #define _UR(b,o) (*((volatile unsigned int*)(((unsigned char*) b) + (o))))
57 #define BIT_CLR(p,o,m)  UR(p,o) = UR(p,o) & (~(unsigned int)m)
58 #define BIT_SET(p,o,m)  UR(p,o) = UR(p,o) | ( (unsigned int)m)
59
60 #define UART_REG_SIZE   32
61
62 #define UART_R_DATA     (0x00)
63 #define UART_R_FCON     (0x04)
64 #define UART_R_BRCON    (0x08)
65 #define UART_R_CON      (0x0c)
66 #define UART_R_STATUS   (0x10)
67 #define UART_R_RAWISR   (0x14)
68 #define UART_R_INTEN    (0x18)
69 #define UART_R_ISR      (0x1c)
70
71 #define UARTEN          (0x01)          /* UART enable */
72 #define SIRDIS          (0x02)          /* Serial IR disable (UART1 only) */
73
74 #define RxEmpty         (0x10)
75 #define TxEmpty         (0x80)
76 #define TxFull          (0x20)
77 #define nRxRdy          RxEmpty
78 #define nTxRdy          TxFull
79 #define TxBusy          (0x08)
80
81 #define RxBreak         (0x0800)
82 #define RxOverrunError  (0x0400)
83 #define RxParityError   (0x0200)
84 #define RxFramingError  (0x0100)
85 #define RxError     (RxBreak | RxOverrunError | RxParityError | RxFramingError)
86
87 #define DCD             (0x04)
88 #define DSR             (0x02)
89 #define CTS             (0x01)
90
91 #define RxInt           (0x01)
92 #define TxInt           (0x02)
93 #define ModemInt        (0x04)
94 #define RxTimeoutInt    (0x08)
95
96 #define MSEOI           (0x10)
97
98 #define WLEN_8          (0x60)
99 #define WLEN_7          (0x40)
100 #define WLEN_6          (0x20)
101 #define WLEN_5          (0x00)
102 #define WLEN            (0x60)  /* Mask for all word-length bits */
103 #define STP2            (0x08)
104 #define PEN             (0x02)  /* Parity Enable */
105 #define EPS             (0x04)  /* Even Parity Set */
106 #define FEN             (0x10)  /* FIFO Enable */
107 #define BRK             (0x01)  /* Send Break */
108
109
110 struct uart_port_lh7a40x {
111         struct uart_port port;
112         unsigned int statusPrev; /* Most recently read modem status */
113 };
114
115 static void lh7a40xuart_stop_tx (struct uart_port* port, unsigned int tty_stop)
116 {
117         BIT_CLR (port, UART_R_INTEN, TxInt);
118 }
119
120 static void lh7a40xuart_start_tx (struct uart_port* port,
121                                   unsigned int tty_start)
122 {
123         BIT_SET (port, UART_R_INTEN, TxInt);
124
125         /* *** FIXME: do I need to check for startup of the
126                       transmitter?  The old driver did, but AMBA
127                       doesn't . */
128 }
129
130 static void lh7a40xuart_stop_rx (struct uart_port* port)
131 {
132         BIT_SET (port, UART_R_INTEN, RxTimeoutInt | RxInt);
133 }
134
135 static void lh7a40xuart_enable_ms (struct uart_port* port)
136 {
137         BIT_SET (port, UART_R_INTEN, ModemInt);
138 }
139
140 static void
141 #ifdef SUPPORT_SYSRQ
142 lh7a40xuart_rx_chars (struct uart_port* port, struct pt_regs* regs)
143 #else
144 lh7a40xuart_rx_chars (struct uart_port* port)
145 #endif
146 {
147         struct tty_struct* tty = port->info->tty;
148         int cbRxMax = 256;      /* (Gross) limit on receive */
149         unsigned int data, flag;/* Received data and status */
150
151         while (!(UR (port, UART_R_STATUS) & nRxRdy) && --cbRxMax) {
152                 if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
153                         if (tty->low_latency)
154                                 tty_flip_buffer_push(tty);
155                         /*
156                          * If this failed then we will throw away the
157                          * bytes but must do so to clear interrupts
158                          */
159                 }
160
161                 data = UR (port, UART_R_DATA);
162                 flag = TTY_NORMAL;
163                 ++port->icount.rx;
164
165                 if (data & RxError) {   /* Quick check, short-circuit */
166                         if (data & RxBreak) {
167                                 data &= ~(RxFramingError | RxParityError);
168                                 ++port->icount.brk;
169                                 if (uart_handle_break (port))
170                                         continue;
171                         }
172                         else if (data & RxParityError)
173                                 ++port->icount.parity;
174                         else if (data & RxFramingError)
175                                 ++port->icount.frame;
176                         if (data & RxOverrunError)
177                                 ++port->icount.overrun;
178
179                                 /* Mask by termios, leave Rx'd byte */
180                         data &= port->read_status_mask | 0xff;
181
182                         if (data & RxBreak)
183                                 flag = TTY_BREAK;
184                         else if (data & RxParityError)
185                                 flag = TTY_PARITY;
186                         else if (data & RxFramingError)
187                                 flag = TTY_FRAME;
188                 }
189
190                 if (uart_handle_sysrq_char (port, (unsigned char) data, regs))
191                         continue;
192
193                 if ((data & port->ignore_status_mask) == 0) {
194                         tty_insert_flip_char(tty, data, flag);
195                 }
196                 if ((data & RxOverrunError)
197                     && tty->flip.count < TTY_FLIPBUF_SIZE) {
198                         /*
199                          * Overrun is special, since it's reported
200                          * immediately, and doesn't affect the current
201                          * character
202                          */
203                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
204                 }
205         }
206         tty_flip_buffer_push (tty);
207         return;
208 }
209
210 static void lh7a40xuart_tx_chars (struct uart_port* port)
211 {
212         struct circ_buf* xmit = &port->info->xmit;
213         int cbTxMax = port->fifosize;
214
215         if (port->x_char) {
216                 UR (port, UART_R_DATA) = port->x_char;
217                 ++port->icount.tx;
218                 port->x_char = 0;
219                 return;
220         }
221         if (uart_circ_empty (xmit) || uart_tx_stopped (port)) {
222                 lh7a40xuart_stop_tx (port, 0);
223                 return;
224         }
225
226         /* Unlike the AMBA UART, the lh7a40x UART does not guarantee
227            that at least half of the FIFO is empty.  Instead, we check
228            status for every character.  Using the AMBA method causes
229            the transmitter to drop characters. */
230
231         do {
232                 UR (port, UART_R_DATA) = xmit->buf[xmit->tail];
233                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
234                 ++port->icount.tx;
235                 if (uart_circ_empty(xmit))
236                         break;
237         } while (!(UR (port, UART_R_STATUS) & nTxRdy)
238                  && cbTxMax--);
239
240         if (uart_circ_chars_pending (xmit) < WAKEUP_CHARS)
241                 uart_write_wakeup (port);
242
243         if (uart_circ_empty (xmit))
244                 lh7a40xuart_stop_tx (port, 0);
245 }
246
247 static void lh7a40xuart_modem_status (struct uart_port* port)
248 {
249         unsigned int status = UR (port, UART_R_STATUS);
250         unsigned int delta
251                 = status ^ ((struct uart_port_lh7a40x*) port)->statusPrev;
252
253         BIT_SET (port, UART_R_RAWISR, MSEOI); /* Clear modem status intr */
254
255         if (!delta)             /* Only happens if we missed 2 transitions */
256                 return;
257
258         ((struct uart_port_lh7a40x*) port)->statusPrev = status;
259
260         if (delta & DCD)
261                 uart_handle_dcd_change (port, status & DCD);
262
263         if (delta & DSR)
264                 ++port->icount.dsr;
265
266         if (delta & CTS)
267                 uart_handle_cts_change (port, status & CTS);
268
269         wake_up_interruptible (&port->info->delta_msr_wait);
270 }
271
272 static irqreturn_t lh7a40xuart_int (int irq, void* dev_id,
273                                     struct pt_regs* regs)
274 {
275         struct uart_port* port = dev_id;
276         unsigned int cLoopLimit = ISR_LOOP_LIMIT;
277         unsigned int isr = UR (port, UART_R_ISR);
278
279
280         do {
281                 if (isr & (RxInt | RxTimeoutInt))
282 #ifdef SUPPORT_SYSRQ
283                         lh7a40xuart_rx_chars(port, regs);
284 #else
285                         lh7a40xuart_rx_chars(port);
286 #endif
287                 if (isr & ModemInt)
288                         lh7a40xuart_modem_status (port);
289                 if (isr & TxInt)
290                         lh7a40xuart_tx_chars (port);
291
292                 if (--cLoopLimit == 0)
293                         break;
294
295                 isr = UR (port, UART_R_ISR);
296         } while (isr & (RxInt | TxInt | RxTimeoutInt));
297
298         return IRQ_HANDLED;
299 }
300
301 static unsigned int lh7a40xuart_tx_empty (struct uart_port* port)
302 {
303         return (UR (port, UART_R_STATUS) & TxEmpty) ? TIOCSER_TEMT : 0;
304 }
305
306 static unsigned int lh7a40xuart_get_mctrl (struct uart_port* port)
307 {
308         unsigned int result = 0;
309         unsigned int status = UR (port, UART_R_STATUS);
310
311         if (status & DCD)
312                 result |= TIOCM_CAR;
313         if (status & DSR)
314                 result |= TIOCM_DSR;
315         if (status & CTS)
316                 result |= TIOCM_CTS;
317
318         return result;
319 }
320
321 static void lh7a40xuart_set_mctrl (struct uart_port* port, unsigned int mctrl)
322 {
323         /* None of the ports supports DTR. UART1 supports RTS through GPIO. */
324         /* Note, kernel appears to be setting DTR and RTS on console. */
325
326         /* *** FIXME: this deserves more work.  There's some work in
327                tracing all of the IO pins. */
328 #if 0
329         if( port->mapbase == UART1_PHYS) {
330                 gpioRegs_t *gpio = (gpioRegs_t *)IO_ADDRESS(GPIO_PHYS);
331
332                 if (mctrl & TIOCM_RTS)
333                         gpio->pbdr &= ~GPIOB_UART1_RTS;
334                 else
335                         gpio->pbdr |= GPIOB_UART1_RTS;
336         }
337 #endif
338 }
339
340 static void lh7a40xuart_break_ctl (struct uart_port* port, int break_state)
341 {
342         unsigned long flags;
343
344         spin_lock_irqsave(&port->lock, flags);
345         if (break_state == -1)
346                 BIT_SET (port, UART_R_FCON, BRK); /* Assert break */
347         else
348                 BIT_CLR (port, UART_R_FCON, BRK); /* Deassert break */
349         spin_unlock_irqrestore(&port->lock, flags);
350 }
351
352 static int lh7a40xuart_startup (struct uart_port* port)
353 {
354         int retval;
355
356         retval = request_irq (port->irq, lh7a40xuart_int, 0,
357                               "serial_lh7a40x", port);
358         if (retval)
359                 return retval;
360
361                                 /* Initial modem control-line settings */
362         ((struct uart_port_lh7a40x*) port)->statusPrev
363                 = UR (port, UART_R_STATUS);
364
365         /* There is presently no configuration option to enable IR.
366            Thus, we always disable it. */
367
368         BIT_SET (port, UART_R_CON, UARTEN | SIRDIS);
369         BIT_SET (port, UART_R_INTEN, RxTimeoutInt | RxInt);
370
371         return 0;
372 }
373
374 static void lh7a40xuart_shutdown (struct uart_port* port)
375 {
376         free_irq (port->irq, port);
377         BIT_CLR (port, UART_R_FCON, BRK | FEN);
378         BIT_CLR (port, UART_R_CON, UARTEN);
379 }
380
381 static void lh7a40xuart_set_termios (struct uart_port* port,
382                                      struct termios* termios,
383                                      struct termios* old)
384 {
385         unsigned int con;
386         unsigned int inten;
387         unsigned int fcon;
388         unsigned long flags;
389         unsigned int baud;
390         unsigned int quot;
391
392         baud = uart_get_baud_rate (port, termios, old, 8, port->uartclk/16);
393         quot = uart_get_divisor (port, baud); /* -1 performed elsewhere */
394
395         switch (termios->c_cflag & CSIZE) {
396         case CS5:
397                 fcon = WLEN_5;
398                 break;
399         case CS6:
400                 fcon = WLEN_6;
401                 break;
402         case CS7:
403                 fcon = WLEN_7;
404                 break;
405         case CS8:
406         default:
407                 fcon = WLEN_8;
408                 break;
409         }
410         if (termios->c_cflag & CSTOPB)
411                 fcon |= STP2;
412         if (termios->c_cflag & PARENB) {
413                 fcon |= PEN;
414                 if (!(termios->c_cflag & PARODD))
415                         fcon |= EPS;
416         }
417         if (port->fifosize > 1)
418                 fcon |= FEN;
419
420         spin_lock_irqsave (&port->lock, flags);
421
422         uart_update_timeout (port, termios->c_cflag, baud);
423
424         port->read_status_mask = RxOverrunError;
425         if (termios->c_iflag & INPCK)
426                 port->read_status_mask |= RxFramingError | RxParityError;
427         if (termios->c_iflag & (BRKINT | PARMRK))
428                 port->read_status_mask |= RxBreak;
429
430                 /* Figure mask for status we ignore */
431         port->ignore_status_mask = 0;
432         if (termios->c_iflag & IGNPAR)
433                 port->ignore_status_mask |= RxFramingError | RxParityError;
434         if (termios->c_iflag & IGNBRK) {
435                 port->ignore_status_mask |= RxBreak;
436                 /* Ignore overrun when ignorning parity */
437                 /* *** FIXME: is this in the right place? */
438                 if (termios->c_iflag & IGNPAR)
439                         port->ignore_status_mask |= RxOverrunError;
440         }
441
442                 /* Ignore all receive errors when receive disabled */
443         if ((termios->c_cflag & CREAD) == 0)
444                 port->ignore_status_mask |= RxError;
445
446         con   = UR (port, UART_R_CON);
447         inten = (UR (port, UART_R_INTEN) & ~ModemInt);
448
449         if (UART_ENABLE_MS (port, termios->c_cflag))
450                 inten |= ModemInt;
451
452         BIT_CLR (port, UART_R_CON, UARTEN);     /* Disable UART */
453         UR (port, UART_R_INTEN) = 0;            /* Disable interrupts */
454         UR (port, UART_R_BRCON) = quot - 1;     /* Set baud rate divisor */
455         UR (port, UART_R_FCON)  = fcon;         /* Set FIFO and frame ctrl */
456         UR (port, UART_R_INTEN) = inten;        /* Enable interrupts */
457         UR (port, UART_R_CON)   = con;          /* Restore UART mode */
458
459         spin_unlock_irqrestore(&port->lock, flags);
460 }
461
462 static const char* lh7a40xuart_type (struct uart_port* port)
463 {
464         return port->type == PORT_LH7A40X ? "LH7A40X" : NULL;
465 }
466
467 static void lh7a40xuart_release_port (struct uart_port* port)
468 {
469         release_mem_region (port->mapbase, UART_REG_SIZE);
470 }
471
472 static int lh7a40xuart_request_port (struct uart_port* port)
473 {
474         return request_mem_region (port->mapbase, UART_REG_SIZE,
475                                    "serial_lh7a40x") != NULL
476                 ? 0 : -EBUSY;
477 }
478
479 static void lh7a40xuart_config_port (struct uart_port* port, int flags)
480 {
481         if (flags & UART_CONFIG_TYPE) {
482                 port->type = PORT_LH7A40X;
483                 lh7a40xuart_request_port (port);
484         }
485 }
486
487 static int lh7a40xuart_verify_port (struct uart_port* port,
488                                     struct serial_struct* ser)
489 {
490         int ret = 0;
491
492         if (ser->type != PORT_UNKNOWN && ser->type != PORT_LH7A40X)
493                 ret = -EINVAL;
494         if (ser->irq < 0 || ser->irq >= NR_IRQS)
495                 ret = -EINVAL;
496         if (ser->baud_base < 9600) /* *** FIXME: is this true? */
497                 ret = -EINVAL;
498         return ret;
499 }
500
501 static struct uart_ops lh7a40x_uart_ops = {
502         .tx_empty       = lh7a40xuart_tx_empty,
503         .set_mctrl      = lh7a40xuart_set_mctrl,
504         .get_mctrl      = lh7a40xuart_get_mctrl,
505         .stop_tx        = lh7a40xuart_stop_tx,
506         .start_tx       = lh7a40xuart_start_tx,
507         .stop_rx        = lh7a40xuart_stop_rx,
508         .enable_ms      = lh7a40xuart_enable_ms,
509         .break_ctl      = lh7a40xuart_break_ctl,
510         .startup        = lh7a40xuart_startup,
511         .shutdown       = lh7a40xuart_shutdown,
512         .set_termios    = lh7a40xuart_set_termios,
513         .type           = lh7a40xuart_type,
514         .release_port   = lh7a40xuart_release_port,
515         .request_port   = lh7a40xuart_request_port,
516         .config_port    = lh7a40xuart_config_port,
517         .verify_port    = lh7a40xuart_verify_port,
518 };
519
520 static struct uart_port_lh7a40x lh7a40x_ports[DEV_NR] = {
521         {
522                 .port = {
523                         .membase        = (void*) io_p2v (UART1_PHYS),
524                         .mapbase        = UART1_PHYS,
525                         .iotype         = SERIAL_IO_MEM,
526                         .irq            = IRQ_UART1INTR,
527                         .uartclk        = 14745600/2,
528                         .fifosize       = 16,
529                         .ops            = &lh7a40x_uart_ops,
530                         .flags          = ASYNC_BOOT_AUTOCONF,
531                         .line           = 0,
532                 },
533         },
534         {
535                 .port = {
536                         .membase        = (void*) io_p2v (UART2_PHYS),
537                         .mapbase        = UART2_PHYS,
538                         .iotype         = SERIAL_IO_MEM,
539                         .irq            = IRQ_UART2INTR,
540                         .uartclk        = 14745600/2,
541                         .fifosize       = 16,
542                         .ops            = &lh7a40x_uart_ops,
543                         .flags          = ASYNC_BOOT_AUTOCONF,
544                         .line           = 1,
545                 },
546         },
547         {
548                 .port = {
549                         .membase        = (void*) io_p2v (UART3_PHYS),
550                         .mapbase        = UART3_PHYS,
551                         .iotype         = SERIAL_IO_MEM,
552                         .irq            = IRQ_UART3INTR,
553                         .uartclk        = 14745600/2,
554                         .fifosize       = 16,
555                         .ops            = &lh7a40x_uart_ops,
556                         .flags          = ASYNC_BOOT_AUTOCONF,
557                         .line           = 2,
558                 },
559         },
560 };
561
562 #ifndef CONFIG_SERIAL_LH7A40X_CONSOLE
563 # define LH7A40X_CONSOLE NULL
564 #else
565 # define LH7A40X_CONSOLE &lh7a40x_console
566
567
568 static void lh7a40xuart_console_write (struct console* co,
569                                        const char* s,
570                                        unsigned int count)
571 {
572         struct uart_port* port = &lh7a40x_ports[co->index].port;
573         unsigned int con = UR (port, UART_R_CON);
574         unsigned int inten = UR (port, UART_R_INTEN);
575
576
577         UR (port, UART_R_INTEN) = 0;            /* Disable all interrupts */
578         BIT_SET (port, UART_R_CON, UARTEN | SIRDIS); /* Enable UART */
579
580         for (; count-- > 0; ++s) {
581                 while (UR (port, UART_R_STATUS) & nTxRdy)
582                         ;
583                 UR (port, UART_R_DATA) = *s;
584                 if (*s == '\n') {
585                         while ((UR (port, UART_R_STATUS) & TxBusy))
586                                 ;
587                         UR (port, UART_R_DATA) = '\r';
588                 }
589         }
590
591                                 /* Wait until all characters are sent */
592         while (UR (port, UART_R_STATUS) & TxBusy)
593                 ;
594
595                                 /* Restore control and interrupt mask */
596         UR (port, UART_R_CON) = con;
597         UR (port, UART_R_INTEN) = inten;
598 }
599
600 static void __init lh7a40xuart_console_get_options (struct uart_port* port,
601                                                     int* baud,
602                                                     int* parity,
603                                                     int* bits)
604 {
605         if (UR (port, UART_R_CON) & UARTEN) {
606                 unsigned int fcon = UR (port, UART_R_FCON);
607                 unsigned int quot = UR (port, UART_R_BRCON) + 1;
608
609                 switch (fcon & (PEN | EPS)) {
610                 default:        *parity = 'n'; break;
611                 case PEN:       *parity = 'o'; break;
612                 case PEN | EPS: *parity = 'e'; break;
613                 }
614
615                 switch (fcon & WLEN) {
616                 default:
617                 case WLEN_8: *bits = 8; break;
618                 case WLEN_7: *bits = 7; break;
619                 case WLEN_6: *bits = 6; break;
620                 case WLEN_5: *bits = 5; break;
621                 }
622
623                 *baud = port->uartclk/(16*quot);
624         }
625 }
626
627 static int __init lh7a40xuart_console_setup (struct console* co, char* options)
628 {
629         struct uart_port* port;
630         int baud = 38400;
631         int bits = 8;
632         int parity = 'n';
633         int flow = 'n';
634
635         if (co->index >= DEV_NR) /* Bounds check on device number */
636                 co->index = 0;
637         port = &lh7a40x_ports[co->index].port;
638
639         if (options)
640                 uart_parse_options (options, &baud, &parity, &bits, &flow);
641         else
642                 lh7a40xuart_console_get_options (port, &baud, &parity, &bits);
643
644         return uart_set_options (port, co, baud, parity, bits, flow);
645 }
646
647 extern struct uart_driver lh7a40x_reg;
648 static struct console lh7a40x_console = {
649         .name           = "ttyAM",
650         .write          = lh7a40xuart_console_write,
651         .device         = uart_console_device,
652         .setup          = lh7a40xuart_console_setup,
653         .flags          = CON_PRINTBUFFER,
654         .index          = -1,
655         .data           = &lh7a40x_reg,
656 };
657
658 static int __init lh7a40xuart_console_init(void)
659 {
660         register_console (&lh7a40x_console);
661         return 0;
662 }
663
664 console_initcall (lh7a40xuart_console_init);
665
666 #endif
667
668 static struct uart_driver lh7a40x_reg = {
669         .owner                  = THIS_MODULE,
670         .driver_name            = "ttyAM",
671         .dev_name               = "ttyAM",
672         .major                  = DEV_MAJOR,
673         .minor                  = DEV_MINOR,
674         .nr                     = DEV_NR,
675         .cons                   = LH7A40X_CONSOLE,
676 };
677
678 static int __init lh7a40xuart_init(void)
679 {
680         int ret;
681
682         printk (KERN_INFO "serial: LH7A40X serial driver\n");
683
684         ret = uart_register_driver (&lh7a40x_reg);
685
686         if (ret == 0) {
687                 int i;
688
689                 for (i = 0; i < DEV_NR; i++)
690                         uart_add_one_port (&lh7a40x_reg,
691                                            &lh7a40x_ports[i].port);
692         }
693         return ret;
694 }
695
696 static void __exit lh7a40xuart_exit(void)
697 {
698         int i;
699
700         for (i = 0; i < DEV_NR; i++)
701                 uart_remove_one_port (&lh7a40x_reg, &lh7a40x_ports[i].port);
702
703         uart_unregister_driver (&lh7a40x_reg);
704 }
705
706 module_init (lh7a40xuart_init);
707 module_exit (lh7a40xuart_exit);
708
709 MODULE_AUTHOR ("Marc Singer");
710 MODULE_DESCRIPTION ("Sharp LH7A40X serial port driver");
711 MODULE_LICENSE ("GPL");