1 /* 2 * Sony MemoryStick support 3 * 4 * Copyright (C) 2007 Alex Dubov <oakad@yahoo.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 * 10 * Special thanks to Carlos Corbacho for providing various MemoryStick cards 11 * that made this driver possible. 12 * 13 */ 14 15 #include <linux/memstick.h> 16 #include <linux/idr.h> 17 #include <linux/fs.h> 18 #include <linux/delay.h> 19 #include <linux/slab.h> 20 #include <linux/module.h> 21 #include <linux/pm_runtime.h> 22 23 #define DRIVER_NAME "memstick" 24 25 static unsigned int cmd_retries = 3; 26 module_param(cmd_retries, uint, 0644); 27 28 static struct workqueue_struct *workqueue; 29 static DEFINE_IDR(memstick_host_idr); 30 static DEFINE_SPINLOCK(memstick_host_lock); 31 32 static int memstick_dev_match(struct memstick_dev *card, 33 struct memstick_device_id *id) 34 { 35 if (id->match_flags & MEMSTICK_MATCH_ALL) { 36 if ((id->type == card->id.type) 37 && (id->category == card->id.category) 38 && (id->class == card->id.class)) 39 return 1; 40 } 41 42 return 0; 43 } 44 45 static int memstick_bus_match(struct device *dev, struct device_driver *drv) 46 { 47 struct memstick_dev *card = container_of(dev, struct memstick_dev, 48 dev); 49 struct memstick_driver *ms_drv = container_of(drv, 50 struct memstick_driver, 51 driver); 52 struct memstick_device_id *ids = ms_drv->id_table; 53 54 if (ids) { 55 while (ids->match_flags) { 56 if (memstick_dev_match(card, ids)) 57 return 1; 58 ++ids; 59 } 60 } 61 return 0; 62 } 63 64 static int memstick_uevent(struct device *dev, struct kobj_uevent_env *env) 65 { 66 struct memstick_dev *card = container_of(dev, struct memstick_dev, 67 dev); 68 69 if (add_uevent_var(env, "MEMSTICK_TYPE=%02X", card->id.type)) 70 return -ENOMEM; 71 72 if (add_uevent_var(env, "MEMSTICK_CATEGORY=%02X", card->id.category)) 73 return -ENOMEM; 74 75 if (add_uevent_var(env, "MEMSTICK_CLASS=%02X", card->id.class)) 76 return -ENOMEM; 77 78 return 0; 79 } 80 81 static int memstick_device_probe(struct device *dev) 82 { 83 struct memstick_dev *card = container_of(dev, struct memstick_dev, 84 dev); 85 struct memstick_driver *drv = container_of(dev->driver, 86 struct memstick_driver, 87 driver); 88 int rc = -ENODEV; 89 90 if (dev->driver && drv->probe) { 91 rc = drv->probe(card); 92 if (!rc) 93 get_device(dev); 94 } 95 return rc; 96 } 97 98 static int memstick_device_remove(struct device *dev) 99 { 100 struct memstick_dev *card = container_of(dev, struct memstick_dev, 101 dev); 102 struct memstick_driver *drv = container_of(dev->driver, 103 struct memstick_driver, 104 driver); 105 106 if (dev->driver && drv->remove) { 107 drv->remove(card); 108 card->dev.driver = NULL; 109 } 110 111 put_device(dev); 112 return 0; 113 } 114 115 #ifdef CONFIG_PM 116 117 static int memstick_device_suspend(struct device *dev, pm_message_t state) 118 { 119 struct memstick_dev *card = container_of(dev, struct memstick_dev, 120 dev); 121 struct memstick_driver *drv = container_of(dev->driver, 122 struct memstick_driver, 123 driver); 124 125 if (dev->driver && drv->suspend) 126 return drv->suspend(card, state); 127 return 0; 128 } 129 130 static int memstick_device_resume(struct device *dev) 131 { 132 struct memstick_dev *card = container_of(dev, struct memstick_dev, 133 dev); 134 struct memstick_driver *drv = container_of(dev->driver, 135 struct memstick_driver, 136 driver); 137 138 if (dev->driver && drv->resume) 139 return drv->resume(card); 140 return 0; 141 } 142 143 #else 144 145 #define memstick_device_suspend NULL 146 #define memstick_device_resume NULL 147 148 #endif /* CONFIG_PM */ 149 150 #define MEMSTICK_ATTR(name, format) \ 151 static ssize_t name##_show(struct device *dev, struct device_attribute *attr, \ 152 char *buf) \ 153 { \ 154 struct memstick_dev *card = container_of(dev, struct memstick_dev, \ 155 dev); \ 156 return sprintf(buf, format, card->id.name); \ 157 } \ 158 static DEVICE_ATTR_RO(name); 159 160 MEMSTICK_ATTR(type, "%02X"); 161 MEMSTICK_ATTR(category, "%02X"); 162 MEMSTICK_ATTR(class, "%02X"); 163 164 static struct attribute *memstick_dev_attrs[] = { 165 &dev_attr_type.attr, 166 &dev_attr_category.attr, 167 &dev_attr_class.attr, 168 NULL, 169 }; 170 ATTRIBUTE_GROUPS(memstick_dev); 171 172 static struct bus_type memstick_bus_type = { 173 .name = "memstick", 174 .dev_groups = memstick_dev_groups, 175 .match = memstick_bus_match, 176 .uevent = memstick_uevent, 177 .probe = memstick_device_probe, 178 .remove = memstick_device_remove, 179 .suspend = memstick_device_suspend, 180 .resume = memstick_device_resume 181 }; 182 183 static void memstick_free(struct device *dev) 184 { 185 struct memstick_host *host = container_of(dev, struct memstick_host, 186 dev); 187 kfree(host); 188 } 189 190 static struct class memstick_host_class = { 191 .name = "memstick_host", 192 .dev_release = memstick_free 193 }; 194 195 static void memstick_free_card(struct device *dev) 196 { 197 struct memstick_dev *card = container_of(dev, struct memstick_dev, 198 dev); 199 kfree(card); 200 } 201 202 static int memstick_dummy_check(struct memstick_dev *card) 203 { 204 return 0; 205 } 206 207 /** 208 * memstick_detect_change - schedule media detection on memstick host 209 * @host - host to use 210 */ 211 void memstick_detect_change(struct memstick_host *host) 212 { 213 queue_work(workqueue, &host->media_checker); 214 } 215 EXPORT_SYMBOL(memstick_detect_change); 216 217 /** 218 * memstick_next_req - called by host driver to obtain next request to process 219 * @host - host to use 220 * @mrq - pointer to stick the request to 221 * 222 * Host calls this function from idle state (*mrq == NULL) or after finishing 223 * previous request (*mrq should point to it). If previous request was 224 * unsuccessful, it is retried for predetermined number of times. Return value 225 * of 0 means that new request was assigned to the host. 226 */ 227 int memstick_next_req(struct memstick_host *host, struct memstick_request **mrq) 228 { 229 int rc = -ENXIO; 230 231 if ((*mrq) && (*mrq)->error && host->retries) { 232 (*mrq)->error = rc; 233 host->retries--; 234 return 0; 235 } 236 237 if (host->card && host->card->next_request) 238 rc = host->card->next_request(host->card, mrq); 239 240 if (!rc) 241 host->retries = cmd_retries > 1 ? cmd_retries - 1 : 1; 242 else 243 *mrq = NULL; 244 245 return rc; 246 } 247 EXPORT_SYMBOL(memstick_next_req); 248 249 /** 250 * memstick_new_req - notify the host that some requests are pending 251 * @host - host to use 252 */ 253 void memstick_new_req(struct memstick_host *host) 254 { 255 if (host->card) { 256 host->retries = cmd_retries; 257 reinit_completion(&host->card->mrq_complete); 258 host->request(host); 259 } 260 } 261 EXPORT_SYMBOL(memstick_new_req); 262 263 /** 264 * memstick_init_req_sg - set request fields needed for bulk data transfer 265 * @mrq - request to use 266 * @tpc - memstick Transport Protocol Command 267 * @sg - TPC argument 268 */ 269 void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc, 270 const struct scatterlist *sg) 271 { 272 mrq->tpc = tpc; 273 if (tpc & 8) 274 mrq->data_dir = WRITE; 275 else 276 mrq->data_dir = READ; 277 278 mrq->sg = *sg; 279 mrq->long_data = 1; 280 281 if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD) 282 mrq->need_card_int = 1; 283 else 284 mrq->need_card_int = 0; 285 } 286 EXPORT_SYMBOL(memstick_init_req_sg); 287 288 /** 289 * memstick_init_req - set request fields needed for short data transfer 290 * @mrq - request to use 291 * @tpc - memstick Transport Protocol Command 292 * @buf - TPC argument buffer 293 * @length - TPC argument size 294 * 295 * The intended use of this function (transfer of data items several bytes 296 * in size) allows us to just copy the value between request structure and 297 * user supplied buffer. 298 */ 299 void memstick_init_req(struct memstick_request *mrq, unsigned char tpc, 300 const void *buf, size_t length) 301 { 302 mrq->tpc = tpc; 303 if (tpc & 8) 304 mrq->data_dir = WRITE; 305 else 306 mrq->data_dir = READ; 307 308 mrq->data_len = length > sizeof(mrq->data) ? sizeof(mrq->data) : length; 309 if (mrq->data_dir == WRITE) 310 memcpy(mrq->data, buf, mrq->data_len); 311 312 mrq->long_data = 0; 313 314 if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD) 315 mrq->need_card_int = 1; 316 else 317 mrq->need_card_int = 0; 318 } 319 EXPORT_SYMBOL(memstick_init_req); 320 321 /* 322 * Functions prefixed with "h_" are protocol callbacks. They can be called from 323 * interrupt context. Return value of 0 means that request processing is still 324 * ongoing, while special error value of -EAGAIN means that current request is 325 * finished (and request processor should come back some time later). 326 */ 327 328 static int h_memstick_read_dev_id(struct memstick_dev *card, 329 struct memstick_request **mrq) 330 { 331 struct ms_id_register id_reg; 332 333 if (!(*mrq)) { 334 memstick_init_req(&card->current_mrq, MS_TPC_READ_REG, &id_reg, 335 sizeof(struct ms_id_register)); 336 *mrq = &card->current_mrq; 337 return 0; 338 } else { 339 if (!(*mrq)->error) { 340 memcpy(&id_reg, (*mrq)->data, sizeof(id_reg)); 341 card->id.match_flags = MEMSTICK_MATCH_ALL; 342 card->id.type = id_reg.type; 343 card->id.category = id_reg.category; 344 card->id.class = id_reg.class; 345 dev_dbg(&card->dev, "if_mode = %02x\n", id_reg.if_mode); 346 } 347 complete(&card->mrq_complete); 348 return -EAGAIN; 349 } 350 } 351 352 static int h_memstick_set_rw_addr(struct memstick_dev *card, 353 struct memstick_request **mrq) 354 { 355 if (!(*mrq)) { 356 memstick_init_req(&card->current_mrq, MS_TPC_SET_RW_REG_ADRS, 357 (char *)&card->reg_addr, 358 sizeof(card->reg_addr)); 359 *mrq = &card->current_mrq; 360 return 0; 361 } else { 362 complete(&card->mrq_complete); 363 return -EAGAIN; 364 } 365 } 366 367 /** 368 * memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to 369 * complete 370 * @card - media device to use 371 */ 372 int memstick_set_rw_addr(struct memstick_dev *card) 373 { 374 card->next_request = h_memstick_set_rw_addr; 375 memstick_new_req(card->host); 376 wait_for_completion(&card->mrq_complete); 377 378 return card->current_mrq.error; 379 } 380 EXPORT_SYMBOL(memstick_set_rw_addr); 381 382 static struct memstick_dev *memstick_alloc_card(struct memstick_host *host) 383 { 384 struct memstick_dev *card = kzalloc(sizeof(struct memstick_dev), 385 GFP_KERNEL); 386 struct memstick_dev *old_card = host->card; 387 struct ms_id_register id_reg; 388 389 if (card) { 390 card->host = host; 391 dev_set_name(&card->dev, "%s", dev_name(&host->dev)); 392 card->dev.parent = &host->dev; 393 card->dev.bus = &memstick_bus_type; 394 card->dev.release = memstick_free_card; 395 card->check = memstick_dummy_check; 396 397 card->reg_addr.r_offset = offsetof(struct ms_register, id); 398 card->reg_addr.r_length = sizeof(id_reg); 399 card->reg_addr.w_offset = offsetof(struct ms_register, id); 400 card->reg_addr.w_length = sizeof(id_reg); 401 402 init_completion(&card->mrq_complete); 403 404 host->card = card; 405 if (memstick_set_rw_addr(card)) 406 goto err_out; 407 408 card->next_request = h_memstick_read_dev_id; 409 memstick_new_req(host); 410 wait_for_completion(&card->mrq_complete); 411 412 if (card->current_mrq.error) 413 goto err_out; 414 } 415 host->card = old_card; 416 return card; 417 err_out: 418 host->card = old_card; 419 kfree(card); 420 return NULL; 421 } 422 423 static int memstick_power_on(struct memstick_host *host) 424 { 425 int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON); 426 427 if (!rc) 428 rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL); 429 430 return rc; 431 } 432 433 static void memstick_check(struct work_struct *work) 434 { 435 struct memstick_host *host = container_of(work, struct memstick_host, 436 media_checker); 437 struct memstick_dev *card; 438 439 dev_dbg(&host->dev, "memstick_check started\n"); 440 pm_runtime_get_noresume(host->dev.parent); 441 mutex_lock(&host->lock); 442 if (!host->card) { 443 if (memstick_power_on(host)) 444 goto out_power_off; 445 } else if (host->card->stop) 446 host->card->stop(host->card); 447 448 card = memstick_alloc_card(host); 449 450 if (!card) { 451 if (host->card) { 452 device_unregister(&host->card->dev); 453 host->card = NULL; 454 } 455 } else { 456 dev_dbg(&host->dev, "new card %02x, %02x, %02x\n", 457 card->id.type, card->id.category, card->id.class); 458 if (host->card) { 459 if (memstick_set_rw_addr(host->card) 460 || !memstick_dev_match(host->card, &card->id) 461 || !(host->card->check(host->card))) { 462 device_unregister(&host->card->dev); 463 host->card = NULL; 464 } else if (host->card->start) 465 host->card->start(host->card); 466 } 467 468 if (!host->card) { 469 host->card = card; 470 if (device_register(&card->dev)) { 471 put_device(&card->dev); 472 kfree(host->card); 473 host->card = NULL; 474 } 475 } else 476 kfree(card); 477 } 478 479 out_power_off: 480 if (!host->card) 481 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF); 482 483 mutex_unlock(&host->lock); 484 pm_runtime_put(host->dev.parent); 485 dev_dbg(&host->dev, "memstick_check finished\n"); 486 } 487 488 /** 489 * memstick_alloc_host - allocate a memstick_host structure 490 * @extra: size of the user private data to allocate 491 * @dev: parent device of the host 492 */ 493 struct memstick_host *memstick_alloc_host(unsigned int extra, 494 struct device *dev) 495 { 496 struct memstick_host *host; 497 498 host = kzalloc(sizeof(struct memstick_host) + extra, GFP_KERNEL); 499 if (host) { 500 mutex_init(&host->lock); 501 INIT_WORK(&host->media_checker, memstick_check); 502 host->dev.class = &memstick_host_class; 503 host->dev.parent = dev; 504 device_initialize(&host->dev); 505 } 506 return host; 507 } 508 EXPORT_SYMBOL(memstick_alloc_host); 509 510 /** 511 * memstick_add_host - start request processing on memstick host 512 * @host - host to use 513 */ 514 int memstick_add_host(struct memstick_host *host) 515 { 516 int rc; 517 518 idr_preload(GFP_KERNEL); 519 spin_lock(&memstick_host_lock); 520 521 rc = idr_alloc(&memstick_host_idr, host, 0, 0, GFP_NOWAIT); 522 if (rc >= 0) 523 host->id = rc; 524 525 spin_unlock(&memstick_host_lock); 526 idr_preload_end(); 527 if (rc < 0) 528 return rc; 529 530 dev_set_name(&host->dev, "memstick%u", host->id); 531 532 rc = device_add(&host->dev); 533 if (rc) { 534 spin_lock(&memstick_host_lock); 535 idr_remove(&memstick_host_idr, host->id); 536 spin_unlock(&memstick_host_lock); 537 return rc; 538 } 539 540 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF); 541 memstick_detect_change(host); 542 return 0; 543 } 544 EXPORT_SYMBOL(memstick_add_host); 545 546 /** 547 * memstick_remove_host - stop request processing on memstick host 548 * @host - host to use 549 */ 550 void memstick_remove_host(struct memstick_host *host) 551 { 552 flush_workqueue(workqueue); 553 mutex_lock(&host->lock); 554 if (host->card) 555 device_unregister(&host->card->dev); 556 host->card = NULL; 557 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF); 558 mutex_unlock(&host->lock); 559 560 spin_lock(&memstick_host_lock); 561 idr_remove(&memstick_host_idr, host->id); 562 spin_unlock(&memstick_host_lock); 563 device_del(&host->dev); 564 } 565 EXPORT_SYMBOL(memstick_remove_host); 566 567 /** 568 * memstick_free_host - free memstick host 569 * @host - host to use 570 */ 571 void memstick_free_host(struct memstick_host *host) 572 { 573 mutex_destroy(&host->lock); 574 put_device(&host->dev); 575 } 576 EXPORT_SYMBOL(memstick_free_host); 577 578 /** 579 * memstick_suspend_host - notify bus driver of host suspension 580 * @host - host to use 581 */ 582 void memstick_suspend_host(struct memstick_host *host) 583 { 584 mutex_lock(&host->lock); 585 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF); 586 mutex_unlock(&host->lock); 587 } 588 EXPORT_SYMBOL(memstick_suspend_host); 589 590 /** 591 * memstick_resume_host - notify bus driver of host resumption 592 * @host - host to use 593 */ 594 void memstick_resume_host(struct memstick_host *host) 595 { 596 int rc = 0; 597 598 mutex_lock(&host->lock); 599 if (host->card) 600 rc = memstick_power_on(host); 601 mutex_unlock(&host->lock); 602 603 if (!rc) 604 memstick_detect_change(host); 605 } 606 EXPORT_SYMBOL(memstick_resume_host); 607 608 int memstick_register_driver(struct memstick_driver *drv) 609 { 610 drv->driver.bus = &memstick_bus_type; 611 612 return driver_register(&drv->driver); 613 } 614 EXPORT_SYMBOL(memstick_register_driver); 615 616 void memstick_unregister_driver(struct memstick_driver *drv) 617 { 618 driver_unregister(&drv->driver); 619 } 620 EXPORT_SYMBOL(memstick_unregister_driver); 621 622 623 static int __init memstick_init(void) 624 { 625 int rc; 626 627 workqueue = create_freezable_workqueue("kmemstick"); 628 if (!workqueue) 629 return -ENOMEM; 630 631 rc = bus_register(&memstick_bus_type); 632 if (!rc) 633 rc = class_register(&memstick_host_class); 634 635 if (!rc) 636 return 0; 637 638 bus_unregister(&memstick_bus_type); 639 destroy_workqueue(workqueue); 640 641 return rc; 642 } 643 644 static void __exit memstick_exit(void) 645 { 646 class_unregister(&memstick_host_class); 647 bus_unregister(&memstick_bus_type); 648 destroy_workqueue(workqueue); 649 idr_destroy(&memstick_host_idr); 650 } 651 652 module_init(memstick_init); 653 module_exit(memstick_exit); 654 655 MODULE_AUTHOR("Alex Dubov"); 656 MODULE_LICENSE("GPL"); 657 MODULE_DESCRIPTION("Sony MemoryStick core driver"); 658