You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
337 lines
7.6 KiB
337 lines
7.6 KiB
/*
|
|
* 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 <liam.girdwood@wolfsonmicro.com>
|
|
*
|
|
* Revision history:
|
|
* 22nd Aug 2003 Initial version.
|
|
* 20th Dec 2004 Added ssp_config for changing port config without
|
|
* closing the port.
|
|
* 4th Aug 2005 Added option to disable irq handler registration and
|
|
* cleaned up irq and clock detection.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/init.h>
|
|
#include <linux/mutex.h>
|
|
#include <asm/io.h>
|
|
#include <asm/irq.h>
|
|
#include <asm/hardware.h>
|
|
#include <asm/arch/ssp.h>
|
|
#include <asm/arch/pxa-regs.h>
|
|
|
|
#define PXA_SSP_PORTS 3
|
|
|
|
#define TIMEOUT 100000
|
|
|
|
struct ssp_info_ {
|
|
int irq;
|
|
u32 clock;
|
|
};
|
|
|
|
/*
|
|
* SSP port clock and IRQ settings
|
|
*/
|
|
static const struct ssp_info_ ssp_info[PXA_SSP_PORTS] = {
|
|
#if defined (CONFIG_PXA27x)
|
|
{IRQ_SSP, CKEN23_SSP1},
|
|
{IRQ_SSP2, CKEN3_SSP2},
|
|
{IRQ_SSP3, CKEN4_SSP3},
|
|
#else
|
|
{IRQ_SSP, CKEN3_SSP},
|
|
{IRQ_NSSP, CKEN9_NSSP},
|
|
{IRQ_ASSP, CKEN10_ASSP},
|
|
#endif
|
|
};
|
|
|
|
static DEFINE_MUTEX(mutex);
|
|
static int use_count[PXA_SSP_PORTS] = {0, 0, 0};
|
|
|
|
static irqreturn_t ssp_interrupt(int irq, void *dev_id)
|
|
{
|
|
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
|
|
* 0 success
|
|
*/
|
|
int ssp_write_word(struct ssp_dev *dev, u32 data)
|
|
{
|
|
int timeout = TIMEOUT;
|
|
|
|
while (!(SSSR_P(dev->port) & SSSR_TNF)) {
|
|
if (!--timeout)
|
|
return -ETIMEDOUT;
|
|
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
|
|
* 32-bit data success
|
|
*/
|
|
int ssp_read_word(struct ssp_dev *dev, u32 *data)
|
|
{
|
|
int timeout = TIMEOUT;
|
|
|
|
while (!(SSSR_P(dev->port) & SSSR_RNE)) {
|
|
if (!--timeout)
|
|
return -ETIMEDOUT;
|
|
cpu_relax();
|
|
}
|
|
|
|
*data = SSDR_P(dev->port);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
int ssp_flush(struct ssp_dev *dev)
|
|
{
|
|
int timeout = TIMEOUT * 2;
|
|
|
|
do {
|
|
while (SSSR_P(dev->port) & SSSR_RNE) {
|
|
if (!--timeout)
|
|
return -ETIMEDOUT;
|
|
(void) SSDR_P(dev->port);
|
|
}
|
|
if (!--timeout)
|
|
return -ETIMEDOUT;
|
|
} while (SSSR_P(dev->port) & SSSR_BSY);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* 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, u32 init_flags)
|
|
{
|
|
int ret;
|
|
|
|
if (port > PXA_SSP_PORTS || port == 0)
|
|
return -ENODEV;
|
|
|
|
mutex_lock(&mutex);
|
|
if (use_count[port - 1]) {
|
|
mutex_unlock(&mutex);
|
|
return -EBUSY;
|
|
}
|
|
use_count[port - 1]++;
|
|
|
|
if (!request_mem_region(__PREG(SSCR0_P(port)), 0x2c, "SSP")) {
|
|
use_count[port - 1]--;
|
|
mutex_unlock(&mutex);
|
|
return -EBUSY;
|
|
}
|
|
dev->port = port;
|
|
|
|
/* do we need to get irq */
|
|
if (!(init_flags & SSP_NO_IRQ)) {
|
|
ret = request_irq(ssp_info[port-1].irq, ssp_interrupt,
|
|
0, "SSP", dev);
|
|
if (ret)
|
|
goto out_region;
|
|
dev->irq = ssp_info[port-1].irq;
|
|
} else
|
|
dev->irq = 0;
|
|
|
|
/* turn on SSP port clock */
|
|
pxa_set_cken(ssp_info[port-1].clock, 1);
|
|
mutex_unlock(&mutex);
|
|
return 0;
|
|
|
|
out_region:
|
|
release_mem_region(__PREG(SSCR0_P(port)), 0x2c);
|
|
use_count[port - 1]--;
|
|
mutex_unlock(&mutex);
|
|
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)
|
|
{
|
|
mutex_lock(&mutex);
|
|
SSCR0_P(dev->port) &= ~SSCR0_SSE;
|
|
|
|
if (dev->port > PXA_SSP_PORTS || dev->port == 0) {
|
|
printk(KERN_WARNING "SSP: tried to close invalid port\n");
|
|
return;
|
|
}
|
|
|
|
pxa_set_cken(ssp_info[dev->port-1].clock, 0);
|
|
if (dev->irq)
|
|
free_irq(dev->irq, dev);
|
|
release_mem_region(__PREG(SSCR0_P(dev->port)), 0x2c);
|
|
use_count[dev->port - 1]--;
|
|
mutex_unlock(&mutex);
|
|
}
|
|
|
|
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");
|
|
|
|
|