memstick/core/memstick.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  Sony MemoryStick support
0004  *
0005  *  Copyright (C) 2007 Alex Dubov <oakad@yahoo.com>
0006  *
0007  * Special thanks to Carlos Corbacho for providing various MemoryStick cards
0008  * that made this driver possible.
0009  */
0010
0011 #include <linux/memstick.h>
0012 #include <linux/idr.h>
0013 #include <linux/fs.h>
0014 #include <linux/delay.h>
0015 #include <linux/slab.h>
0016 #include <linux/module.h>
0017 #include <linux/pm_runtime.h>
0018
0019 #define DRIVER_NAME "memstick"
0020
0021 static unsigned int cmd_retries = 3;
0022 module_param(cmd_retries, uint, 0644);
0023
0024 static struct workqueue_struct *workqueue;
0025 static DEFINE_IDR(memstick_host_idr);
0026 static DEFINE_SPINLOCK(memstick_host_lock);
0027
0028 static int memstick_dev_match(struct memstick_dev *card,
0029                   struct memstick_device_id *id)
0030 {
0031     if (id->match_flags & MEMSTICK_MATCH_ALL) {
0032         if ((id->type == card->id.type)
0033             && (id->category == card->id.category)
0034             && (id->class == card->id.class))
0035             return 1;
0036     }
0037
0038     return 0;
0039 }
0040
0041 static int memstick_bus_match(struct device *dev, struct device_driver *drv)
0042 {
0043     struct memstick_dev *card = container_of(dev, struct memstick_dev,
0044                          dev);
0045     struct memstick_driver *ms_drv = container_of(drv,
0046                               struct memstick_driver,
0047                               driver);
0048     struct memstick_device_id *ids = ms_drv->id_table;
0049
0050     if (ids) {
0051         while (ids->match_flags) {
0052             if (memstick_dev_match(card, ids))
0053                 return 1;
0054             ++ids;
0055         }
0056     }
0057     return 0;
0058 }
0059
0060 static int memstick_uevent(struct device *dev, struct kobj_uevent_env *env)
0061 {
0062     struct memstick_dev *card = container_of(dev, struct memstick_dev,
0063                           dev);
0064
0065     if (add_uevent_var(env, "MEMSTICK_TYPE=%02X", card->id.type))
0066         return -ENOMEM;
0067
0068     if (add_uevent_var(env, "MEMSTICK_CATEGORY=%02X", card->id.category))
0069         return -ENOMEM;
0070
0071     if (add_uevent_var(env, "MEMSTICK_CLASS=%02X", card->id.class))
0072         return -ENOMEM;
0073
0074     return 0;
0075 }
0076
0077 static int memstick_device_probe(struct device *dev)
0078 {
0079     struct memstick_dev *card = container_of(dev, struct memstick_dev,
0080                          dev);
0081     struct memstick_driver *drv = container_of(dev->driver,
0082                            struct memstick_driver,
0083                            driver);
0084     int rc = -ENODEV;
0085
0086     if (dev->driver && drv->probe) {
0087         rc = drv->probe(card);
0088         if (!rc)
0089             get_device(dev);
0090     }
0091     return rc;
0092 }
0093
0094 static void memstick_device_remove(struct device *dev)
0095 {
0096     struct memstick_dev *card = container_of(dev, struct memstick_dev,
0097                           dev);
0098     struct memstick_driver *drv = container_of(dev->driver,
0099                            struct memstick_driver,
0100                            driver);
0101
0102     if (dev->driver && drv->remove) {
0103         drv->remove(card);
0104         card->dev.driver = NULL;
0105     }
0106
0107     put_device(dev);
0108 }
0109
0110 #ifdef CONFIG_PM
0111
0112 static int memstick_device_suspend(struct device *dev, pm_message_t state)
0113 {
0114     struct memstick_dev *card = container_of(dev, struct memstick_dev,
0115                           dev);
0116     struct memstick_driver *drv = container_of(dev->driver,
0117                            struct memstick_driver,
0118                            driver);
0119
0120     if (dev->driver && drv->suspend)
0121         return drv->suspend(card, state);
0122     return 0;
0123 }
0124
0125 static int memstick_device_resume(struct device *dev)
0126 {
0127     struct memstick_dev *card = container_of(dev, struct memstick_dev,
0128                           dev);
0129     struct memstick_driver *drv = container_of(dev->driver,
0130                            struct memstick_driver,
0131                            driver);
0132
0133     if (dev->driver && drv->resume)
0134         return drv->resume(card);
0135     return 0;
0136 }
0137
0138 #else
0139
0140 #define memstick_device_suspend NULL
0141 #define memstick_device_resume NULL
0142
0143 #endif /* CONFIG_PM */
0144
0145 #define MEMSTICK_ATTR(name, format)                                           \
0146 static ssize_t name##_show(struct device *dev, struct device_attribute *attr, \
0147                 char *buf)                                        \
0148 {                                                                             \
0149     struct memstick_dev *card = container_of(dev, struct memstick_dev,    \
0150                          dev);                        \
0151     return sprintf(buf, format, card->id.name);                           \
0152 }                                                                             \
0153 static DEVICE_ATTR_RO(name);
0154
0155 MEMSTICK_ATTR(type, "%02X");
0156 MEMSTICK_ATTR(category, "%02X");
0157 MEMSTICK_ATTR(class, "%02X");
0158
0159 static struct attribute *memstick_dev_attrs[] = {
0160     &dev_attr_type.attr,
0161     &dev_attr_category.attr,
0162     &dev_attr_class.attr,
0163     NULL,
0164 };
0165 ATTRIBUTE_GROUPS(memstick_dev);
0166
0167 static struct bus_type memstick_bus_type = {
0168     .name           = "memstick",
0169     .dev_groups = memstick_dev_groups,
0170     .match          = memstick_bus_match,
0171     .uevent         = memstick_uevent,
0172     .probe          = memstick_device_probe,
0173     .remove         = memstick_device_remove,
0174     .suspend        = memstick_device_suspend,
0175     .resume         = memstick_device_resume
0176 };
0177
0178 static void memstick_free(struct device *dev)
0179 {
0180     struct memstick_host *host = container_of(dev, struct memstick_host,
0181                           dev);
0182     kfree(host);
0183 }
0184
0185 static struct class memstick_host_class = {
0186     .name        = "memstick_host",
0187     .dev_release = memstick_free
0188 };
0189
0190 static void memstick_free_card(struct device *dev)
0191 {
0192     struct memstick_dev *card = container_of(dev, struct memstick_dev,
0193                          dev);
0194     kfree(card);
0195 }
0196
0197 static int memstick_dummy_check(struct memstick_dev *card)
0198 {
0199     return 0;
0200 }
0201
0202 /**
0203  * memstick_detect_change - schedule media detection on memstick host
0204  * @host - host to use
0205  */
0206 void memstick_detect_change(struct memstick_host *host)
0207 {
0208     queue_work(workqueue, &host->media_checker);
0209 }
0210 EXPORT_SYMBOL(memstick_detect_change);
0211
0212 /**
0213  * memstick_next_req - called by host driver to obtain next request to process
0214  * @host - host to use
0215  * @mrq - pointer to stick the request to
0216  *
0217  * Host calls this function from idle state (*mrq == NULL) or after finishing
0218  * previous request (*mrq should point to it). If previous request was
0219  * unsuccessful, it is retried for predetermined number of times. Return value
0220  * of 0 means that new request was assigned to the host.
0221  */
0222 int memstick_next_req(struct memstick_host *host, struct memstick_request **mrq)
0223 {
0224     int rc = -ENXIO;
0225
0226     if ((*mrq) && (*mrq)->error && host->retries) {
0227         (*mrq)->error = rc;
0228         host->retries--;
0229         return 0;
0230     }
0231
0232     if (host->card && host->card->next_request)
0233         rc = host->card->next_request(host->card, mrq);
0234
0235     if (!rc)
0236         host->retries = cmd_retries > 1 ? cmd_retries - 1 : 1;
0237     else
0238         *mrq = NULL;
0239
0240     return rc;
0241 }
0242 EXPORT_SYMBOL(memstick_next_req);
0243
0244 /**
0245  * memstick_new_req - notify the host that some requests are pending
0246  * @host - host to use
0247  */
0248 void memstick_new_req(struct memstick_host *host)
0249 {
0250     if (host->card) {
0251         host->retries = cmd_retries;
0252         reinit_completion(&host->card->mrq_complete);
0253         host->request(host);
0254     }
0255 }
0256 EXPORT_SYMBOL(memstick_new_req);
0257
0258 /**
0259  * memstick_init_req_sg - set request fields needed for bulk data transfer
0260  * @mrq - request to use
0261  * @tpc - memstick Transport Protocol Command
0262  * @sg - TPC argument
0263  */
0264 void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
0265               const struct scatterlist *sg)
0266 {
0267     mrq->tpc = tpc;
0268     if (tpc & 8)
0269         mrq->data_dir = WRITE;
0270     else
0271         mrq->data_dir = READ;
0272
0273     mrq->sg = *sg;
0274     mrq->long_data = 1;
0275
0276     if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
0277         mrq->need_card_int = 1;
0278     else
0279         mrq->need_card_int = 0;
0280 }
0281 EXPORT_SYMBOL(memstick_init_req_sg);
0282
0283 /**
0284  * memstick_init_req - set request fields needed for short data transfer
0285  * @mrq - request to use
0286  * @tpc - memstick Transport Protocol Command
0287  * @buf - TPC argument buffer
0288  * @length - TPC argument size
0289  *
0290  * The intended use of this function (transfer of data items several bytes
0291  * in size) allows us to just copy the value between request structure and
0292  * user supplied buffer.
0293  */
0294 void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
0295                const void *buf, size_t length)
0296 {
0297     mrq->tpc = tpc;
0298     if (tpc & 8)
0299         mrq->data_dir = WRITE;
0300     else
0301         mrq->data_dir = READ;
0302
0303     mrq->data_len = length > sizeof(mrq->data) ? sizeof(mrq->data) : length;
0304     if (mrq->data_dir == WRITE)
0305         memcpy(mrq->data, buf, mrq->data_len);
0306
0307     mrq->long_data = 0;
0308
0309     if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
0310         mrq->need_card_int = 1;
0311     else
0312         mrq->need_card_int = 0;
0313 }
0314 EXPORT_SYMBOL(memstick_init_req);
0315
0316 /*
0317  * Functions prefixed with "h_" are protocol callbacks. They can be called from
0318  * interrupt context. Return value of 0 means that request processing is still
0319  * ongoing, while special error value of -EAGAIN means that current request is
0320  * finished (and request processor should come back some time later).
0321  */
0322
0323 static int h_memstick_read_dev_id(struct memstick_dev *card,
0324                   struct memstick_request **mrq)
0325 {
0326     struct ms_id_register id_reg;
0327
0328     if (!(*mrq)) {
0329         memstick_init_req(&card->current_mrq, MS_TPC_READ_REG, &id_reg,
0330                   sizeof(struct ms_id_register));
0331         *mrq = &card->current_mrq;
0332         return 0;
0333     }
0334     if (!(*mrq)->error) {
0335         memcpy(&id_reg, (*mrq)->data, sizeof(id_reg));
0336         card->id.match_flags = MEMSTICK_MATCH_ALL;
0337         card->id.type = id_reg.type;
0338         card->id.category = id_reg.category;
0339         card->id.class = id_reg.class;
0340         dev_dbg(&card->dev, "if_mode = %02x\n", id_reg.if_mode);
0341     }
0342     complete(&card->mrq_complete);
0343     return -EAGAIN;
0344 }
0345
0346 static int h_memstick_set_rw_addr(struct memstick_dev *card,
0347                   struct memstick_request **mrq)
0348 {
0349     if (!(*mrq)) {
0350         memstick_init_req(&card->current_mrq, MS_TPC_SET_RW_REG_ADRS,
0351                   (char *)&card->reg_addr,
0352                   sizeof(card->reg_addr));
0353         *mrq = &card->current_mrq;
0354         return 0;
0355     } else {
0356         complete(&card->mrq_complete);
0357         return -EAGAIN;
0358     }
0359 }
0360
0361 /**
0362  * memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to
0363  *                        complete
0364  * @card - media device to use
0365  */
0366 int memstick_set_rw_addr(struct memstick_dev *card)
0367 {
0368     card->next_request = h_memstick_set_rw_addr;
0369     memstick_new_req(card->host);
0370     wait_for_completion(&card->mrq_complete);
0371
0372     return card->current_mrq.error;
0373 }
0374 EXPORT_SYMBOL(memstick_set_rw_addr);
0375
0376 static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
0377 {
0378     struct memstick_dev *card = kzalloc(sizeof(struct memstick_dev),
0379                         GFP_KERNEL);
0380     struct memstick_dev *old_card = host->card;
0381     struct ms_id_register id_reg;
0382
0383     if (card) {
0384         card->host = host;
0385         dev_set_name(&card->dev, "%s", dev_name(&host->dev));
0386         card->dev.parent = &host->dev;
0387         card->dev.bus = &memstick_bus_type;
0388         card->dev.release = memstick_free_card;
0389         card->check = memstick_dummy_check;
0390
0391         card->reg_addr.r_offset = offsetof(struct ms_register, id);
0392         card->reg_addr.r_length = sizeof(id_reg);
0393         card->reg_addr.w_offset = offsetof(struct ms_register, id);
0394         card->reg_addr.w_length = sizeof(id_reg);
0395
0396         init_completion(&card->mrq_complete);
0397
0398         host->card = card;
0399         if (memstick_set_rw_addr(card))
0400             goto err_out;
0401
0402         card->next_request = h_memstick_read_dev_id;
0403         memstick_new_req(host);
0404         wait_for_completion(&card->mrq_complete);
0405
0406         if (card->current_mrq.error)
0407             goto err_out;
0408     }
0409     host->card = old_card;
0410     return card;
0411 err_out:
0412     host->card = old_card;
0413     kfree(card);
0414     return NULL;
0415 }
0416
0417 static int memstick_power_on(struct memstick_host *host)
0418 {
0419     int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
0420
0421     if (!rc)
0422         rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
0423
0424     return rc;
0425 }
0426
0427 static void memstick_check(struct work_struct *work)
0428 {
0429     struct memstick_host *host = container_of(work, struct memstick_host,
0430                           media_checker);
0431     struct memstick_dev *card;
0432
0433     dev_dbg(&host->dev, "memstick_check started\n");
0434     pm_runtime_get_noresume(host->dev.parent);
0435     mutex_lock(&host->lock);
0436     if (!host->card) {
0437         if (memstick_power_on(host))
0438             goto out_power_off;
0439     } else if (host->card->stop)
0440         host->card->stop(host->card);
0441
0442     if (host->removing)
0443         goto out_power_off;
0444
0445     card = memstick_alloc_card(host);
0446
0447     if (!card) {
0448         if (host->card) {
0449             device_unregister(&host->card->dev);
0450             host->card = NULL;
0451         }
0452     } else {
0453         dev_dbg(&host->dev, "new card %02x, %02x, %02x\n",
0454             card->id.type, card->id.category, card->id.class);
0455         if (host->card) {
0456             if (memstick_set_rw_addr(host->card)
0457                 || !memstick_dev_match(host->card, &card->id)
0458                 || !(host->card->check(host->card))) {
0459                 device_unregister(&host->card->dev);
0460                 host->card = NULL;
0461             } else if (host->card->start)
0462                 host->card->start(host->card);
0463         }
0464
0465         if (!host->card) {
0466             host->card = card;
0467             if (device_register(&card->dev)) {
0468                 put_device(&card->dev);
0469                 host->card = NULL;
0470             }
0471         } else
0472             kfree(card);
0473     }
0474
0475 out_power_off:
0476     if (!host->card)
0477         host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
0478
0479     mutex_unlock(&host->lock);
0480     pm_runtime_put(host->dev.parent);
0481     dev_dbg(&host->dev, "memstick_check finished\n");
0482 }
0483
0484 /**
0485  * memstick_alloc_host - allocate a memstick_host structure
0486  * @extra: size of the user private data to allocate
0487  * @dev: parent device of the host
0488  */
0489 struct memstick_host *memstick_alloc_host(unsigned int extra,
0490                       struct device *dev)
0491 {
0492     struct memstick_host *host;
0493
0494     host = kzalloc(sizeof(struct memstick_host) + extra, GFP_KERNEL);
0495     if (host) {
0496         mutex_init(&host->lock);
0497         INIT_WORK(&host->media_checker, memstick_check);
0498         host->dev.class = &memstick_host_class;
0499         host->dev.parent = dev;
0500         device_initialize(&host->dev);
0501     }
0502     return host;
0503 }
0504 EXPORT_SYMBOL(memstick_alloc_host);
0505
0506 /**
0507  * memstick_add_host - start request processing on memstick host
0508  * @host - host to use
0509  */
0510 int memstick_add_host(struct memstick_host *host)
0511 {
0512     int rc;
0513
0514     idr_preload(GFP_KERNEL);
0515     spin_lock(&memstick_host_lock);
0516
0517     rc = idr_alloc(&memstick_host_idr, host, 0, 0, GFP_NOWAIT);
0518     if (rc >= 0)
0519         host->id = rc;
0520
0521     spin_unlock(&memstick_host_lock);
0522     idr_preload_end();
0523     if (rc < 0)
0524         return rc;
0525
0526     dev_set_name(&host->dev, "memstick%u", host->id);
0527
0528     rc = device_add(&host->dev);
0529     if (rc) {
0530         spin_lock(&memstick_host_lock);
0531         idr_remove(&memstick_host_idr, host->id);
0532         spin_unlock(&memstick_host_lock);
0533         return rc;
0534     }
0535
0536     host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
0537     memstick_detect_change(host);
0538     return 0;
0539 }
0540 EXPORT_SYMBOL(memstick_add_host);
0541
0542 /**
0543  * memstick_remove_host - stop request processing on memstick host
0544  * @host - host to use
0545  */
0546 void memstick_remove_host(struct memstick_host *host)
0547 {
0548     host->removing = 1;
0549     flush_workqueue(workqueue);
0550     mutex_lock(&host->lock);
0551     if (host->card)
0552         device_unregister(&host->card->dev);
0553     host->card = NULL;
0554     host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
0555     mutex_unlock(&host->lock);
0556
0557     spin_lock(&memstick_host_lock);
0558     idr_remove(&memstick_host_idr, host->id);
0559     spin_unlock(&memstick_host_lock);
0560     device_del(&host->dev);
0561 }
0562 EXPORT_SYMBOL(memstick_remove_host);
0563
0564 /**
0565  * memstick_free_host - free memstick host
0566  * @host - host to use
0567  */
0568 void memstick_free_host(struct memstick_host *host)
0569 {
0570     mutex_destroy(&host->lock);
0571     put_device(&host->dev);
0572 }
0573 EXPORT_SYMBOL(memstick_free_host);
0574
0575 /**
0576  * memstick_suspend_host - notify bus driver of host suspension
0577  * @host - host to use
0578  */
0579 void memstick_suspend_host(struct memstick_host *host)
0580 {
0581     mutex_lock(&host->lock);
0582     host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
0583     mutex_unlock(&host->lock);
0584 }
0585 EXPORT_SYMBOL(memstick_suspend_host);
0586
0587 /**
0588  * memstick_resume_host - notify bus driver of host resumption
0589  * @host - host to use
0590  */
0591 void memstick_resume_host(struct memstick_host *host)
0592 {
0593     int rc = 0;
0594
0595     mutex_lock(&host->lock);
0596     if (host->card)
0597         rc = memstick_power_on(host);
0598     mutex_unlock(&host->lock);
0599
0600     if (!rc)
0601         memstick_detect_change(host);
0602 }
0603 EXPORT_SYMBOL(memstick_resume_host);
0604
0605 int memstick_register_driver(struct memstick_driver *drv)
0606 {
0607     drv->driver.bus = &memstick_bus_type;
0608
0609     return driver_register(&drv->driver);
0610 }
0611 EXPORT_SYMBOL(memstick_register_driver);
0612
0613 void memstick_unregister_driver(struct memstick_driver *drv)
0614 {
0615     driver_unregister(&drv->driver);
0616 }
0617 EXPORT_SYMBOL(memstick_unregister_driver);
0618
0619
0620 static int __init memstick_init(void)
0621 {
0622     int rc;
0623
0624     workqueue = create_freezable_workqueue("kmemstick");
0625     if (!workqueue)
0626         return -ENOMEM;
0627
0628     rc = bus_register(&memstick_bus_type);
0629     if (rc)
0630         goto error_destroy_workqueue;
0631
0632     rc = class_register(&memstick_host_class);
0633     if (rc)
0634         goto error_bus_unregister;
0635
0636     return 0;
0637
0638 error_bus_unregister:
0639     bus_unregister(&memstick_bus_type);
0640 error_destroy_workqueue:
0641     destroy_workqueue(workqueue);
0642
0643     return rc;
0644 }
0645
0646 static void __exit memstick_exit(void)
0647 {
0648     class_unregister(&memstick_host_class);
0649     bus_unregister(&memstick_bus_type);
0650     destroy_workqueue(workqueue);
0651     idr_destroy(&memstick_host_idr);
0652 }
0653
0654 module_init(memstick_init);
0655 module_exit(memstick_exit);
0656
0657 MODULE_AUTHOR("Alex Dubov");
0658 MODULE_LICENSE("GPL");
0659 MODULE_DESCRIPTION("Sony MemoryStick core driver");