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