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