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 19static struct workqueue_struct *workqueue; 20static DEFINE_IDR(tifm_adapter_idr); 21static DEFINE_SPINLOCK(tifm_adapter_lock); 22 23static 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 36static 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 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; 58} 59 60static 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 75static 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 114#ifdef CONFIG_PM 115 116static 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 127static 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 145static 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 157static 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 168static 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 175static struct class tifm_adapter_class = { 176 .name = "tifm_adapter", 177 .release = tifm_free 178}; 179 180struct 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} 196EXPORT_SYMBOL(tifm_alloc_adapter); 197 198int 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} 221EXPORT_SYMBOL(tifm_add_adapter); 222 223void 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} 238EXPORT_SYMBOL(tifm_remove_adapter); 239 240void tifm_free_adapter(struct tifm_adapter *fm) 241{ 242 class_device_put(&fm->cdev); 243} 244EXPORT_SYMBOL(tifm_free_adapter); 245 246void tifm_free_device(struct device *dev) 247{ 248 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 249 kfree(sock); 250} 251EXPORT_SYMBOL(tifm_free_device); 252 253struct 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} 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 306void tifm_queue_work(struct work_struct *work) 307{ 308 queue_work(workqueue, work); 309} 310EXPORT_SYMBOL(tifm_queue_work); 311 312int tifm_register_driver(struct tifm_driver *drv) 313{ 314 drv->driver.bus = &tifm_bus_type; 315 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{ 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 345err_out_wq: 346 destroy_workqueue(workqueue); 347 348 return rc; 349} 350 351static void __exit tifm_exit(void) 352{ 353 class_unregister(&tifm_adapter_class); 354 bus_unregister(&tifm_bus_type); 355 destroy_workqueue(workqueue); 356} 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); 366