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