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