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 
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  */
29 int pnp_platform_devices;
30 EXPORT_SYMBOL(pnp_platform_devices);
31 
pnp_alloc(long size)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 
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  */
pnp_register_protocol(struct pnp_protocol * protocol)50 int 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  */
pnp_unregister_protocol(struct pnp_protocol * protocol)81 void 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 
pnp_free_ids(struct pnp_dev * dev)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 
pnp_free_resource(struct pnp_resource * pnp_res)102 void pnp_free_resource(struct pnp_resource *pnp_res)
103 {
104 	list_del(&pnp_res->list);
105 	kfree(pnp_res);
106 }
107 
pnp_free_resources(struct pnp_dev * dev)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 
pnp_release_device(struct device * dmdev)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 
pnp_alloc_dev(struct pnp_protocol * protocol,int id,const char * pnpid)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 
__pnp_add_device(struct pnp_dev * dev)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)
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  */
pnp_add_device(struct pnp_dev * dev)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 
__pnp_remove_device(struct pnp_dev * dev)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 
pnp_init(void)213 static int __init pnp_init(void)
214 {
215 	return bus_register(&pnp_bus_type);
216 }
217 
218 subsys_initcall(pnp_init);
219 
220 int pnp_debug;
221 
222 #if defined(CONFIG_PNP_DEBUG_MESSAGES)
223 module_param_named(debug, pnp_debug, int, 0644);
224 #endif
225