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