1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * cs.c -- Kernel Card Services - core services |
4 | * |
5 | * The initial developer of the original code is David A. Hinds |
6 | * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds |
7 | * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. |
8 | * |
9 | * (C) 1999 David A. Hinds |
10 | */ |
11 | |
12 | #include <linux/module.h> |
13 | #include <linux/moduleparam.h> |
14 | #include <linux/init.h> |
15 | #include <linux/kernel.h> |
16 | #include <linux/string.h> |
17 | #include <linux/major.h> |
18 | #include <linux/errno.h> |
19 | #include <linux/slab.h> |
20 | #include <linux/mm.h> |
21 | #include <linux/interrupt.h> |
22 | #include <linux/timer.h> |
23 | #include <linux/ioport.h> |
24 | #include <linux/delay.h> |
25 | #include <linux/pm.h> |
26 | #include <linux/device.h> |
27 | #include <linux/kthread.h> |
28 | #include <linux/freezer.h> |
29 | #include <asm/irq.h> |
30 | |
31 | #include <pcmcia/ss.h> |
32 | #include <pcmcia/cistpl.h> |
33 | #include <pcmcia/cisreg.h> |
34 | #include <pcmcia/ds.h> |
35 | #include "cs_internal.h" |
36 | |
37 | |
38 | /* Module parameters */ |
39 | |
40 | MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>" ); |
41 | MODULE_DESCRIPTION("Linux Kernel Card Services" ); |
42 | MODULE_LICENSE("GPL" ); |
43 | |
44 | #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444) |
45 | |
46 | INT_MODULE_PARM(setup_delay, 10); /* centiseconds */ |
47 | INT_MODULE_PARM(resume_delay, 20); /* centiseconds */ |
48 | INT_MODULE_PARM(shutdown_delay, 3); /* centiseconds */ |
49 | INT_MODULE_PARM(vcc_settle, 40); /* centiseconds */ |
50 | INT_MODULE_PARM(reset_time, 10); /* usecs */ |
51 | INT_MODULE_PARM(unreset_delay, 10); /* centiseconds */ |
52 | INT_MODULE_PARM(unreset_check, 10); /* centiseconds */ |
53 | INT_MODULE_PARM(unreset_limit, 30); /* unreset_check's */ |
54 | |
55 | /* Access speed for attribute memory windows */ |
56 | INT_MODULE_PARM(cis_speed, 300); /* ns */ |
57 | |
58 | |
59 | socket_state_t dead_socket = { |
60 | .csc_mask = SS_DETECT, |
61 | }; |
62 | EXPORT_SYMBOL(dead_socket); |
63 | |
64 | |
65 | /* List of all sockets, protected by a rwsem */ |
66 | LIST_HEAD(pcmcia_socket_list); |
67 | EXPORT_SYMBOL(pcmcia_socket_list); |
68 | |
69 | DECLARE_RWSEM(pcmcia_socket_list_rwsem); |
70 | EXPORT_SYMBOL(pcmcia_socket_list_rwsem); |
71 | |
72 | |
73 | struct pcmcia_socket *pcmcia_get_socket(struct pcmcia_socket *skt) |
74 | { |
75 | struct device *dev = get_device(dev: &skt->dev); |
76 | if (!dev) |
77 | return NULL; |
78 | return dev_get_drvdata(dev); |
79 | } |
80 | EXPORT_SYMBOL(pcmcia_get_socket); |
81 | |
82 | |
83 | void pcmcia_put_socket(struct pcmcia_socket *skt) |
84 | { |
85 | put_device(dev: &skt->dev); |
86 | } |
87 | EXPORT_SYMBOL(pcmcia_put_socket); |
88 | |
89 | |
90 | static void pcmcia_release_socket(struct device *dev) |
91 | { |
92 | struct pcmcia_socket *socket = dev_get_drvdata(dev); |
93 | |
94 | complete(&socket->socket_released); |
95 | } |
96 | |
97 | static int pccardd(void *__skt); |
98 | |
99 | /** |
100 | * pcmcia_register_socket - add a new pcmcia socket device |
101 | * @socket: the &socket to register |
102 | */ |
103 | int pcmcia_register_socket(struct pcmcia_socket *socket) |
104 | { |
105 | struct task_struct *tsk; |
106 | int ret; |
107 | |
108 | if (!socket || !socket->ops || !socket->dev.parent || !socket->resource_ops) |
109 | return -EINVAL; |
110 | |
111 | dev_dbg(&socket->dev, "pcmcia_register_socket(0x%p)\n" , socket->ops); |
112 | |
113 | /* try to obtain a socket number [yes, it gets ugly if we |
114 | * register more than 2^sizeof(unsigned int) pcmcia |
115 | * sockets... but the socket number is deprecated |
116 | * anyways, so I don't care] */ |
117 | down_write(sem: &pcmcia_socket_list_rwsem); |
118 | if (list_empty(head: &pcmcia_socket_list)) |
119 | socket->sock = 0; |
120 | else { |
121 | unsigned int found, i = 1; |
122 | struct pcmcia_socket *tmp; |
123 | do { |
124 | found = 1; |
125 | list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) { |
126 | if (tmp->sock == i) |
127 | found = 0; |
128 | } |
129 | i++; |
130 | } while (!found); |
131 | socket->sock = i - 1; |
132 | } |
133 | list_add_tail(new: &socket->socket_list, head: &pcmcia_socket_list); |
134 | up_write(sem: &pcmcia_socket_list_rwsem); |
135 | |
136 | #ifndef CONFIG_CARDBUS |
137 | /* |
138 | * If we do not support Cardbus, ensure that |
139 | * the Cardbus socket capability is disabled. |
140 | */ |
141 | socket->features &= ~SS_CAP_CARDBUS; |
142 | #endif |
143 | |
144 | /* set proper values in socket->dev */ |
145 | dev_set_drvdata(dev: &socket->dev, data: socket); |
146 | socket->dev.class = &pcmcia_socket_class; |
147 | dev_set_name(dev: &socket->dev, name: "pcmcia_socket%u" , socket->sock); |
148 | |
149 | /* base address = 0, map = 0 */ |
150 | socket->cis_mem.flags = 0; |
151 | socket->cis_mem.speed = cis_speed; |
152 | |
153 | INIT_LIST_HEAD(list: &socket->cis_cache); |
154 | |
155 | init_completion(x: &socket->socket_released); |
156 | init_completion(x: &socket->thread_done); |
157 | mutex_init(&socket->skt_mutex); |
158 | mutex_init(&socket->ops_mutex); |
159 | spin_lock_init(&socket->thread_lock); |
160 | |
161 | if (socket->resource_ops->init) { |
162 | mutex_lock(&socket->ops_mutex); |
163 | ret = socket->resource_ops->init(socket); |
164 | mutex_unlock(lock: &socket->ops_mutex); |
165 | if (ret) |
166 | goto err; |
167 | } |
168 | |
169 | tsk = kthread_run(pccardd, socket, "pccardd" ); |
170 | if (IS_ERR(ptr: tsk)) { |
171 | ret = PTR_ERR(ptr: tsk); |
172 | goto err; |
173 | } |
174 | |
175 | wait_for_completion(&socket->thread_done); |
176 | if (!socket->thread) { |
177 | dev_warn(&socket->dev, |
178 | "PCMCIA: warning: socket thread did not start\n" ); |
179 | return -EIO; |
180 | } |
181 | |
182 | pcmcia_parse_events(socket, SS_DETECT); |
183 | |
184 | /* |
185 | * Let's try to get the PCMCIA module for 16-bit PCMCIA support. |
186 | * If it fails, it doesn't matter -- we still have 32-bit CardBus |
187 | * support to offer, so this is not a failure mode. |
188 | */ |
189 | request_module_nowait("pcmcia" ); |
190 | |
191 | return 0; |
192 | |
193 | err: |
194 | down_write(sem: &pcmcia_socket_list_rwsem); |
195 | list_del(entry: &socket->socket_list); |
196 | up_write(sem: &pcmcia_socket_list_rwsem); |
197 | return ret; |
198 | } /* pcmcia_register_socket */ |
199 | EXPORT_SYMBOL(pcmcia_register_socket); |
200 | |
201 | |
202 | /** |
203 | * pcmcia_unregister_socket - remove a pcmcia socket device |
204 | * @socket: the &socket to unregister |
205 | */ |
206 | void pcmcia_unregister_socket(struct pcmcia_socket *socket) |
207 | { |
208 | if (!socket) |
209 | return; |
210 | |
211 | dev_dbg(&socket->dev, "pcmcia_unregister_socket(0x%p)\n" , socket->ops); |
212 | |
213 | if (socket->thread) |
214 | kthread_stop(k: socket->thread); |
215 | |
216 | /* remove from our own list */ |
217 | down_write(sem: &pcmcia_socket_list_rwsem); |
218 | list_del(entry: &socket->socket_list); |
219 | up_write(sem: &pcmcia_socket_list_rwsem); |
220 | |
221 | /* wait for sysfs to drop all references */ |
222 | if (socket->resource_ops->exit) { |
223 | mutex_lock(&socket->ops_mutex); |
224 | socket->resource_ops->exit(socket); |
225 | mutex_unlock(lock: &socket->ops_mutex); |
226 | } |
227 | wait_for_completion(&socket->socket_released); |
228 | } /* pcmcia_unregister_socket */ |
229 | EXPORT_SYMBOL(pcmcia_unregister_socket); |
230 | |
231 | |
232 | struct pcmcia_socket *pcmcia_get_socket_by_nr(unsigned int nr) |
233 | { |
234 | struct pcmcia_socket *s; |
235 | |
236 | down_read(sem: &pcmcia_socket_list_rwsem); |
237 | list_for_each_entry(s, &pcmcia_socket_list, socket_list) |
238 | if (s->sock == nr) { |
239 | up_read(sem: &pcmcia_socket_list_rwsem); |
240 | return s; |
241 | } |
242 | up_read(sem: &pcmcia_socket_list_rwsem); |
243 | |
244 | return NULL; |
245 | |
246 | } |
247 | EXPORT_SYMBOL(pcmcia_get_socket_by_nr); |
248 | |
249 | static int socket_reset(struct pcmcia_socket *skt) |
250 | { |
251 | int status, i; |
252 | |
253 | dev_dbg(&skt->dev, "reset\n" ); |
254 | |
255 | skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET; |
256 | skt->ops->set_socket(skt, &skt->socket); |
257 | udelay((long)reset_time); |
258 | |
259 | skt->socket.flags &= ~SS_RESET; |
260 | skt->ops->set_socket(skt, &skt->socket); |
261 | |
262 | msleep(msecs: unreset_delay * 10); |
263 | for (i = 0; i < unreset_limit; i++) { |
264 | skt->ops->get_status(skt, &status); |
265 | |
266 | if (!(status & SS_DETECT)) |
267 | return -ENODEV; |
268 | |
269 | if (status & SS_READY) |
270 | return 0; |
271 | |
272 | msleep(msecs: unreset_check * 10); |
273 | } |
274 | |
275 | dev_err(&skt->dev, "time out after reset\n" ); |
276 | return -ETIMEDOUT; |
277 | } |
278 | |
279 | /* |
280 | * socket_setup() and socket_shutdown() are called by the main event handler |
281 | * when card insertion and removal events are received. |
282 | * socket_setup() turns on socket power and resets the socket, in two stages. |
283 | * socket_shutdown() unconfigures a socket and turns off socket power. |
284 | */ |
285 | static void socket_shutdown(struct pcmcia_socket *s) |
286 | { |
287 | int status; |
288 | |
289 | dev_dbg(&s->dev, "shutdown\n" ); |
290 | |
291 | if (s->callback) |
292 | s->callback->remove(s); |
293 | |
294 | mutex_lock(&s->ops_mutex); |
295 | s->state &= SOCKET_INUSE | SOCKET_PRESENT; |
296 | msleep(msecs: shutdown_delay * 10); |
297 | s->state &= SOCKET_INUSE; |
298 | |
299 | /* Blank out the socket state */ |
300 | s->socket = dead_socket; |
301 | s->ops->init(s); |
302 | s->ops->set_socket(s, &s->socket); |
303 | s->lock_count = 0; |
304 | kfree(objp: s->fake_cis); |
305 | s->fake_cis = NULL; |
306 | s->functions = 0; |
307 | |
308 | /* From here on we can be sure that only we (that is, the |
309 | * pccardd thread) accesses this socket, and all (16-bit) |
310 | * PCMCIA interactions are gone. Therefore, release |
311 | * ops_mutex so that we don't get a sysfs-related lockdep |
312 | * warning. |
313 | */ |
314 | mutex_unlock(lock: &s->ops_mutex); |
315 | |
316 | #ifdef CONFIG_CARDBUS |
317 | cb_free(s); |
318 | #endif |
319 | |
320 | /* give socket some time to power down */ |
321 | msleep(msecs: 100); |
322 | |
323 | s->ops->get_status(s, &status); |
324 | if (status & SS_POWERON) { |
325 | dev_err(&s->dev, |
326 | "*** DANGER *** unable to remove socket power\n" ); |
327 | } |
328 | |
329 | s->state &= ~SOCKET_INUSE; |
330 | } |
331 | |
332 | static int socket_setup(struct pcmcia_socket *skt, int initial_delay) |
333 | { |
334 | int status, i; |
335 | |
336 | dev_dbg(&skt->dev, "setup\n" ); |
337 | |
338 | skt->ops->get_status(skt, &status); |
339 | if (!(status & SS_DETECT)) |
340 | return -ENODEV; |
341 | |
342 | msleep(msecs: initial_delay * 10); |
343 | |
344 | for (i = 0; i < 100; i++) { |
345 | skt->ops->get_status(skt, &status); |
346 | if (!(status & SS_DETECT)) |
347 | return -ENODEV; |
348 | |
349 | if (!(status & SS_PENDING)) |
350 | break; |
351 | |
352 | msleep(msecs: 100); |
353 | } |
354 | |
355 | if (status & SS_PENDING) { |
356 | dev_err(&skt->dev, "voltage interrogation timed out\n" ); |
357 | return -ETIMEDOUT; |
358 | } |
359 | |
360 | if (status & SS_CARDBUS) { |
361 | if (!(skt->features & SS_CAP_CARDBUS)) { |
362 | dev_err(&skt->dev, "cardbus cards are not supported\n" ); |
363 | return -EINVAL; |
364 | } |
365 | skt->state |= SOCKET_CARDBUS; |
366 | } else |
367 | skt->state &= ~SOCKET_CARDBUS; |
368 | |
369 | /* |
370 | * Decode the card voltage requirements, and apply power to the card. |
371 | */ |
372 | if (status & SS_3VCARD) |
373 | skt->socket.Vcc = skt->socket.Vpp = 33; |
374 | else if (!(status & SS_XVCARD)) |
375 | skt->socket.Vcc = skt->socket.Vpp = 50; |
376 | else { |
377 | dev_err(&skt->dev, "unsupported voltage key\n" ); |
378 | return -EIO; |
379 | } |
380 | |
381 | if (skt->power_hook) |
382 | skt->power_hook(skt, HOOK_POWER_PRE); |
383 | |
384 | skt->socket.flags = 0; |
385 | skt->ops->set_socket(skt, &skt->socket); |
386 | |
387 | /* |
388 | * Wait "vcc_settle" for the supply to stabilise. |
389 | */ |
390 | msleep(msecs: vcc_settle * 10); |
391 | |
392 | skt->ops->get_status(skt, &status); |
393 | if (!(status & SS_POWERON)) { |
394 | dev_err(&skt->dev, "unable to apply power\n" ); |
395 | return -EIO; |
396 | } |
397 | |
398 | status = socket_reset(skt); |
399 | |
400 | if (skt->power_hook) |
401 | skt->power_hook(skt, HOOK_POWER_POST); |
402 | |
403 | return status; |
404 | } |
405 | |
406 | /* |
407 | * Handle card insertion. Setup the socket, reset the card, |
408 | * and then tell the rest of PCMCIA that a card is present. |
409 | */ |
410 | static int socket_insert(struct pcmcia_socket *skt) |
411 | { |
412 | int ret; |
413 | |
414 | dev_dbg(&skt->dev, "insert\n" ); |
415 | |
416 | mutex_lock(&skt->ops_mutex); |
417 | if (skt->state & SOCKET_INUSE) { |
418 | mutex_unlock(lock: &skt->ops_mutex); |
419 | return -EINVAL; |
420 | } |
421 | skt->state |= SOCKET_INUSE; |
422 | |
423 | ret = socket_setup(skt, initial_delay: setup_delay); |
424 | if (ret == 0) { |
425 | skt->state |= SOCKET_PRESENT; |
426 | |
427 | dev_notice(&skt->dev, "pccard: %s card inserted into slot %d\n" , |
428 | (skt->state & SOCKET_CARDBUS) ? "CardBus" : "PCMCIA" , |
429 | skt->sock); |
430 | |
431 | #ifdef CONFIG_CARDBUS |
432 | if (skt->state & SOCKET_CARDBUS) { |
433 | cb_alloc(s: skt); |
434 | skt->state |= SOCKET_CARDBUS_CONFIG; |
435 | } |
436 | #endif |
437 | dev_dbg(&skt->dev, "insert done\n" ); |
438 | mutex_unlock(lock: &skt->ops_mutex); |
439 | |
440 | if (!(skt->state & SOCKET_CARDBUS) && (skt->callback)) |
441 | skt->callback->add(skt); |
442 | } else { |
443 | mutex_unlock(lock: &skt->ops_mutex); |
444 | socket_shutdown(s: skt); |
445 | } |
446 | |
447 | return ret; |
448 | } |
449 | |
450 | static int socket_suspend(struct pcmcia_socket *skt) |
451 | { |
452 | if ((skt->state & SOCKET_SUSPEND) && !(skt->state & SOCKET_IN_RESUME)) |
453 | return -EBUSY; |
454 | |
455 | mutex_lock(&skt->ops_mutex); |
456 | /* store state on first suspend, but not after spurious wakeups */ |
457 | if (!(skt->state & SOCKET_IN_RESUME)) |
458 | skt->suspended_state = skt->state; |
459 | |
460 | skt->socket = dead_socket; |
461 | skt->ops->set_socket(skt, &skt->socket); |
462 | if (skt->ops->suspend) |
463 | skt->ops->suspend(skt); |
464 | skt->state |= SOCKET_SUSPEND; |
465 | skt->state &= ~SOCKET_IN_RESUME; |
466 | mutex_unlock(lock: &skt->ops_mutex); |
467 | return 0; |
468 | } |
469 | |
470 | static int socket_early_resume(struct pcmcia_socket *skt) |
471 | { |
472 | mutex_lock(&skt->ops_mutex); |
473 | skt->socket = dead_socket; |
474 | skt->ops->init(skt); |
475 | skt->ops->set_socket(skt, &skt->socket); |
476 | if (skt->state & SOCKET_PRESENT) |
477 | skt->resume_status = socket_setup(skt, initial_delay: resume_delay); |
478 | skt->state |= SOCKET_IN_RESUME; |
479 | mutex_unlock(lock: &skt->ops_mutex); |
480 | return 0; |
481 | } |
482 | |
483 | static int socket_late_resume(struct pcmcia_socket *skt) |
484 | { |
485 | int ret = 0; |
486 | |
487 | mutex_lock(&skt->ops_mutex); |
488 | skt->state &= ~(SOCKET_SUSPEND | SOCKET_IN_RESUME); |
489 | mutex_unlock(lock: &skt->ops_mutex); |
490 | |
491 | if (!(skt->state & SOCKET_PRESENT)) { |
492 | ret = socket_insert(skt); |
493 | if (ret == -ENODEV) |
494 | ret = 0; |
495 | return ret; |
496 | } |
497 | |
498 | if (skt->resume_status) { |
499 | socket_shutdown(s: skt); |
500 | return 0; |
501 | } |
502 | |
503 | if (skt->suspended_state != skt->state) { |
504 | dev_dbg(&skt->dev, |
505 | "suspend state 0x%x != resume state 0x%x\n" , |
506 | skt->suspended_state, skt->state); |
507 | |
508 | socket_shutdown(s: skt); |
509 | return socket_insert(skt); |
510 | } |
511 | |
512 | if (!(skt->state & SOCKET_CARDBUS) && (skt->callback)) |
513 | ret = skt->callback->early_resume(skt); |
514 | return ret; |
515 | } |
516 | |
517 | /* |
518 | * Finalize the resume. In case of a cardbus socket, we have |
519 | * to rebind the devices as we can't be certain that it has been |
520 | * replaced, or not. |
521 | */ |
522 | static int socket_complete_resume(struct pcmcia_socket *skt) |
523 | { |
524 | int ret = 0; |
525 | #ifdef CONFIG_CARDBUS |
526 | if (skt->state & SOCKET_CARDBUS) { |
527 | /* We can't be sure the CardBus card is the same |
528 | * as the one previously inserted. Therefore, remove |
529 | * and re-add... */ |
530 | cb_free(s: skt); |
531 | ret = cb_alloc(s: skt); |
532 | if (ret) |
533 | cb_free(s: skt); |
534 | } |
535 | #endif |
536 | return ret; |
537 | } |
538 | |
539 | /* |
540 | * Resume a socket. If a card is present, verify its CIS against |
541 | * our cached copy. If they are different, the card has been |
542 | * replaced, and we need to tell the drivers. |
543 | */ |
544 | static int socket_resume(struct pcmcia_socket *skt) |
545 | { |
546 | int err; |
547 | if (!(skt->state & SOCKET_SUSPEND)) |
548 | return -EBUSY; |
549 | |
550 | socket_early_resume(skt); |
551 | err = socket_late_resume(skt); |
552 | if (!err) |
553 | err = socket_complete_resume(skt); |
554 | return err; |
555 | } |
556 | |
557 | static void socket_remove(struct pcmcia_socket *skt) |
558 | { |
559 | dev_notice(&skt->dev, "pccard: card ejected from slot %d\n" , skt->sock); |
560 | socket_shutdown(s: skt); |
561 | } |
562 | |
563 | /* |
564 | * Process a socket card detect status change. |
565 | * |
566 | * If we don't have a card already present, delay the detect event for |
567 | * about 20ms (to be on the safe side) before reading the socket status. |
568 | * |
569 | * Some i82365-based systems send multiple SS_DETECT events during card |
570 | * insertion, and the "card present" status bit seems to bounce. This |
571 | * will probably be true with GPIO-based card detection systems after |
572 | * the product has aged. |
573 | */ |
574 | static void socket_detect_change(struct pcmcia_socket *skt) |
575 | { |
576 | if (!(skt->state & SOCKET_SUSPEND)) { |
577 | int status; |
578 | |
579 | if (!(skt->state & SOCKET_PRESENT)) |
580 | msleep(msecs: 20); |
581 | |
582 | skt->ops->get_status(skt, &status); |
583 | if ((skt->state & SOCKET_PRESENT) && |
584 | !(status & SS_DETECT)) |
585 | socket_remove(skt); |
586 | if (!(skt->state & SOCKET_PRESENT) && |
587 | (status & SS_DETECT)) |
588 | socket_insert(skt); |
589 | } |
590 | } |
591 | |
592 | static int pccardd(void *__skt) |
593 | { |
594 | struct pcmcia_socket *skt = __skt; |
595 | int ret; |
596 | |
597 | skt->thread = current; |
598 | skt->socket = dead_socket; |
599 | skt->ops->init(skt); |
600 | skt->ops->set_socket(skt, &skt->socket); |
601 | |
602 | /* register with the device core */ |
603 | ret = device_register(dev: &skt->dev); |
604 | if (ret) { |
605 | dev_warn(&skt->dev, "PCMCIA: unable to register socket\n" ); |
606 | skt->thread = NULL; |
607 | complete(&skt->thread_done); |
608 | put_device(dev: &skt->dev); |
609 | return 0; |
610 | } |
611 | ret = pccard_sysfs_add_socket(dev: &skt->dev); |
612 | if (ret) |
613 | dev_warn(&skt->dev, "err %d adding socket attributes\n" , ret); |
614 | |
615 | complete(&skt->thread_done); |
616 | |
617 | /* wait for userspace to catch up */ |
618 | msleep(msecs: 250); |
619 | |
620 | set_freezable(); |
621 | for (;;) { |
622 | unsigned long flags; |
623 | unsigned int events; |
624 | unsigned int sysfs_events; |
625 | |
626 | spin_lock_irqsave(&skt->thread_lock, flags); |
627 | events = skt->thread_events; |
628 | skt->thread_events = 0; |
629 | sysfs_events = skt->sysfs_events; |
630 | skt->sysfs_events = 0; |
631 | spin_unlock_irqrestore(lock: &skt->thread_lock, flags); |
632 | |
633 | mutex_lock(&skt->skt_mutex); |
634 | if (events & SS_DETECT) |
635 | socket_detect_change(skt); |
636 | |
637 | if (sysfs_events) { |
638 | if (sysfs_events & PCMCIA_UEVENT_EJECT) |
639 | socket_remove(skt); |
640 | if (sysfs_events & PCMCIA_UEVENT_INSERT) |
641 | socket_insert(skt); |
642 | if ((sysfs_events & PCMCIA_UEVENT_SUSPEND) && |
643 | !(skt->state & SOCKET_CARDBUS)) { |
644 | if (skt->callback) |
645 | ret = skt->callback->suspend(skt); |
646 | else |
647 | ret = 0; |
648 | if (!ret) { |
649 | socket_suspend(skt); |
650 | msleep(msecs: 100); |
651 | } |
652 | } |
653 | if ((sysfs_events & PCMCIA_UEVENT_RESUME) && |
654 | !(skt->state & SOCKET_CARDBUS)) { |
655 | ret = socket_resume(skt); |
656 | if (!ret && skt->callback) |
657 | skt->callback->resume(skt); |
658 | } |
659 | if ((sysfs_events & PCMCIA_UEVENT_REQUERY) && |
660 | !(skt->state & SOCKET_CARDBUS)) { |
661 | if (!ret && skt->callback) |
662 | skt->callback->requery(skt); |
663 | } |
664 | } |
665 | mutex_unlock(lock: &skt->skt_mutex); |
666 | |
667 | if (events || sysfs_events) |
668 | continue; |
669 | |
670 | set_current_state(TASK_INTERRUPTIBLE); |
671 | if (kthread_should_stop()) |
672 | break; |
673 | |
674 | schedule(); |
675 | |
676 | try_to_freeze(); |
677 | } |
678 | /* make sure we are running before we exit */ |
679 | __set_current_state(TASK_RUNNING); |
680 | |
681 | /* shut down socket, if a device is still present */ |
682 | if (skt->state & SOCKET_PRESENT) { |
683 | mutex_lock(&skt->skt_mutex); |
684 | socket_remove(skt); |
685 | mutex_unlock(lock: &skt->skt_mutex); |
686 | } |
687 | |
688 | /* remove from the device core */ |
689 | pccard_sysfs_remove_socket(dev: &skt->dev); |
690 | device_unregister(dev: &skt->dev); |
691 | |
692 | return 0; |
693 | } |
694 | |
695 | /* |
696 | * Yenta (at least) probes interrupts before registering the socket and |
697 | * starting the handler thread. |
698 | */ |
699 | void pcmcia_parse_events(struct pcmcia_socket *s, u_int events) |
700 | { |
701 | unsigned long flags; |
702 | dev_dbg(&s->dev, "parse_events: events %08x\n" , events); |
703 | if (s->thread) { |
704 | spin_lock_irqsave(&s->thread_lock, flags); |
705 | s->thread_events |= events; |
706 | spin_unlock_irqrestore(lock: &s->thread_lock, flags); |
707 | |
708 | wake_up_process(tsk: s->thread); |
709 | } |
710 | } /* pcmcia_parse_events */ |
711 | EXPORT_SYMBOL(pcmcia_parse_events); |
712 | |
713 | /** |
714 | * pcmcia_parse_uevents() - tell pccardd to issue manual commands |
715 | * @s: the PCMCIA socket we wan't to command |
716 | * @events: events to pass to pccardd |
717 | * |
718 | * userspace-issued insert, eject, suspend and resume commands must be |
719 | * handled by pccardd to avoid any sysfs-related deadlocks. Valid events |
720 | * are PCMCIA_UEVENT_EJECT (for eject), PCMCIA_UEVENT__INSERT (for insert), |
721 | * PCMCIA_UEVENT_RESUME (for resume), PCMCIA_UEVENT_SUSPEND (for suspend) |
722 | * and PCMCIA_UEVENT_REQUERY (for re-querying the PCMCIA card). |
723 | */ |
724 | void pcmcia_parse_uevents(struct pcmcia_socket *s, u_int events) |
725 | { |
726 | unsigned long flags; |
727 | dev_dbg(&s->dev, "parse_uevents: events %08x\n" , events); |
728 | if (s->thread) { |
729 | spin_lock_irqsave(&s->thread_lock, flags); |
730 | s->sysfs_events |= events; |
731 | spin_unlock_irqrestore(lock: &s->thread_lock, flags); |
732 | |
733 | wake_up_process(tsk: s->thread); |
734 | } |
735 | } |
736 | EXPORT_SYMBOL(pcmcia_parse_uevents); |
737 | |
738 | |
739 | /* register pcmcia_callback */ |
740 | int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c) |
741 | { |
742 | int ret = 0; |
743 | |
744 | /* s->skt_mutex also protects s->callback */ |
745 | mutex_lock(&s->skt_mutex); |
746 | |
747 | if (c) { |
748 | /* registration */ |
749 | if (s->callback) { |
750 | ret = -EBUSY; |
751 | goto err; |
752 | } |
753 | |
754 | s->callback = c; |
755 | |
756 | if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) |
757 | s->callback->add(s); |
758 | } else |
759 | s->callback = NULL; |
760 | err: |
761 | mutex_unlock(lock: &s->skt_mutex); |
762 | |
763 | return ret; |
764 | } |
765 | EXPORT_SYMBOL(pccard_register_pcmcia); |
766 | |
767 | |
768 | /* I'm not sure which "reset" function this is supposed to use, |
769 | * but for now, it uses the low-level interface's reset, not the |
770 | * CIS register. |
771 | */ |
772 | |
773 | int pcmcia_reset_card(struct pcmcia_socket *skt) |
774 | { |
775 | int ret; |
776 | |
777 | dev_dbg(&skt->dev, "resetting socket\n" ); |
778 | |
779 | mutex_lock(&skt->skt_mutex); |
780 | do { |
781 | if (!(skt->state & SOCKET_PRESENT)) { |
782 | dev_dbg(&skt->dev, "can't reset, not present\n" ); |
783 | ret = -ENODEV; |
784 | break; |
785 | } |
786 | if (skt->state & SOCKET_SUSPEND) { |
787 | dev_dbg(&skt->dev, "can't reset, suspended\n" ); |
788 | ret = -EBUSY; |
789 | break; |
790 | } |
791 | if (skt->state & SOCKET_CARDBUS) { |
792 | dev_dbg(&skt->dev, "can't reset, is cardbus\n" ); |
793 | ret = -EPERM; |
794 | break; |
795 | } |
796 | |
797 | if (skt->callback) |
798 | skt->callback->suspend(skt); |
799 | mutex_lock(&skt->ops_mutex); |
800 | ret = socket_reset(skt); |
801 | mutex_unlock(lock: &skt->ops_mutex); |
802 | if ((ret == 0) && (skt->callback)) |
803 | skt->callback->resume(skt); |
804 | |
805 | ret = 0; |
806 | } while (0); |
807 | mutex_unlock(lock: &skt->skt_mutex); |
808 | |
809 | return ret; |
810 | } /* reset_card */ |
811 | EXPORT_SYMBOL(pcmcia_reset_card); |
812 | |
813 | |
814 | static int pcmcia_socket_uevent(const struct device *dev, |
815 | struct kobj_uevent_env *env) |
816 | { |
817 | const struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev); |
818 | |
819 | if (add_uevent_var(env, format: "SOCKET_NO=%u" , s->sock)) |
820 | return -ENOMEM; |
821 | |
822 | return 0; |
823 | } |
824 | |
825 | |
826 | static struct completion pcmcia_unload; |
827 | |
828 | static void pcmcia_release_socket_class(const struct class *data) |
829 | { |
830 | complete(&pcmcia_unload); |
831 | } |
832 | |
833 | |
834 | #ifdef CONFIG_PM |
835 | |
836 | static int __pcmcia_pm_op(struct device *dev, |
837 | int (*callback) (struct pcmcia_socket *skt)) |
838 | { |
839 | struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev); |
840 | int ret; |
841 | |
842 | mutex_lock(&s->skt_mutex); |
843 | ret = callback(s); |
844 | mutex_unlock(lock: &s->skt_mutex); |
845 | |
846 | return ret; |
847 | } |
848 | |
849 | static int pcmcia_socket_dev_suspend_noirq(struct device *dev) |
850 | { |
851 | return __pcmcia_pm_op(dev, callback: socket_suspend); |
852 | } |
853 | |
854 | static int pcmcia_socket_dev_resume_noirq(struct device *dev) |
855 | { |
856 | return __pcmcia_pm_op(dev, callback: socket_early_resume); |
857 | } |
858 | |
859 | static int __used pcmcia_socket_dev_resume(struct device *dev) |
860 | { |
861 | return __pcmcia_pm_op(dev, callback: socket_late_resume); |
862 | } |
863 | |
864 | static void __used pcmcia_socket_dev_complete(struct device *dev) |
865 | { |
866 | WARN(__pcmcia_pm_op(dev, socket_complete_resume), |
867 | "failed to complete resume" ); |
868 | } |
869 | |
870 | static const struct dev_pm_ops pcmcia_socket_pm_ops = { |
871 | /* dev_resume may be called with IRQs enabled */ |
872 | SET_SYSTEM_SLEEP_PM_OPS(NULL, |
873 | pcmcia_socket_dev_resume) |
874 | |
875 | /* late suspend must be called with IRQs disabled */ |
876 | .suspend_noirq = pcmcia_socket_dev_suspend_noirq, |
877 | .freeze_noirq = pcmcia_socket_dev_suspend_noirq, |
878 | .poweroff_noirq = pcmcia_socket_dev_suspend_noirq, |
879 | |
880 | /* early resume must be called with IRQs disabled */ |
881 | .resume_noirq = pcmcia_socket_dev_resume_noirq, |
882 | .thaw_noirq = pcmcia_socket_dev_resume_noirq, |
883 | .restore_noirq = pcmcia_socket_dev_resume_noirq, |
884 | .complete = pcmcia_socket_dev_complete, |
885 | }; |
886 | |
887 | #define PCMCIA_SOCKET_CLASS_PM_OPS (&pcmcia_socket_pm_ops) |
888 | |
889 | #else /* CONFIG_PM */ |
890 | |
891 | #define PCMCIA_SOCKET_CLASS_PM_OPS NULL |
892 | |
893 | #endif /* CONFIG_PM */ |
894 | |
895 | struct class pcmcia_socket_class = { |
896 | .name = "pcmcia_socket" , |
897 | .dev_uevent = pcmcia_socket_uevent, |
898 | .dev_release = pcmcia_release_socket, |
899 | .class_release = pcmcia_release_socket_class, |
900 | .pm = PCMCIA_SOCKET_CLASS_PM_OPS, |
901 | }; |
902 | EXPORT_SYMBOL(pcmcia_socket_class); |
903 | |
904 | |
905 | static int __init init_pcmcia_cs(void) |
906 | { |
907 | init_completion(x: &pcmcia_unload); |
908 | return class_register(class: &pcmcia_socket_class); |
909 | } |
910 | |
911 | static void __exit exit_pcmcia_cs(void) |
912 | { |
913 | class_unregister(class: &pcmcia_socket_class); |
914 | wait_for_completion(&pcmcia_unload); |
915 | } |
916 | |
917 | subsys_initcall(init_pcmcia_cs); |
918 | module_exit(exit_pcmcia_cs); |
919 | |
920 | |