1/* 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/string.h> 20#include <linux/major.h> 21#include <linux/errno.h> 22#include <linux/slab.h> 23#include <linux/mm.h> 24#include <linux/interrupt.h> 25#include <linux/timer.h> 26#include <linux/ioport.h> 27#include <linux/delay.h> 28#include <linux/pm.h> 29#include <linux/device.h> 30#include <linux/kthread.h> 31#include <linux/freezer.h> 32#include <asm/system.h> 33#include <asm/irq.h> 34 35#define IN_CARD_SERVICES 36#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 45 46/* Module parameters */ 47 48MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>"); 49MODULE_DESCRIPTION("Linux Kernel Card Services"); 50MODULE_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 66#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 77 78socket_state_t dead_socket = { 79 .csc_mask = SS_DETECT, 80}; 81EXPORT_SYMBOL(dead_socket); 82 83 84/* List of all sockets, protected by a rwsem */ 85LIST_HEAD(pcmcia_socket_list); 86EXPORT_SYMBOL(pcmcia_socket_list); 87 88DECLARE_RWSEM(pcmcia_socket_list_rwsem); 89EXPORT_SYMBOL(pcmcia_socket_list_rwsem); 90 91 92/** 93 * 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 97 * .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.parent != dev) 113 continue; 114 mutex_lock(&socket->skt_mutex); 115 socket_suspend(socket); 116 mutex_unlock(&socket->skt_mutex); 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.parent != dev) 131 continue; 132 mutex_lock(&socket->skt_mutex); 133 socket_resume(socket); 134 mutex_unlock(&socket->skt_mutex); 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 device *dev = get_device(&skt->dev); 146 if (!dev) 147 return NULL; 148 skt = dev_get_drvdata(dev); 149 if (!try_module_get(skt->owner)) { 150 put_device(&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 put_device(&skt->dev); 162} 163EXPORT_SYMBOL(pcmcia_put_socket); 164 165 166static void pcmcia_release_socket(struct device *dev) 167{ 168 struct pcmcia_socket *socket = dev_get_drvdata(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 struct task_struct *tsk; 181 int ret; 182 183 if (!socket || !socket->ops || !socket->dev.parent || !socket->resource_ops) 184 return -EINVAL; 185 186 cs_dbg(socket, 0, "pcmcia_register_socket(0x%p)\n", socket->ops); 187 188 spin_lock_init(&socket->lock); 189 190 if (socket->resource_ops->init) { 191 ret = socket->resource_ops->init(socket); 192 if (ret) 193 return (ret); 194 } 195 196 /* try to obtain a socket number [yes, it gets ugly if we 197 * register more than 2^sizeof(unsigned int) pcmcia 198 * sockets... but the socket number is deprecated 199 * anyways, so I don't care] */ 200 down_write(&pcmcia_socket_list_rwsem); 201 if (list_empty(&pcmcia_socket_list)) 202 socket->sock = 0; 203 else { 204 unsigned int found, i = 1; 205 struct pcmcia_socket *tmp; 206 do { 207 found = 1; 208 list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) { 209 if (tmp->sock == i) 210 found = 0; 211 } 212 i++; 213 } while (!found); 214 socket->sock = i - 1; 215 } 216 list_add_tail(&socket->socket_list, &pcmcia_socket_list); 217 up_write(&pcmcia_socket_list_rwsem); 218 219#ifndef CONFIG_CARDBUS 220 /* 221 * If we do not support Cardbus, ensure that 222 * the Cardbus socket capability is disabled. 223 */ 224 socket->features &= ~SS_CAP_CARDBUS; 225#endif 226 227 /* set proper values in socket->dev */ 228 dev_set_drvdata(&socket->dev, socket); 229 socket->dev.class = &pcmcia_socket_class; 230 snprintf(socket->dev.bus_id, BUS_ID_SIZE, "pcmcia_socket%u", socket->sock); 231 232 /* base address = 0, map = 0 */ 233 socket->cis_mem.flags = 0; 234 socket->cis_mem.speed = cis_speed; 235 236 INIT_LIST_HEAD(&socket->cis_cache); 237 238 init_completion(&socket->socket_released); 239 init_completion(&socket->thread_done); 240 init_waitqueue_head(&socket->thread_wait); 241 mutex_init(&socket->skt_mutex); 242 spin_lock_init(&socket->thread_lock); 243 244 tsk = kthread_run(pccardd, socket, "pccardd"); 245 if (IS_ERR(tsk)) { 246 ret = PTR_ERR(tsk); 247 goto err; 248 } 249 250 wait_for_completion(&socket->thread_done); 251 if (!socket->thread) { 252 printk(KERN_WARNING "PCMCIA: warning: socket thread for socket %p did not start\n", socket); 253 return -EIO; 254 } 255 256 pcmcia_parse_events(socket, SS_DETECT); 257 258 return 0; 259 260 err: 261 down_write(&pcmcia_socket_list_rwsem); 262 list_del(&socket->socket_list); 263 up_write(&pcmcia_socket_list_rwsem); 264 return ret; 265} /* pcmcia_register_socket */ 266EXPORT_SYMBOL(pcmcia_register_socket); 267 268 269/** 270 * pcmcia_unregister_socket - remove a pcmcia socket device 271 */ 272void pcmcia_unregister_socket(struct pcmcia_socket *socket) 273{ 274 if (!socket) 275 return; 276 277 cs_dbg(socket, 0, "pcmcia_unregister_socket(0x%p)\n", socket->ops); 278 279 if (socket->thread) { 280 wake_up(&socket->thread_wait); 281 kthread_stop(socket->thread); 282 } 283 release_cis_mem(socket); 284 285 /* remove from our own list */ 286 down_write(&pcmcia_socket_list_rwsem); 287 list_del(&socket->socket_list); 288 up_write(&pcmcia_socket_list_rwsem); 289 290 /* wait for sysfs to drop all references */ 291 release_resource_db(socket); 292 wait_for_completion(&socket->socket_released); 293} /* pcmcia_unregister_socket */ 294EXPORT_SYMBOL(pcmcia_unregister_socket); 295 296 297struct pcmcia_socket * pcmcia_get_socket_by_nr(unsigned int nr) 298{ 299 struct pcmcia_socket *s; 300 301 down_read(&pcmcia_socket_list_rwsem); 302 list_for_each_entry(s, &pcmcia_socket_list, socket_list) 303 if (s->sock == nr) { 304 up_read(&pcmcia_socket_list_rwsem); 305 return s; 306 } 307 up_read(&pcmcia_socket_list_rwsem); 308 309 return NULL; 310 311} 312EXPORT_SYMBOL(pcmcia_get_socket_by_nr); 313 314/** 315 * The central event handler. Send_event() sends an event to the 316 * 16-bit subsystem, which then calls the relevant device drivers. 317 * Parse_events() interprets the event bits from 318 * a card status change report. Do_shutdown() handles the high 319 * priority stuff associated with a card removal. 320 */ 321 322/* NOTE: send_event needs to be called with skt->sem held. */ 323 324static int send_event(struct pcmcia_socket *s, event_t event, int priority) 325{ 326 int ret; 327 328 if (s->state & SOCKET_CARDBUS) 329 return 0; 330 331 cs_dbg(s, 1, "send_event(event %d, pri %d, callback 0x%p)\n", 332 event, priority, s->callback); 333 334 if (!s->callback) 335 return 0; 336 if (!try_module_get(s->callback->owner)) 337 return 0; 338 339 ret = s->callback->event(s, event, priority); 340 341 module_put(s->callback->owner); 342 343 return ret; 344} 345 346static void socket_remove_drivers(struct pcmcia_socket *skt) 347{ 348 cs_dbg(skt, 4, "remove_drivers\n"); 349 350 send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH); 351} 352 353static int socket_reset(struct pcmcia_socket *skt) 354{ 355 int status, i; 356 357 cs_dbg(skt, 4, "reset\n"); 358 359 skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET; 360 skt->ops->set_socket(skt, &skt->socket); 361 udelay((long)reset_time); 362 363 skt->socket.flags &= ~SS_RESET; 364 skt->ops->set_socket(skt, &skt->socket); 365 366 msleep(unreset_delay * 10); 367 for (i = 0; i < unreset_limit; i++) { 368 skt->ops->get_status(skt, &status); 369 370 if (!(status & SS_DETECT)) 371 return CS_NO_CARD; 372 373 if (status & SS_READY) 374 return CS_SUCCESS; 375 376 msleep(unreset_check * 10); 377 } 378 379 cs_err(skt, "time out after reset.\n"); 380 return CS_GENERAL_FAILURE; 381} 382 383/** 384 * socket_setup() and socket_shutdown() are called by the main event handler 385 * when card insertion and removal events are received. 386 * socket_setup() turns on socket power and resets the socket, in two stages. 387 * socket_shutdown() unconfigures a socket and turns off socket power. 388 */ 389static void socket_shutdown(struct pcmcia_socket *s) 390{ 391 int status; 392 393 cs_dbg(s, 4, "shutdown\n"); 394 395 socket_remove_drivers(s); 396 s->state &= SOCKET_INUSE | SOCKET_PRESENT; 397 msleep(shutdown_delay * 10); 398 s->state &= SOCKET_INUSE; 399 400 /* Blank out the socket state */ 401 s->socket = dead_socket; 402 s->ops->init(s); 403 s->ops->set_socket(s, &s->socket); 404 s->irq.AssignedIRQ = s->irq.Config = 0; 405 s->lock_count = 0; 406 destroy_cis_cache(s); 407#ifdef CONFIG_CARDBUS 408 cb_free(s); 409#endif 410 s->functions = 0; 411 412 s->ops->get_status(s, &status); 413 if (status & SS_POWERON) { 414 printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s); 415 } 416 417 cs_socket_put(s); 418} 419 420static int socket_setup(struct pcmcia_socket *skt, int initial_delay) 421{ 422 int status, i; 423 424 cs_dbg(skt, 4, "setup\n"); 425 426 skt->ops->get_status(skt, &status); 427 if (!(status & SS_DETECT)) 428 return CS_NO_CARD; 429 430 msleep(initial_delay * 10); 431 432 for (i = 0; i < 100; i++) { 433 skt->ops->get_status(skt, &status); 434 if (!(status & SS_DETECT)) 435 return CS_NO_CARD; 436 437 if (!(status & SS_PENDING)) 438 break; 439 440 msleep(100); 441 } 442 443 if (status & SS_PENDING) { 444 cs_err(skt, "voltage interrogation timed out.\n"); 445 return CS_GENERAL_FAILURE; 446 } 447 448 if (status & SS_CARDBUS) { 449 if (!(skt->features & SS_CAP_CARDBUS)) { 450 cs_err(skt, "cardbus cards are not supported.\n"); 451 return CS_BAD_TYPE; 452 } 453 skt->state |= SOCKET_CARDBUS; 454 } 455 456 /* 457 * Decode the card voltage requirements, and apply power to the card. 458 */ 459 if (status & SS_3VCARD) 460 skt->socket.Vcc = skt->socket.Vpp = 33; 461 else if (!(status & SS_XVCARD)) 462 skt->socket.Vcc = skt->socket.Vpp = 50; 463 else { 464 cs_err(skt, "unsupported voltage key.\n"); 465 return CS_BAD_TYPE; 466 } 467 468 if (skt->power_hook) 469 skt->power_hook(skt, HOOK_POWER_PRE); 470 471 skt->socket.flags = 0; 472 skt->ops->set_socket(skt, &skt->socket); 473 474 /* 475 * Wait "vcc_settle" for the supply to stabilise. 476 */ 477 msleep(vcc_settle * 10); 478 479 skt->ops->get_status(skt, &status); 480 if (!(status & SS_POWERON)) { 481 cs_err(skt, "unable to apply power.\n"); 482 return CS_BAD_TYPE; 483 } 484 485 status = socket_reset(skt); 486 487 if (skt->power_hook) 488 skt->power_hook(skt, HOOK_POWER_POST); 489 490 return status; 491} 492 493/* 494 * Handle card insertion. Setup the socket, reset the card, 495 * and then tell the rest of PCMCIA that a card is present. 496 */ 497static int socket_insert(struct pcmcia_socket *skt) 498{ 499 int ret; 500 501 cs_dbg(skt, 4, "insert\n"); 502 503 if (!cs_socket_get(skt)) 504 return CS_NO_CARD; 505 506 ret = socket_setup(skt, setup_delay); 507 if (ret == CS_SUCCESS) { 508 skt->state |= SOCKET_PRESENT; 509 510 printk(KERN_NOTICE "pccard: %s card inserted into slot %d\n", 511 (skt->state & SOCKET_CARDBUS) ? "CardBus" : "PCMCIA", 512 skt->sock); 513 514#ifdef CONFIG_CARDBUS 515 if (skt->state & SOCKET_CARDBUS) { 516 cb_alloc(skt); 517 skt->state |= SOCKET_CARDBUS_CONFIG; 518 } 519#endif 520 cs_dbg(skt, 4, "insert done\n"); 521 522 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW); 523 } else { 524 socket_shutdown(skt); 525 } 526 527 return ret; 528} 529 530static int socket_suspend(struct pcmcia_socket *skt) 531{ 532 if (skt->state & SOCKET_SUSPEND) 533 return CS_IN_USE; 534 535 send_event(skt, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW); 536 skt->socket = dead_socket; 537 skt->ops->set_socket(skt, &skt->socket); 538 if (skt->ops->suspend) 539 skt->ops->suspend(skt); 540 skt->state |= SOCKET_SUSPEND; 541 542 return CS_SUCCESS; 543} 544 545/* 546 * Resume a socket. If a card is present, verify its CIS against 547 * our cached copy. If they are different, the card has been 548 * replaced, and we need to tell the drivers. 549 */ 550static int socket_resume(struct pcmcia_socket *skt) 551{ 552 int ret; 553 554 if (!(skt->state & SOCKET_SUSPEND)) 555 return CS_IN_USE; 556 557 skt->socket = dead_socket; 558 skt->ops->init(skt); 559 skt->ops->set_socket(skt, &skt->socket); 560 561 if (!(skt->state & SOCKET_PRESENT)) { 562 skt->state &= ~SOCKET_SUSPEND; 563 return socket_insert(skt); 564 } 565 566 ret = socket_setup(skt, resume_delay); 567 if (ret == CS_SUCCESS) { 568 if (verify_cis_cache(skt) != 0) { 569 cs_dbg(skt, 4, "cis mismatch - different card\n"); 570 socket_remove_drivers(skt); 571 destroy_cis_cache(skt); 572 msleep(200); 573 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW); 574 } else { 575 cs_dbg(skt, 4, "cis matches cache\n"); 576 send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW); 577 } 578 } else { 579 socket_shutdown(skt); 580 } 581 582 skt->state &= ~SOCKET_SUSPEND; 583 584 return CS_SUCCESS; 585} 586 587static void socket_remove(struct pcmcia_socket *skt) 588{ 589 printk(KERN_NOTICE "pccard: card ejected from slot %d\n", skt->sock); 590 socket_shutdown(skt); 591} 592 593/* 594 * Process a socket card detect status change. 595 * 596 * If we don't have a card already present, delay the detect event for 597 * about 20ms (to be on the safe side) before reading the socket status. 598 * 599 * Some i82365-based systems send multiple SS_DETECT events during card 600 * insertion, and the "card present" status bit seems to bounce. This 601 * will probably be true with GPIO-based card detection systems after 602 * the product has aged. 603 */ 604static void socket_detect_change(struct pcmcia_socket *skt) 605{ 606 if (!(skt->state & SOCKET_SUSPEND)) { 607 int status; 608 609 if (!(skt->state & SOCKET_PRESENT)) 610 msleep(20); 611 612 skt->ops->get_status(skt, &status); 613 if ((skt->state & SOCKET_PRESENT) && 614 !(status & SS_DETECT)) 615 socket_remove(skt); 616 if (!(skt->state & SOCKET_PRESENT) && 617 (status & SS_DETECT)) 618 socket_insert(skt); 619 } 620} 621 622static int pccardd(void *__skt) 623{ 624 struct pcmcia_socket *skt = __skt; 625 DECLARE_WAITQUEUE(wait, current); 626 int ret; 627 628 skt->thread = current; 629 skt->socket = dead_socket; 630 skt->ops->init(skt); 631 skt->ops->set_socket(skt, &skt->socket); 632 633 /* register with the device core */ 634 ret = device_register(&skt->dev); 635 if (ret) { 636 printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n", 637 skt); 638 skt->thread = NULL; 639 complete(&skt->thread_done); 640 return 0; 641 } 642 643 add_wait_queue(&skt->thread_wait, &wait); 644 complete(&skt->thread_done); 645 646 for (;;) { 647 unsigned long flags; 648 unsigned int events; 649 650 set_current_state(TASK_INTERRUPTIBLE); 651 652 spin_lock_irqsave(&skt->thread_lock, flags); 653 events = skt->thread_events; 654 skt->thread_events = 0; 655 spin_unlock_irqrestore(&skt->thread_lock, flags); 656 657 if (events) { 658 mutex_lock(&skt->skt_mutex); 659 if (events & SS_DETECT) 660 socket_detect_change(skt); 661 if (events & SS_BATDEAD) 662 send_event(skt, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW); 663 if (events & SS_BATWARN) 664 send_event(skt, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW); 665 if (events & SS_READY) 666 send_event(skt, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW); 667 mutex_unlock(&skt->skt_mutex); 668 continue; 669 } 670 671 if (kthread_should_stop()) 672 break; 673 674 schedule(); 675 try_to_freeze(); 676 } 677 /* make sure we are running before we exit */ 678 set_current_state(TASK_RUNNING); 679 680 remove_wait_queue(&skt->thread_wait, &wait); 681 682 /* remove from the device core */ 683 device_unregister(&skt->dev); 684 685 return 0; 686} 687 688/* 689 * Yenta (at least) probes interrupts before registering the socket and 690 * starting the handler thread. 691 */ 692void pcmcia_parse_events(struct pcmcia_socket *s, u_int events) 693{ 694 unsigned long flags; 695 cs_dbg(s, 4, "parse_events: events %08x\n", events); 696 if (s->thread) { 697 spin_lock_irqsave(&s->thread_lock, flags); 698 s->thread_events |= events; 699 spin_unlock_irqrestore(&s->thread_lock, flags); 700 701 wake_up(&s->thread_wait); 702 } 703} /* pcmcia_parse_events */ 704EXPORT_SYMBOL(pcmcia_parse_events); 705 706 707/* register pcmcia_callback */ 708int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c) 709{ 710 int ret = 0; 711 712 /* s->skt_mutex also protects s->callback */ 713 mutex_lock(&s->skt_mutex); 714 715 if (c) { 716 /* registration */ 717 if (s->callback) { 718 ret = -EBUSY; 719 goto err; 720 } 721 722 s->callback = c; 723 724 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) 725 send_event(s, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW); 726 } else 727 s->callback = NULL; 728 err: 729 mutex_unlock(&s->skt_mutex); 730 731 return ret; 732} 733EXPORT_SYMBOL(pccard_register_pcmcia); 734 735 736/* I'm not sure which "reset" function this is supposed to use, 737 * but for now, it uses the low-level interface's reset, not the 738 * CIS register. 739 */ 740 741int pccard_reset_card(struct pcmcia_socket *skt) 742{ 743 int ret; 744 745 cs_dbg(skt, 1, "resetting socket\n"); 746 747 mutex_lock(&skt->skt_mutex); 748 do { 749 if (!(skt->state & SOCKET_PRESENT)) { 750 ret = CS_NO_CARD; 751 break; 752 } 753 if (skt->state & SOCKET_SUSPEND) { 754 ret = CS_IN_USE; 755 break; 756 } 757 if (skt->state & SOCKET_CARDBUS) { 758 ret = CS_UNSUPPORTED_FUNCTION; 759 break; 760 } 761 762 ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW); 763 if (ret == 0) { 764 send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW); 765 if (skt->callback) 766 skt->callback->suspend(skt); 767 if (socket_reset(skt) == CS_SUCCESS) { 768 send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW); 769 if (skt->callback) 770 skt->callback->resume(skt); 771 } 772 } 773 774 ret = CS_SUCCESS; 775 } while (0); 776 mutex_unlock(&skt->skt_mutex); 777 778 return ret; 779} /* reset_card */ 780EXPORT_SYMBOL(pccard_reset_card); 781 782 783/* These shut down or wake up a socket. They are sort of user 784 * initiated versions of the APM suspend and resume actions. 785 */ 786int pcmcia_suspend_card(struct pcmcia_socket *skt) 787{ 788 int ret; 789 790 cs_dbg(skt, 1, "suspending socket\n"); 791 792 mutex_lock(&skt->skt_mutex); 793 do { 794 if (!(skt->state & SOCKET_PRESENT)) { 795 ret = CS_NO_CARD; 796 break; 797 } 798 if (skt->state & SOCKET_CARDBUS) { 799 ret = CS_UNSUPPORTED_FUNCTION; 800 break; 801 } 802 if (skt->callback) { 803 ret = skt->callback->suspend(skt); 804 if (ret) 805 break; 806 } 807 ret = socket_suspend(skt); 808 } while (0); 809 mutex_unlock(&skt->skt_mutex); 810 811 return ret; 812} /* suspend_card */ 813EXPORT_SYMBOL(pcmcia_suspend_card); 814 815 816int pcmcia_resume_card(struct pcmcia_socket *skt) 817{ 818 int ret; 819 820 cs_dbg(skt, 1, "waking up socket\n"); 821 822 mutex_lock(&skt->skt_mutex); 823 do { 824 if (!(skt->state & SOCKET_PRESENT)) { 825 ret = CS_NO_CARD; 826 break; 827 } 828 if (skt->state & SOCKET_CARDBUS) { 829 ret = CS_UNSUPPORTED_FUNCTION; 830 break; 831 } 832 ret = socket_resume(skt); 833 if (!ret && skt->callback) 834 skt->callback->resume(skt); 835 } while (0); 836 mutex_unlock(&skt->skt_mutex); 837 838 return ret; 839} /* resume_card */ 840EXPORT_SYMBOL(pcmcia_resume_card); 841 842 843/* These handle user requests to eject or insert a card. */ 844int pcmcia_eject_card(struct pcmcia_socket *skt) 845{ 846 int ret; 847 848 cs_dbg(skt, 1, "user eject request\n"); 849 850 mutex_lock(&skt->skt_mutex); 851 do { 852 if (!(skt->state & SOCKET_PRESENT)) { 853 ret = -ENODEV; 854 break; 855 } 856 857 ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW); 858 if (ret != 0) { 859 ret = -EINVAL; 860 break; 861 } 862 863 socket_remove(skt); 864 ret = 0; 865 } while (0); 866 mutex_unlock(&skt->skt_mutex); 867 868 return ret; 869} /* eject_card */ 870EXPORT_SYMBOL(pcmcia_eject_card); 871 872 873int pcmcia_insert_card(struct pcmcia_socket *skt) 874{ 875 int ret; 876 877 cs_dbg(skt, 1, "user insert request\n"); 878 879 mutex_lock(&skt->skt_mutex); 880 do { 881 if (skt->state & SOCKET_PRESENT) { 882 ret = -EBUSY; 883 break; 884 } 885 if (socket_insert(skt) == CS_NO_CARD) { 886 ret = -ENODEV; 887 break; 888 } 889 ret = 0; 890 } while (0); 891 mutex_unlock(&skt->skt_mutex); 892 893 return ret; 894} /* insert_card */ 895EXPORT_SYMBOL(pcmcia_insert_card); 896 897 898static int pcmcia_socket_uevent(struct device *dev, char **envp, 899 int num_envp, char *buffer, int buffer_size) 900{ 901 struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev); 902 int i = 0, length = 0; 903 904 if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, 905 &length, "SOCKET_NO=%u", s->sock)) 906 return -ENOMEM; 907 908 envp[i] = NULL; 909 910 return 0; 911} 912 913 914static struct completion pcmcia_unload; 915 916static void pcmcia_release_socket_class(struct class *data) 917{ 918 complete(&pcmcia_unload); 919} 920 921 922struct class pcmcia_socket_class = { 923 .name = "pcmcia_socket", 924 .dev_uevent = pcmcia_socket_uevent, 925 .dev_release = pcmcia_release_socket, 926 .class_release = pcmcia_release_socket_class, 927}; 928EXPORT_SYMBOL(pcmcia_socket_class); 929 930 931static int __init init_pcmcia_cs(void) 932{ 933 int ret; 934 935 init_completion(&pcmcia_unload); 936 ret = class_register(&pcmcia_socket_class); 937 if (ret) 938 return (ret); 939 return class_interface_register(&pccard_sysfs_interface); 940} 941 942static void __exit exit_pcmcia_cs(void) 943{ 944 class_interface_unregister(&pccard_sysfs_interface); 945 class_unregister(&pcmcia_socket_class); 946 947 wait_for_completion(&pcmcia_unload); 948} 949 950subsys_initcall(init_pcmcia_cs); 951module_exit(exit_pcmcia_cs); 952