Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6
[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)
116 {
117         BIT_CLR (port, UART_R_INTEN, TxInt);
118 }
119
120 static void lh7a40xuart_start_tx (struct uart_port* port)
121 {
122         BIT_SET (port, UART_R_INTEN, TxInt);
123
124         /* *** FIXME: do I need to check for startup of the
125                       transmitter?  The old driver did, but AMBA
126                       doesn't . */
127 }
128
129 static void lh7a40xuart_stop_rx (struct uart_port* port)
130 {
131         BIT_SET (port, UART_R_INTEN, RxTimeoutInt | RxInt);
132 }
133
134 static void lh7a40xuart_enable_ms (struct uart_port* port)
135 {
136         BIT_SET (port, UART_R_INTEN, ModemInt);
137 }
138
139 static void
140 #ifdef SUPPORT_SYSRQ
141 lh7a40xuart_rx_chars (struct uart_port* port, struct pt_regs* regs)
142 #else
143 lh7a40xuart_rx_chars (struct uart_port* port)
144 #endif
145 {
146         struct tty_struct* tty = port->info->tty;
147         int cbRxMax = 256;      /* (Gross) limit on receive */
148         unsigned int data, flag;/* Received data and status */
149
150         while (!(UR (port, UART_R_STATUS) & nRxRdy) && --cbRxMax) {
151                 if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
152                         if (tty->low_latency)
153                                 tty_flip_buffer_push(tty);
154                         /*
155                          * If this failed then we will throw away the
156                          * bytes but must do so to clear interrupts
157                          */
158                 }
159
160                 data = UR (port, UART_R_DATA);
161                 flag = TTY_NORMAL;
162                 ++port->icount.rx;
163
164                 if (unlikely(data & RxError)) { /* Quick check, short-circuit */
165                         if (data & RxBreak) {
166                                 data &= ~(RxFramingError | RxParityError);
167                                 ++port->icount.brk;
168                                 if (uart_handle_break (port))
169                                         continue;
170                         }
171                         else if (data & RxParityError)
172                                 ++port->icount.parity;
173                         else if (data & RxFramingError)
174                                 ++port->icount.frame;
175                         if (data & RxOverrunError)
176                                 ++port->icount.overrun;
177
178                                 /* Mask by termios, leave Rx'd byte */
179                         data &= port->read_status_mask | 0xff;
180
181                         if (data & RxBreak)
182                                 flag = TTY_BREAK;
183                         else if (data & RxParityError)
184                                 flag = TTY_PARITY;
185                         else if (data & RxFramingError)
186                                 flag = TTY_FRAME;
187                 }
188
189                 if (uart_handle_sysrq_char (port, (unsigned char) data, regs))
190                         continue;
191
192                 uart_insert_char(port, data, RxOverrunError, data, flag);
193         }
194         tty_flip_buffer_push (tty);
195         return;
196 }
197
198 static void lh7a40xuart_tx_chars (struct uart_port* port)
199 {
200         struct circ_buf* xmit = &port->info->xmit;
201         int cbTxMax = port->fifosize;
202
203         if (port->x_char) {
204                 UR (port, UART_R_DATA) = port->x_char;
205                 ++port->icount.tx;
206                 port->x_char = 0;
207                 return;
208         }
209         if (uart_circ_empty (xmit) || uart_tx_stopped (port)) {
210                 lh7a40xuart_stop_tx (port);
211                 return;
212         }
213
214         /* Unlike the AMBA UART, the lh7a40x UART does not guarantee
215            that at least half of the FIFO is empty.  Instead, we check
216            status for every character.  Using the AMBA method causes
217            the transmitter to drop characters. */
218
219         do {
220                 UR (port, UART_R_DATA) = xmit->buf[xmit->tail];
221                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
222                 ++port->icount.tx;
223                 if (uart_circ_empty(xmit))
224                         break;
225         } while (!(UR (port, UART_R_STATUS) & nTxRdy)
226                  && cbTxMax--);
227
228         if (uart_circ_chars_pending (xmit) < WAKEUP_CHARS)
229                 uart_write_wakeup (port);
230
231         if (uart_circ_empty (xmit))
232                 lh7a40xuart_stop_tx (port);
233 }
234
235 static void lh7a40xuart_modem_status (struct uart_port* port)
236 {
237         unsigned int status = UR (port, UART_R_STATUS);
238         unsigned int delta
239                 = status ^ ((struct uart_port_lh7a40x*) port)->statusPrev;
240
241         BIT_SET (port, UART_R_RAWISR, MSEOI); /* Clear modem status intr */
242
243         if (!delta)             /* Only happens if we missed 2 transitions */
244                 return;
245
246         ((struct uart_port_lh7a40x*) port)->statusPrev = status;
247
248         if (delta & DCD)
249                 uart_handle_dcd_change (port, status & DCD);
250
251         if (delta & DSR)
252                 ++port->icount.dsr;
253
254         if (delta & CTS)
255                 uart_handle_cts_change (port, status & CTS);
256
257         wake_up_interruptible (&port->info->delta_msr_wait);
258 }
259
260 static irqreturn_t lh7a40xuart_int (int irq, void* dev_id,
261                                     struct pt_regs* regs)
262 {
263         struct uart_port* port = dev_id;
264         unsigned int cLoopLimit = ISR_LOOP_LIMIT;
265         unsigned int isr = UR (port, UART_R_ISR);
266
267
268         do {
269                 if (isr & (RxInt | RxTimeoutInt))
270 #ifdef SUPPORT_SYSRQ
271                         lh7a40xuart_rx_chars(port, regs);
272 #else
273                         lh7a40xuart_rx_chars(port);
274 #endif
275                 if (isr & ModemInt)
276                         lh7a40xuart_modem_status (port);
277                 if (isr & TxInt)
278                         lh7a40xuart_tx_chars (port);
279
280                 if (--cLoopLimit == 0)
281                         break;
282
283                 isr = UR (port, UART_R_ISR);
284         } while (isr & (RxInt | TxInt | RxTimeoutInt));
285
286         return IRQ_HANDLED;
287 }
288
289 static unsigned int lh7a40xuart_tx_empty (struct uart_port* port)
290 {
291         return (UR (port, UART_R_STATUS) & TxEmpty) ? TIOCSER_TEMT : 0;
292 }
293
294 static unsigned int lh7a40xuart_get_mctrl (struct uart_port* port)
295 {
296         unsigned int result = 0;
297         unsigned int status = UR (port, UART_R_STATUS);
298
299         if (status & DCD)
300                 result |= TIOCM_CAR;
301         if (status & DSR)
302                 result |= TIOCM_DSR;
303         if (status & CTS)
304                 result |= TIOCM_CTS;
305
306         return result;
307 }
308
309 static void lh7a40xuart_set_mctrl (struct uart_port* port, unsigned int mctrl)
310 {
311         /* None of the ports supports DTR. UART1 supports RTS through GPIO. */
312         /* Note, kernel appears to be setting DTR and RTS on console. */
313
314         /* *** FIXME: this deserves more work.  There's some work in
315                tracing all of the IO pins. */
316 #if 0
317         if( port->mapbase == UART1_PHYS) {
318                 gpioRegs_t *gpio = (gpioRegs_t *)IO_ADDRESS(GPIO_PHYS);
319
320                 if (mctrl & TIOCM_RTS)
321                         gpio->pbdr &= ~GPIOB_UART1_RTS;
322                 else
323                         gpio->pbdr |= GPIOB_UART1_RTS;
324         }
325 #endif
326 }
327
328 static void lh7a40xuart_break_ctl (struct uart_port* port, int break_state)
329 {
330         unsigned long flags;
331
332         spin_lock_irqsave(&port->lock, flags);
333         if (break_state == -1)
334                 BIT_SET (port, UART_R_FCON, BRK); /* Assert break */
335         else
336                 BIT_CLR (port, UART_R_FCON, BRK); /* Deassert break */
337         spin_unlock_irqrestore(&port->lock, flags);
338 }
339
340 static int lh7a40xuart_startup (struct uart_port* port)
341 {
342         int retval;
343
344         retval = request_irq (port->irq, lh7a40xuart_int, 0,
345                               "serial_lh7a40x", port);
346         if (retval)
347                 return retval;
348
349                                 /* Initial modem control-line settings */
350         ((struct uart_port_lh7a40x*) port)->statusPrev
351                 = UR (port, UART_R_STATUS);
352
353         /* There is presently no configuration option to enable IR.
354            Thus, we always disable it. */
355
356         BIT_SET (port, UART_R_CON, UARTEN | SIRDIS);
357         BIT_SET (port, UART_R_INTEN, RxTimeoutInt | RxInt);
358
359         return 0;
360 }
361
362 static void lh7a40xuart_shutdown (struct uart_port* port)
363 {
364         free_irq (port->irq, port);
365         BIT_CLR (port, UART_R_FCON, BRK | FEN);
366         BIT_CLR (port, UART_R_CON, UARTEN);
367 }
368
369 static void lh7a40xuart_set_termios (struct uart_port* port,
370                                      struct termios* termios,
371                                      struct termios* old)
372 {
373         unsigned int con;
374         unsigned int inten;
375         unsigned int fcon;
376         unsigned long flags;
377         unsigned int baud;
378         unsigned int quot;
379
380         baud = uart_get_baud_rate (port, termios, old, 8, port->uartclk/16);
381         quot = uart_get_divisor (port, baud); /* -1 performed elsewhere */
382
383         switch (termios->c_cflag & CSIZE) {
384         case CS5:
385                 fcon = WLEN_5;
386                 break;
387         case CS6:
388                 fcon = WLEN_6;
389                 break;
390         case CS7:
391                 fcon = WLEN_7;
392                 break;
393         case CS8:
394         default:
395                 fcon = WLEN_8;
396                 break;
397         }
398         if (termios->c_cflag & CSTOPB)
399                 fcon |= STP2;
400         if (termios->c_cflag & PARENB) {
401                 fcon |= PEN;
402                 if (!(termios->c_cflag & PARODD))
403                         fcon |= EPS;
404         }
405         if (port->fifosize > 1)
406                 fcon |= FEN;
407
408         spin_lock_irqsave (&port->lock, flags);
409
410         uart_update_timeout (port, termios->c_cflag, baud);
411
412         port->read_status_mask = RxOverrunError;
413         if (termios->c_iflag & INPCK)
414                 port->read_status_mask |= RxFramingError | RxParityError;
415         if (termios->c_iflag & (BRKINT | PARMRK))
416                 port->read_status_mask |= RxBreak;
417
418                 /* Figure mask for status we ignore */
419         port->ignore_status_mask = 0;
420         if (termios->c_iflag & IGNPAR)
421                 port->ignore_status_mask |= RxFramingError | RxParityError;
422         if (termios->c_iflag & IGNBRK) {
423                 port->ignore_status_mask |= RxBreak;
424                 /* Ignore overrun when ignorning parity */
425                 /* *** FIXME: is this in the right place? */
426                 if (termios->c_iflag & IGNPAR)
427                         port->ignore_status_mask |= RxOverrunError;
428         }
429
430                 /* Ignore all receive errors when receive disabled */
431         if ((termios->c_cflag & CREAD) == 0)
432                 port->ignore_status_mask |= RxError;
433
434         con   = UR (port, UART_R_CON);
435         inten = (UR (port, UART_R_INTEN) & ~ModemInt);
436
437         if (UART_ENABLE_MS (port, termios->c_cflag))
438                 inten |= ModemInt;
439
440         BIT_CLR (port, UART_R_CON, UARTEN);     /* Disable UART */
441         UR (port, UART_R_INTEN) = 0;            /* Disable interrupts */
442         UR (port, UART_R_BRCON) = quot - 1;     /* Set baud rate divisor */
443         UR (port, UART_R_FCON)  = fcon;         /* Set FIFO and frame ctrl */
444         UR (port, UART_R_INTEN) = inten;        /* Enable interrupts */
445         UR (port, UART_R_CON)   = con;          /* Restore UART mode */
446
447         spin_unlock_irqrestore(&port->lock, flags);
448 }
449
450 static const char* lh7a40xuart_type (struct uart_port* port)
451 {
452         return port->type == PORT_LH7A40X ? "LH7A40X" : NULL;
453 }
454
455 static void lh7a40xuart_release_port (struct uart_port* port)
456 {
457         release_mem_region (port->mapbase, UART_REG_SIZE);
458 }
459
460 static int lh7a40xuart_request_port (struct uart_port* port)
461 {
462         return request_mem_region (port->mapbase, UART_REG_SIZE,
463                                    "serial_lh7a40x") != NULL
464                 ? 0 : -EBUSY;
465 }
466
467 static void lh7a40xuart_config_port (struct uart_port* port, int flags)
468 {
469         if (flags & UART_CONFIG_TYPE) {
470                 port->type = PORT_LH7A40X;
471                 lh7a40xuart_request_port (port);
472         }
473 }
474
475 static int lh7a40xuart_verify_port (struct uart_port* port,
476                                     struct serial_struct* ser)
477 {
478         int ret = 0;
479
480         if (ser->type != PORT_UNKNOWN && ser->type != PORT_LH7A40X)
481                 ret = -EINVAL;
482         if (ser->irq < 0 || ser->irq >= NR_IRQS)
483                 ret = -EINVAL;
484         if (ser->baud_base < 9600) /* *** FIXME: is this true? */
485                 ret = -EINVAL;
486         return ret;
487 }
488
489 static struct uart_ops lh7a40x_uart_ops = {
490         .tx_empty       = lh7a40xuart_tx_empty,
491         .set_mctrl      = lh7a40xuart_set_mctrl,
492         .get_mctrl      = lh7a40xuart_get_mctrl,
493         .stop_tx        = lh7a40xuart_stop_tx,
494         .start_tx       = lh7a40xuart_start_tx,
495         .stop_rx        = lh7a40xuart_stop_rx,
496         .enable_ms      = lh7a40xuart_enable_ms,
497         .break_ctl      = lh7a40xuart_break_ctl,
498         .startup        = lh7a40xuart_startup,
499         .shutdown       = lh7a40xuart_shutdown,
500         .set_termios    = lh7a40xuart_set_termios,
501         .type           = lh7a40xuart_type,
502         .release_port   = lh7a40xuart_release_port,
503         .request_port   = lh7a40xuart_request_port,
504         .config_port    = lh7a40xuart_config_port,
505         .verify_port    = lh7a40xuart_verify_port,
506 };
507
508 static struct uart_port_lh7a40x lh7a40x_ports[DEV_NR] = {
509         {
510                 .port = {
511                         .membase        = (void*) io_p2v (UART1_PHYS),
512                         .mapbase        = UART1_PHYS,
513                         .iotype         = SERIAL_IO_MEM,
514                         .irq            = IRQ_UART1INTR,
515                         .uartclk        = 14745600/2,
516                         .fifosize       = 16,
517                         .ops            = &lh7a40x_uart_ops,
518                         .flags          = ASYNC_BOOT_AUTOCONF,
519                         .line           = 0,
520                 },
521         },
522         {
523                 .port = {
524                         .membase        = (void*) io_p2v (UART2_PHYS),
525                         .mapbase        = UART2_PHYS,
526                         .iotype         = SERIAL_IO_MEM,
527                         .irq            = IRQ_UART2INTR,
528                         .uartclk        = 14745600/2,
529                         .fifosize       = 16,
530                         .ops            = &lh7a40x_uart_ops,
531                         .flags          = ASYNC_BOOT_AUTOCONF,
532                         .line           = 1,
533                 },
534         },
535         {
536                 .port = {
537                         .membase        = (void*) io_p2v (UART3_PHYS),
538                         .mapbase        = UART3_PHYS,
539                         .iotype         = SERIAL_IO_MEM,
540                         .irq            = IRQ_UART3INTR,
541                         .uartclk        = 14745600/2,
542                         .fifosize       = 16,
543                         .ops            = &lh7a40x_uart_ops,
544                         .flags          = ASYNC_BOOT_AUTOCONF,
545                         .line           = 2,
546                 },
547         },
548 };
549
550 #ifndef CONFIG_SERIAL_LH7A40X_CONSOLE
551 # define LH7A40X_CONSOLE NULL
552 #else
553 # define LH7A40X_CONSOLE &lh7a40x_console
554
555
556 static void lh7a40xuart_console_write (struct console* co,
557                                        const char* s,
558                                        unsigned int count)
559 {
560         struct uart_port* port = &lh7a40x_ports[co->index].port;
561         unsigned int con = UR (port, UART_R_CON);
562         unsigned int inten = UR (port, UART_R_INTEN);
563
564
565         UR (port, UART_R_INTEN) = 0;            /* Disable all interrupts */
566         BIT_SET (port, UART_R_CON, UARTEN | SIRDIS); /* Enable UART */
567
568         for (; count-- > 0; ++s) {
569                 while (UR (port, UART_R_STATUS) & nTxRdy)
570                         ;
571                 UR (port, UART_R_DATA) = *s;
572                 if (*s == '\n') {
573                         while ((UR (port, UART_R_STATUS) & TxBusy))
574                                 ;
575                         UR (port, UART_R_DATA) = '\r';
576                 }
577         }
578
579                                 /* Wait until all characters are sent */
580         while (UR (port, UART_R_STATUS) & TxBusy)
581                 ;
582
583                                 /* Restore control and interrupt mask */
584         UR (port, UART_R_CON) = con;
585         UR (port, UART_R_INTEN) = inten;
586 }
587
588 static void __init lh7a40xuart_console_get_options (struct uart_port* port,
589                                                     int* baud,
590                                                     int* parity,
591                                                     int* bits)
592 {
593         if (UR (port, UART_R_CON) & UARTEN) {
594                 unsigned int fcon = UR (port, UART_R_FCON);
595                 unsigned int quot = UR (port, UART_R_BRCON) + 1;
596
597                 switch (fcon & (PEN | EPS)) {
598                 default:        *parity = 'n'; break;
599                 case PEN:       *parity = 'o'; break;
600                 case PEN | EPS: *parity = 'e'; break;
601                 }
602
603                 switch (fcon & WLEN) {
604                 default:
605                 case WLEN_8: *bits = 8; break;
606                 case WLEN_7: *bits = 7; break;
607                 case WLEN_6: *bits = 6; break;
608                 case WLEN_5: *bits = 5; break;
609                 }
610
611                 *baud = port->uartclk/(16*quot);
612         }
613 }
614
615 static int __init lh7a40xuart_console_setup (struct console* co, char* options)
616 {
617         struct uart_port* port;
618         int baud = 38400;
619         int bits = 8;
620         int parity = 'n';
621         int flow = 'n';
622
623         if (co->index >= DEV_NR) /* Bounds check on device number */
624                 co->index = 0;
625         port = &lh7a40x_ports[co->index].port;
626
627         if (options)
628                 uart_parse_options (options, &baud, &parity, &bits, &flow);
629         else
630                 lh7a40xuart_console_get_options (port, &baud, &parity, &bits);
631
632         return uart_set_options (port, co, baud, parity, bits, flow);
633 }
634
635 static struct uart_driver lh7a40x_reg;
636 static struct console lh7a40x_console = {
637         .name           = "ttyAM",
638         .write          = lh7a40xuart_console_write,
639         .device         = uart_console_device,
640         .setup          = lh7a40xuart_console_setup,
641         .flags          = CON_PRINTBUFFER,
642         .index          = -1,
643         .data           = &lh7a40x_reg,
644 };
645
646 static int __init lh7a40xuart_console_init(void)
647 {
648         register_console (&lh7a40x_console);
649         return 0;
650 }
651
652 console_initcall (lh7a40xuart_console_init);
653
654 #endif
655
656 static struct uart_driver lh7a40x_reg = {
657         .owner                  = THIS_MODULE,
658         .driver_name            = "ttyAM",
659         .dev_name               = "ttyAM",
660         .major                  = DEV_MAJOR,
661         .minor                  = DEV_MINOR,
662         .nr                     = DEV_NR,
663         .cons                   = LH7A40X_CONSOLE,
664 };
665
666 static int __init lh7a40xuart_init(void)
667 {
668         int ret;
669
670         printk (KERN_INFO "serial: LH7A40X serial driver\n");
671
672         ret = uart_register_driver (&lh7a40x_reg);
673
674         if (ret == 0) {
675                 int i;
676
677                 for (i = 0; i < DEV_NR; i++)
678                         uart_add_one_port (&lh7a40x_reg,
679                                            &lh7a40x_ports[i].port);
680         }
681         return ret;
682 }
683
684 static void __exit lh7a40xuart_exit(void)
685 {
686         int i;
687
688         for (i = 0; i < DEV_NR; i++)
689                 uart_remove_one_port (&lh7a40x_reg, &lh7a40x_ports[i].port);
690
691         uart_unregister_driver (&lh7a40x_reg);
692 }
693
694 module_init (lh7a40xuart_init);
695 module_exit (lh7a40xuart_exit);
696
697 MODULE_AUTHOR ("Marc Singer");
698 MODULE_DESCRIPTION ("Sharp LH7A40X serial port driver");
699 MODULE_LICENSE ("GPL");