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