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