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, struct pt_regs *regs) 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); 245