1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * tifm_core.c - TI FlashMedia driver |
4 | * |
5 | * Copyright (C) 2006 Alex Dubov <oakad@yahoo.com> |
6 | */ |
7 | |
8 | #include <linux/tifm.h> |
9 | #include <linux/slab.h> |
10 | #include <linux/init.h> |
11 | #include <linux/idr.h> |
12 | #include <linux/module.h> |
13 | |
14 | #define DRIVER_NAME "tifm_core" |
15 | #define DRIVER_VERSION "0.8" |
16 | |
17 | static struct workqueue_struct *workqueue; |
18 | static DEFINE_IDR(tifm_adapter_idr); |
19 | static DEFINE_SPINLOCK(tifm_adapter_lock); |
20 | |
21 | static const char *tifm_media_type_name(unsigned char type, unsigned char nt) |
22 | { |
23 | const char *card_type_name[3][3] = { |
24 | { "SmartMedia/xD" , "MemoryStick" , "MMC/SD" }, |
25 | { "XD" , "MS" , "SD" }, |
26 | { "xd" , "ms" , "sd" } |
27 | }; |
28 | |
29 | if (nt > 2 || type < 1 || type > 3) |
30 | return NULL; |
31 | return card_type_name[nt][type - 1]; |
32 | } |
33 | |
34 | static int tifm_dev_match(struct tifm_dev *sock, struct tifm_device_id *id) |
35 | { |
36 | if (sock->type == id->type) |
37 | return 1; |
38 | return 0; |
39 | } |
40 | |
41 | static int tifm_bus_match(struct device *dev, struct device_driver *drv) |
42 | { |
43 | struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); |
44 | struct tifm_driver *fm_drv = container_of(drv, struct tifm_driver, |
45 | driver); |
46 | struct tifm_device_id *ids = fm_drv->id_table; |
47 | |
48 | if (ids) { |
49 | while (ids->type) { |
50 | if (tifm_dev_match(sock, id: ids)) |
51 | return 1; |
52 | ++ids; |
53 | } |
54 | } |
55 | return 0; |
56 | } |
57 | |
58 | static int tifm_uevent(const struct device *dev, struct kobj_uevent_env *env) |
59 | { |
60 | const struct tifm_dev *sock = container_of_const(dev, struct tifm_dev, dev); |
61 | |
62 | if (add_uevent_var(env, format: "TIFM_CARD_TYPE=%s" , tifm_media_type_name(type: sock->type, nt: 1))) |
63 | return -ENOMEM; |
64 | |
65 | return 0; |
66 | } |
67 | |
68 | static int tifm_device_probe(struct device *dev) |
69 | { |
70 | struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); |
71 | struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, |
72 | driver); |
73 | int rc = -ENODEV; |
74 | |
75 | get_device(dev); |
76 | if (dev->driver && drv->probe) { |
77 | rc = drv->probe(sock); |
78 | if (!rc) |
79 | return 0; |
80 | } |
81 | put_device(dev); |
82 | return rc; |
83 | } |
84 | |
85 | static void tifm_dummy_event(struct tifm_dev *sock) |
86 | { |
87 | return; |
88 | } |
89 | |
90 | static void tifm_device_remove(struct device *dev) |
91 | { |
92 | struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); |
93 | struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, |
94 | driver); |
95 | |
96 | if (dev->driver && drv->remove) { |
97 | sock->card_event = tifm_dummy_event; |
98 | sock->data_event = tifm_dummy_event; |
99 | drv->remove(sock); |
100 | sock->dev.driver = NULL; |
101 | } |
102 | |
103 | put_device(dev); |
104 | } |
105 | |
106 | #ifdef CONFIG_PM |
107 | |
108 | static int tifm_device_suspend(struct device *dev, pm_message_t state) |
109 | { |
110 | struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); |
111 | struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, |
112 | driver); |
113 | |
114 | if (dev->driver && drv->suspend) |
115 | return drv->suspend(sock, state); |
116 | return 0; |
117 | } |
118 | |
119 | static int tifm_device_resume(struct device *dev) |
120 | { |
121 | struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); |
122 | struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, |
123 | driver); |
124 | |
125 | if (dev->driver && drv->resume) |
126 | return drv->resume(sock); |
127 | return 0; |
128 | } |
129 | |
130 | #else |
131 | |
132 | #define tifm_device_suspend NULL |
133 | #define tifm_device_resume NULL |
134 | |
135 | #endif /* CONFIG_PM */ |
136 | |
137 | static ssize_t type_show(struct device *dev, struct device_attribute *attr, |
138 | char *buf) |
139 | { |
140 | struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); |
141 | return sprintf(buf, fmt: "%x" , sock->type); |
142 | } |
143 | static DEVICE_ATTR_RO(type); |
144 | |
145 | static struct attribute *tifm_dev_attrs[] = { |
146 | &dev_attr_type.attr, |
147 | NULL, |
148 | }; |
149 | ATTRIBUTE_GROUPS(tifm_dev); |
150 | |
151 | static struct bus_type tifm_bus_type = { |
152 | .name = "tifm" , |
153 | .dev_groups = tifm_dev_groups, |
154 | .match = tifm_bus_match, |
155 | .uevent = tifm_uevent, |
156 | .probe = tifm_device_probe, |
157 | .remove = tifm_device_remove, |
158 | .suspend = tifm_device_suspend, |
159 | .resume = tifm_device_resume |
160 | }; |
161 | |
162 | static void tifm_free(struct device *dev) |
163 | { |
164 | struct tifm_adapter *fm = container_of(dev, struct tifm_adapter, dev); |
165 | |
166 | kfree(objp: fm); |
167 | } |
168 | |
169 | static const struct class tifm_adapter_class = { |
170 | .name = "tifm_adapter" , |
171 | .dev_release = tifm_free |
172 | }; |
173 | |
174 | struct tifm_adapter *tifm_alloc_adapter(unsigned int num_sockets, |
175 | struct device *dev) |
176 | { |
177 | struct tifm_adapter *fm; |
178 | |
179 | fm = kzalloc(struct_size(fm, sockets, num_sockets), GFP_KERNEL); |
180 | if (fm) { |
181 | fm->dev.class = &tifm_adapter_class; |
182 | fm->dev.parent = dev; |
183 | device_initialize(dev: &fm->dev); |
184 | spin_lock_init(&fm->lock); |
185 | fm->num_sockets = num_sockets; |
186 | } |
187 | return fm; |
188 | } |
189 | EXPORT_SYMBOL(tifm_alloc_adapter); |
190 | |
191 | int tifm_add_adapter(struct tifm_adapter *fm) |
192 | { |
193 | int rc; |
194 | |
195 | idr_preload(GFP_KERNEL); |
196 | spin_lock(lock: &tifm_adapter_lock); |
197 | rc = idr_alloc(&tifm_adapter_idr, ptr: fm, start: 0, end: 0, GFP_NOWAIT); |
198 | if (rc >= 0) |
199 | fm->id = rc; |
200 | spin_unlock(lock: &tifm_adapter_lock); |
201 | idr_preload_end(); |
202 | if (rc < 0) |
203 | return rc; |
204 | |
205 | dev_set_name(dev: &fm->dev, name: "tifm%u" , fm->id); |
206 | rc = device_add(dev: &fm->dev); |
207 | if (rc) { |
208 | spin_lock(lock: &tifm_adapter_lock); |
209 | idr_remove(&tifm_adapter_idr, id: fm->id); |
210 | spin_unlock(lock: &tifm_adapter_lock); |
211 | } |
212 | |
213 | return rc; |
214 | } |
215 | EXPORT_SYMBOL(tifm_add_adapter); |
216 | |
217 | void tifm_remove_adapter(struct tifm_adapter *fm) |
218 | { |
219 | unsigned int cnt; |
220 | |
221 | flush_workqueue(workqueue); |
222 | for (cnt = 0; cnt < fm->num_sockets; ++cnt) { |
223 | if (fm->sockets[cnt]) |
224 | device_unregister(dev: &fm->sockets[cnt]->dev); |
225 | } |
226 | |
227 | spin_lock(lock: &tifm_adapter_lock); |
228 | idr_remove(&tifm_adapter_idr, id: fm->id); |
229 | spin_unlock(lock: &tifm_adapter_lock); |
230 | device_del(dev: &fm->dev); |
231 | } |
232 | EXPORT_SYMBOL(tifm_remove_adapter); |
233 | |
234 | void tifm_free_adapter(struct tifm_adapter *fm) |
235 | { |
236 | put_device(dev: &fm->dev); |
237 | } |
238 | EXPORT_SYMBOL(tifm_free_adapter); |
239 | |
240 | void tifm_free_device(struct device *dev) |
241 | { |
242 | struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); |
243 | kfree(objp: sock); |
244 | } |
245 | EXPORT_SYMBOL(tifm_free_device); |
246 | |
247 | struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id, |
248 | unsigned char type) |
249 | { |
250 | struct tifm_dev *sock = NULL; |
251 | |
252 | if (!tifm_media_type_name(type, nt: 0)) |
253 | return sock; |
254 | |
255 | sock = kzalloc(size: sizeof(struct tifm_dev), GFP_KERNEL); |
256 | if (sock) { |
257 | spin_lock_init(&sock->lock); |
258 | sock->type = type; |
259 | sock->socket_id = id; |
260 | sock->card_event = tifm_dummy_event; |
261 | sock->data_event = tifm_dummy_event; |
262 | |
263 | sock->dev.parent = fm->dev.parent; |
264 | sock->dev.bus = &tifm_bus_type; |
265 | sock->dev.dma_mask = fm->dev.parent->dma_mask; |
266 | sock->dev.release = tifm_free_device; |
267 | |
268 | dev_set_name(dev: &sock->dev, name: "tifm_%s%u:%u" , |
269 | tifm_media_type_name(type, nt: 2), fm->id, id); |
270 | printk(KERN_INFO DRIVER_NAME |
271 | ": %s card detected in socket %u:%u\n" , |
272 | tifm_media_type_name(type, 0), fm->id, id); |
273 | } |
274 | return sock; |
275 | } |
276 | EXPORT_SYMBOL(tifm_alloc_device); |
277 | |
278 | void tifm_eject(struct tifm_dev *sock) |
279 | { |
280 | struct tifm_adapter *fm = dev_get_drvdata(dev: sock->dev.parent); |
281 | fm->eject(fm, sock); |
282 | } |
283 | EXPORT_SYMBOL(tifm_eject); |
284 | |
285 | int tifm_has_ms_pif(struct tifm_dev *sock) |
286 | { |
287 | struct tifm_adapter *fm = dev_get_drvdata(dev: sock->dev.parent); |
288 | return fm->has_ms_pif(fm, sock); |
289 | } |
290 | EXPORT_SYMBOL(tifm_has_ms_pif); |
291 | |
292 | int tifm_map_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents, |
293 | int direction) |
294 | { |
295 | return dma_map_sg(&to_pci_dev(sock->dev.parent)->dev, sg, nents, |
296 | direction); |
297 | } |
298 | EXPORT_SYMBOL(tifm_map_sg); |
299 | |
300 | void tifm_unmap_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents, |
301 | int direction) |
302 | { |
303 | dma_unmap_sg(&to_pci_dev(sock->dev.parent)->dev, sg, nents, direction); |
304 | } |
305 | EXPORT_SYMBOL(tifm_unmap_sg); |
306 | |
307 | void tifm_queue_work(struct work_struct *work) |
308 | { |
309 | queue_work(wq: workqueue, work); |
310 | } |
311 | EXPORT_SYMBOL(tifm_queue_work); |
312 | |
313 | int tifm_register_driver(struct tifm_driver *drv) |
314 | { |
315 | drv->driver.bus = &tifm_bus_type; |
316 | |
317 | return driver_register(drv: &drv->driver); |
318 | } |
319 | EXPORT_SYMBOL(tifm_register_driver); |
320 | |
321 | void tifm_unregister_driver(struct tifm_driver *drv) |
322 | { |
323 | driver_unregister(drv: &drv->driver); |
324 | } |
325 | EXPORT_SYMBOL(tifm_unregister_driver); |
326 | |
327 | static int __init tifm_init(void) |
328 | { |
329 | int rc; |
330 | |
331 | workqueue = create_freezable_workqueue("tifm" ); |
332 | if (!workqueue) |
333 | return -ENOMEM; |
334 | |
335 | rc = bus_register(bus: &tifm_bus_type); |
336 | |
337 | if (rc) |
338 | goto err_out_wq; |
339 | |
340 | rc = class_register(class: &tifm_adapter_class); |
341 | if (!rc) |
342 | return 0; |
343 | |
344 | bus_unregister(bus: &tifm_bus_type); |
345 | |
346 | err_out_wq: |
347 | destroy_workqueue(wq: workqueue); |
348 | |
349 | return rc; |
350 | } |
351 | |
352 | static void __exit tifm_exit(void) |
353 | { |
354 | class_unregister(class: &tifm_adapter_class); |
355 | bus_unregister(bus: &tifm_bus_type); |
356 | destroy_workqueue(wq: workqueue); |
357 | } |
358 | |
359 | subsys_initcall(tifm_init); |
360 | module_exit(tifm_exit); |
361 | |
362 | MODULE_LICENSE("GPL" ); |
363 | MODULE_AUTHOR("Alex Dubov" ); |
364 | MODULE_DESCRIPTION("TI FlashMedia core driver" ); |
365 | MODULE_LICENSE("GPL" ); |
366 | MODULE_VERSION(DRIVER_VERSION); |
367 | |