Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
core.c
Go to the documentation of this file.
1 /*
2  * core.c - contains all core device and protocol registration functions
3  *
4  * Copyright 2002 Adam Belay <[email protected]>
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 
20 static LIST_HEAD(pnp_protocols);
21 LIST_HEAD(pnp_global);
22 DEFINE_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  */
31 
32 void *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 
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 
82 {
83  spin_lock(&pnp_lock);
84  list_del(&protocol->protocol_list);
85  spin_unlock(&pnp_lock);
86  device_unregister(&protocol->dev);
87 }
88 
89 static 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 
102 void pnp_free_resource(struct pnp_resource *pnp_res)
103 {
104  list_del(&pnp_res->list);
105  kfree(pnp_res);
106 }
107 
108 void 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 
117 static 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 
127 struct 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 
160 int __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)
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  */
180 int 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 
204 void __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 
213 static int __init pnp_init(void)
214 {
215  return bus_register(&pnp_bus_type);
216 }
217 
218 subsys_initcall(pnp_init);
219 
221 
222 #if defined(CONFIG_PNP_DEBUG_MESSAGES)
223 module_param_named(debug, pnp_debug, int, 0644);
224 #endif