Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 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" |
Alex Dubov | 4552f0c | 2007-04-12 16:59:12 +1000 | [diff] [blame] | 17 | #define DRIVER_VERSION "0.8" |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 18 | |
Alex Dubov | 3540af8ff | 2007-04-12 16:59:15 +1000 | [diff] [blame] | 19 | static struct workqueue_struct *workqueue; |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 20 | static DEFINE_IDR(tifm_adapter_idr); |
| 21 | static DEFINE_SPINLOCK(tifm_adapter_lock); |
| 22 | |
Alex Dubov | e23f2b8 | 2007-04-12 16:59:14 +1000 | [diff] [blame] | 23 | static const char *tifm_media_type_name(unsigned char type, unsigned char nt) |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 24 | { |
Alex Dubov | e23f2b8 | 2007-04-12 16:59:14 +1000 | [diff] [blame] | 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]; |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 34 | } |
| 35 | |
Alex Dubov | e23f2b8 | 2007-04-12 16:59:14 +1000 | [diff] [blame] | 36 | static int tifm_dev_match(struct tifm_dev *sock, struct tifm_device_id *id) |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 37 | { |
Alex Dubov | e23f2b8 | 2007-04-12 16:59:14 +1000 | [diff] [blame] | 38 | if (sock->type == id->type) |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 39 | return 1; |
Alex Dubov | e23f2b8 | 2007-04-12 16:59:14 +1000 | [diff] [blame] | 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; |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 58 | } |
| 59 | |
| 60 | static int tifm_uevent(struct device *dev, char **envp, int num_envp, |
| 61 | char *buffer, int buffer_size) |
| 62 | { |
Alex Dubov | e23f2b8 | 2007-04-12 16:59:14 +1000 | [diff] [blame] | 63 | struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 64 | int i = 0; |
| 65 | int length = 0; |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 66 | |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 67 | if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length, |
Alex Dubov | e23f2b8 | 2007-04-12 16:59:14 +1000 | [diff] [blame] | 68 | "TIFM_CARD_TYPE=%s", |
| 69 | tifm_media_type_name(sock->type, 1))) |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 70 | return -ENOMEM; |
| 71 | |
| 72 | return 0; |
| 73 | } |
| 74 | |
Alex Dubov | 8dc4a61 | 2007-04-12 16:59:13 +1000 | [diff] [blame] | 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 | |
Alex Dubov | 41d78f74 | 2006-12-11 01:55:37 +1100 | [diff] [blame] | 114 | #ifdef CONFIG_PM |
| 115 | |
| 116 | static int tifm_device_suspend(struct device *dev, pm_message_t state) |
| 117 | { |
Alex Dubov | 91f8d01 | 2007-04-12 17:05:26 +1000 | [diff] [blame] | 118 | struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); |
Alex Dubov | 8dc4a61 | 2007-04-12 16:59:13 +1000 | [diff] [blame] | 119 | struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, |
| 120 | driver); |
Alex Dubov | 41d78f74 | 2006-12-11 01:55:37 +1100 | [diff] [blame] | 121 | |
Alex Dubov | 8dc4a61 | 2007-04-12 16:59:13 +1000 | [diff] [blame] | 122 | if (dev->driver && drv->suspend) |
Alex Dubov | 91f8d01 | 2007-04-12 17:05:26 +1000 | [diff] [blame] | 123 | return drv->suspend(sock, state); |
Alex Dubov | 41d78f74 | 2006-12-11 01:55:37 +1100 | [diff] [blame] | 124 | return 0; |
| 125 | } |
| 126 | |
| 127 | static int tifm_device_resume(struct device *dev) |
| 128 | { |
Alex Dubov | 91f8d01 | 2007-04-12 17:05:26 +1000 | [diff] [blame] | 129 | struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); |
Alex Dubov | 8dc4a61 | 2007-04-12 16:59:13 +1000 | [diff] [blame] | 130 | struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, |
| 131 | driver); |
Alex Dubov | 41d78f74 | 2006-12-11 01:55:37 +1100 | [diff] [blame] | 132 | |
Alex Dubov | 8dc4a61 | 2007-04-12 16:59:13 +1000 | [diff] [blame] | 133 | if (dev->driver && drv->resume) |
Alex Dubov | 91f8d01 | 2007-04-12 17:05:26 +1000 | [diff] [blame] | 134 | return drv->resume(sock); |
Alex Dubov | 41d78f74 | 2006-12-11 01:55:37 +1100 | [diff] [blame] | 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 | |
Alex Dubov | 4e64f22 | 2007-04-12 16:59:20 +1000 | [diff] [blame] | 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 | |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 157 | static struct bus_type tifm_bus_type = { |
Alex Dubov | 91f8d01 | 2007-04-12 17:05:26 +1000 | [diff] [blame] | 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 |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 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 | |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 172 | kfree(fm); |
| 173 | } |
| 174 | |
| 175 | static struct class tifm_adapter_class = { |
| 176 | .name = "tifm_adapter", |
| 177 | .release = tifm_free |
| 178 | }; |
| 179 | |
Alex Dubov | 6113ed73 | 2007-04-12 16:59:17 +1000 | [diff] [blame] | 180 | struct tifm_adapter *tifm_alloc_adapter(unsigned int num_sockets, |
| 181 | struct device *dev) |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 182 | { |
| 183 | struct tifm_adapter *fm; |
| 184 | |
Alex Dubov | 6113ed73 | 2007-04-12 16:59:17 +1000 | [diff] [blame] | 185 | fm = kzalloc(sizeof(struct tifm_adapter) |
| 186 | + sizeof(struct tifm_dev*) * num_sockets, GFP_KERNEL); |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 187 | if (fm) { |
| 188 | fm->cdev.class = &tifm_adapter_class; |
Alex Dubov | 6113ed73 | 2007-04-12 16:59:17 +1000 | [diff] [blame] | 189 | fm->cdev.dev = dev; |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 190 | class_device_initialize(&fm->cdev); |
Alex Dubov | 6113ed73 | 2007-04-12 16:59:17 +1000 | [diff] [blame] | 191 | spin_lock_init(&fm->lock); |
| 192 | fm->num_sockets = num_sockets; |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 193 | } |
| 194 | return fm; |
| 195 | } |
| 196 | EXPORT_SYMBOL(tifm_alloc_adapter); |
| 197 | |
Alex Dubov | 3540af8ff | 2007-04-12 16:59:15 +1000 | [diff] [blame] | 198 | int tifm_add_adapter(struct tifm_adapter *fm) |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 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); |
Alex Dubov | 6113ed73 | 2007-04-12 16:59:17 +1000 | [diff] [blame] | 208 | if (rc) |
| 209 | return rc; |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 210 | |
Alex Dubov | 6113ed73 | 2007-04-12 16:59:17 +1000 | [diff] [blame] | 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); |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 217 | } |
Alex Dubov | 6113ed73 | 2007-04-12 16:59:17 +1000 | [diff] [blame] | 218 | |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 219 | return rc; |
| 220 | } |
| 221 | EXPORT_SYMBOL(tifm_add_adapter); |
| 222 | |
| 223 | void tifm_remove_adapter(struct tifm_adapter *fm) |
| 224 | { |
Alex Dubov | 6113ed73 | 2007-04-12 16:59:17 +1000 | [diff] [blame] | 225 | unsigned int cnt; |
| 226 | |
Alex Dubov | 3540af8ff | 2007-04-12 16:59:15 +1000 | [diff] [blame] | 227 | flush_workqueue(workqueue); |
Alex Dubov | 6113ed73 | 2007-04-12 16:59:17 +1000 | [diff] [blame] | 228 | for (cnt = 0; cnt < fm->num_sockets; ++cnt) { |
| 229 | if (fm->sockets[cnt]) |
| 230 | device_unregister(&fm->sockets[cnt]->dev); |
| 231 | } |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 232 | |
| 233 | spin_lock(&tifm_adapter_lock); |
| 234 | idr_remove(&tifm_adapter_idr, fm->id); |
| 235 | spin_unlock(&tifm_adapter_lock); |
Alex Dubov | 6113ed73 | 2007-04-12 16:59:17 +1000 | [diff] [blame] | 236 | class_device_del(&fm->cdev); |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 237 | } |
| 238 | EXPORT_SYMBOL(tifm_remove_adapter); |
| 239 | |
Alex Dubov | 6113ed73 | 2007-04-12 16:59:17 +1000 | [diff] [blame] | 240 | void tifm_free_adapter(struct tifm_adapter *fm) |
| 241 | { |
| 242 | class_device_put(&fm->cdev); |
| 243 | } |
| 244 | EXPORT_SYMBOL(tifm_free_adapter); |
| 245 | |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 246 | void tifm_free_device(struct device *dev) |
| 247 | { |
Alex Dubov | 2428a8f | 2007-04-12 16:59:18 +1000 | [diff] [blame] | 248 | struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); |
| 249 | kfree(sock); |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 250 | } |
| 251 | EXPORT_SYMBOL(tifm_free_device); |
| 252 | |
Alex Dubov | 2428a8f | 2007-04-12 16:59:18 +1000 | [diff] [blame] | 253 | struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id, |
| 254 | unsigned char type) |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 255 | { |
Alex Dubov | 2428a8f | 2007-04-12 16:59:18 +1000 | [diff] [blame] | 256 | struct tifm_dev *sock = NULL; |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 257 | |
Alex Dubov | 2428a8f | 2007-04-12 16:59:18 +1000 | [diff] [blame] | 258 | if (!tifm_media_type_name(type, 0)) |
| 259 | return sock; |
Alex Dubov | 8e02f85 | 2006-12-08 16:50:51 +1100 | [diff] [blame] | 260 | |
Alex Dubov | 2428a8f | 2007-04-12 16:59:18 +1000 | [diff] [blame] | 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; |
| 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 Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 280 | } |
Alex Dubov | 2428a8f | 2007-04-12 16:59:18 +1000 | [diff] [blame] | 281 | return sock; |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 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 | |
Alex Dubov | 3540af8ff | 2007-04-12 16:59:15 +1000 | [diff] [blame] | 306 | void tifm_queue_work(struct work_struct *work) |
| 307 | { |
| 308 | queue_work(workqueue, work); |
| 309 | } |
| 310 | EXPORT_SYMBOL(tifm_queue_work); |
| 311 | |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 312 | int tifm_register_driver(struct tifm_driver *drv) |
| 313 | { |
| 314 | drv->driver.bus = &tifm_bus_type; |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 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 | { |
Alex Dubov | 3540af8ff | 2007-04-12 16:59:15 +1000 | [diff] [blame] | 328 | int rc; |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 329 | |
Alex Dubov | 3540af8ff | 2007-04-12 16:59:15 +1000 | [diff] [blame] | 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); |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 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); |
Alex Dubov | 3540af8ff | 2007-04-12 16:59:15 +1000 | [diff] [blame] | 355 | destroy_workqueue(workqueue); |
Alex Dubov | 4020f2d | 2006-10-04 02:15:37 -0700 | [diff] [blame] | 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); |