blob: fabd3529cebcb035e56769354986c99e561ecb08 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * cs.c -- Kernel Card Services - core services
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * The initial developer of the original code is David A. Hinds
9 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
10 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
11 *
12 * (C) 1999 David A. Hinds
13 */
14
15#include <linux/module.h>
16#include <linux/moduleparam.h>
17#include <linux/init.h>
18#include <linux/kernel.h>
19#include <linux/config.h>
20#include <linux/string.h>
21#include <linux/major.h>
22#include <linux/errno.h>
23#include <linux/slab.h>
24#include <linux/mm.h>
25#include <linux/interrupt.h>
26#include <linux/timer.h>
27#include <linux/ioport.h>
28#include <linux/delay.h>
29#include <linux/pm.h>
30#include <linux/pci.h>
31#include <linux/device.h>
32#include <asm/system.h>
33#include <asm/irq.h>
34
35#define IN_CARD_SERVICES
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <pcmcia/cs_types.h>
37#include <pcmcia/ss.h>
38#include <pcmcia/cs.h>
39#include <pcmcia/bulkmem.h>
40#include <pcmcia/cistpl.h>
41#include <pcmcia/cisreg.h>
42#include <pcmcia/ds.h>
43#include "cs_internal.h"
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46/* Module parameters */
47
48MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
Dominik Brodowski33519dd2005-06-27 16:28:53 -070049MODULE_DESCRIPTION("Linux Kernel Card Services");
Linus Torvalds1da177e2005-04-16 15:20:36 -070050MODULE_LICENSE("GPL");
51
52#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
53
54INT_MODULE_PARM(setup_delay, 10); /* centiseconds */
55INT_MODULE_PARM(resume_delay, 20); /* centiseconds */
56INT_MODULE_PARM(shutdown_delay, 3); /* centiseconds */
57INT_MODULE_PARM(vcc_settle, 40); /* centiseconds */
58INT_MODULE_PARM(reset_time, 10); /* usecs */
59INT_MODULE_PARM(unreset_delay, 10); /* centiseconds */
60INT_MODULE_PARM(unreset_check, 10); /* centiseconds */
61INT_MODULE_PARM(unreset_limit, 30); /* unreset_check's */
62
63/* Access speed for attribute memory windows */
64INT_MODULE_PARM(cis_speed, 300); /* ns */
65
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#ifdef DEBUG
67static int pc_debug;
68
69module_param(pc_debug, int, 0644);
70
71int cs_debug_level(int level)
72{
73 return pc_debug > level;
74}
75#endif
76
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78socket_state_t dead_socket = {
79 .csc_mask = SS_DETECT,
80};
Dominik Brodowski33519dd2005-06-27 16:28:53 -070081EXPORT_SYMBOL(dead_socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83
84/* List of all sockets, protected by a rwsem */
85LIST_HEAD(pcmcia_socket_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086EXPORT_SYMBOL(pcmcia_socket_list);
Dominik Brodowski33519dd2005-06-27 16:28:53 -070087
88DECLARE_RWSEM(pcmcia_socket_list_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089EXPORT_SYMBOL(pcmcia_socket_list_rwsem);
90
91
Linus Torvalds1da177e2005-04-16 15:20:36 -070092/**
Dominik Brodowski33519dd2005-06-27 16:28:53 -070093 * Low-level PCMCIA socket drivers need to register with the PCCard
94 * core using pcmcia_register_socket.
95 *
96 * socket drivers are expected to use the following callbacks in their
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 * .drv struct:
98 * - pcmcia_socket_dev_suspend
99 * - pcmcia_socket_dev_resume
100 * These functions check for the appropriate struct pcmcia_soket arrays,
101 * and pass them to the low-level functions pcmcia_{suspend,resume}_socket
102 */
103static int socket_resume(struct pcmcia_socket *skt);
104static int socket_suspend(struct pcmcia_socket *skt);
105
106int pcmcia_socket_dev_suspend(struct device *dev, pm_message_t state)
107{
108 struct pcmcia_socket *socket;
109
110 down_read(&pcmcia_socket_list_rwsem);
111 list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
112 if (socket->dev.dev != dev)
113 continue;
114 down(&socket->skt_sem);
115 socket_suspend(socket);
116 up(&socket->skt_sem);
117 }
118 up_read(&pcmcia_socket_list_rwsem);
119
120 return 0;
121}
122EXPORT_SYMBOL(pcmcia_socket_dev_suspend);
123
124int pcmcia_socket_dev_resume(struct device *dev)
125{
126 struct pcmcia_socket *socket;
127
128 down_read(&pcmcia_socket_list_rwsem);
129 list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
130 if (socket->dev.dev != dev)
131 continue;
132 down(&socket->skt_sem);
133 socket_resume(socket);
134 up(&socket->skt_sem);
135 }
136 up_read(&pcmcia_socket_list_rwsem);
137
138 return 0;
139}
140EXPORT_SYMBOL(pcmcia_socket_dev_resume);
141
142
143struct pcmcia_socket * pcmcia_get_socket(struct pcmcia_socket *skt)
144{
145 struct class_device *cl_dev = class_device_get(&skt->dev);
146 if (!cl_dev)
147 return NULL;
148 skt = class_get_devdata(cl_dev);
149 if (!try_module_get(skt->owner)) {
150 class_device_put(&skt->dev);
151 return NULL;
152 }
153 return (skt);
154}
155EXPORT_SYMBOL(pcmcia_get_socket);
156
157
158void pcmcia_put_socket(struct pcmcia_socket *skt)
159{
160 module_put(skt->owner);
161 class_device_put(&skt->dev);
162}
163EXPORT_SYMBOL(pcmcia_put_socket);
164
165
166static void pcmcia_release_socket(struct class_device *class_dev)
167{
168 struct pcmcia_socket *socket = class_get_devdata(class_dev);
169
170 complete(&socket->socket_released);
171}
172
173static int pccardd(void *__skt);
174
175/**
176 * pcmcia_register_socket - add a new pcmcia socket device
177 */
178int pcmcia_register_socket(struct pcmcia_socket *socket)
179{
180 int ret;
181
182 if (!socket || !socket->ops || !socket->dev.dev || !socket->resource_ops)
183 return -EINVAL;
184
185 cs_dbg(socket, 0, "pcmcia_register_socket(0x%p)\n", socket->ops);
186
187 spin_lock_init(&socket->lock);
188
189 if (socket->resource_ops->init) {
190 ret = socket->resource_ops->init(socket);
191 if (ret)
192 return (ret);
193 }
194
195 /* try to obtain a socket number [yes, it gets ugly if we
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700196 * register more than 2^sizeof(unsigned int) pcmcia
197 * sockets... but the socket number is deprecated
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 * anyways, so I don't care] */
199 down_write(&pcmcia_socket_list_rwsem);
200 if (list_empty(&pcmcia_socket_list))
201 socket->sock = 0;
202 else {
203 unsigned int found, i = 1;
204 struct pcmcia_socket *tmp;
205 do {
206 found = 1;
207 list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) {
208 if (tmp->sock == i)
209 found = 0;
210 }
211 i++;
212 } while (!found);
213 socket->sock = i - 1;
214 }
215 list_add_tail(&socket->socket_list, &pcmcia_socket_list);
216 up_write(&pcmcia_socket_list_rwsem);
217
Russell King5bc6b682005-07-07 17:59:07 -0700218#ifndef CONFIG_CARDBUS
219 /*
220 * If we do not support Cardbus, ensure that
221 * the Cardbus socket capability is disabled.
222 */
223 socket->features &= ~SS_CAP_CARDBUS;
224#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226 /* set proper values in socket->dev */
227 socket->dev.class_data = socket;
228 socket->dev.class = &pcmcia_socket_class;
229 snprintf(socket->dev.class_id, BUS_ID_SIZE, "pcmcia_socket%u", socket->sock);
230
231 /* base address = 0, map = 0 */
232 socket->cis_mem.flags = 0;
233 socket->cis_mem.speed = cis_speed;
234
235 INIT_LIST_HEAD(&socket->cis_cache);
236
237 init_completion(&socket->socket_released);
238 init_completion(&socket->thread_done);
239 init_waitqueue_head(&socket->thread_wait);
240 init_MUTEX(&socket->skt_sem);
241 spin_lock_init(&socket->thread_lock);
242
243 ret = kernel_thread(pccardd, socket, CLONE_KERNEL);
244 if (ret < 0)
245 goto err;
246
247 wait_for_completion(&socket->thread_done);
248 if(!socket->thread) {
249 printk(KERN_WARNING "PCMCIA: warning: socket thread for socket %p did not start\n", socket);
250 return -EIO;
251 }
252 pcmcia_parse_events(socket, SS_DETECT);
253
254 return 0;
255
256 err:
257 down_write(&pcmcia_socket_list_rwsem);
258 list_del(&socket->socket_list);
259 up_write(&pcmcia_socket_list_rwsem);
260 return ret;
261} /* pcmcia_register_socket */
262EXPORT_SYMBOL(pcmcia_register_socket);
263
264
265/**
266 * pcmcia_unregister_socket - remove a pcmcia socket device
267 */
268void pcmcia_unregister_socket(struct pcmcia_socket *socket)
269{
270 if (!socket)
271 return;
272
273 cs_dbg(socket, 0, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
274
275 if (socket->thread) {
276 init_completion(&socket->thread_done);
277 socket->thread = NULL;
278 wake_up(&socket->thread_wait);
279 wait_for_completion(&socket->thread_done);
280 }
281 release_cis_mem(socket);
282
283 /* remove from our own list */
284 down_write(&pcmcia_socket_list_rwsem);
285 list_del(&socket->socket_list);
286 up_write(&pcmcia_socket_list_rwsem);
287
288 /* wait for sysfs to drop all references */
289 release_resource_db(socket);
290 wait_for_completion(&socket->socket_released);
291} /* pcmcia_unregister_socket */
292EXPORT_SYMBOL(pcmcia_unregister_socket);
293
294
295struct pcmcia_socket * pcmcia_get_socket_by_nr(unsigned int nr)
296{
297 struct pcmcia_socket *s;
298
299 down_read(&pcmcia_socket_list_rwsem);
300 list_for_each_entry(s, &pcmcia_socket_list, socket_list)
301 if (s->sock == nr) {
302 up_read(&pcmcia_socket_list_rwsem);
303 return s;
304 }
305 up_read(&pcmcia_socket_list_rwsem);
306
307 return NULL;
308
309}
310EXPORT_SYMBOL(pcmcia_get_socket_by_nr);
311
312
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700313/**
314 * socket_setup() and shutdown_socket() are called by the main event
315 * handler when card insertion and removal events are received.
316 * socket_setup() turns on socket power and resets the socket, in two stages.
317 * shutdown_socket() unconfigures a socket and turns off socket power.
318 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319static void shutdown_socket(struct pcmcia_socket *s)
320{
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700321 cs_dbg(s, 1, "shutdown_socket\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700323 /* Blank out the socket state */
324 s->socket = dead_socket;
325 s->ops->init(s);
326 s->ops->set_socket(s, &s->socket);
327 s->irq.AssignedIRQ = s->irq.Config = 0;
328 s->lock_count = 0;
329 destroy_cis_cache(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330#ifdef CONFIG_CARDBUS
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700331 cb_free(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332#endif
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700333 s->functions = 0;
334 if (s->config) {
335 kfree(s->config);
336 s->config = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 }
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700338
339 {
340 int status;
341 s->ops->get_status(s, &status);
342 if (status & SS_POWERON) {
343 printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s);
344 }
345 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346} /* shutdown_socket */
347
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700349/**
350 * The central event handler. Send_event() sends an event to the
351 * 16-bit subsystem, which then calls the relevant device drivers.
352 * Parse_events() interprets the event bits from
353 * a card status change report. Do_shutdown() handles the high
354 * priority stuff associated with a card removal.
355 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
357/* NOTE: send_event needs to be called with skt->sem held. */
358
359static int send_event(struct pcmcia_socket *s, event_t event, int priority)
360{
361 int ret;
362
363 if (s->state & SOCKET_CARDBUS)
364 return 0;
365
366 cs_dbg(s, 1, "send_event(event %d, pri %d, callback 0x%p)\n",
367 event, priority, s->callback);
368
369 if (!s->callback)
370 return 0;
371 if (!try_module_get(s->callback->owner))
372 return 0;
373
374 ret = s->callback->event(s, event, priority);
375
376 module_put(s->callback->owner);
377
378 return ret;
379}
380
381static void socket_remove_drivers(struct pcmcia_socket *skt)
382{
383 cs_dbg(skt, 4, "remove_drivers\n");
384
385 send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
386}
387
388static void socket_shutdown(struct pcmcia_socket *skt)
389{
390 cs_dbg(skt, 4, "shutdown\n");
391
392 socket_remove_drivers(skt);
393 skt->state &= SOCKET_INUSE|SOCKET_PRESENT;
394 msleep(shutdown_delay * 10);
395 skt->state &= SOCKET_INUSE;
396 shutdown_socket(skt);
397}
398
399static int socket_reset(struct pcmcia_socket *skt)
400{
401 int status, i;
402
403 cs_dbg(skt, 4, "reset\n");
404
405 skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
406 skt->ops->set_socket(skt, &skt->socket);
407 udelay((long)reset_time);
408
409 skt->socket.flags &= ~SS_RESET;
410 skt->ops->set_socket(skt, &skt->socket);
411
412 msleep(unreset_delay * 10);
413 for (i = 0; i < unreset_limit; i++) {
414 skt->ops->get_status(skt, &status);
415
416 if (!(status & SS_DETECT))
417 return CS_NO_CARD;
418
419 if (status & SS_READY)
420 return CS_SUCCESS;
421
422 msleep(unreset_check * 10);
423 }
424
425 cs_err(skt, "time out after reset.\n");
426 return CS_GENERAL_FAILURE;
427}
428
429static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
430{
431 int status, i;
432
433 cs_dbg(skt, 4, "setup\n");
434
435 skt->ops->get_status(skt, &status);
436 if (!(status & SS_DETECT))
437 return CS_NO_CARD;
438
439 msleep(initial_delay * 10);
440
441 for (i = 0; i < 100; i++) {
442 skt->ops->get_status(skt, &status);
443 if (!(status & SS_DETECT))
444 return CS_NO_CARD;
445
446 if (!(status & SS_PENDING))
447 break;
448
449 msleep(100);
450 }
451
452 if (status & SS_PENDING) {
453 cs_err(skt, "voltage interrogation timed out.\n");
454 return CS_GENERAL_FAILURE;
455 }
456
457 if (status & SS_CARDBUS) {
Russell King5bc6b682005-07-07 17:59:07 -0700458 if (!(skt->features & SS_CAP_CARDBUS)) {
459 cs_err(skt, "cardbus cards are not supported.\n");
460 return CS_BAD_TYPE;
461 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 skt->state |= SOCKET_CARDBUS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 }
464
465 /*
466 * Decode the card voltage requirements, and apply power to the card.
467 */
468 if (status & SS_3VCARD)
469 skt->socket.Vcc = skt->socket.Vpp = 33;
470 else if (!(status & SS_XVCARD))
471 skt->socket.Vcc = skt->socket.Vpp = 50;
472 else {
473 cs_err(skt, "unsupported voltage key.\n");
474 return CS_BAD_TYPE;
475 }
Daniel Ritzfa912bc2005-06-23 00:10:12 -0700476
477 if (skt->power_hook)
478 skt->power_hook(skt, HOOK_POWER_PRE);
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 skt->socket.flags = 0;
481 skt->ops->set_socket(skt, &skt->socket);
482
483 /*
484 * Wait "vcc_settle" for the supply to stabilise.
485 */
486 msleep(vcc_settle * 10);
487
488 skt->ops->get_status(skt, &status);
489 if (!(status & SS_POWERON)) {
490 cs_err(skt, "unable to apply power.\n");
491 return CS_BAD_TYPE;
492 }
493
Daniel Ritzfa912bc2005-06-23 00:10:12 -0700494 status = socket_reset(skt);
495
496 if (skt->power_hook)
497 skt->power_hook(skt, HOOK_POWER_POST);
498
499 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500}
501
502/*
503 * Handle card insertion. Setup the socket, reset the card,
504 * and then tell the rest of PCMCIA that a card is present.
505 */
506static int socket_insert(struct pcmcia_socket *skt)
507{
508 int ret;
509
510 cs_dbg(skt, 4, "insert\n");
511
512 if (!cs_socket_get(skt))
513 return CS_NO_CARD;
514
515 ret = socket_setup(skt, setup_delay);
516 if (ret == CS_SUCCESS) {
517 skt->state |= SOCKET_PRESENT;
518#ifdef CONFIG_CARDBUS
519 if (skt->state & SOCKET_CARDBUS) {
520 cb_alloc(skt);
521 skt->state |= SOCKET_CARDBUS_CONFIG;
522 }
523#endif
524 cs_dbg(skt, 4, "insert done\n");
525
526 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
527 } else {
528 socket_shutdown(skt);
529 cs_socket_put(skt);
530 }
531
532 return ret;
533}
534
535static int socket_suspend(struct pcmcia_socket *skt)
536{
537 if (skt->state & SOCKET_SUSPEND)
538 return CS_IN_USE;
539
540 send_event(skt, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
541 skt->socket = dead_socket;
542 skt->ops->set_socket(skt, &skt->socket);
543 if (skt->ops->suspend)
544 skt->ops->suspend(skt);
545 skt->state |= SOCKET_SUSPEND;
546
547 return CS_SUCCESS;
548}
549
550/*
551 * Resume a socket. If a card is present, verify its CIS against
552 * our cached copy. If they are different, the card has been
553 * replaced, and we need to tell the drivers.
554 */
555static int socket_resume(struct pcmcia_socket *skt)
556{
557 int ret;
558
559 if (!(skt->state & SOCKET_SUSPEND))
560 return CS_IN_USE;
561
562 skt->socket = dead_socket;
563 skt->ops->init(skt);
564 skt->ops->set_socket(skt, &skt->socket);
565
566 if (!(skt->state & SOCKET_PRESENT)) {
567 skt->state &= ~SOCKET_SUSPEND;
568 return socket_insert(skt);
569 }
570
571 ret = socket_setup(skt, resume_delay);
572 if (ret == CS_SUCCESS) {
573 /*
574 * FIXME: need a better check here for cardbus cards.
575 */
576 if (verify_cis_cache(skt) != 0) {
577 cs_dbg(skt, 4, "cis mismatch - different card\n");
578 socket_remove_drivers(skt);
579 destroy_cis_cache(skt);
580 /*
581 * Workaround: give DS time to schedule removal.
582 * Remove me once the 100ms delay is eliminated
583 * in ds.c
584 */
585 msleep(200);
586 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
587 } else {
588 cs_dbg(skt, 4, "cis matches cache\n");
589 send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
590 }
591 } else {
592 socket_shutdown(skt);
593 cs_socket_put(skt);
594 }
595
596 skt->state &= ~SOCKET_SUSPEND;
597
598 return CS_SUCCESS;
599}
600
601static void socket_remove(struct pcmcia_socket *skt)
602{
603 socket_shutdown(skt);
604 cs_socket_put(skt);
605}
606
607/*
608 * Process a socket card detect status change.
609 *
610 * If we don't have a card already present, delay the detect event for
611 * about 20ms (to be on the safe side) before reading the socket status.
612 *
613 * Some i82365-based systems send multiple SS_DETECT events during card
614 * insertion, and the "card present" status bit seems to bounce. This
615 * will probably be true with GPIO-based card detection systems after
616 * the product has aged.
617 */
618static void socket_detect_change(struct pcmcia_socket *skt)
619{
620 if (!(skt->state & SOCKET_SUSPEND)) {
621 int status;
622
623 if (!(skt->state & SOCKET_PRESENT))
624 msleep(20);
625
626 skt->ops->get_status(skt, &status);
627 if ((skt->state & SOCKET_PRESENT) &&
628 !(status & SS_DETECT))
629 socket_remove(skt);
630 if (!(skt->state & SOCKET_PRESENT) &&
631 (status & SS_DETECT))
632 socket_insert(skt);
633 }
634}
635
636static int pccardd(void *__skt)
637{
638 struct pcmcia_socket *skt = __skt;
639 DECLARE_WAITQUEUE(wait, current);
640 int ret;
641
642 daemonize("pccardd");
643
644 skt->thread = current;
645 skt->socket = dead_socket;
646 skt->ops->init(skt);
647 skt->ops->set_socket(skt, &skt->socket);
648
649 /* register with the device core */
650 ret = class_device_register(&skt->dev);
651 if (ret) {
652 printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n",
653 skt);
654 skt->thread = NULL;
655 complete_and_exit(&skt->thread_done, 0);
656 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
658 add_wait_queue(&skt->thread_wait, &wait);
Daniel Ritzbf4de6f2005-09-09 13:03:23 -0700659 complete(&skt->thread_done);
660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 for (;;) {
662 unsigned long flags;
663 unsigned int events;
664
665 set_current_state(TASK_INTERRUPTIBLE);
666
667 spin_lock_irqsave(&skt->thread_lock, flags);
668 events = skt->thread_events;
669 skt->thread_events = 0;
670 spin_unlock_irqrestore(&skt->thread_lock, flags);
671
672 if (events) {
673 down(&skt->skt_sem);
674 if (events & SS_DETECT)
675 socket_detect_change(skt);
676 if (events & SS_BATDEAD)
677 send_event(skt, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW);
678 if (events & SS_BATWARN)
679 send_event(skt, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW);
680 if (events & SS_READY)
681 send_event(skt, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW);
682 up(&skt->skt_sem);
683 continue;
684 }
685
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 if (!skt->thread)
687 break;
Daniel Ritzbf4de6f2005-09-09 13:03:23 -0700688
689 schedule();
690 try_to_freeze();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 }
692 remove_wait_queue(&skt->thread_wait, &wait);
693
694 /* remove from the device core */
695 class_device_unregister(&skt->dev);
696
697 complete_and_exit(&skt->thread_done, 0);
698}
699
700/*
701 * Yenta (at least) probes interrupts before registering the socket and
702 * starting the handler thread.
703 */
704void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
705{
706 cs_dbg(s, 4, "parse_events: events %08x\n", events);
707 if (s->thread) {
708 spin_lock(&s->thread_lock);
709 s->thread_events |= events;
710 spin_unlock(&s->thread_lock);
711
712 wake_up(&s->thread_wait);
713 }
714} /* pcmcia_parse_events */
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700715EXPORT_SYMBOL(pcmcia_parse_events);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
718/* register pcmcia_callback */
719int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c)
720{
721 int ret = 0;
722
723 /* s->skt_sem also protects s->callback */
724 down(&s->skt_sem);
725
726 if (c) {
727 /* registration */
728 if (s->callback) {
729 ret = -EBUSY;
730 goto err;
731 }
732
733 s->callback = c;
734
735 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT)
736 send_event(s, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
737 } else
738 s->callback = NULL;
739 err:
740 up(&s->skt_sem);
741
742 return ret;
743}
744EXPORT_SYMBOL(pccard_register_pcmcia);
745
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700747/* I'm not sure which "reset" function this is supposed to use,
748 * but for now, it uses the low-level interface's reset, not the
749 * CIS register.
750 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751
752int pccard_reset_card(struct pcmcia_socket *skt)
753{
754 int ret;
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700755
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 cs_dbg(skt, 1, "resetting socket\n");
757
758 down(&skt->skt_sem);
759 do {
760 if (!(skt->state & SOCKET_PRESENT)) {
761 ret = CS_NO_CARD;
762 break;
763 }
764 if (skt->state & SOCKET_SUSPEND) {
765 ret = CS_IN_USE;
766 break;
767 }
768 if (skt->state & SOCKET_CARDBUS) {
769 ret = CS_UNSUPPORTED_FUNCTION;
770 break;
771 }
772
773 ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
774 if (ret == 0) {
775 send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
776 if (socket_reset(skt) == CS_SUCCESS)
777 send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
778 }
779
780 ret = CS_SUCCESS;
781 } while (0);
782 up(&skt->skt_sem);
783
784 return ret;
785} /* reset_card */
786EXPORT_SYMBOL(pccard_reset_card);
787
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700789/* These shut down or wake up a socket. They are sort of user
790 * initiated versions of the APM suspend and resume actions.
791 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792int pcmcia_suspend_card(struct pcmcia_socket *skt)
793{
794 int ret;
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700795
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 cs_dbg(skt, 1, "suspending socket\n");
797
798 down(&skt->skt_sem);
799 do {
800 if (!(skt->state & SOCKET_PRESENT)) {
801 ret = CS_NO_CARD;
802 break;
803 }
804 if (skt->state & SOCKET_CARDBUS) {
805 ret = CS_UNSUPPORTED_FUNCTION;
806 break;
807 }
808 ret = socket_suspend(skt);
809 } while (0);
810 up(&skt->skt_sem);
811
812 return ret;
813} /* suspend_card */
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700814EXPORT_SYMBOL(pcmcia_suspend_card);
815
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
817int pcmcia_resume_card(struct pcmcia_socket *skt)
818{
819 int ret;
820
821 cs_dbg(skt, 1, "waking up socket\n");
822
823 down(&skt->skt_sem);
824 do {
825 if (!(skt->state & SOCKET_PRESENT)) {
826 ret = CS_NO_CARD;
827 break;
828 }
829 if (skt->state & SOCKET_CARDBUS) {
830 ret = CS_UNSUPPORTED_FUNCTION;
831 break;
832 }
833 ret = socket_resume(skt);
834 } while (0);
835 up(&skt->skt_sem);
836
837 return ret;
838} /* resume_card */
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700839EXPORT_SYMBOL(pcmcia_resume_card);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700842/* These handle user requests to eject or insert a card. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843int pcmcia_eject_card(struct pcmcia_socket *skt)
844{
845 int ret;
846
847 cs_dbg(skt, 1, "user eject request\n");
848
849 down(&skt->skt_sem);
850 do {
851 if (!(skt->state & SOCKET_PRESENT)) {
852 ret = -ENODEV;
853 break;
854 }
855
856 ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
857 if (ret != 0) {
858 ret = -EINVAL;
859 break;
860 }
861
862 socket_remove(skt);
863 ret = 0;
864 } while (0);
865 up(&skt->skt_sem);
866
867 return ret;
868} /* eject_card */
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700869EXPORT_SYMBOL(pcmcia_eject_card);
870
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
872int pcmcia_insert_card(struct pcmcia_socket *skt)
873{
874 int ret;
875
876 cs_dbg(skt, 1, "user insert request\n");
877
878 down(&skt->skt_sem);
879 do {
880 if (skt->state & SOCKET_PRESENT) {
881 ret = -EBUSY;
882 break;
883 }
884 if (socket_insert(skt) == CS_NO_CARD) {
885 ret = -ENODEV;
886 break;
887 }
888 ret = 0;
889 } while (0);
890 up(&skt->skt_sem);
891
892 return ret;
893} /* insert_card */
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700894EXPORT_SYMBOL(pcmcia_insert_card);
895
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Dominik Brodowski3ee13932005-06-27 16:28:05 -0700897static int pcmcia_socket_hotplug(struct class_device *dev, char **envp,
898 int num_envp, char *buffer, int buffer_size)
899{
900 struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev);
901 int i = 0, length = 0;
902
903 if (add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size,
904 &length, "SOCKET_NO=%u", s->sock))
905 return -ENOMEM;
906
907 envp[i] = NULL;
908
909 return 0;
910}
911
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
Dominik Brodowski378a33a2005-06-27 16:28:54 -0700913static struct completion pcmcia_unload;
914
915static void pcmcia_release_socket_class(struct class *data)
916{
917 complete(&pcmcia_unload);
918}
919
920
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921struct class pcmcia_socket_class = {
922 .name = "pcmcia_socket",
Dominik Brodowski3ee13932005-06-27 16:28:05 -0700923 .hotplug = pcmcia_socket_hotplug,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 .release = pcmcia_release_socket,
Dominik Brodowski378a33a2005-06-27 16:28:54 -0700925 .class_release = pcmcia_release_socket_class,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926};
927EXPORT_SYMBOL(pcmcia_socket_class);
928
929
930static int __init init_pcmcia_cs(void)
931{
Dominik Brodowski378a33a2005-06-27 16:28:54 -0700932 int ret;
933
934 init_completion(&pcmcia_unload);
935 ret = class_register(&pcmcia_socket_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 if (ret)
937 return (ret);
938 return class_interface_register(&pccard_sysfs_interface);
939}
940
941static void __exit exit_pcmcia_cs(void)
942{
Dominik Brodowski33519dd2005-06-27 16:28:53 -0700943 class_interface_unregister(&pccard_sysfs_interface);
944 class_unregister(&pcmcia_socket_class);
Dominik Brodowski378a33a2005-06-27 16:28:54 -0700945
946 wait_for_completion(&pcmcia_unload);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947}
948
949subsys_initcall(init_pcmcia_cs);
950module_exit(exit_pcmcia_cs);
951