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, char *pnpid)
 128{
 129        struct pnp_dev *dev;
 130        struct pnp_id *dev_id;
 131
 132        dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL);
 133        if (!dev)
 134                return NULL;
 135
 136        INIT_LIST_HEAD(&dev->resources);
 137        INIT_LIST_HEAD(&dev->options);
 138        dev->protocol = protocol;
 139        dev->number = id;
 140        dev->dma_mask = DMA_24BIT_MASK;
 141
 142        dev->dev.parent = &dev->protocol->dev;
 143        dev->dev.bus = &pnp_bus_type;
 144        dev->dev.dma_mask = &dev->dma_mask;
 145        dev->dev.coherent_dma_mask = dev->dma_mask;
 146        dev->dev.release = &pnp_release_device;
 147
 148        dev_set_name(&dev->dev, "%02x:%02x", dev->protocol->number, dev->number);
 149
 150        dev_id = pnp_add_id(dev, pnpid);
 151        if (!dev_id) {
 152                kfree(dev);
 153                return NULL;
 154        }
 155
 156        return dev;
 157}
 158
 159int __pnp_add_device(struct pnp_dev *dev)
 160{
 161        pnp_fixup_device(dev);
 162        dev->status = PNP_READY;
 163        spin_lock(&pnp_lock);
 164        list_add_tail(&dev->global_list, &pnp_global);
 165        list_add_tail(&dev->protocol_list, &dev->protocol->devices);
 166        spin_unlock(&pnp_lock);
 167        return device_register(&dev->dev);
 168}
 169
 170/*
 171 * pnp_add_device - adds a pnp device to the pnp layer
 172 * @dev: pointer to dev to add
 173 *
 174 *  adds to driver model, name database, fixups, interface, etc.
 175 */
 176int pnp_add_device(struct pnp_dev *dev)
 177{
 178        int ret;
 179        char buf[128];
 180        int len = 0;
 181        struct pnp_id *id;
 182
 183        if (dev->card)
 184                return -EINVAL;
 185
 186        ret = __pnp_add_device(dev);
 187        if (ret)
 188                return ret;
 189
 190        buf[0] = '\0';
 191        for (id = dev->id; id; id = id->next)
 192                len += scnprintf(buf + len, sizeof(buf) - len, " %s", id->id);
 193
 194        pnp_dbg(&dev->dev, "%s device, IDs%s (%s)\n",
 195                dev->protocol->name, buf, dev->active ? "active" : "disabled");
 196        return 0;
 197}
 198
 199void __pnp_remove_device(struct pnp_dev *dev)
 200{
 201        spin_lock(&pnp_lock);
 202        list_del(&dev->global_list);
 203        list_del(&dev->protocol_list);
 204        spin_unlock(&pnp_lock);
 205        device_unregister(&dev->dev);
 206}
 207
 208static int __init pnp_init(void)
 209{
 210        return bus_register(&pnp_bus_type);
 211}
 212
 213subsys_initcall(pnp_init);
 214
 215int pnp_debug;
 216
 217#if defined(CONFIG_PNP_DEBUG_MESSAGES)
 218static int __init pnp_debug_setup(char *__unused)
 219{
 220        pnp_debug = 1;
 221        return 1;
 222}
 223__setup("pnp.debug", pnp_debug_setup);
 224#endif
 225