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