mpsc.c revision e4294b3ecd1da9abeb66709c89f71b1ba888b3b1
11da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 21da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Generic driver for the MPSC (UART mode) on Marvell parts (e.g., GT64240, 31da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * GT64260, MV64340, MV64360, GT96100, ... ). 41da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 51da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Author: Mark A. Greer <mgreer@mvista.com> 61da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 71da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Based on an old MPSC driver that was in the linuxppc tree. It appears to 81da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * have been created by Chris Zankel (formerly of MontaVista) but there 91da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * is no proper Copyright so I'm not sure. Apparently, parts were also 101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * taken from PPCBoot (now U-Boot). Also based on drivers/serial/8250.c 111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * by Russell King. 121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2004 (c) MontaVista, Software, Inc. This file is licensed under 141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the terms of the GNU General Public License version 2. This program 151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * is licensed "as is" without any warranty of any kind, whether express 161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * or implied. 171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The MPSC interface is much like a typical network controller's interface. 201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * That is, you set up separate rings of descriptors for transmitting and 211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * receiving data. There is also a pool of buffers with (one buffer per 221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * descriptor) that incoming data are dma'd into or outgoing data are dma'd 231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * out of. 241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The MPSC requires two other controllers to be able to work. The Baud Rate 261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Generator (BRG) provides a clock at programmable frequencies which determines 271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the baud rate. The Serial DMA Controller (SDMA) takes incoming data from the 281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * MPSC and DMA's it into memory or DMA's outgoing data and passes it to the 291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * MPSC. It is actually the SDMA interrupt that the driver uses to keep the 301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * transmit and receive "engines" going (i.e., indicate data has been 311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * transmitted or received). 321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * NOTES: 341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1) Some chips have an erratum where several regs cannot be 361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * read. To work around that, we keep a local copy of those regs in 371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 'mpsc_port_info'. 381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2) Some chips have an erratum where the ctlr will hang when the SDMA ctlr 401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * accesses system mem with coherency enabled. For that reason, the driver 411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * assumes that coherency for that ctlr has been disabled. This means 421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * that when in a cache coherent system, the driver has to manually manage 431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the data cache on the areas that it touches because the dma_* macro are 441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * basically no-ops. 451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3) There is an erratum (on PPC) where you can't use the instruction to do 471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * a DMA_TO_DEVICE/cache clean so DMA_BIDIRECTIONAL/flushes are used in places 481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * where a DMA_TO_DEVICE/clean would have [otherwise] sufficed. 491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4) AFAICT, hardware flow control isn't supported by the controller --MAG. 511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 53e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/config.h> 54e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 55e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#if defined(CONFIG_SERIAL_MPSC_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) 56e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SUPPORT_SYSRQ 57e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#endif 58e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 59e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/module.h> 60e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/moduleparam.h> 61e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/tty.h> 62e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/tty_flip.h> 63e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/ioport.h> 64e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/init.h> 65e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/console.h> 66e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/sysrq.h> 67e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/serial.h> 68e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/serial_core.h> 69e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/delay.h> 70e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/device.h> 71e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/dma-mapping.h> 72e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <linux/mv643xx.h> 73d052d1beff706920e82c5d55006b08e256b5df09Russell King#include <linux/platform_device.h> 74d052d1beff706920e82c5d55006b08e256b5df09Russell King 75e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <asm/io.h> 76e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#include <asm/irq.h> 77e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 78e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#if defined(CONFIG_SERIAL_MPSC_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) 79e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SUPPORT_SYSRQ 80e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#endif 81e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 82e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_NUM_CTLRS 2 83e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 84e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer/* 85e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer * Descriptors and buffers must be cache line aligned. 86e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer * Buffers lengths must be multiple of cache line size. 87e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer * Number of Tx & Rx descriptors must be powers of 2. 88e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer */ 89e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_RXR_ENTRIES 32 90e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_RXRE_SIZE dma_get_cache_alignment() 91e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_RXR_SIZE (MPSC_RXR_ENTRIES * MPSC_RXRE_SIZE) 92e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_RXBE_SIZE dma_get_cache_alignment() 93e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_RXB_SIZE (MPSC_RXR_ENTRIES * MPSC_RXBE_SIZE) 94e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 95e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_TXR_ENTRIES 32 96e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_TXRE_SIZE dma_get_cache_alignment() 97e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_TXR_SIZE (MPSC_TXR_ENTRIES * MPSC_TXRE_SIZE) 98e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_TXBE_SIZE dma_get_cache_alignment() 99e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_TXB_SIZE (MPSC_TXR_ENTRIES * MPSC_TXBE_SIZE) 100e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 101e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_DMA_ALLOC_SIZE (MPSC_RXR_SIZE + MPSC_RXB_SIZE + \ 102e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer MPSC_TXR_SIZE + MPSC_TXB_SIZE + \ 103e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer dma_get_cache_alignment() /* for alignment */) 104e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 105e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer/* Rx and Tx Ring entry descriptors -- assume entry size is <= cacheline size */ 106e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greerstruct mpsc_rx_desc { 107e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u16 bufsize; 108e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u16 bytecnt; 109e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 cmdstat; 110e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 link; 111e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 buf_ptr; 112e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer} __attribute((packed)); 113e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 114e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greerstruct mpsc_tx_desc { 115e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u16 bytecnt; 116e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u16 shadow; 117e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 cmdstat; 118e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 link; 119e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 buf_ptr; 120e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer} __attribute((packed)); 121e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 122e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer/* 123e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer * Some regs that have the erratum that you can't read them are are shared 124e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer * between the two MPSC controllers. This struct contains those shared regs. 125e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer */ 126e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greerstruct mpsc_shared_regs { 127e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer phys_addr_t mpsc_routing_base_p; 128e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer phys_addr_t sdma_intr_base_p; 129e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 130e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer void __iomem *mpsc_routing_base; 131e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer void __iomem *sdma_intr_base; 132e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 133e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 MPSC_MRR_m; 134e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 MPSC_RCRR_m; 135e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 MPSC_TCRR_m; 136e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 SDMA_INTR_CAUSE_m; 137e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 SDMA_INTR_MASK_m; 138e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer}; 139e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 140e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer/* The main driver data structure */ 141e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greerstruct mpsc_port_info { 142e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer struct uart_port port; /* Overlay uart_port structure */ 143e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 144e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer /* Internal driver state for this ctlr */ 145e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u8 ready; 146e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u8 rcv_data; 147e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer tcflag_t c_iflag; /* save termios->c_iflag */ 148e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer tcflag_t c_cflag; /* save termios->c_cflag */ 149e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 150e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer /* Info passed in from platform */ 151e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u8 mirror_regs; /* Need to mirror regs? */ 152e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u8 cache_mgmt; /* Need manual cache mgmt? */ 153e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u8 brg_can_tune; /* BRG has baud tuning? */ 154e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 brg_clk_src; 155e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u16 mpsc_max_idle; 156e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer int default_baud; 157e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer int default_bits; 158e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer int default_parity; 159e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer int default_flow; 160e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 161e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer /* Physical addresses of various blocks of registers (from platform) */ 162e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer phys_addr_t mpsc_base_p; 163e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer phys_addr_t sdma_base_p; 164e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer phys_addr_t brg_base_p; 165e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 166e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer /* Virtual addresses of various blocks of registers (from platform) */ 167e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer void __iomem *mpsc_base; 168e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer void __iomem *sdma_base; 169e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer void __iomem *brg_base; 170e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 171e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer /* Descriptor ring and buffer allocations */ 172e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer void *dma_region; 173e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer dma_addr_t dma_region_p; 174e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 175e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer dma_addr_t rxr; /* Rx descriptor ring */ 176e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer dma_addr_t rxr_p; /* Phys addr of rxr */ 177e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u8 *rxb; /* Rx Ring I/O buf */ 178e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u8 *rxb_p; /* Phys addr of rxb */ 179e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 rxr_posn; /* First desc w/ Rx data */ 180e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 181e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer dma_addr_t txr; /* Tx descriptor ring */ 182e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer dma_addr_t txr_p; /* Phys addr of txr */ 183e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u8 *txb; /* Tx Ring I/O buf */ 184e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u8 *txb_p; /* Phys addr of txb */ 185e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer int txr_head; /* Where new data goes */ 186e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer int txr_tail; /* Where sent data comes off */ 187e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 188e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer /* Mirrored values of regs we can't read (if 'mirror_regs' set) */ 189e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 MPSC_MPCR_m; 190e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 MPSC_CHR_1_m; 191e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 MPSC_CHR_2_m; 192e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 MPSC_CHR_10_m; 193e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer u32 BRG_BCR_m; 194e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer struct mpsc_shared_regs *shared_regs; 195e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer}; 196e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 197e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer/* Hooks to platform-specific code */ 198e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greerint mpsc_platform_register_driver(void); 199e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greervoid mpsc_platform_unregister_driver(void); 200e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 201e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer/* Hooks back in to mpsc common to be called by platform-specific code */ 202e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greerstruct mpsc_port_info *mpsc_device_probe(int index); 203e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greerstruct mpsc_port_info *mpsc_device_remove(int index); 204e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 205e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer/* Main MPSC Configuration Register Offsets */ 206e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_MMCRL 0x0000 207e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_MMCRH 0x0004 208e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_MPCR 0x0008 209e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_1 0x000c 210e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2 0x0010 211e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_3 0x0014 212e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_4 0x0018 213e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_5 0x001c 214e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_6 0x0020 215e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_7 0x0024 216e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_8 0x0028 217e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_9 0x002c 218e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_10 0x0030 219e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_11 0x0034 220e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 221e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_MPCR_FRZ (1 << 9) 222e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_MPCR_CL_5 0 223e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_MPCR_CL_6 1 224e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_MPCR_CL_7 2 225e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_MPCR_CL_8 3 226e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_MPCR_SBL_1 0 227e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_MPCR_SBL_2 1 228e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 229e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2_TEV (1<<1) 230e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2_TA (1<<7) 231e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2_TTCS (1<<9) 232e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2_REV (1<<17) 233e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2_RA (1<<23) 234e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2_CRD (1<<25) 235e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2_EH (1<<31) 236e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2_PAR_ODD 0 237e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2_PAR_SPACE 1 238e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2_PAR_EVEN 2 239e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_CHR_2_PAR_MARK 3 240e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 241e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer/* MPSC Signal Routing */ 242e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_MRR 0x0000 243e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_RCRR 0x0004 244e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define MPSC_TCRR 0x0008 245e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 246e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer/* Serial DMA Controller Interface Registers */ 247e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDC 0x0000 248e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDCM 0x0008 249e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_RX_DESC 0x0800 250e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_RX_BUF_PTR 0x0808 251e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SCRDP 0x0810 252e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_TX_DESC 0x0c00 253e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SCTDP 0x0c10 254e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SFTDP 0x0c14 255e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 256e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_PE (1<<0) 257e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_CDL (1<<1) 258e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_FR (1<<3) 259e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_OR (1<<6) 260e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_BR (1<<9) 261e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_MI (1<<10) 262e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_A (1<<11) 263e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_AM (1<<12) 264e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_CT (1<<13) 265e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_C (1<<14) 266e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_ES (1<<15) 267e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_L (1<<16) 268e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_F (1<<17) 269e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_P (1<<18) 270e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_EI (1<<23) 271e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_CMDSTAT_O (1<<31) 272e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 273e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_DESC_DFLT (SDMA_DESC_CMDSTAT_O | \ 274e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer SDMA_DESC_CMDSTAT_EI) 275e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 276e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDC_RFT (1<<0) 277e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDC_SFM (1<<1) 278e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDC_BLMR (1<<6) 279e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDC_BLMT (1<<7) 280e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDC_POVR (1<<8) 281e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDC_RIFB (1<<9) 282e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 283e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDCM_ERD (1<<7) 284e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDCM_AR (1<<15) 285e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDCM_STD (1<<16) 286e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDCM_TXD (1<<23) 287e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_SDCM_AT (1<<31) 288e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 289e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_0_CAUSE_RXBUF (1<<0) 290e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_0_CAUSE_RXERR (1<<1) 291e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_0_CAUSE_TXBUF (1<<2) 292e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_0_CAUSE_TXEND (1<<3) 293e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_1_CAUSE_RXBUF (1<<8) 294e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_1_CAUSE_RXERR (1<<9) 295e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_1_CAUSE_TXBUF (1<<10) 296e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_1_CAUSE_TXEND (1<<11) 297e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 298e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_CAUSE_RX_MASK (SDMA_0_CAUSE_RXBUF | SDMA_0_CAUSE_RXERR | \ 299e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer SDMA_1_CAUSE_RXBUF | SDMA_1_CAUSE_RXERR) 300e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_CAUSE_TX_MASK (SDMA_0_CAUSE_TXBUF | SDMA_0_CAUSE_TXEND | \ 301e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer SDMA_1_CAUSE_TXBUF | SDMA_1_CAUSE_TXEND) 302e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 303e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer/* SDMA Interrupt registers */ 304e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_INTR_CAUSE 0x0000 305e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define SDMA_INTR_MASK 0x0080 306e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer 307e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer/* Baud Rate Generator Interface Registers */ 308e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define BRG_BCR 0x0000 309e4294b3ecd1da9abeb66709c89f71b1ba888b3b1Mark A. Greer#define BRG_BTR 0x0004 3101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 3121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Define how this driver is known to the outside (we've been assigned a 3131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * range on the "Low-density serial ports" major). 3141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 3151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MPSC_MAJOR 204 3161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MPSC_MINOR_START 44 3171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MPSC_DRIVER_NAME "MPSC" 3181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MPSC_DEVFS_NAME "ttymm/" 3191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MPSC_DEV_NAME "ttyMM" 3201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MPSC_VERSION "1.00" 3211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct mpsc_port_info mpsc_ports[MPSC_NUM_CTLRS]; 3231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct mpsc_shared_regs mpsc_shared_regs; 3244d0145a7deab4027a0f0a7de74c2d103b8f029cfLee Nicksstatic struct uart_driver mpsc_reg; 3251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3264d0145a7deab4027a0f0a7de74c2d103b8f029cfLee Nicksstatic void mpsc_start_rx(struct mpsc_port_info *pi); 3274d0145a7deab4027a0f0a7de74c2d103b8f029cfLee Nicksstatic void mpsc_free_ring_mem(struct mpsc_port_info *pi); 3284d0145a7deab4027a0f0a7de74c2d103b8f029cfLee Nicksstatic void mpsc_release_port(struct uart_port *port); 3291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 3301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 3311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Baud Rate Generator Routines (BRG) 3331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 3351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 3361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 3371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_brg_init(struct mpsc_port_info *pi, u32 clk_src) 3381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 3391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 3401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (pi->mirror_regs) ? pi->BRG_BCR_m : readl(pi->brg_base + BRG_BCR); 3421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (v & ~(0xf << 18)) | ((clk_src & 0xf) << 18); 3431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->brg_can_tune) 3451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v &= ~(1 << 25); 3461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 3481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->BRG_BCR_m = v; 3491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->brg_base + BRG_BCR); 3501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(readl(pi->brg_base + BRG_BTR) & 0xffff0000, 3521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->brg_base + BRG_BTR); 3531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 3541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 3571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_brg_enable(struct mpsc_port_info *pi) 3581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 3591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 3601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (pi->mirror_regs) ? pi->BRG_BCR_m : readl(pi->brg_base + BRG_BCR); 3621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v |= (1 << 16); 3631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 3651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->BRG_BCR_m = v; 3661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->brg_base + BRG_BCR); 3671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 3681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 3711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_brg_disable(struct mpsc_port_info *pi) 3721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 3731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 3741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (pi->mirror_regs) ? pi->BRG_BCR_m : readl(pi->brg_base + BRG_BCR); 3761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v &= ~(1 << 16); 3771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 3791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->BRG_BCR_m = v; 3801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->brg_base + BRG_BCR); 3811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 3821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 3851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_set_baudrate(struct mpsc_port_info *pi, u32 baud) 3861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 3871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* 3881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * To set the baud, we adjust the CDV field in the BRG_BCR reg. 3891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * From manual: Baud = clk / ((CDV+1)*2) ==> CDV = (clk / (baud*2)) - 1. 3901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * However, the input clock is divided by 16 in the MPSC b/c of how 3911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 'MPSC_MMCRH' was set up so we have to divide the 'clk' used in our 3921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * calculation by 16 to account for that. So the real calculation 3931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * that accounts for the way the mpsc is set up is: 3941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * CDV = (clk / (baud*2*16)) - 1 ==> CDV = (clk / (baud << 5)) - 1. 3951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 3961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 cdv = (pi->port.uartclk / (baud << 5)) - 1; 3971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 3981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_brg_disable(pi); 4001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (pi->mirror_regs) ? pi->BRG_BCR_m : readl(pi->brg_base + BRG_BCR); 4011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (v & 0xffff0000) | (cdv & 0xffff); 4021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 4041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->BRG_BCR_m = v; 4051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->brg_base + BRG_BCR); 4061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_brg_enable(pi); 4071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 4091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 4121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 4131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Serial DMA Routines (SDMA) 4151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 4171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 4181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 4201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_burstsize(struct mpsc_port_info *pi, u32 burst_size) 4211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 4231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_sdma_burstsize[%d]: burst_size: %d\n", 4251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.line, burst_size); 4261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds burst_size >>= 3; /* Divide by 8 b/c reg values are 8-byte chunks */ 4281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (burst_size < 2) 4301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = 0x0; /* 1 64-bit word */ 4311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (burst_size < 4) 4321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = 0x1; /* 2 64-bit words */ 4331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (burst_size < 8) 4341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = 0x2; /* 4 64-bit words */ 4351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 4361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = 0x3; /* 8 64-bit words */ 4371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel((readl(pi->sdma_base + SDMA_SDC) & (0x3 << 12)) | (v << 12), 4391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->sdma_base + SDMA_SDC); 4401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 4411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 4441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_init(struct mpsc_port_info *pi, u32 burst_size) 4451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_sdma_init[%d]: burst_size: %d\n", pi->port.line, 4471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds burst_size); 4481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel((readl(pi->sdma_base + SDMA_SDC) & 0x3ff) | 0x03f, 4501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->sdma_base + SDMA_SDC); 4511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_burstsize(pi, burst_size); 4521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 4531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline u32 4561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_intr_mask(struct mpsc_port_info *pi, u32 mask) 4571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 old, v; 4591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_sdma_intr_mask[%d]: mask: 0x%x\n", pi->port.line, mask); 4611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds old = v = (pi->mirror_regs) ? pi->shared_regs->SDMA_INTR_MASK_m : 4631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds readl(pi->shared_regs->sdma_intr_base + SDMA_INTR_MASK); 4641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mask &= 0xf; 4661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->port.line) 4671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mask <<= 8; 4681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v &= ~mask; 4691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 4711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->shared_regs->SDMA_INTR_MASK_m = v; 4721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->shared_regs->sdma_intr_base + SDMA_INTR_MASK); 4731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->port.line) 4751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds old >>= 8; 4761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return old & 0xf; 4771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 4801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_intr_unmask(struct mpsc_port_info *pi, u32 mask) 4811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 4831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_sdma_intr_unmask[%d]: mask: 0x%x\n", pi->port.line,mask); 4851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (pi->mirror_regs) ? pi->shared_regs->SDMA_INTR_MASK_m : 4871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds readl(pi->shared_regs->sdma_intr_base + SDMA_INTR_MASK); 4881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mask &= 0xf; 4901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->port.line) 4911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mask <<= 8; 4921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v |= mask; 4931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 4951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->shared_regs->SDMA_INTR_MASK_m = v; 4961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->shared_regs->sdma_intr_base + SDMA_INTR_MASK); 4971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 4981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 5011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_intr_ack(struct mpsc_port_info *pi) 5021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_sdma_intr_ack[%d]: Acknowledging IRQ\n", pi->port.line); 5041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 5061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->shared_regs->SDMA_INTR_CAUSE_m = 0; 5071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, pi->shared_regs->sdma_intr_base + SDMA_INTR_CAUSE); 5081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 5091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 5121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_set_rx_ring(struct mpsc_port_info *pi, struct mpsc_rx_desc *rxre_p) 5131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_sdma_set_rx_ring[%d]: rxre_p: 0x%x\n", 5151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.line, (u32) rxre_p); 5161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel((u32)rxre_p, pi->sdma_base + SDMA_SCRDP); 5181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 5191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 5221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_set_tx_ring(struct mpsc_port_info *pi, struct mpsc_tx_desc *txre_p) 5231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel((u32)txre_p, pi->sdma_base + SDMA_SFTDP); 5251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel((u32)txre_p, pi->sdma_base + SDMA_SCTDP); 5261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 5271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 5301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_cmd(struct mpsc_port_info *pi, u32 val) 5311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 5331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = readl(pi->sdma_base + SDMA_SDCM); 5351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (val) 5361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v |= val; 5371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 5381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = 0; 5391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wmb(); 5401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->sdma_base + SDMA_SDCM); 5411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wmb(); 5421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 5431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline uint 5461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_tx_active(struct mpsc_port_info *pi) 5471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return readl(pi->sdma_base + SDMA_SDCM) & SDMA_SDCM_TXD; 5491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 5521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_start_tx(struct mpsc_port_info *pi) 5531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_tx_desc *txre, *txre_p; 5551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If tx isn't running & there's a desc ready to go, start it */ 5571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!mpsc_sdma_tx_active(pi)) { 5581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre = (struct mpsc_tx_desc *)(pi->txr + 5591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (pi->txr_tail * MPSC_TXRE_SIZE)); 5601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_cache_sync((void *) txre, MPSC_TXRE_SIZE, DMA_FROM_DEVICE); 5611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) 5621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */ 5631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds invalidate_dcache_range((ulong)txre, 5641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ulong)txre + MPSC_TXRE_SIZE); 5651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 5661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (be32_to_cpu(txre->cmdstat) & SDMA_DESC_CMDSTAT_O) { 5681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre_p = (struct mpsc_tx_desc *)(pi->txr_p + 5691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (pi->txr_tail * 5701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_TXRE_SIZE)); 5711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_set_tx_ring(pi, txre_p); 5731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_cmd(pi, SDMA_SDCM_STD | SDMA_SDCM_TXD); 5741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 5751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 5761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 5781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 5811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_stop(struct mpsc_port_info *pi) 5821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_sdma_stop[%d]: Stopping SDMA\n", pi->port.line); 5841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Abort any SDMA transfers */ 5861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_cmd(pi, 0); 5871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_cmd(pi, SDMA_SDCM_AR | SDMA_SDCM_AT); 5881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Clear the SDMA current and first TX and RX pointers */ 5902c6e75999000ebc942526466dbd0de37bfac73a4Al Viro mpsc_sdma_set_tx_ring(pi, NULL); 5912c6e75999000ebc942526466dbd0de37bfac73a4Al Viro mpsc_sdma_set_rx_ring(pi, NULL); 5921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Disable interrupts */ 5941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_intr_mask(pi, 0xf); 5951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_intr_ack(pi); 5961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 5981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 6011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 6021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 6031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Multi-Protocol Serial Controller Routines (MPSC) 6041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 6051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 6061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 6071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 6091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_hw_init(struct mpsc_port_info *pi) 6101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 6121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_hw_init[%d]: Initializing hardware\n", pi->port.line); 6141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Set up clock routing */ 6161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) { 6171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = pi->shared_regs->MPSC_MRR_m; 6181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v &= ~0x1c7; 6191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->shared_regs->MPSC_MRR_m = v; 6201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->shared_regs->mpsc_routing_base + MPSC_MRR); 6211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = pi->shared_regs->MPSC_RCRR_m; 6231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (v & ~0xf0f) | 0x100; 6241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->shared_regs->MPSC_RCRR_m = v; 6251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->shared_regs->mpsc_routing_base + MPSC_RCRR); 6261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = pi->shared_regs->MPSC_TCRR_m; 6281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (v & ~0xf0f) | 0x100; 6291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->shared_regs->MPSC_TCRR_m = v; 6301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->shared_regs->mpsc_routing_base + MPSC_TCRR); 6311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 6331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = readl(pi->shared_regs->mpsc_routing_base + MPSC_MRR); 6341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v &= ~0x1c7; 6351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->shared_regs->mpsc_routing_base + MPSC_MRR); 6361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = readl(pi->shared_regs->mpsc_routing_base + MPSC_RCRR); 6381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (v & ~0xf0f) | 0x100; 6391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->shared_regs->mpsc_routing_base + MPSC_RCRR); 6401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = readl(pi->shared_regs->mpsc_routing_base + MPSC_TCRR); 6421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (v & ~0xf0f) | 0x100; 6431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->shared_regs->mpsc_routing_base + MPSC_TCRR); 6441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Put MPSC in UART mode & enabel Tx/Rx egines */ 6471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0x000004c4, pi->mpsc_base + MPSC_MMCRL); 6481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* No preamble, 16x divider, low-latency, */ 6501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0x04400400, pi->mpsc_base + MPSC_MMCRH); 6511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) { 6531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_CHR_1_m = 0; 6541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_CHR_2_m = 0; 6551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, pi->mpsc_base + MPSC_CHR_1); 6571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, pi->mpsc_base + MPSC_CHR_2); 6581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(pi->mpsc_max_idle, pi->mpsc_base + MPSC_CHR_3); 6591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, pi->mpsc_base + MPSC_CHR_4); 6601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, pi->mpsc_base + MPSC_CHR_5); 6611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, pi->mpsc_base + MPSC_CHR_6); 6621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, pi->mpsc_base + MPSC_CHR_7); 6631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, pi->mpsc_base + MPSC_CHR_8); 6641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, pi->mpsc_base + MPSC_CHR_9); 6651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(0, pi->mpsc_base + MPSC_CHR_10); 6661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 6681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 6711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_enter_hunt(struct mpsc_port_info *pi) 6721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_enter_hunt[%d]: Hunting...\n", pi->port.line); 6741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) { 6761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(pi->MPSC_CHR_2_m | MPSC_CHR_2_EH, 6771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->mpsc_base + MPSC_CHR_2); 6781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Erratum prevents reading CHR_2 so just delay for a while */ 6791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(100); 6801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 6821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(readl(pi->mpsc_base + MPSC_CHR_2) | MPSC_CHR_2_EH, 6831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->mpsc_base + MPSC_CHR_2); 6841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (readl(pi->mpsc_base + MPSC_CHR_2) & MPSC_CHR_2_EH) 6861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(10); 6871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 6901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 6931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_freeze(struct mpsc_port_info *pi) 6941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 6961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_freeze[%d]: Freezing\n", pi->port.line); 6981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (pi->mirror_regs) ? pi->MPSC_MPCR_m : 7001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds readl(pi->mpsc_base + MPSC_MPCR); 7011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v |= MPSC_MPCR_FRZ; 7021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 7041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_MPCR_m = v; 7051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->mpsc_base + MPSC_MPCR); 7061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 7071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 7101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_unfreeze(struct mpsc_port_info *pi) 7111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 7131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (pi->mirror_regs) ? pi->MPSC_MPCR_m : 7151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds readl(pi->mpsc_base + MPSC_MPCR); 7161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v &= ~MPSC_MPCR_FRZ; 7171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 7191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_MPCR_m = v; 7201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->mpsc_base + MPSC_MPCR); 7211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_unfreeze[%d]: Unfrozen\n", pi->port.line); 7231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 7241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 7271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_set_char_length(struct mpsc_port_info *pi, u32 len) 7281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 7301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_set_char_length[%d]: char len: %d\n", pi->port.line,len); 7321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (pi->mirror_regs) ? pi->MPSC_MPCR_m : 7341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds readl(pi->mpsc_base + MPSC_MPCR); 7351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (v & ~(0x3 << 12)) | ((len & 0x3) << 12); 7361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 7381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_MPCR_m = v; 7391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->mpsc_base + MPSC_MPCR); 7401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 7411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 7441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_set_stop_bit_length(struct mpsc_port_info *pi, u32 len) 7451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 7471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_set_stop_bit_length[%d]: stop bits: %d\n", 7491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.line, len); 7501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (pi->mirror_regs) ? pi->MPSC_MPCR_m : 7521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds readl(pi->mpsc_base + MPSC_MPCR); 7531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (v & ~(1 << 14)) | ((len & 0x1) << 14); 7551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 7571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_MPCR_m = v; 7581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->mpsc_base + MPSC_MPCR); 7591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 7601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 7631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_set_parity(struct mpsc_port_info *pi, u32 p) 7641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 7661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_set_parity[%d]: parity bits: 0x%x\n", pi->port.line, p); 7681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (pi->mirror_regs) ? pi->MPSC_CHR_2_m : 7701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds readl(pi->mpsc_base + MPSC_CHR_2); 7711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds p &= 0x3; 7731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = (v & ~0xc000c) | (p << 18) | (p << 2); 7741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 7761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_CHR_2_m = v; 7771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->mpsc_base + MPSC_CHR_2); 7781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 7791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 7821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 7831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 7841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Driver Init Routines 7851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 7861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 7871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 7881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 7901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_init_hw(struct mpsc_port_info *pi) 7911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_init_hw[%d]: Initializing\n", pi->port.line); 7931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_brg_init(pi, pi->brg_clk_src); 7951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_brg_enable(pi); 7961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_init(pi, dma_get_cache_alignment()); /* burst a cacheline */ 7971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_stop(pi); 7981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_hw_init(pi); 7991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 8011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 8021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 8041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_alloc_ring_mem(struct mpsc_port_info *pi) 8051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 8061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc = 0; 8071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_alloc_ring_mem[%d]: Allocating ring mem\n", 8091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.line); 8101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!pi->dma_region) { 8121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!dma_supported(pi->port.dev, 0xffffffff)) { 8131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "MPSC: Inadequate DMA support\n"); 8141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = -ENXIO; 8151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if ((pi->dma_region = dma_alloc_noncoherent(pi->port.dev, 8171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_DMA_ALLOC_SIZE, &pi->dma_region_p, GFP_KERNEL)) 8181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds == NULL) { 8191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "MPSC: Can't alloc Desc region\n"); 8211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = -ENOMEM; 8221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 8261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 8271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 8291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_free_ring_mem(struct mpsc_port_info *pi) 8301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 8311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_free_ring_mem[%d]: Freeing ring mem\n", pi->port.line); 8321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->dma_region) { 8341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_free_noncoherent(pi->port.dev, MPSC_DMA_ALLOC_SIZE, 8351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->dma_region, pi->dma_region_p); 8361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->dma_region = NULL; 8371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->dma_region_p = (dma_addr_t) NULL; 8381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 8411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 8421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 8441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_init_rings(struct mpsc_port_info *pi) 8451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 8461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_rx_desc *rxre; 8471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_tx_desc *txre; 8481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_addr_t dp, dp_p; 8491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 *bp, *bp_p; 8501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 8511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_init_rings[%d]: Initializing rings\n", pi->port.line); 8531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BUG_ON(pi->dma_region == NULL); 8551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(pi->dma_region, 0, MPSC_DMA_ALLOC_SIZE); 8571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* 8591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Descriptors & buffers are multiples of cacheline size and must be 8601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * cacheline aligned. 8611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 8621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp = ALIGN((u32) pi->dma_region, dma_get_cache_alignment()); 8631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp_p = ALIGN((u32) pi->dma_region_p, dma_get_cache_alignment()); 8641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* 8661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Partition dma region into rx ring descriptor, rx buffers, 8671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * tx ring descriptors, and tx buffers. 8681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 8691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rxr = dp; 8701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rxr_p = dp_p; 8711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp += MPSC_RXR_SIZE; 8721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp_p += MPSC_RXR_SIZE; 8731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rxb = (u8 *) dp; 8751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rxb_p = (u8 *) dp_p; 8761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp += MPSC_RXB_SIZE; 8771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp_p += MPSC_RXB_SIZE; 8781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rxr_posn = 0; 8801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr = dp; 8821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr_p = dp_p; 8831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp += MPSC_TXR_SIZE; 8841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp_p += MPSC_TXR_SIZE; 8851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txb = (u8 *) dp; 8871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txb_p = (u8 *) dp_p; 8881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr_head = 0; 8901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr_tail = 0; 8911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Init rx ring descriptors */ 8931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp = pi->rxr; 8941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp_p = pi->rxr_p; 8951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp = pi->rxb; 8961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp_p = pi->rxb_p; 8971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < MPSC_RXR_ENTRIES; i++) { 8991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rxre = (struct mpsc_rx_desc *)dp; 9001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rxre->bufsize = cpu_to_be16(MPSC_RXBE_SIZE); 9021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rxre->bytecnt = cpu_to_be16(0); 9031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rxre->cmdstat = cpu_to_be32(SDMA_DESC_CMDSTAT_O | 9041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_EI | 9051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_F | 9061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_L); 9071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rxre->link = cpu_to_be32(dp_p + MPSC_RXRE_SIZE); 9081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rxre->buf_ptr = cpu_to_be32(bp_p); 9091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp += MPSC_RXRE_SIZE; 9111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp_p += MPSC_RXRE_SIZE; 9121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp += MPSC_RXBE_SIZE; 9131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp_p += MPSC_RXBE_SIZE; 9141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rxre->link = cpu_to_be32(pi->rxr_p); /* Wrap last back to first */ 9161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Init tx ring descriptors */ 9181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp = pi->txr; 9191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp_p = pi->txr_p; 9201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp = pi->txb; 9211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp_p = pi->txb_p; 9221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < MPSC_TXR_ENTRIES; i++) { 9241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre = (struct mpsc_tx_desc *)dp; 9251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre->link = cpu_to_be32(dp_p + MPSC_TXRE_SIZE); 9271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre->buf_ptr = cpu_to_be32(bp_p); 9281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp += MPSC_TXRE_SIZE; 9301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dp_p += MPSC_TXRE_SIZE; 9311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp += MPSC_TXBE_SIZE; 9321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp_p += MPSC_TXBE_SIZE; 9331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre->link = cpu_to_be32(pi->txr_p); /* Wrap last back to first */ 9351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_cache_sync((void *) pi->dma_region, MPSC_DMA_ALLOC_SIZE, 9371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DMA_BIDIRECTIONAL); 9381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) 9391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */ 9401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flush_dcache_range((ulong)pi->dma_region, 9411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ulong)pi->dma_region + MPSC_DMA_ALLOC_SIZE); 9421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 9431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 9451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 9481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_uninit_rings(struct mpsc_port_info *pi) 9491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 9501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_uninit_rings[%d]: Uninitializing rings\n",pi->port.line); 9511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BUG_ON(pi->dma_region == NULL); 9531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rxr = 0; 9551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rxr_p = 0; 9561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rxb = NULL; 9571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rxb_p = NULL; 9581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rxr_posn = 0; 9591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr = 0; 9611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr_p = 0; 9621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txb = NULL; 9631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txb_p = NULL; 9641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr_head = 0; 9651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr_tail = 0; 9661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 9681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 9711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_make_ready(struct mpsc_port_info *pi) 9721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 9731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc; 9741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_make_ready[%d]: Making cltr ready\n", pi->port.line); 9761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!pi->ready) { 9781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_init_hw(pi); 9791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((rc = mpsc_alloc_ring_mem(pi))) 9801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 9811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_init_rings(pi); 9821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->ready = 1; 9831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 9861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 9891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 9901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 9911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Interrupt Handling Routines 9921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 9931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 9941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 9951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline int 9971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_rx_intr(struct mpsc_port_info *pi, struct pt_regs *regs) 9981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 9991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_rx_desc *rxre; 10001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct tty_struct *tty = pi->port.info->tty; 10011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 cmdstat, bytes_in, i; 10021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc = 0; 10031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 *bp; 10041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char flag = TTY_NORMAL; 10051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_rx_intr[%d]: Handling Rx intr\n", pi->port.line); 10071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rxre = (struct mpsc_rx_desc *)(pi->rxr + (pi->rxr_posn*MPSC_RXRE_SIZE)); 10091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_cache_sync((void *)rxre, MPSC_RXRE_SIZE, DMA_FROM_DEVICE); 10111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) 10121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */ 10131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds invalidate_dcache_range((ulong)rxre, 10141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ulong)rxre + MPSC_RXRE_SIZE); 10151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 10161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* 10181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Loop through Rx descriptors handling ones that have been completed. 10191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 10201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (!((cmdstat = be32_to_cpu(rxre->cmdstat)) & SDMA_DESC_CMDSTAT_O)){ 10211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bytes_in = be16_to_cpu(rxre->bytecnt); 10221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Following use of tty struct directly is deprecated */ 102433f0f88f1c51ae5c2d593d26960c760ea154c2e2Alan Cox if (unlikely(tty_buffer_request_room(tty, bytes_in) < bytes_in)) { 10251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (tty->low_latency) 10261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tty_flip_buffer_push(tty); 10271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* 102833f0f88f1c51ae5c2d593d26960c760ea154c2e2Alan Cox * If this failed then we will throw away the bytes 102933f0f88f1c51ae5c2d593d26960c760ea154c2e2Alan Cox * but must do so to clear interrupts. 10301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 10311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp = pi->rxb + (pi->rxr_posn * MPSC_RXBE_SIZE); 10341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_cache_sync((void *) bp, MPSC_RXBE_SIZE, DMA_FROM_DEVICE); 10351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) 10361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */ 10371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds invalidate_dcache_range((ulong)bp, 10381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ulong)bp + MPSC_RXBE_SIZE); 10391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 10401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* 10421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Other than for parity error, the manual provides little 10431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * info on what data will be in a frame flagged by any of 10441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * these errors. For parity error, it is the last byte in 10451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the buffer that had the error. As for the rest, I guess 10461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * we'll assume there is no data in the buffer. 10471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * If there is...it gets lost. 10481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 10491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (unlikely(cmdstat & (SDMA_DESC_CMDSTAT_BR | 10501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_FR | SDMA_DESC_CMDSTAT_OR))) { 10511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.icount.rx++; 10531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cmdstat & SDMA_DESC_CMDSTAT_BR) { /* Break */ 10551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.icount.brk++; 10561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (uart_handle_break(&pi->port)) 10581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto next_frame; 10591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (cmdstat & SDMA_DESC_CMDSTAT_FR)/* Framing */ 10611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.icount.frame++; 10621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (cmdstat & SDMA_DESC_CMDSTAT_OR) /* Overrun */ 10631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.icount.overrun++; 10641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmdstat &= pi->port.read_status_mask; 10661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (cmdstat & SDMA_DESC_CMDSTAT_BR) 10681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flag = TTY_BREAK; 10691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (cmdstat & SDMA_DESC_CMDSTAT_FR) 10701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flag = TTY_FRAME; 10711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (cmdstat & SDMA_DESC_CMDSTAT_OR) 10721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flag = TTY_OVERRUN; 10731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (cmdstat & SDMA_DESC_CMDSTAT_PE) 10741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flag = TTY_PARITY; 10751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (uart_handle_sysrq_char(&pi->port, *bp, regs)) { 10781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp++; 10791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bytes_in--; 10801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto next_frame; 10811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((unlikely(cmdstat & (SDMA_DESC_CMDSTAT_BR | 10841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_FR | SDMA_DESC_CMDSTAT_OR))) && 10851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds !(cmdstat & pi->port.ignore_status_mask)) 10861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tty_insert_flip_char(tty, *bp, flag); 10881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 10891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i=0; i<bytes_in; i++) 10901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tty_insert_flip_char(tty, *bp++, TTY_NORMAL); 10911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.icount.rx += bytes_in; 10931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsnext_frame: 10961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rxre->bytecnt = cpu_to_be16(0); 10971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wmb(); 10981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rxre->cmdstat = cpu_to_be32(SDMA_DESC_CMDSTAT_O | 10991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_EI | 11001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_F | 11011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_L); 11021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wmb(); 11031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_cache_sync((void *)rxre, MPSC_RXRE_SIZE, DMA_BIDIRECTIONAL); 11041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) 11051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */ 11061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flush_dcache_range((ulong)rxre, 11071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ulong)rxre + MPSC_RXRE_SIZE); 11081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 11091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Advance to next descriptor */ 11111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rxr_posn = (pi->rxr_posn + 1) & (MPSC_RXR_ENTRIES - 1); 11121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rxre = (struct mpsc_rx_desc *)(pi->rxr + 11131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (pi->rxr_posn * MPSC_RXRE_SIZE)); 11141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_cache_sync((void *)rxre, MPSC_RXRE_SIZE, DMA_FROM_DEVICE); 11151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) 11161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */ 11171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds invalidate_dcache_range((ulong)rxre, 11181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ulong)rxre + MPSC_RXRE_SIZE); 11191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 11201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = 1; 11221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Restart rx engine, if its stopped */ 11251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((readl(pi->sdma_base + SDMA_SDCM) & SDMA_SDCM_ERD) == 0) 11261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_start_rx(pi); 11271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tty_flip_buffer_push(tty); 11291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 11301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 11331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_setup_tx_desc(struct mpsc_port_info *pi, u32 count, u32 intr) 11341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 11351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_tx_desc *txre; 11361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre = (struct mpsc_tx_desc *)(pi->txr + 11381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (pi->txr_head * MPSC_TXRE_SIZE)); 11391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre->bytecnt = cpu_to_be16(count); 11411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre->shadow = txre->bytecnt; 11421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wmb(); /* ensure cmdstat is last field updated */ 11431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre->cmdstat = cpu_to_be32(SDMA_DESC_CMDSTAT_O | SDMA_DESC_CMDSTAT_F | 11441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_L | ((intr) ? 11451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_EI 11461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds : 0)); 11471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wmb(); 11481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_cache_sync((void *) txre, MPSC_TXRE_SIZE, DMA_BIDIRECTIONAL); 11491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) 11501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */ 11511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flush_dcache_range((ulong)txre, 11521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ulong)txre + MPSC_TXRE_SIZE); 11531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 11541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 11561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 11591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_copy_tx_data(struct mpsc_port_info *pi) 11601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 11611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct circ_buf *xmit = &pi->port.info->xmit; 11621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 *bp; 11631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 i; 11641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Make sure the desc ring isn't full */ 11661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (CIRC_CNT(pi->txr_head, pi->txr_tail, MPSC_TXR_ENTRIES) < 11671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (MPSC_TXR_ENTRIES - 1)) { 11681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->port.x_char) { 11691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* 11701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Ideally, we should use the TCS field in 11711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * CHR_1 to put the x_char out immediately but 11721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * errata prevents us from being able to read 11731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * CHR_2 to know that its safe to write to 11741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * CHR_1. Instead, just put it in-band with 11751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * all the other Tx data. 11761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 11771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp = pi->txb + (pi->txr_head * MPSC_TXBE_SIZE); 11781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *bp = pi->port.x_char; 11791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.x_char = 0; 11801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds i = 1; 11811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (!uart_circ_empty(xmit) && !uart_tx_stopped(&pi->port)){ 11831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds i = min((u32) MPSC_TXBE_SIZE, 11841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (u32) uart_circ_chars_pending(xmit)); 11851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds i = min(i, (u32) CIRC_CNT_TO_END(xmit->head, xmit->tail, 11861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds UART_XMIT_SIZE)); 11871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp = pi->txb + (pi->txr_head * MPSC_TXBE_SIZE); 11881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memcpy(bp, &xmit->buf[xmit->tail], i); 11891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds xmit->tail = (xmit->tail + i) & (UART_XMIT_SIZE - 1); 11901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 11921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds uart_write_wakeup(&pi->port); 11931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else /* All tx data copied into ring bufs */ 11951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 11961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_cache_sync((void *) bp, MPSC_TXBE_SIZE, DMA_BIDIRECTIONAL); 11981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) 11991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */ 12001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flush_dcache_range((ulong)bp, 12011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ulong)bp + MPSC_TXBE_SIZE); 12021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 12031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_setup_tx_desc(pi, i, 1); 12041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Advance to next descriptor */ 12061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr_head = (pi->txr_head + 1) & (MPSC_TXR_ENTRIES - 1); 12071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 12101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline int 12131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_tx_intr(struct mpsc_port_info *pi) 12141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 12151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_tx_desc *txre; 12161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc = 0; 12171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!mpsc_sdma_tx_active(pi)) { 12191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre = (struct mpsc_tx_desc *)(pi->txr + 12201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (pi->txr_tail * MPSC_TXRE_SIZE)); 12211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_cache_sync((void *) txre, MPSC_TXRE_SIZE, DMA_FROM_DEVICE); 12231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) 12241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */ 12251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds invalidate_dcache_range((ulong)txre, 12261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ulong)txre + MPSC_TXRE_SIZE); 12271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 12281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (!(be32_to_cpu(txre->cmdstat) & SDMA_DESC_CMDSTAT_O)) { 12301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = 1; 12311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.icount.tx += be16_to_cpu(txre->bytecnt); 12321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr_tail = (pi->txr_tail+1) & (MPSC_TXR_ENTRIES-1); 12331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If no more data to tx, fall out of loop */ 12351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->txr_head == pi->txr_tail) 12361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds txre = (struct mpsc_tx_desc *)(pi->txr + 12391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (pi->txr_tail * MPSC_TXRE_SIZE)); 12401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_cache_sync((void *) txre, MPSC_TXRE_SIZE, 12411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DMA_FROM_DEVICE); 12421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) 12431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */ 12441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds invalidate_dcache_range((ulong)txre, 12451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ulong)txre + MPSC_TXRE_SIZE); 12461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 12471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_copy_tx_data(pi); 12501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_start_tx(pi); /* start next desc if ready */ 12511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 12541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 12571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This is the driver's interrupt handler. To avoid a race, we first clear 12581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the interrupt, then handle any completed Rx/Tx descriptors. When done 12591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * handling those descriptors, we restart the Rx/Tx engines if they're stopped. 12601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 12611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic irqreturn_t 12621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_sdma_intr(int irq, void *dev_id, struct pt_regs *regs) 12631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 12641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = dev_id; 12651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ulong iflags; 12661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc = IRQ_NONE; 12671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_sdma_intr[%d]: SDMA Interrupt Received\n",pi->port.line); 12691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(&pi->port.lock, iflags); 12711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_intr_ack(pi); 12721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mpsc_rx_intr(pi, regs)) 12731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = IRQ_HANDLED; 12741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mpsc_tx_intr(pi)) 12751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = IRQ_HANDLED; 12761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(&pi->port.lock, iflags); 12771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_sdma_intr[%d]: SDMA Interrupt Handled\n", pi->port.line); 12791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 12801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 12831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 12841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 12851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * serial_core.c Interface routines 12861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 12871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 12881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 12891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic uint 12901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_tx_empty(struct uart_port *port) 12911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 12921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = (struct mpsc_port_info *)port; 12931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ulong iflags; 12941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds uint rc; 12951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(&pi->port.lock, iflags); 12971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = mpsc_sdma_tx_active(pi) ? 0 : TIOCSER_TEMT; 12981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(&pi->port.lock, iflags); 12991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 13011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 13041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_set_mctrl(struct uart_port *port, uint mctrl) 13051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 13061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Have no way to set modem control lines AFAICT */ 13071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 13081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic uint 13111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_get_mctrl(struct uart_port *port) 13121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 13131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = (struct mpsc_port_info *)port; 13141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 mflags, status; 13151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status = (pi->mirror_regs) ? pi->MPSC_CHR_10_m : 13171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds readl(pi->mpsc_base + MPSC_CHR_10); 13181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mflags = 0; 13201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (status & 0x1) 13211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mflags |= TIOCM_CTS; 13221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (status & 0x2) 13231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mflags |= TIOCM_CAR; 13241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return mflags | TIOCM_DSR; /* No way to tell if DSR asserted */ 13261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 1329b129a8ccd53f74c43e4c83c8e0031a4990040830Russell Kingmpsc_stop_tx(struct uart_port *port) 13301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 13311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = (struct mpsc_port_info *)port; 13321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1333b129a8ccd53f74c43e4c83c8e0031a4990040830Russell King pr_debug("mpsc_stop_tx[%d]\n", port->line); 13341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_freeze(pi); 13361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 13371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 1340b129a8ccd53f74c43e4c83c8e0031a4990040830Russell Kingmpsc_start_tx(struct uart_port *port) 13411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 13421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = (struct mpsc_port_info *)port; 13431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_unfreeze(pi); 13451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_copy_tx_data(pi); 13461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_start_tx(pi); 13471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1348b129a8ccd53f74c43e4c83c8e0031a4990040830Russell King pr_debug("mpsc_start_tx[%d]\n", port->line); 13491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 13501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 13531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_start_rx(struct mpsc_port_info *pi) 13541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 13551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_start_rx[%d]: Starting...\n", pi->port.line); 13561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1357f7232056bff5fe2d3bfeab35252a66ebaeb5bbdeCarlos Sanchez /* Issue a Receive Abort to clear any receive errors */ 1358f7232056bff5fe2d3bfeab35252a66ebaeb5bbdeCarlos Sanchez writel(MPSC_CHR_2_RA, pi->mpsc_base + MPSC_CHR_2); 13591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->rcv_data) { 13601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_enter_hunt(pi); 13611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_cmd(pi, SDMA_SDCM_ERD); 13621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 13641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 13671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_stop_rx(struct uart_port *port) 13681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 13691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = (struct mpsc_port_info *)port; 13701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_stop_rx[%d]: Stopping...\n", port->line); 13721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_cmd(pi, SDMA_SDCM_AR); 13741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 13751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 13781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_enable_ms(struct uart_port *port) 13791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 13801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; /* Not supported */ 13811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 13841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_break_ctl(struct uart_port *port, int ctl) 13851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 13861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = (struct mpsc_port_info *)port; 13871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ulong flags; 13881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 v; 13891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds v = ctl ? 0x00ff0000 : 0; 13911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(&pi->port.lock, flags); 13931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->mirror_regs) 13941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_CHR_1_m = v; 13951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds writel(v, pi->mpsc_base + MPSC_CHR_1); 13961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(&pi->port.lock, flags); 13971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 13991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 14001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 14021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_startup(struct uart_port *port) 14031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 14041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = (struct mpsc_port_info *)port; 14051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 flag = 0; 14061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc; 14071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_startup[%d]: Starting up MPSC, irq: %d\n", 14091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds port->line, pi->port.irq); 14101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((rc = mpsc_make_ready(pi)) == 0) { 14121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Setup IRQ handler */ 14131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_intr_ack(pi); 14141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* If irq's are shared, need to set flag */ 14161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mpsc_ports[0].port.irq == mpsc_ports[1].port.irq) 14171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flag = SA_SHIRQ; 14181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (request_irq(pi->port.irq, mpsc_sdma_intr, flag, 1420a30ff2e348af9d3a1782103130c88960550a773fMark A. Greer "mpsc-sdma", pi)) 14211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "MPSC: Can't get SDMA IRQ %d\n", 14221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.irq); 14231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_intr_unmask(pi, 0xf); 14251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_set_rx_ring(pi, (struct mpsc_rx_desc *)(pi->rxr_p + 14261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (pi->rxr_posn * MPSC_RXRE_SIZE))); 14271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 14301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 14311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 14331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_shutdown(struct uart_port *port) 14341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 14351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = (struct mpsc_port_info *)port; 14361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_shutdown[%d]: Shutting down MPSC\n", port->line); 14381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_stop(pi); 14401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds free_irq(pi->port.irq, pi); 14411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 14421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 14431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 14451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_set_termios(struct uart_port *port, struct termios *termios, 14461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct termios *old) 14471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 14481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = (struct mpsc_port_info *)port; 14491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 baud; 14501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ulong flags; 14511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u32 chr_bits, stop_bits, par; 14521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->c_iflag = termios->c_iflag; 14541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->c_cflag = termios->c_cflag; 14551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch (termios->c_cflag & CSIZE) { 14571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case CS5: 14581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds chr_bits = MPSC_MPCR_CL_5; 14591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 14601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case CS6: 14611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds chr_bits = MPSC_MPCR_CL_6; 14621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 14631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case CS7: 14641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds chr_bits = MPSC_MPCR_CL_7; 14651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 14661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case CS8: 14671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: 14681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds chr_bits = MPSC_MPCR_CL_8; 14691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 14701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (termios->c_cflag & CSTOPB) 14731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds stop_bits = MPSC_MPCR_SBL_2; 14741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 14751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds stop_bits = MPSC_MPCR_SBL_1; 14761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds par = MPSC_CHR_2_PAR_EVEN; 14781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (termios->c_cflag & PARENB) 14791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (termios->c_cflag & PARODD) 14801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds par = MPSC_CHR_2_PAR_ODD; 14811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef CMSPAR 14821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (termios->c_cflag & CMSPAR) { 14831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (termios->c_cflag & PARODD) 14841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds par = MPSC_CHR_2_PAR_MARK; 14851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 14861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds par = MPSC_CHR_2_PAR_SPACE; 14871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 14891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk); 14911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(&pi->port.lock, flags); 14931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds uart_update_timeout(port, termios->c_cflag, baud); 14951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_set_char_length(pi, chr_bits); 14971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_set_stop_bit_length(pi, stop_bits); 14981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_set_parity(pi, par); 14991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_set_baudrate(pi, baud); 15001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Characters/events to read */ 15021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rcv_data = 1; 15031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.read_status_mask = SDMA_DESC_CMDSTAT_OR; 15041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (termios->c_iflag & INPCK) 15061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.read_status_mask |= SDMA_DESC_CMDSTAT_PE | 15071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_FR; 15081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (termios->c_iflag & (BRKINT | PARMRK)) 15101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.read_status_mask |= SDMA_DESC_CMDSTAT_BR; 15111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Characters/events to ignore */ 15131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.ignore_status_mask = 0; 15141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (termios->c_iflag & IGNPAR) 15161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.ignore_status_mask |= SDMA_DESC_CMDSTAT_PE | 15171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDMA_DESC_CMDSTAT_FR; 15181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (termios->c_iflag & IGNBRK) { 15201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.ignore_status_mask |= SDMA_DESC_CMDSTAT_BR; 15211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (termios->c_iflag & IGNPAR) 15231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.ignore_status_mask |= SDMA_DESC_CMDSTAT_OR; 15241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Ignore all chars if CREAD not set */ 15271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(termios->c_cflag & CREAD)) 15281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->rcv_data = 0; 15291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 15301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_start_rx(pi); 15311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(&pi->port.lock, flags); 15331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 15341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic const char * 15371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_type(struct uart_port *port) 15381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 15391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_type[%d]: port type: %s\n", port->line,MPSC_DRIVER_NAME); 15401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return MPSC_DRIVER_NAME; 15411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 15441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_request_port(struct uart_port *port) 15451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 15461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Should make chip/platform specific call */ 15471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 15481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 15511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_release_port(struct uart_port *port) 15521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 15531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = (struct mpsc_port_info *)port; 15541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->ready) { 15561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_uninit_rings(pi); 15571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_free_ring_mem(pi); 15581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->ready = 0; 15591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 15621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 15651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_config_port(struct uart_port *port, int flags) 15661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 15671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 15681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 15711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_verify_port(struct uart_port *port, struct serial_struct *ser) 15721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 15731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = (struct mpsc_port_info *)port; 15741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc = 0; 15751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_verify_port[%d]: Verifying port data\n", pi->port.line); 15771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ser->type != PORT_UNKNOWN && ser->type != PORT_MPSC) 15791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = -EINVAL; 15801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (pi->port.irq != ser->irq) 15811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = -EINVAL; 15821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (ser->io_type != SERIAL_IO_MEM) 15831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = -EINVAL; 15841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (pi->port.uartclk / 16 != ser->baud_base) /* Not sure */ 15851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = -EINVAL; 15861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if ((void *)pi->port.mapbase != ser->iomem_base) 15871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = -EINVAL; 15881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (pi->port.iobase != ser->port) 15891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = -EINVAL; 15901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (ser->hub6 != 0) 15911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = -EINVAL; 15921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 15941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct uart_ops mpsc_pops = { 15971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .tx_empty = mpsc_tx_empty, 15981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .set_mctrl = mpsc_set_mctrl, 15991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .get_mctrl = mpsc_get_mctrl, 16001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .stop_tx = mpsc_stop_tx, 16011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .start_tx = mpsc_start_tx, 16021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .stop_rx = mpsc_stop_rx, 16031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .enable_ms = mpsc_enable_ms, 16041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .break_ctl = mpsc_break_ctl, 16051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .startup = mpsc_startup, 16061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .shutdown = mpsc_shutdown, 16071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .set_termios = mpsc_set_termios, 16081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .type = mpsc_type, 16091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .release_port = mpsc_release_port, 16101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .request_port = mpsc_request_port, 16111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .config_port = mpsc_config_port, 16121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .verify_port = mpsc_verify_port, 16131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 16141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 16161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 16171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 16181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Console Interface Routines 16191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 16201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 16211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 16221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef CONFIG_SERIAL_MPSC_CONSOLE 16241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 16251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_console_write(struct console *co, const char *s, uint count) 16261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 16271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi = &mpsc_ports[co->index]; 16281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds u8 *bp, *dp, add_cr = 0; 16291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 16301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (mpsc_sdma_tx_active(pi)) 16321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(100); 16331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (count > 0) { 16351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bp = dp = pi->txb + (pi->txr_head * MPSC_TXBE_SIZE); 16361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; i < MPSC_TXBE_SIZE; i++) { 16381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (count == 0) 16391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 16401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (add_cr) { 16421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *(dp++) = '\r'; 16431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds add_cr = 0; 16441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 16461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *(dp++) = *s; 16471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (*(s++) == '\n') { /* add '\r' after '\n' */ 16491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds add_cr = 1; 16501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds count++; 16511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds count--; 16551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_cache_sync((void *) bp, MPSC_TXBE_SIZE, DMA_BIDIRECTIONAL); 16581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE) 16591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (pi->cache_mgmt) /* GT642[46]0 Res #COMM-2 */ 16601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flush_dcache_range((ulong)bp, 16611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (ulong)bp + MPSC_TXBE_SIZE); 16621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 16631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_setup_tx_desc(pi, i, 0); 16641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr_head = (pi->txr_head + 1) & (MPSC_TXR_ENTRIES - 1); 16651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_sdma_start_tx(pi); 16661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (mpsc_sdma_tx_active(pi)) 16681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(100); 16691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->txr_tail = (pi->txr_tail + 1) & (MPSC_TXR_ENTRIES - 1); 16711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 16741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 16751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int __init 16771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_console_setup(struct console *co, char *options) 16781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 16791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi; 16801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int baud, bits, parity, flow; 16811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_console_setup[%d]: options: %s\n", co->index, options); 16831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (co->index >= MPSC_NUM_CTLRS) 16851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds co->index = 0; 16861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi = &mpsc_ports[co->index]; 16881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds baud = pi->default_baud; 16901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bits = pi->default_bits; 16911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds parity = pi->default_parity; 16921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds flow = pi->default_flow; 16931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!pi->port.ops) 16951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENODEV; 16961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_init(&pi->port.lock); /* Temporary fix--copied from 8250.c */ 16981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (options) 17001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds uart_parse_options(options, &baud, &parity, &bits, &flow); 17011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return uart_set_options(&pi->port, co, baud, parity, bits, flow); 17031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct console mpsc_console = { 17061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .name = MPSC_DEV_NAME, 17071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .write = mpsc_console_write, 17081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .device = uart_console_device, 17091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .setup = mpsc_console_setup, 17101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .flags = CON_PRINTBUFFER, 17111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .index = -1, 17121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .data = &mpsc_reg, 17131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 17141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int __init 17161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_late_console_init(void) 17171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pr_debug("mpsc_late_console_init: Enter\n"); 17191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(mpsc_console.flags & CON_ENABLED)) 17211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds register_console(&mpsc_console); 17221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 17231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldslate_initcall(mpsc_late_console_init); 17261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MPSC_CONSOLE &mpsc_console 17281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 17291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define MPSC_CONSOLE NULL 17301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 17311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 17321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 17331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 17341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Dummy Platform Driver to extract & map shared register regions 17351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 17361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 17371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 17381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 17391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_resource_err(char *s) 17401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_WARNING "MPSC: Platform device resource error in %s\n", s); 17421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 17431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 17461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_shared_map_regs(struct platform_device *pd) 17471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct resource *r; 17491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((r = platform_get_resource(pd, IORESOURCE_MEM, 17511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_ROUTING_BASE_ORDER)) && request_mem_region(r->start, 17521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_ROUTING_REG_BLOCK_SIZE, "mpsc_routing_regs")) { 17531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.mpsc_routing_base = ioremap(r->start, 17551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_ROUTING_REG_BLOCK_SIZE); 17561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.mpsc_routing_base_p = r->start; 17571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 17591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_resource_err("MPSC routing base"); 17601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 17611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((r = platform_get_resource(pd, IORESOURCE_MEM, 17641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_SDMA_INTR_BASE_ORDER)) && request_mem_region(r->start, 17651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_SDMA_INTR_REG_BLOCK_SIZE, "sdma_intr_regs")) { 17661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.sdma_intr_base = ioremap(r->start, 17681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_SDMA_INTR_REG_BLOCK_SIZE); 17691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.sdma_intr_base_p = r->start; 17701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 17721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds iounmap(mpsc_shared_regs.mpsc_routing_base); 17731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_mem_region(mpsc_shared_regs.mpsc_routing_base_p, 17741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_ROUTING_REG_BLOCK_SIZE); 17751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_resource_err("SDMA intr base"); 17761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 17771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 17801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 17831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_shared_unmap_regs(void) 17841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!mpsc_shared_regs.mpsc_routing_base) { 17861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds iounmap(mpsc_shared_regs.mpsc_routing_base); 17871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_mem_region(mpsc_shared_regs.mpsc_routing_base_p, 17881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_ROUTING_REG_BLOCK_SIZE); 17891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!mpsc_shared_regs.sdma_intr_base) { 17911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds iounmap(mpsc_shared_regs.sdma_intr_base); 17921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_mem_region(mpsc_shared_regs.sdma_intr_base_p, 17931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_SDMA_INTR_REG_BLOCK_SIZE); 17941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17962c6e75999000ebc942526466dbd0de37bfac73a4Al Viro mpsc_shared_regs.mpsc_routing_base = NULL; 17972c6e75999000ebc942526466dbd0de37bfac73a4Al Viro mpsc_shared_regs.sdma_intr_base = NULL; 17981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.mpsc_routing_base_p = 0; 18001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.sdma_intr_base_p = 0; 18011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 18031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 18041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 18063ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell Kingmpsc_shared_drv_probe(struct platform_device *dev) 18071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 18081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_shared_pdata *pdata; 18091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc = -ENODEV; 18101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18113ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King if (dev->id == 0) { 18123ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King if (!(rc = mpsc_shared_map_regs(dev))) { 18133ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King pdata = (struct mpsc_shared_pdata *)dev->dev.platform_data; 18141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.MPSC_MRR_m = pdata->mrr_val; 18161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.MPSC_RCRR_m= pdata->rcrr_val; 18171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.MPSC_TCRR_m= pdata->tcrr_val; 18181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.SDMA_INTR_CAUSE_m = 18191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pdata->intr_cause_val; 18201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.SDMA_INTR_MASK_m = 18211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pdata->intr_mask_val; 18221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = 0; 18241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 18281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 18291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 18313ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell Kingmpsc_shared_drv_remove(struct platform_device *dev) 18321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 18331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc = -ENODEV; 18341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18353ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King if (dev->id == 0) { 18361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_unmap_regs(); 18371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.MPSC_MRR_m = 0; 18381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.MPSC_RCRR_m = 0; 18391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.MPSC_TCRR_m = 0; 18401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.SDMA_INTR_CAUSE_m = 0; 18411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_shared_regs.SDMA_INTR_MASK_m = 0; 18421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = 0; 18431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 18461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 18471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18483ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell Kingstatic struct platform_driver mpsc_shared_driver = { 18491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .probe = mpsc_shared_drv_probe, 18501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .remove = mpsc_shared_drv_remove, 18513ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King .driver = { 18523ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King .name = MPSC_SHARED_NAME, 18533ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King }, 18541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 18551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 18571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 18581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 18591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Driver Interface Routines 18601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 18611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ****************************************************************************** 18621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 18631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct uart_driver mpsc_reg = { 18641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .owner = THIS_MODULE, 18651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .driver_name = MPSC_DRIVER_NAME, 18661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .devfs_name = MPSC_DEVFS_NAME, 18671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .dev_name = MPSC_DEV_NAME, 18681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .major = MPSC_MAJOR, 18691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .minor = MPSC_MINOR_START, 18701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .nr = MPSC_NUM_CTLRS, 18711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .cons = MPSC_CONSOLE, 18721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 18731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 18751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_drv_map_regs(struct mpsc_port_info *pi, struct platform_device *pd) 18761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 18771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct resource *r; 18781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((r = platform_get_resource(pd, IORESOURCE_MEM, MPSC_BASE_ORDER)) && 18801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds request_mem_region(r->start, MPSC_REG_BLOCK_SIZE, "mpsc_regs")){ 18811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->mpsc_base = ioremap(r->start, MPSC_REG_BLOCK_SIZE); 18831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->mpsc_base_p = r->start; 18841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 18861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_resource_err("MPSC base"); 18871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 18881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((r = platform_get_resource(pd, IORESOURCE_MEM, 18911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_SDMA_BASE_ORDER)) && request_mem_region(r->start, 18921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MPSC_SDMA_REG_BLOCK_SIZE, "sdma_regs")) { 18931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->sdma_base = ioremap(r->start,MPSC_SDMA_REG_BLOCK_SIZE); 18951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->sdma_base_p = r->start; 18961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 18981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_resource_err("SDMA base"); 18991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 19001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if ((r = platform_get_resource(pd,IORESOURCE_MEM,MPSC_BRG_BASE_ORDER)) 19031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && request_mem_region(r->start, MPSC_BRG_REG_BLOCK_SIZE, 19041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "brg_regs")) { 19051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->brg_base = ioremap(r->start, MPSC_BRG_REG_BLOCK_SIZE); 19071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->brg_base_p = r->start; 19081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 19101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_resource_err("BRG base"); 19111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENOMEM; 19121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 19151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 19181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_drv_unmap_regs(struct mpsc_port_info *pi) 19191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 19201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!pi->mpsc_base) { 19211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds iounmap(pi->mpsc_base); 19221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_mem_region(pi->mpsc_base_p, MPSC_REG_BLOCK_SIZE); 19231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!pi->sdma_base) { 19251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds iounmap(pi->sdma_base); 19261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_mem_region(pi->sdma_base_p, MPSC_SDMA_REG_BLOCK_SIZE); 19271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!pi->brg_base) { 19291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds iounmap(pi->brg_base); 19301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds release_mem_region(pi->brg_base_p, MPSC_BRG_REG_BLOCK_SIZE); 19311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19332c6e75999000ebc942526466dbd0de37bfac73a4Al Viro pi->mpsc_base = NULL; 19342c6e75999000ebc942526466dbd0de37bfac73a4Al Viro pi->sdma_base = NULL; 19352c6e75999000ebc942526466dbd0de37bfac73a4Al Viro pi->brg_base = NULL; 19361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->mpsc_base_p = 0; 19381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->sdma_base_p = 0; 19391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->brg_base_p = 0; 19401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 19421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void 19451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_drv_get_platform_data(struct mpsc_port_info *pi, 19461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct platform_device *pd, int num) 19471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 19481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_pdata *pdata; 19491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pdata = (struct mpsc_pdata *)pd->dev.platform_data; 19511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.uartclk = pdata->brg_clk_freq; 19531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.iotype = UPIO_MEM; 19541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.line = num; 19551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.type = PORT_MPSC; 19561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.fifosize = MPSC_TXBE_SIZE; 19571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.membase = pi->mpsc_base; 19581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.mapbase = (ulong)pi->mpsc_base; 19591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.ops = &mpsc_pops; 19601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->mirror_regs = pdata->mirror_regs; 19621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->cache_mgmt = pdata->cache_mgmt; 19631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->brg_can_tune = pdata->brg_can_tune; 19641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->brg_clk_src = pdata->brg_clk_src; 19651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->mpsc_max_idle = pdata->max_idle; 19661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->default_baud = pdata->default_baud; 19671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->default_bits = pdata->default_bits; 19681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->default_parity = pdata->default_parity; 19691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->default_flow = pdata->default_flow; 19701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Initial values of mirrored regs */ 19721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_CHR_1_m = pdata->chr_1_val; 19731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_CHR_2_m = pdata->chr_2_val; 19741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_CHR_10_m = pdata->chr_10_val; 19751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->MPSC_MPCR_m = pdata->mpcr_val; 19761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->BRG_BCR_m = pdata->bcr_val; 19771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->shared_regs = &mpsc_shared_regs; 19791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pi->port.irq = platform_get_irq(pd, 0); 19811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 19831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 19863ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell Kingmpsc_drv_probe(struct platform_device *dev) 19871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 19881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mpsc_port_info *pi; 19891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc = -ENODEV; 19901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19913ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King pr_debug("mpsc_drv_probe: Adding MPSC %d\n", dev->id); 19921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19933ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King if (dev->id < MPSC_NUM_CTLRS) { 19943ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King pi = &mpsc_ports[dev->id]; 19951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19963ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King if (!(rc = mpsc_drv_map_regs(pi, dev))) { 19973ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King mpsc_drv_get_platform_data(pi, dev, dev->id); 19981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(rc = mpsc_make_ready(pi))) 20001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(rc = uart_add_one_port(&mpsc_reg, 20011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &pi->port))) 20021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds rc = 0; 20031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else { 20041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_release_port( 20051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct uart_port *)pi); 20061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_drv_unmap_regs(pi); 20071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 20091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mpsc_drv_unmap_regs(pi); 20101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 20141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 20173ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell Kingmpsc_drv_remove(struct platform_device *dev) 20181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 20193ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King pr_debug("mpsc_drv_exit: Removing MPSC %d\n", dev->id); 20201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20213ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King if (dev->id < MPSC_NUM_CTLRS) { 20223ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King uart_remove_one_port(&mpsc_reg, &mpsc_ports[dev->id].port); 20233ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King mpsc_release_port((struct uart_port *)&mpsc_ports[dev->id].port); 20243ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King mpsc_drv_unmap_regs(&mpsc_ports[dev->id]); 20251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 20261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 20281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENODEV; 20291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20313ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell Kingstatic struct platform_driver mpsc_driver = { 20321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .probe = mpsc_drv_probe, 20331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .remove = mpsc_drv_remove, 20343ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King .driver = { 20353ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King .name = MPSC_CTLR_NAME, 20363ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King }, 20371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 20381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int __init 20401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_drv_init(void) 20411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 20421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int rc; 20431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_INFO "Serial: MPSC driver $Revision: 1.00 $\n"); 20451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(mpsc_ports, 0, sizeof(mpsc_ports)); 20471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(&mpsc_shared_regs, 0, sizeof(mpsc_shared_regs)); 20481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!(rc = uart_register_driver(&mpsc_reg))) { 20503ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King if (!(rc = platform_driver_register(&mpsc_shared_driver))) { 20513ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King if ((rc = platform_driver_register(&mpsc_driver))) { 20523ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King platform_driver_unregister(&mpsc_shared_driver); 20531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds uart_unregister_driver(&mpsc_reg); 20541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 20571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds uart_unregister_driver(&mpsc_reg); 20581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return rc; 20611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void __exit 20651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmpsc_drv_exit(void) 20661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 20673ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King platform_driver_unregister(&mpsc_driver); 20683ae5eaec1d2d9c0cf53745352e7d4b152810ba24Russell King platform_driver_unregister(&mpsc_shared_driver); 20691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds uart_unregister_driver(&mpsc_reg); 20701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(mpsc_ports, 0, sizeof(mpsc_ports)); 20711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(&mpsc_shared_regs, 0, sizeof(mpsc_shared_regs)); 20721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 20731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmodule_init(mpsc_drv_init); 20761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmodule_exit(mpsc_drv_exit); 20771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_AUTHOR("Mark A. Greer <mgreer@mvista.com>"); 20791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_DESCRIPTION("Generic Marvell MPSC serial/UART driver $Revision: 1.00 $"); 20801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_VERSION(MPSC_VERSION); 20811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_LICENSE("GPL"); 20821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_ALIAS_CHARDEV_MAJOR(MPSC_MAJOR); 2083