blob: d195fb088f4a05a7678ea7e289e5f18a503e64c7 [file] [log] [blame]
Alex Dubov4020f2d2006-10-04 02:15:37 -07001/*
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"
Alex Dubov4552f0c2007-04-12 16:59:12 +100017#define DRIVER_VERSION "0.8"
Alex Dubov4020f2d2006-10-04 02:15:37 -070018
Alex Dubov3540af8ff2007-04-12 16:59:15 +100019static struct workqueue_struct *workqueue;
Alex Dubov4020f2d2006-10-04 02:15:37 -070020static DEFINE_IDR(tifm_adapter_idr);
21static DEFINE_SPINLOCK(tifm_adapter_lock);
22
Alex Dubove23f2b82007-04-12 16:59:14 +100023static const char *tifm_media_type_name(unsigned char type, unsigned char nt)
Alex Dubov4020f2d2006-10-04 02:15:37 -070024{
Alex Dubove23f2b82007-04-12 16:59:14 +100025 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];
Alex Dubov4020f2d2006-10-04 02:15:37 -070034}
35
Alex Dubove23f2b82007-04-12 16:59:14 +100036static int tifm_dev_match(struct tifm_dev *sock, struct tifm_device_id *id)
Alex Dubov4020f2d2006-10-04 02:15:37 -070037{
Alex Dubove23f2b82007-04-12 16:59:14 +100038 if (sock->type == id->type)
Alex Dubov4020f2d2006-10-04 02:15:37 -070039 return 1;
Alex Dubove23f2b82007-04-12 16:59:14 +100040 return 0;
41}
42
43static 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;
Alex Dubov4020f2d2006-10-04 02:15:37 -070058}
59
60static int tifm_uevent(struct device *dev, char **envp, int num_envp,
61 char *buffer, int buffer_size)
62{
Alex Dubove23f2b82007-04-12 16:59:14 +100063 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
Alex Dubov4020f2d2006-10-04 02:15:37 -070064 int i = 0;
65 int length = 0;
Alex Dubov4020f2d2006-10-04 02:15:37 -070066
Alex Dubov4020f2d2006-10-04 02:15:37 -070067 if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
Alex Dubove23f2b82007-04-12 16:59:14 +100068 "TIFM_CARD_TYPE=%s",
69 tifm_media_type_name(sock->type, 1)))
Alex Dubov4020f2d2006-10-04 02:15:37 -070070 return -ENOMEM;
71
72 return 0;
73}
74
Alex Dubov8dc4a612007-04-12 16:59:13 +100075static 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
92static void tifm_dummy_event(struct tifm_dev *sock)
93{
94 return;
95}
96
97static 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
Alex Dubov41d78f742006-12-11 01:55:37 +1100114#ifdef CONFIG_PM
115
116static int tifm_device_suspend(struct device *dev, pm_message_t state)
117{
Alex Dubov91f8d012007-04-12 17:05:26 +1000118 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
Alex Dubov8dc4a612007-04-12 16:59:13 +1000119 struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver,
120 driver);
Alex Dubov41d78f742006-12-11 01:55:37 +1100121
Alex Dubov8dc4a612007-04-12 16:59:13 +1000122 if (dev->driver && drv->suspend)
Alex Dubov91f8d012007-04-12 17:05:26 +1000123 return drv->suspend(sock, state);
Alex Dubov41d78f742006-12-11 01:55:37 +1100124 return 0;
125}
126
127static int tifm_device_resume(struct device *dev)
128{
Alex Dubov91f8d012007-04-12 17:05:26 +1000129 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
Alex Dubov8dc4a612007-04-12 16:59:13 +1000130 struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver,
131 driver);
Alex Dubov41d78f742006-12-11 01:55:37 +1100132
Alex Dubov8dc4a612007-04-12 16:59:13 +1000133 if (dev->driver && drv->resume)
Alex Dubov91f8d012007-04-12 17:05:26 +1000134 return drv->resume(sock);
Alex Dubov41d78f742006-12-11 01:55:37 +1100135 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
Alex Dubov4e64f222007-04-12 16:59:20 +1000145static 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
152static struct device_attribute tifm_dev_attrs[] = {
153 __ATTR(type, S_IRUGO, type_show, NULL),
154 __ATTR_NULL
155};
156
Alex Dubov4020f2d2006-10-04 02:15:37 -0700157static struct bus_type tifm_bus_type = {
Alex Dubov91f8d012007-04-12 17:05:26 +1000158 .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
Alex Dubov4020f2d2006-10-04 02:15:37 -0700166};
167
168static void tifm_free(struct class_device *cdev)
169{
170 struct tifm_adapter *fm = container_of(cdev, struct tifm_adapter, cdev);
171
Alex Dubov4020f2d2006-10-04 02:15:37 -0700172 kfree(fm);
173}
174
175static struct class tifm_adapter_class = {
176 .name = "tifm_adapter",
177 .release = tifm_free
178};
179
Alex Dubov6113ed732007-04-12 16:59:17 +1000180struct tifm_adapter *tifm_alloc_adapter(unsigned int num_sockets,
181 struct device *dev)
Alex Dubov4020f2d2006-10-04 02:15:37 -0700182{
183 struct tifm_adapter *fm;
184
Alex Dubov6113ed732007-04-12 16:59:17 +1000185 fm = kzalloc(sizeof(struct tifm_adapter)
186 + sizeof(struct tifm_dev*) * num_sockets, GFP_KERNEL);
Alex Dubov4020f2d2006-10-04 02:15:37 -0700187 if (fm) {
188 fm->cdev.class = &tifm_adapter_class;
Alex Dubov6113ed732007-04-12 16:59:17 +1000189 fm->cdev.dev = dev;
Alex Dubov4020f2d2006-10-04 02:15:37 -0700190 class_device_initialize(&fm->cdev);
Alex Dubov6113ed732007-04-12 16:59:17 +1000191 spin_lock_init(&fm->lock);
192 fm->num_sockets = num_sockets;
Alex Dubov4020f2d2006-10-04 02:15:37 -0700193 }
194 return fm;
195}
196EXPORT_SYMBOL(tifm_alloc_adapter);
197
Alex Dubov3540af8ff2007-04-12 16:59:15 +1000198int tifm_add_adapter(struct tifm_adapter *fm)
Alex Dubov4020f2d2006-10-04 02:15:37 -0700199{
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);
Alex Dubov6113ed732007-04-12 16:59:17 +1000208 if (rc)
209 return rc;
Alex Dubov4020f2d2006-10-04 02:15:37 -0700210
Alex Dubov6113ed732007-04-12 16:59:17 +1000211 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);
Alex Dubov4020f2d2006-10-04 02:15:37 -0700217 }
Alex Dubov6113ed732007-04-12 16:59:17 +1000218
Alex Dubov4020f2d2006-10-04 02:15:37 -0700219 return rc;
220}
221EXPORT_SYMBOL(tifm_add_adapter);
222
223void tifm_remove_adapter(struct tifm_adapter *fm)
224{
Alex Dubov6113ed732007-04-12 16:59:17 +1000225 unsigned int cnt;
226
Alex Dubov3540af8ff2007-04-12 16:59:15 +1000227 flush_workqueue(workqueue);
Alex Dubov6113ed732007-04-12 16:59:17 +1000228 for (cnt = 0; cnt < fm->num_sockets; ++cnt) {
229 if (fm->sockets[cnt])
230 device_unregister(&fm->sockets[cnt]->dev);
231 }
Alex Dubov4020f2d2006-10-04 02:15:37 -0700232
233 spin_lock(&tifm_adapter_lock);
234 idr_remove(&tifm_adapter_idr, fm->id);
235 spin_unlock(&tifm_adapter_lock);
Alex Dubov6113ed732007-04-12 16:59:17 +1000236 class_device_del(&fm->cdev);
Alex Dubov4020f2d2006-10-04 02:15:37 -0700237}
238EXPORT_SYMBOL(tifm_remove_adapter);
239
Alex Dubov6113ed732007-04-12 16:59:17 +1000240void tifm_free_adapter(struct tifm_adapter *fm)
241{
242 class_device_put(&fm->cdev);
243}
244EXPORT_SYMBOL(tifm_free_adapter);
245
Alex Dubov4020f2d2006-10-04 02:15:37 -0700246void tifm_free_device(struct device *dev)
247{
Alex Dubov2428a8f2007-04-12 16:59:18 +1000248 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev);
249 kfree(sock);
Alex Dubov4020f2d2006-10-04 02:15:37 -0700250}
251EXPORT_SYMBOL(tifm_free_device);
252
Alex Dubov2428a8f2007-04-12 16:59:18 +1000253struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id,
254 unsigned char type)
Alex Dubov4020f2d2006-10-04 02:15:37 -0700255{
Alex Dubov2428a8f2007-04-12 16:59:18 +1000256 struct tifm_dev *sock = NULL;
Alex Dubov4020f2d2006-10-04 02:15:37 -0700257
Alex Dubov2428a8f2007-04-12 16:59:18 +1000258 if (!tifm_media_type_name(type, 0))
259 return sock;
Alex Dubov8e02f852006-12-08 16:50:51 +1100260
Alex Dubov2428a8f2007-04-12 16:59:18 +1000261 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;
268
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);
Alex Dubov4020f2d2006-10-04 02:15:37 -0700280 }
Alex Dubov2428a8f2007-04-12 16:59:18 +1000281 return sock;
Alex Dubov4020f2d2006-10-04 02:15:37 -0700282}
283EXPORT_SYMBOL(tifm_alloc_device);
284
285void tifm_eject(struct tifm_dev *sock)
286{
287 struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent);
288 fm->eject(fm, sock);
289}
290EXPORT_SYMBOL(tifm_eject);
291
292int 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}
297EXPORT_SYMBOL(tifm_map_sg);
298
299void 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}
304EXPORT_SYMBOL(tifm_unmap_sg);
305
Alex Dubov3540af8ff2007-04-12 16:59:15 +1000306void tifm_queue_work(struct work_struct *work)
307{
308 queue_work(workqueue, work);
309}
310EXPORT_SYMBOL(tifm_queue_work);
311
Alex Dubov4020f2d2006-10-04 02:15:37 -0700312int tifm_register_driver(struct tifm_driver *drv)
313{
314 drv->driver.bus = &tifm_bus_type;
Alex Dubov4020f2d2006-10-04 02:15:37 -0700315
316 return driver_register(&drv->driver);
317}
318EXPORT_SYMBOL(tifm_register_driver);
319
320void tifm_unregister_driver(struct tifm_driver *drv)
321{
322 driver_unregister(&drv->driver);
323}
324EXPORT_SYMBOL(tifm_unregister_driver);
325
326static int __init tifm_init(void)
327{
Alex Dubov3540af8ff2007-04-12 16:59:15 +1000328 int rc;
Alex Dubov4020f2d2006-10-04 02:15:37 -0700329
Alex Dubov3540af8ff2007-04-12 16:59:15 +1000330 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
345err_out_wq:
346 destroy_workqueue(workqueue);
Alex Dubov4020f2d2006-10-04 02:15:37 -0700347
348 return rc;
349}
350
351static void __exit tifm_exit(void)
352{
353 class_unregister(&tifm_adapter_class);
354 bus_unregister(&tifm_bus_type);
Alex Dubov3540af8ff2007-04-12 16:59:15 +1000355 destroy_workqueue(workqueue);
Alex Dubov4020f2d2006-10-04 02:15:37 -0700356}
357
358subsys_initcall(tifm_init);
359module_exit(tifm_exit);
360
361MODULE_LICENSE("GPL");
362MODULE_AUTHOR("Alex Dubov");
363MODULE_DESCRIPTION("TI FlashMedia core driver");
364MODULE_LICENSE("GPL");
365MODULE_VERSION(DRIVER_VERSION);