arch/arm/mach-sa1100/ssp.c

   1 /*
   2  *  linux/arch/arm/mach-sa1100/ssp.c
   3  *
   4  *  Copyright (C) 2003 Russell King.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  *  Generic SSP driver.  This provides the generic core for simple
  11  *  IO-based SSP applications.
  12  */
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/sched.h>
  16 #include <linux/errno.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/ioport.h>
  19 #include <linux/init.h>
  20
  21 #include <asm/io.h>
  22 #include <asm/irq.h>
  23 #include <asm/hardware.h>
  24 #include <asm/hardware/ssp.h>
  25
  26 #define TIMEOUT 100000
  27
  28 static irqreturn_t ssp_interrupt(int irq, void *dev_id)
  29 {
  30         unsigned int status = Ser4SSSR;
  31
  32         if (status & SSSR_ROR) {
  33                 printk(KERN_WARNING "SSP: receiver overrun\n");
  34         }
  35
  36         Ser4SSSR = SSSR_ROR;
  37
  38         return status ? IRQ_HANDLED : IRQ_NONE;
  39 }
  40
  41 /**
  42  * ssp_write_word - write a word to the SSP port
  43  * @data: 16-bit, MSB justified data to write.
  44  *
  45  * Wait for a free entry in the SSP transmit FIFO, and write a data
  46  * word to the SSP port.  Wait for the SSP port to start sending
  47  * the data.
  48  *
  49  * The caller is expected to perform the necessary locking.
  50  *
  51  * Returns:
  52  *   %-ETIMEDOUT        timeout occurred
  53  *   0                  success
  54  */
  55 int ssp_write_word(u16 data)
  56 {
  57         int timeout = TIMEOUT;
  58
  59         while (!(Ser4SSSR & SSSR_TNF)) {
  60                 if (!--timeout)
  61                         return -ETIMEDOUT;
  62                 cpu_relax();
  63         }
  64
  65         Ser4SSDR = data;
  66
  67         timeout = TIMEOUT;
  68         while (!(Ser4SSSR & SSSR_BSY)) {
  69                 if (!--timeout)
  70                         return -ETIMEDOUT;
  71                 cpu_relax();
  72         }
  73
  74         return 0;
  75 }
  76
  77 /**
  78  * ssp_read_word - read a word from the SSP port
  79  *
  80  * Wait for a data word in the SSP receive FIFO, and return the
  81  * received data.  Data is LSB justified.
  82  *
  83  * Note: Currently, if data is not expected to be received, this
  84  * function will wait for ever.
  85  *
  86  * The caller is expected to perform the necessary locking.
  87  *
  88  * Returns:
  89  *   %-ETIMEDOUT        timeout occurred
  90  *   16-bit data        success
  91  */
  92 int ssp_read_word(u16 *data)
  93 {
  94         int timeout = TIMEOUT;
  95
  96         while (!(Ser4SSSR & SSSR_RNE)) {
  97                 if (!--timeout)
  98                         return -ETIMEDOUT;
  99                 cpu_relax();
 100         }
 101
 102         *data = (u16)Ser4SSDR;
 103
 104         return 0;
 105 }
 106
 107 /**
 108  * ssp_flush - flush the transmit and receive FIFOs
 109  *
 110  * Wait for the SSP to idle, and ensure that the receive FIFO
 111  * is empty.
 112  *
 113  * The caller is expected to perform the necessary locking.
 114  *
 115  * Returns:
 116  *   %-ETIMEDOUT        timeout occurred
 117  *   0                  success
 118  */
 119 int ssp_flush(void)
 120 {
 121         int timeout = TIMEOUT * 2;
 122
 123         do {
 124                 while (Ser4SSSR & SSSR_RNE) {
 125                         if (!--timeout)
 126                                 return -ETIMEDOUT;
 127                         (void) Ser4SSDR;
 128                 }
 129                 if (!--timeout)
 130                         return -ETIMEDOUT;
 131         } while (Ser4SSSR & SSSR_BSY);
 132
 133         return 0;
 134 }
 135
 136 /**
 137  * ssp_enable - enable the SSP port
 138  *
 139  * Turn on the SSP port.
 140  */
 141 void ssp_enable(void)
 142 {
 143         Ser4SSCR0 |= SSCR0_SSE;
 144 }
 145
 146 /**
 147  * ssp_disable - shut down the SSP port
 148  *
 149  * Turn off the SSP port, optionally powering it down.
 150  */
 151 void ssp_disable(void)
 152 {
 153         Ser4SSCR0 &= ~SSCR0_SSE;
 154 }
 155
 156 /**
 157  * ssp_save_state - save the SSP configuration
 158  * @ssp: pointer to structure to save SSP configuration
 159  *
 160  * Save the configured SSP state for suspend.
 161  */
 162 void ssp_save_state(struct ssp_state *ssp)
 163 {
 164         ssp->cr0 = Ser4SSCR0;
 165         ssp->cr1 = Ser4SSCR1;
 166
 167         Ser4SSCR0 &= ~SSCR0_SSE;
 168 }
 169
 170 /**
 171  * ssp_restore_state - restore a previously saved SSP configuration
 172  * @ssp: pointer to configuration saved by ssp_save_state
 173  *
 174  * Restore the SSP configuration saved previously by ssp_save_state.
 175  */
 176 void ssp_restore_state(struct ssp_state *ssp)
 177 {
 178         Ser4SSSR = SSSR_ROR;
 179
 180         Ser4SSCR0 = ssp->cr0 & ~SSCR0_SSE;
 181         Ser4SSCR1 = ssp->cr1;
 182         Ser4SSCR0 = ssp->cr0;
 183 }
 184
 185 /**
 186  * ssp_init - setup the SSP port
 187  *
 188  * initialise and claim resources for the SSP port.
 189  *
 190  * Returns:
 191  *   %-ENODEV   if the SSP port is unavailable
 192  *   %-EBUSY    if the resources are already in use
 193  *   %0         on success
 194  */
 195 int ssp_init(void)
 196 {
 197         int ret;
 198
 199         if (!(PPAR & PPAR_SPR) && (Ser4MCCR0 & MCCR0_MCE))
 200                 return -ENODEV;
 201
 202         if (!request_mem_region(__PREG(Ser4SSCR0), 0x18, "SSP")) {
 203                 return -EBUSY;
 204         }
 205
 206         Ser4SSSR = SSSR_ROR;
 207
 208         ret = request_irq(IRQ_Ser4SSP, ssp_interrupt, 0, "SSP", NULL);
 209         if (ret)
 210                 goto out_region;
 211
 212         return 0;
 213
 214  out_region:
 215         release_mem_region(__PREG(Ser4SSCR0), 0x18);
 216         return ret;
 217 }
 218
 219 /**
 220  * ssp_exit - undo the effects of ssp_init
 221  *
 222  * release and free resources for the SSP port.
 223  */
 224 void ssp_exit(void)
 225 {
 226         Ser4SSCR0 &= ~SSCR0_SSE;
 227
 228         free_irq(IRQ_Ser4SSP, NULL);
 229         release_mem_region(__PREG(Ser4SSCR0), 0x18);
 230 }
 231
 232 MODULE_AUTHOR("Russell King");
 233 MODULE_DESCRIPTION("SA11x0 SSP PIO driver");
 234 MODULE_LICENSE("GPL");
 235
 236 EXPORT_SYMBOL(ssp_write_word);
 237 EXPORT_SYMBOL(ssp_read_word);
 238 EXPORT_SYMBOL(ssp_flush);
 239 EXPORT_SYMBOL(ssp_enable);
 240 EXPORT_SYMBOL(ssp_disable);
 241 EXPORT_SYMBOL(ssp_save_state);
 242 EXPORT_SYMBOL(ssp_restore_state);
 243 EXPORT_SYMBOL(ssp_init);
 244 EXPORT_SYMBOL(ssp_exit);