Logo Search packages:      
Sourcecode: linux-2.6 version File versions  Download package

ssp.c

/*
 *  linux/arch/arm/mach-sa1100/ssp.c
 *
 *  Copyright (C) 2003 Russell King.
 *
 * 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.
 *
 *  Generic SSP driver.  This provides the generic core for simple
 *  IO-based SSP applications.
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/init.h>

#include <asm/io.h>
#include <asm/irq.h>
#include <asm/hardware.h>
#include <asm/hardware/ssp.h>

#define TIMEOUT 100000

static irqreturn_t ssp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
      unsigned int status = Ser4SSSR;

      if (status & SSSR_ROR) {
            printk(KERN_WARNING "SSP: receiver overrun\n");
      }

      Ser4SSSR = SSSR_ROR;

      return status ? IRQ_HANDLED : IRQ_NONE;
}

/**
 * ssp_write_word - write a word to the SSP port
 * @data: 16-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.  Wait for the SSP port to start sending
 * the data.
 *
 * The caller is expected to perform the necessary locking.
 *
 * Returns:
 *   %-ETIMEDOUT  timeout occurred
 *   0                  success
 */
int ssp_write_word(u16 data)
{
      int timeout = TIMEOUT;

      while (!(Ser4SSSR & SSSR_TNF)) {
              if (!--timeout)
                  return -ETIMEDOUT;
            cpu_relax();
      }

      Ser4SSDR = data;

      timeout = TIMEOUT;
      while (!(Ser4SSSR & SSSR_BSY)) {
              if (!--timeout)
                  return -ETIMEDOUT;
            cpu_relax();
      }

      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
 *   16-bit data  success
 */
int ssp_read_word(u16 *data)
{
      int timeout = TIMEOUT;

      while (!(Ser4SSSR & SSSR_RNE)) {
              if (!--timeout)
                  return -ETIMEDOUT;
            cpu_relax();
      }

      *data = (u16)Ser4SSDR;

      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.
 *
 * Returns:
 *   %-ETIMEDOUT  timeout occurred
 *   0                  success
 */
int ssp_flush(void)
{
      int timeout = TIMEOUT * 2;

      do {
            while (Ser4SSSR & SSSR_RNE) {
                    if (!--timeout)
                        return -ETIMEDOUT;
                  (void) Ser4SSDR;
            }
              if (!--timeout)
                  return -ETIMEDOUT;
      } while (Ser4SSSR & SSSR_BSY);

      return 0;
}

/**
 * ssp_enable - enable the SSP port
 *
 * Turn on the SSP port.
 */
void ssp_enable(void)
{
      Ser4SSCR0 |= SSCR0_SSE;
}

/**
 * ssp_disable - shut down the SSP port
 *
 * Turn off the SSP port, optionally powering it down.
 */
void ssp_disable(void)
{
      Ser4SSCR0 &= ~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_state *ssp)
{
      ssp->cr0 = Ser4SSCR0;
      ssp->cr1 = Ser4SSCR1;

      Ser4SSCR0 &= ~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_state *ssp)
{
      Ser4SSSR = SSSR_ROR;

      Ser4SSCR0 = ssp->cr0 & ~SSCR0_SSE;
      Ser4SSCR1 = ssp->cr1;
      Ser4SSCR0 = ssp->cr0;
}

/**
 * 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(void)
{
      int ret;

      if (!(PPAR & PPAR_SPR) && (Ser4MCCR0 & MCCR0_MCE))
            return -ENODEV;

      if (!request_mem_region(__PREG(Ser4SSCR0), 0x18, "SSP")) {
            return -EBUSY;
      }

      Ser4SSSR = SSSR_ROR;

      ret = request_irq(IRQ_Ser4SSP, ssp_interrupt, 0, "SSP", NULL);
      if (ret)
            goto out_region;

      return 0;

 out_region:
      release_mem_region(__PREG(Ser4SSCR0), 0x18);
      return ret;
}

/**
 * ssp_exit - undo the effects of ssp_init
 *
 * release and free resources for the SSP port.
 */
void ssp_exit(void)
{
      Ser4SSCR0 &= ~SSCR0_SSE;

      free_irq(IRQ_Ser4SSP, NULL);
      release_mem_region(__PREG(Ser4SSCR0), 0x18);
}

MODULE_AUTHOR("Russell King");
MODULE_DESCRIPTION("SA11x0 SSP PIO driver");
MODULE_LICENSE("GPL");

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);

Generated by  Doxygen 1.6.0   Back to index