/* * linux/arch/arm/mach-pxa/ssp.c * * based on linux/arch/arm/mach-sa1100/ssp.c by Russell King * * Copyright (C) 2003 Russell King. * Copyright (C) 2003 Wolfson Microelectronics PLC * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * PXA2xx SSP driver. This provides the generic core for simple * IO-based SSP applications and allows easy port setup for DMA access. * * Author: Liam Girdwood * * Revision history: * 22nd Aug 2003 Initial version. * 20th Dec 2004 Added ssp_config for changing port config without * closing the port. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #define PXA_SSP_PORTS 3 static DECLARE_MUTEX(sem); static int use_count[PXA_SSP_PORTS] = {0, 0, 0}; static irqreturn_t ssp_interrupt(int irq, void *dev_id, struct pt_regs *regs) { struct ssp_dev *dev = (struct ssp_dev*) dev_id; unsigned int status = SSSR_P(dev->port); SSSR_P(dev->port) = status; /* clear status bits */ if (status & SSSR_ROR) printk(KERN_WARNING "SSP(%d): receiver overrun\n", dev->port); if (status & SSSR_TUR) printk(KERN_WARNING "SSP(%d): transmitter underrun\n", dev->port); if (status & SSSR_BCE) printk(KERN_WARNING "SSP(%d): bit count error\n", dev->port); return IRQ_HANDLED; } /** * ssp_write_word - write a word to the SSP port * @data: 32-bit, MSB justified data to write. * * Wait for a free entry in the SSP transmit FIFO, and write a data * word to the SSP port. * * The caller is expected to perform the necessary locking. * * Returns: * %-ETIMEDOUT timeout occurred (for future) * 0 success */ int ssp_write_word(struct ssp_dev *dev, u32 data) { while (!(SSSR_P(dev->port) & SSSR_TNF)) cpu_relax(); SSDR_P(dev->port) = data; return 0; } /** * ssp_read_word - read a word from the SSP port * * Wait for a data word in the SSP receive FIFO, and return the * received data. Data is LSB justified. * * Note: Currently, if data is not expected to be received, this * function will wait for ever. * * The caller is expected to perform the necessary locking. * * Returns: * %-ETIMEDOUT timeout occurred (for future) * 32-bit data success */ int ssp_read_word(struct ssp_dev *dev) { while (!(SSSR_P(dev->port) & SSSR_RNE)) cpu_relax(); return SSDR_P(dev->port); } /** * ssp_flush - flush the transmit and receive FIFOs * * Wait for the SSP to idle, and ensure that the receive FIFO * is empty. * * The caller is expected to perform the necessary locking. */ void ssp_flush(struct ssp_dev *dev) { do { while (SSSR_P(dev->port) & SSSR_RNE) { (void) SSDR_P(dev->port); } } while (SSSR_P(dev->port) & SSSR_BSY); } /** * ssp_enable - enable the SSP port * * Turn on the SSP port. */ void ssp_enable(struct ssp_dev *dev) { SSCR0_P(dev->port) |= SSCR0_SSE; } /** * ssp_disable - shut down the SSP port * * Turn off the SSP port, optionally powering it down. */ void ssp_disable(struct ssp_dev *dev) { SSCR0_P(dev->port) &= ~SSCR0_SSE; } /** * ssp_save_state - save the SSP configuration * @ssp: pointer to structure to save SSP configuration * * Save the configured SSP state for suspend. */ void ssp_save_state(struct ssp_dev *dev, struct ssp_state *ssp) { ssp->cr0 = SSCR0_P(dev->port); ssp->cr1 = SSCR1_P(dev->port); ssp->to = SSTO_P(dev->port); ssp->psp = SSPSP_P(dev->port); SSCR0_P(dev->port) &= ~SSCR0_SSE; } /** * ssp_restore_state - restore a previously saved SSP configuration * @ssp: pointer to configuration saved by ssp_save_state * * Restore the SSP configuration saved previously by ssp_save_state. */ void ssp_restore_state(struct ssp_dev *dev, struct ssp_state *ssp) { SSSR_P(dev->port) = SSSR_ROR | SSSR_TUR | SSSR_BCE; SSCR0_P(dev->port) = ssp->cr0 & ~SSCR0_SSE; SSCR1_P(dev->port) = ssp->cr1; SSTO_P(dev->port) = ssp->to; SSPSP_P(dev->port) = ssp->psp; SSCR0_P(dev->port) = ssp->cr0; } /** * ssp_config - configure SSP port settings * @mode: port operating mode * @flags: port config flags * @psp_flags: port PSP config flags * @speed: port speed * * Port MUST be disabled by ssp_disable before making any config changes. */ int ssp_config(struct ssp_dev *dev, u32 mode, u32 flags, u32 psp_flags, u32 speed) { dev->mode = mode; dev->flags = flags; dev->psp_flags = psp_flags; dev->speed = speed; /* set up port type, speed, port settings */ SSCR0_P(dev->port) = (dev->speed | dev->mode); SSCR1_P(dev->port) = dev->flags; SSPSP_P(dev->port) = dev->psp_flags; return 0; } /** * ssp_init - setup the SSP port * * initialise and claim resources for the SSP port. * * Returns: * %-ENODEV if the SSP port is unavailable * %-EBUSY if the resources are already in use * %0 on success */ int ssp_init(struct ssp_dev *dev, u32 port) { int ret, irq; if (port > PXA_SSP_PORTS || port == 0) return -ENODEV; down(&sem); if (use_count[port - 1]) { up(&sem); return -EBUSY; } use_count[port - 1]++; if (!request_mem_region(__PREG(SSCR0_P(port)), 0x2c, "SSP")) { use_count[port - 1]--; up(&sem); return -EBUSY; } switch (port) { case 1: irq = IRQ_SSP; break; #if defined (CONFIG_PXA27x) case 2: irq = IRQ_SSP2; break; case 3: irq = IRQ_SSP3; break; #else case 2: irq = IRQ_NSSP; break; case 3: irq = IRQ_ASSP; break; #endif default: return -ENODEV; } dev->port = port; ret = request_irq(irq, ssp_interrupt, 0, "SSP", dev); if (ret) goto out_region; /* turn on SSP port clock */ switch (dev->port) { #if defined (CONFIG_PXA27x) case 1: pxa_set_cken(CKEN23_SSP1, 1); break; case 2: pxa_set_cken(CKEN3_SSP2, 1); break; case 3: pxa_set_cken(CKEN4_SSP3, 1); break; #else case 1: pxa_set_cken(CKEN3_SSP, 1); break; case 2: pxa_set_cken(CKEN9_NSSP, 1); break; case 3: pxa_set_cken(CKEN10_ASSP, 1); break; #endif } up(&sem); return 0; out_region: release_mem_region(__PREG(SSCR0_P(port)), 0x2c); use_count[port - 1]--; up(&sem); return ret; } /** * ssp_exit - undo the effects of ssp_init * * release and free resources for the SSP port. */ void ssp_exit(struct ssp_dev *dev) { int irq; down(&sem); SSCR0_P(dev->port) &= ~SSCR0_SSE; /* find irq, save power and turn off SSP port clock */ switch (dev->port) { #if defined (CONFIG_PXA27x) case 1: irq = IRQ_SSP; pxa_set_cken(CKEN23_SSP1, 0); break; case 2: irq = IRQ_SSP2; pxa_set_cken(CKEN3_SSP2, 0); break; case 3: irq = IRQ_SSP3; pxa_set_cken(CKEN4_SSP3, 0); break; #else case 1: irq = IRQ_SSP; pxa_set_cken(CKEN3_SSP, 0); break; case 2: irq = IRQ_NSSP; pxa_set_cken(CKEN9_NSSP, 0); break; case 3: irq = IRQ_ASSP; pxa_set_cken(CKEN10_ASSP, 0); break; #endif default: printk(KERN_WARNING "SSP: tried to close invalid port\n"); return; } free_irq(irq, dev); release_mem_region(__PREG(SSCR0_P(dev->port)), 0x2c); use_count[dev->port - 1]--; up(&sem); } EXPORT_SYMBOL(ssp_write_word); EXPORT_SYMBOL(ssp_read_word); EXPORT_SYMBOL(ssp_flush); EXPORT_SYMBOL(ssp_enable); EXPORT_SYMBOL(ssp_disable); EXPORT_SYMBOL(ssp_save_state); EXPORT_SYMBOL(ssp_restore_state); EXPORT_SYMBOL(ssp_init); EXPORT_SYMBOL(ssp_exit); EXPORT_SYMBOL(ssp_config); MODULE_DESCRIPTION("PXA SSP driver"); MODULE_AUTHOR("Liam Girdwood"); MODULE_LICENSE("GPL");