1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
2baf8532aSAlex Dubov /*
3baf8532aSAlex Dubov * Sony MemoryStick support
4baf8532aSAlex Dubov *
5baf8532aSAlex Dubov * Copyright (C) 2007 Alex Dubov <oakad@yahoo.com>
6baf8532aSAlex Dubov *
7baf8532aSAlex Dubov * Special thanks to Carlos Corbacho for providing various MemoryStick cards
8baf8532aSAlex Dubov * that made this driver possible.
9baf8532aSAlex Dubov */
10baf8532aSAlex Dubov
11baf8532aSAlex Dubov #include <linux/memstick.h>
12baf8532aSAlex Dubov #include <linux/idr.h>
13baf8532aSAlex Dubov #include <linux/fs.h>
14baf8532aSAlex Dubov #include <linux/delay.h>
155a0e3ad6STejun Heo #include <linux/slab.h>
16c47e7893SPaul Gortmaker #include <linux/module.h>
17e03e303eSKai-Heng Feng #include <linux/pm_runtime.h>
18baf8532aSAlex Dubov
19baf8532aSAlex Dubov #define DRIVER_NAME "memstick"
20baf8532aSAlex Dubov
21baf8532aSAlex Dubov static unsigned int cmd_retries = 3;
22baf8532aSAlex Dubov module_param(cmd_retries, uint, 0644);
23baf8532aSAlex Dubov
24baf8532aSAlex Dubov static struct workqueue_struct *workqueue;
25baf8532aSAlex Dubov static DEFINE_IDR(memstick_host_idr);
26baf8532aSAlex Dubov static DEFINE_SPINLOCK(memstick_host_lock);
27baf8532aSAlex Dubov
memstick_dev_match(struct memstick_dev * card,struct memstick_device_id * id)28baf8532aSAlex Dubov static int memstick_dev_match(struct memstick_dev *card,
29baf8532aSAlex Dubov struct memstick_device_id *id)
30baf8532aSAlex Dubov {
31baf8532aSAlex Dubov if (id->match_flags & MEMSTICK_MATCH_ALL) {
32baf8532aSAlex Dubov if ((id->type == card->id.type)
33baf8532aSAlex Dubov && (id->category == card->id.category)
34baf8532aSAlex Dubov && (id->class == card->id.class))
35baf8532aSAlex Dubov return 1;
36baf8532aSAlex Dubov }
37baf8532aSAlex Dubov
38baf8532aSAlex Dubov return 0;
39baf8532aSAlex Dubov }
40baf8532aSAlex Dubov
memstick_bus_match(struct device * dev,const struct device_driver * drv)41*d69d8048SGreg Kroah-Hartman static int memstick_bus_match(struct device *dev, const struct device_driver *drv)
42baf8532aSAlex Dubov {
43baf8532aSAlex Dubov struct memstick_dev *card = container_of(dev, struct memstick_dev,
44baf8532aSAlex Dubov dev);
45*d69d8048SGreg Kroah-Hartman const struct memstick_driver *ms_drv = container_of_const(drv, struct memstick_driver,
46baf8532aSAlex Dubov driver);
47baf8532aSAlex Dubov struct memstick_device_id *ids = ms_drv->id_table;
48baf8532aSAlex Dubov
49baf8532aSAlex Dubov if (ids) {
50baf8532aSAlex Dubov while (ids->match_flags) {
51baf8532aSAlex Dubov if (memstick_dev_match(card, ids))
52baf8532aSAlex Dubov return 1;
53baf8532aSAlex Dubov ++ids;
54baf8532aSAlex Dubov }
55baf8532aSAlex Dubov }
56baf8532aSAlex Dubov return 0;
57baf8532aSAlex Dubov }
58baf8532aSAlex Dubov
memstick_uevent(const struct device * dev,struct kobj_uevent_env * env)592a81ada3SGreg Kroah-Hartman static int memstick_uevent(const struct device *dev, struct kobj_uevent_env *env)
60baf8532aSAlex Dubov {
612a81ada3SGreg Kroah-Hartman const struct memstick_dev *card = container_of_const(dev, struct memstick_dev,
62baf8532aSAlex Dubov dev);
63baf8532aSAlex Dubov
64baf8532aSAlex Dubov if (add_uevent_var(env, "MEMSTICK_TYPE=%02X", card->id.type))
65baf8532aSAlex Dubov return -ENOMEM;
66baf8532aSAlex Dubov
67baf8532aSAlex Dubov if (add_uevent_var(env, "MEMSTICK_CATEGORY=%02X", card->id.category))
68baf8532aSAlex Dubov return -ENOMEM;
69baf8532aSAlex Dubov
70baf8532aSAlex Dubov if (add_uevent_var(env, "MEMSTICK_CLASS=%02X", card->id.class))
71baf8532aSAlex Dubov return -ENOMEM;
72baf8532aSAlex Dubov
73baf8532aSAlex Dubov return 0;
74baf8532aSAlex Dubov }
75baf8532aSAlex Dubov
memstick_device_probe(struct device * dev)76baf8532aSAlex Dubov static int memstick_device_probe(struct device *dev)
77baf8532aSAlex Dubov {
78baf8532aSAlex Dubov struct memstick_dev *card = container_of(dev, struct memstick_dev,
79baf8532aSAlex Dubov dev);
80baf8532aSAlex Dubov struct memstick_driver *drv = container_of(dev->driver,
81baf8532aSAlex Dubov struct memstick_driver,
82baf8532aSAlex Dubov driver);
83baf8532aSAlex Dubov int rc = -ENODEV;
84baf8532aSAlex Dubov
85baf8532aSAlex Dubov if (dev->driver && drv->probe) {
86baf8532aSAlex Dubov rc = drv->probe(card);
87baf8532aSAlex Dubov if (!rc)
88baf8532aSAlex Dubov get_device(dev);
89baf8532aSAlex Dubov }
90baf8532aSAlex Dubov return rc;
91baf8532aSAlex Dubov }
92baf8532aSAlex Dubov
memstick_device_remove(struct device * dev)93fc7a6209SUwe Kleine-König static void memstick_device_remove(struct device *dev)
94baf8532aSAlex Dubov {
95baf8532aSAlex Dubov struct memstick_dev *card = container_of(dev, struct memstick_dev,
96baf8532aSAlex Dubov dev);
97baf8532aSAlex Dubov struct memstick_driver *drv = container_of(dev->driver,
98baf8532aSAlex Dubov struct memstick_driver,
99baf8532aSAlex Dubov driver);
100baf8532aSAlex Dubov
101baf8532aSAlex Dubov if (dev->driver && drv->remove) {
102baf8532aSAlex Dubov drv->remove(card);
103baf8532aSAlex Dubov card->dev.driver = NULL;
104baf8532aSAlex Dubov }
105baf8532aSAlex Dubov
106baf8532aSAlex Dubov put_device(dev);
107baf8532aSAlex Dubov }
108baf8532aSAlex Dubov
109baf8532aSAlex Dubov #ifdef CONFIG_PM
110baf8532aSAlex Dubov
memstick_device_suspend(struct device * dev,pm_message_t state)111baf8532aSAlex Dubov static int memstick_device_suspend(struct device *dev, pm_message_t state)
112baf8532aSAlex Dubov {
113baf8532aSAlex Dubov struct memstick_dev *card = container_of(dev, struct memstick_dev,
114baf8532aSAlex Dubov dev);
115baf8532aSAlex Dubov struct memstick_driver *drv = container_of(dev->driver,
116baf8532aSAlex Dubov struct memstick_driver,
117baf8532aSAlex Dubov driver);
118baf8532aSAlex Dubov
119baf8532aSAlex Dubov if (dev->driver && drv->suspend)
120baf8532aSAlex Dubov return drv->suspend(card, state);
121baf8532aSAlex Dubov return 0;
122baf8532aSAlex Dubov }
123baf8532aSAlex Dubov
memstick_device_resume(struct device * dev)124baf8532aSAlex Dubov static int memstick_device_resume(struct device *dev)
125baf8532aSAlex Dubov {
126baf8532aSAlex Dubov struct memstick_dev *card = container_of(dev, struct memstick_dev,
127baf8532aSAlex Dubov dev);
128baf8532aSAlex Dubov struct memstick_driver *drv = container_of(dev->driver,
129baf8532aSAlex Dubov struct memstick_driver,
130baf8532aSAlex Dubov driver);
131baf8532aSAlex Dubov
132baf8532aSAlex Dubov if (dev->driver && drv->resume)
133baf8532aSAlex Dubov return drv->resume(card);
134baf8532aSAlex Dubov return 0;
135baf8532aSAlex Dubov }
136baf8532aSAlex Dubov
137baf8532aSAlex Dubov #else
138baf8532aSAlex Dubov
139baf8532aSAlex Dubov #define memstick_device_suspend NULL
140baf8532aSAlex Dubov #define memstick_device_resume NULL
141baf8532aSAlex Dubov
142baf8532aSAlex Dubov #endif /* CONFIG_PM */
143baf8532aSAlex Dubov
144baf8532aSAlex Dubov #define MEMSTICK_ATTR(name, format) \
145baf8532aSAlex Dubov static ssize_t name##_show(struct device *dev, struct device_attribute *attr, \
146baf8532aSAlex Dubov char *buf) \
147baf8532aSAlex Dubov { \
148baf8532aSAlex Dubov struct memstick_dev *card = container_of(dev, struct memstick_dev, \
149baf8532aSAlex Dubov dev); \
150baf8532aSAlex Dubov return sprintf(buf, format, card->id.name); \
151b785464bSGreg Kroah-Hartman } \
152b785464bSGreg Kroah-Hartman static DEVICE_ATTR_RO(name);
153baf8532aSAlex Dubov
154baf8532aSAlex Dubov MEMSTICK_ATTR(type, "%02X");
155baf8532aSAlex Dubov MEMSTICK_ATTR(category, "%02X");
156baf8532aSAlex Dubov MEMSTICK_ATTR(class, "%02X");
157baf8532aSAlex Dubov
158b785464bSGreg Kroah-Hartman static struct attribute *memstick_dev_attrs[] = {
159b785464bSGreg Kroah-Hartman &dev_attr_type.attr,
160b785464bSGreg Kroah-Hartman &dev_attr_category.attr,
161b785464bSGreg Kroah-Hartman &dev_attr_class.attr,
162b785464bSGreg Kroah-Hartman NULL,
163baf8532aSAlex Dubov };
164b785464bSGreg Kroah-Hartman ATTRIBUTE_GROUPS(memstick_dev);
165baf8532aSAlex Dubov
166cb8e8570SRicardo B. Marliere static const struct bus_type memstick_bus_type = {
167baf8532aSAlex Dubov .name = "memstick",
168b785464bSGreg Kroah-Hartman .dev_groups = memstick_dev_groups,
169baf8532aSAlex Dubov .match = memstick_bus_match,
170baf8532aSAlex Dubov .uevent = memstick_uevent,
171baf8532aSAlex Dubov .probe = memstick_device_probe,
172baf8532aSAlex Dubov .remove = memstick_device_remove,
173baf8532aSAlex Dubov .suspend = memstick_device_suspend,
174baf8532aSAlex Dubov .resume = memstick_device_resume
175baf8532aSAlex Dubov };
176baf8532aSAlex Dubov
memstick_free(struct device * dev)177c4c66cf1SGreg Kroah-Hartman static void memstick_free(struct device *dev)
178baf8532aSAlex Dubov {
179c4c66cf1SGreg Kroah-Hartman struct memstick_host *host = container_of(dev, struct memstick_host,
180c4c66cf1SGreg Kroah-Hartman dev);
181baf8532aSAlex Dubov kfree(host);
182baf8532aSAlex Dubov }
183baf8532aSAlex Dubov
184baf8532aSAlex Dubov static struct class memstick_host_class = {
185baf8532aSAlex Dubov .name = "memstick_host",
186c4c66cf1SGreg Kroah-Hartman .dev_release = memstick_free
187baf8532aSAlex Dubov };
188baf8532aSAlex Dubov
memstick_free_card(struct device * dev)189baf8532aSAlex Dubov static void memstick_free_card(struct device *dev)
190baf8532aSAlex Dubov {
191baf8532aSAlex Dubov struct memstick_dev *card = container_of(dev, struct memstick_dev,
192baf8532aSAlex Dubov dev);
193baf8532aSAlex Dubov kfree(card);
194baf8532aSAlex Dubov }
195baf8532aSAlex Dubov
memstick_dummy_check(struct memstick_dev * card)196baf8532aSAlex Dubov static int memstick_dummy_check(struct memstick_dev *card)
197baf8532aSAlex Dubov {
198baf8532aSAlex Dubov return 0;
199baf8532aSAlex Dubov }
200baf8532aSAlex Dubov
201baf8532aSAlex Dubov /**
202baf8532aSAlex Dubov * memstick_detect_change - schedule media detection on memstick host
203baf8532aSAlex Dubov * @host - host to use
204baf8532aSAlex Dubov */
memstick_detect_change(struct memstick_host * host)205baf8532aSAlex Dubov void memstick_detect_change(struct memstick_host *host)
206baf8532aSAlex Dubov {
207baf8532aSAlex Dubov queue_work(workqueue, &host->media_checker);
208baf8532aSAlex Dubov }
209baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_detect_change);
210baf8532aSAlex Dubov
211baf8532aSAlex Dubov /**
212baf8532aSAlex Dubov * memstick_next_req - called by host driver to obtain next request to process
213baf8532aSAlex Dubov * @host - host to use
214baf8532aSAlex Dubov * @mrq - pointer to stick the request to
215baf8532aSAlex Dubov *
216baf8532aSAlex Dubov * Host calls this function from idle state (*mrq == NULL) or after finishing
217baf8532aSAlex Dubov * previous request (*mrq should point to it). If previous request was
218baf8532aSAlex Dubov * unsuccessful, it is retried for predetermined number of times. Return value
219baf8532aSAlex Dubov * of 0 means that new request was assigned to the host.
220baf8532aSAlex Dubov */
memstick_next_req(struct memstick_host * host,struct memstick_request ** mrq)221baf8532aSAlex Dubov int memstick_next_req(struct memstick_host *host, struct memstick_request **mrq)
222baf8532aSAlex Dubov {
223baf8532aSAlex Dubov int rc = -ENXIO;
224baf8532aSAlex Dubov
225baf8532aSAlex Dubov if ((*mrq) && (*mrq)->error && host->retries) {
226baf8532aSAlex Dubov (*mrq)->error = rc;
227baf8532aSAlex Dubov host->retries--;
228baf8532aSAlex Dubov return 0;
229baf8532aSAlex Dubov }
230baf8532aSAlex Dubov
231baf8532aSAlex Dubov if (host->card && host->card->next_request)
232baf8532aSAlex Dubov rc = host->card->next_request(host->card, mrq);
233baf8532aSAlex Dubov
234baf8532aSAlex Dubov if (!rc)
23529196dc6SAlex Dubov host->retries = cmd_retries > 1 ? cmd_retries - 1 : 1;
236baf8532aSAlex Dubov else
237baf8532aSAlex Dubov *mrq = NULL;
238baf8532aSAlex Dubov
239baf8532aSAlex Dubov return rc;
240baf8532aSAlex Dubov }
241baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_next_req);
242baf8532aSAlex Dubov
243baf8532aSAlex Dubov /**
244baf8532aSAlex Dubov * memstick_new_req - notify the host that some requests are pending
245baf8532aSAlex Dubov * @host - host to use
246baf8532aSAlex Dubov */
memstick_new_req(struct memstick_host * host)247baf8532aSAlex Dubov void memstick_new_req(struct memstick_host *host)
248baf8532aSAlex Dubov {
249f1d82698SAlex Dubov if (host->card) {
250baf8532aSAlex Dubov host->retries = cmd_retries;
25116735d02SWolfram Sang reinit_completion(&host->card->mrq_complete);
252baf8532aSAlex Dubov host->request(host);
253baf8532aSAlex Dubov }
254f1d82698SAlex Dubov }
255baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_new_req);
256baf8532aSAlex Dubov
257baf8532aSAlex Dubov /**
258baf8532aSAlex Dubov * memstick_init_req_sg - set request fields needed for bulk data transfer
259baf8532aSAlex Dubov * @mrq - request to use
260baf8532aSAlex Dubov * @tpc - memstick Transport Protocol Command
261baf8532aSAlex Dubov * @sg - TPC argument
262baf8532aSAlex Dubov */
memstick_init_req_sg(struct memstick_request * mrq,unsigned char tpc,const struct scatterlist * sg)263baf8532aSAlex Dubov void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
2648e82f8c3SAlex Dubov const struct scatterlist *sg)
265baf8532aSAlex Dubov {
266baf8532aSAlex Dubov mrq->tpc = tpc;
267baf8532aSAlex Dubov if (tpc & 8)
268baf8532aSAlex Dubov mrq->data_dir = WRITE;
269baf8532aSAlex Dubov else
270baf8532aSAlex Dubov mrq->data_dir = READ;
271baf8532aSAlex Dubov
272baf8532aSAlex Dubov mrq->sg = *sg;
273e1f19995SAlex Dubov mrq->long_data = 1;
274baf8532aSAlex Dubov
275baf8532aSAlex Dubov if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
276baf8532aSAlex Dubov mrq->need_card_int = 1;
277baf8532aSAlex Dubov else
278baf8532aSAlex Dubov mrq->need_card_int = 0;
279baf8532aSAlex Dubov }
280baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_init_req_sg);
281baf8532aSAlex Dubov
282baf8532aSAlex Dubov /**
283baf8532aSAlex Dubov * memstick_init_req - set request fields needed for short data transfer
284baf8532aSAlex Dubov * @mrq - request to use
285baf8532aSAlex Dubov * @tpc - memstick Transport Protocol Command
286baf8532aSAlex Dubov * @buf - TPC argument buffer
287baf8532aSAlex Dubov * @length - TPC argument size
288baf8532aSAlex Dubov *
289baf8532aSAlex Dubov * The intended use of this function (transfer of data items several bytes
290baf8532aSAlex Dubov * in size) allows us to just copy the value between request structure and
291baf8532aSAlex Dubov * user supplied buffer.
292baf8532aSAlex Dubov */
memstick_init_req(struct memstick_request * mrq,unsigned char tpc,const void * buf,size_t length)293baf8532aSAlex Dubov void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
2948e82f8c3SAlex Dubov const void *buf, size_t length)
295baf8532aSAlex Dubov {
296baf8532aSAlex Dubov mrq->tpc = tpc;
297baf8532aSAlex Dubov if (tpc & 8)
298baf8532aSAlex Dubov mrq->data_dir = WRITE;
299baf8532aSAlex Dubov else
300baf8532aSAlex Dubov mrq->data_dir = READ;
301baf8532aSAlex Dubov
302baf8532aSAlex Dubov mrq->data_len = length > sizeof(mrq->data) ? sizeof(mrq->data) : length;
303baf8532aSAlex Dubov if (mrq->data_dir == WRITE)
304baf8532aSAlex Dubov memcpy(mrq->data, buf, mrq->data_len);
305baf8532aSAlex Dubov
306e1f19995SAlex Dubov mrq->long_data = 0;
307baf8532aSAlex Dubov
308baf8532aSAlex Dubov if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
309baf8532aSAlex Dubov mrq->need_card_int = 1;
310baf8532aSAlex Dubov else
311baf8532aSAlex Dubov mrq->need_card_int = 0;
312baf8532aSAlex Dubov }
313baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_init_req);
314baf8532aSAlex Dubov
315baf8532aSAlex Dubov /*
316baf8532aSAlex Dubov * Functions prefixed with "h_" are protocol callbacks. They can be called from
317baf8532aSAlex Dubov * interrupt context. Return value of 0 means that request processing is still
318baf8532aSAlex Dubov * ongoing, while special error value of -EAGAIN means that current request is
319baf8532aSAlex Dubov * finished (and request processor should come back some time later).
320baf8532aSAlex Dubov */
321baf8532aSAlex Dubov
h_memstick_read_dev_id(struct memstick_dev * card,struct memstick_request ** mrq)322baf8532aSAlex Dubov static int h_memstick_read_dev_id(struct memstick_dev *card,
323baf8532aSAlex Dubov struct memstick_request **mrq)
324baf8532aSAlex Dubov {
325baf8532aSAlex Dubov struct ms_id_register id_reg;
326baf8532aSAlex Dubov
327baf8532aSAlex Dubov if (!(*mrq)) {
328de182cc8SArnd Bergmann memstick_init_req(&card->current_mrq, MS_TPC_READ_REG, &id_reg,
329baf8532aSAlex Dubov sizeof(struct ms_id_register));
330baf8532aSAlex Dubov *mrq = &card->current_mrq;
331baf8532aSAlex Dubov return 0;
3329a8a369bSJoey Pabalan }
333baf8532aSAlex Dubov if (!(*mrq)->error) {
334baf8532aSAlex Dubov memcpy(&id_reg, (*mrq)->data, sizeof(id_reg));
335baf8532aSAlex Dubov card->id.match_flags = MEMSTICK_MATCH_ALL;
336baf8532aSAlex Dubov card->id.type = id_reg.type;
337baf8532aSAlex Dubov card->id.category = id_reg.category;
338baf8532aSAlex Dubov card->id.class = id_reg.class;
339b873c2f3SJiri Slaby dev_dbg(&card->dev, "if_mode = %02x\n", id_reg.if_mode);
340baf8532aSAlex Dubov }
341baf8532aSAlex Dubov complete(&card->mrq_complete);
342baf8532aSAlex Dubov return -EAGAIN;
343baf8532aSAlex Dubov }
344baf8532aSAlex Dubov
h_memstick_set_rw_addr(struct memstick_dev * card,struct memstick_request ** mrq)345baf8532aSAlex Dubov static int h_memstick_set_rw_addr(struct memstick_dev *card,
346baf8532aSAlex Dubov struct memstick_request **mrq)
347baf8532aSAlex Dubov {
348baf8532aSAlex Dubov if (!(*mrq)) {
349baf8532aSAlex Dubov memstick_init_req(&card->current_mrq, MS_TPC_SET_RW_REG_ADRS,
350baf8532aSAlex Dubov (char *)&card->reg_addr,
351baf8532aSAlex Dubov sizeof(card->reg_addr));
352baf8532aSAlex Dubov *mrq = &card->current_mrq;
353baf8532aSAlex Dubov return 0;
354baf8532aSAlex Dubov } else {
355baf8532aSAlex Dubov complete(&card->mrq_complete);
356baf8532aSAlex Dubov return -EAGAIN;
357baf8532aSAlex Dubov }
358baf8532aSAlex Dubov }
359baf8532aSAlex Dubov
360baf8532aSAlex Dubov /**
361baf8532aSAlex Dubov * memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to
362baf8532aSAlex Dubov * complete
363baf8532aSAlex Dubov * @card - media device to use
364baf8532aSAlex Dubov */
memstick_set_rw_addr(struct memstick_dev * card)365baf8532aSAlex Dubov int memstick_set_rw_addr(struct memstick_dev *card)
366baf8532aSAlex Dubov {
367baf8532aSAlex Dubov card->next_request = h_memstick_set_rw_addr;
368baf8532aSAlex Dubov memstick_new_req(card->host);
369baf8532aSAlex Dubov wait_for_completion(&card->mrq_complete);
370baf8532aSAlex Dubov
371baf8532aSAlex Dubov return card->current_mrq.error;
372baf8532aSAlex Dubov }
373baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_set_rw_addr);
374baf8532aSAlex Dubov
memstick_alloc_card(struct memstick_host * host)375baf8532aSAlex Dubov static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
376baf8532aSAlex Dubov {
377baf8532aSAlex Dubov struct memstick_dev *card = kzalloc(sizeof(struct memstick_dev),
378baf8532aSAlex Dubov GFP_KERNEL);
379baf8532aSAlex Dubov struct memstick_dev *old_card = host->card;
380baf8532aSAlex Dubov struct ms_id_register id_reg;
381baf8532aSAlex Dubov
382baf8532aSAlex Dubov if (card) {
383baf8532aSAlex Dubov card->host = host;
3840252c3b4SKay Sievers dev_set_name(&card->dev, "%s", dev_name(&host->dev));
385c4c66cf1SGreg Kroah-Hartman card->dev.parent = &host->dev;
386baf8532aSAlex Dubov card->dev.bus = &memstick_bus_type;
387baf8532aSAlex Dubov card->dev.release = memstick_free_card;
388baf8532aSAlex Dubov card->check = memstick_dummy_check;
389baf8532aSAlex Dubov
390baf8532aSAlex Dubov card->reg_addr.r_offset = offsetof(struct ms_register, id);
391baf8532aSAlex Dubov card->reg_addr.r_length = sizeof(id_reg);
392baf8532aSAlex Dubov card->reg_addr.w_offset = offsetof(struct ms_register, id);
393baf8532aSAlex Dubov card->reg_addr.w_length = sizeof(id_reg);
394baf8532aSAlex Dubov
395baf8532aSAlex Dubov init_completion(&card->mrq_complete);
396baf8532aSAlex Dubov
397baf8532aSAlex Dubov host->card = card;
398baf8532aSAlex Dubov if (memstick_set_rw_addr(card))
399baf8532aSAlex Dubov goto err_out;
400baf8532aSAlex Dubov
401baf8532aSAlex Dubov card->next_request = h_memstick_read_dev_id;
402baf8532aSAlex Dubov memstick_new_req(host);
403baf8532aSAlex Dubov wait_for_completion(&card->mrq_complete);
404baf8532aSAlex Dubov
405baf8532aSAlex Dubov if (card->current_mrq.error)
406baf8532aSAlex Dubov goto err_out;
407baf8532aSAlex Dubov }
408baf8532aSAlex Dubov host->card = old_card;
409baf8532aSAlex Dubov return card;
410baf8532aSAlex Dubov err_out:
411baf8532aSAlex Dubov host->card = old_card;
4124b6d621cSGreg Kroah-Hartman kfree_const(card->dev.kobj.name);
413baf8532aSAlex Dubov kfree(card);
414baf8532aSAlex Dubov return NULL;
415baf8532aSAlex Dubov }
416baf8532aSAlex Dubov
memstick_power_on(struct memstick_host * host)417b7789998SAlex Dubov static int memstick_power_on(struct memstick_host *host)
418baf8532aSAlex Dubov {
419b7789998SAlex Dubov int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
420b7789998SAlex Dubov
421b7789998SAlex Dubov if (!rc)
422b7789998SAlex Dubov rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
423b7789998SAlex Dubov
424b7789998SAlex Dubov return rc;
425baf8532aSAlex Dubov }
426baf8532aSAlex Dubov
memstick_check(struct work_struct * work)427baf8532aSAlex Dubov static void memstick_check(struct work_struct *work)
428baf8532aSAlex Dubov {
429baf8532aSAlex Dubov struct memstick_host *host = container_of(work, struct memstick_host,
430baf8532aSAlex Dubov media_checker);
431baf8532aSAlex Dubov struct memstick_dev *card;
432baf8532aSAlex Dubov
433c4c66cf1SGreg Kroah-Hartman dev_dbg(&host->dev, "memstick_check started\n");
434e03e303eSKai-Heng Feng pm_runtime_get_noresume(host->dev.parent);
435baf8532aSAlex Dubov mutex_lock(&host->lock);
43617017d8dSAlex Dubov if (!host->card) {
43717017d8dSAlex Dubov if (memstick_power_on(host))
43817017d8dSAlex Dubov goto out_power_off;
4398e82f8c3SAlex Dubov } else if (host->card->stop)
44017017d8dSAlex Dubov host->card->stop(host->card);
441baf8532aSAlex Dubov
44262c59a87SKai-Heng Feng if (host->removing)
44362c59a87SKai-Heng Feng goto out_power_off;
44462c59a87SKai-Heng Feng
445baf8532aSAlex Dubov card = memstick_alloc_card(host);
446baf8532aSAlex Dubov
447baf8532aSAlex Dubov if (!card) {
448baf8532aSAlex Dubov if (host->card) {
449baf8532aSAlex Dubov device_unregister(&host->card->dev);
450baf8532aSAlex Dubov host->card = NULL;
451baf8532aSAlex Dubov }
452baf8532aSAlex Dubov } else {
453c4c66cf1SGreg Kroah-Hartman dev_dbg(&host->dev, "new card %02x, %02x, %02x\n",
454baf8532aSAlex Dubov card->id.type, card->id.category, card->id.class);
455baf8532aSAlex Dubov if (host->card) {
456baf8532aSAlex Dubov if (memstick_set_rw_addr(host->card)
457baf8532aSAlex Dubov || !memstick_dev_match(host->card, &card->id)
458baf8532aSAlex Dubov || !(host->card->check(host->card))) {
459baf8532aSAlex Dubov device_unregister(&host->card->dev);
460baf8532aSAlex Dubov host->card = NULL;
4618e82f8c3SAlex Dubov } else if (host->card->start)
46217017d8dSAlex Dubov host->card->start(host->card);
463baf8532aSAlex Dubov }
464baf8532aSAlex Dubov
465baf8532aSAlex Dubov if (!host->card) {
466baf8532aSAlex Dubov host->card = card;
467baf8532aSAlex Dubov if (device_register(&card->dev)) {
4680193383aSVasiliy Kulikov put_device(&card->dev);
469baf8532aSAlex Dubov host->card = NULL;
470baf8532aSAlex Dubov }
4714b6d621cSGreg Kroah-Hartman } else {
4724b6d621cSGreg Kroah-Hartman kfree_const(card->dev.kobj.name);
473baf8532aSAlex Dubov kfree(card);
474baf8532aSAlex Dubov }
4754b6d621cSGreg Kroah-Hartman }
476baf8532aSAlex Dubov
47717017d8dSAlex Dubov out_power_off:
478baf8532aSAlex Dubov if (!host->card)
479baf8532aSAlex Dubov host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
480baf8532aSAlex Dubov
481baf8532aSAlex Dubov mutex_unlock(&host->lock);
482e03e303eSKai-Heng Feng pm_runtime_put(host->dev.parent);
483c4c66cf1SGreg Kroah-Hartman dev_dbg(&host->dev, "memstick_check finished\n");
484baf8532aSAlex Dubov }
485baf8532aSAlex Dubov
486baf8532aSAlex Dubov /**
487baf8532aSAlex Dubov * memstick_alloc_host - allocate a memstick_host structure
488baf8532aSAlex Dubov * @extra: size of the user private data to allocate
489baf8532aSAlex Dubov * @dev: parent device of the host
490baf8532aSAlex Dubov */
memstick_alloc_host(unsigned int extra,struct device * dev)491baf8532aSAlex Dubov struct memstick_host *memstick_alloc_host(unsigned int extra,
492baf8532aSAlex Dubov struct device *dev)
493baf8532aSAlex Dubov {
494baf8532aSAlex Dubov struct memstick_host *host;
495baf8532aSAlex Dubov
496baf8532aSAlex Dubov host = kzalloc(sizeof(struct memstick_host) + extra, GFP_KERNEL);
497baf8532aSAlex Dubov if (host) {
498baf8532aSAlex Dubov mutex_init(&host->lock);
499baf8532aSAlex Dubov INIT_WORK(&host->media_checker, memstick_check);
500c4c66cf1SGreg Kroah-Hartman host->dev.class = &memstick_host_class;
501c4c66cf1SGreg Kroah-Hartman host->dev.parent = dev;
502c4c66cf1SGreg Kroah-Hartman device_initialize(&host->dev);
503baf8532aSAlex Dubov }
504baf8532aSAlex Dubov return host;
505baf8532aSAlex Dubov }
506baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_alloc_host);
507baf8532aSAlex Dubov
508baf8532aSAlex Dubov /**
509baf8532aSAlex Dubov * memstick_add_host - start request processing on memstick host
510baf8532aSAlex Dubov * @host - host to use
511baf8532aSAlex Dubov */
memstick_add_host(struct memstick_host * host)512baf8532aSAlex Dubov int memstick_add_host(struct memstick_host *host)
513baf8532aSAlex Dubov {
514baf8532aSAlex Dubov int rc;
515baf8532aSAlex Dubov
5167b51f478STejun Heo idr_preload(GFP_KERNEL);
517baf8532aSAlex Dubov spin_lock(&memstick_host_lock);
5187b51f478STejun Heo
5197b51f478STejun Heo rc = idr_alloc(&memstick_host_idr, host, 0, 0, GFP_NOWAIT);
5207b51f478STejun Heo if (rc >= 0)
5217b51f478STejun Heo host->id = rc;
5227b51f478STejun Heo
523baf8532aSAlex Dubov spin_unlock(&memstick_host_lock);
5247b51f478STejun Heo idr_preload_end();
5257b51f478STejun Heo if (rc < 0)
526baf8532aSAlex Dubov return rc;
527baf8532aSAlex Dubov
5280252c3b4SKay Sievers dev_set_name(&host->dev, "memstick%u", host->id);
529baf8532aSAlex Dubov
530c4c66cf1SGreg Kroah-Hartman rc = device_add(&host->dev);
531baf8532aSAlex Dubov if (rc) {
532baf8532aSAlex Dubov spin_lock(&memstick_host_lock);
533baf8532aSAlex Dubov idr_remove(&memstick_host_idr, host->id);
534baf8532aSAlex Dubov spin_unlock(&memstick_host_lock);
535baf8532aSAlex Dubov return rc;
536baf8532aSAlex Dubov }
537baf8532aSAlex Dubov
538baf8532aSAlex Dubov host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
539baf8532aSAlex Dubov memstick_detect_change(host);
540baf8532aSAlex Dubov return 0;
541baf8532aSAlex Dubov }
542baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_add_host);
543baf8532aSAlex Dubov
544baf8532aSAlex Dubov /**
545baf8532aSAlex Dubov * memstick_remove_host - stop request processing on memstick host
546baf8532aSAlex Dubov * @host - host to use
547baf8532aSAlex Dubov */
memstick_remove_host(struct memstick_host * host)548baf8532aSAlex Dubov void memstick_remove_host(struct memstick_host *host)
549baf8532aSAlex Dubov {
55062c59a87SKai-Heng Feng host->removing = 1;
551baf8532aSAlex Dubov flush_workqueue(workqueue);
552baf8532aSAlex Dubov mutex_lock(&host->lock);
553baf8532aSAlex Dubov if (host->card)
554baf8532aSAlex Dubov device_unregister(&host->card->dev);
555baf8532aSAlex Dubov host->card = NULL;
556baf8532aSAlex Dubov host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
557baf8532aSAlex Dubov mutex_unlock(&host->lock);
558baf8532aSAlex Dubov
559baf8532aSAlex Dubov spin_lock(&memstick_host_lock);
560baf8532aSAlex Dubov idr_remove(&memstick_host_idr, host->id);
561baf8532aSAlex Dubov spin_unlock(&memstick_host_lock);
562c4c66cf1SGreg Kroah-Hartman device_del(&host->dev);
563baf8532aSAlex Dubov }
564baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_remove_host);
565baf8532aSAlex Dubov
566baf8532aSAlex Dubov /**
567baf8532aSAlex Dubov * memstick_free_host - free memstick host
568baf8532aSAlex Dubov * @host - host to use
569baf8532aSAlex Dubov */
memstick_free_host(struct memstick_host * host)570baf8532aSAlex Dubov void memstick_free_host(struct memstick_host *host)
571baf8532aSAlex Dubov {
572baf8532aSAlex Dubov mutex_destroy(&host->lock);
573c4c66cf1SGreg Kroah-Hartman put_device(&host->dev);
574baf8532aSAlex Dubov }
575baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_free_host);
576baf8532aSAlex Dubov
577d114ad54SAlex Dubov /**
578d114ad54SAlex Dubov * memstick_suspend_host - notify bus driver of host suspension
579d114ad54SAlex Dubov * @host - host to use
580d114ad54SAlex Dubov */
memstick_suspend_host(struct memstick_host * host)581d114ad54SAlex Dubov void memstick_suspend_host(struct memstick_host *host)
582d114ad54SAlex Dubov {
583d114ad54SAlex Dubov mutex_lock(&host->lock);
584d114ad54SAlex Dubov host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
585d114ad54SAlex Dubov mutex_unlock(&host->lock);
586d114ad54SAlex Dubov }
587d114ad54SAlex Dubov EXPORT_SYMBOL(memstick_suspend_host);
588d114ad54SAlex Dubov
589d114ad54SAlex Dubov /**
590d114ad54SAlex Dubov * memstick_resume_host - notify bus driver of host resumption
591d114ad54SAlex Dubov * @host - host to use
592d114ad54SAlex Dubov */
memstick_resume_host(struct memstick_host * host)593d114ad54SAlex Dubov void memstick_resume_host(struct memstick_host *host)
594d114ad54SAlex Dubov {
595b7789998SAlex Dubov int rc = 0;
596b7789998SAlex Dubov
597d114ad54SAlex Dubov mutex_lock(&host->lock);
598ead70773SAlex Dubov if (host->card)
599b7789998SAlex Dubov rc = memstick_power_on(host);
600d114ad54SAlex Dubov mutex_unlock(&host->lock);
601b7789998SAlex Dubov
602b7789998SAlex Dubov if (!rc)
603d114ad54SAlex Dubov memstick_detect_change(host);
604d114ad54SAlex Dubov }
605d114ad54SAlex Dubov EXPORT_SYMBOL(memstick_resume_host);
606d114ad54SAlex Dubov
memstick_register_driver(struct memstick_driver * drv)607baf8532aSAlex Dubov int memstick_register_driver(struct memstick_driver *drv)
608baf8532aSAlex Dubov {
609baf8532aSAlex Dubov drv->driver.bus = &memstick_bus_type;
610baf8532aSAlex Dubov
611baf8532aSAlex Dubov return driver_register(&drv->driver);
612baf8532aSAlex Dubov }
613baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_register_driver);
614baf8532aSAlex Dubov
memstick_unregister_driver(struct memstick_driver * drv)615baf8532aSAlex Dubov void memstick_unregister_driver(struct memstick_driver *drv)
616baf8532aSAlex Dubov {
617baf8532aSAlex Dubov driver_unregister(&drv->driver);
618baf8532aSAlex Dubov }
619baf8532aSAlex Dubov EXPORT_SYMBOL(memstick_unregister_driver);
620baf8532aSAlex Dubov
621baf8532aSAlex Dubov
memstick_init(void)622baf8532aSAlex Dubov static int __init memstick_init(void)
623baf8532aSAlex Dubov {
624baf8532aSAlex Dubov int rc;
625baf8532aSAlex Dubov
62658a69cb4STejun Heo workqueue = create_freezable_workqueue("kmemstick");
627baf8532aSAlex Dubov if (!workqueue)
628baf8532aSAlex Dubov return -ENOMEM;
629baf8532aSAlex Dubov
630baf8532aSAlex Dubov rc = bus_register(&memstick_bus_type);
63165f1a0d3SWang Hai if (rc)
63265f1a0d3SWang Hai goto error_destroy_workqueue;
633baf8532aSAlex Dubov
63465f1a0d3SWang Hai rc = class_register(&memstick_host_class);
63565f1a0d3SWang Hai if (rc)
63665f1a0d3SWang Hai goto error_bus_unregister;
63765f1a0d3SWang Hai
638baf8532aSAlex Dubov return 0;
639baf8532aSAlex Dubov
64065f1a0d3SWang Hai error_bus_unregister:
641baf8532aSAlex Dubov bus_unregister(&memstick_bus_type);
64265f1a0d3SWang Hai error_destroy_workqueue:
643baf8532aSAlex Dubov destroy_workqueue(workqueue);
644baf8532aSAlex Dubov
645baf8532aSAlex Dubov return rc;
646baf8532aSAlex Dubov }
647baf8532aSAlex Dubov
memstick_exit(void)648baf8532aSAlex Dubov static void __exit memstick_exit(void)
649baf8532aSAlex Dubov {
650baf8532aSAlex Dubov class_unregister(&memstick_host_class);
651baf8532aSAlex Dubov bus_unregister(&memstick_bus_type);
652baf8532aSAlex Dubov destroy_workqueue(workqueue);
653baf8532aSAlex Dubov idr_destroy(&memstick_host_idr);
654baf8532aSAlex Dubov }
655baf8532aSAlex Dubov
656baf8532aSAlex Dubov module_init(memstick_init);
657baf8532aSAlex Dubov module_exit(memstick_exit);
658baf8532aSAlex Dubov
659baf8532aSAlex Dubov MODULE_AUTHOR("Alex Dubov");
660baf8532aSAlex Dubov MODULE_LICENSE("GPL");
661baf8532aSAlex Dubov MODULE_DESCRIPTION("Sony MemoryStick core driver");
662