]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
1da177e4 LT |
2 | /* |
3 | * Linux Plug and Play Support | |
4 | * Copyright by Adam Belay <ambx1@neo.rr.com> | |
1f32ca31 BH |
5 | * Copyright (C) 2008 Hewlett-Packard Development Company, L.P. |
6 | * Bjorn Helgaas <bjorn.helgaas@hp.com> | |
1da177e4 LT |
7 | */ |
8 | ||
9 | #ifndef _LINUX_PNP_H | |
10 | #define _LINUX_PNP_H | |
11 | ||
1da177e4 LT |
12 | #include <linux/device.h> |
13 | #include <linux/list.h> | |
14 | #include <linux/errno.h> | |
15 | #include <linux/mod_devicetable.h> | |
01395d79 | 16 | #include <linux/console.h> |
1da177e4 | 17 | |
1da177e4 LT |
18 | #define PNP_NAME_LEN 50 |
19 | ||
20 | struct pnp_protocol; | |
21 | struct pnp_dev; | |
22 | ||
1da177e4 LT |
23 | /* |
24 | * Resource Management | |
25 | */ | |
ef3d7714 | 26 | #ifdef CONFIG_PNP |
b563cf59 RH |
27 | struct resource *pnp_get_resource(struct pnp_dev *dev, unsigned long type, |
28 | unsigned int num); | |
ef3d7714 | 29 | #else |
b563cf59 RH |
30 | static inline struct resource *pnp_get_resource(struct pnp_dev *dev, |
31 | unsigned long type, unsigned int num) | |
ef3d7714 DM |
32 | { |
33 | return NULL; | |
34 | } | |
35 | #endif | |
1da177e4 | 36 | |
13575e81 BH |
37 | static inline int pnp_resource_valid(struct resource *res) |
38 | { | |
aee3ad81 BH |
39 | if (res) |
40 | return 1; | |
41 | return 0; | |
42 | } | |
43 | ||
44 | static inline int pnp_resource_enabled(struct resource *res) | |
45 | { | |
46 | if (res && !(res->flags & IORESOURCE_DISABLED)) | |
13575e81 BH |
47 | return 1; |
48 | return 0; | |
49 | } | |
50 | ||
51 | static inline resource_size_t pnp_resource_len(struct resource *res) | |
52 | { | |
53 | if (res->start == 0 && res->end == 0) | |
54 | return 0; | |
28f65c11 | 55 | return resource_size(res); |
13575e81 BH |
56 | } |
57 | ||
58 | ||
59 | static inline resource_size_t pnp_port_start(struct pnp_dev *dev, | |
60 | unsigned int bar) | |
61 | { | |
20bfdbba BH |
62 | struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar); |
63 | ||
64 | if (pnp_resource_valid(res)) | |
65 | return res->start; | |
66 | return 0; | |
13575e81 BH |
67 | } |
68 | ||
69 | static inline resource_size_t pnp_port_end(struct pnp_dev *dev, | |
70 | unsigned int bar) | |
71 | { | |
20bfdbba BH |
72 | struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar); |
73 | ||
74 | if (pnp_resource_valid(res)) | |
75 | return res->end; | |
76 | return 0; | |
13575e81 BH |
77 | } |
78 | ||
79 | static inline unsigned long pnp_port_flags(struct pnp_dev *dev, | |
80 | unsigned int bar) | |
81 | { | |
20bfdbba BH |
82 | struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar); |
83 | ||
84 | if (pnp_resource_valid(res)) | |
85 | return res->flags; | |
aee3ad81 | 86 | return IORESOURCE_IO | IORESOURCE_AUTO; |
13575e81 BH |
87 | } |
88 | ||
89 | static inline int pnp_port_valid(struct pnp_dev *dev, unsigned int bar) | |
90 | { | |
91 | return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_IO, bar)); | |
92 | } | |
93 | ||
94 | static inline resource_size_t pnp_port_len(struct pnp_dev *dev, | |
95 | unsigned int bar) | |
96 | { | |
20bfdbba BH |
97 | struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar); |
98 | ||
99 | if (pnp_resource_valid(res)) | |
100 | return pnp_resource_len(res); | |
101 | return 0; | |
13575e81 BH |
102 | } |
103 | ||
104 | ||
105 | static inline resource_size_t pnp_mem_start(struct pnp_dev *dev, | |
106 | unsigned int bar) | |
107 | { | |
20bfdbba BH |
108 | struct resource *res = pnp_get_resource(dev, IORESOURCE_MEM, bar); |
109 | ||
110 | if (pnp_resource_valid(res)) | |
111 | return res->start; | |
112 | return 0; | |
13575e81 BH |
113 | } |
114 | ||
115 | static inline resource_size_t pnp_mem_end(struct pnp_dev *dev, | |
116 | unsigned int bar) | |
117 | { | |
20bfdbba BH |
118 | struct resource *res = pnp_get_resource(dev, IORESOURCE_MEM, bar); |
119 | ||
120 | if (pnp_resource_valid(res)) | |
121 | return res->end; | |
122 | return 0; | |
13575e81 BH |
123 | } |
124 | ||
125 | static inline unsigned long pnp_mem_flags(struct pnp_dev *dev, unsigned int bar) | |
126 | { | |
20bfdbba BH |
127 | struct resource *res = pnp_get_resource(dev, IORESOURCE_MEM, bar); |
128 | ||
129 | if (pnp_resource_valid(res)) | |
130 | return res->flags; | |
aee3ad81 | 131 | return IORESOURCE_MEM | IORESOURCE_AUTO; |
13575e81 BH |
132 | } |
133 | ||
134 | static inline int pnp_mem_valid(struct pnp_dev *dev, unsigned int bar) | |
135 | { | |
136 | return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_MEM, bar)); | |
137 | } | |
138 | ||
139 | static inline resource_size_t pnp_mem_len(struct pnp_dev *dev, | |
140 | unsigned int bar) | |
141 | { | |
20bfdbba BH |
142 | struct resource *res = pnp_get_resource(dev, IORESOURCE_MEM, bar); |
143 | ||
144 | if (pnp_resource_valid(res)) | |
145 | return pnp_resource_len(res); | |
146 | return 0; | |
13575e81 BH |
147 | } |
148 | ||
149 | ||
150 | static inline resource_size_t pnp_irq(struct pnp_dev *dev, unsigned int bar) | |
151 | { | |
20bfdbba BH |
152 | struct resource *res = pnp_get_resource(dev, IORESOURCE_IRQ, bar); |
153 | ||
154 | if (pnp_resource_valid(res)) | |
155 | return res->start; | |
156 | return -1; | |
13575e81 BH |
157 | } |
158 | ||
159 | static inline unsigned long pnp_irq_flags(struct pnp_dev *dev, unsigned int bar) | |
160 | { | |
20bfdbba BH |
161 | struct resource *res = pnp_get_resource(dev, IORESOURCE_IRQ, bar); |
162 | ||
163 | if (pnp_resource_valid(res)) | |
164 | return res->flags; | |
aee3ad81 | 165 | return IORESOURCE_IRQ | IORESOURCE_AUTO; |
13575e81 BH |
166 | } |
167 | ||
168 | static inline int pnp_irq_valid(struct pnp_dev *dev, unsigned int bar) | |
169 | { | |
170 | return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_IRQ, bar)); | |
171 | } | |
172 | ||
173 | ||
174 | static inline resource_size_t pnp_dma(struct pnp_dev *dev, unsigned int bar) | |
175 | { | |
20bfdbba BH |
176 | struct resource *res = pnp_get_resource(dev, IORESOURCE_DMA, bar); |
177 | ||
178 | if (pnp_resource_valid(res)) | |
179 | return res->start; | |
180 | return -1; | |
13575e81 BH |
181 | } |
182 | ||
183 | static inline unsigned long pnp_dma_flags(struct pnp_dev *dev, unsigned int bar) | |
184 | { | |
20bfdbba BH |
185 | struct resource *res = pnp_get_resource(dev, IORESOURCE_DMA, bar); |
186 | ||
187 | if (pnp_resource_valid(res)) | |
188 | return res->flags; | |
aee3ad81 | 189 | return IORESOURCE_DMA | IORESOURCE_AUTO; |
13575e81 BH |
190 | } |
191 | ||
192 | static inline int pnp_dma_valid(struct pnp_dev *dev, unsigned int bar) | |
193 | { | |
194 | return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_DMA, bar)); | |
195 | } | |
1da177e4 | 196 | |
1da177e4 | 197 | |
1da177e4 | 198 | /* |
fd3f8984 | 199 | * Device Management |
1da177e4 LT |
200 | */ |
201 | ||
202 | struct pnp_card { | |
07d4e9af BH |
203 | struct device dev; /* Driver Model device interface */ |
204 | unsigned char number; /* used as an index, must be unique */ | |
1da177e4 LT |
205 | struct list_head global_list; /* node in global list of cards */ |
206 | struct list_head protocol_list; /* node in protocol's list of cards */ | |
207 | struct list_head devices; /* devices attached to the card */ | |
208 | ||
9dd78466 | 209 | struct pnp_protocol *protocol; |
07d4e9af | 210 | struct pnp_id *id; /* contains supported EISA IDs */ |
1da177e4 LT |
211 | |
212 | char name[PNP_NAME_LEN]; /* contains a human-readable name */ | |
07d4e9af | 213 | unsigned char pnpver; /* Plug & Play version */ |
9dd78466 | 214 | unsigned char productver; /* product version */ |
07d4e9af BH |
215 | unsigned int serial; /* serial number */ |
216 | unsigned char checksum; /* if zero - checksum passed */ | |
1da177e4 LT |
217 | struct proc_dir_entry *procdir; /* directory entry in /proc/bus/isapnp */ |
218 | }; | |
219 | ||
220 | #define global_to_pnp_card(n) list_entry(n, struct pnp_card, global_list) | |
221 | #define protocol_to_pnp_card(n) list_entry(n, struct pnp_card, protocol_list) | |
222 | #define to_pnp_card(n) container_of(n, struct pnp_card, dev) | |
223 | #define pnp_for_each_card(card) \ | |
224 | for((card) = global_to_pnp_card(pnp_cards.next); \ | |
225 | (card) != global_to_pnp_card(&pnp_cards); \ | |
226 | (card) = global_to_pnp_card((card)->global_list.next)) | |
227 | ||
228 | struct pnp_card_link { | |
9dd78466 BH |
229 | struct pnp_card *card; |
230 | struct pnp_card_driver *driver; | |
231 | void *driver_data; | |
4c98cfef | 232 | pm_message_t pm_state; |
1da177e4 LT |
233 | }; |
234 | ||
9dd78466 | 235 | static inline void *pnp_get_card_drvdata(struct pnp_card_link *pcard) |
1da177e4 LT |
236 | { |
237 | return pcard->driver_data; | |
238 | } | |
239 | ||
9dd78466 | 240 | static inline void pnp_set_card_drvdata(struct pnp_card_link *pcard, void *data) |
1da177e4 LT |
241 | { |
242 | pcard->driver_data = data; | |
243 | } | |
244 | ||
245 | struct pnp_dev { | |
07d4e9af | 246 | struct device dev; /* Driver Model device interface */ |
2e17c550 | 247 | u64 dma_mask; |
544451a1 | 248 | unsigned int number; /* used as an index, must be unique */ |
1da177e4 LT |
249 | int status; |
250 | ||
251 | struct list_head global_list; /* node in global list of devices */ | |
252 | struct list_head protocol_list; /* node in list of device's protocol */ | |
253 | struct list_head card_list; /* node in card's list of devices */ | |
254 | struct list_head rdev_list; /* node in cards list of requested devices */ | |
255 | ||
9dd78466 BH |
256 | struct pnp_protocol *protocol; |
257 | struct pnp_card *card; /* card the device is attached to, none if NULL */ | |
258 | struct pnp_driver *driver; | |
259 | struct pnp_card_link *card_link; | |
1da177e4 | 260 | |
07d4e9af | 261 | struct pnp_id *id; /* supported EISA IDs */ |
1da177e4 LT |
262 | |
263 | int active; | |
264 | int capabilities; | |
1f32ca31 | 265 | unsigned int num_dependent_sets; |
aee3ad81 | 266 | struct list_head resources; |
1f32ca31 | 267 | struct list_head options; |
1da177e4 LT |
268 | |
269 | char name[PNP_NAME_LEN]; /* contains a human-readable name */ | |
07d4e9af | 270 | int flags; /* used by protocols */ |
1da177e4 LT |
271 | struct proc_dir_entry *procent; /* device entry in /proc/bus/isapnp */ |
272 | void *data; | |
273 | }; | |
274 | ||
275 | #define global_to_pnp_dev(n) list_entry(n, struct pnp_dev, global_list) | |
276 | #define card_to_pnp_dev(n) list_entry(n, struct pnp_dev, card_list) | |
277 | #define protocol_to_pnp_dev(n) list_entry(n, struct pnp_dev, protocol_list) | |
278 | #define to_pnp_dev(n) container_of(n, struct pnp_dev, dev) | |
279 | #define pnp_for_each_dev(dev) \ | |
280 | for((dev) = global_to_pnp_dev(pnp_global.next); \ | |
281 | (dev) != global_to_pnp_dev(&pnp_global); \ | |
282 | (dev) = global_to_pnp_dev((dev)->global_list.next)) | |
283 | #define card_for_each_dev(card,dev) \ | |
284 | for((dev) = card_to_pnp_dev((card)->devices.next); \ | |
285 | (dev) != card_to_pnp_dev(&(card)->devices); \ | |
286 | (dev) = card_to_pnp_dev((dev)->card_list.next)) | |
287 | #define pnp_dev_name(dev) (dev)->name | |
288 | ||
9dd78466 | 289 | static inline void *pnp_get_drvdata(struct pnp_dev *pdev) |
1da177e4 LT |
290 | { |
291 | return dev_get_drvdata(&pdev->dev); | |
292 | } | |
293 | ||
9dd78466 | 294 | static inline void pnp_set_drvdata(struct pnp_dev *pdev, void *data) |
1da177e4 LT |
295 | { |
296 | dev_set_drvdata(&pdev->dev, data); | |
297 | } | |
298 | ||
299 | struct pnp_fixup { | |
300 | char id[7]; | |
9dd78466 | 301 | void (*quirk_function) (struct pnp_dev * dev); /* fixup function */ |
1da177e4 LT |
302 | }; |
303 | ||
304 | /* config parameters */ | |
305 | #define PNP_CONFIG_NORMAL 0x0001 | |
306 | #define PNP_CONFIG_FORCE 0x0002 /* disables validity checking */ | |
307 | ||
308 | /* capabilities */ | |
309 | #define PNP_READ 0x0001 | |
310 | #define PNP_WRITE 0x0002 | |
311 | #define PNP_DISABLE 0x0004 | |
312 | #define PNP_CONFIGURABLE 0x0008 | |
313 | #define PNP_REMOVABLE 0x0010 | |
01395d79 | 314 | #define PNP_CONSOLE 0x0020 |
1da177e4 | 315 | |
402b310c | 316 | #define pnp_can_read(dev) (((dev)->protocol->get) && \ |
1da177e4 | 317 | ((dev)->capabilities & PNP_READ)) |
402b310c | 318 | #define pnp_can_write(dev) (((dev)->protocol->set) && \ |
1da177e4 | 319 | ((dev)->capabilities & PNP_WRITE)) |
01395d79 PH |
320 | #define pnp_can_disable(dev) (((dev)->protocol->disable) && \ |
321 | ((dev)->capabilities & PNP_DISABLE) && \ | |
322 | (!((dev)->capabilities & PNP_CONSOLE) || \ | |
323 | console_suspend_enabled)) | |
1da177e4 LT |
324 | #define pnp_can_configure(dev) ((!(dev)->active) && \ |
325 | ((dev)->capabilities & PNP_CONFIGURABLE)) | |
01395d79 PH |
326 | #define pnp_can_suspend(dev) (((dev)->protocol->suspend) && \ |
327 | (!((dev)->capabilities & PNP_CONSOLE) || \ | |
328 | console_suspend_enabled)) | |
329 | ||
1da177e4 LT |
330 | |
331 | #ifdef CONFIG_ISAPNP | |
332 | extern struct pnp_protocol isapnp_protocol; | |
333 | #define pnp_device_is_isapnp(dev) ((dev)->protocol == (&isapnp_protocol)) | |
334 | #else | |
335 | #define pnp_device_is_isapnp(dev) 0 | |
336 | #endif | |
b3bd86e2 | 337 | extern struct mutex pnp_res_mutex; |
1da177e4 LT |
338 | |
339 | #ifdef CONFIG_PNPBIOS | |
340 | extern struct pnp_protocol pnpbios_protocol; | |
80dfd83d | 341 | extern bool arch_pnpbios_disabled(void); |
1da177e4 LT |
342 | #define pnp_device_is_pnpbios(dev) ((dev)->protocol == (&pnpbios_protocol)) |
343 | #else | |
344 | #define pnp_device_is_pnpbios(dev) 0 | |
80dfd83d | 345 | #define arch_pnpbios_disabled() false |
1da177e4 LT |
346 | #endif |
347 | ||
9065ce45 BH |
348 | #ifdef CONFIG_PNPACPI |
349 | extern struct pnp_protocol pnpacpi_protocol; | |
350 | ||
351 | static inline struct acpi_device *pnp_acpi_device(struct pnp_dev *dev) | |
352 | { | |
353 | if (dev->protocol == &pnpacpi_protocol) | |
354 | return dev->data; | |
355 | return NULL; | |
356 | } | |
357 | #else | |
358 | #define pnp_acpi_device(dev) 0 | |
359 | #endif | |
360 | ||
1da177e4 LT |
361 | /* status */ |
362 | #define PNP_READY 0x0000 | |
363 | #define PNP_ATTACHED 0x0001 | |
364 | #define PNP_BUSY 0x0002 | |
365 | #define PNP_FAULTY 0x0004 | |
366 | ||
367 | /* isapnp specific macros */ | |
368 | ||
369 | #define isapnp_card_number(dev) ((dev)->card ? (dev)->card->number : -1) | |
370 | #define isapnp_csn_number(dev) ((dev)->number) | |
371 | ||
372 | /* | |
373 | * Driver Management | |
374 | */ | |
375 | ||
376 | struct pnp_id { | |
377 | char id[PNP_ID_LEN]; | |
9dd78466 | 378 | struct pnp_id *next; |
1da177e4 LT |
379 | }; |
380 | ||
381 | struct pnp_driver { | |
9dd78466 | 382 | char *name; |
1da177e4 LT |
383 | const struct pnp_device_id *id_table; |
384 | unsigned int flags; | |
07d4e9af BH |
385 | int (*probe) (struct pnp_dev *dev, const struct pnp_device_id *dev_id); |
386 | void (*remove) (struct pnp_dev *dev); | |
abd6633c | 387 | void (*shutdown) (struct pnp_dev *dev); |
07d4e9af BH |
388 | int (*suspend) (struct pnp_dev *dev, pm_message_t state); |
389 | int (*resume) (struct pnp_dev *dev); | |
1da177e4 LT |
390 | struct device_driver driver; |
391 | }; | |
392 | ||
393 | #define to_pnp_driver(drv) container_of(drv, struct pnp_driver, driver) | |
394 | ||
395 | struct pnp_card_driver { | |
396 | struct list_head global_list; | |
9dd78466 | 397 | char *name; |
1da177e4 LT |
398 | const struct pnp_card_device_id *id_table; |
399 | unsigned int flags; | |
07d4e9af BH |
400 | int (*probe) (struct pnp_card_link *card, |
401 | const struct pnp_card_device_id *card_id); | |
402 | void (*remove) (struct pnp_card_link *card); | |
403 | int (*suspend) (struct pnp_card_link *card, pm_message_t state); | |
404 | int (*resume) (struct pnp_card_link *card); | |
1da177e4 LT |
405 | struct pnp_driver link; |
406 | }; | |
407 | ||
408 | #define to_pnp_card_driver(drv) container_of(drv, struct pnp_card_driver, link) | |
409 | ||
410 | /* pnp driver flags */ | |
411 | #define PNP_DRIVER_RES_DO_NOT_CHANGE 0x0001 /* do not change the state of the device */ | |
412 | #define PNP_DRIVER_RES_DISABLE 0x0003 /* ensure the device is disabled */ | |
413 | ||
1da177e4 LT |
414 | /* |
415 | * Protocol Management | |
416 | */ | |
417 | ||
418 | struct pnp_protocol { | |
9dd78466 BH |
419 | struct list_head protocol_list; |
420 | char *name; | |
1da177e4 LT |
421 | |
422 | /* resource control functions */ | |
59284cb4 BH |
423 | int (*get) (struct pnp_dev *dev); |
424 | int (*set) (struct pnp_dev *dev); | |
07d4e9af | 425 | int (*disable) (struct pnp_dev *dev); |
1da177e4 | 426 | |
fc30e68e | 427 | /* protocol specific suspend/resume */ |
b14e033e | 428 | bool (*can_wakeup) (struct pnp_dev *dev); |
9dd78466 BH |
429 | int (*suspend) (struct pnp_dev * dev, pm_message_t state); |
430 | int (*resume) (struct pnp_dev * dev); | |
fc30e68e | 431 | |
1da177e4 | 432 | /* used by pnp layer only (look but don't touch) */ |
9dd78466 BH |
433 | unsigned char number; /* protocol number */ |
434 | struct device dev; /* link to driver model */ | |
435 | struct list_head cards; | |
436 | struct list_head devices; | |
1da177e4 LT |
437 | }; |
438 | ||
439 | #define to_pnp_protocol(n) list_entry(n, struct pnp_protocol, protocol_list) | |
440 | #define protocol_for_each_card(protocol,card) \ | |
441 | for((card) = protocol_to_pnp_card((protocol)->cards.next); \ | |
442 | (card) != protocol_to_pnp_card(&(protocol)->cards); \ | |
443 | (card) = protocol_to_pnp_card((card)->protocol_list.next)) | |
444 | #define protocol_for_each_dev(protocol,dev) \ | |
445 | for((dev) = protocol_to_pnp_dev((protocol)->devices.next); \ | |
446 | (dev) != protocol_to_pnp_dev(&(protocol)->devices); \ | |
447 | (dev) = protocol_to_pnp_dev((dev)->protocol_list.next)) | |
448 | ||
cbcdc1de DB |
449 | extern struct bus_type pnp_bus_type; |
450 | ||
1da177e4 LT |
451 | #if defined(CONFIG_PNP) |
452 | ||
453 | /* device management */ | |
1da177e4 LT |
454 | int pnp_device_attach(struct pnp_dev *pnp_dev); |
455 | void pnp_device_detach(struct pnp_dev *pnp_dev); | |
456 | extern struct list_head pnp_global; | |
8f81dd14 | 457 | extern int pnp_platform_devices; |
1da177e4 LT |
458 | |
459 | /* multidevice card support */ | |
9dd78466 BH |
460 | struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink, |
461 | const char *id, struct pnp_dev *from); | |
462 | void pnp_release_card_device(struct pnp_dev *dev); | |
463 | int pnp_register_card_driver(struct pnp_card_driver *drv); | |
464 | void pnp_unregister_card_driver(struct pnp_card_driver *drv); | |
1da177e4 LT |
465 | extern struct list_head pnp_cards; |
466 | ||
467 | /* resource management */ | |
57fd51a8 BH |
468 | int pnp_possible_config(struct pnp_dev *dev, int type, resource_size_t base, |
469 | resource_size_t size); | |
1da177e4 | 470 | int pnp_auto_config_dev(struct pnp_dev *dev); |
68094e32 PO |
471 | int pnp_start_dev(struct pnp_dev *dev); |
472 | int pnp_stop_dev(struct pnp_dev *dev); | |
1da177e4 LT |
473 | int pnp_activate_dev(struct pnp_dev *dev); |
474 | int pnp_disable_dev(struct pnp_dev *dev); | |
1b8e6966 | 475 | int pnp_range_reserved(resource_size_t start, resource_size_t end); |
1da177e4 LT |
476 | |
477 | /* protocol helpers */ | |
9dd78466 BH |
478 | int pnp_is_active(struct pnp_dev *dev); |
479 | int compare_pnp_id(struct pnp_id *pos, const char *id); | |
1da177e4 LT |
480 | int pnp_register_driver(struct pnp_driver *drv); |
481 | void pnp_unregister_driver(struct pnp_driver *drv); | |
482 | ||
483 | #else | |
484 | ||
485 | /* device management */ | |
07d4e9af BH |
486 | static inline int pnp_device_attach(struct pnp_dev *pnp_dev) { return -ENODEV; } |
487 | static inline void pnp_device_detach(struct pnp_dev *pnp_dev) { } | |
9dd78466 | 488 | |
8f81dd14 | 489 | #define pnp_platform_devices 0 |
1da177e4 LT |
490 | |
491 | /* multidevice card support */ | |
07d4e9af BH |
492 | static inline struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink, const char *id, struct pnp_dev *from) { return NULL; } |
493 | static inline void pnp_release_card_device(struct pnp_dev *dev) { } | |
494 | static inline int pnp_register_card_driver(struct pnp_card_driver *drv) { return -ENODEV; } | |
495 | static inline void pnp_unregister_card_driver(struct pnp_card_driver *drv) { } | |
1da177e4 LT |
496 | |
497 | /* resource management */ | |
57fd51a8 BH |
498 | static inline int pnp_possible_config(struct pnp_dev *dev, int type, |
499 | resource_size_t base, | |
500 | resource_size_t size) { return 0; } | |
07d4e9af | 501 | static inline int pnp_auto_config_dev(struct pnp_dev *dev) { return -ENODEV; } |
07d4e9af BH |
502 | static inline int pnp_start_dev(struct pnp_dev *dev) { return -ENODEV; } |
503 | static inline int pnp_stop_dev(struct pnp_dev *dev) { return -ENODEV; } | |
504 | static inline int pnp_activate_dev(struct pnp_dev *dev) { return -ENODEV; } | |
505 | static inline int pnp_disable_dev(struct pnp_dev *dev) { return -ENODEV; } | |
1b8e6966 | 506 | static inline int pnp_range_reserved(resource_size_t start, resource_size_t end) { return 0;} |
1da177e4 LT |
507 | |
508 | /* protocol helpers */ | |
07d4e9af BH |
509 | static inline int pnp_is_active(struct pnp_dev *dev) { return 0; } |
510 | static inline int compare_pnp_id(struct pnp_id *pos, const char *id) { return -ENODEV; } | |
07d4e9af BH |
511 | static inline int pnp_register_driver(struct pnp_driver *drv) { return -ENODEV; } |
512 | static inline void pnp_unregister_driver(struct pnp_driver *drv) { } | |
1da177e4 LT |
513 | |
514 | #endif /* CONFIG_PNP */ | |
515 | ||
95c0fd45 PH |
516 | /** |
517 | * module_pnp_driver() - Helper macro for registering a PnP driver | |
518 | * @__pnp_driver: pnp_driver struct | |
519 | * | |
520 | * Helper macro for PnP drivers which do not do anything special in module | |
521 | * init/exit. This eliminates a lot of boilerplate. Each module may only | |
522 | * use this macro once, and calling it replaces module_init() and module_exit() | |
523 | */ | |
524 | #define module_pnp_driver(__pnp_driver) \ | |
525 | module_driver(__pnp_driver, pnp_register_driver, \ | |
526 | pnp_unregister_driver) | |
527 | ||
1da177e4 | 528 | #endif /* _LINUX_PNP_H */ |