2 * drivers/serial/sb1250-duart.c
4 * Support for the asynchronous serial interface (DUART) included
5 * in the BCM1250 and derived System-On-a-Chip (SOC) devices.
7 * Copyright (c) 2007 Maciej W. Rozycki
9 * Derived from drivers/char/sb1250_duart.c for which the following
12 * Copyright (c) 2000, 2001, 2002, 2003, 2004 Broadcom Corporation
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version
17 * 2 of the License, or (at your option) any later version.
21 * "BCM1250/BCM1125/BCM1125H User Manual", Broadcom Corporation
24 #if defined(CONFIG_SERIAL_SB1250_DUART_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
28 #include <linux/console.h>
29 #include <linux/delay.h>
30 #include <linux/errno.h>
31 #include <linux/init.h>
32 #include <linux/interrupt.h>
33 #include <linux/ioport.h>
34 #include <linux/kernel.h>
35 #include <linux/major.h>
36 #include <linux/serial.h>
37 #include <linux/serial_core.h>
38 #include <linux/spinlock.h>
39 #include <linux/sysrq.h>
40 #include <linux/tty.h>
41 #include <linux/types.h>
43 #include <asm/atomic.h>
47 #include <asm/sibyte/sb1250.h>
48 #include <asm/sibyte/sb1250_uart.h>
49 #include <asm/sibyte/swarm.h>
52 #if defined(CONFIG_SIBYTE_BCM1x55) || defined(CONFIG_SIBYTE_BCM1x80)
53 #include <asm/sibyte/bcm1480_regs.h>
54 #include <asm/sibyte/bcm1480_int.h>
56 #define SBD_CHANREGS(line) A_BCM1480_DUART_CHANREG((line), 0)
57 #define SBD_CTRLREGS(line) A_BCM1480_DUART_CTRLREG((line), 0)
58 #define SBD_INT(line) (K_BCM1480_INT_UART_0 + (line))
60 #elif defined(CONFIG_SIBYTE_SB1250) || defined(CONFIG_SIBYTE_BCM112X)
61 #include <asm/sibyte/sb1250_regs.h>
62 #include <asm/sibyte/sb1250_int.h>
64 #define SBD_CHANREGS(line) A_DUART_CHANREG((line), 0)
65 #define SBD_CTRLREGS(line) A_DUART_CTRLREG(0)
66 #define SBD_INT(line) (K_INT_UART_0 + (line))
69 #error invalid SB1250 UART configuration
74 MODULE_AUTHOR("Maciej W. Rozycki <macro@linux-mips.org>");
75 MODULE_DESCRIPTION("BCM1xxx on-chip DUART serial driver");
76 MODULE_LICENSE("GPL");
79 #define DUART_MAX_CHIP 2
80 #define DUART_MAX_SIDE 2
86 struct sbd_duart
*duart
;
87 struct uart_port port
;
88 unsigned char __iomem
*memctrl
;
94 * Per-DUART state for the shared register space.
97 struct sbd_port sport
[2];
98 unsigned long mapctrl
;
102 #define to_sport(uport) container_of(uport, struct sbd_port, port)
104 static struct sbd_duart sbd_duarts
[DUART_MAX_CHIP
];
106 #define __unused __attribute__((__unused__))
110 * Reading and writing SB1250 DUART registers.
112 * There are three register spaces: two per-channel ones and
113 * a shared one. We have to define accessors appropriately.
114 * All registers are 64-bit and all but the Baud Rate Clock
115 * registers only define 8 least significant bits. There is
116 * also a workaround to take into account. Raw accessors use
117 * the full register width, but cooked ones truncate it
118 * intentionally so that the rest of the driver does not care.
120 static u64
__read_sbdchn(struct sbd_port
*sport
, int reg
)
122 void __iomem
*csr
= sport
->port
.membase
+ reg
;
124 return __raw_readq(csr
);
127 static u64
__read_sbdshr(struct sbd_port
*sport
, int reg
)
129 void __iomem
*csr
= sport
->memctrl
+ reg
;
131 return __raw_readq(csr
);
134 static void __write_sbdchn(struct sbd_port
*sport
, int reg
, u64 value
)
136 void __iomem
*csr
= sport
->port
.membase
+ reg
;
138 __raw_writeq(value
, csr
);
141 static void __write_sbdshr(struct sbd_port
*sport
, int reg
, u64 value
)
143 void __iomem
*csr
= sport
->memctrl
+ reg
;
145 __raw_writeq(value
, csr
);
149 * In bug 1956, we get glitches that can mess up uart registers. This
150 * "read-mode-reg after any register access" is an accepted workaround.
152 static void __war_sbd1956(struct sbd_port
*sport
)
154 __read_sbdchn(sport
, R_DUART_MODE_REG_1
);
155 __read_sbdchn(sport
, R_DUART_MODE_REG_2
);
158 static unsigned char read_sbdchn(struct sbd_port
*sport
, int reg
)
160 unsigned char retval
;
162 retval
= __read_sbdchn(sport
, reg
);
164 __war_sbd1956(sport
);
168 static unsigned char read_sbdshr(struct sbd_port
*sport
, int reg
)
170 unsigned char retval
;
172 retval
= __read_sbdshr(sport
, reg
);
174 __war_sbd1956(sport
);
178 static void write_sbdchn(struct sbd_port
*sport
, int reg
, unsigned int value
)
180 __write_sbdchn(sport
, reg
, value
);
182 __war_sbd1956(sport
);
185 static void write_sbdshr(struct sbd_port
*sport
, int reg
, unsigned int value
)
187 __write_sbdshr(sport
, reg
, value
);
189 __war_sbd1956(sport
);
193 static int sbd_receive_ready(struct sbd_port
*sport
)
195 return read_sbdchn(sport
, R_DUART_STATUS
) & M_DUART_RX_RDY
;
198 static int sbd_receive_drain(struct sbd_port
*sport
)
202 while (sbd_receive_ready(sport
) && loops
--)
203 read_sbdchn(sport
, R_DUART_RX_HOLD
);
207 static int __unused
sbd_transmit_ready(struct sbd_port
*sport
)
209 return read_sbdchn(sport
, R_DUART_STATUS
) & M_DUART_TX_RDY
;
212 static int __unused
sbd_transmit_drain(struct sbd_port
*sport
)
216 while (!sbd_transmit_ready(sport
) && loops
--)
221 static int sbd_transmit_empty(struct sbd_port
*sport
)
223 return read_sbdchn(sport
, R_DUART_STATUS
) & M_DUART_TX_EMT
;
226 static int sbd_line_drain(struct sbd_port
*sport
)
230 while (!sbd_transmit_empty(sport
) && loops
--)
236 static unsigned int sbd_tx_empty(struct uart_port
*uport
)
238 struct sbd_port
*sport
= to_sport(uport
);
240 return sbd_transmit_empty(sport
) ? TIOCSER_TEMT
: 0;
243 static unsigned int sbd_get_mctrl(struct uart_port
*uport
)
245 struct sbd_port
*sport
= to_sport(uport
);
246 unsigned int mctrl
, status
;
248 status
= read_sbdshr(sport
, R_DUART_IN_PORT
);
249 status
>>= (uport
->line
) % 2;
250 mctrl
= (!(status
& M_DUART_IN_PIN0_VAL
) ? TIOCM_CTS
: 0) |
251 (!(status
& M_DUART_IN_PIN4_VAL
) ? TIOCM_CAR
: 0) |
252 (!(status
& M_DUART_RIN0_PIN
) ? TIOCM_RNG
: 0) |
253 (!(status
& M_DUART_IN_PIN2_VAL
) ? TIOCM_DSR
: 0);
257 static void sbd_set_mctrl(struct uart_port
*uport
, unsigned int mctrl
)
259 struct sbd_port
*sport
= to_sport(uport
);
260 unsigned int clr
= 0, set
= 0, mode2
;
262 if (mctrl
& TIOCM_DTR
)
263 set
|= M_DUART_SET_OPR2
;
265 clr
|= M_DUART_CLR_OPR2
;
266 if (mctrl
& TIOCM_RTS
)
267 set
|= M_DUART_SET_OPR0
;
269 clr
|= M_DUART_CLR_OPR0
;
270 clr
<<= (uport
->line
) % 2;
271 set
<<= (uport
->line
) % 2;
273 mode2
= read_sbdchn(sport
, R_DUART_MODE_REG_2
);
274 mode2
&= ~M_DUART_CHAN_MODE
;
275 if (mctrl
& TIOCM_LOOP
)
276 mode2
|= V_DUART_CHAN_MODE_LCL_LOOP
;
278 mode2
|= V_DUART_CHAN_MODE_NORMAL
;
280 write_sbdshr(sport
, R_DUART_CLEAR_OPR
, clr
);
281 write_sbdshr(sport
, R_DUART_SET_OPR
, set
);
282 write_sbdchn(sport
, R_DUART_MODE_REG_2
, mode2
);
285 static void sbd_stop_tx(struct uart_port
*uport
)
287 struct sbd_port
*sport
= to_sport(uport
);
289 write_sbdchn(sport
, R_DUART_CMD
, M_DUART_TX_DIS
);
290 sport
->tx_stopped
= 1;
293 static void sbd_start_tx(struct uart_port
*uport
)
295 struct sbd_port
*sport
= to_sport(uport
);
298 /* Enable tx interrupts. */
299 mask
= read_sbdshr(sport
, R_DUART_IMRREG((uport
->line
) % 2));
300 mask
|= M_DUART_IMR_TX
;
301 write_sbdshr(sport
, R_DUART_IMRREG((uport
->line
) % 2), mask
);
303 /* Go!, go!, go!... */
304 write_sbdchn(sport
, R_DUART_CMD
, M_DUART_TX_EN
);
305 sport
->tx_stopped
= 0;
308 static void sbd_stop_rx(struct uart_port
*uport
)
310 struct sbd_port
*sport
= to_sport(uport
);
312 write_sbdshr(sport
, R_DUART_IMRREG((uport
->line
) % 2), 0);
315 static void sbd_enable_ms(struct uart_port
*uport
)
317 struct sbd_port
*sport
= to_sport(uport
);
319 write_sbdchn(sport
, R_DUART_AUXCTL_X
,
320 M_DUART_CIN_CHNG_ENA
| M_DUART_CTS_CHNG_ENA
);
323 static void sbd_break_ctl(struct uart_port
*uport
, int break_state
)
325 struct sbd_port
*sport
= to_sport(uport
);
327 if (break_state
== -1)
328 write_sbdchn(sport
, R_DUART_CMD
, V_DUART_MISC_CMD_START_BREAK
);
330 write_sbdchn(sport
, R_DUART_CMD
, V_DUART_MISC_CMD_STOP_BREAK
);
334 static void sbd_receive_chars(struct sbd_port
*sport
)
336 struct uart_port
*uport
= &sport
->port
;
337 struct uart_icount
*icount
;
338 unsigned int status
, ch
, flag
;
341 for (count
= 16; count
; count
--) {
342 status
= read_sbdchn(sport
, R_DUART_STATUS
);
343 if (!(status
& M_DUART_RX_RDY
))
346 ch
= read_sbdchn(sport
, R_DUART_RX_HOLD
);
350 icount
= &uport
->icount
;
353 if (unlikely(status
&
354 (M_DUART_RCVD_BRK
| M_DUART_FRM_ERR
|
355 M_DUART_PARITY_ERR
| M_DUART_OVRUN_ERR
))) {
356 if (status
& M_DUART_RCVD_BRK
) {
358 if (uart_handle_break(uport
))
360 } else if (status
& M_DUART_FRM_ERR
)
362 else if (status
& M_DUART_PARITY_ERR
)
364 if (status
& M_DUART_OVRUN_ERR
)
367 status
&= uport
->read_status_mask
;
368 if (status
& M_DUART_RCVD_BRK
)
370 else if (status
& M_DUART_FRM_ERR
)
372 else if (status
& M_DUART_PARITY_ERR
)
376 if (uart_handle_sysrq_char(uport
, ch
))
379 uart_insert_char(uport
, status
, M_DUART_OVRUN_ERR
, ch
, flag
);
382 tty_flip_buffer_push(uport
->info
->tty
);
385 static void sbd_transmit_chars(struct sbd_port
*sport
)
387 struct uart_port
*uport
= &sport
->port
;
388 struct circ_buf
*xmit
= &sport
->port
.info
->xmit
;
392 /* XON/XOFF chars. */
393 if (sport
->port
.x_char
) {
394 write_sbdchn(sport
, R_DUART_TX_HOLD
, sport
->port
.x_char
);
395 sport
->port
.icount
.tx
++;
396 sport
->port
.x_char
= 0;
400 /* If nothing to do or stopped or hardware stopped. */
401 stop_tx
= (uart_circ_empty(xmit
) || uart_tx_stopped(&sport
->port
));
405 write_sbdchn(sport
, R_DUART_TX_HOLD
, xmit
->buf
[xmit
->tail
]);
406 xmit
->tail
= (xmit
->tail
+ 1) & (UART_XMIT_SIZE
- 1);
407 sport
->port
.icount
.tx
++;
409 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
410 uart_write_wakeup(&sport
->port
);
413 /* Are we are done? */
414 if (stop_tx
|| uart_circ_empty(xmit
)) {
415 /* Disable tx interrupts. */
416 mask
= read_sbdshr(sport
, R_DUART_IMRREG((uport
->line
) % 2));
417 mask
&= ~M_DUART_IMR_TX
;
418 write_sbdshr(sport
, R_DUART_IMRREG((uport
->line
) % 2), mask
);
422 static void sbd_status_handle(struct sbd_port
*sport
)
424 struct uart_port
*uport
= &sport
->port
;
427 delta
= read_sbdshr(sport
, R_DUART_INCHREG((uport
->line
) % 2));
428 delta
>>= (uport
->line
) % 2;
430 if (delta
& (M_DUART_IN_PIN0_VAL
<< S_DUART_IN_PIN_CHNG
))
431 uart_handle_cts_change(uport
, !(delta
& M_DUART_IN_PIN0_VAL
));
433 if (delta
& (M_DUART_IN_PIN2_VAL
<< S_DUART_IN_PIN_CHNG
))
436 if (delta
& ((M_DUART_IN_PIN2_VAL
| M_DUART_IN_PIN0_VAL
) <<
437 S_DUART_IN_PIN_CHNG
))
438 wake_up_interruptible(&uport
->info
->delta_msr_wait
);
441 static irqreturn_t
sbd_interrupt(int irq
, void *dev_id
)
443 struct sbd_port
*sport
= dev_id
;
444 struct uart_port
*uport
= &sport
->port
;
445 irqreturn_t status
= IRQ_NONE
;
446 unsigned int intstat
;
449 for (count
= 16; count
; count
--) {
450 intstat
= read_sbdshr(sport
,
451 R_DUART_ISRREG((uport
->line
) % 2));
452 intstat
&= read_sbdshr(sport
,
453 R_DUART_IMRREG((uport
->line
) % 2));
454 intstat
&= M_DUART_ISR_ALL
;
458 if (intstat
& M_DUART_ISR_RX
)
459 sbd_receive_chars(sport
);
460 if (intstat
& M_DUART_ISR_IN
)
461 sbd_status_handle(sport
);
462 if (intstat
& M_DUART_ISR_TX
)
463 sbd_transmit_chars(sport
);
465 status
= IRQ_HANDLED
;
472 static int sbd_startup(struct uart_port
*uport
)
474 struct sbd_port
*sport
= to_sport(uport
);
478 ret
= request_irq(sport
->port
.irq
, sbd_interrupt
,
479 IRQF_SHARED
, "sb1250-duart", sport
);
483 /* Clear the receive FIFO. */
484 sbd_receive_drain(sport
);
486 /* Clear the interrupt registers. */
487 write_sbdchn(sport
, R_DUART_CMD
, V_DUART_MISC_CMD_RESET_BREAK_INT
);
488 read_sbdshr(sport
, R_DUART_INCHREG((uport
->line
) % 2));
490 /* Set rx/tx interrupt to FIFO available. */
491 mode1
= read_sbdchn(sport
, R_DUART_MODE_REG_1
);
492 mode1
&= ~(M_DUART_RX_IRQ_SEL_RXFULL
| M_DUART_TX_IRQ_SEL_TXEMPT
);
493 write_sbdchn(sport
, R_DUART_MODE_REG_1
, mode1
);
495 /* Disable tx, enable rx. */
496 write_sbdchn(sport
, R_DUART_CMD
, M_DUART_TX_DIS
| M_DUART_RX_EN
);
497 sport
->tx_stopped
= 1;
499 /* Enable interrupts. */
500 write_sbdshr(sport
, R_DUART_IMRREG((uport
->line
) % 2),
501 M_DUART_IMR_IN
| M_DUART_IMR_RX
);
506 static void sbd_shutdown(struct uart_port
*uport
)
508 struct sbd_port
*sport
= to_sport(uport
);
510 write_sbdchn(sport
, R_DUART_CMD
, M_DUART_TX_DIS
| M_DUART_RX_DIS
);
511 sport
->tx_stopped
= 1;
512 free_irq(sport
->port
.irq
, sport
);
516 static void sbd_init_port(struct sbd_port
*sport
)
518 struct uart_port
*uport
= &sport
->port
;
520 if (sport
->initialised
)
523 /* There is no DUART reset feature, so just set some sane defaults. */
524 write_sbdchn(sport
, R_DUART_CMD
, V_DUART_MISC_CMD_RESET_TX
);
525 write_sbdchn(sport
, R_DUART_CMD
, V_DUART_MISC_CMD_RESET_RX
);
526 write_sbdchn(sport
, R_DUART_MODE_REG_1
, V_DUART_BITS_PER_CHAR_8
);
527 write_sbdchn(sport
, R_DUART_MODE_REG_2
, 0);
528 write_sbdchn(sport
, R_DUART_FULL_CTL
,
529 V_DUART_INT_TIME(0) | V_DUART_SIG_FULL(15));
530 write_sbdchn(sport
, R_DUART_OPCR_X
, 0);
531 write_sbdchn(sport
, R_DUART_AUXCTL_X
, 0);
532 write_sbdshr(sport
, R_DUART_IMRREG((uport
->line
) % 2), 0);
534 sport
->initialised
= 1;
537 static void sbd_set_termios(struct uart_port
*uport
, struct ktermios
*termios
,
538 struct ktermios
*old_termios
)
540 struct sbd_port
*sport
= to_sport(uport
);
541 unsigned int mode1
= 0, mode2
= 0, aux
= 0;
542 unsigned int mode1mask
= 0, mode2mask
= 0, auxmask
= 0;
543 unsigned int oldmode1
, oldmode2
, oldaux
;
544 unsigned int baud
, brg
;
545 unsigned int command
;
547 mode1mask
|= ~(M_DUART_PARITY_MODE
| M_DUART_PARITY_TYPE_ODD
|
548 M_DUART_BITS_PER_CHAR
);
549 mode2mask
|= ~M_DUART_STOP_BIT_LEN_2
;
550 auxmask
|= ~M_DUART_CTS_CHNG_ENA
;
553 switch (termios
->c_cflag
& CSIZE
) {
556 /* Unsupported, leave unchanged. */
557 mode1mask
|= M_DUART_PARITY_MODE
;
560 mode1
|= V_DUART_BITS_PER_CHAR_7
;
564 mode1
|= V_DUART_BITS_PER_CHAR_8
;
568 /* Parity and stop bits. */
569 if (termios
->c_cflag
& CSTOPB
)
570 mode2
|= M_DUART_STOP_BIT_LEN_2
;
572 mode2
|= M_DUART_STOP_BIT_LEN_1
;
573 if (termios
->c_cflag
& PARENB
)
574 mode1
|= V_DUART_PARITY_MODE_ADD
;
576 mode1
|= V_DUART_PARITY_MODE_NONE
;
577 if (termios
->c_cflag
& PARODD
)
578 mode1
|= M_DUART_PARITY_TYPE_ODD
;
580 mode1
|= M_DUART_PARITY_TYPE_EVEN
;
582 baud
= uart_get_baud_rate(uport
, termios
, old_termios
, 1200, 5000000);
583 brg
= V_DUART_BAUD_RATE(baud
);
584 /* The actual lower bound is 1221bps, so compensate. */
585 if (brg
> M_DUART_CLK_COUNTER
)
586 brg
= M_DUART_CLK_COUNTER
;
588 uart_update_timeout(uport
, termios
->c_cflag
, baud
);
590 uport
->read_status_mask
= M_DUART_OVRUN_ERR
;
591 if (termios
->c_iflag
& INPCK
)
592 uport
->read_status_mask
|= M_DUART_FRM_ERR
|
594 if (termios
->c_iflag
& (BRKINT
| PARMRK
))
595 uport
->read_status_mask
|= M_DUART_RCVD_BRK
;
597 uport
->ignore_status_mask
= 0;
598 if (termios
->c_iflag
& IGNPAR
)
599 uport
->ignore_status_mask
|= M_DUART_FRM_ERR
|
601 if (termios
->c_iflag
& IGNBRK
) {
602 uport
->ignore_status_mask
|= M_DUART_RCVD_BRK
;
603 if (termios
->c_iflag
& IGNPAR
)
604 uport
->ignore_status_mask
|= M_DUART_OVRUN_ERR
;
607 if (termios
->c_cflag
& CREAD
)
608 command
= M_DUART_RX_EN
;
610 command
= M_DUART_RX_DIS
;
612 if (termios
->c_cflag
& CRTSCTS
)
613 aux
|= M_DUART_CTS_CHNG_ENA
;
615 aux
&= ~M_DUART_CTS_CHNG_ENA
;
617 spin_lock(&uport
->lock
);
619 if (sport
->tx_stopped
)
620 command
|= M_DUART_TX_DIS
;
622 command
|= M_DUART_TX_EN
;
624 oldmode1
= read_sbdchn(sport
, R_DUART_MODE_REG_1
) & mode1mask
;
625 oldmode2
= read_sbdchn(sport
, R_DUART_MODE_REG_2
) & mode2mask
;
626 oldaux
= read_sbdchn(sport
, R_DUART_AUXCTL_X
) & auxmask
;
628 if (!sport
->tx_stopped
)
629 sbd_line_drain(sport
);
630 write_sbdchn(sport
, R_DUART_CMD
, M_DUART_TX_DIS
| M_DUART_RX_DIS
);
632 write_sbdchn(sport
, R_DUART_MODE_REG_1
, mode1
| oldmode1
);
633 write_sbdchn(sport
, R_DUART_MODE_REG_2
, mode2
| oldmode2
);
634 write_sbdchn(sport
, R_DUART_CLK_SEL
, brg
);
635 write_sbdchn(sport
, R_DUART_AUXCTL_X
, aux
| oldaux
);
637 write_sbdchn(sport
, R_DUART_CMD
, command
);
639 spin_unlock(&uport
->lock
);
643 static const char *sbd_type(struct uart_port
*uport
)
645 return "SB1250 DUART";
648 static void sbd_release_port(struct uart_port
*uport
)
650 struct sbd_port
*sport
= to_sport(uport
);
651 struct sbd_duart
*duart
= sport
->duart
;
654 iounmap(sport
->memctrl
);
655 sport
->memctrl
= NULL
;
656 iounmap(uport
->membase
);
657 uport
->membase
= NULL
;
659 map_guard
= atomic_add_return(-1, &duart
->map_guard
);
661 release_mem_region(duart
->mapctrl
, DUART_CHANREG_SPACING
);
662 release_mem_region(uport
->mapbase
, DUART_CHANREG_SPACING
);
665 static int sbd_map_port(struct uart_port
*uport
)
667 static const char *err
= KERN_ERR
"sbd: Cannot map MMIO\n";
668 struct sbd_port
*sport
= to_sport(uport
);
669 struct sbd_duart
*duart
= sport
->duart
;
672 uport
->membase
= ioremap_nocache(uport
->mapbase
,
673 DUART_CHANREG_SPACING
);
674 if (!uport
->membase
) {
680 sport
->memctrl
= ioremap_nocache(duart
->mapctrl
,
681 DUART_CHANREG_SPACING
);
682 if (!sport
->memctrl
) {
684 iounmap(uport
->membase
);
685 uport
->membase
= NULL
;
692 static int sbd_request_port(struct uart_port
*uport
)
694 static const char *err
= KERN_ERR
695 "sbd: Unable to reserve MMIO resource\n";
696 struct sbd_duart
*duart
= to_sport(uport
)->duart
;
700 if (!request_mem_region(uport
->mapbase
, DUART_CHANREG_SPACING
,
705 map_guard
= atomic_add_return(1, &duart
->map_guard
);
706 if (map_guard
== 1) {
707 if (!request_mem_region(duart
->mapctrl
, DUART_CHANREG_SPACING
,
709 atomic_add(-1, &duart
->map_guard
);
715 ret
= sbd_map_port(uport
);
717 map_guard
= atomic_add_return(-1, &duart
->map_guard
);
719 release_mem_region(duart
->mapctrl
,
720 DUART_CHANREG_SPACING
);
724 release_mem_region(uport
->mapbase
, DUART_CHANREG_SPACING
);
730 static void sbd_config_port(struct uart_port
*uport
, int flags
)
732 struct sbd_port
*sport
= to_sport(uport
);
734 if (flags
& UART_CONFIG_TYPE
) {
735 if (sbd_request_port(uport
))
738 uport
->type
= PORT_SB1250_DUART
;
740 sbd_init_port(sport
);
744 static int sbd_verify_port(struct uart_port
*uport
, struct serial_struct
*ser
)
748 if (ser
->type
!= PORT_UNKNOWN
&& ser
->type
!= PORT_SB1250_DUART
)
750 if (ser
->irq
!= uport
->irq
)
752 if (ser
->baud_base
!= uport
->uartclk
/ 16)
758 static struct uart_ops sbd_ops
= {
759 .tx_empty
= sbd_tx_empty
,
760 .set_mctrl
= sbd_set_mctrl
,
761 .get_mctrl
= sbd_get_mctrl
,
762 .stop_tx
= sbd_stop_tx
,
763 .start_tx
= sbd_start_tx
,
764 .stop_rx
= sbd_stop_rx
,
765 .enable_ms
= sbd_enable_ms
,
766 .break_ctl
= sbd_break_ctl
,
767 .startup
= sbd_startup
,
768 .shutdown
= sbd_shutdown
,
769 .set_termios
= sbd_set_termios
,
771 .release_port
= sbd_release_port
,
772 .request_port
= sbd_request_port
,
773 .config_port
= sbd_config_port
,
774 .verify_port
= sbd_verify_port
,
777 /* Initialize SB1250 DUART port structures. */
778 static void __init
sbd_probe_duarts(void)
787 /* Set the number of available units based on the SOC type. */
789 case K_SYS_SOC_TYPE_BCM1x55
:
790 case K_SYS_SOC_TYPE_BCM1x80
:
794 /* Assume at least two serial ports at the normal address. */
801 for (chip
= 0, line
= 0; chip
< DUART_MAX_CHIP
&& line
< max_lines
;
803 sbd_duarts
[chip
].mapctrl
= SBD_CTRLREGS(line
);
805 for (side
= 0; side
< DUART_MAX_SIDE
&& line
< max_lines
;
807 struct sbd_port
*sport
= &sbd_duarts
[chip
].sport
[side
];
808 struct uart_port
*uport
= &sport
->port
;
810 sport
->duart
= &sbd_duarts
[chip
];
812 uport
->irq
= SBD_INT(line
);
813 uport
->uartclk
= 100000000 / 20 * 16;
814 uport
->fifosize
= 16;
815 uport
->iotype
= UPIO_MEM
;
816 uport
->flags
= UPF_BOOT_AUTOCONF
;
817 uport
->ops
= &sbd_ops
;
819 uport
->mapbase
= SBD_CHANREGS(line
);
825 #ifdef CONFIG_SERIAL_SB1250_DUART_CONSOLE
827 * Serial console stuff. Very basic, polling driver for doing serial
828 * console output. The console_sem is held by the caller, so we
829 * shouldn't be interrupted for more console activity.
831 static void sbd_console_putchar(struct uart_port
*uport
, int ch
)
833 struct sbd_port
*sport
= to_sport(uport
);
835 sbd_transmit_drain(sport
);
836 write_sbdchn(sport
, R_DUART_TX_HOLD
, ch
);
839 static void sbd_console_write(struct console
*co
, const char *s
,
842 int chip
= co
->index
/ DUART_MAX_SIDE
;
843 int side
= co
->index
% DUART_MAX_SIDE
;
844 struct sbd_port
*sport
= &sbd_duarts
[chip
].sport
[side
];
845 struct uart_port
*uport
= &sport
->port
;
849 /* Disable transmit interrupts and enable the transmitter. */
850 spin_lock_irqsave(&uport
->lock
, flags
);
851 mask
= read_sbdshr(sport
, R_DUART_IMRREG((uport
->line
) % 2));
852 write_sbdshr(sport
, R_DUART_IMRREG((uport
->line
) % 2),
853 mask
& ~M_DUART_IMR_TX
);
854 write_sbdchn(sport
, R_DUART_CMD
, M_DUART_TX_EN
);
855 spin_unlock_irqrestore(&uport
->lock
, flags
);
857 uart_console_write(&sport
->port
, s
, count
, sbd_console_putchar
);
859 /* Restore transmit interrupts and the transmitter enable. */
860 spin_lock_irqsave(&uport
->lock
, flags
);
861 sbd_line_drain(sport
);
862 if (sport
->tx_stopped
)
863 write_sbdchn(sport
, R_DUART_CMD
, M_DUART_TX_DIS
);
864 write_sbdshr(sport
, R_DUART_IMRREG((uport
->line
) % 2), mask
);
865 spin_unlock_irqrestore(&uport
->lock
, flags
);
868 static int __init
sbd_console_setup(struct console
*co
, char *options
)
870 int chip
= co
->index
/ DUART_MAX_SIDE
;
871 int side
= co
->index
% DUART_MAX_SIDE
;
872 struct sbd_port
*sport
= &sbd_duarts
[chip
].sport
[side
];
873 struct uart_port
*uport
= &sport
->port
;
883 ret
= sbd_map_port(uport
);
887 sbd_init_port(sport
);
890 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
891 return uart_set_options(uport
, co
, baud
, parity
, bits
, flow
);
894 static struct uart_driver sbd_reg
;
895 static struct console sbd_console
= {
897 .write
= sbd_console_write
,
898 .device
= uart_console_device
,
899 .setup
= sbd_console_setup
,
900 .flags
= CON_PRINTBUFFER
,
905 static int __init
sbd_serial_console_init(void)
908 register_console(&sbd_console
);
913 console_initcall(sbd_serial_console_init
);
915 #define SERIAL_SB1250_DUART_CONSOLE &sbd_console
917 #define SERIAL_SB1250_DUART_CONSOLE NULL
918 #endif /* CONFIG_SERIAL_SB1250_DUART_CONSOLE */
921 static struct uart_driver sbd_reg
= {
922 .owner
= THIS_MODULE
,
923 .driver_name
= "serial",
926 .minor
= SB1250_DUART_MINOR_BASE
,
927 .nr
= DUART_MAX_CHIP
* DUART_MAX_SIDE
,
928 .cons
= SERIAL_SB1250_DUART_CONSOLE
,
931 /* Set up the driver and register it. */
932 static int __init
sbd_init(void)
938 ret
= uart_register_driver(&sbd_reg
);
942 for (i
= 0; i
< DUART_MAX_CHIP
* DUART_MAX_SIDE
; i
++) {
943 struct sbd_duart
*duart
= &sbd_duarts
[i
/ DUART_MAX_SIDE
];
944 struct sbd_port
*sport
= &duart
->sport
[i
% DUART_MAX_SIDE
];
945 struct uart_port
*uport
= &sport
->port
;
948 uart_add_one_port(&sbd_reg
, uport
);
954 /* Unload the driver. Unregister stuff, get ready to go away. */
955 static void __exit
sbd_exit(void)
959 for (i
= DUART_MAX_CHIP
* DUART_MAX_SIDE
- 1; i
>= 0; i
--) {
960 struct sbd_duart
*duart
= &sbd_duarts
[i
/ DUART_MAX_SIDE
];
961 struct sbd_port
*sport
= &duart
->sport
[i
% DUART_MAX_SIDE
];
962 struct uart_port
*uport
= &sport
->port
;
965 uart_remove_one_port(&sbd_reg
, uport
);
968 uart_unregister_driver(&sbd_reg
);
971 module_init(sbd_init
);
972 module_exit(sbd_exit
);