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