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