2 * linux/drivers/serial/cpm_uart.c
4 * Driver for CPM (SCC/SMC) serial ports; core driver
6 * Based on arch/ppc/cpm2_io/uart.c by Dan Malek
7 * Based on ppc8xx.c by Thomas Gleixner
8 * Based on drivers/serial/amba.c by Russell King
10 * Maintainer: Kumar Gala (galak@kernel.crashing.org) (CPM2)
11 * Pantelis Antoniou (panto@intracom.gr) (CPM1)
13 * Copyright (C) 2004 Freescale Semiconductor, Inc.
14 * (C) 2004 Intracom, S.A.
15 * (C) 2005-2006 MontaVista Software, Inc.
16 * Vitaly Bordug <vbordug@ru.mvista.com>
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License as published by
20 * the Free Software Foundation; either version 2 of the License, or
21 * (at your option) any later version.
23 * This program is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * GNU General Public License for more details.
28 * You should have received a copy of the GNU General Public License
29 * along with this program; if not, write to the Free Software
30 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 #include <linux/module.h>
35 #include <linux/tty.h>
36 #include <linux/ioport.h>
37 #include <linux/init.h>
38 #include <linux/serial.h>
39 #include <linux/console.h>
40 #include <linux/sysrq.h>
41 #include <linux/device.h>
42 #include <linux/bootmem.h>
43 #include <linux/dma-mapping.h>
44 #include <linux/fs_uart_pd.h>
48 #include <asm/delay.h>
49 #include <asm/fs_pd.h>
51 #if defined(CONFIG_SERIAL_CPM_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
55 #include <linux/serial_core.h>
56 #include <linux/kernel.h>
60 /***********************************************************************/
62 /* Track which ports are configured as uarts */
63 int cpm_uart_port_map
[UART_NR
];
64 /* How many ports did we config as uarts */
67 /**************************************************************/
69 static int cpm_uart_tx_pump(struct uart_port
*port
);
70 static void cpm_uart_init_smc(struct uart_cpm_port
*pinfo
);
71 static void cpm_uart_init_scc(struct uart_cpm_port
*pinfo
);
72 static void cpm_uart_initbd(struct uart_cpm_port
*pinfo
);
74 /**************************************************************/
77 /* Place-holder for board-specific stuff */
78 struct platform_device
* __attribute__ ((weak
)) __init
79 early_uart_get_pdev(int index
)
85 static void cpm_uart_count(void)
88 #ifdef CONFIG_SERIAL_CPM_SMC1
89 cpm_uart_port_map
[cpm_uart_nr
++] = UART_SMC1
;
91 #ifdef CONFIG_SERIAL_CPM_SMC2
92 cpm_uart_port_map
[cpm_uart_nr
++] = UART_SMC2
;
94 #ifdef CONFIG_SERIAL_CPM_SCC1
95 cpm_uart_port_map
[cpm_uart_nr
++] = UART_SCC1
;
97 #ifdef CONFIG_SERIAL_CPM_SCC2
98 cpm_uart_port_map
[cpm_uart_nr
++] = UART_SCC2
;
100 #ifdef CONFIG_SERIAL_CPM_SCC3
101 cpm_uart_port_map
[cpm_uart_nr
++] = UART_SCC3
;
103 #ifdef CONFIG_SERIAL_CPM_SCC4
104 cpm_uart_port_map
[cpm_uart_nr
++] = UART_SCC4
;
108 /* Get UART number by its id */
109 static int cpm_uart_id2nr(int id
)
113 for (i
=0; i
<UART_NR
; i
++) {
114 if (cpm_uart_port_map
[i
] == id
)
119 /* not found or invalid argument */
124 * Check, if transmit buffers are processed
126 static unsigned int cpm_uart_tx_empty(struct uart_port
*port
)
128 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
129 volatile cbd_t
*bdp
= pinfo
->tx_bd_base
;
133 if (bdp
->cbd_sc
& BD_SC_READY
)
136 if (bdp
->cbd_sc
& BD_SC_WRAP
) {
143 pr_debug("CPM uart[%d]:tx_empty: %d\n", port
->line
, ret
);
148 static void cpm_uart_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
150 /* Whee. Do nothing. */
153 static unsigned int cpm_uart_get_mctrl(struct uart_port
*port
)
155 /* Whee. Do nothing. */
156 return TIOCM_CAR
| TIOCM_DSR
| TIOCM_CTS
;
162 static void cpm_uart_stop_tx(struct uart_port
*port
)
164 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
165 volatile smc_t
*smcp
= pinfo
->smcp
;
166 volatile scc_t
*sccp
= pinfo
->sccp
;
168 pr_debug("CPM uart[%d]:stop tx\n", port
->line
);
171 smcp
->smc_smcm
&= ~SMCM_TX
;
173 sccp
->scc_sccm
&= ~UART_SCCM_TX
;
179 static void cpm_uart_start_tx(struct uart_port
*port
)
181 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
182 volatile smc_t
*smcp
= pinfo
->smcp
;
183 volatile scc_t
*sccp
= pinfo
->sccp
;
185 pr_debug("CPM uart[%d]:start tx\n", port
->line
);
188 if (smcp
->smc_smcm
& SMCM_TX
)
191 if (sccp
->scc_sccm
& UART_SCCM_TX
)
195 if (cpm_uart_tx_pump(port
) != 0) {
197 smcp
->smc_smcm
|= SMCM_TX
;
199 sccp
->scc_sccm
|= UART_SCCM_TX
;
207 static void cpm_uart_stop_rx(struct uart_port
*port
)
209 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
210 volatile smc_t
*smcp
= pinfo
->smcp
;
211 volatile scc_t
*sccp
= pinfo
->sccp
;
213 pr_debug("CPM uart[%d]:stop rx\n", port
->line
);
216 smcp
->smc_smcm
&= ~SMCM_RX
;
218 sccp
->scc_sccm
&= ~UART_SCCM_RX
;
222 * Enable Modem status interrupts
224 static void cpm_uart_enable_ms(struct uart_port
*port
)
226 pr_debug("CPM uart[%d]:enable ms\n", port
->line
);
232 static void cpm_uart_break_ctl(struct uart_port
*port
, int break_state
)
234 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
235 int line
= pinfo
- cpm_uart_ports
;
237 pr_debug("CPM uart[%d]:break ctrl, break_state: %d\n", port
->line
,
241 cpm_line_cr_cmd(line
, CPM_CR_STOP_TX
);
243 cpm_line_cr_cmd(line
, CPM_CR_RESTART_TX
);
247 * Transmit characters, refill buffer descriptor, if possible
249 static void cpm_uart_int_tx(struct uart_port
*port
)
251 pr_debug("CPM uart[%d]:TX INT\n", port
->line
);
253 cpm_uart_tx_pump(port
);
259 static void cpm_uart_int_rx(struct uart_port
*port
)
262 unsigned char ch
, *cp
;
263 struct tty_struct
*tty
= port
->info
->tty
;
264 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
269 pr_debug("CPM uart[%d]:RX INT\n", port
->line
);
271 /* Just loop through the closed BDs and copy the characters into
277 status
= bdp
->cbd_sc
;
278 /* If this one is empty, return happy */
279 if (status
& BD_SC_EMPTY
)
282 /* get number of characters, and check spce in flip-buffer */
285 /* If we have not enough room in tty flip buffer, then we try
286 * later, which will be the next rx-interrupt or a timeout
288 if(tty_buffer_request_room(tty
, i
) < i
) {
289 printk(KERN_WARNING
"No room in flip buffer\n");
294 cp
= cpm2cpu_addr(bdp
->cbd_bufaddr
, pinfo
);
296 /* loop through the buffer */
303 (BD_SC_BR
| BD_SC_FR
| BD_SC_PR
| BD_SC_OV
))
305 if (uart_handle_sysrq_char(port
, ch
))
309 tty_insert_flip_char(tty
, ch
, flg
);
311 } /* End while (i--) */
313 /* This BD is ready to be used again. Clear status. get next */
314 bdp
->cbd_sc
&= ~(BD_SC_BR
| BD_SC_FR
| BD_SC_PR
| BD_SC_OV
| BD_SC_ID
);
315 bdp
->cbd_sc
|= BD_SC_EMPTY
;
317 if (bdp
->cbd_sc
& BD_SC_WRAP
)
318 bdp
= pinfo
->rx_bd_base
;
324 /* Write back buffer pointer */
325 pinfo
->rx_cur
= (volatile cbd_t
*) bdp
;
327 /* activate BH processing */
328 tty_flip_buffer_push(tty
);
332 /* Error processing */
336 if (status
& BD_SC_BR
)
338 if (status
& BD_SC_PR
)
339 port
->icount
.parity
++;
340 if (status
& BD_SC_FR
)
341 port
->icount
.frame
++;
342 if (status
& BD_SC_OV
)
343 port
->icount
.overrun
++;
345 /* Mask out ignored conditions */
346 status
&= port
->read_status_mask
;
348 /* Handle the remaining ones */
349 if (status
& BD_SC_BR
)
351 else if (status
& BD_SC_PR
)
353 else if (status
& BD_SC_FR
)
356 /* overrun does not affect the current character ! */
357 if (status
& BD_SC_OV
) {
360 /* We skip this buffer */
361 /* CHECK: Is really nothing senseful there */
362 /* ASSUMPTION: it contains nothing valid */
372 * Asynchron mode interrupt handler
374 static irqreturn_t
cpm_uart_int(int irq
, void *data
)
377 struct uart_port
*port
= (struct uart_port
*)data
;
378 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
379 volatile smc_t
*smcp
= pinfo
->smcp
;
380 volatile scc_t
*sccp
= pinfo
->sccp
;
382 pr_debug("CPM uart[%d]:IRQ\n", port
->line
);
385 events
= smcp
->smc_smce
;
386 smcp
->smc_smce
= events
;
387 if (events
& SMCM_BRKE
)
388 uart_handle_break(port
);
389 if (events
& SMCM_RX
)
390 cpm_uart_int_rx(port
);
391 if (events
& SMCM_TX
)
392 cpm_uart_int_tx(port
);
394 events
= sccp
->scc_scce
;
395 sccp
->scc_scce
= events
;
396 if (events
& UART_SCCM_BRKE
)
397 uart_handle_break(port
);
398 if (events
& UART_SCCM_RX
)
399 cpm_uart_int_rx(port
);
400 if (events
& UART_SCCM_TX
)
401 cpm_uart_int_tx(port
);
403 return (events
) ? IRQ_HANDLED
: IRQ_NONE
;
406 static int cpm_uart_startup(struct uart_port
*port
)
409 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
410 int line
= pinfo
- cpm_uart_ports
;
412 pr_debug("CPM uart[%d]:startup\n", port
->line
);
414 /* Install interrupt handler. */
415 retval
= request_irq(port
->irq
, cpm_uart_int
, 0, "cpm_uart", port
);
421 pinfo
->smcp
->smc_smcm
|= SMCM_RX
;
422 pinfo
->smcp
->smc_smcmr
|= (SMCMR_REN
| SMCMR_TEN
);
424 pinfo
->sccp
->scc_sccm
|= UART_SCCM_RX
;
425 pinfo
->sccp
->scc_gsmrl
|= (SCC_GSMRL_ENR
| SCC_GSMRL_ENT
);
428 if (!(pinfo
->flags
& FLAG_CONSOLE
))
429 cpm_line_cr_cmd(line
,CPM_CR_INIT_TRX
);
433 inline void cpm_uart_wait_until_send(struct uart_cpm_port
*pinfo
)
435 set_current_state(TASK_UNINTERRUPTIBLE
);
436 schedule_timeout(pinfo
->wait_closing
);
442 static void cpm_uart_shutdown(struct uart_port
*port
)
444 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
445 int line
= pinfo
- cpm_uart_ports
;
447 pr_debug("CPM uart[%d]:shutdown\n", port
->line
);
449 /* free interrupt handler */
450 free_irq(port
->irq
, port
);
452 /* If the port is not the console, disable Rx and Tx. */
453 if (!(pinfo
->flags
& FLAG_CONSOLE
)) {
454 /* Wait for all the BDs marked sent */
455 while(!cpm_uart_tx_empty(port
)) {
456 set_current_state(TASK_UNINTERRUPTIBLE
);
460 if (pinfo
->wait_closing
)
461 cpm_uart_wait_until_send(pinfo
);
465 volatile smc_t
*smcp
= pinfo
->smcp
;
466 smcp
->smc_smcmr
&= ~(SMCMR_REN
| SMCMR_TEN
);
467 smcp
->smc_smcm
&= ~(SMCM_RX
| SMCM_TX
);
469 volatile scc_t
*sccp
= pinfo
->sccp
;
470 sccp
->scc_gsmrl
&= ~(SCC_GSMRL_ENR
| SCC_GSMRL_ENT
);
471 sccp
->scc_sccm
&= ~(UART_SCCM_TX
| UART_SCCM_RX
);
474 /* Shut them really down and reinit buffer descriptors */
476 cpm_line_cr_cmd(line
, CPM_CR_STOP_TX
);
478 cpm_line_cr_cmd(line
, CPM_CR_GRA_STOP_TX
);
480 cpm_uart_initbd(pinfo
);
484 static void cpm_uart_set_termios(struct uart_port
*port
,
485 struct ktermios
*termios
,
486 struct ktermios
*old
)
490 u16 cval
, scval
, prev_mode
;
492 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
493 volatile smc_t
*smcp
= pinfo
->smcp
;
494 volatile scc_t
*sccp
= pinfo
->sccp
;
496 pr_debug("CPM uart[%d]:set_termios\n", port
->line
);
498 baud
= uart_get_baud_rate(port
, termios
, old
, 0, port
->uartclk
/ 16);
500 /* Character length programmed into the mode register is the
501 * sum of: 1 start bit, number of data bits, 0 or 1 parity bit,
502 * 1 or 2 stop bits, minus 1.
503 * The value 'bits' counts this for us.
509 switch (termios
->c_cflag
& CSIZE
) {
522 /* Never happens, but GCC is too dumb to figure it out */
529 if (termios
->c_cflag
& CSTOPB
) {
530 cval
|= SMCMR_SL
; /* Two stops */
531 scval
|= SCU_PSMR_SL
;
535 if (termios
->c_cflag
& PARENB
) {
537 scval
|= SCU_PSMR_PEN
;
539 if (!(termios
->c_cflag
& PARODD
)) {
540 cval
|= SMCMR_PM_EVEN
;
541 scval
|= (SCU_PSMR_REVP
| SCU_PSMR_TEVP
);
546 * Set up parity check flag
548 #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
550 port
->read_status_mask
= (BD_SC_EMPTY
| BD_SC_OV
);
551 if (termios
->c_iflag
& INPCK
)
552 port
->read_status_mask
|= BD_SC_FR
| BD_SC_PR
;
553 if ((termios
->c_iflag
& BRKINT
) || (termios
->c_iflag
& PARMRK
))
554 port
->read_status_mask
|= BD_SC_BR
;
557 * Characters to ignore
559 port
->ignore_status_mask
= 0;
560 if (termios
->c_iflag
& IGNPAR
)
561 port
->ignore_status_mask
|= BD_SC_PR
| BD_SC_FR
;
562 if (termios
->c_iflag
& IGNBRK
) {
563 port
->ignore_status_mask
|= BD_SC_BR
;
565 * If we're ignore parity and break indicators, ignore
566 * overruns too. (For real raw support).
568 if (termios
->c_iflag
& IGNPAR
)
569 port
->ignore_status_mask
|= BD_SC_OV
;
572 * !!! ignore all characters if CREAD is not set
574 if ((termios
->c_cflag
& CREAD
) == 0)
575 port
->read_status_mask
&= ~BD_SC_EMPTY
;
577 spin_lock_irqsave(&port
->lock
, flags
);
579 /* Start bit has not been added (so don't, because we would just
580 * subtract it later), and we need to add one for the number of
581 * stops bits (there is always at least one).
585 /* Set the mode register. We want to keep a copy of the
586 * enables, because we want to put them back if they were
589 prev_mode
= smcp
->smc_smcmr
;
590 smcp
->smc_smcmr
= smcr_mk_clen(bits
) | cval
| SMCMR_SM_UART
;
591 smcp
->smc_smcmr
|= (prev_mode
& (SMCMR_REN
| SMCMR_TEN
));
593 sccp
->scc_psmr
= (sbits
<< 12) | scval
;
596 cpm_set_brg(pinfo
->brg
- 1, baud
);
597 spin_unlock_irqrestore(&port
->lock
, flags
);
601 static const char *cpm_uart_type(struct uart_port
*port
)
603 pr_debug("CPM uart[%d]:uart_type\n", port
->line
);
605 return port
->type
== PORT_CPM
? "CPM UART" : NULL
;
609 * verify the new serial_struct (for TIOCSSERIAL).
611 static int cpm_uart_verify_port(struct uart_port
*port
,
612 struct serial_struct
*ser
)
616 pr_debug("CPM uart[%d]:verify_port\n", port
->line
);
618 if (ser
->type
!= PORT_UNKNOWN
&& ser
->type
!= PORT_CPM
)
620 if (ser
->irq
< 0 || ser
->irq
>= NR_IRQS
)
622 if (ser
->baud_base
< 9600)
628 * Transmit characters, refill buffer descriptor, if possible
630 static int cpm_uart_tx_pump(struct uart_port
*port
)
635 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
636 struct circ_buf
*xmit
= &port
->info
->xmit
;
638 /* Handle xon/xoff */
640 /* Pick next descriptor and fill from buffer */
643 p
= cpm2cpu_addr(bdp
->cbd_bufaddr
, pinfo
);
647 bdp
->cbd_sc
|= BD_SC_READY
;
649 if (bdp
->cbd_sc
& BD_SC_WRAP
)
650 bdp
= pinfo
->tx_bd_base
;
660 if (uart_circ_empty(xmit
) || uart_tx_stopped(port
)) {
661 cpm_uart_stop_tx(port
);
665 /* Pick next descriptor and fill from buffer */
668 while (!(bdp
->cbd_sc
& BD_SC_READY
) && (xmit
->tail
!= xmit
->head
)) {
670 p
= cpm2cpu_addr(bdp
->cbd_bufaddr
, pinfo
);
671 while (count
< pinfo
->tx_fifosize
) {
672 *p
++ = xmit
->buf
[xmit
->tail
];
673 xmit
->tail
= (xmit
->tail
+ 1) & (UART_XMIT_SIZE
- 1);
676 if (xmit
->head
== xmit
->tail
)
679 bdp
->cbd_datlen
= count
;
680 bdp
->cbd_sc
|= BD_SC_READY
;
683 if (bdp
->cbd_sc
& BD_SC_WRAP
)
684 bdp
= pinfo
->tx_bd_base
;
690 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
691 uart_write_wakeup(port
);
693 if (uart_circ_empty(xmit
)) {
694 cpm_uart_stop_tx(port
);
702 * init buffer descriptors
704 static void cpm_uart_initbd(struct uart_cpm_port
*pinfo
)
710 pr_debug("CPM uart[%d]:initbd\n", pinfo
->port
.line
);
712 /* Set the physical address of the host memory
713 * buffers in the buffer descriptors, and the
714 * virtual address for us to work with.
716 mem_addr
= pinfo
->mem_addr
;
717 bdp
= pinfo
->rx_cur
= pinfo
->rx_bd_base
;
718 for (i
= 0; i
< (pinfo
->rx_nrfifos
- 1); i
++, bdp
++) {
719 bdp
->cbd_bufaddr
= cpu2cpm_addr(mem_addr
, pinfo
);
720 bdp
->cbd_sc
= BD_SC_EMPTY
| BD_SC_INTRPT
;
721 mem_addr
+= pinfo
->rx_fifosize
;
724 bdp
->cbd_bufaddr
= cpu2cpm_addr(mem_addr
, pinfo
);
725 bdp
->cbd_sc
= BD_SC_WRAP
| BD_SC_EMPTY
| BD_SC_INTRPT
;
727 /* Set the physical address of the host memory
728 * buffers in the buffer descriptors, and the
729 * virtual address for us to work with.
731 mem_addr
= pinfo
->mem_addr
+ L1_CACHE_ALIGN(pinfo
->rx_nrfifos
* pinfo
->rx_fifosize
);
732 bdp
= pinfo
->tx_cur
= pinfo
->tx_bd_base
;
733 for (i
= 0; i
< (pinfo
->tx_nrfifos
- 1); i
++, bdp
++) {
734 bdp
->cbd_bufaddr
= cpu2cpm_addr(mem_addr
, pinfo
);
735 bdp
->cbd_sc
= BD_SC_INTRPT
;
736 mem_addr
+= pinfo
->tx_fifosize
;
739 bdp
->cbd_bufaddr
= cpu2cpm_addr(mem_addr
, pinfo
);
740 bdp
->cbd_sc
= BD_SC_WRAP
| BD_SC_INTRPT
;
743 static void cpm_uart_init_scc(struct uart_cpm_port
*pinfo
)
745 int line
= pinfo
- cpm_uart_ports
;
747 volatile scc_uart_t
*sup
;
749 pr_debug("CPM uart[%d]:init_scc\n", pinfo
->port
.line
);
755 pinfo
->sccup
->scc_genscc
.scc_rbase
= (unsigned char *)pinfo
->rx_bd_base
- DPRAM_BASE
;
756 pinfo
->sccup
->scc_genscc
.scc_tbase
= (unsigned char *)pinfo
->tx_bd_base
- DPRAM_BASE
;
758 /* Set up the uart parameters in the
762 cpm_set_scc_fcr(sup
);
764 sup
->scc_genscc
.scc_mrblr
= pinfo
->rx_fifosize
;
765 sup
->scc_maxidl
= pinfo
->rx_fifosize
;
774 sup
->scc_char1
= 0x8000;
775 sup
->scc_char2
= 0x8000;
776 sup
->scc_char3
= 0x8000;
777 sup
->scc_char4
= 0x8000;
778 sup
->scc_char5
= 0x8000;
779 sup
->scc_char6
= 0x8000;
780 sup
->scc_char7
= 0x8000;
781 sup
->scc_char8
= 0x8000;
782 sup
->scc_rccm
= 0xc0ff;
784 /* Send the CPM an initialize command.
786 cpm_line_cr_cmd(line
, CPM_CR_INIT_TRX
);
788 /* Set UART mode, 8 bit, no parity, one stop.
789 * Enable receive and transmit.
793 (SCC_GSMRL_MODE_UART
| SCC_GSMRL_TDCR_16
| SCC_GSMRL_RDCR_16
);
795 /* Enable rx interrupts and clear all pending events. */
797 scp
->scc_scce
= 0xffff;
798 scp
->scc_dsr
= 0x7e7e;
799 scp
->scc_psmr
= 0x3000;
801 scp
->scc_gsmrl
|= (SCC_GSMRL_ENR
| SCC_GSMRL_ENT
);
804 static void cpm_uart_init_smc(struct uart_cpm_port
*pinfo
)
806 int line
= pinfo
- cpm_uart_ports
;
808 volatile smc_uart_t
*up
;
810 pr_debug("CPM uart[%d]:init_smc\n", pinfo
->port
.line
);
816 pinfo
->smcup
->smc_rbase
= (u_char
*)pinfo
->rx_bd_base
- DPRAM_BASE
;
817 pinfo
->smcup
->smc_tbase
= (u_char
*)pinfo
->tx_bd_base
- DPRAM_BASE
;
820 * In case SMC1 is being relocated...
822 #if defined (CONFIG_I2C_SPI_SMC1_UCODE_PATCH)
823 up
->smc_rbptr
= pinfo
->smcup
->smc_rbase
;
824 up
->smc_tbptr
= pinfo
->smcup
->smc_tbase
;
827 up
->smc_brkcr
= 1; /* number of break chars */
831 /* Set up the uart parameters in the
836 /* Using idle charater time requires some additional tuning. */
837 up
->smc_mrblr
= pinfo
->rx_fifosize
;
838 up
->smc_maxidl
= pinfo
->rx_fifosize
;
843 cpm_line_cr_cmd(line
, CPM_CR_INIT_TRX
);
845 /* Set UART mode, 8 bit, no parity, one stop.
846 * Enable receive and transmit.
848 sp
->smc_smcmr
= smcr_mk_clen(9) | SMCMR_SM_UART
;
850 /* Enable only rx interrupts clear all pending events. */
854 sp
->smc_smcmr
|= (SMCMR_REN
| SMCMR_TEN
);
858 * Initialize port. This is called from early_console stuff
859 * so we have to be careful here !
861 static int cpm_uart_request_port(struct uart_port
*port
)
863 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
866 pr_debug("CPM uart[%d]:request port\n", port
->line
);
868 if (pinfo
->flags
& FLAG_CONSOLE
)
872 pinfo
->smcp
->smc_smcm
&= ~(SMCM_RX
| SMCM_TX
);
873 pinfo
->smcp
->smc_smcmr
&= ~(SMCMR_REN
| SMCMR_TEN
);
875 pinfo
->sccp
->scc_sccm
&= ~(UART_SCCM_TX
| UART_SCCM_RX
);
876 pinfo
->sccp
->scc_gsmrl
&= ~(SCC_GSMRL_ENR
| SCC_GSMRL_ENT
);
879 ret
= cpm_uart_allocbuf(pinfo
, 0);
884 cpm_uart_initbd(pinfo
);
886 cpm_uart_init_smc(pinfo
);
888 cpm_uart_init_scc(pinfo
);
893 static void cpm_uart_release_port(struct uart_port
*port
)
895 struct uart_cpm_port
*pinfo
= (struct uart_cpm_port
*)port
;
897 if (!(pinfo
->flags
& FLAG_CONSOLE
))
898 cpm_uart_freebuf(pinfo
);
902 * Configure/autoconfigure the port.
904 static void cpm_uart_config_port(struct uart_port
*port
, int flags
)
906 pr_debug("CPM uart[%d]:config_port\n", port
->line
);
908 if (flags
& UART_CONFIG_TYPE
) {
909 port
->type
= PORT_CPM
;
910 cpm_uart_request_port(port
);
913 static struct uart_ops cpm_uart_pops
= {
914 .tx_empty
= cpm_uart_tx_empty
,
915 .set_mctrl
= cpm_uart_set_mctrl
,
916 .get_mctrl
= cpm_uart_get_mctrl
,
917 .stop_tx
= cpm_uart_stop_tx
,
918 .start_tx
= cpm_uart_start_tx
,
919 .stop_rx
= cpm_uart_stop_rx
,
920 .enable_ms
= cpm_uart_enable_ms
,
921 .break_ctl
= cpm_uart_break_ctl
,
922 .startup
= cpm_uart_startup
,
923 .shutdown
= cpm_uart_shutdown
,
924 .set_termios
= cpm_uart_set_termios
,
925 .type
= cpm_uart_type
,
926 .release_port
= cpm_uart_release_port
,
927 .request_port
= cpm_uart_request_port
,
928 .config_port
= cpm_uart_config_port
,
929 .verify_port
= cpm_uart_verify_port
,
932 struct uart_cpm_port cpm_uart_ports
[UART_NR
] = {
936 .ops
= &cpm_uart_pops
,
938 .lock
= __SPIN_LOCK_UNLOCKED(cpm_uart_ports
[UART_SMC1
].port
.lock
),
941 .tx_nrfifos
= TX_NUM_FIFO
,
942 .tx_fifosize
= TX_BUF_SIZE
,
943 .rx_nrfifos
= RX_NUM_FIFO
,
944 .rx_fifosize
= RX_BUF_SIZE
,
945 .set_lineif
= smc1_lineif
,
950 .ops
= &cpm_uart_pops
,
952 .lock
= __SPIN_LOCK_UNLOCKED(cpm_uart_ports
[UART_SMC2
].port
.lock
),
955 .tx_nrfifos
= TX_NUM_FIFO
,
956 .tx_fifosize
= TX_BUF_SIZE
,
957 .rx_nrfifos
= RX_NUM_FIFO
,
958 .rx_fifosize
= RX_BUF_SIZE
,
959 .set_lineif
= smc2_lineif
,
960 #ifdef CONFIG_SERIAL_CPM_ALT_SMC2
967 .ops
= &cpm_uart_pops
,
969 .lock
= __SPIN_LOCK_UNLOCKED(cpm_uart_ports
[UART_SCC1
].port
.lock
),
971 .tx_nrfifos
= TX_NUM_FIFO
,
972 .tx_fifosize
= TX_BUF_SIZE
,
973 .rx_nrfifos
= RX_NUM_FIFO
,
974 .rx_fifosize
= RX_BUF_SIZE
,
975 .set_lineif
= scc1_lineif
,
976 .wait_closing
= SCC_WAIT_CLOSING
,
981 .ops
= &cpm_uart_pops
,
983 .lock
= __SPIN_LOCK_UNLOCKED(cpm_uart_ports
[UART_SCC2
].port
.lock
),
985 .tx_nrfifos
= TX_NUM_FIFO
,
986 .tx_fifosize
= TX_BUF_SIZE
,
987 .rx_nrfifos
= RX_NUM_FIFO
,
988 .rx_fifosize
= RX_BUF_SIZE
,
989 .set_lineif
= scc2_lineif
,
990 .wait_closing
= SCC_WAIT_CLOSING
,
995 .ops
= &cpm_uart_pops
,
997 .lock
= __SPIN_LOCK_UNLOCKED(cpm_uart_ports
[UART_SCC3
].port
.lock
),
999 .tx_nrfifos
= TX_NUM_FIFO
,
1000 .tx_fifosize
= TX_BUF_SIZE
,
1001 .rx_nrfifos
= RX_NUM_FIFO
,
1002 .rx_fifosize
= RX_BUF_SIZE
,
1003 .set_lineif
= scc3_lineif
,
1004 .wait_closing
= SCC_WAIT_CLOSING
,
1009 .ops
= &cpm_uart_pops
,
1011 .lock
= __SPIN_LOCK_UNLOCKED(cpm_uart_ports
[UART_SCC4
].port
.lock
),
1013 .tx_nrfifos
= TX_NUM_FIFO
,
1014 .tx_fifosize
= TX_BUF_SIZE
,
1015 .rx_nrfifos
= RX_NUM_FIFO
,
1016 .rx_fifosize
= RX_BUF_SIZE
,
1017 .set_lineif
= scc4_lineif
,
1018 .wait_closing
= SCC_WAIT_CLOSING
,
1022 int cpm_uart_drv_get_platform_data(struct platform_device
*pdev
, int is_con
)
1025 struct fs_uart_platform_info
*pdata
= pdev
->dev
.platform_data
;
1026 int idx
; /* It is UART_SMCx or UART_SCCx index */
1027 struct uart_cpm_port
*pinfo
;
1031 idx
= pdata
->fs_no
= fs_uart_get_id(pdata
);
1033 line
= cpm_uart_id2nr(idx
);
1035 printk(KERN_ERR
"%s(): port %d is not registered", __FUNCTION__
, idx
);
1039 pinfo
= (struct uart_cpm_port
*) &cpm_uart_ports
[idx
];
1041 pinfo
->brg
= pdata
->brg
;
1044 pinfo
->port
.line
= line
;
1045 pinfo
->port
.flags
= UPF_BOOT_AUTOCONF
;
1048 if (!(r
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "regs")))
1050 mem
= (u32
)ioremap(r
->start
, r
->end
- r
->start
+ 1);
1052 if (!(r
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "pram")))
1054 pram
= (u32
)ioremap(r
->start
, r
->end
- r
->start
+ 1);
1056 if(idx
> fsid_smc2_uart
) {
1057 pinfo
->sccp
= (scc_t
*)mem
;
1058 pinfo
->sccup
= (scc_uart_t
*)pram
;
1060 pinfo
->smcp
= (smc_t
*)mem
;
1061 pinfo
->smcup
= (smc_uart_t
*)pram
;
1063 pinfo
->tx_nrfifos
= pdata
->tx_num_fifo
;
1064 pinfo
->tx_fifosize
= pdata
->tx_buf_size
;
1066 pinfo
->rx_nrfifos
= pdata
->rx_num_fifo
;
1067 pinfo
->rx_fifosize
= pdata
->rx_buf_size
;
1069 pinfo
->port
.uartclk
= pdata
->uart_clk
;
1070 pinfo
->port
.mapbase
= (unsigned long)mem
;
1071 pinfo
->port
.irq
= platform_get_irq(pdev
, 0);
1076 #ifdef CONFIG_SERIAL_CPM_CONSOLE
1078 * Print a string to the serial port trying not to disturb
1079 * any possible real use of the port...
1081 * Note that this is called with interrupts already disabled
1083 static void cpm_uart_console_write(struct console
*co
, const char *s
,
1086 struct uart_cpm_port
*pinfo
=
1087 &cpm_uart_ports
[cpm_uart_port_map
[co
->index
]];
1089 volatile cbd_t
*bdp
, *bdbase
;
1090 volatile unsigned char *cp
;
1092 /* Get the address of the host memory buffer.
1094 bdp
= pinfo
->tx_cur
;
1095 bdbase
= pinfo
->tx_bd_base
;
1098 * Now, do each character. This is not as bad as it looks
1099 * since this is a holding FIFO and not a transmitting FIFO.
1100 * We could add the complexity of filling the entire transmit
1101 * buffer, but we would just wait longer between accesses......
1103 for (i
= 0; i
< count
; i
++, s
++) {
1104 /* Wait for transmitter fifo to empty.
1105 * Ready indicates output is ready, and xmt is doing
1106 * that, not that it is ready for us to send.
1108 while ((bdp
->cbd_sc
& BD_SC_READY
) != 0)
1111 /* Send the character out.
1112 * If the buffer address is in the CPM DPRAM, don't
1115 cp
= cpm2cpu_addr(bdp
->cbd_bufaddr
, pinfo
);
1119 bdp
->cbd_datlen
= 1;
1120 bdp
->cbd_sc
|= BD_SC_READY
;
1122 if (bdp
->cbd_sc
& BD_SC_WRAP
)
1127 /* if a LF, also do CR... */
1129 while ((bdp
->cbd_sc
& BD_SC_READY
) != 0)
1132 cp
= cpm2cpu_addr(bdp
->cbd_bufaddr
, pinfo
);
1135 bdp
->cbd_datlen
= 1;
1136 bdp
->cbd_sc
|= BD_SC_READY
;
1138 if (bdp
->cbd_sc
& BD_SC_WRAP
)
1146 * Finally, Wait for transmitter & holding register to empty
1147 * and restore the IER
1149 while ((bdp
->cbd_sc
& BD_SC_READY
) != 0)
1152 pinfo
->tx_cur
= (volatile cbd_t
*) bdp
;
1156 static int __init
cpm_uart_console_setup(struct console
*co
, char *options
)
1158 struct uart_port
*port
;
1159 struct uart_cpm_port
*pinfo
;
1166 struct fs_uart_platform_info
*pdata
;
1167 struct platform_device
* pdev
= early_uart_get_pdev(co
->index
);
1170 pr_info("cpm_uart: console: compat mode\n");
1171 /* compatibility - will be cleaned up */
1172 cpm_uart_init_portdesc();
1176 (struct uart_port
*)&cpm_uart_ports
[cpm_uart_port_map
[co
->index
]];
1177 pinfo
= (struct uart_cpm_port
*)port
;
1179 if (pinfo
->set_lineif
)
1180 pinfo
->set_lineif(pinfo
);
1182 pdata
= pdev
->dev
.platform_data
;
1184 if (pdata
->init_ioports
)
1185 pdata
->init_ioports(pdata
);
1187 cpm_uart_drv_get_platform_data(pdev
, 1);
1190 pinfo
->flags
|= FLAG_CONSOLE
;
1193 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
1195 if ((baud
= uart_baudrate()) == -1)
1199 if (IS_SMC(pinfo
)) {
1200 pinfo
->smcp
->smc_smcm
&= ~(SMCM_RX
| SMCM_TX
);
1201 pinfo
->smcp
->smc_smcmr
&= ~(SMCMR_REN
| SMCMR_TEN
);
1203 pinfo
->sccp
->scc_sccm
&= ~(UART_SCCM_TX
| UART_SCCM_RX
);
1204 pinfo
->sccp
->scc_gsmrl
&= ~(SCC_GSMRL_ENR
| SCC_GSMRL_ENT
);
1207 ret
= cpm_uart_allocbuf(pinfo
, 1);
1212 cpm_uart_initbd(pinfo
);
1215 cpm_uart_init_smc(pinfo
);
1217 cpm_uart_init_scc(pinfo
);
1219 uart_set_options(port
, co
, baud
, parity
, bits
, flow
);
1224 static struct uart_driver cpm_reg
;
1225 static struct console cpm_scc_uart_console
= {
1227 .write
= cpm_uart_console_write
,
1228 .device
= uart_console_device
,
1229 .setup
= cpm_uart_console_setup
,
1230 .flags
= CON_PRINTBUFFER
,
1235 int __init
cpm_uart_console_init(void)
1237 register_console(&cpm_scc_uart_console
);
1241 console_initcall(cpm_uart_console_init
);
1243 #define CPM_UART_CONSOLE &cpm_scc_uart_console
1245 #define CPM_UART_CONSOLE NULL
1248 static struct uart_driver cpm_reg
= {
1249 .owner
= THIS_MODULE
,
1250 .driver_name
= "ttyCPM",
1251 .dev_name
= "ttyCPM",
1252 .major
= SERIAL_CPM_MAJOR
,
1253 .minor
= SERIAL_CPM_MINOR
,
1254 .cons
= CPM_UART_CONSOLE
,
1256 static int cpm_uart_drv_probe(struct device
*dev
)
1258 struct platform_device
*pdev
= to_platform_device(dev
);
1259 struct fs_uart_platform_info
*pdata
;
1263 printk(KERN_ERR
"CPM UART: platform data missing!\n");
1267 pdata
= pdev
->dev
.platform_data
;
1269 if ((ret
= cpm_uart_drv_get_platform_data(pdev
, 0)))
1272 pr_debug("cpm_uart_drv_probe: Adding CPM UART %d\n", cpm_uart_id2nr(pdata
->fs_no
));
1274 if (pdata
->init_ioports
)
1275 pdata
->init_ioports(pdata
);
1277 ret
= uart_add_one_port(&cpm_reg
, &cpm_uart_ports
[pdata
->fs_no
].port
);
1282 static int cpm_uart_drv_remove(struct device
*dev
)
1284 struct platform_device
*pdev
= to_platform_device(dev
);
1285 struct fs_uart_platform_info
*pdata
= pdev
->dev
.platform_data
;
1287 pr_debug("cpm_uart_drv_remove: Removing CPM UART %d\n",
1288 cpm_uart_id2nr(pdata
->fs_no
));
1290 uart_remove_one_port(&cpm_reg
, &cpm_uart_ports
[pdata
->fs_no
].port
);
1294 static struct device_driver cpm_smc_uart_driver
= {
1295 .name
= "fsl-cpm-smc:uart",
1296 .bus
= &platform_bus_type
,
1297 .probe
= cpm_uart_drv_probe
,
1298 .remove
= cpm_uart_drv_remove
,
1301 static struct device_driver cpm_scc_uart_driver
= {
1302 .name
= "fsl-cpm-scc:uart",
1303 .bus
= &platform_bus_type
,
1304 .probe
= cpm_uart_drv_probe
,
1305 .remove
= cpm_uart_drv_remove
,
1309 This is supposed to match uart devices on platform bus,
1311 static int match_is_uart (struct device
* dev
, void* data
)
1313 struct platform_device
* pdev
= container_of(dev
, struct platform_device
, dev
);
1315 /* this was setfunc as uart */
1316 if(strstr(pdev
->name
,":uart")) {
1323 static int cpm_uart_init(void) {
1328 printk(KERN_INFO
"Serial: CPM driver $Revision: 0.02 $\n");
1330 /* lookup the bus for uart devices */
1331 dev
= bus_find_device(&platform_bus_type
, NULL
, 0, match_is_uart
);
1333 /* There are devices on the bus - all should be OK */
1336 cpm_reg
.nr
= cpm_uart_nr
;
1338 if (!(ret
= uart_register_driver(&cpm_reg
))) {
1339 if ((ret
= driver_register(&cpm_smc_uart_driver
))) {
1340 uart_unregister_driver(&cpm_reg
);
1343 if ((ret
= driver_register(&cpm_scc_uart_driver
))) {
1344 driver_unregister(&cpm_scc_uart_driver
);
1345 uart_unregister_driver(&cpm_reg
);
1349 /* No capable platform devices found - falling back to legacy mode */
1350 pr_info("cpm_uart: WARNING: no UART devices found on platform bus!\n");
1352 "cpm_uart: the driver will guess configuration, but this mode is no longer supported.\n");
1354 /* Don't run this again, if the console driver did it already */
1355 if (cpm_uart_nr
== 0)
1356 cpm_uart_init_portdesc();
1358 cpm_reg
.nr
= cpm_uart_nr
;
1359 ret
= uart_register_driver(&cpm_reg
);
1364 for (i
= 0; i
< cpm_uart_nr
; i
++) {
1365 int con
= cpm_uart_port_map
[i
];
1366 cpm_uart_ports
[con
].port
.line
= i
;
1367 cpm_uart_ports
[con
].port
.flags
= UPF_BOOT_AUTOCONF
;
1368 if (cpm_uart_ports
[con
].set_lineif
)
1369 cpm_uart_ports
[con
].set_lineif(&cpm_uart_ports
[con
]);
1370 uart_add_one_port(&cpm_reg
, &cpm_uart_ports
[con
].port
);
1377 static void __exit
cpm_uart_exit(void)
1379 driver_unregister(&cpm_scc_uart_driver
);
1380 driver_unregister(&cpm_smc_uart_driver
);
1381 uart_unregister_driver(&cpm_reg
);
1384 module_init(cpm_uart_init
);
1385 module_exit(cpm_uart_exit
);
1387 MODULE_AUTHOR("Kumar Gala/Antoniou Pantelis");
1388 MODULE_DESCRIPTION("CPM SCC/SMC port driver $Revision: 0.01 $");
1389 MODULE_LICENSE("GPL");
1390 MODULE_ALIAS_CHARDEV(SERIAL_CPM_MAJOR
, SERIAL_CPM_MINOR
);