2 * Generic driver for the MPSC (UART mode) on Marvell parts (e.g., GT64240,
3 * GT64260, MV64340, MV64360, GT96100, ... ).
5 * Author: Mark A. Greer <mgreer@mvista.com>
7 * Based on an old MPSC driver that was in the linuxppc tree. It appears to
8 * have been created by Chris Zankel (formerly of MontaVista) but there
9 * is no proper Copyright so I'm not sure. Apparently, parts were also
10 * taken from PPCBoot (now U-Boot). Also based on drivers/serial/8250.c
13 * 2004 (c) MontaVista, Software, Inc. This file is licensed under
14 * the terms of the GNU General Public License version 2. This program
15 * is licensed "as is" without any warranty of any kind, whether express
19 * The MPSC interface is much like a typical network controller's interface.
20 * That is, you set up separate rings of descriptors for transmitting and
21 * receiving data. There is also a pool of buffers with (one buffer per
22 * descriptor) that incoming data are dma'd into or outgoing data are dma'd
25 * The MPSC requires two other controllers to be able to work. The Baud Rate
26 * Generator (BRG) provides a clock at programmable frequencies which determines
27 * the baud rate. The Serial DMA Controller (SDMA) takes incoming data from the
28 * MPSC and DMA's it into memory or DMA's outgoing data and passes it to the
29 * MPSC. It is actually the SDMA interrupt that the driver uses to keep the
30 * transmit and receive "engines" going (i.e., indicate data has been
31 * transmitted or received).
35 * 1) Some chips have an erratum where several regs cannot be
36 * read. To work around that, we keep a local copy of those regs in
39 * 2) Some chips have an erratum where the ctlr will hang when the SDMA ctlr
40 * accesses system mem with coherency enabled. For that reason, the driver
41 * assumes that coherency for that ctlr has been disabled. This means
42 * that when in a cache coherent system, the driver has to manually manage
43 * the data cache on the areas that it touches because the dma_* macro are
46 * 3) There is an erratum (on PPC) where you can't use the instruction to do
47 * a DMA_TO_DEVICE/cache clean so DMA_BIDIRECTIONAL/flushes are used in places
48 * where a DMA_TO_DEVICE/clean would have [otherwise] sufficed.
50 * 4) AFAICT, hardware flow control isn't supported by the controller --MAG.
53 #include <linux/config.h>
55 #if defined(CONFIG_SERIAL_MPSC_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
59 #include <linux/module.h>
60 #include <linux/moduleparam.h>
61 #include <linux/tty.h>
62 #include <linux/tty_flip.h>
63 #include <linux/ioport.h>
64 #include <linux/init.h>
65 #include <linux/console.h>
66 #include <linux/sysrq.h>
67 #include <linux/serial.h>
68 #include <linux/serial_core.h>
69 #include <linux/delay.h>
70 #include <linux/device.h>
71 #include <linux/dma-mapping.h>
72 #include <linux/mv643xx.h>
73 #include <linux/platform_device.h>
78 #if defined(CONFIG_SERIAL_MPSC_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
82 #define MPSC_NUM_CTLRS 2
85 * Descriptors and buffers must be cache line aligned.
86 * Buffers lengths must be multiple of cache line size.
87 * Number of Tx & Rx descriptors must be powers of 2.
89 #define MPSC_RXR_ENTRIES 32
90 #define MPSC_RXRE_SIZE dma_get_cache_alignment()
91 #define MPSC_RXR_SIZE (MPSC_RXR_ENTRIES * MPSC_RXRE_SIZE)
92 #define MPSC_RXBE_SIZE dma_get_cache_alignment()
93 #define MPSC_RXB_SIZE (MPSC_RXR_ENTRIES * MPSC_RXBE_SIZE)
95 #define MPSC_TXR_ENTRIES 32
96 #define MPSC_TXRE_SIZE dma_get_cache_alignment()
97 #define MPSC_TXR_SIZE (MPSC_TXR_ENTRIES * MPSC_TXRE_SIZE)
98 #define MPSC_TXBE_SIZE dma_get_cache_alignment()
99 #define MPSC_TXB_SIZE (MPSC_TXR_ENTRIES * MPSC_TXBE_SIZE)
101 #define MPSC_DMA_ALLOC_SIZE (MPSC_RXR_SIZE + MPSC_RXB_SIZE + \
102 MPSC_TXR_SIZE + MPSC_TXB_SIZE + \
103 dma_get_cache_alignment() /* for alignment */)
105 /* Rx and Tx Ring entry descriptors -- assume entry size is <= cacheline size */
106 struct mpsc_rx_desc
{
112 } __attribute((packed
));
114 struct mpsc_tx_desc
{
120 } __attribute((packed
));
123 * Some regs that have the erratum that you can't read them are are shared
124 * between the two MPSC controllers. This struct contains those shared regs.
126 struct mpsc_shared_regs
{
127 phys_addr_t mpsc_routing_base_p
;
128 phys_addr_t sdma_intr_base_p
;
130 void __iomem
*mpsc_routing_base
;
131 void __iomem
*sdma_intr_base
;
136 u32 SDMA_INTR_CAUSE_m
;
137 u32 SDMA_INTR_MASK_m
;
140 /* The main driver data structure */
141 struct mpsc_port_info
{
142 struct uart_port port
; /* Overlay uart_port structure */
144 /* Internal driver state for this ctlr */
147 tcflag_t c_iflag
; /* save termios->c_iflag */
148 tcflag_t c_cflag
; /* save termios->c_cflag */
150 /* Info passed in from platform */
151 u8 mirror_regs
; /* Need to mirror regs? */
152 u8 cache_mgmt
; /* Need manual cache mgmt? */
153 u8 brg_can_tune
; /* BRG has baud tuning? */
161 /* Physical addresses of various blocks of registers (from platform) */
162 phys_addr_t mpsc_base_p
;
163 phys_addr_t sdma_base_p
;
164 phys_addr_t brg_base_p
;
166 /* Virtual addresses of various blocks of registers (from platform) */
167 void __iomem
*mpsc_base
;
168 void __iomem
*sdma_base
;
169 void __iomem
*brg_base
;
171 /* Descriptor ring and buffer allocations */
173 dma_addr_t dma_region_p
;
175 dma_addr_t rxr
; /* Rx descriptor ring */
176 dma_addr_t rxr_p
; /* Phys addr of rxr */
177 u8
*rxb
; /* Rx Ring I/O buf */
178 u8
*rxb_p
; /* Phys addr of rxb */
179 u32 rxr_posn
; /* First desc w/ Rx data */
181 dma_addr_t txr
; /* Tx descriptor ring */
182 dma_addr_t txr_p
; /* Phys addr of txr */
183 u8
*txb
; /* Tx Ring I/O buf */
184 u8
*txb_p
; /* Phys addr of txb */
185 int txr_head
; /* Where new data goes */
186 int txr_tail
; /* Where sent data comes off */
188 /* Mirrored values of regs we can't read (if 'mirror_regs' set) */
194 struct mpsc_shared_regs
*shared_regs
;
197 /* Hooks to platform-specific code */
198 int mpsc_platform_register_driver(void);
199 void mpsc_platform_unregister_driver(void);
201 /* Hooks back in to mpsc common to be called by platform-specific code */
202 struct mpsc_port_info
*mpsc_device_probe(int index
);
203 struct mpsc_port_info
*mpsc_device_remove(int index
);
205 /* Main MPSC Configuration Register Offsets */
206 #define MPSC_MMCRL 0x0000
207 #define MPSC_MMCRH 0x0004
208 #define MPSC_MPCR 0x0008
209 #define MPSC_CHR_1 0x000c
210 #define MPSC_CHR_2 0x0010
211 #define MPSC_CHR_3 0x0014
212 #define MPSC_CHR_4 0x0018
213 #define MPSC_CHR_5 0x001c
214 #define MPSC_CHR_6 0x0020
215 #define MPSC_CHR_7 0x0024
216 #define MPSC_CHR_8 0x0028
217 #define MPSC_CHR_9 0x002c
218 #define MPSC_CHR_10 0x0030
219 #define MPSC_CHR_11 0x0034
221 #define MPSC_MPCR_FRZ (1 << 9)
222 #define MPSC_MPCR_CL_5 0
223 #define MPSC_MPCR_CL_6 1
224 #define MPSC_MPCR_CL_7 2
225 #define MPSC_MPCR_CL_8 3
226 #define MPSC_MPCR_SBL_1 0
227 #define MPSC_MPCR_SBL_2 1
229 #define MPSC_CHR_2_TEV (1<<1)
230 #define MPSC_CHR_2_TA (1<<7)
231 #define MPSC_CHR_2_TTCS (1<<9)
232 #define MPSC_CHR_2_REV (1<<17)
233 #define MPSC_CHR_2_RA (1<<23)
234 #define MPSC_CHR_2_CRD (1<<25)
235 #define MPSC_CHR_2_EH (1<<31)
236 #define MPSC_CHR_2_PAR_ODD 0
237 #define MPSC_CHR_2_PAR_SPACE 1
238 #define MPSC_CHR_2_PAR_EVEN 2
239 #define MPSC_CHR_2_PAR_MARK 3
241 /* MPSC Signal Routing */
242 #define MPSC_MRR 0x0000
243 #define MPSC_RCRR 0x0004
244 #define MPSC_TCRR 0x0008
246 /* Serial DMA Controller Interface Registers */
247 #define SDMA_SDC 0x0000
248 #define SDMA_SDCM 0x0008
249 #define SDMA_RX_DESC 0x0800
250 #define SDMA_RX_BUF_PTR 0x0808
251 #define SDMA_SCRDP 0x0810
252 #define SDMA_TX_DESC 0x0c00
253 #define SDMA_SCTDP 0x0c10
254 #define SDMA_SFTDP 0x0c14
256 #define SDMA_DESC_CMDSTAT_PE (1<<0)
257 #define SDMA_DESC_CMDSTAT_CDL (1<<1)
258 #define SDMA_DESC_CMDSTAT_FR (1<<3)
259 #define SDMA_DESC_CMDSTAT_OR (1<<6)
260 #define SDMA_DESC_CMDSTAT_BR (1<<9)
261 #define SDMA_DESC_CMDSTAT_MI (1<<10)
262 #define SDMA_DESC_CMDSTAT_A (1<<11)
263 #define SDMA_DESC_CMDSTAT_AM (1<<12)
264 #define SDMA_DESC_CMDSTAT_CT (1<<13)
265 #define SDMA_DESC_CMDSTAT_C (1<<14)
266 #define SDMA_DESC_CMDSTAT_ES (1<<15)
267 #define SDMA_DESC_CMDSTAT_L (1<<16)
268 #define SDMA_DESC_CMDSTAT_F (1<<17)
269 #define SDMA_DESC_CMDSTAT_P (1<<18)
270 #define SDMA_DESC_CMDSTAT_EI (1<<23)
271 #define SDMA_DESC_CMDSTAT_O (1<<31)
273 #define SDMA_DESC_DFLT (SDMA_DESC_CMDSTAT_O | \
274 SDMA_DESC_CMDSTAT_EI)
276 #define SDMA_SDC_RFT (1<<0)
277 #define SDMA_SDC_SFM (1<<1)
278 #define SDMA_SDC_BLMR (1<<6)
279 #define SDMA_SDC_BLMT (1<<7)
280 #define SDMA_SDC_POVR (1<<8)
281 #define SDMA_SDC_RIFB (1<<9)
283 #define SDMA_SDCM_ERD (1<<7)
284 #define SDMA_SDCM_AR (1<<15)
285 #define SDMA_SDCM_STD (1<<16)
286 #define SDMA_SDCM_TXD (1<<23)
287 #define SDMA_SDCM_AT (1<<31)
289 #define SDMA_0_CAUSE_RXBUF (1<<0)
290 #define SDMA_0_CAUSE_RXERR (1<<1)
291 #define SDMA_0_CAUSE_TXBUF (1<<2)
292 #define SDMA_0_CAUSE_TXEND (1<<3)
293 #define SDMA_1_CAUSE_RXBUF (1<<8)
294 #define SDMA_1_CAUSE_RXERR (1<<9)
295 #define SDMA_1_CAUSE_TXBUF (1<<10)
296 #define SDMA_1_CAUSE_TXEND (1<<11)
298 #define SDMA_CAUSE_RX_MASK (SDMA_0_CAUSE_RXBUF | SDMA_0_CAUSE_RXERR | \
299 SDMA_1_CAUSE_RXBUF | SDMA_1_CAUSE_RXERR)
300 #define SDMA_CAUSE_TX_MASK (SDMA_0_CAUSE_TXBUF | SDMA_0_CAUSE_TXEND | \
301 SDMA_1_CAUSE_TXBUF | SDMA_1_CAUSE_TXEND)
303 /* SDMA Interrupt registers */
304 #define SDMA_INTR_CAUSE 0x0000
305 #define SDMA_INTR_MASK 0x0080
307 /* Baud Rate Generator Interface Registers */
308 #define BRG_BCR 0x0000
309 #define BRG_BTR 0x0004
312 * Define how this driver is known to the outside (we've been assigned a
313 * range on the "Low-density serial ports" major).
315 #define MPSC_MAJOR 204
316 #define MPSC_MINOR_START 44
317 #define MPSC_DRIVER_NAME "MPSC"
318 #define MPSC_DEV_NAME "ttyMM"
319 #define MPSC_VERSION "1.00"
321 static struct mpsc_port_info mpsc_ports
[MPSC_NUM_CTLRS
];
322 static struct mpsc_shared_regs mpsc_shared_regs
;
323 static struct uart_driver mpsc_reg
;
325 static void mpsc_start_rx(struct mpsc_port_info
*pi
);
326 static void mpsc_free_ring_mem(struct mpsc_port_info
*pi
);
327 static void mpsc_release_port(struct uart_port
*port
);
329 ******************************************************************************
331 * Baud Rate Generator Routines (BRG)
333 ******************************************************************************
336 mpsc_brg_init(struct mpsc_port_info
*pi
, u32 clk_src
)
340 v
= (pi
->mirror_regs
) ? pi
->BRG_BCR_m
: readl(pi
->brg_base
+ BRG_BCR
);
341 v
= (v
& ~(0xf << 18)) | ((clk_src
& 0xf) << 18);
343 if (pi
->brg_can_tune
)
348 writel(v
, pi
->brg_base
+ BRG_BCR
);
350 writel(readl(pi
->brg_base
+ BRG_BTR
) & 0xffff0000,
351 pi
->brg_base
+ BRG_BTR
);
356 mpsc_brg_enable(struct mpsc_port_info
*pi
)
360 v
= (pi
->mirror_regs
) ? pi
->BRG_BCR_m
: readl(pi
->brg_base
+ BRG_BCR
);
365 writel(v
, pi
->brg_base
+ BRG_BCR
);
370 mpsc_brg_disable(struct mpsc_port_info
*pi
)
374 v
= (pi
->mirror_regs
) ? pi
->BRG_BCR_m
: readl(pi
->brg_base
+ BRG_BCR
);
379 writel(v
, pi
->brg_base
+ BRG_BCR
);
384 mpsc_set_baudrate(struct mpsc_port_info
*pi
, u32 baud
)
387 * To set the baud, we adjust the CDV field in the BRG_BCR reg.
388 * From manual: Baud = clk / ((CDV+1)*2) ==> CDV = (clk / (baud*2)) - 1.
389 * However, the input clock is divided by 16 in the MPSC b/c of how
390 * 'MPSC_MMCRH' was set up so we have to divide the 'clk' used in our
391 * calculation by 16 to account for that. So the real calculation
392 * that accounts for the way the mpsc is set up is:
393 * CDV = (clk / (baud*2*16)) - 1 ==> CDV = (clk / (baud << 5)) - 1.
395 u32 cdv
= (pi
->port
.uartclk
/ (baud
<< 5)) - 1;
398 mpsc_brg_disable(pi
);
399 v
= (pi
->mirror_regs
) ? pi
->BRG_BCR_m
: readl(pi
->brg_base
+ BRG_BCR
);
400 v
= (v
& 0xffff0000) | (cdv
& 0xffff);
404 writel(v
, pi
->brg_base
+ BRG_BCR
);
411 ******************************************************************************
413 * Serial DMA Routines (SDMA)
415 ******************************************************************************
419 mpsc_sdma_burstsize(struct mpsc_port_info
*pi
, u32 burst_size
)
423 pr_debug("mpsc_sdma_burstsize[%d]: burst_size: %d\n",
424 pi
->port
.line
, burst_size
);
426 burst_size
>>= 3; /* Divide by 8 b/c reg values are 8-byte chunks */
429 v
= 0x0; /* 1 64-bit word */
430 else if (burst_size
< 4)
431 v
= 0x1; /* 2 64-bit words */
432 else if (burst_size
< 8)
433 v
= 0x2; /* 4 64-bit words */
435 v
= 0x3; /* 8 64-bit words */
437 writel((readl(pi
->sdma_base
+ SDMA_SDC
) & (0x3 << 12)) | (v
<< 12),
438 pi
->sdma_base
+ SDMA_SDC
);
443 mpsc_sdma_init(struct mpsc_port_info
*pi
, u32 burst_size
)
445 pr_debug("mpsc_sdma_init[%d]: burst_size: %d\n", pi
->port
.line
,
448 writel((readl(pi
->sdma_base
+ SDMA_SDC
) & 0x3ff) | 0x03f,
449 pi
->sdma_base
+ SDMA_SDC
);
450 mpsc_sdma_burstsize(pi
, burst_size
);
455 mpsc_sdma_intr_mask(struct mpsc_port_info
*pi
, u32 mask
)
459 pr_debug("mpsc_sdma_intr_mask[%d]: mask: 0x%x\n", pi
->port
.line
, mask
);
461 old
= v
= (pi
->mirror_regs
) ? pi
->shared_regs
->SDMA_INTR_MASK_m
:
462 readl(pi
->shared_regs
->sdma_intr_base
+ SDMA_INTR_MASK
);
470 pi
->shared_regs
->SDMA_INTR_MASK_m
= v
;
471 writel(v
, pi
->shared_regs
->sdma_intr_base
+ SDMA_INTR_MASK
);
479 mpsc_sdma_intr_unmask(struct mpsc_port_info
*pi
, u32 mask
)
483 pr_debug("mpsc_sdma_intr_unmask[%d]: mask: 0x%x\n", pi
->port
.line
,mask
);
485 v
= (pi
->mirror_regs
) ? pi
->shared_regs
->SDMA_INTR_MASK_m
:
486 readl(pi
->shared_regs
->sdma_intr_base
+ SDMA_INTR_MASK
);
494 pi
->shared_regs
->SDMA_INTR_MASK_m
= v
;
495 writel(v
, pi
->shared_regs
->sdma_intr_base
+ SDMA_INTR_MASK
);
500 mpsc_sdma_intr_ack(struct mpsc_port_info
*pi
)
502 pr_debug("mpsc_sdma_intr_ack[%d]: Acknowledging IRQ\n", pi
->port
.line
);
505 pi
->shared_regs
->SDMA_INTR_CAUSE_m
= 0;
506 writel(0, pi
->shared_regs
->sdma_intr_base
+ SDMA_INTR_CAUSE
);
511 mpsc_sdma_set_rx_ring(struct mpsc_port_info
*pi
, struct mpsc_rx_desc
*rxre_p
)
513 pr_debug("mpsc_sdma_set_rx_ring[%d]: rxre_p: 0x%x\n",
514 pi
->port
.line
, (u32
) rxre_p
);
516 writel((u32
)rxre_p
, pi
->sdma_base
+ SDMA_SCRDP
);
521 mpsc_sdma_set_tx_ring(struct mpsc_port_info
*pi
, struct mpsc_tx_desc
*txre_p
)
523 writel((u32
)txre_p
, pi
->sdma_base
+ SDMA_SFTDP
);
524 writel((u32
)txre_p
, pi
->sdma_base
+ SDMA_SCTDP
);
529 mpsc_sdma_cmd(struct mpsc_port_info
*pi
, u32 val
)
533 v
= readl(pi
->sdma_base
+ SDMA_SDCM
);
539 writel(v
, pi
->sdma_base
+ SDMA_SDCM
);
545 mpsc_sdma_tx_active(struct mpsc_port_info
*pi
)
547 return readl(pi
->sdma_base
+ SDMA_SDCM
) & SDMA_SDCM_TXD
;
551 mpsc_sdma_start_tx(struct mpsc_port_info
*pi
)
553 struct mpsc_tx_desc
*txre
, *txre_p
;
555 /* If tx isn't running & there's a desc ready to go, start it */
556 if (!mpsc_sdma_tx_active(pi
)) {
557 txre
= (struct mpsc_tx_desc
*)(pi
->txr
+
558 (pi
->txr_tail
* MPSC_TXRE_SIZE
));
559 dma_cache_sync((void *) txre
, MPSC_TXRE_SIZE
, DMA_FROM_DEVICE
);
560 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
561 if (pi
->cache_mgmt
) /* GT642[46]0 Res #COMM-2 */
562 invalidate_dcache_range((ulong
)txre
,
563 (ulong
)txre
+ MPSC_TXRE_SIZE
);
566 if (be32_to_cpu(txre
->cmdstat
) & SDMA_DESC_CMDSTAT_O
) {
567 txre_p
= (struct mpsc_tx_desc
*)(pi
->txr_p
+
571 mpsc_sdma_set_tx_ring(pi
, txre_p
);
572 mpsc_sdma_cmd(pi
, SDMA_SDCM_STD
| SDMA_SDCM_TXD
);
580 mpsc_sdma_stop(struct mpsc_port_info
*pi
)
582 pr_debug("mpsc_sdma_stop[%d]: Stopping SDMA\n", pi
->port
.line
);
584 /* Abort any SDMA transfers */
585 mpsc_sdma_cmd(pi
, 0);
586 mpsc_sdma_cmd(pi
, SDMA_SDCM_AR
| SDMA_SDCM_AT
);
588 /* Clear the SDMA current and first TX and RX pointers */
589 mpsc_sdma_set_tx_ring(pi
, NULL
);
590 mpsc_sdma_set_rx_ring(pi
, NULL
);
592 /* Disable interrupts */
593 mpsc_sdma_intr_mask(pi
, 0xf);
594 mpsc_sdma_intr_ack(pi
);
600 ******************************************************************************
602 * Multi-Protocol Serial Controller Routines (MPSC)
604 ******************************************************************************
608 mpsc_hw_init(struct mpsc_port_info
*pi
)
612 pr_debug("mpsc_hw_init[%d]: Initializing hardware\n", pi
->port
.line
);
614 /* Set up clock routing */
615 if (pi
->mirror_regs
) {
616 v
= pi
->shared_regs
->MPSC_MRR_m
;
618 pi
->shared_regs
->MPSC_MRR_m
= v
;
619 writel(v
, pi
->shared_regs
->mpsc_routing_base
+ MPSC_MRR
);
621 v
= pi
->shared_regs
->MPSC_RCRR_m
;
622 v
= (v
& ~0xf0f) | 0x100;
623 pi
->shared_regs
->MPSC_RCRR_m
= v
;
624 writel(v
, pi
->shared_regs
->mpsc_routing_base
+ MPSC_RCRR
);
626 v
= pi
->shared_regs
->MPSC_TCRR_m
;
627 v
= (v
& ~0xf0f) | 0x100;
628 pi
->shared_regs
->MPSC_TCRR_m
= v
;
629 writel(v
, pi
->shared_regs
->mpsc_routing_base
+ MPSC_TCRR
);
632 v
= readl(pi
->shared_regs
->mpsc_routing_base
+ MPSC_MRR
);
634 writel(v
, pi
->shared_regs
->mpsc_routing_base
+ MPSC_MRR
);
636 v
= readl(pi
->shared_regs
->mpsc_routing_base
+ MPSC_RCRR
);
637 v
= (v
& ~0xf0f) | 0x100;
638 writel(v
, pi
->shared_regs
->mpsc_routing_base
+ MPSC_RCRR
);
640 v
= readl(pi
->shared_regs
->mpsc_routing_base
+ MPSC_TCRR
);
641 v
= (v
& ~0xf0f) | 0x100;
642 writel(v
, pi
->shared_regs
->mpsc_routing_base
+ MPSC_TCRR
);
645 /* Put MPSC in UART mode & enabel Tx/Rx egines */
646 writel(0x000004c4, pi
->mpsc_base
+ MPSC_MMCRL
);
648 /* No preamble, 16x divider, low-latency, */
649 writel(0x04400400, pi
->mpsc_base
+ MPSC_MMCRH
);
651 if (pi
->mirror_regs
) {
652 pi
->MPSC_CHR_1_m
= 0;
653 pi
->MPSC_CHR_2_m
= 0;
655 writel(0, pi
->mpsc_base
+ MPSC_CHR_1
);
656 writel(0, pi
->mpsc_base
+ MPSC_CHR_2
);
657 writel(pi
->mpsc_max_idle
, pi
->mpsc_base
+ MPSC_CHR_3
);
658 writel(0, pi
->mpsc_base
+ MPSC_CHR_4
);
659 writel(0, pi
->mpsc_base
+ MPSC_CHR_5
);
660 writel(0, pi
->mpsc_base
+ MPSC_CHR_6
);
661 writel(0, pi
->mpsc_base
+ MPSC_CHR_7
);
662 writel(0, pi
->mpsc_base
+ MPSC_CHR_8
);
663 writel(0, pi
->mpsc_base
+ MPSC_CHR_9
);
664 writel(0, pi
->mpsc_base
+ MPSC_CHR_10
);
670 mpsc_enter_hunt(struct mpsc_port_info
*pi
)
672 pr_debug("mpsc_enter_hunt[%d]: Hunting...\n", pi
->port
.line
);
674 if (pi
->mirror_regs
) {
675 writel(pi
->MPSC_CHR_2_m
| MPSC_CHR_2_EH
,
676 pi
->mpsc_base
+ MPSC_CHR_2
);
677 /* Erratum prevents reading CHR_2 so just delay for a while */
681 writel(readl(pi
->mpsc_base
+ MPSC_CHR_2
) | MPSC_CHR_2_EH
,
682 pi
->mpsc_base
+ MPSC_CHR_2
);
684 while (readl(pi
->mpsc_base
+ MPSC_CHR_2
) & MPSC_CHR_2_EH
)
692 mpsc_freeze(struct mpsc_port_info
*pi
)
696 pr_debug("mpsc_freeze[%d]: Freezing\n", pi
->port
.line
);
698 v
= (pi
->mirror_regs
) ? pi
->MPSC_MPCR_m
:
699 readl(pi
->mpsc_base
+ MPSC_MPCR
);
704 writel(v
, pi
->mpsc_base
+ MPSC_MPCR
);
709 mpsc_unfreeze(struct mpsc_port_info
*pi
)
713 v
= (pi
->mirror_regs
) ? pi
->MPSC_MPCR_m
:
714 readl(pi
->mpsc_base
+ MPSC_MPCR
);
719 writel(v
, pi
->mpsc_base
+ MPSC_MPCR
);
721 pr_debug("mpsc_unfreeze[%d]: Unfrozen\n", pi
->port
.line
);
726 mpsc_set_char_length(struct mpsc_port_info
*pi
, u32 len
)
730 pr_debug("mpsc_set_char_length[%d]: char len: %d\n", pi
->port
.line
,len
);
732 v
= (pi
->mirror_regs
) ? pi
->MPSC_MPCR_m
:
733 readl(pi
->mpsc_base
+ MPSC_MPCR
);
734 v
= (v
& ~(0x3 << 12)) | ((len
& 0x3) << 12);
738 writel(v
, pi
->mpsc_base
+ MPSC_MPCR
);
743 mpsc_set_stop_bit_length(struct mpsc_port_info
*pi
, u32 len
)
747 pr_debug("mpsc_set_stop_bit_length[%d]: stop bits: %d\n",
750 v
= (pi
->mirror_regs
) ? pi
->MPSC_MPCR_m
:
751 readl(pi
->mpsc_base
+ MPSC_MPCR
);
753 v
= (v
& ~(1 << 14)) | ((len
& 0x1) << 14);
757 writel(v
, pi
->mpsc_base
+ MPSC_MPCR
);
762 mpsc_set_parity(struct mpsc_port_info
*pi
, u32 p
)
766 pr_debug("mpsc_set_parity[%d]: parity bits: 0x%x\n", pi
->port
.line
, p
);
768 v
= (pi
->mirror_regs
) ? pi
->MPSC_CHR_2_m
:
769 readl(pi
->mpsc_base
+ MPSC_CHR_2
);
772 v
= (v
& ~0xc000c) | (p
<< 18) | (p
<< 2);
775 pi
->MPSC_CHR_2_m
= v
;
776 writel(v
, pi
->mpsc_base
+ MPSC_CHR_2
);
781 ******************************************************************************
783 * Driver Init Routines
785 ******************************************************************************
789 mpsc_init_hw(struct mpsc_port_info
*pi
)
791 pr_debug("mpsc_init_hw[%d]: Initializing\n", pi
->port
.line
);
793 mpsc_brg_init(pi
, pi
->brg_clk_src
);
795 mpsc_sdma_init(pi
, dma_get_cache_alignment()); /* burst a cacheline */
803 mpsc_alloc_ring_mem(struct mpsc_port_info
*pi
)
807 pr_debug("mpsc_alloc_ring_mem[%d]: Allocating ring mem\n",
810 if (!pi
->dma_region
) {
811 if (!dma_supported(pi
->port
.dev
, 0xffffffff)) {
812 printk(KERN_ERR
"MPSC: Inadequate DMA support\n");
815 else if ((pi
->dma_region
= dma_alloc_noncoherent(pi
->port
.dev
,
816 MPSC_DMA_ALLOC_SIZE
, &pi
->dma_region_p
, GFP_KERNEL
))
819 printk(KERN_ERR
"MPSC: Can't alloc Desc region\n");
828 mpsc_free_ring_mem(struct mpsc_port_info
*pi
)
830 pr_debug("mpsc_free_ring_mem[%d]: Freeing ring mem\n", pi
->port
.line
);
832 if (pi
->dma_region
) {
833 dma_free_noncoherent(pi
->port
.dev
, MPSC_DMA_ALLOC_SIZE
,
834 pi
->dma_region
, pi
->dma_region_p
);
835 pi
->dma_region
= NULL
;
836 pi
->dma_region_p
= (dma_addr_t
) NULL
;
843 mpsc_init_rings(struct mpsc_port_info
*pi
)
845 struct mpsc_rx_desc
*rxre
;
846 struct mpsc_tx_desc
*txre
;
851 pr_debug("mpsc_init_rings[%d]: Initializing rings\n", pi
->port
.line
);
853 BUG_ON(pi
->dma_region
== NULL
);
855 memset(pi
->dma_region
, 0, MPSC_DMA_ALLOC_SIZE
);
858 * Descriptors & buffers are multiples of cacheline size and must be
861 dp
= ALIGN((u32
) pi
->dma_region
, dma_get_cache_alignment());
862 dp_p
= ALIGN((u32
) pi
->dma_region_p
, dma_get_cache_alignment());
865 * Partition dma region into rx ring descriptor, rx buffers,
866 * tx ring descriptors, and tx buffers.
871 dp_p
+= MPSC_RXR_SIZE
;
874 pi
->rxb_p
= (u8
*) dp_p
;
876 dp_p
+= MPSC_RXB_SIZE
;
883 dp_p
+= MPSC_TXR_SIZE
;
886 pi
->txb_p
= (u8
*) dp_p
;
891 /* Init rx ring descriptors */
897 for (i
= 0; i
< MPSC_RXR_ENTRIES
; i
++) {
898 rxre
= (struct mpsc_rx_desc
*)dp
;
900 rxre
->bufsize
= cpu_to_be16(MPSC_RXBE_SIZE
);
901 rxre
->bytecnt
= cpu_to_be16(0);
902 rxre
->cmdstat
= cpu_to_be32(SDMA_DESC_CMDSTAT_O
|
903 SDMA_DESC_CMDSTAT_EI
|
904 SDMA_DESC_CMDSTAT_F
|
905 SDMA_DESC_CMDSTAT_L
);
906 rxre
->link
= cpu_to_be32(dp_p
+ MPSC_RXRE_SIZE
);
907 rxre
->buf_ptr
= cpu_to_be32(bp_p
);
909 dp
+= MPSC_RXRE_SIZE
;
910 dp_p
+= MPSC_RXRE_SIZE
;
911 bp
+= MPSC_RXBE_SIZE
;
912 bp_p
+= MPSC_RXBE_SIZE
;
914 rxre
->link
= cpu_to_be32(pi
->rxr_p
); /* Wrap last back to first */
916 /* Init tx ring descriptors */
922 for (i
= 0; i
< MPSC_TXR_ENTRIES
; i
++) {
923 txre
= (struct mpsc_tx_desc
*)dp
;
925 txre
->link
= cpu_to_be32(dp_p
+ MPSC_TXRE_SIZE
);
926 txre
->buf_ptr
= cpu_to_be32(bp_p
);
928 dp
+= MPSC_TXRE_SIZE
;
929 dp_p
+= MPSC_TXRE_SIZE
;
930 bp
+= MPSC_TXBE_SIZE
;
931 bp_p
+= MPSC_TXBE_SIZE
;
933 txre
->link
= cpu_to_be32(pi
->txr_p
); /* Wrap last back to first */
935 dma_cache_sync((void *) pi
->dma_region
, MPSC_DMA_ALLOC_SIZE
,
937 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
938 if (pi
->cache_mgmt
) /* GT642[46]0 Res #COMM-2 */
939 flush_dcache_range((ulong
)pi
->dma_region
,
940 (ulong
)pi
->dma_region
+ MPSC_DMA_ALLOC_SIZE
);
947 mpsc_uninit_rings(struct mpsc_port_info
*pi
)
949 pr_debug("mpsc_uninit_rings[%d]: Uninitializing rings\n",pi
->port
.line
);
951 BUG_ON(pi
->dma_region
== NULL
);
970 mpsc_make_ready(struct mpsc_port_info
*pi
)
974 pr_debug("mpsc_make_ready[%d]: Making cltr ready\n", pi
->port
.line
);
978 if ((rc
= mpsc_alloc_ring_mem(pi
)))
988 ******************************************************************************
990 * Interrupt Handling Routines
992 ******************************************************************************
996 mpsc_rx_intr(struct mpsc_port_info
*pi
, struct pt_regs
*regs
)
998 struct mpsc_rx_desc
*rxre
;
999 struct tty_struct
*tty
= pi
->port
.info
->tty
;
1000 u32 cmdstat
, bytes_in
, i
;
1003 char flag
= TTY_NORMAL
;
1005 pr_debug("mpsc_rx_intr[%d]: Handling Rx intr\n", pi
->port
.line
);
1007 rxre
= (struct mpsc_rx_desc
*)(pi
->rxr
+ (pi
->rxr_posn
*MPSC_RXRE_SIZE
));
1009 dma_cache_sync((void *)rxre
, MPSC_RXRE_SIZE
, DMA_FROM_DEVICE
);
1010 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
1011 if (pi
->cache_mgmt
) /* GT642[46]0 Res #COMM-2 */
1012 invalidate_dcache_range((ulong
)rxre
,
1013 (ulong
)rxre
+ MPSC_RXRE_SIZE
);
1017 * Loop through Rx descriptors handling ones that have been completed.
1019 while (!((cmdstat
= be32_to_cpu(rxre
->cmdstat
)) & SDMA_DESC_CMDSTAT_O
)){
1020 bytes_in
= be16_to_cpu(rxre
->bytecnt
);
1022 /* Following use of tty struct directly is deprecated */
1023 if (unlikely(tty_buffer_request_room(tty
, bytes_in
) < bytes_in
)) {
1024 if (tty
->low_latency
)
1025 tty_flip_buffer_push(tty
);
1027 * If this failed then we will throw away the bytes
1028 * but must do so to clear interrupts.
1032 bp
= pi
->rxb
+ (pi
->rxr_posn
* MPSC_RXBE_SIZE
);
1033 dma_cache_sync((void *) bp
, MPSC_RXBE_SIZE
, DMA_FROM_DEVICE
);
1034 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
1035 if (pi
->cache_mgmt
) /* GT642[46]0 Res #COMM-2 */
1036 invalidate_dcache_range((ulong
)bp
,
1037 (ulong
)bp
+ MPSC_RXBE_SIZE
);
1041 * Other than for parity error, the manual provides little
1042 * info on what data will be in a frame flagged by any of
1043 * these errors. For parity error, it is the last byte in
1044 * the buffer that had the error. As for the rest, I guess
1045 * we'll assume there is no data in the buffer.
1046 * If there is...it gets lost.
1048 if (unlikely(cmdstat
& (SDMA_DESC_CMDSTAT_BR
|
1049 SDMA_DESC_CMDSTAT_FR
| SDMA_DESC_CMDSTAT_OR
))) {
1051 pi
->port
.icount
.rx
++;
1053 if (cmdstat
& SDMA_DESC_CMDSTAT_BR
) { /* Break */
1054 pi
->port
.icount
.brk
++;
1056 if (uart_handle_break(&pi
->port
))
1059 else if (cmdstat
& SDMA_DESC_CMDSTAT_FR
)/* Framing */
1060 pi
->port
.icount
.frame
++;
1061 else if (cmdstat
& SDMA_DESC_CMDSTAT_OR
) /* Overrun */
1062 pi
->port
.icount
.overrun
++;
1064 cmdstat
&= pi
->port
.read_status_mask
;
1066 if (cmdstat
& SDMA_DESC_CMDSTAT_BR
)
1068 else if (cmdstat
& SDMA_DESC_CMDSTAT_FR
)
1070 else if (cmdstat
& SDMA_DESC_CMDSTAT_OR
)
1072 else if (cmdstat
& SDMA_DESC_CMDSTAT_PE
)
1076 if (uart_handle_sysrq_char(&pi
->port
, *bp
, regs
)) {
1082 if ((unlikely(cmdstat
& (SDMA_DESC_CMDSTAT_BR
|
1083 SDMA_DESC_CMDSTAT_FR
| SDMA_DESC_CMDSTAT_OR
))) &&
1084 !(cmdstat
& pi
->port
.ignore_status_mask
))
1086 tty_insert_flip_char(tty
, *bp
, flag
);
1088 for (i
=0; i
<bytes_in
; i
++)
1089 tty_insert_flip_char(tty
, *bp
++, TTY_NORMAL
);
1091 pi
->port
.icount
.rx
+= bytes_in
;
1095 rxre
->bytecnt
= cpu_to_be16(0);
1097 rxre
->cmdstat
= cpu_to_be32(SDMA_DESC_CMDSTAT_O
|
1098 SDMA_DESC_CMDSTAT_EI
|
1099 SDMA_DESC_CMDSTAT_F
|
1100 SDMA_DESC_CMDSTAT_L
);
1102 dma_cache_sync((void *)rxre
, MPSC_RXRE_SIZE
, DMA_BIDIRECTIONAL
);
1103 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
1104 if (pi
->cache_mgmt
) /* GT642[46]0 Res #COMM-2 */
1105 flush_dcache_range((ulong
)rxre
,
1106 (ulong
)rxre
+ MPSC_RXRE_SIZE
);
1109 /* Advance to next descriptor */
1110 pi
->rxr_posn
= (pi
->rxr_posn
+ 1) & (MPSC_RXR_ENTRIES
- 1);
1111 rxre
= (struct mpsc_rx_desc
*)(pi
->rxr
+
1112 (pi
->rxr_posn
* MPSC_RXRE_SIZE
));
1113 dma_cache_sync((void *)rxre
, MPSC_RXRE_SIZE
, DMA_FROM_DEVICE
);
1114 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
1115 if (pi
->cache_mgmt
) /* GT642[46]0 Res #COMM-2 */
1116 invalidate_dcache_range((ulong
)rxre
,
1117 (ulong
)rxre
+ MPSC_RXRE_SIZE
);
1123 /* Restart rx engine, if its stopped */
1124 if ((readl(pi
->sdma_base
+ SDMA_SDCM
) & SDMA_SDCM_ERD
) == 0)
1127 tty_flip_buffer_push(tty
);
1132 mpsc_setup_tx_desc(struct mpsc_port_info
*pi
, u32 count
, u32 intr
)
1134 struct mpsc_tx_desc
*txre
;
1136 txre
= (struct mpsc_tx_desc
*)(pi
->txr
+
1137 (pi
->txr_head
* MPSC_TXRE_SIZE
));
1139 txre
->bytecnt
= cpu_to_be16(count
);
1140 txre
->shadow
= txre
->bytecnt
;
1141 wmb(); /* ensure cmdstat is last field updated */
1142 txre
->cmdstat
= cpu_to_be32(SDMA_DESC_CMDSTAT_O
| SDMA_DESC_CMDSTAT_F
|
1143 SDMA_DESC_CMDSTAT_L
| ((intr
) ?
1144 SDMA_DESC_CMDSTAT_EI
1147 dma_cache_sync((void *) txre
, MPSC_TXRE_SIZE
, DMA_BIDIRECTIONAL
);
1148 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
1149 if (pi
->cache_mgmt
) /* GT642[46]0 Res #COMM-2 */
1150 flush_dcache_range((ulong
)txre
,
1151 (ulong
)txre
+ MPSC_TXRE_SIZE
);
1158 mpsc_copy_tx_data(struct mpsc_port_info
*pi
)
1160 struct circ_buf
*xmit
= &pi
->port
.info
->xmit
;
1164 /* Make sure the desc ring isn't full */
1165 while (CIRC_CNT(pi
->txr_head
, pi
->txr_tail
, MPSC_TXR_ENTRIES
) <
1166 (MPSC_TXR_ENTRIES
- 1)) {
1167 if (pi
->port
.x_char
) {
1169 * Ideally, we should use the TCS field in
1170 * CHR_1 to put the x_char out immediately but
1171 * errata prevents us from being able to read
1172 * CHR_2 to know that its safe to write to
1173 * CHR_1. Instead, just put it in-band with
1174 * all the other Tx data.
1176 bp
= pi
->txb
+ (pi
->txr_head
* MPSC_TXBE_SIZE
);
1177 *bp
= pi
->port
.x_char
;
1178 pi
->port
.x_char
= 0;
1181 else if (!uart_circ_empty(xmit
) && !uart_tx_stopped(&pi
->port
)){
1182 i
= min((u32
) MPSC_TXBE_SIZE
,
1183 (u32
) uart_circ_chars_pending(xmit
));
1184 i
= min(i
, (u32
) CIRC_CNT_TO_END(xmit
->head
, xmit
->tail
,
1186 bp
= pi
->txb
+ (pi
->txr_head
* MPSC_TXBE_SIZE
);
1187 memcpy(bp
, &xmit
->buf
[xmit
->tail
], i
);
1188 xmit
->tail
= (xmit
->tail
+ i
) & (UART_XMIT_SIZE
- 1);
1190 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
1191 uart_write_wakeup(&pi
->port
);
1193 else /* All tx data copied into ring bufs */
1196 dma_cache_sync((void *) bp
, MPSC_TXBE_SIZE
, DMA_BIDIRECTIONAL
);
1197 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
1198 if (pi
->cache_mgmt
) /* GT642[46]0 Res #COMM-2 */
1199 flush_dcache_range((ulong
)bp
,
1200 (ulong
)bp
+ MPSC_TXBE_SIZE
);
1202 mpsc_setup_tx_desc(pi
, i
, 1);
1204 /* Advance to next descriptor */
1205 pi
->txr_head
= (pi
->txr_head
+ 1) & (MPSC_TXR_ENTRIES
- 1);
1212 mpsc_tx_intr(struct mpsc_port_info
*pi
)
1214 struct mpsc_tx_desc
*txre
;
1217 if (!mpsc_sdma_tx_active(pi
)) {
1218 txre
= (struct mpsc_tx_desc
*)(pi
->txr
+
1219 (pi
->txr_tail
* MPSC_TXRE_SIZE
));
1221 dma_cache_sync((void *) txre
, MPSC_TXRE_SIZE
, DMA_FROM_DEVICE
);
1222 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
1223 if (pi
->cache_mgmt
) /* GT642[46]0 Res #COMM-2 */
1224 invalidate_dcache_range((ulong
)txre
,
1225 (ulong
)txre
+ MPSC_TXRE_SIZE
);
1228 while (!(be32_to_cpu(txre
->cmdstat
) & SDMA_DESC_CMDSTAT_O
)) {
1230 pi
->port
.icount
.tx
+= be16_to_cpu(txre
->bytecnt
);
1231 pi
->txr_tail
= (pi
->txr_tail
+1) & (MPSC_TXR_ENTRIES
-1);
1233 /* If no more data to tx, fall out of loop */
1234 if (pi
->txr_head
== pi
->txr_tail
)
1237 txre
= (struct mpsc_tx_desc
*)(pi
->txr
+
1238 (pi
->txr_tail
* MPSC_TXRE_SIZE
));
1239 dma_cache_sync((void *) txre
, MPSC_TXRE_SIZE
,
1241 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
1242 if (pi
->cache_mgmt
) /* GT642[46]0 Res #COMM-2 */
1243 invalidate_dcache_range((ulong
)txre
,
1244 (ulong
)txre
+ MPSC_TXRE_SIZE
);
1248 mpsc_copy_tx_data(pi
);
1249 mpsc_sdma_start_tx(pi
); /* start next desc if ready */
1256 * This is the driver's interrupt handler. To avoid a race, we first clear
1257 * the interrupt, then handle any completed Rx/Tx descriptors. When done
1258 * handling those descriptors, we restart the Rx/Tx engines if they're stopped.
1261 mpsc_sdma_intr(int irq
, void *dev_id
, struct pt_regs
*regs
)
1263 struct mpsc_port_info
*pi
= dev_id
;
1267 pr_debug("mpsc_sdma_intr[%d]: SDMA Interrupt Received\n",pi
->port
.line
);
1269 spin_lock_irqsave(&pi
->port
.lock
, iflags
);
1270 mpsc_sdma_intr_ack(pi
);
1271 if (mpsc_rx_intr(pi
, regs
))
1273 if (mpsc_tx_intr(pi
))
1275 spin_unlock_irqrestore(&pi
->port
.lock
, iflags
);
1277 pr_debug("mpsc_sdma_intr[%d]: SDMA Interrupt Handled\n", pi
->port
.line
);
1282 ******************************************************************************
1284 * serial_core.c Interface routines
1286 ******************************************************************************
1289 mpsc_tx_empty(struct uart_port
*port
)
1291 struct mpsc_port_info
*pi
= (struct mpsc_port_info
*)port
;
1295 spin_lock_irqsave(&pi
->port
.lock
, iflags
);
1296 rc
= mpsc_sdma_tx_active(pi
) ? 0 : TIOCSER_TEMT
;
1297 spin_unlock_irqrestore(&pi
->port
.lock
, iflags
);
1303 mpsc_set_mctrl(struct uart_port
*port
, uint mctrl
)
1305 /* Have no way to set modem control lines AFAICT */
1310 mpsc_get_mctrl(struct uart_port
*port
)
1312 struct mpsc_port_info
*pi
= (struct mpsc_port_info
*)port
;
1315 status
= (pi
->mirror_regs
) ? pi
->MPSC_CHR_10_m
:
1316 readl(pi
->mpsc_base
+ MPSC_CHR_10
);
1320 mflags
|= TIOCM_CTS
;
1322 mflags
|= TIOCM_CAR
;
1324 return mflags
| TIOCM_DSR
; /* No way to tell if DSR asserted */
1328 mpsc_stop_tx(struct uart_port
*port
)
1330 struct mpsc_port_info
*pi
= (struct mpsc_port_info
*)port
;
1332 pr_debug("mpsc_stop_tx[%d]\n", port
->line
);
1339 mpsc_start_tx(struct uart_port
*port
)
1341 struct mpsc_port_info
*pi
= (struct mpsc_port_info
*)port
;
1344 mpsc_copy_tx_data(pi
);
1345 mpsc_sdma_start_tx(pi
);
1347 pr_debug("mpsc_start_tx[%d]\n", port
->line
);
1352 mpsc_start_rx(struct mpsc_port_info
*pi
)
1354 pr_debug("mpsc_start_rx[%d]: Starting...\n", pi
->port
.line
);
1356 /* Issue a Receive Abort to clear any receive errors */
1357 writel(MPSC_CHR_2_RA
, pi
->mpsc_base
+ MPSC_CHR_2
);
1359 mpsc_enter_hunt(pi
);
1360 mpsc_sdma_cmd(pi
, SDMA_SDCM_ERD
);
1366 mpsc_stop_rx(struct uart_port
*port
)
1368 struct mpsc_port_info
*pi
= (struct mpsc_port_info
*)port
;
1370 pr_debug("mpsc_stop_rx[%d]: Stopping...\n", port
->line
);
1372 mpsc_sdma_cmd(pi
, SDMA_SDCM_AR
);
1377 mpsc_enable_ms(struct uart_port
*port
)
1379 return; /* Not supported */
1383 mpsc_break_ctl(struct uart_port
*port
, int ctl
)
1385 struct mpsc_port_info
*pi
= (struct mpsc_port_info
*)port
;
1389 v
= ctl
? 0x00ff0000 : 0;
1391 spin_lock_irqsave(&pi
->port
.lock
, flags
);
1392 if (pi
->mirror_regs
)
1393 pi
->MPSC_CHR_1_m
= v
;
1394 writel(v
, pi
->mpsc_base
+ MPSC_CHR_1
);
1395 spin_unlock_irqrestore(&pi
->port
.lock
, flags
);
1401 mpsc_startup(struct uart_port
*port
)
1403 struct mpsc_port_info
*pi
= (struct mpsc_port_info
*)port
;
1407 pr_debug("mpsc_startup[%d]: Starting up MPSC, irq: %d\n",
1408 port
->line
, pi
->port
.irq
);
1410 if ((rc
= mpsc_make_ready(pi
)) == 0) {
1411 /* Setup IRQ handler */
1412 mpsc_sdma_intr_ack(pi
);
1414 /* If irq's are shared, need to set flag */
1415 if (mpsc_ports
[0].port
.irq
== mpsc_ports
[1].port
.irq
)
1418 if (request_irq(pi
->port
.irq
, mpsc_sdma_intr
, flag
,
1420 printk(KERN_ERR
"MPSC: Can't get SDMA IRQ %d\n",
1423 mpsc_sdma_intr_unmask(pi
, 0xf);
1424 mpsc_sdma_set_rx_ring(pi
, (struct mpsc_rx_desc
*)(pi
->rxr_p
+
1425 (pi
->rxr_posn
* MPSC_RXRE_SIZE
)));
1432 mpsc_shutdown(struct uart_port
*port
)
1434 struct mpsc_port_info
*pi
= (struct mpsc_port_info
*)port
;
1436 pr_debug("mpsc_shutdown[%d]: Shutting down MPSC\n", port
->line
);
1439 free_irq(pi
->port
.irq
, pi
);
1444 mpsc_set_termios(struct uart_port
*port
, struct termios
*termios
,
1445 struct termios
*old
)
1447 struct mpsc_port_info
*pi
= (struct mpsc_port_info
*)port
;
1450 u32 chr_bits
, stop_bits
, par
;
1452 pi
->c_iflag
= termios
->c_iflag
;
1453 pi
->c_cflag
= termios
->c_cflag
;
1455 switch (termios
->c_cflag
& CSIZE
) {
1457 chr_bits
= MPSC_MPCR_CL_5
;
1460 chr_bits
= MPSC_MPCR_CL_6
;
1463 chr_bits
= MPSC_MPCR_CL_7
;
1467 chr_bits
= MPSC_MPCR_CL_8
;
1471 if (termios
->c_cflag
& CSTOPB
)
1472 stop_bits
= MPSC_MPCR_SBL_2
;
1474 stop_bits
= MPSC_MPCR_SBL_1
;
1476 par
= MPSC_CHR_2_PAR_EVEN
;
1477 if (termios
->c_cflag
& PARENB
)
1478 if (termios
->c_cflag
& PARODD
)
1479 par
= MPSC_CHR_2_PAR_ODD
;
1481 if (termios
->c_cflag
& CMSPAR
) {
1482 if (termios
->c_cflag
& PARODD
)
1483 par
= MPSC_CHR_2_PAR_MARK
;
1485 par
= MPSC_CHR_2_PAR_SPACE
;
1489 baud
= uart_get_baud_rate(port
, termios
, old
, 0, port
->uartclk
);
1491 spin_lock_irqsave(&pi
->port
.lock
, flags
);
1493 uart_update_timeout(port
, termios
->c_cflag
, baud
);
1495 mpsc_set_char_length(pi
, chr_bits
);
1496 mpsc_set_stop_bit_length(pi
, stop_bits
);
1497 mpsc_set_parity(pi
, par
);
1498 mpsc_set_baudrate(pi
, baud
);
1500 /* Characters/events to read */
1502 pi
->port
.read_status_mask
= SDMA_DESC_CMDSTAT_OR
;
1504 if (termios
->c_iflag
& INPCK
)
1505 pi
->port
.read_status_mask
|= SDMA_DESC_CMDSTAT_PE
|
1506 SDMA_DESC_CMDSTAT_FR
;
1508 if (termios
->c_iflag
& (BRKINT
| PARMRK
))
1509 pi
->port
.read_status_mask
|= SDMA_DESC_CMDSTAT_BR
;
1511 /* Characters/events to ignore */
1512 pi
->port
.ignore_status_mask
= 0;
1514 if (termios
->c_iflag
& IGNPAR
)
1515 pi
->port
.ignore_status_mask
|= SDMA_DESC_CMDSTAT_PE
|
1516 SDMA_DESC_CMDSTAT_FR
;
1518 if (termios
->c_iflag
& IGNBRK
) {
1519 pi
->port
.ignore_status_mask
|= SDMA_DESC_CMDSTAT_BR
;
1521 if (termios
->c_iflag
& IGNPAR
)
1522 pi
->port
.ignore_status_mask
|= SDMA_DESC_CMDSTAT_OR
;
1525 /* Ignore all chars if CREAD not set */
1526 if (!(termios
->c_cflag
& CREAD
))
1531 spin_unlock_irqrestore(&pi
->port
.lock
, flags
);
1536 mpsc_type(struct uart_port
*port
)
1538 pr_debug("mpsc_type[%d]: port type: %s\n", port
->line
,MPSC_DRIVER_NAME
);
1539 return MPSC_DRIVER_NAME
;
1543 mpsc_request_port(struct uart_port
*port
)
1545 /* Should make chip/platform specific call */
1550 mpsc_release_port(struct uart_port
*port
)
1552 struct mpsc_port_info
*pi
= (struct mpsc_port_info
*)port
;
1555 mpsc_uninit_rings(pi
);
1556 mpsc_free_ring_mem(pi
);
1564 mpsc_config_port(struct uart_port
*port
, int flags
)
1570 mpsc_verify_port(struct uart_port
*port
, struct serial_struct
*ser
)
1572 struct mpsc_port_info
*pi
= (struct mpsc_port_info
*)port
;
1575 pr_debug("mpsc_verify_port[%d]: Verifying port data\n", pi
->port
.line
);
1577 if (ser
->type
!= PORT_UNKNOWN
&& ser
->type
!= PORT_MPSC
)
1579 else if (pi
->port
.irq
!= ser
->irq
)
1581 else if (ser
->io_type
!= SERIAL_IO_MEM
)
1583 else if (pi
->port
.uartclk
/ 16 != ser
->baud_base
) /* Not sure */
1585 else if ((void *)pi
->port
.mapbase
!= ser
->iomem_base
)
1587 else if (pi
->port
.iobase
!= ser
->port
)
1589 else if (ser
->hub6
!= 0)
1595 static struct uart_ops mpsc_pops
= {
1596 .tx_empty
= mpsc_tx_empty
,
1597 .set_mctrl
= mpsc_set_mctrl
,
1598 .get_mctrl
= mpsc_get_mctrl
,
1599 .stop_tx
= mpsc_stop_tx
,
1600 .start_tx
= mpsc_start_tx
,
1601 .stop_rx
= mpsc_stop_rx
,
1602 .enable_ms
= mpsc_enable_ms
,
1603 .break_ctl
= mpsc_break_ctl
,
1604 .startup
= mpsc_startup
,
1605 .shutdown
= mpsc_shutdown
,
1606 .set_termios
= mpsc_set_termios
,
1608 .release_port
= mpsc_release_port
,
1609 .request_port
= mpsc_request_port
,
1610 .config_port
= mpsc_config_port
,
1611 .verify_port
= mpsc_verify_port
,
1615 ******************************************************************************
1617 * Console Interface Routines
1619 ******************************************************************************
1622 #ifdef CONFIG_SERIAL_MPSC_CONSOLE
1624 mpsc_console_write(struct console
*co
, const char *s
, uint count
)
1626 struct mpsc_port_info
*pi
= &mpsc_ports
[co
->index
];
1627 u8
*bp
, *dp
, add_cr
= 0;
1630 while (mpsc_sdma_tx_active(pi
))
1634 bp
= dp
= pi
->txb
+ (pi
->txr_head
* MPSC_TXBE_SIZE
);
1636 for (i
= 0; i
< MPSC_TXBE_SIZE
; i
++) {
1647 if (*(s
++) == '\n') { /* add '\r' after '\n' */
1656 dma_cache_sync((void *) bp
, MPSC_TXBE_SIZE
, DMA_BIDIRECTIONAL
);
1657 #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
1658 if (pi
->cache_mgmt
) /* GT642[46]0 Res #COMM-2 */
1659 flush_dcache_range((ulong
)bp
,
1660 (ulong
)bp
+ MPSC_TXBE_SIZE
);
1662 mpsc_setup_tx_desc(pi
, i
, 0);
1663 pi
->txr_head
= (pi
->txr_head
+ 1) & (MPSC_TXR_ENTRIES
- 1);
1664 mpsc_sdma_start_tx(pi
);
1666 while (mpsc_sdma_tx_active(pi
))
1669 pi
->txr_tail
= (pi
->txr_tail
+ 1) & (MPSC_TXR_ENTRIES
- 1);
1676 mpsc_console_setup(struct console
*co
, char *options
)
1678 struct mpsc_port_info
*pi
;
1679 int baud
, bits
, parity
, flow
;
1681 pr_debug("mpsc_console_setup[%d]: options: %s\n", co
->index
, options
);
1683 if (co
->index
>= MPSC_NUM_CTLRS
)
1686 pi
= &mpsc_ports
[co
->index
];
1688 baud
= pi
->default_baud
;
1689 bits
= pi
->default_bits
;
1690 parity
= pi
->default_parity
;
1691 flow
= pi
->default_flow
;
1696 spin_lock_init(&pi
->port
.lock
); /* Temporary fix--copied from 8250.c */
1699 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
1701 return uart_set_options(&pi
->port
, co
, baud
, parity
, bits
, flow
);
1704 static struct console mpsc_console
= {
1705 .name
= MPSC_DEV_NAME
,
1706 .write
= mpsc_console_write
,
1707 .device
= uart_console_device
,
1708 .setup
= mpsc_console_setup
,
1709 .flags
= CON_PRINTBUFFER
,
1715 mpsc_late_console_init(void)
1717 pr_debug("mpsc_late_console_init: Enter\n");
1719 if (!(mpsc_console
.flags
& CON_ENABLED
))
1720 register_console(&mpsc_console
);
1724 late_initcall(mpsc_late_console_init
);
1726 #define MPSC_CONSOLE &mpsc_console
1728 #define MPSC_CONSOLE NULL
1731 ******************************************************************************
1733 * Dummy Platform Driver to extract & map shared register regions
1735 ******************************************************************************
1738 mpsc_resource_err(char *s
)
1740 printk(KERN_WARNING
"MPSC: Platform device resource error in %s\n", s
);
1745 mpsc_shared_map_regs(struct platform_device
*pd
)
1749 if ((r
= platform_get_resource(pd
, IORESOURCE_MEM
,
1750 MPSC_ROUTING_BASE_ORDER
)) && request_mem_region(r
->start
,
1751 MPSC_ROUTING_REG_BLOCK_SIZE
, "mpsc_routing_regs")) {
1753 mpsc_shared_regs
.mpsc_routing_base
= ioremap(r
->start
,
1754 MPSC_ROUTING_REG_BLOCK_SIZE
);
1755 mpsc_shared_regs
.mpsc_routing_base_p
= r
->start
;
1758 mpsc_resource_err("MPSC routing base");
1762 if ((r
= platform_get_resource(pd
, IORESOURCE_MEM
,
1763 MPSC_SDMA_INTR_BASE_ORDER
)) && request_mem_region(r
->start
,
1764 MPSC_SDMA_INTR_REG_BLOCK_SIZE
, "sdma_intr_regs")) {
1766 mpsc_shared_regs
.sdma_intr_base
= ioremap(r
->start
,
1767 MPSC_SDMA_INTR_REG_BLOCK_SIZE
);
1768 mpsc_shared_regs
.sdma_intr_base_p
= r
->start
;
1771 iounmap(mpsc_shared_regs
.mpsc_routing_base
);
1772 release_mem_region(mpsc_shared_regs
.mpsc_routing_base_p
,
1773 MPSC_ROUTING_REG_BLOCK_SIZE
);
1774 mpsc_resource_err("SDMA intr base");
1782 mpsc_shared_unmap_regs(void)
1784 if (!mpsc_shared_regs
.mpsc_routing_base
) {
1785 iounmap(mpsc_shared_regs
.mpsc_routing_base
);
1786 release_mem_region(mpsc_shared_regs
.mpsc_routing_base_p
,
1787 MPSC_ROUTING_REG_BLOCK_SIZE
);
1789 if (!mpsc_shared_regs
.sdma_intr_base
) {
1790 iounmap(mpsc_shared_regs
.sdma_intr_base
);
1791 release_mem_region(mpsc_shared_regs
.sdma_intr_base_p
,
1792 MPSC_SDMA_INTR_REG_BLOCK_SIZE
);
1795 mpsc_shared_regs
.mpsc_routing_base
= NULL
;
1796 mpsc_shared_regs
.sdma_intr_base
= NULL
;
1798 mpsc_shared_regs
.mpsc_routing_base_p
= 0;
1799 mpsc_shared_regs
.sdma_intr_base_p
= 0;
1805 mpsc_shared_drv_probe(struct platform_device
*dev
)
1807 struct mpsc_shared_pdata
*pdata
;
1811 if (!(rc
= mpsc_shared_map_regs(dev
))) {
1812 pdata
= (struct mpsc_shared_pdata
*)dev
->dev
.platform_data
;
1814 mpsc_shared_regs
.MPSC_MRR_m
= pdata
->mrr_val
;
1815 mpsc_shared_regs
.MPSC_RCRR_m
= pdata
->rcrr_val
;
1816 mpsc_shared_regs
.MPSC_TCRR_m
= pdata
->tcrr_val
;
1817 mpsc_shared_regs
.SDMA_INTR_CAUSE_m
=
1818 pdata
->intr_cause_val
;
1819 mpsc_shared_regs
.SDMA_INTR_MASK_m
=
1820 pdata
->intr_mask_val
;
1830 mpsc_shared_drv_remove(struct platform_device
*dev
)
1835 mpsc_shared_unmap_regs();
1836 mpsc_shared_regs
.MPSC_MRR_m
= 0;
1837 mpsc_shared_regs
.MPSC_RCRR_m
= 0;
1838 mpsc_shared_regs
.MPSC_TCRR_m
= 0;
1839 mpsc_shared_regs
.SDMA_INTR_CAUSE_m
= 0;
1840 mpsc_shared_regs
.SDMA_INTR_MASK_m
= 0;
1847 static struct platform_driver mpsc_shared_driver
= {
1848 .probe
= mpsc_shared_drv_probe
,
1849 .remove
= mpsc_shared_drv_remove
,
1851 .name
= MPSC_SHARED_NAME
,
1856 ******************************************************************************
1858 * Driver Interface Routines
1860 ******************************************************************************
1862 static struct uart_driver mpsc_reg
= {
1863 .owner
= THIS_MODULE
,
1864 .driver_name
= MPSC_DRIVER_NAME
,
1865 .dev_name
= MPSC_DEV_NAME
,
1866 .major
= MPSC_MAJOR
,
1867 .minor
= MPSC_MINOR_START
,
1868 .nr
= MPSC_NUM_CTLRS
,
1869 .cons
= MPSC_CONSOLE
,
1873 mpsc_drv_map_regs(struct mpsc_port_info
*pi
, struct platform_device
*pd
)
1877 if ((r
= platform_get_resource(pd
, IORESOURCE_MEM
, MPSC_BASE_ORDER
)) &&
1878 request_mem_region(r
->start
, MPSC_REG_BLOCK_SIZE
, "mpsc_regs")){
1880 pi
->mpsc_base
= ioremap(r
->start
, MPSC_REG_BLOCK_SIZE
);
1881 pi
->mpsc_base_p
= r
->start
;
1884 mpsc_resource_err("MPSC base");
1888 if ((r
= platform_get_resource(pd
, IORESOURCE_MEM
,
1889 MPSC_SDMA_BASE_ORDER
)) && request_mem_region(r
->start
,
1890 MPSC_SDMA_REG_BLOCK_SIZE
, "sdma_regs")) {
1892 pi
->sdma_base
= ioremap(r
->start
,MPSC_SDMA_REG_BLOCK_SIZE
);
1893 pi
->sdma_base_p
= r
->start
;
1896 mpsc_resource_err("SDMA base");
1900 if ((r
= platform_get_resource(pd
,IORESOURCE_MEM
,MPSC_BRG_BASE_ORDER
))
1901 && request_mem_region(r
->start
, MPSC_BRG_REG_BLOCK_SIZE
,
1904 pi
->brg_base
= ioremap(r
->start
, MPSC_BRG_REG_BLOCK_SIZE
);
1905 pi
->brg_base_p
= r
->start
;
1908 mpsc_resource_err("BRG base");
1916 mpsc_drv_unmap_regs(struct mpsc_port_info
*pi
)
1918 if (!pi
->mpsc_base
) {
1919 iounmap(pi
->mpsc_base
);
1920 release_mem_region(pi
->mpsc_base_p
, MPSC_REG_BLOCK_SIZE
);
1922 if (!pi
->sdma_base
) {
1923 iounmap(pi
->sdma_base
);
1924 release_mem_region(pi
->sdma_base_p
, MPSC_SDMA_REG_BLOCK_SIZE
);
1926 if (!pi
->brg_base
) {
1927 iounmap(pi
->brg_base
);
1928 release_mem_region(pi
->brg_base_p
, MPSC_BRG_REG_BLOCK_SIZE
);
1931 pi
->mpsc_base
= NULL
;
1932 pi
->sdma_base
= NULL
;
1933 pi
->brg_base
= NULL
;
1935 pi
->mpsc_base_p
= 0;
1936 pi
->sdma_base_p
= 0;
1943 mpsc_drv_get_platform_data(struct mpsc_port_info
*pi
,
1944 struct platform_device
*pd
, int num
)
1946 struct mpsc_pdata
*pdata
;
1948 pdata
= (struct mpsc_pdata
*)pd
->dev
.platform_data
;
1950 pi
->port
.uartclk
= pdata
->brg_clk_freq
;
1951 pi
->port
.iotype
= UPIO_MEM
;
1952 pi
->port
.line
= num
;
1953 pi
->port
.type
= PORT_MPSC
;
1954 pi
->port
.fifosize
= MPSC_TXBE_SIZE
;
1955 pi
->port
.membase
= pi
->mpsc_base
;
1956 pi
->port
.mapbase
= (ulong
)pi
->mpsc_base
;
1957 pi
->port
.ops
= &mpsc_pops
;
1959 pi
->mirror_regs
= pdata
->mirror_regs
;
1960 pi
->cache_mgmt
= pdata
->cache_mgmt
;
1961 pi
->brg_can_tune
= pdata
->brg_can_tune
;
1962 pi
->brg_clk_src
= pdata
->brg_clk_src
;
1963 pi
->mpsc_max_idle
= pdata
->max_idle
;
1964 pi
->default_baud
= pdata
->default_baud
;
1965 pi
->default_bits
= pdata
->default_bits
;
1966 pi
->default_parity
= pdata
->default_parity
;
1967 pi
->default_flow
= pdata
->default_flow
;
1969 /* Initial values of mirrored regs */
1970 pi
->MPSC_CHR_1_m
= pdata
->chr_1_val
;
1971 pi
->MPSC_CHR_2_m
= pdata
->chr_2_val
;
1972 pi
->MPSC_CHR_10_m
= pdata
->chr_10_val
;
1973 pi
->MPSC_MPCR_m
= pdata
->mpcr_val
;
1974 pi
->BRG_BCR_m
= pdata
->bcr_val
;
1976 pi
->shared_regs
= &mpsc_shared_regs
;
1978 pi
->port
.irq
= platform_get_irq(pd
, 0);
1984 mpsc_drv_probe(struct platform_device
*dev
)
1986 struct mpsc_port_info
*pi
;
1989 pr_debug("mpsc_drv_probe: Adding MPSC %d\n", dev
->id
);
1991 if (dev
->id
< MPSC_NUM_CTLRS
) {
1992 pi
= &mpsc_ports
[dev
->id
];
1994 if (!(rc
= mpsc_drv_map_regs(pi
, dev
))) {
1995 mpsc_drv_get_platform_data(pi
, dev
, dev
->id
);
1997 if (!(rc
= mpsc_make_ready(pi
)))
1998 if (!(rc
= uart_add_one_port(&mpsc_reg
,
2003 (struct uart_port
*)pi
);
2004 mpsc_drv_unmap_regs(pi
);
2007 mpsc_drv_unmap_regs(pi
);
2015 mpsc_drv_remove(struct platform_device
*dev
)
2017 pr_debug("mpsc_drv_exit: Removing MPSC %d\n", dev
->id
);
2019 if (dev
->id
< MPSC_NUM_CTLRS
) {
2020 uart_remove_one_port(&mpsc_reg
, &mpsc_ports
[dev
->id
].port
);
2021 mpsc_release_port((struct uart_port
*)&mpsc_ports
[dev
->id
].port
);
2022 mpsc_drv_unmap_regs(&mpsc_ports
[dev
->id
]);
2029 static struct platform_driver mpsc_driver
= {
2030 .probe
= mpsc_drv_probe
,
2031 .remove
= mpsc_drv_remove
,
2033 .name
= MPSC_CTLR_NAME
,
2042 printk(KERN_INFO
"Serial: MPSC driver $Revision: 1.00 $\n");
2044 memset(mpsc_ports
, 0, sizeof(mpsc_ports
));
2045 memset(&mpsc_shared_regs
, 0, sizeof(mpsc_shared_regs
));
2047 if (!(rc
= uart_register_driver(&mpsc_reg
))) {
2048 if (!(rc
= platform_driver_register(&mpsc_shared_driver
))) {
2049 if ((rc
= platform_driver_register(&mpsc_driver
))) {
2050 platform_driver_unregister(&mpsc_shared_driver
);
2051 uart_unregister_driver(&mpsc_reg
);
2055 uart_unregister_driver(&mpsc_reg
);
2065 platform_driver_unregister(&mpsc_driver
);
2066 platform_driver_unregister(&mpsc_shared_driver
);
2067 uart_unregister_driver(&mpsc_reg
);
2068 memset(mpsc_ports
, 0, sizeof(mpsc_ports
));
2069 memset(&mpsc_shared_regs
, 0, sizeof(mpsc_shared_regs
));
2073 module_init(mpsc_drv_init
);
2074 module_exit(mpsc_drv_exit
);
2076 MODULE_AUTHOR("Mark A. Greer <mgreer@mvista.com>");
2077 MODULE_DESCRIPTION("Generic Marvell MPSC serial/UART driver $Revision: 1.00 $");
2078 MODULE_VERSION(MPSC_VERSION
);
2079 MODULE_LICENSE("GPL");
2080 MODULE_ALIAS_CHARDEV_MAJOR(MPSC_MAJOR
);