1 /* 2 * ds.c -- 16-bit PCMCIA core support 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 * (C) 2003 - 2004 Dominik Brodowski 14 */ 15 16 #include <linux/config.h> 17 #include <linux/module.h> 18 #include <linux/moduleparam.h> 19 #include <linux/init.h> 20 #include <linux/kernel.h> 21 #include <linux/major.h> 22 #include <linux/string.h> 23 #include <linux/errno.h> 24 #include <linux/slab.h> 25 #include <linux/mm.h> 26 #include <linux/fcntl.h> 27 #include <linux/sched.h> 28 #include <linux/smp_lock.h> 29 #include <linux/timer.h> 30 #include <linux/ioctl.h> 31 #include <linux/proc_fs.h> 32 #include <linux/poll.h> 33 #include <linux/pci.h> 34 #include <linux/list.h> 35 #include <linux/delay.h> 36 #include <linux/kref.h> 37 #include <linux/workqueue.h> 38 #include <linux/crc32.h> 39 40 #include <asm/atomic.h> 41 42 #define IN_CARD_SERVICES 43 #include <pcmcia/version.h> 44 #include <pcmcia/cs_types.h> 45 #include <pcmcia/cs.h> 46 #include <pcmcia/bulkmem.h> 47 #include <pcmcia/cistpl.h> 48 #include <pcmcia/ds.h> 49 #include <pcmcia/ss.h> 50 51 #include "cs_internal.h" 52 53 /*====================================================================*/ 54 55 /* Module parameters */ 56 57 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>"); 58 MODULE_DESCRIPTION("PCMCIA Driver Services"); 59 MODULE_LICENSE("GPL"); 60 61 #ifdef DEBUG 62 int ds_pc_debug; 63 64 module_param_named(pc_debug, ds_pc_debug, int, 0644); 65 66 #define ds_dbg(lvl, fmt, arg...) do { \ 67 if (ds_pc_debug > (lvl)) \ 68 printk(KERN_DEBUG "ds: " fmt , ## arg); \ 69 } while (0) 70 #else 71 #define ds_dbg(lvl, fmt, arg...) do { } while (0) 72 #endif 73 74 /*====================================================================*/ 75 76 /* Device user information */ 77 #define MAX_EVENTS 32 78 #define USER_MAGIC 0x7ea4 79 #define CHECK_USER(u) \ 80 (((u) == NULL) || ((u)->user_magic != USER_MAGIC)) 81 typedef struct user_info_t { 82 u_int user_magic; 83 int event_head, event_tail; 84 event_t event[MAX_EVENTS]; 85 struct user_info_t *next; 86 struct pcmcia_bus_socket *socket; 87 } user_info_t; 88 89 /* Socket state information */ 90 struct pcmcia_bus_socket { 91 struct kref refcount; 92 struct pcmcia_callback callback; 93 int state; 94 user_info_t *user; 95 wait_queue_head_t queue; 96 struct pcmcia_socket *parent; 97 98 /* the PCMCIA devices connected to this socket (normally one, more 99 * for multifunction devices: */ 100 struct list_head devices_list; 101 u8 device_count; /* the number of devices, used 102 * only internally and subject 103 * to incorrectness and change */ 104 }; 105 static spinlock_t pcmcia_dev_list_lock; 106 107 #define DS_SOCKET_PRESENT 0x01 108 #define DS_SOCKET_BUSY 0x02 109 #define DS_SOCKET_REMOVAL_PENDING 0x10 110 #define DS_SOCKET_DEAD 0x80 111 112 /*====================================================================*/ 113 114 static int major_dev = -1; 115 116 static int unbind_request(struct pcmcia_bus_socket *s); 117 118 /*====================================================================*/ 119 120 /* code which was in cs.c before */ 121 122 /* String tables for error messages */ 123 124 typedef struct lookup_t { 125 int key; 126 char *msg; 127 } lookup_t; 128 129 static const lookup_t error_table[] = { 130 { CS_SUCCESS, "Operation succeeded" }, 131 { CS_BAD_ADAPTER, "Bad adapter" }, 132 { CS_BAD_ATTRIBUTE, "Bad attribute", }, 133 { CS_BAD_BASE, "Bad base address" }, 134 { CS_BAD_EDC, "Bad EDC" }, 135 { CS_BAD_IRQ, "Bad IRQ" }, 136 { CS_BAD_OFFSET, "Bad offset" }, 137 { CS_BAD_PAGE, "Bad page number" }, 138 { CS_READ_FAILURE, "Read failure" }, 139 { CS_BAD_SIZE, "Bad size" }, 140 { CS_BAD_SOCKET, "Bad socket" }, 141 { CS_BAD_TYPE, "Bad type" }, 142 { CS_BAD_VCC, "Bad Vcc" }, 143 { CS_BAD_VPP, "Bad Vpp" }, 144 { CS_BAD_WINDOW, "Bad window" }, 145 { CS_WRITE_FAILURE, "Write failure" }, 146 { CS_NO_CARD, "No card present" }, 147 { CS_UNSUPPORTED_FUNCTION, "Usupported function" }, 148 { CS_UNSUPPORTED_MODE, "Unsupported mode" }, 149 { CS_BAD_SPEED, "Bad speed" }, 150 { CS_BUSY, "Resource busy" }, 151 { CS_GENERAL_FAILURE, "General failure" }, 152 { CS_WRITE_PROTECTED, "Write protected" }, 153 { CS_BAD_ARG_LENGTH, "Bad argument length" }, 154 { CS_BAD_ARGS, "Bad arguments" }, 155 { CS_CONFIGURATION_LOCKED, "Configuration locked" }, 156 { CS_IN_USE, "Resource in use" }, 157 { CS_NO_MORE_ITEMS, "No more items" }, 158 { CS_OUT_OF_RESOURCE, "Out of resource" }, 159 { CS_BAD_HANDLE, "Bad handle" }, 160 { CS_BAD_TUPLE, "Bad CIS tuple" } 161 }; 162 163 164 static const lookup_t service_table[] = { 165 { AccessConfigurationRegister, "AccessConfigurationRegister" }, 166 { AddSocketServices, "AddSocketServices" }, 167 { AdjustResourceInfo, "AdjustResourceInfo" }, 168 { CheckEraseQueue, "CheckEraseQueue" }, 169 { CloseMemory, "CloseMemory" }, 170 { DeregisterClient, "DeregisterClient" }, 171 { DeregisterEraseQueue, "DeregisterEraseQueue" }, 172 { GetCardServicesInfo, "GetCardServicesInfo" }, 173 { GetClientInfo, "GetClientInfo" }, 174 { GetConfigurationInfo, "GetConfigurationInfo" }, 175 { GetEventMask, "GetEventMask" }, 176 { GetFirstClient, "GetFirstClient" }, 177 { GetFirstRegion, "GetFirstRegion" }, 178 { GetFirstTuple, "GetFirstTuple" }, 179 { GetNextClient, "GetNextClient" }, 180 { GetNextRegion, "GetNextRegion" }, 181 { GetNextTuple, "GetNextTuple" }, 182 { GetStatus, "GetStatus" }, 183 { GetTupleData, "GetTupleData" }, 184 { MapMemPage, "MapMemPage" }, 185 { ModifyConfiguration, "ModifyConfiguration" }, 186 { ModifyWindow, "ModifyWindow" }, 187 { OpenMemory, "OpenMemory" }, 188 { ParseTuple, "ParseTuple" }, 189 { ReadMemory, "ReadMemory" }, 190 { RegisterClient, "RegisterClient" }, 191 { RegisterEraseQueue, "RegisterEraseQueue" }, 192 { RegisterMTD, "RegisterMTD" }, 193 { ReleaseConfiguration, "ReleaseConfiguration" }, 194 { ReleaseIO, "ReleaseIO" }, 195 { ReleaseIRQ, "ReleaseIRQ" }, 196 { ReleaseWindow, "ReleaseWindow" }, 197 { RequestConfiguration, "RequestConfiguration" }, 198 { RequestIO, "RequestIO" }, 199 { RequestIRQ, "RequestIRQ" }, 200 { RequestSocketMask, "RequestSocketMask" }, 201 { RequestWindow, "RequestWindow" }, 202 { ResetCard, "ResetCard" }, 203 { SetEventMask, "SetEventMask" }, 204 { ValidateCIS, "ValidateCIS" }, 205 { WriteMemory, "WriteMemory" }, 206 { BindDevice, "BindDevice" }, 207 { BindMTD, "BindMTD" }, 208 { ReportError, "ReportError" }, 209 { SuspendCard, "SuspendCard" }, 210 { ResumeCard, "ResumeCard" }, 211 { EjectCard, "EjectCard" }, 212 { InsertCard, "InsertCard" }, 213 { ReplaceCIS, "ReplaceCIS" } 214 }; 215 216 217 int pcmcia_report_error(client_handle_t handle, error_info_t *err) 218 { 219 int i; 220 char *serv; 221 222 if (CHECK_HANDLE(handle)) 223 printk(KERN_NOTICE); 224 else { 225 struct pcmcia_device *p_dev = handle_to_pdev(handle); 226 printk(KERN_NOTICE "%s: ", p_dev->dev.bus_id); 227 } 228 229 for (i = 0; i < ARRAY_SIZE(service_table); i++) 230 if (service_table[i].key == err->func) 231 break; 232 if (i < ARRAY_SIZE(service_table)) 233 serv = service_table[i].msg; 234 else 235 serv = "Unknown service number"; 236 237 for (i = 0; i < ARRAY_SIZE(error_table); i++) 238 if (error_table[i].key == err->retcode) 239 break; 240 if (i < ARRAY_SIZE(error_table)) 241 printk("%s: %s\n", serv, error_table[i].msg); 242 else 243 printk("%s: Unknown error code %#x\n", serv, err->retcode); 244 245 return CS_SUCCESS; 246 } /* report_error */ 247 EXPORT_SYMBOL(pcmcia_report_error); 248 249 /* end of code which was in cs.c before */ 250 251 /*======================================================================*/ 252 253 void cs_error(client_handle_t handle, int func, int ret) 254 { 255 error_info_t err = { func, ret }; 256 pcmcia_report_error(handle, &err); 257 } 258 EXPORT_SYMBOL(cs_error); 259 260 /*======================================================================*/ 261 262 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info); 263 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr); 264 265 static void pcmcia_release_bus_socket(struct kref *refcount) 266 { 267 struct pcmcia_bus_socket *s = container_of(refcount, struct pcmcia_bus_socket, refcount); 268 pcmcia_put_socket(s->parent); 269 kfree(s); 270 } 271 272 static void pcmcia_put_bus_socket(struct pcmcia_bus_socket *s) 273 { 274 kref_put(&s->refcount, pcmcia_release_bus_socket); 275 } 276 277 static struct pcmcia_bus_socket *pcmcia_get_bus_socket(struct pcmcia_bus_socket *s) 278 { 279 kref_get(&s->refcount); 280 return (s); 281 } 282 283 /** 284 * pcmcia_register_driver - register a PCMCIA driver with the bus core 285 * 286 * Registers a PCMCIA driver with the PCMCIA bus core. 287 */ 288 static int pcmcia_device_probe(struct device *dev); 289 static int pcmcia_device_remove(struct device * dev); 290 291 int pcmcia_register_driver(struct pcmcia_driver *driver) 292 { 293 if (!driver) 294 return -EINVAL; 295 296 /* initialize common fields */ 297 driver->drv.bus = &pcmcia_bus_type; 298 driver->drv.owner = driver->owner; 299 driver->drv.probe = pcmcia_device_probe; 300 driver->drv.remove = pcmcia_device_remove; 301 302 return driver_register(&driver->drv); 303 } 304 EXPORT_SYMBOL(pcmcia_register_driver); 305 306 /** 307 * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core 308 */ 309 void pcmcia_unregister_driver(struct pcmcia_driver *driver) 310 { 311 driver_unregister(&driver->drv); 312 } 313 EXPORT_SYMBOL(pcmcia_unregister_driver); 314 315 #ifdef CONFIG_PROC_FS 316 static struct proc_dir_entry *proc_pccard = NULL; 317 318 static int proc_read_drivers_callback(struct device_driver *driver, void *d) 319 { 320 char **p = d; 321 struct pcmcia_driver *p_drv = container_of(driver, 322 struct pcmcia_driver, drv); 323 324 *p += sprintf(*p, "%-24.24s 1 %d\n", p_drv->drv.name, 325 #ifdef CONFIG_MODULE_UNLOAD 326 (p_drv->owner) ? module_refcount(p_drv->owner) : 1 327 #else 328 1 329 #endif 330 ); 331 d = (void *) p; 332 333 return 0; 334 } 335 336 static int proc_read_drivers(char *buf, char **start, off_t pos, 337 int count, int *eof, void *data) 338 { 339 char *p = buf; 340 341 bus_for_each_drv(&pcmcia_bus_type, NULL, 342 (void *) &p, proc_read_drivers_callback); 343 344 return (p - buf); 345 } 346 #endif 347 348 /* pcmcia_device handling */ 349 350 static struct pcmcia_device * pcmcia_get_dev(struct pcmcia_device *p_dev) 351 { 352 struct device *tmp_dev; 353 tmp_dev = get_device(&p_dev->dev); 354 if (!tmp_dev) 355 return NULL; 356 return to_pcmcia_dev(tmp_dev); 357 } 358 359 static void pcmcia_put_dev(struct pcmcia_device *p_dev) 360 { 361 if (p_dev) 362 put_device(&p_dev->dev); 363 } 364 365 static void pcmcia_release_dev(struct device *dev) 366 { 367 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 368 ds_dbg(1, "releasing dev %p\n", p_dev); 369 pcmcia_put_bus_socket(p_dev->socket->pcmcia); 370 kfree(p_dev); 371 } 372 373 374 static int pcmcia_device_probe(struct device * dev) 375 { 376 struct pcmcia_device *p_dev; 377 struct pcmcia_driver *p_drv; 378 int ret = 0; 379 380 dev = get_device(dev); 381 if (!dev) 382 return -ENODEV; 383 384 p_dev = to_pcmcia_dev(dev); 385 p_drv = to_pcmcia_drv(dev->driver); 386 387 if (!try_module_get(p_drv->owner)) { 388 ret = -EINVAL; 389 goto put_dev; 390 } 391 392 if (p_drv->attach) { 393 p_dev->instance = p_drv->attach(); 394 if ((!p_dev->instance) || (p_dev->client.state & CLIENT_UNBOUND)) { 395 printk(KERN_NOTICE "ds: unable to create instance " 396 "of '%s'!\n", p_drv->drv.name); 397 ret = -EINVAL; 398 } 399 } 400 401 if (ret) 402 module_put(p_drv->owner); 403 put_dev: 404 if ((ret) || !(p_drv->attach)) 405 put_device(dev); 406 return (ret); 407 } 408 409 410 static int pcmcia_device_remove(struct device * dev) 411 { 412 struct pcmcia_device *p_dev; 413 struct pcmcia_driver *p_drv; 414 415 /* detach the "instance" */ 416 p_dev = to_pcmcia_dev(dev); 417 p_drv = to_pcmcia_drv(dev->driver); 418 419 if (p_drv) { 420 if ((p_drv->detach) && (p_dev->instance)) { 421 p_drv->detach(p_dev->instance); 422 /* from pcmcia_probe_device */ 423 put_device(&p_dev->dev); 424 } 425 module_put(p_drv->owner); 426 } 427 428 return 0; 429 } 430 431 432 433 /* 434 * pcmcia_device_query -- determine information about a pcmcia device 435 */ 436 static int pcmcia_device_query(struct pcmcia_device *p_dev) 437 { 438 cistpl_manfid_t manf_id; 439 cistpl_funcid_t func_id; 440 cistpl_vers_1_t vers1; 441 unsigned int i; 442 443 if (!pccard_read_tuple(p_dev->socket, p_dev->func, 444 CISTPL_MANFID, &manf_id)) { 445 p_dev->manf_id = manf_id.manf; 446 p_dev->card_id = manf_id.card; 447 p_dev->has_manf_id = 1; 448 p_dev->has_card_id = 1; 449 } 450 451 if (!pccard_read_tuple(p_dev->socket, p_dev->func, 452 CISTPL_FUNCID, &func_id)) { 453 p_dev->func_id = func_id.func; 454 p_dev->has_func_id = 1; 455 } else { 456 /* rule of thumb: cards with no FUNCID, but with 457 * common memory device geometry information, are 458 * probably memory cards (from pcmcia-cs) */ 459 cistpl_device_geo_t devgeo; 460 if (!pccard_read_tuple(p_dev->socket, p_dev->func, 461 CISTPL_DEVICE_GEO, &devgeo)) { 462 ds_dbg(0, "mem device geometry probably means " 463 "FUNCID_MEMORY\n"); 464 p_dev->func_id = CISTPL_FUNCID_MEMORY; 465 p_dev->has_func_id = 1; 466 } 467 } 468 469 if (!pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_VERS_1, 470 &vers1)) { 471 for (i=0; i < vers1.ns; i++) { 472 char *tmp; 473 unsigned int length; 474 475 tmp = vers1.str + vers1.ofs[i]; 476 477 length = strlen(tmp) + 1; 478 if ((length < 3) || (length > 255)) 479 continue; 480 481 p_dev->prod_id[i] = kmalloc(sizeof(char) * length, 482 GFP_KERNEL); 483 if (!p_dev->prod_id[i]) 484 continue; 485 486 p_dev->prod_id[i] = strncpy(p_dev->prod_id[i], 487 tmp, length); 488 } 489 } 490 491 return 0; 492 } 493 494 495 /* device_add_lock is needed to avoid double registration by cardmgr and kernel. 496 * Serializes pcmcia_device_add; will most likely be removed in future. 497 * 498 * While it has the caveat that adding new PCMCIA devices inside(!) device_register() 499 * won't work, this doesn't matter much at the moment: the driver core doesn't 500 * support it either. 501 */ 502 static DECLARE_MUTEX(device_add_lock); 503 504 static struct pcmcia_device * pcmcia_device_add(struct pcmcia_bus_socket *s, unsigned int function) 505 { 506 struct pcmcia_device *p_dev; 507 unsigned long flags; 508 509 s = pcmcia_get_bus_socket(s); 510 if (!s) 511 return NULL; 512 513 down(&device_add_lock); 514 515 p_dev = kmalloc(sizeof(struct pcmcia_device), GFP_KERNEL); 516 if (!p_dev) 517 goto err_put; 518 memset(p_dev, 0, sizeof(struct pcmcia_device)); 519 520 p_dev->socket = s->parent; 521 p_dev->device_no = (s->device_count++); 522 p_dev->func = function; 523 524 p_dev->dev.bus = &pcmcia_bus_type; 525 p_dev->dev.parent = s->parent->dev.dev; 526 p_dev->dev.release = pcmcia_release_dev; 527 sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no); 528 529 /* compat */ 530 p_dev->client.client_magic = CLIENT_MAGIC; 531 p_dev->client.Socket = s->parent; 532 p_dev->client.Function = function; 533 p_dev->client.state = CLIENT_UNBOUND; 534 535 /* Add to the list in pcmcia_bus_socket */ 536 spin_lock_irqsave(&pcmcia_dev_list_lock, flags); 537 list_add_tail(&p_dev->socket_device_list, &s->devices_list); 538 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 539 540 if (device_register(&p_dev->dev)) { 541 spin_lock_irqsave(&pcmcia_dev_list_lock, flags); 542 list_del(&p_dev->socket_device_list); 543 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 544 545 goto err_free; 546 } 547 548 up(&device_add_lock); 549 550 return p_dev; 551 552 err_free: 553 kfree(p_dev); 554 s->device_count--; 555 err_put: 556 up(&device_add_lock); 557 pcmcia_put_bus_socket(s); 558 559 return NULL; 560 } 561 562 563 static int pcmcia_card_add(struct pcmcia_socket *s) 564 { 565 cisinfo_t cisinfo; 566 cistpl_longlink_mfc_t mfc; 567 unsigned int no_funcs, i; 568 int ret = 0; 569 570 if (!(s->resource_setup_done)) 571 return -EAGAIN; /* try again, but later... */ 572 573 pcmcia_validate_mem(s); 574 ret = pccard_validate_cis(s, BIND_FN_ALL, &cisinfo); 575 if (ret || !cisinfo.Chains) { 576 ds_dbg(0, "invalid CIS or invalid resources\n"); 577 return -ENODEV; 578 } 579 580 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc)) 581 no_funcs = mfc.nfn; 582 else 583 no_funcs = 1; 584 585 /* this doesn't handle multifunction devices on one pcmcia function 586 * yet. */ 587 for (i=0; i < no_funcs; i++) 588 pcmcia_device_add(s->pcmcia, i); 589 590 return (ret); 591 } 592 593 594 static int pcmcia_bus_match(struct device * dev, struct device_driver * drv) { 595 struct pcmcia_device * p_dev = to_pcmcia_dev(dev); 596 struct pcmcia_driver * p_drv = to_pcmcia_drv(drv); 597 598 /* matching by cardmgr */ 599 if (p_dev->cardmgr == p_drv) 600 return 1; 601 602 return 0; 603 } 604 605 #ifdef CONFIG_HOTPLUG 606 607 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp, 608 char *buffer, int buffer_size) 609 { 610 struct pcmcia_device *p_dev; 611 int i, length = 0; 612 u32 hash[4] = { 0, 0, 0, 0}; 613 614 if (!dev) 615 return -ENODEV; 616 617 p_dev = to_pcmcia_dev(dev); 618 619 /* calculate hashes */ 620 for (i=0; i<4; i++) { 621 if (!p_dev->prod_id[i]) 622 continue; 623 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i])); 624 } 625 626 i = 0; 627 628 if (add_hotplug_env_var(envp, num_envp, &i, 629 buffer, buffer_size, &length, 630 "SOCKET_NO=%u", 631 p_dev->socket->sock)) 632 return -ENOMEM; 633 634 if (add_hotplug_env_var(envp, num_envp, &i, 635 buffer, buffer_size, &length, 636 "DEVICE_NO=%02X", 637 p_dev->device_no)) 638 return -ENOMEM; 639 640 if (add_hotplug_env_var(envp, num_envp, &i, 641 buffer, buffer_size, &length, 642 "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" 643 "pa%08Xpb%08Xpc%08Xpd%08X", 644 p_dev->has_manf_id ? p_dev->manf_id : 0, 645 p_dev->has_card_id ? p_dev->card_id : 0, 646 p_dev->has_func_id ? p_dev->func_id : 0, 647 p_dev->func, 648 p_dev->device_no, 649 hash[0], 650 hash[1], 651 hash[2], 652 hash[3])) 653 return -ENOMEM; 654 655 envp[i] = NULL; 656 657 return 0; 658 } 659 660 #else 661 662 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp, 663 char *buffer, int buffer_size) 664 { 665 return -ENODEV; 666 } 667 668 #endif 669 670 /************************ per-device sysfs output ***************************/ 671 672 #define pcmcia_device_attr(field, test, format) \ 673 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \ 674 { \ 675 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \ 676 return p_dev->test ? sprintf (buf, format, p_dev->field) : -ENODEV; \ 677 } 678 679 #define pcmcia_device_stringattr(name, field) \ 680 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf) \ 681 { \ 682 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \ 683 return p_dev->field ? sprintf (buf, "%s\n", p_dev->field) : -ENODEV; \ 684 } 685 686 pcmcia_device_attr(func, socket, "0x%02x\n"); 687 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n"); 688 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n"); 689 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n"); 690 pcmcia_device_stringattr(prod_id1, prod_id[0]); 691 pcmcia_device_stringattr(prod_id2, prod_id[1]); 692 pcmcia_device_stringattr(prod_id3, prod_id[2]); 693 pcmcia_device_stringattr(prod_id4, prod_id[3]); 694 695 static struct device_attribute pcmcia_dev_attrs[] = { 696 __ATTR(function, 0444, func_show, NULL), 697 __ATTR_RO(func_id), 698 __ATTR_RO(manf_id), 699 __ATTR_RO(card_id), 700 __ATTR_RO(prod_id1), 701 __ATTR_RO(prod_id2), 702 __ATTR_RO(prod_id3), 703 __ATTR_RO(prod_id4), 704 __ATTR_NULL, 705 }; 706 707 708 /*====================================================================== 709 710 These manage a ring buffer of events pending for one user process 711 712 ======================================================================*/ 713 714 static int queue_empty(user_info_t *user) 715 { 716 return (user->event_head == user->event_tail); 717 } 718 719 static event_t get_queued_event(user_info_t *user) 720 { 721 user->event_tail = (user->event_tail+1) % MAX_EVENTS; 722 return user->event[user->event_tail]; 723 } 724 725 static void queue_event(user_info_t *user, event_t event) 726 { 727 user->event_head = (user->event_head+1) % MAX_EVENTS; 728 if (user->event_head == user->event_tail) 729 user->event_tail = (user->event_tail+1) % MAX_EVENTS; 730 user->event[user->event_head] = event; 731 } 732 733 static void handle_event(struct pcmcia_bus_socket *s, event_t event) 734 { 735 user_info_t *user; 736 for (user = s->user; user; user = user->next) 737 queue_event(user, event); 738 wake_up_interruptible(&s->queue); 739 } 740 741 742 /*====================================================================== 743 744 The card status event handler. 745 746 ======================================================================*/ 747 748 struct send_event_data { 749 struct pcmcia_socket *skt; 750 event_t event; 751 int priority; 752 }; 753 754 static int send_event_callback(struct device *dev, void * _data) 755 { 756 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 757 struct send_event_data *data = _data; 758 759 /* we get called for all sockets, but may only pass the event 760 * for drivers _on the affected socket_ */ 761 if (p_dev->socket != data->skt) 762 return 0; 763 764 if (p_dev->client.state & (CLIENT_UNBOUND|CLIENT_STALE)) 765 return 0; 766 767 if (p_dev->client.EventMask & data->event) 768 return EVENT(&p_dev->client, data->event, data->priority); 769 770 return 0; 771 } 772 773 static int send_event(struct pcmcia_socket *s, event_t event, int priority) 774 { 775 int ret = 0; 776 struct send_event_data private; 777 struct pcmcia_bus_socket *skt = pcmcia_get_bus_socket(s->pcmcia); 778 779 if (!skt) 780 return 0; 781 782 private.skt = s; 783 private.event = event; 784 private.priority = priority; 785 786 ret = bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback); 787 788 pcmcia_put_bus_socket(skt); 789 return ret; 790 } /* send_event */ 791 792 793 /* Normally, the event is passed to individual drivers after 794 * informing userspace. Only for CS_EVENT_CARD_REMOVAL this 795 * is inversed to maintain historic compatibility. 796 */ 797 798 static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) 799 { 800 struct pcmcia_bus_socket *s = skt->pcmcia; 801 int ret = 0; 802 803 ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n", 804 event, priority, s); 805 806 switch (event) { 807 808 case CS_EVENT_CARD_REMOVAL: 809 s->state &= ~DS_SOCKET_PRESENT; 810 send_event(skt, event, priority); 811 unbind_request(s); 812 handle_event(s, event); 813 break; 814 815 case CS_EVENT_CARD_INSERTION: 816 s->state |= DS_SOCKET_PRESENT; 817 pcmcia_card_add(skt); 818 handle_event(s, event); 819 break; 820 821 case CS_EVENT_EJECTION_REQUEST: 822 ret = send_event(skt, event, priority); 823 break; 824 825 default: 826 handle_event(s, event); 827 send_event(skt, event, priority); 828 break; 829 } 830 831 return 0; 832 } /* ds_event */ 833 834 835 /*====================================================================== 836 837 bind_request() and bind_device() are merged by now. Register_client() 838 is called right at the end of bind_request(), during the driver's 839 ->attach() call. Individual descriptions: 840 841 bind_request() connects a socket to a particular client driver. 842 It looks up the specified device ID in the list of registered 843 drivers, binds it to the socket, and tries to create an instance 844 of the device. unbind_request() deletes a driver instance. 845 846 Bind_device() associates a device driver with a particular socket. 847 It is normally called by Driver Services after it has identified 848 a newly inserted card. An instance of that driver will then be 849 eligible to register as a client of this socket. 850 851 Register_client() uses the dev_info_t handle to match the 852 caller with a socket. The driver must have already been bound 853 to a socket with bind_device() -- in fact, bind_device() 854 allocates the client structure that will be used. 855 856 ======================================================================*/ 857 858 static int bind_request(struct pcmcia_bus_socket *s, bind_info_t *bind_info) 859 { 860 struct pcmcia_driver *p_drv; 861 struct pcmcia_device *p_dev; 862 int ret = 0; 863 unsigned long flags; 864 865 s = pcmcia_get_bus_socket(s); 866 if (!s) 867 return -EINVAL; 868 869 ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock, 870 (char *)bind_info->dev_info); 871 872 p_drv = get_pcmcia_driver(&bind_info->dev_info); 873 if (!p_drv) { 874 ret = -EINVAL; 875 goto err_put; 876 } 877 878 if (!try_module_get(p_drv->owner)) { 879 ret = -EINVAL; 880 goto err_put_driver; 881 } 882 883 spin_lock_irqsave(&pcmcia_dev_list_lock, flags); 884 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) { 885 if (p_dev->func == bind_info->function) { 886 if ((p_dev->dev.driver == &p_drv->drv)) { 887 if (p_dev->cardmgr) { 888 /* if there's already a device 889 * registered, and it was registered 890 * by userspace before, we need to 891 * return the "instance". */ 892 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 893 bind_info->instance = p_dev->instance; 894 ret = -EBUSY; 895 goto err_put_module; 896 } else { 897 /* the correct driver managed to bind 898 * itself magically to the correct 899 * device. */ 900 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 901 p_dev->cardmgr = p_drv; 902 ret = 0; 903 goto err_put_module; 904 } 905 } else if (!p_dev->dev.driver) { 906 /* there's already a device available where 907 * no device has been bound to yet. So we don't 908 * need to register a device! */ 909 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 910 goto rescan; 911 } 912 } 913 } 914 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 915 916 p_dev = pcmcia_device_add(s, bind_info->function); 917 if (!p_dev) { 918 ret = -EIO; 919 goto err_put_module; 920 } 921 922 rescan: 923 p_dev->cardmgr = p_drv; 924 925 pcmcia_device_query(p_dev); 926 927 /* 928 * Prevent this racing with a card insertion. 929 */ 930 down(&s->parent->skt_sem); 931 bus_rescan_devices(&pcmcia_bus_type); 932 up(&s->parent->skt_sem); 933 934 /* check whether the driver indeed matched. I don't care if this 935 * is racy or not, because it can only happen on cardmgr access 936 * paths... 937 */ 938 if (!(p_dev->dev.driver == &p_drv->drv)) 939 p_dev->cardmgr = NULL; 940 941 err_put_module: 942 module_put(p_drv->owner); 943 err_put_driver: 944 put_driver(&p_drv->drv); 945 err_put: 946 pcmcia_put_bus_socket(s); 947 948 return (ret); 949 } /* bind_request */ 950 951 952 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req) 953 { 954 client_t *client = NULL; 955 struct pcmcia_socket *s; 956 struct pcmcia_bus_socket *skt = NULL; 957 struct pcmcia_device *p_dev = NULL; 958 959 /* Look for unbound client with matching dev_info */ 960 down_read(&pcmcia_socket_list_rwsem); 961 list_for_each_entry(s, &pcmcia_socket_list, socket_list) { 962 unsigned long flags; 963 964 if (s->state & SOCKET_CARDBUS) 965 continue; 966 967 skt = s->pcmcia; 968 if (!skt) 969 continue; 970 skt = pcmcia_get_bus_socket(skt); 971 if (!skt) 972 continue; 973 spin_lock_irqsave(&pcmcia_dev_list_lock, flags); 974 list_for_each_entry(p_dev, &skt->devices_list, socket_device_list) { 975 struct pcmcia_driver *p_drv; 976 p_dev = pcmcia_get_dev(p_dev); 977 if (!p_dev) 978 continue; 979 if (!(p_dev->client.state & CLIENT_UNBOUND) || 980 (!p_dev->dev.driver)) { 981 pcmcia_put_dev(p_dev); 982 continue; 983 } 984 p_drv = to_pcmcia_drv(p_dev->dev.driver); 985 if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) { 986 client = &p_dev->client; 987 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 988 goto found; 989 } 990 pcmcia_put_dev(p_dev); 991 } 992 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 993 pcmcia_put_bus_socket(skt); 994 } 995 found: 996 up_read(&pcmcia_socket_list_rwsem); 997 if (!p_dev || !client) 998 return -ENODEV; 999 1000 pcmcia_put_bus_socket(skt); /* safe, as we already hold a reference from bind_device */ 1001 1002 *handle = client; 1003 client->state &= ~CLIENT_UNBOUND; 1004 client->Socket = s; 1005 client->EventMask = req->EventMask; 1006 client->event_handler = req->event_handler; 1007 client->event_callback_args = req->event_callback_args; 1008 client->event_callback_args.client_handle = client; 1009 1010 if (s->state & SOCKET_CARDBUS) 1011 client->state |= CLIENT_CARDBUS; 1012 1013 if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) && 1014 (client->Function != BIND_FN_ALL)) { 1015 cistpl_longlink_mfc_t mfc; 1016 if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc) 1017 == CS_SUCCESS) 1018 s->functions = mfc.nfn; 1019 else 1020 s->functions = 1; 1021 s->config = kmalloc(sizeof(config_t) * s->functions, 1022 GFP_KERNEL); 1023 if (!s->config) 1024 goto out_no_resource; 1025 memset(s->config, 0, sizeof(config_t) * s->functions); 1026 } 1027 1028 ds_dbg(1, "register_client(): client 0x%p, dev %s\n", 1029 client, p_dev->dev.bus_id); 1030 if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE) 1031 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW); 1032 1033 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) { 1034 if (client->EventMask & CS_EVENT_CARD_INSERTION) 1035 EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW); 1036 } 1037 1038 return CS_SUCCESS; 1039 1040 out_no_resource: 1041 pcmcia_put_dev(p_dev); 1042 return CS_OUT_OF_RESOURCE; 1043 } /* register_client */ 1044 EXPORT_SYMBOL(pcmcia_register_client); 1045 1046 1047 /*====================================================================*/ 1048 1049 extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s); 1050 1051 static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info, int first) 1052 { 1053 dev_node_t *node; 1054 struct pcmcia_device *p_dev; 1055 unsigned long flags; 1056 int ret = 0; 1057 1058 #ifdef CONFIG_CARDBUS 1059 /* 1060 * Some unbelievably ugly code to associate the PCI cardbus 1061 * device and its driver with the PCMCIA "bind" information. 1062 */ 1063 { 1064 struct pci_bus *bus; 1065 1066 bus = pcmcia_lookup_bus(s->parent); 1067 if (bus) { 1068 struct list_head *list; 1069 struct pci_dev *dev = NULL; 1070 1071 list = bus->devices.next; 1072 while (list != &bus->devices) { 1073 struct pci_dev *pdev = pci_dev_b(list); 1074 list = list->next; 1075 1076 if (first) { 1077 dev = pdev; 1078 break; 1079 } 1080 1081 /* Try to handle "next" here some way? */ 1082 } 1083 if (dev && dev->driver) { 1084 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN); 1085 bind_info->major = 0; 1086 bind_info->minor = 0; 1087 bind_info->next = NULL; 1088 return 0; 1089 } 1090 } 1091 } 1092 #endif 1093 1094 spin_lock_irqsave(&pcmcia_dev_list_lock, flags); 1095 list_for_each_entry(p_dev, &s->devices_list, socket_device_list) { 1096 if (p_dev->func == bind_info->function) { 1097 p_dev = pcmcia_get_dev(p_dev); 1098 if (!p_dev) 1099 continue; 1100 goto found; 1101 } 1102 } 1103 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 1104 return -ENODEV; 1105 1106 found: 1107 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 1108 1109 if ((!p_dev->instance) || 1110 (p_dev->instance->state & DEV_CONFIG_PENDING)) { 1111 ret = -EAGAIN; 1112 goto err_put; 1113 } 1114 1115 if (first) 1116 node = p_dev->instance->dev; 1117 else 1118 for (node = p_dev->instance->dev; node; node = node->next) 1119 if (node == bind_info->next) 1120 break; 1121 if (!node) { 1122 ret = -ENODEV; 1123 goto err_put; 1124 } 1125 1126 strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN); 1127 bind_info->major = node->major; 1128 bind_info->minor = node->minor; 1129 bind_info->next = node->next; 1130 1131 err_put: 1132 pcmcia_put_dev(p_dev); 1133 return (ret); 1134 } /* get_device_info */ 1135 1136 /*====================================================================*/ 1137 1138 /* unbind _all_ devices attached to a given pcmcia_bus_socket. The 1139 * drivers have been called with EVENT_CARD_REMOVAL before. 1140 */ 1141 static int unbind_request(struct pcmcia_bus_socket *s) 1142 { 1143 struct pcmcia_device *p_dev; 1144 unsigned long flags; 1145 1146 ds_dbg(2, "unbind_request(%d)\n", s->parent->sock); 1147 1148 s->device_count = 0; 1149 1150 for (;;) { 1151 /* unregister all pcmcia_devices registered with this socket*/ 1152 spin_lock_irqsave(&pcmcia_dev_list_lock, flags); 1153 if (list_empty(&s->devices_list)) { 1154 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 1155 return 0; 1156 } 1157 p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list); 1158 list_del(&p_dev->socket_device_list); 1159 p_dev->client.state |= CLIENT_STALE; 1160 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); 1161 1162 device_unregister(&p_dev->dev); 1163 } 1164 1165 return 0; 1166 } /* unbind_request */ 1167 1168 int pcmcia_deregister_client(client_handle_t handle) 1169 { 1170 struct pcmcia_socket *s; 1171 int i; 1172 struct pcmcia_device *p_dev = handle_to_pdev(handle); 1173 1174 if (CHECK_HANDLE(handle)) 1175 return CS_BAD_HANDLE; 1176 1177 s = SOCKET(handle); 1178 ds_dbg(1, "deregister_client(%p)\n", handle); 1179 1180 if (handle->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED)) 1181 goto warn_out; 1182 for (i = 0; i < MAX_WIN; i++) 1183 if (handle->state & CLIENT_WIN_REQ(i)) 1184 goto warn_out; 1185 1186 if (handle->state & CLIENT_STALE) { 1187 handle->client_magic = 0; 1188 handle->state &= ~CLIENT_STALE; 1189 pcmcia_put_dev(p_dev); 1190 } else { 1191 handle->state = CLIENT_UNBOUND; 1192 handle->event_handler = NULL; 1193 } 1194 1195 return CS_SUCCESS; 1196 warn_out: 1197 printk(KERN_WARNING "ds: deregister_client was called too early.\n"); 1198 return CS_IN_USE; 1199 } /* deregister_client */ 1200 EXPORT_SYMBOL(pcmcia_deregister_client); 1201 1202 1203 /*====================================================================== 1204 1205 The user-mode PC Card device interface 1206 1207 ======================================================================*/ 1208 1209 static int ds_open(struct inode *inode, struct file *file) 1210 { 1211 socket_t i = iminor(inode); 1212 struct pcmcia_bus_socket *s; 1213 user_info_t *user; 1214 1215 ds_dbg(0, "ds_open(socket %d)\n", i); 1216 1217 s = get_socket_info_by_nr(i); 1218 if (!s) 1219 return -ENODEV; 1220 s = pcmcia_get_bus_socket(s); 1221 if (!s) 1222 return -ENODEV; 1223 1224 if ((file->f_flags & O_ACCMODE) != O_RDONLY) { 1225 if (s->state & DS_SOCKET_BUSY) { 1226 pcmcia_put_bus_socket(s); 1227 return -EBUSY; 1228 } 1229 else 1230 s->state |= DS_SOCKET_BUSY; 1231 } 1232 1233 user = kmalloc(sizeof(user_info_t), GFP_KERNEL); 1234 if (!user) { 1235 pcmcia_put_bus_socket(s); 1236 return -ENOMEM; 1237 } 1238 user->event_tail = user->event_head = 0; 1239 user->next = s->user; 1240 user->user_magic = USER_MAGIC; 1241 user->socket = s; 1242 s->user = user; 1243 file->private_data = user; 1244 1245 if (s->state & DS_SOCKET_PRESENT) 1246 queue_event(user, CS_EVENT_CARD_INSERTION); 1247 return 0; 1248 } /* ds_open */ 1249 1250 /*====================================================================*/ 1251 1252 static int ds_release(struct inode *inode, struct file *file) 1253 { 1254 struct pcmcia_bus_socket *s; 1255 user_info_t *user, **link; 1256 1257 ds_dbg(0, "ds_release(socket %d)\n", iminor(inode)); 1258 1259 user = file->private_data; 1260 if (CHECK_USER(user)) 1261 goto out; 1262 1263 s = user->socket; 1264 1265 /* Unlink user data structure */ 1266 if ((file->f_flags & O_ACCMODE) != O_RDONLY) { 1267 s->state &= ~DS_SOCKET_BUSY; 1268 } 1269 file->private_data = NULL; 1270 for (link = &s->user; *link; link = &(*link)->next) 1271 if (*link == user) break; 1272 if (link == NULL) 1273 goto out; 1274 *link = user->next; 1275 user->user_magic = 0; 1276 kfree(user); 1277 pcmcia_put_bus_socket(s); 1278 out: 1279 return 0; 1280 } /* ds_release */ 1281 1282 /*====================================================================*/ 1283 1284 static ssize_t ds_read(struct file *file, char __user *buf, 1285 size_t count, loff_t *ppos) 1286 { 1287 struct pcmcia_bus_socket *s; 1288 user_info_t *user; 1289 int ret; 1290 1291 ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode)); 1292 1293 if (count < 4) 1294 return -EINVAL; 1295 1296 user = file->private_data; 1297 if (CHECK_USER(user)) 1298 return -EIO; 1299 1300 s = user->socket; 1301 if (s->state & DS_SOCKET_DEAD) 1302 return -EIO; 1303 1304 ret = wait_event_interruptible(s->queue, !queue_empty(user)); 1305 if (ret == 0) 1306 ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4; 1307 1308 return ret; 1309 } /* ds_read */ 1310 1311 /*====================================================================*/ 1312 1313 static ssize_t ds_write(struct file *file, const char __user *buf, 1314 size_t count, loff_t *ppos) 1315 { 1316 ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode)); 1317 1318 if (count != 4) 1319 return -EINVAL; 1320 if ((file->f_flags & O_ACCMODE) == O_RDONLY) 1321 return -EBADF; 1322 1323 return -EIO; 1324 } /* ds_write */ 1325 1326 /*====================================================================*/ 1327 1328 /* No kernel lock - fine */ 1329 static u_int ds_poll(struct file *file, poll_table *wait) 1330 { 1331 struct pcmcia_bus_socket *s; 1332 user_info_t *user; 1333 1334 ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode)); 1335 1336 user = file->private_data; 1337 if (CHECK_USER(user)) 1338 return POLLERR; 1339 s = user->socket; 1340 /* 1341 * We don't check for a dead socket here since that 1342 * will send cardmgr into an endless spin. 1343 */ 1344 poll_wait(file, &s->queue, wait); 1345 if (!queue_empty(user)) 1346 return POLLIN | POLLRDNORM; 1347 return 0; 1348 } /* ds_poll */ 1349 1350 /*====================================================================*/ 1351 1352 extern int pcmcia_adjust_resource_info(adjust_t *adj); 1353 1354 static int ds_ioctl(struct inode * inode, struct file * file, 1355 u_int cmd, u_long arg) 1356 { 1357 struct pcmcia_bus_socket *s; 1358 void __user *uarg = (char __user *)arg; 1359 u_int size; 1360 int ret, err; 1361 ds_ioctl_arg_t *buf; 1362 user_info_t *user; 1363 1364 ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg); 1365 1366 user = file->private_data; 1367 if (CHECK_USER(user)) 1368 return -EIO; 1369 1370 s = user->socket; 1371 if (s->state & DS_SOCKET_DEAD) 1372 return -EIO; 1373 1374 size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT; 1375 if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL; 1376 1377 /* Permission check */ 1378 if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN)) 1379 return -EPERM; 1380 1381 if (cmd & IOC_IN) { 1382 if (!access_ok(VERIFY_READ, uarg, size)) { 1383 ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT); 1384 return -EFAULT; 1385 } 1386 } 1387 if (cmd & IOC_OUT) { 1388 if (!access_ok(VERIFY_WRITE, uarg, size)) { 1389 ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT); 1390 return -EFAULT; 1391 } 1392 } 1393 buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL); 1394 if (!buf) 1395 return -ENOMEM; 1396 1397 err = ret = 0; 1398 1399 if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size); 1400 1401 switch (cmd) { 1402 case DS_ADJUST_RESOURCE_INFO: 1403 ret = pcmcia_adjust_resource_info(&buf->adjust); 1404 break; 1405 case DS_GET_CARD_SERVICES_INFO: 1406 ret = pcmcia_get_card_services_info(&buf->servinfo); 1407 break; 1408 case DS_GET_CONFIGURATION_INFO: 1409 if (buf->config.Function && 1410 (buf->config.Function >= s->parent->functions)) 1411 ret = CS_BAD_ARGS; 1412 else 1413 ret = pccard_get_configuration_info(s->parent, 1414 buf->config.Function, &buf->config); 1415 break; 1416 case DS_GET_FIRST_TUPLE: 1417 down(&s->parent->skt_sem); 1418 pcmcia_validate_mem(s->parent); 1419 up(&s->parent->skt_sem); 1420 ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple); 1421 break; 1422 case DS_GET_NEXT_TUPLE: 1423 ret = pccard_get_next_tuple(s->parent, BIND_FN_ALL, &buf->tuple); 1424 break; 1425 case DS_GET_TUPLE_DATA: 1426 buf->tuple.TupleData = buf->tuple_parse.data; 1427 buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data); 1428 ret = pccard_get_tuple_data(s->parent, &buf->tuple); 1429 break; 1430 case DS_PARSE_TUPLE: 1431 buf->tuple.TupleData = buf->tuple_parse.data; 1432 ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse); 1433 break; 1434 case DS_RESET_CARD: 1435 ret = pccard_reset_card(s->parent); 1436 break; 1437 case DS_GET_STATUS: 1438 if (buf->status.Function && 1439 (buf->status.Function >= s->parent->functions)) 1440 ret = CS_BAD_ARGS; 1441 else 1442 ret = pccard_get_status(s->parent, buf->status.Function, &buf->status); 1443 break; 1444 case DS_VALIDATE_CIS: 1445 down(&s->parent->skt_sem); 1446 pcmcia_validate_mem(s->parent); 1447 up(&s->parent->skt_sem); 1448 ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo); 1449 break; 1450 case DS_SUSPEND_CARD: 1451 ret = pcmcia_suspend_card(s->parent); 1452 break; 1453 case DS_RESUME_CARD: 1454 ret = pcmcia_resume_card(s->parent); 1455 break; 1456 case DS_EJECT_CARD: 1457 err = pcmcia_eject_card(s->parent); 1458 break; 1459 case DS_INSERT_CARD: 1460 err = pcmcia_insert_card(s->parent); 1461 break; 1462 case DS_ACCESS_CONFIGURATION_REGISTER: 1463 if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) { 1464 err = -EPERM; 1465 goto free_out; 1466 } 1467 if (buf->conf_reg.Function && 1468 (buf->conf_reg.Function >= s->parent->functions)) 1469 ret = CS_BAD_ARGS; 1470 else 1471 ret = pccard_access_configuration_register(s->parent, 1472 buf->conf_reg.Function, &buf->conf_reg); 1473 break; 1474 case DS_GET_FIRST_REGION: 1475 case DS_GET_NEXT_REGION: 1476 case DS_BIND_MTD: 1477 if (!capable(CAP_SYS_ADMIN)) { 1478 err = -EPERM; 1479 goto free_out; 1480 } else { 1481 static int printed = 0; 1482 if (!printed) { 1483 printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n"); 1484 printk(KERN_WARNING "MTD handling any more.\n"); 1485 printed++; 1486 } 1487 } 1488 err = -EINVAL; 1489 goto free_out; 1490 break; 1491 case DS_GET_FIRST_WINDOW: 1492 ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 0, 1493 &buf->win_info.window); 1494 break; 1495 case DS_GET_NEXT_WINDOW: 1496 ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 1497 buf->win_info.handle->index + 1, &buf->win_info.window); 1498 break; 1499 case DS_GET_MEM_PAGE: 1500 ret = pcmcia_get_mem_page(buf->win_info.handle, 1501 &buf->win_info.map); 1502 break; 1503 case DS_REPLACE_CIS: 1504 ret = pcmcia_replace_cis(s->parent, &buf->cisdump); 1505 break; 1506 case DS_BIND_REQUEST: 1507 if (!capable(CAP_SYS_ADMIN)) { 1508 err = -EPERM; 1509 goto free_out; 1510 } 1511 err = bind_request(s, &buf->bind_info); 1512 break; 1513 case DS_GET_DEVICE_INFO: 1514 err = get_device_info(s, &buf->bind_info, 1); 1515 break; 1516 case DS_GET_NEXT_DEVICE: 1517 err = get_device_info(s, &buf->bind_info, 0); 1518 break; 1519 case DS_UNBIND_REQUEST: 1520 err = 0; 1521 break; 1522 default: 1523 err = -EINVAL; 1524 } 1525 1526 if ((err == 0) && (ret != CS_SUCCESS)) { 1527 ds_dbg(2, "ds_ioctl: ret = %d\n", ret); 1528 switch (ret) { 1529 case CS_BAD_SOCKET: case CS_NO_CARD: 1530 err = -ENODEV; break; 1531 case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ: 1532 case CS_BAD_TUPLE: 1533 err = -EINVAL; break; 1534 case CS_IN_USE: 1535 err = -EBUSY; break; 1536 case CS_OUT_OF_RESOURCE: 1537 err = -ENOSPC; break; 1538 case CS_NO_MORE_ITEMS: 1539 err = -ENODATA; break; 1540 case CS_UNSUPPORTED_FUNCTION: 1541 err = -ENOSYS; break; 1542 default: 1543 err = -EIO; break; 1544 } 1545 } 1546 1547 if (cmd & IOC_OUT) { 1548 if (__copy_to_user(uarg, (char *)buf, size)) 1549 err = -EFAULT; 1550 } 1551 1552 free_out: 1553 kfree(buf); 1554 return err; 1555 } /* ds_ioctl */ 1556 1557 /*====================================================================*/ 1558 1559 static struct file_operations ds_fops = { 1560 .owner = THIS_MODULE, 1561 .open = ds_open, 1562 .release = ds_release, 1563 .ioctl = ds_ioctl, 1564 .read = ds_read, 1565 .write = ds_write, 1566 .poll = ds_poll, 1567 }; 1568 1569 static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev) 1570 { 1571 struct pcmcia_socket *socket = class_get_devdata(class_dev); 1572 struct pcmcia_bus_socket *s; 1573 int ret; 1574 1575 s = kmalloc(sizeof(struct pcmcia_bus_socket), GFP_KERNEL); 1576 if(!s) 1577 return -ENOMEM; 1578 memset(s, 0, sizeof(struct pcmcia_bus_socket)); 1579 1580 /* get reference to parent socket */ 1581 s->parent = pcmcia_get_socket(socket); 1582 if (!s->parent) { 1583 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket); 1584 kfree (s); 1585 return -ENODEV; 1586 } 1587 1588 kref_init(&s->refcount); 1589 1590 /* 1591 * Ugly. But we want to wait for the socket threads to have started up. 1592 * We really should let the drivers themselves drive some of this.. 1593 */ 1594 msleep(250); 1595 1596 init_waitqueue_head(&s->queue); 1597 INIT_LIST_HEAD(&s->devices_list); 1598 1599 /* Set up hotline to Card Services */ 1600 s->callback.owner = THIS_MODULE; 1601 s->callback.event = &ds_event; 1602 s->callback.resources_done = &pcmcia_card_add; 1603 socket->pcmcia = s; 1604 1605 ret = pccard_register_pcmcia(socket, &s->callback); 1606 if (ret) { 1607 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket); 1608 pcmcia_put_bus_socket(s); 1609 socket->pcmcia = NULL; 1610 return (ret); 1611 } 1612 1613 return 0; 1614 } 1615 1616 1617 static void pcmcia_bus_remove_socket(struct class_device *class_dev) 1618 { 1619 struct pcmcia_socket *socket = class_get_devdata(class_dev); 1620 1621 if (!socket || !socket->pcmcia) 1622 return; 1623 1624 pccard_register_pcmcia(socket, NULL); 1625 1626 socket->pcmcia->state |= DS_SOCKET_DEAD; 1627 pcmcia_put_bus_socket(socket->pcmcia); 1628 socket->pcmcia = NULL; 1629 1630 return; 1631 } 1632 1633 1634 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */ 1635 static struct class_interface pcmcia_bus_interface = { 1636 .class = &pcmcia_socket_class, 1637 .add = &pcmcia_bus_add_socket, 1638 .remove = &pcmcia_bus_remove_socket, 1639 }; 1640 1641 1642 struct bus_type pcmcia_bus_type = { 1643 .name = "pcmcia", 1644 .hotplug = pcmcia_bus_hotplug, 1645 .match = pcmcia_bus_match, 1646 .dev_attrs = pcmcia_dev_attrs, 1647 }; 1648 EXPORT_SYMBOL(pcmcia_bus_type); 1649 1650 1651 static int __init init_pcmcia_bus(void) 1652 { 1653 int i; 1654 1655 spin_lock_init(&pcmcia_dev_list_lock); 1656 1657 bus_register(&pcmcia_bus_type); 1658 class_interface_register(&pcmcia_bus_interface); 1659 1660 /* Set up character device for user mode clients */ 1661 i = register_chrdev(0, "pcmcia", &ds_fops); 1662 if (i < 0) 1663 printk(KERN_NOTICE "unable to find a free device # for " 1664 "Driver Services (error=%d)\n", i); 1665 else 1666 major_dev = i; 1667 1668 #ifdef CONFIG_PROC_FS 1669 proc_pccard = proc_mkdir("pccard", proc_bus); 1670 if (proc_pccard) 1671 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL); 1672 #endif 1673 1674 return 0; 1675 } 1676 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that 1677 * pcmcia_socket_class is already registered */ 1678 1679 1680 static void __exit exit_pcmcia_bus(void) 1681 { 1682 class_interface_unregister(&pcmcia_bus_interface); 1683 1684 #ifdef CONFIG_PROC_FS 1685 if (proc_pccard) { 1686 remove_proc_entry("drivers", proc_pccard); 1687 remove_proc_entry("pccard", proc_bus); 1688 } 1689 #endif 1690 if (major_dev != -1) 1691 unregister_chrdev(major_dev, "pcmcia"); 1692 1693 bus_unregister(&pcmcia_bus_type); 1694 } 1695 module_exit(exit_pcmcia_bus); 1696 1697 1698 1699 /* helpers for backwards-compatible functions */ 1700 1701 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr) 1702 { 1703 struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr); 1704 if (s && s->pcmcia) 1705 return s->pcmcia; 1706 else 1707 return NULL; 1708 } 1709 1710 /* backwards-compatible accessing of driver --- by name! */ 1711 1712 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info) 1713 { 1714 struct device_driver *drv; 1715 struct pcmcia_driver *p_drv; 1716 1717 drv = driver_find((char *) dev_info, &pcmcia_bus_type); 1718 if (!drv) 1719 return NULL; 1720 1721 p_drv = container_of(drv, struct pcmcia_driver, drv); 1722 1723 return (p_drv); 1724 } 1725 1726 MODULE_ALIAS("ds"); 1727