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