drivers/pnp/core.c

   1 /*
   2  * core.c - contains all core device and protocol registration functions
   3  *
   4  * Copyright 2002 Adam Belay <ambx1@neo.rr.com>
   5  */
   6
   7 #include <linux/pnp.h>
   8 #include <linux/types.h>
   9 #include <linux/list.h>
  10 #include <linux/device.h>
  11 #include <linux/module.h>
  12 #include <linux/mutex.h>
  13 #include <linux/init.h>
  14 #include <linux/string.h>
  15 #include <linux/slab.h>
  16 #include <linux/errno.h>
  17 #include <linux/dma-mapping.h>
  18
  19 #include "base.h"
  20
  21 static LIST_HEAD(pnp_protocols);
  22 LIST_HEAD(pnp_global);
  23 DEFINE_MUTEX(pnp_lock);
  24
  25 /*
  26  * ACPI or PNPBIOS should tell us about all platform devices, so we can
  27  * skip some blind probes.  ISAPNP typically enumerates only plug-in ISA
  28  * devices, not built-in things like COM ports.
  29  */
  30 int pnp_platform_devices;
  31 EXPORT_SYMBOL(pnp_platform_devices);
  32
  33 void *pnp_alloc(long size)
  34 {
  35         void *result;
  36
  37         result = kzalloc(size, GFP_KERNEL);
  38         if (!result) {
  39                 printk(KERN_ERR "pnp: Out of Memory\n");
  40                 return NULL;
  41         }
  42         return result;
  43 }
  44
  45 static void pnp_remove_protocol(struct pnp_protocol *protocol)
  46 {
  47         mutex_lock(&pnp_lock);
  48         list_del(&protocol->protocol_list);
  49         mutex_unlock(&pnp_lock);
  50 }
  51
  52 /**
  53  * pnp_protocol_register - adds a pnp protocol to the pnp layer
  54  * @protocol: pointer to the corresponding pnp_protocol structure
  55  *
  56  *  Ex protocols: ISAPNP, PNPBIOS, etc
  57  */
  58 int pnp_register_protocol(struct pnp_protocol *protocol)
  59 {
  60         struct list_head *pos;
  61         int nodenum, ret;
  62
  63         INIT_LIST_HEAD(&protocol->devices);
  64         INIT_LIST_HEAD(&protocol->cards);
  65         nodenum = 0;
  66
  67         mutex_lock(&pnp_lock);
  68
  69         /* assign the lowest unused number */
  70         list_for_each(pos, &pnp_protocols) {
  71                 struct pnp_protocol *cur = to_pnp_protocol(pos);
  72                 if (cur->number == nodenum) {
  73                         pos = &pnp_protocols;
  74                         nodenum++;
  75                 }
  76         }
  77
  78         protocol->number = nodenum;
  79         dev_set_name(&protocol->dev, "pnp%d", nodenum);
  80
  81         list_add_tail(&protocol->protocol_list, &pnp_protocols);
  82
  83         mutex_unlock(&pnp_lock);
  84
  85         ret = device_register(&protocol->dev);
  86         if (ret)
  87                 pnp_remove_protocol(protocol);
  88
  89         return ret;
  90 }
  91
  92 /**
  93  * pnp_protocol_unregister - removes a pnp protocol from the pnp layer
  94  * @protocol: pointer to the corresponding pnp_protocol structure
  95  */
  96 void pnp_unregister_protocol(struct pnp_protocol *protocol)
  97 {
  98         pnp_remove_protocol(protocol);
  99         device_unregister(&protocol->dev);
 100 }
 101
 102 static void pnp_free_ids(struct pnp_dev *dev)
 103 {
 104         struct pnp_id *id;
 105         struct pnp_id *next;
 106
 107         id = dev->id;
 108         while (id) {
 109                 next = id->next;
 110                 kfree(id);
 111                 id = next;
 112         }
 113 }
 114
 115 void pnp_free_resource(struct pnp_resource *pnp_res)
 116 {
 117         list_del(&pnp_res->list);
 118         kfree(pnp_res);
 119 }
 120
 121 void pnp_free_resources(struct pnp_dev *dev)
 122 {
 123         struct pnp_resource *pnp_res, *tmp;
 124
 125         list_for_each_entry_safe(pnp_res, tmp, &dev->resources, list) {
 126                 pnp_free_resource(pnp_res);
 127         }
 128 }
 129
 130 static void pnp_release_device(struct device *dmdev)
 131 {
 132         struct pnp_dev *dev = to_pnp_dev(dmdev);
 133
 134         pnp_free_ids(dev);
 135         pnp_free_resources(dev);
 136         pnp_free_options(dev);
 137         kfree(dev);
 138 }
 139
 140 struct pnp_dev *pnp_alloc_dev(struct pnp_protocol *protocol, int id,
 141                               const char *pnpid)
 142 {
 143         struct pnp_dev *dev;
 144         struct pnp_id *dev_id;
 145
 146         dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL);
 147         if (!dev)
 148                 return NULL;
 149
 150         INIT_LIST_HEAD(&dev->resources);
 151         INIT_LIST_HEAD(&dev->options);
 152         dev->protocol = protocol;
 153         dev->number = id;
 154         dev->dma_mask = DMA_BIT_MASK(24);
 155
 156         dev->dev.parent = &dev->protocol->dev;
 157         dev->dev.bus = &pnp_bus_type;
 158         dev->dev.dma_mask = &dev->dma_mask;
 159         dev->dev.coherent_dma_mask = dev->dma_mask;
 160         dev->dev.release = &pnp_release_device;
 161
 162         dev_set_name(&dev->dev, "%02x:%02x", dev->protocol->number, dev->number);
 163
 164         dev_id = pnp_add_id(dev, pnpid);
 165         if (!dev_id) {
 166                 kfree(dev);
 167                 return NULL;
 168         }
 169
 170         return dev;
 171 }
 172
 173 static void pnp_delist_device(struct pnp_dev *dev)
 174 {
 175         mutex_lock(&pnp_lock);
 176         list_del(&dev->global_list);
 177         list_del(&dev->protocol_list);
 178         mutex_unlock(&pnp_lock);
 179 }
 180
 181 int __pnp_add_device(struct pnp_dev *dev)
 182 {
 183         int ret;
 184
 185         pnp_fixup_device(dev);
 186         dev->status = PNP_READY;
 187
 188         mutex_lock(&pnp_lock);
 189
 190         list_add_tail(&dev->global_list, &pnp_global);
 191         list_add_tail(&dev->protocol_list, &dev->protocol->devices);
 192
 193         mutex_unlock(&pnp_lock);
 194
 195         ret = device_register(&dev->dev);
 196         if (ret)
 197                 pnp_delist_device(dev);
 198         else if (dev->protocol->can_wakeup)
 199                 device_set_wakeup_capable(&dev->dev,
 200                                 dev->protocol->can_wakeup(dev));
 201
 202         return ret;
 203 }
 204
 205 /*
 206  * pnp_add_device - adds a pnp device to the pnp layer
 207  * @dev: pointer to dev to add
 208  *
 209  *  adds to driver model, name database, fixups, interface, etc.
 210  */
 211 int pnp_add_device(struct pnp_dev *dev)
 212 {
 213         int ret;
 214         char buf[128];
 215         int len = 0;
 216         struct pnp_id *id;
 217
 218         if (dev->card)
 219                 return -EINVAL;
 220
 221         ret = __pnp_add_device(dev);
 222         if (ret)
 223                 return ret;
 224
 225         buf[0] = '\0';
 226         for (id = dev->id; id; id = id->next)
 227                 len += scnprintf(buf + len, sizeof(buf) - len, " %s", id->id);
 228
 229         dev_printk(KERN_DEBUG, &dev->dev, "%s device, IDs%s (%s)\n",
 230                    dev->protocol->name, buf,
 231                    dev->active ? "active" : "disabled");
 232         return 0;
 233 }
 234
 235 void __pnp_remove_device(struct pnp_dev *dev)
 236 {
 237         pnp_delist_device(dev);
 238         device_unregister(&dev->dev);
 239 }
 240
 241 static int __init pnp_init(void)
 242 {
 243         return bus_register(&pnp_bus_type);
 244 }
 245
 246 subsys_initcall(pnp_init);
 247
 248 int pnp_debug;
 249
 250 #if defined(CONFIG_PNP_DEBUG_MESSAGES)
 251 module_param_named(debug, pnp_debug, int, 0644);
 252 #endif