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
memstick_dev_match(struct memstick_dev * card,const struct memstick_device_id * id)28 static int memstick_dev_match(struct memstick_dev *card,
29 const 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
memstick_bus_match(struct device * dev,const struct device_driver * drv)41 static 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 const 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
memstick_uevent(const struct device * dev,struct kobj_uevent_env * env)59 static 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
memstick_device_probe(struct device * dev)76 static 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
memstick_device_remove(struct device * dev)93 static 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_PM
110
memstick_device_suspend(struct device * dev,pm_message_t state)111 static 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
memstick_device_resume(struct device * dev)124 static 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 #else
138
139 #define memstick_device_suspend NULL
140 #define memstick_device_resume NULL
141
142 #endif /* CONFIG_PM */
143
144 #define MEMSTICK_ATTR(name, format) \
145 static 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 } \
152 static DEVICE_ATTR_RO(name);
153
154 MEMSTICK_ATTR(type, "%02X");
155 MEMSTICK_ATTR(category, "%02X");
156 MEMSTICK_ATTR(class, "%02X");
157
158 static struct attribute *memstick_dev_attrs[] = {
159 &dev_attr_type.attr,
160 &dev_attr_category.attr,
161 &dev_attr_class.attr,
162 NULL,
163 };
164 ATTRIBUTE_GROUPS(memstick_dev);
165
166 static 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_resume
175 };
176
memstick_free(struct device * dev)177 static 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
184 static struct class memstick_host_class = {
185 .name = "memstick_host",
186 .dev_release = memstick_free
187 };
188
memstick_free_card(struct device * dev)189 static 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
memstick_dummy_check(struct memstick_dev * card)196 static int memstick_dummy_check(struct memstick_dev *card)
197 {
198 return 0;
199 }
200
201 /**
202 * memstick_detect_change - schedule media detection on memstick host
203 * @host: host to use
204 */
memstick_detect_change(struct memstick_host * host)205 void memstick_detect_change(struct memstick_host *host)
206 {
207 queue_work(workqueue, &host->media_checker);
208 }
209 EXPORT_SYMBOL(memstick_detect_change);
210
211 /**
212 * memstick_next_req - called by host driver to obtain next request to process
213 * @host: host to use
214 * @mrq: pointer to stick the request to
215 *
216 * Host calls this function from idle state (*mrq == NULL) or after finishing
217 * previous request (*mrq should point to it). If previous request was
218 * unsuccessful, it is retried for predetermined number of times.
219 *
220 * Returns: value of 0 means that new request was assigned to the host.
221 * Otherwise a negative error code is returned.
222 */
memstick_next_req(struct memstick_host * host,struct memstick_request ** mrq)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 */
memstick_new_req(struct memstick_host * host)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 */
memstick_init_req_sg(struct memstick_request * mrq,unsigned char tpc,const struct scatterlist * sg)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 */
memstick_init_req(struct memstick_request * mrq,unsigned char tpc,const void * buf,size_t length)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
h_memstick_read_dev_id(struct memstick_dev * card,struct memstick_request ** mrq)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 }
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
h_memstick_set_rw_addr(struct memstick_dev * card,struct memstick_request ** mrq)347 static int h_memstick_set_rw_addr(struct memstick_dev *card,
348 struct memstick_request **mrq)
349 {
350 if (!(*mrq)) {
351 memstick_init_req(&card->current_mrq, MS_TPC_SET_RW_REG_ADRS,
352 (char *)&card->reg_addr,
353 sizeof(card->reg_addr));
354 *mrq = &card->current_mrq;
355 return 0;
356 } else {
357 complete(&card->mrq_complete);
358 return -EAGAIN;
359 }
360 }
361
362 /**
363 * memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to
364 * complete
365 * @card: media device to use
366 *
367 * Returns: error setting for the current request
368 */
memstick_set_rw_addr(struct memstick_dev * card)369 int memstick_set_rw_addr(struct memstick_dev *card)
370 {
371 card->next_request = h_memstick_set_rw_addr;
372 memstick_new_req(card->host);
373 if (!wait_for_completion_timeout(&card->mrq_complete,
374 msecs_to_jiffies(500)))
375 card->current_mrq.error = -ETIMEDOUT;
376
377 return card->current_mrq.error;
378 }
379 EXPORT_SYMBOL(memstick_set_rw_addr);
380
memstick_alloc_card(struct memstick_host * host)381 static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
382 {
383 struct memstick_dev *card = kzalloc_obj(struct memstick_dev);
384 struct memstick_dev *old_card = host->card;
385 struct ms_id_register id_reg;
386
387 if (card) {
388 card->host = host;
389 dev_set_name(&card->dev, "%s", dev_name(&host->dev));
390 card->dev.parent = &host->dev;
391 card->dev.bus = &memstick_bus_type;
392 card->dev.release = memstick_free_card;
393 card->check = memstick_dummy_check;
394
395 card->reg_addr.r_offset = offsetof(struct ms_register, id);
396 card->reg_addr.r_length = sizeof(id_reg);
397 card->reg_addr.w_offset = offsetof(struct ms_register, id);
398 card->reg_addr.w_length = sizeof(id_reg);
399
400 init_completion(&card->mrq_complete);
401
402 host->card = card;
403 if (memstick_set_rw_addr(card))
404 goto err_out;
405
406 card->next_request = h_memstick_read_dev_id;
407 memstick_new_req(host);
408 if (!wait_for_completion_timeout(&card->mrq_complete,
409 msecs_to_jiffies(500)))
410 card->current_mrq.error = -ETIMEDOUT;
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_const(card->dev.kobj.name);
420 kfree(card);
421 return NULL;
422 }
423
memstick_power_on(struct memstick_host * host)424 static int memstick_power_on(struct memstick_host *host)
425 {
426 int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
427
428 if (!rc)
429 rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
430
431 return rc;
432 }
433
memstick_check(struct work_struct * work)434 static void memstick_check(struct work_struct *work)
435 {
436 struct memstick_host *host = container_of(work, struct memstick_host,
437 media_checker);
438 struct memstick_dev *card;
439
440 dev_dbg(&host->dev, "memstick_check started\n");
441 pm_runtime_get_noresume(host->dev.parent);
442 mutex_lock(&host->lock);
443 if (!host->card) {
444 if (memstick_power_on(host))
445 goto out_power_off;
446 } else if (host->card->stop)
447 host->card->stop(host->card);
448
449 if (host->removing)
450 goto out_power_off;
451
452 card = memstick_alloc_card(host);
453
454 if (!card) {
455 if (host->card) {
456 device_unregister(&host->card->dev);
457 host->card = NULL;
458 }
459 } else {
460 dev_dbg(&host->dev, "new card %02x, %02x, %02x\n",
461 card->id.type, card->id.category, card->id.class);
462 if (host->card) {
463 if (memstick_set_rw_addr(host->card)
464 || !memstick_dev_match(host->card, &card->id)
465 || !(host->card->check(host->card))) {
466 device_unregister(&host->card->dev);
467 host->card = NULL;
468 } else if (host->card->start)
469 host->card->start(host->card);
470 }
471
472 if (!host->card) {
473 host->card = card;
474 if (device_register(&card->dev)) {
475 put_device(&card->dev);
476 host->card = NULL;
477 }
478 } else {
479 kfree_const(card->dev.kobj.name);
480 kfree(card);
481 }
482 }
483
484 out_power_off:
485 if (!host->card)
486 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
487
488 mutex_unlock(&host->lock);
489 pm_runtime_put(host->dev.parent);
490 dev_dbg(&host->dev, "memstick_check finished\n");
491 }
492
493 /**
494 * memstick_alloc_host - allocate a memstick_host structure
495 * @extra: size of the user private data to allocate
496 * @dev: parent device of the host
497 *
498 * Returns: %NULL on failure or the allocated &memstick_host pointer on success
499 */
memstick_alloc_host(unsigned int extra,struct device * dev)500 struct memstick_host *memstick_alloc_host(unsigned int extra,
501 struct device *dev)
502 {
503 struct memstick_host *host;
504
505 host = kzalloc(sizeof(struct memstick_host) + extra, GFP_KERNEL);
506 if (host) {
507 mutex_init(&host->lock);
508 INIT_WORK(&host->media_checker, memstick_check);
509 host->dev.class = &memstick_host_class;
510 host->dev.parent = dev;
511 device_initialize(&host->dev);
512 }
513 return host;
514 }
515 EXPORT_SYMBOL(memstick_alloc_host);
516
517 /**
518 * memstick_add_host - start request processing on memstick host
519 * @host: host to use
520 *
521 * Returns: %0 on success or a negative error code on failure
522 */
memstick_add_host(struct memstick_host * host)523 int memstick_add_host(struct memstick_host *host)
524 {
525 int rc;
526
527 idr_preload(GFP_KERNEL);
528 spin_lock(&memstick_host_lock);
529
530 rc = idr_alloc(&memstick_host_idr, host, 0, 0, GFP_NOWAIT);
531 if (rc >= 0)
532 host->id = rc;
533
534 spin_unlock(&memstick_host_lock);
535 idr_preload_end();
536 if (rc < 0)
537 return rc;
538
539 dev_set_name(&host->dev, "memstick%u", host->id);
540
541 rc = device_add(&host->dev);
542 if (rc) {
543 spin_lock(&memstick_host_lock);
544 idr_remove(&memstick_host_idr, host->id);
545 spin_unlock(&memstick_host_lock);
546 return rc;
547 }
548
549 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
550 memstick_detect_change(host);
551 return 0;
552 }
553 EXPORT_SYMBOL(memstick_add_host);
554
555 /**
556 * memstick_remove_host - stop request processing on memstick host
557 * @host: host to use
558 */
memstick_remove_host(struct memstick_host * host)559 void memstick_remove_host(struct memstick_host *host)
560 {
561 flush_workqueue(workqueue);
562 mutex_lock(&host->lock);
563 if (host->card)
564 device_unregister(&host->card->dev);
565 host->card = NULL;
566 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
567 mutex_unlock(&host->lock);
568
569 spin_lock(&memstick_host_lock);
570 idr_remove(&memstick_host_idr, host->id);
571 spin_unlock(&memstick_host_lock);
572 device_del(&host->dev);
573 }
574 EXPORT_SYMBOL(memstick_remove_host);
575
576 /**
577 * memstick_free_host - free memstick host
578 * @host: host to use
579 */
memstick_free_host(struct memstick_host * host)580 void memstick_free_host(struct memstick_host *host)
581 {
582 mutex_destroy(&host->lock);
583 put_device(&host->dev);
584 }
585 EXPORT_SYMBOL(memstick_free_host);
586
587 /**
588 * memstick_suspend_host - notify bus driver of host suspension
589 * @host: host to use
590 */
memstick_suspend_host(struct memstick_host * host)591 void memstick_suspend_host(struct memstick_host *host)
592 {
593 mutex_lock(&host->lock);
594 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
595 mutex_unlock(&host->lock);
596 }
597 EXPORT_SYMBOL(memstick_suspend_host);
598
599 /**
600 * memstick_resume_host - notify bus driver of host resumption
601 * @host: host to use
602 */
memstick_resume_host(struct memstick_host * host)603 void memstick_resume_host(struct memstick_host *host)
604 {
605 int rc = 0;
606
607 mutex_lock(&host->lock);
608 if (host->card)
609 rc = memstick_power_on(host);
610 mutex_unlock(&host->lock);
611
612 if (!rc)
613 memstick_detect_change(host);
614 }
615 EXPORT_SYMBOL(memstick_resume_host);
616
memstick_register_driver(struct memstick_driver * drv)617 int memstick_register_driver(struct memstick_driver *drv)
618 {
619 drv->driver.bus = &memstick_bus_type;
620
621 return driver_register(&drv->driver);
622 }
623 EXPORT_SYMBOL(memstick_register_driver);
624
memstick_unregister_driver(struct memstick_driver * drv)625 void memstick_unregister_driver(struct memstick_driver *drv)
626 {
627 driver_unregister(&drv->driver);
628 }
629 EXPORT_SYMBOL(memstick_unregister_driver);
630
631
memstick_init(void)632 static int __init memstick_init(void)
633 {
634 int rc;
635
636 workqueue = create_freezable_workqueue("kmemstick");
637 if (!workqueue)
638 return -ENOMEM;
639
640 rc = bus_register(&memstick_bus_type);
641 if (rc)
642 goto error_destroy_workqueue;
643
644 rc = class_register(&memstick_host_class);
645 if (rc)
646 goto error_bus_unregister;
647
648 return 0;
649
650 error_bus_unregister:
651 bus_unregister(&memstick_bus_type);
652 error_destroy_workqueue:
653 destroy_workqueue(workqueue);
654
655 return rc;
656 }
657
memstick_exit(void)658 static void __exit memstick_exit(void)
659 {
660 class_unregister(&memstick_host_class);
661 bus_unregister(&memstick_bus_type);
662 destroy_workqueue(workqueue);
663 idr_destroy(&memstick_host_idr);
664 }
665
666 module_init(memstick_init);
667 module_exit(memstick_exit);
668
669 MODULE_AUTHOR("Alex Dubov");
670 MODULE_LICENSE("GPL");
671 MODULE_DESCRIPTION("Sony MemoryStick core driver");
672