Eric Lee / linux-smarc-t335x-v3.2

Download as
Browse Code ยป

Commit ff632054ced5e1a8a28e7196c013e5af37895f7b

Authored by Thomas Gleixner
Committed by Russell King
1 parent e6e3c3be8a
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

[ARM] 3695/1: ARM drivers/pcmcia: Fixup includes 

Patch from Thomas Gleixner

From: Thomas Gleixner <tglx@linutronix.de>

Include the generic header file instead of the ARM specific one.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>

Showing 1 changed file with 1 additions and 1 deletions Inline Diff

drivers/pcmcia/soc_common.c
Diff comments   View file @ ff63205
1 /*====================================================================== 1 /*======================================================================
2 2
3 Common support code for the PCMCIA control functionality of 3 Common support code for the PCMCIA control functionality of
4 integrated SOCs like the SA-11x0 and PXA2xx microprocessors. 4 integrated SOCs like the SA-11x0 and PXA2xx microprocessors.
5 5
6 The contents of this file are subject to the Mozilla Public 6 The contents of this file are subject to the Mozilla Public
7 License Version 1.1 (the "License"); you may not use this file 7 License Version 1.1 (the "License"); you may not use this file
8 except in compliance with the License. You may obtain a copy of 8 except in compliance with the License. You may obtain a copy of
9 the License at http://www.mozilla.org/MPL/ 9 the License at http://www.mozilla.org/MPL/
10 10
11 Software distributed under the License is distributed on an "AS 11 Software distributed under the License is distributed on an "AS
12 IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or 12 IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
13 implied. See the License for the specific language governing 13 implied. See the License for the specific language governing
14 rights and limitations under the License. 14 rights and limitations under the License.
15 15
16 The initial developer of the original code is John G. Dorsey 16 The initial developer of the original code is John G. Dorsey
17 <john+@cs.cmu.edu>. Portions created by John G. Dorsey are 17 <john+@cs.cmu.edu>. Portions created by John G. Dorsey are
18 Copyright (C) 1999 John G. Dorsey. All Rights Reserved. 18 Copyright (C) 1999 John G. Dorsey. All Rights Reserved.
19 19
20 Alternatively, the contents of this file may be used under the 20 Alternatively, the contents of this file may be used under the
21 terms of the GNU Public License version 2 (the "GPL"), in which 21 terms of the GNU Public License version 2 (the "GPL"), in which
22 case the provisions of the GPL are applicable instead of the 22 case the provisions of the GPL are applicable instead of the
23 above. If you wish to allow the use of your version of this file 23 above. If you wish to allow the use of your version of this file
24 only under the terms of the GPL and not to allow others to use 24 only under the terms of the GPL and not to allow others to use
25 your version of this file under the MPL, indicate your decision 25 your version of this file under the MPL, indicate your decision
26 by deleting the provisions above and replace them with the notice 26 by deleting the provisions above and replace them with the notice
27 and other provisions required by the GPL. If you do not delete 27 and other provisions required by the GPL. If you do not delete
28 the provisions above, a recipient may use your version of this 28 the provisions above, a recipient may use your version of this
29 file under either the MPL or the GPL. 29 file under either the MPL or the GPL.
30 30
31 ======================================================================*/ 31 ======================================================================*/
32 32
33 33
34 #include <linux/module.h> 34 #include <linux/module.h>
35 #include <linux/moduleparam.h> 35 #include <linux/moduleparam.h>
36 #include <linux/init.h> 36 #include <linux/init.h>
37 #include <linux/kernel.h> 37 #include <linux/kernel.h>
38 #include <linux/timer.h> 38 #include <linux/timer.h>
39 #include <linux/mm.h> 39 #include <linux/mm.h>
40 #include <linux/interrupt.h> 40 #include <linux/interrupt.h>
41 #include <linux/irq.h>
41 #include <linux/spinlock.h> 42 #include <linux/spinlock.h>
42 #include <linux/cpufreq.h> 43 #include <linux/cpufreq.h>
43 44
44 #include <asm/hardware.h> 45 #include <asm/hardware.h>
45 #include <asm/io.h> 46 #include <asm/io.h>
46 #include <asm/irq.h>
47 #include <asm/system.h> 47 #include <asm/system.h>
48 48
49 #include "soc_common.h" 49 #include "soc_common.h"
50 50
51 /* FIXME: platform dependent resource declaration has to move out of this file */ 51 /* FIXME: platform dependent resource declaration has to move out of this file */
52 #ifdef CONFIG_ARCH_PXA 52 #ifdef CONFIG_ARCH_PXA
53 #include <asm/arch/pxa-regs.h> 53 #include <asm/arch/pxa-regs.h>
54 #endif 54 #endif
55 55
56 #ifdef DEBUG 56 #ifdef DEBUG
57 57
58 static int pc_debug; 58 static int pc_debug;
59 module_param(pc_debug, int, 0644); 59 module_param(pc_debug, int, 0644);
60 60
61 void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func, 61 void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func,
62 int lvl, const char *fmt, ...) 62 int lvl, const char *fmt, ...)
63 { 63 {
64 va_list args; 64 va_list args;
65 if (pc_debug > lvl) { 65 if (pc_debug > lvl) {
66 printk(KERN_DEBUG "skt%u: %s: ", skt->nr, func); 66 printk(KERN_DEBUG "skt%u: %s: ", skt->nr, func);
67 va_start(args, fmt); 67 va_start(args, fmt);
68 vprintk(fmt, args); 68 vprintk(fmt, args);
69 va_end(args); 69 va_end(args);
70 } 70 }
71 } 71 }
72 72
73 #endif 73 #endif
74 74
75 #define to_soc_pcmcia_socket(x) container_of(x, struct soc_pcmcia_socket, socket) 75 #define to_soc_pcmcia_socket(x) container_of(x, struct soc_pcmcia_socket, socket)
76 76
77 static unsigned short 77 static unsigned short
78 calc_speed(unsigned short *spds, int num, unsigned short dflt) 78 calc_speed(unsigned short *spds, int num, unsigned short dflt)
79 { 79 {
80 unsigned short speed = 0; 80 unsigned short speed = 0;
81 int i; 81 int i;
82 82
83 for (i = 0; i < num; i++) 83 for (i = 0; i < num; i++)
84 if (speed < spds[i]) 84 if (speed < spds[i])
85 speed = spds[i]; 85 speed = spds[i];
86 if (speed == 0) 86 if (speed == 0)
87 speed = dflt; 87 speed = dflt;
88 88
89 return speed; 89 return speed;
90 } 90 }
91 91
92 void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt, struct soc_pcmcia_timing *timing) 92 void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt, struct soc_pcmcia_timing *timing)
93 { 93 {
94 timing->io = calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS); 94 timing->io = calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
95 timing->mem = calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS); 95 timing->mem = calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
96 timing->attr = calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS); 96 timing->attr = calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
97 } 97 }
98 EXPORT_SYMBOL(soc_common_pcmcia_get_timing); 98 EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
99 99
100 static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt) 100 static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
101 { 101 {
102 struct pcmcia_state state; 102 struct pcmcia_state state;
103 unsigned int stat; 103 unsigned int stat;
104 104
105 memset(&state, 0, sizeof(struct pcmcia_state)); 105 memset(&state, 0, sizeof(struct pcmcia_state));
106 106
107 skt->ops->socket_state(skt, &state); 107 skt->ops->socket_state(skt, &state);
108 108
109 stat = state.detect ? SS_DETECT : 0; 109 stat = state.detect ? SS_DETECT : 0;
110 stat |= state.ready ? SS_READY : 0; 110 stat |= state.ready ? SS_READY : 0;
111 stat |= state.wrprot ? SS_WRPROT : 0; 111 stat |= state.wrprot ? SS_WRPROT : 0;
112 stat |= state.vs_3v ? SS_3VCARD : 0; 112 stat |= state.vs_3v ? SS_3VCARD : 0;
113 stat |= state.vs_Xv ? SS_XVCARD : 0; 113 stat |= state.vs_Xv ? SS_XVCARD : 0;
114 114
115 /* The power status of individual sockets is not available 115 /* The power status of individual sockets is not available
116 * explicitly from the hardware, so we just remember the state 116 * explicitly from the hardware, so we just remember the state
117 * and regurgitate it upon request: 117 * and regurgitate it upon request:
118 */ 118 */
119 stat |= skt->cs_state.Vcc ? SS_POWERON : 0; 119 stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
120 120
121 if (skt->cs_state.flags & SS_IOCARD) 121 if (skt->cs_state.flags & SS_IOCARD)
122 stat |= state.bvd1 ? SS_STSCHG : 0; 122 stat |= state.bvd1 ? SS_STSCHG : 0;
123 else { 123 else {
124 if (state.bvd1 == 0) 124 if (state.bvd1 == 0)
125 stat |= SS_BATDEAD; 125 stat |= SS_BATDEAD;
126 else if (state.bvd2 == 0) 126 else if (state.bvd2 == 0)
127 stat |= SS_BATWARN; 127 stat |= SS_BATWARN;
128 } 128 }
129 return stat; 129 return stat;
130 } 130 }
131 131
132 /* 132 /*
133 * soc_common_pcmcia_config_skt 133 * soc_common_pcmcia_config_skt
134 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 134 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
135 * 135 *
136 * Convert PCMCIA socket state to our socket configure structure. 136 * Convert PCMCIA socket state to our socket configure structure.
137 */ 137 */
138 static int 138 static int
139 soc_common_pcmcia_config_skt(struct soc_pcmcia_socket *skt, socket_state_t *state) 139 soc_common_pcmcia_config_skt(struct soc_pcmcia_socket *skt, socket_state_t *state)
140 { 140 {
141 int ret; 141 int ret;
142 142
143 ret = skt->ops->configure_socket(skt, state); 143 ret = skt->ops->configure_socket(skt, state);
144 if (ret == 0) { 144 if (ret == 0) {
145 /* 145 /*
146 * This really needs a better solution. The IRQ 146 * This really needs a better solution. The IRQ
147 * may or may not be claimed by the driver. 147 * may or may not be claimed by the driver.
148 */ 148 */
149 if (skt->irq_state != 1 && state->io_irq) { 149 if (skt->irq_state != 1 && state->io_irq) {
150 skt->irq_state = 1; 150 skt->irq_state = 1;
151 set_irq_type(skt->irq, IRQT_FALLING); 151 set_irq_type(skt->irq, IRQT_FALLING);
152 } else if (skt->irq_state == 1 && state->io_irq == 0) { 152 } else if (skt->irq_state == 1 && state->io_irq == 0) {
153 skt->irq_state = 0; 153 skt->irq_state = 0;
154 set_irq_type(skt->irq, IRQT_NOEDGE); 154 set_irq_type(skt->irq, IRQT_NOEDGE);
155 } 155 }
156 156
157 skt->cs_state = *state; 157 skt->cs_state = *state;
158 } 158 }
159 159
160 if (ret < 0) 160 if (ret < 0)
161 printk(KERN_ERR "soc_common_pcmcia: unable to configure " 161 printk(KERN_ERR "soc_common_pcmcia: unable to configure "
162 "socket %d\n", skt->nr); 162 "socket %d\n", skt->nr);
163 163
164 return ret; 164 return ret;
165 } 165 }
166 166
167 /* soc_common_pcmcia_sock_init() 167 /* soc_common_pcmcia_sock_init()
168 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 168 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
169 * 169 *
170 * (Re-)Initialise the socket, turning on status interrupts 170 * (Re-)Initialise the socket, turning on status interrupts
171 * and PCMCIA bus. This must wait for power to stabilise 171 * and PCMCIA bus. This must wait for power to stabilise
172 * so that the card status signals report correctly. 172 * so that the card status signals report correctly.
173 * 173 *
174 * Returns: 0 174 * Returns: 0
175 */ 175 */
176 static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock) 176 static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
177 { 177 {
178 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 178 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
179 179
180 debug(skt, 2, "initializing socket\n"); 180 debug(skt, 2, "initializing socket\n");
181 181
182 skt->ops->socket_init(skt); 182 skt->ops->socket_init(skt);
183 return 0; 183 return 0;
184 } 184 }
185 185
186 186
187 /* 187 /*
188 * soc_common_pcmcia_suspend() 188 * soc_common_pcmcia_suspend()
189 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 189 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
190 * 190 *
191 * Remove power on the socket, disable IRQs from the card. 191 * Remove power on the socket, disable IRQs from the card.
192 * Turn off status interrupts, and disable the PCMCIA bus. 192 * Turn off status interrupts, and disable the PCMCIA bus.
193 * 193 *
194 * Returns: 0 194 * Returns: 0
195 */ 195 */
196 static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock) 196 static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
197 { 197 {
198 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 198 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
199 199
200 debug(skt, 2, "suspending socket\n"); 200 debug(skt, 2, "suspending socket\n");
201 201
202 skt->ops->socket_suspend(skt); 202 skt->ops->socket_suspend(skt);
203 203
204 return 0; 204 return 0;
205 } 205 }
206 206
207 static DEFINE_SPINLOCK(status_lock); 207 static DEFINE_SPINLOCK(status_lock);
208 208
209 static void soc_common_check_status(struct soc_pcmcia_socket *skt) 209 static void soc_common_check_status(struct soc_pcmcia_socket *skt)
210 { 210 {
211 unsigned int events; 211 unsigned int events;
212 212
213 debug(skt, 4, "entering PCMCIA monitoring thread\n"); 213 debug(skt, 4, "entering PCMCIA monitoring thread\n");
214 214
215 do { 215 do {
216 unsigned int status; 216 unsigned int status;
217 unsigned long flags; 217 unsigned long flags;
218 218
219 status = soc_common_pcmcia_skt_state(skt); 219 status = soc_common_pcmcia_skt_state(skt);
220 220
221 spin_lock_irqsave(&status_lock, flags); 221 spin_lock_irqsave(&status_lock, flags);
222 events = (status ^ skt->status) & skt->cs_state.csc_mask; 222 events = (status ^ skt->status) & skt->cs_state.csc_mask;
223 skt->status = status; 223 skt->status = status;
224 spin_unlock_irqrestore(&status_lock, flags); 224 spin_unlock_irqrestore(&status_lock, flags);
225 225
226 debug(skt, 4, "events: %s%s%s%s%s%s\n", 226 debug(skt, 4, "events: %s%s%s%s%s%s\n",
227 events == 0 ? "<NONE>" : "", 227 events == 0 ? "<NONE>" : "",
228 events & SS_DETECT ? "DETECT " : "", 228 events & SS_DETECT ? "DETECT " : "",
229 events & SS_READY ? "READY " : "", 229 events & SS_READY ? "READY " : "",
230 events & SS_BATDEAD ? "BATDEAD " : "", 230 events & SS_BATDEAD ? "BATDEAD " : "",
231 events & SS_BATWARN ? "BATWARN " : "", 231 events & SS_BATWARN ? "BATWARN " : "",
232 events & SS_STSCHG ? "STSCHG " : ""); 232 events & SS_STSCHG ? "STSCHG " : "");
233 233
234 if (events) 234 if (events)
235 pcmcia_parse_events(&skt->socket, events); 235 pcmcia_parse_events(&skt->socket, events);
236 } while (events); 236 } while (events);
237 } 237 }
238 238
239 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */ 239 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
240 static void soc_common_pcmcia_poll_event(unsigned long dummy) 240 static void soc_common_pcmcia_poll_event(unsigned long dummy)
241 { 241 {
242 struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy; 242 struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
243 debug(skt, 4, "polling for events\n"); 243 debug(skt, 4, "polling for events\n");
244 244
245 mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD); 245 mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
246 246
247 soc_common_check_status(skt); 247 soc_common_check_status(skt);
248 } 248 }
249 249
250 250
251 /* 251 /*
252 * Service routine for socket driver interrupts (requested by the 252 * Service routine for socket driver interrupts (requested by the
253 * low-level PCMCIA init() operation via soc_common_pcmcia_thread()). 253 * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
254 * The actual interrupt-servicing work is performed by 254 * The actual interrupt-servicing work is performed by
255 * soc_common_pcmcia_thread(), largely because the Card Services event- 255 * soc_common_pcmcia_thread(), largely because the Card Services event-
256 * handling code performs scheduling operations which cannot be 256 * handling code performs scheduling operations which cannot be
257 * executed from within an interrupt context. 257 * executed from within an interrupt context.
258 */ 258 */
259 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs) 259 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs)
260 { 260 {
261 struct soc_pcmcia_socket *skt = dev; 261 struct soc_pcmcia_socket *skt = dev;
262 262
263 debug(skt, 3, "servicing IRQ %d\n", irq); 263 debug(skt, 3, "servicing IRQ %d\n", irq);
264 264
265 soc_common_check_status(skt); 265 soc_common_check_status(skt);
266 266
267 return IRQ_HANDLED; 267 return IRQ_HANDLED;
268 } 268 }
269 269
270 270
271 /* 271 /*
272 * Implements the get_status() operation for the in-kernel PCMCIA 272 * Implements the get_status() operation for the in-kernel PCMCIA
273 * service (formerly SS_GetStatus in Card Services). Essentially just 273 * service (formerly SS_GetStatus in Card Services). Essentially just
274 * fills in bits in `status' according to internal driver state or 274 * fills in bits in `status' according to internal driver state or
275 * the value of the voltage detect chipselect register. 275 * the value of the voltage detect chipselect register.
276 * 276 *
277 * As a debugging note, during card startup, the PCMCIA core issues 277 * As a debugging note, during card startup, the PCMCIA core issues
278 * three set_socket() commands in a row the first with RESET deasserted, 278 * three set_socket() commands in a row the first with RESET deasserted,
279 * the second with RESET asserted, and the last with RESET deasserted 279 * the second with RESET asserted, and the last with RESET deasserted
280 * again. Following the third set_socket(), a get_status() command will 280 * again. Following the third set_socket(), a get_status() command will
281 * be issued. The kernel is looking for the SS_READY flag (see 281 * be issued. The kernel is looking for the SS_READY flag (see
282 * setup_socket(), reset_socket(), and unreset_socket() in cs.c). 282 * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
283 * 283 *
284 * Returns: 0 284 * Returns: 0
285 */ 285 */
286 static int 286 static int
287 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status) 287 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
288 { 288 {
289 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 289 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
290 290
291 skt->status = soc_common_pcmcia_skt_state(skt); 291 skt->status = soc_common_pcmcia_skt_state(skt);
292 *status = skt->status; 292 *status = skt->status;
293 293
294 return 0; 294 return 0;
295 } 295 }
296 296
297 297
298 /* 298 /*
299 * Implements the set_socket() operation for the in-kernel PCMCIA 299 * Implements the set_socket() operation for the in-kernel PCMCIA
300 * service (formerly SS_SetSocket in Card Services). We more or 300 * service (formerly SS_SetSocket in Card Services). We more or
301 * less punt all of this work and let the kernel handle the details 301 * less punt all of this work and let the kernel handle the details
302 * of power configuration, reset, &c. We also record the value of 302 * of power configuration, reset, &c. We also record the value of
303 * `state' in order to regurgitate it to the PCMCIA core later. 303 * `state' in order to regurgitate it to the PCMCIA core later.
304 */ 304 */
305 static int 305 static int
306 soc_common_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state) 306 soc_common_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
307 { 307 {
308 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 308 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
309 309
310 debug(skt, 2, "mask: %s%s%s%s%s%sflags: %s%s%s%s%s%sVcc %d Vpp %d irq %d\n", 310 debug(skt, 2, "mask: %s%s%s%s%s%sflags: %s%s%s%s%s%sVcc %d Vpp %d irq %d\n",
311 (state->csc_mask==0)?"<NONE> ":"", 311 (state->csc_mask==0)?"<NONE> ":"",
312 (state->csc_mask&SS_DETECT)?"DETECT ":"", 312 (state->csc_mask&SS_DETECT)?"DETECT ":"",
313 (state->csc_mask&SS_READY)?"READY ":"", 313 (state->csc_mask&SS_READY)?"READY ":"",
314 (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"", 314 (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
315 (state->csc_mask&SS_BATWARN)?"BATWARN ":"", 315 (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
316 (state->csc_mask&SS_STSCHG)?"STSCHG ":"", 316 (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
317 (state->flags==0)?"<NONE> ":"", 317 (state->flags==0)?"<NONE> ":"",
318 (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"", 318 (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
319 (state->flags&SS_IOCARD)?"IOCARD ":"", 319 (state->flags&SS_IOCARD)?"IOCARD ":"",
320 (state->flags&SS_RESET)?"RESET ":"", 320 (state->flags&SS_RESET)?"RESET ":"",
321 (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"", 321 (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
322 (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"", 322 (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"",
323 state->Vcc, state->Vpp, state->io_irq); 323 state->Vcc, state->Vpp, state->io_irq);
324 324
325 return soc_common_pcmcia_config_skt(skt, state); 325 return soc_common_pcmcia_config_skt(skt, state);
326 } 326 }
327 327
328 328
329 /* 329 /*
330 * Implements the set_io_map() operation for the in-kernel PCMCIA 330 * Implements the set_io_map() operation for the in-kernel PCMCIA
331 * service (formerly SS_SetIOMap in Card Services). We configure 331 * service (formerly SS_SetIOMap in Card Services). We configure
332 * the map speed as requested, but override the address ranges 332 * the map speed as requested, but override the address ranges
333 * supplied by Card Services. 333 * supplied by Card Services.
334 * 334 *
335 * Returns: 0 on success, -1 on error 335 * Returns: 0 on success, -1 on error
336 */ 336 */
337 static int 337 static int
338 soc_common_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map) 338 soc_common_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
339 { 339 {
340 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 340 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
341 unsigned short speed = map->speed; 341 unsigned short speed = map->speed;
342 342
343 debug(skt, 2, "map %u speed %u start 0x%08x stop 0x%08x\n", 343 debug(skt, 2, "map %u speed %u start 0x%08x stop 0x%08x\n",
344 map->map, map->speed, map->start, map->stop); 344 map->map, map->speed, map->start, map->stop);
345 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n", 345 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
346 (map->flags==0)?"<NONE>":"", 346 (map->flags==0)?"<NONE>":"",
347 (map->flags&MAP_ACTIVE)?"ACTIVE ":"", 347 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
348 (map->flags&MAP_16BIT)?"16BIT ":"", 348 (map->flags&MAP_16BIT)?"16BIT ":"",
349 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"", 349 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
350 (map->flags&MAP_0WS)?"0WS ":"", 350 (map->flags&MAP_0WS)?"0WS ":"",
351 (map->flags&MAP_WRPROT)?"WRPROT ":"", 351 (map->flags&MAP_WRPROT)?"WRPROT ":"",
352 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"", 352 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"",
353 (map->flags&MAP_PREFETCH)?"PREFETCH ":""); 353 (map->flags&MAP_PREFETCH)?"PREFETCH ":"");
354 354
355 if (map->map >= MAX_IO_WIN) { 355 if (map->map >= MAX_IO_WIN) {
356 printk(KERN_ERR "%s(): map (%d) out of range\n", __FUNCTION__, 356 printk(KERN_ERR "%s(): map (%d) out of range\n", __FUNCTION__,
357 map->map); 357 map->map);
358 return -1; 358 return -1;
359 } 359 }
360 360
361 if (map->flags & MAP_ACTIVE) { 361 if (map->flags & MAP_ACTIVE) {
362 if (speed == 0) 362 if (speed == 0)
363 speed = SOC_PCMCIA_IO_ACCESS; 363 speed = SOC_PCMCIA_IO_ACCESS;
364 } else { 364 } else {
365 speed = 0; 365 speed = 0;
366 } 366 }
367 367
368 skt->spd_io[map->map] = speed; 368 skt->spd_io[map->map] = speed;
369 skt->ops->set_timing(skt); 369 skt->ops->set_timing(skt);
370 370
371 if (map->stop == 1) 371 if (map->stop == 1)
372 map->stop = PAGE_SIZE-1; 372 map->stop = PAGE_SIZE-1;
373 373
374 map->stop -= map->start; 374 map->stop -= map->start;
375 map->stop += skt->socket.io_offset; 375 map->stop += skt->socket.io_offset;
376 map->start = skt->socket.io_offset; 376 map->start = skt->socket.io_offset;
377 377
378 return 0; 378 return 0;
379 } 379 }
380 380
381 381
382 /* 382 /*
383 * Implements the set_mem_map() operation for the in-kernel PCMCIA 383 * Implements the set_mem_map() operation for the in-kernel PCMCIA
384 * service (formerly SS_SetMemMap in Card Services). We configure 384 * service (formerly SS_SetMemMap in Card Services). We configure
385 * the map speed as requested, but override the address ranges 385 * the map speed as requested, but override the address ranges
386 * supplied by Card Services. 386 * supplied by Card Services.
387 * 387 *
388 * Returns: 0 on success, -ERRNO on error 388 * Returns: 0 on success, -ERRNO on error
389 */ 389 */
390 static int 390 static int
391 soc_common_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map) 391 soc_common_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
392 { 392 {
393 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); 393 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
394 struct resource *res; 394 struct resource *res;
395 unsigned short speed = map->speed; 395 unsigned short speed = map->speed;
396 396
397 debug(skt, 2, "map %u speed %u card_start %08x\n", 397 debug(skt, 2, "map %u speed %u card_start %08x\n",
398 map->map, map->speed, map->card_start); 398 map->map, map->speed, map->card_start);
399 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n", 399 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
400 (map->flags==0)?"<NONE>":"", 400 (map->flags==0)?"<NONE>":"",
401 (map->flags&MAP_ACTIVE)?"ACTIVE ":"", 401 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
402 (map->flags&MAP_16BIT)?"16BIT ":"", 402 (map->flags&MAP_16BIT)?"16BIT ":"",
403 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"", 403 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
404 (map->flags&MAP_0WS)?"0WS ":"", 404 (map->flags&MAP_0WS)?"0WS ":"",
405 (map->flags&MAP_WRPROT)?"WRPROT ":"", 405 (map->flags&MAP_WRPROT)?"WRPROT ":"",
406 (map->flags&MAP_ATTRIB)?"ATTRIB ":"", 406 (map->flags&MAP_ATTRIB)?"ATTRIB ":"",
407 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":""); 407 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"");
408 408
409 if (map->map >= MAX_WIN) 409 if (map->map >= MAX_WIN)
410 return -EINVAL; 410 return -EINVAL;
411 411
412 if (map->flags & MAP_ACTIVE) { 412 if (map->flags & MAP_ACTIVE) {
413 if (speed == 0) 413 if (speed == 0)
414 speed = 300; 414 speed = 300;
415 } else { 415 } else {
416 speed = 0; 416 speed = 0;
417 } 417 }
418 418
419 if (map->flags & MAP_ATTRIB) { 419 if (map->flags & MAP_ATTRIB) {
420 res = &skt->res_attr; 420 res = &skt->res_attr;
421 skt->spd_attr[map->map] = speed; 421 skt->spd_attr[map->map] = speed;
422 skt->spd_mem[map->map] = 0; 422 skt->spd_mem[map->map] = 0;
423 } else { 423 } else {
424 res = &skt->res_mem; 424 res = &skt->res_mem;
425 skt->spd_attr[map->map] = 0; 425 skt->spd_attr[map->map] = 0;
426 skt->spd_mem[map->map] = speed; 426 skt->spd_mem[map->map] = speed;
427 } 427 }
428 428
429 skt->ops->set_timing(skt); 429 skt->ops->set_timing(skt);
430 430
431 map->static_start = res->start + map->card_start; 431 map->static_start = res->start + map->card_start;
432 432
433 return 0; 433 return 0;
434 } 434 }
435 435
436 struct bittbl { 436 struct bittbl {
437 unsigned int mask; 437 unsigned int mask;
438 const char *name; 438 const char *name;
439 }; 439 };
440 440
441 static struct bittbl status_bits[] = { 441 static struct bittbl status_bits[] = {
442 { SS_WRPROT, "SS_WRPROT" }, 442 { SS_WRPROT, "SS_WRPROT" },
443 { SS_BATDEAD, "SS_BATDEAD" }, 443 { SS_BATDEAD, "SS_BATDEAD" },
444 { SS_BATWARN, "SS_BATWARN" }, 444 { SS_BATWARN, "SS_BATWARN" },
445 { SS_READY, "SS_READY" }, 445 { SS_READY, "SS_READY" },
446 { SS_DETECT, "SS_DETECT" }, 446 { SS_DETECT, "SS_DETECT" },
447 { SS_POWERON, "SS_POWERON" }, 447 { SS_POWERON, "SS_POWERON" },
448 { SS_STSCHG, "SS_STSCHG" }, 448 { SS_STSCHG, "SS_STSCHG" },
449 { SS_3VCARD, "SS_3VCARD" }, 449 { SS_3VCARD, "SS_3VCARD" },
450 { SS_XVCARD, "SS_XVCARD" }, 450 { SS_XVCARD, "SS_XVCARD" },
451 }; 451 };
452 452
453 static struct bittbl conf_bits[] = { 453 static struct bittbl conf_bits[] = {
454 { SS_PWR_AUTO, "SS_PWR_AUTO" }, 454 { SS_PWR_AUTO, "SS_PWR_AUTO" },
455 { SS_IOCARD, "SS_IOCARD" }, 455 { SS_IOCARD, "SS_IOCARD" },
456 { SS_RESET, "SS_RESET" }, 456 { SS_RESET, "SS_RESET" },
457 { SS_DMA_MODE, "SS_DMA_MODE" }, 457 { SS_DMA_MODE, "SS_DMA_MODE" },
458 { SS_SPKR_ENA, "SS_SPKR_ENA" }, 458 { SS_SPKR_ENA, "SS_SPKR_ENA" },
459 { SS_OUTPUT_ENA, "SS_OUTPUT_ENA" }, 459 { SS_OUTPUT_ENA, "SS_OUTPUT_ENA" },
460 }; 460 };
461 461
462 static void 462 static void
463 dump_bits(char **p, const char *prefix, unsigned int val, struct bittbl *bits, int sz) 463 dump_bits(char **p, const char *prefix, unsigned int val, struct bittbl *bits, int sz)
464 { 464 {
465 char *b = *p; 465 char *b = *p;
466 int i; 466 int i;
467 467
468 b += sprintf(b, "%-9s:", prefix); 468 b += sprintf(b, "%-9s:", prefix);
469 for (i = 0; i < sz; i++) 469 for (i = 0; i < sz; i++)
470 if (val & bits[i].mask) 470 if (val & bits[i].mask)
471 b += sprintf(b, " %s", bits[i].name); 471 b += sprintf(b, " %s", bits[i].name);
472 *b++ = '\n'; 472 *b++ = '\n';
473 *p = b; 473 *p = b;
474 } 474 }
475 475
476 /* 476 /*
477 * Implements the /sys/class/pcmcia_socket/??/status file. 477 * Implements the /sys/class/pcmcia_socket/??/status file.
478 * 478 *
479 * Returns: the number of characters added to the buffer 479 * Returns: the number of characters added to the buffer
480 */ 480 */
481 static ssize_t show_status(struct class_device *class_dev, char *buf) 481 static ssize_t show_status(struct class_device *class_dev, char *buf)
482 { 482 {
483 struct soc_pcmcia_socket *skt = 483 struct soc_pcmcia_socket *skt =
484 container_of(class_dev, struct soc_pcmcia_socket, socket.dev); 484 container_of(class_dev, struct soc_pcmcia_socket, socket.dev);
485 char *p = buf; 485 char *p = buf;
486 486
487 p+=sprintf(p, "slot : %d\n", skt->nr); 487 p+=sprintf(p, "slot : %d\n", skt->nr);
488 488
489 dump_bits(&p, "status", skt->status, 489 dump_bits(&p, "status", skt->status,
490 status_bits, ARRAY_SIZE(status_bits)); 490 status_bits, ARRAY_SIZE(status_bits));
491 dump_bits(&p, "csc_mask", skt->cs_state.csc_mask, 491 dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
492 status_bits, ARRAY_SIZE(status_bits)); 492 status_bits, ARRAY_SIZE(status_bits));
493 dump_bits(&p, "cs_flags", skt->cs_state.flags, 493 dump_bits(&p, "cs_flags", skt->cs_state.flags,
494 conf_bits, ARRAY_SIZE(conf_bits)); 494 conf_bits, ARRAY_SIZE(conf_bits));
495 495
496 p+=sprintf(p, "Vcc : %d\n", skt->cs_state.Vcc); 496 p+=sprintf(p, "Vcc : %d\n", skt->cs_state.Vcc);
497 p+=sprintf(p, "Vpp : %d\n", skt->cs_state.Vpp); 497 p+=sprintf(p, "Vpp : %d\n", skt->cs_state.Vpp);
498 p+=sprintf(p, "IRQ : %d (%d)\n", skt->cs_state.io_irq, skt->irq); 498 p+=sprintf(p, "IRQ : %d (%d)\n", skt->cs_state.io_irq, skt->irq);
499 if (skt->ops->show_timing) 499 if (skt->ops->show_timing)
500 p+=skt->ops->show_timing(skt, p); 500 p+=skt->ops->show_timing(skt, p);
501 501
502 return p-buf; 502 return p-buf;
503 } 503 }
504 static CLASS_DEVICE_ATTR(status, S_IRUGO, show_status, NULL); 504 static CLASS_DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
505 505
506 506
507 static struct pccard_operations soc_common_pcmcia_operations = { 507 static struct pccard_operations soc_common_pcmcia_operations = {
508 .init = soc_common_pcmcia_sock_init, 508 .init = soc_common_pcmcia_sock_init,
509 .suspend = soc_common_pcmcia_suspend, 509 .suspend = soc_common_pcmcia_suspend,
510 .get_status = soc_common_pcmcia_get_status, 510 .get_status = soc_common_pcmcia_get_status,
511 .set_socket = soc_common_pcmcia_set_socket, 511 .set_socket = soc_common_pcmcia_set_socket,
512 .set_io_map = soc_common_pcmcia_set_io_map, 512 .set_io_map = soc_common_pcmcia_set_io_map,
513 .set_mem_map = soc_common_pcmcia_set_mem_map, 513 .set_mem_map = soc_common_pcmcia_set_mem_map,
514 }; 514 };
515 515
516 516
517 int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt, 517 int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt,
518 struct pcmcia_irqs *irqs, int nr) 518 struct pcmcia_irqs *irqs, int nr)
519 { 519 {
520 int i, res = 0; 520 int i, res = 0;
521 521
522 for (i = 0; i < nr; i++) { 522 for (i = 0; i < nr; i++) {
523 if (irqs[i].sock != skt->nr) 523 if (irqs[i].sock != skt->nr)
524 continue; 524 continue;
525 res = request_irq(irqs[i].irq, soc_common_pcmcia_interrupt, 525 res = request_irq(irqs[i].irq, soc_common_pcmcia_interrupt,
526 SA_INTERRUPT, irqs[i].str, skt); 526 SA_INTERRUPT, irqs[i].str, skt);
527 if (res) 527 if (res)
528 break; 528 break;
529 set_irq_type(irqs[i].irq, IRQT_NOEDGE); 529 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
530 } 530 }
531 531
532 if (res) { 532 if (res) {
533 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n", 533 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
534 irqs[i].irq, res); 534 irqs[i].irq, res);
535 535
536 while (i--) 536 while (i--)
537 if (irqs[i].sock == skt->nr) 537 if (irqs[i].sock == skt->nr)
538 free_irq(irqs[i].irq, skt); 538 free_irq(irqs[i].irq, skt);
539 } 539 }
540 return res; 540 return res;
541 } 541 }
542 EXPORT_SYMBOL(soc_pcmcia_request_irqs); 542 EXPORT_SYMBOL(soc_pcmcia_request_irqs);
543 543
544 void soc_pcmcia_free_irqs(struct soc_pcmcia_socket *skt, 544 void soc_pcmcia_free_irqs(struct soc_pcmcia_socket *skt,
545 struct pcmcia_irqs *irqs, int nr) 545 struct pcmcia_irqs *irqs, int nr)
546 { 546 {
547 int i; 547 int i;
548 548
549 for (i = 0; i < nr; i++) 549 for (i = 0; i < nr; i++)
550 if (irqs[i].sock == skt->nr) 550 if (irqs[i].sock == skt->nr)
551 free_irq(irqs[i].irq, skt); 551 free_irq(irqs[i].irq, skt);
552 } 552 }
553 EXPORT_SYMBOL(soc_pcmcia_free_irqs); 553 EXPORT_SYMBOL(soc_pcmcia_free_irqs);
554 554
555 void soc_pcmcia_disable_irqs(struct soc_pcmcia_socket *skt, 555 void soc_pcmcia_disable_irqs(struct soc_pcmcia_socket *skt,
556 struct pcmcia_irqs *irqs, int nr) 556 struct pcmcia_irqs *irqs, int nr)
557 { 557 {
558 int i; 558 int i;
559 559
560 for (i = 0; i < nr; i++) 560 for (i = 0; i < nr; i++)
561 if (irqs[i].sock == skt->nr) 561 if (irqs[i].sock == skt->nr)
562 set_irq_type(irqs[i].irq, IRQT_NOEDGE); 562 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
563 } 563 }
564 EXPORT_SYMBOL(soc_pcmcia_disable_irqs); 564 EXPORT_SYMBOL(soc_pcmcia_disable_irqs);
565 565
566 void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt, 566 void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt,
567 struct pcmcia_irqs *irqs, int nr) 567 struct pcmcia_irqs *irqs, int nr)
568 { 568 {
569 int i; 569 int i;
570 570
571 for (i = 0; i < nr; i++) 571 for (i = 0; i < nr; i++)
572 if (irqs[i].sock == skt->nr) { 572 if (irqs[i].sock == skt->nr) {
573 set_irq_type(irqs[i].irq, IRQT_RISING); 573 set_irq_type(irqs[i].irq, IRQT_RISING);
574 set_irq_type(irqs[i].irq, IRQT_BOTHEDGE); 574 set_irq_type(irqs[i].irq, IRQT_BOTHEDGE);
575 } 575 }
576 } 576 }
577 EXPORT_SYMBOL(soc_pcmcia_enable_irqs); 577 EXPORT_SYMBOL(soc_pcmcia_enable_irqs);
578 578
579 579
580 LIST_HEAD(soc_pcmcia_sockets); 580 LIST_HEAD(soc_pcmcia_sockets);
581 DECLARE_MUTEX(soc_pcmcia_sockets_lock); 581 DECLARE_MUTEX(soc_pcmcia_sockets_lock);
582 582
583 static const char *skt_names[] = { 583 static const char *skt_names[] = {
584 "PCMCIA socket 0", 584 "PCMCIA socket 0",
585 "PCMCIA socket 1", 585 "PCMCIA socket 1",
586 }; 586 };
587 587
588 struct skt_dev_info { 588 struct skt_dev_info {
589 int nskt; 589 int nskt;
590 struct soc_pcmcia_socket skt[0]; 590 struct soc_pcmcia_socket skt[0];
591 }; 591 };
592 592
593 #define SKT_DEV_INFO_SIZE(n) \ 593 #define SKT_DEV_INFO_SIZE(n) \
594 (sizeof(struct skt_dev_info) + (n)*sizeof(struct soc_pcmcia_socket)) 594 (sizeof(struct skt_dev_info) + (n)*sizeof(struct soc_pcmcia_socket))
595 595
596 #ifdef CONFIG_CPU_FREQ 596 #ifdef CONFIG_CPU_FREQ
597 static int 597 static int
598 soc_pcmcia_notifier(struct notifier_block *nb, unsigned long val, void *data) 598 soc_pcmcia_notifier(struct notifier_block *nb, unsigned long val, void *data)
599 { 599 {
600 struct soc_pcmcia_socket *skt; 600 struct soc_pcmcia_socket *skt;
601 struct cpufreq_freqs *freqs = data; 601 struct cpufreq_freqs *freqs = data;
602 int ret = 0; 602 int ret = 0;
603 603
604 down(&soc_pcmcia_sockets_lock); 604 down(&soc_pcmcia_sockets_lock);
605 list_for_each_entry(skt, &soc_pcmcia_sockets, node) 605 list_for_each_entry(skt, &soc_pcmcia_sockets, node)
606 if ( skt->ops->frequency_change ) 606 if ( skt->ops->frequency_change )
607 ret += skt->ops->frequency_change(skt, val, freqs); 607 ret += skt->ops->frequency_change(skt, val, freqs);
608 up(&soc_pcmcia_sockets_lock); 608 up(&soc_pcmcia_sockets_lock);
609 609
610 return ret; 610 return ret;
611 } 611 }
612 612
613 static struct notifier_block soc_pcmcia_notifier_block = { 613 static struct notifier_block soc_pcmcia_notifier_block = {
614 .notifier_call = soc_pcmcia_notifier 614 .notifier_call = soc_pcmcia_notifier
615 }; 615 };
616 616
617 static int soc_pcmcia_cpufreq_register(void) 617 static int soc_pcmcia_cpufreq_register(void)
618 { 618 {
619 int ret; 619 int ret;
620 620
621 ret = cpufreq_register_notifier(&soc_pcmcia_notifier_block, 621 ret = cpufreq_register_notifier(&soc_pcmcia_notifier_block,
622 CPUFREQ_TRANSITION_NOTIFIER); 622 CPUFREQ_TRANSITION_NOTIFIER);
623 if (ret < 0) 623 if (ret < 0)
624 printk(KERN_ERR "Unable to register CPU frequency change " 624 printk(KERN_ERR "Unable to register CPU frequency change "
625 "notifier for PCMCIA (%d)\n", ret); 625 "notifier for PCMCIA (%d)\n", ret);
626 return ret; 626 return ret;
627 } 627 }
628 628
629 static void soc_pcmcia_cpufreq_unregister(void) 629 static void soc_pcmcia_cpufreq_unregister(void)
630 { 630 {
631 cpufreq_unregister_notifier(&soc_pcmcia_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); 631 cpufreq_unregister_notifier(&soc_pcmcia_notifier_block, CPUFREQ_TRANSITION_NOTIFIER);
632 } 632 }
633 633
634 #else 634 #else
635 static int soc_pcmcia_cpufreq_register(void) { return 0; } 635 static int soc_pcmcia_cpufreq_register(void) { return 0; }
636 static void soc_pcmcia_cpufreq_unregister(void) {} 636 static void soc_pcmcia_cpufreq_unregister(void) {}
637 #endif 637 #endif
638 638
639 int soc_common_drv_pcmcia_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr) 639 int soc_common_drv_pcmcia_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr)
640 { 640 {
641 struct skt_dev_info *sinfo; 641 struct skt_dev_info *sinfo;
642 struct soc_pcmcia_socket *skt; 642 struct soc_pcmcia_socket *skt;
643 int ret, i; 643 int ret, i;
644 644
645 down(&soc_pcmcia_sockets_lock); 645 down(&soc_pcmcia_sockets_lock);
646 646
647 sinfo = kzalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL); 647 sinfo = kzalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL);
648 if (!sinfo) { 648 if (!sinfo) {
649 ret = -ENOMEM; 649 ret = -ENOMEM;
650 goto out; 650 goto out;
651 } 651 }
652 652
653 sinfo->nskt = nr; 653 sinfo->nskt = nr;
654 654
655 /* 655 /*
656 * Initialise the per-socket structure. 656 * Initialise the per-socket structure.
657 */ 657 */
658 for (i = 0; i < nr; i++) { 658 for (i = 0; i < nr; i++) {
659 skt = &sinfo->skt[i]; 659 skt = &sinfo->skt[i];
660 660
661 skt->socket.ops = &soc_common_pcmcia_operations; 661 skt->socket.ops = &soc_common_pcmcia_operations;
662 skt->socket.owner = ops->owner; 662 skt->socket.owner = ops->owner;
663 skt->socket.dev.dev = dev; 663 skt->socket.dev.dev = dev;
664 664
665 init_timer(&skt->poll_timer); 665 init_timer(&skt->poll_timer);
666 skt->poll_timer.function = soc_common_pcmcia_poll_event; 666 skt->poll_timer.function = soc_common_pcmcia_poll_event;
667 skt->poll_timer.data = (unsigned long)skt; 667 skt->poll_timer.data = (unsigned long)skt;
668 skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD; 668 skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
669 669
670 skt->nr = first + i; 670 skt->nr = first + i;
671 skt->irq = NO_IRQ; 671 skt->irq = NO_IRQ;
672 skt->dev = dev; 672 skt->dev = dev;
673 skt->ops = ops; 673 skt->ops = ops;
674 674
675 skt->res_skt.start = _PCMCIA(skt->nr); 675 skt->res_skt.start = _PCMCIA(skt->nr);
676 skt->res_skt.end = _PCMCIA(skt->nr) + PCMCIASp - 1; 676 skt->res_skt.end = _PCMCIA(skt->nr) + PCMCIASp - 1;
677 skt->res_skt.name = skt_names[skt->nr]; 677 skt->res_skt.name = skt_names[skt->nr];
678 skt->res_skt.flags = IORESOURCE_MEM; 678 skt->res_skt.flags = IORESOURCE_MEM;
679 679
680 ret = request_resource(&iomem_resource, &skt->res_skt); 680 ret = request_resource(&iomem_resource, &skt->res_skt);
681 if (ret) 681 if (ret)
682 goto out_err_1; 682 goto out_err_1;
683 683
684 skt->res_io.start = _PCMCIAIO(skt->nr); 684 skt->res_io.start = _PCMCIAIO(skt->nr);
685 skt->res_io.end = _PCMCIAIO(skt->nr) + PCMCIAIOSp - 1; 685 skt->res_io.end = _PCMCIAIO(skt->nr) + PCMCIAIOSp - 1;
686 skt->res_io.name = "io"; 686 skt->res_io.name = "io";
687 skt->res_io.flags = IORESOURCE_MEM | IORESOURCE_BUSY; 687 skt->res_io.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
688 688
689 ret = request_resource(&skt->res_skt, &skt->res_io); 689 ret = request_resource(&skt->res_skt, &skt->res_io);
690 if (ret) 690 if (ret)
691 goto out_err_2; 691 goto out_err_2;
692 692
693 skt->res_mem.start = _PCMCIAMem(skt->nr); 693 skt->res_mem.start = _PCMCIAMem(skt->nr);
694 skt->res_mem.end = _PCMCIAMem(skt->nr) + PCMCIAMemSp - 1; 694 skt->res_mem.end = _PCMCIAMem(skt->nr) + PCMCIAMemSp - 1;
695 skt->res_mem.name = "memory"; 695 skt->res_mem.name = "memory";
696 skt->res_mem.flags = IORESOURCE_MEM; 696 skt->res_mem.flags = IORESOURCE_MEM;
697 697
698 ret = request_resource(&skt->res_skt, &skt->res_mem); 698 ret = request_resource(&skt->res_skt, &skt->res_mem);
699 if (ret) 699 if (ret)
700 goto out_err_3; 700 goto out_err_3;
701 701
702 skt->res_attr.start = _PCMCIAAttr(skt->nr); 702 skt->res_attr.start = _PCMCIAAttr(skt->nr);
703 skt->res_attr.end = _PCMCIAAttr(skt->nr) + PCMCIAAttrSp - 1; 703 skt->res_attr.end = _PCMCIAAttr(skt->nr) + PCMCIAAttrSp - 1;
704 skt->res_attr.name = "attribute"; 704 skt->res_attr.name = "attribute";
705 skt->res_attr.flags = IORESOURCE_MEM; 705 skt->res_attr.flags = IORESOURCE_MEM;
706 706
707 ret = request_resource(&skt->res_skt, &skt->res_attr); 707 ret = request_resource(&skt->res_skt, &skt->res_attr);
708 if (ret) 708 if (ret)
709 goto out_err_4; 709 goto out_err_4;
710 710
711 skt->virt_io = ioremap(skt->res_io.start, 0x10000); 711 skt->virt_io = ioremap(skt->res_io.start, 0x10000);
712 if (skt->virt_io == NULL) { 712 if (skt->virt_io == NULL) {
713 ret = -ENOMEM; 713 ret = -ENOMEM;
714 goto out_err_5; 714 goto out_err_5;
715 } 715 }
716 716
717 if (list_empty(&soc_pcmcia_sockets)) 717 if (list_empty(&soc_pcmcia_sockets))
718 soc_pcmcia_cpufreq_register(); 718 soc_pcmcia_cpufreq_register();
719 719
720 list_add(&skt->node, &soc_pcmcia_sockets); 720 list_add(&skt->node, &soc_pcmcia_sockets);
721 721
722 /* 722 /*
723 * We initialize default socket timing here, because 723 * We initialize default socket timing here, because
724 * we are not guaranteed to see a SetIOMap operation at 724 * we are not guaranteed to see a SetIOMap operation at
725 * runtime. 725 * runtime.
726 */ 726 */
727 ops->set_timing(skt); 727 ops->set_timing(skt);
728 728
729 ret = ops->hw_init(skt); 729 ret = ops->hw_init(skt);
730 if (ret) 730 if (ret)
731 goto out_err_6; 731 goto out_err_6;
732 732
733 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD; 733 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
734 skt->socket.resource_ops = &pccard_static_ops; 734 skt->socket.resource_ops = &pccard_static_ops;
735 skt->socket.irq_mask = 0; 735 skt->socket.irq_mask = 0;
736 skt->socket.map_size = PAGE_SIZE; 736 skt->socket.map_size = PAGE_SIZE;
737 skt->socket.pci_irq = skt->irq; 737 skt->socket.pci_irq = skt->irq;
738 skt->socket.io_offset = (unsigned long)skt->virt_io; 738 skt->socket.io_offset = (unsigned long)skt->virt_io;
739 739
740 skt->status = soc_common_pcmcia_skt_state(skt); 740 skt->status = soc_common_pcmcia_skt_state(skt);
741 741
742 ret = pcmcia_register_socket(&skt->socket); 742 ret = pcmcia_register_socket(&skt->socket);
743 if (ret) 743 if (ret)
744 goto out_err_7; 744 goto out_err_7;
745 745
746 WARN_ON(skt->socket.sock != i); 746 WARN_ON(skt->socket.sock != i);
747 747
748 add_timer(&skt->poll_timer); 748 add_timer(&skt->poll_timer);
749 749
750 class_device_create_file(&skt->socket.dev, &class_device_attr_status); 750 class_device_create_file(&skt->socket.dev, &class_device_attr_status);
751 } 751 }
752 752
753 dev_set_drvdata(dev, sinfo); 753 dev_set_drvdata(dev, sinfo);
754 ret = 0; 754 ret = 0;
755 goto out; 755 goto out;
756 756
757 do { 757 do {
758 skt = &sinfo->skt[i]; 758 skt = &sinfo->skt[i];
759 759
760 del_timer_sync(&skt->poll_timer); 760 del_timer_sync(&skt->poll_timer);
761 pcmcia_unregister_socket(&skt->socket); 761 pcmcia_unregister_socket(&skt->socket);
762 762
763 out_err_7: 763 out_err_7:
764 flush_scheduled_work(); 764 flush_scheduled_work();
765 765
766 ops->hw_shutdown(skt); 766 ops->hw_shutdown(skt);
767 out_err_6: 767 out_err_6:
768 list_del(&skt->node); 768 list_del(&skt->node);
769 iounmap(skt->virt_io); 769 iounmap(skt->virt_io);
770 out_err_5: 770 out_err_5:
771 release_resource(&skt->res_attr); 771 release_resource(&skt->res_attr);
772 out_err_4: 772 out_err_4:
773 release_resource(&skt->res_mem); 773 release_resource(&skt->res_mem);
774 out_err_3: 774 out_err_3:
775 release_resource(&skt->res_io); 775 release_resource(&skt->res_io);
776 out_err_2: 776 out_err_2:
777 release_resource(&skt->res_skt); 777 release_resource(&skt->res_skt);
778 out_err_1: 778 out_err_1:
779 i--; 779 i--;
780 } while (i > 0); 780 } while (i > 0);
781 781
782 kfree(sinfo); 782 kfree(sinfo);
783 783
784 out: 784 out:
785 up(&soc_pcmcia_sockets_lock); 785 up(&soc_pcmcia_sockets_lock);
786 return ret; 786 return ret;
787 } 787 }
788 788
789 int soc_common_drv_pcmcia_remove(struct device *dev) 789 int soc_common_drv_pcmcia_remove(struct device *dev)
790 { 790 {
791 struct skt_dev_info *sinfo = dev_get_drvdata(dev); 791 struct skt_dev_info *sinfo = dev_get_drvdata(dev);
792 int i; 792 int i;
793 793
794 dev_set_drvdata(dev, NULL); 794 dev_set_drvdata(dev, NULL);
795 795
796 down(&soc_pcmcia_sockets_lock); 796 down(&soc_pcmcia_sockets_lock);
797 for (i = 0; i < sinfo->nskt; i++) { 797 for (i = 0; i < sinfo->nskt; i++) {
798 struct soc_pcmcia_socket *skt = &sinfo->skt[i]; 798 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
799 799
800 del_timer_sync(&skt->poll_timer); 800 del_timer_sync(&skt->poll_timer);
801 801
802 pcmcia_unregister_socket(&skt->socket); 802 pcmcia_unregister_socket(&skt->socket);
803 803
804 flush_scheduled_work(); 804 flush_scheduled_work();
805 805
806 skt->ops->hw_shutdown(skt); 806 skt->ops->hw_shutdown(skt);
807 807
808 soc_common_pcmcia_config_skt(skt, &dead_socket); 808 soc_common_pcmcia_config_skt(skt, &dead_socket);
809 809
810 list_del(&skt->node); 810 list_del(&skt->node);
811 iounmap(skt->virt_io); 811 iounmap(skt->virt_io);
812 skt->virt_io = NULL; 812 skt->virt_io = NULL;
813 release_resource(&skt->res_attr); 813 release_resource(&skt->res_attr);
814 release_resource(&skt->res_mem); 814 release_resource(&skt->res_mem);
815 release_resource(&skt->res_io); 815 release_resource(&skt->res_io);
816 release_resource(&skt->res_skt); 816 release_resource(&skt->res_skt);
817 } 817 }
818 if (list_empty(&soc_pcmcia_sockets)) 818 if (list_empty(&soc_pcmcia_sockets))
819 soc_pcmcia_cpufreq_unregister(); 819 soc_pcmcia_cpufreq_unregister();
820 820
821 up(&soc_pcmcia_sockets_lock); 821 up(&soc_pcmcia_sockets_lock);
822 822
823 kfree(sinfo); 823 kfree(sinfo);
824 824
825 return 0; 825 return 0;
826 } 826 }