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
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, 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
60static 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
77static 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
94static 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
113static 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
126static 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)                                           \
147static 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}                                                                             \
154static DEVICE_ATTR_RO(name);
155
156MEMSTICK_ATTR(type, "%02X");
157MEMSTICK_ATTR(category, "%02X");
158MEMSTICK_ATTR(class, "%02X");
159
160static struct attribute *memstick_dev_attrs[] = {
161	&dev_attr_type.attr,
162	&dev_attr_category.attr,
163	&dev_attr_class.attr,
164	NULL,
165};
166ATTRIBUTE_GROUPS(memstick_dev);
167
168static 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
179static 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
186static struct class memstick_host_class = {
187	.name        = "memstick_host",
188	.dev_release = memstick_free
189};
190
191static 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
198static 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 */
207void memstick_detect_change(struct memstick_host *host)
208{
209	queue_work(workqueue, &host->media_checker);
210}
211EXPORT_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 */
223int 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}
243EXPORT_SYMBOL(memstick_next_req);
244
245/**
246 * memstick_new_req - notify the host that some requests are pending
247 * @host - host to use
248 */
249void 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}
257EXPORT_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 */
265void 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}
282EXPORT_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 */
295void 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}
315EXPORT_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
324static 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
348static 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 */
368int 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}
376EXPORT_SYMBOL(memstick_set_rw_addr);
377
378static 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;
413err_out:
414	host->card = old_card;
415	kfree_const(card->dev.kobj.name);
416	kfree(card);
417	return NULL;
418}
419
420static 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
430static 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
480out_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 */
494struct 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}
509EXPORT_SYMBOL(memstick_alloc_host);
510
511/**
512 * memstick_add_host - start request processing on memstick host
513 * @host - host to use
514 */
515int 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}
545EXPORT_SYMBOL(memstick_add_host);
546
547/**
548 * memstick_remove_host - stop request processing on memstick host
549 * @host - host to use
550 */
551void 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}
567EXPORT_SYMBOL(memstick_remove_host);
568
569/**
570 * memstick_free_host - free memstick host
571 * @host - host to use
572 */
573void memstick_free_host(struct memstick_host *host)
574{
575	mutex_destroy(&host->lock);
576	put_device(&host->dev);
577}
578EXPORT_SYMBOL(memstick_free_host);
579
580/**
581 * memstick_suspend_host - notify bus driver of host suspension
582 * @host - host to use
583 */
584void 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}
590EXPORT_SYMBOL(memstick_suspend_host);
591
592/**
593 * memstick_resume_host - notify bus driver of host resumption
594 * @host - host to use
595 */
596void 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}
608EXPORT_SYMBOL(memstick_resume_host);
609
610int memstick_register_driver(struct memstick_driver *drv)
611{
612	drv->driver.bus = &memstick_bus_type;
613
614	return driver_register(&drv->driver);
615}
616EXPORT_SYMBOL(memstick_register_driver);
617
618void memstick_unregister_driver(struct memstick_driver *drv)
619{
620	driver_unregister(&drv->driver);
621}
622EXPORT_SYMBOL(memstick_unregister_driver);
623
624
625static 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
643error_bus_unregister:
644	bus_unregister(&memstick_bus_type);
645error_destroy_workqueue:
646	destroy_workqueue(workqueue);
647
648	return rc;
649}
650
651static 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
659module_init(memstick_init);
660module_exit(memstick_exit);
661
662MODULE_AUTHOR("Alex Dubov");
663MODULE_LICENSE("GPL");
664MODULE_DESCRIPTION("Sony MemoryStick core driver");
665