Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : /*
3 : : * Linux Plug and Play Support
4 : : * Copyright by Adam Belay <ambx1@neo.rr.com>
5 : : * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
6 : : * Bjorn Helgaas <bjorn.helgaas@hp.com>
7 : : */
8 : :
9 : : #ifndef _LINUX_PNP_H
10 : : #define _LINUX_PNP_H
11 : :
12 : : #include <linux/device.h>
13 : : #include <linux/list.h>
14 : : #include <linux/errno.h>
15 : : #include <linux/mod_devicetable.h>
16 : : #include <linux/console.h>
17 : :
18 : : #define PNP_NAME_LEN 50
19 : :
20 : : struct pnp_protocol;
21 : : struct pnp_dev;
22 : :
23 : : /*
24 : : * Resource Management
25 : : */
26 : : #ifdef CONFIG_PNP
27 : : struct resource *pnp_get_resource(struct pnp_dev *dev, unsigned long type,
28 : : unsigned int num);
29 : : #else
30 : : static inline struct resource *pnp_get_resource(struct pnp_dev *dev,
31 : : unsigned long type, unsigned int num)
32 : : {
33 : : return NULL;
34 : : }
35 : : #endif
36 : :
37 : 260 : static inline int pnp_resource_valid(struct resource *res)
38 : : {
39 [ + + - + : 117 : if (res)
+ - + - +
- + - ]
40 : 104 : return 1;
41 : : return 0;
42 : : }
43 : :
44 : 0 : static inline int pnp_resource_enabled(struct resource *res)
45 : : {
46 [ # # # # : 0 : if (res && !(res->flags & IORESOURCE_DISABLED))
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
47 [ # # # # ]: 0 : return 1;
48 : : return 0;
49 : : }
50 : :
51 : 26 : static inline resource_size_t pnp_resource_len(struct resource *res)
52 : : {
53 [ # # # # ]: 0 : if (res->start == 0 && res->end == 0)
54 : : return 0;
55 : 26 : return resource_size(res);
56 : : }
57 : :
58 : :
59 : 52 : static inline resource_size_t pnp_port_start(struct pnp_dev *dev,
60 : : unsigned int bar)
61 : : {
62 : 52 : struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar);
63 : :
64 [ + - + - : 52 : if (pnp_resource_valid(res))
+ - + - ]
65 [ + - ]: 52 : return res->start;
66 : : return 0;
67 : : }
68 : :
69 : : static inline resource_size_t pnp_port_end(struct pnp_dev *dev,
70 : : unsigned int bar)
71 : : {
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;
77 : : }
78 : :
79 : : static inline unsigned long pnp_port_flags(struct pnp_dev *dev,
80 : : unsigned int bar)
81 : : {
82 : : struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar);
83 : :
84 : : if (pnp_resource_valid(res))
85 : : return res->flags;
86 : : return IORESOURCE_IO | IORESOURCE_AUTO;
87 : : }
88 : :
89 : 65 : static inline int pnp_port_valid(struct pnp_dev *dev, unsigned int bar)
90 : : {
91 : 65 : return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_IO, bar));
92 : : }
93 : :
94 : 26 : static inline resource_size_t pnp_port_len(struct pnp_dev *dev,
95 : : unsigned int bar)
96 : : {
97 : 26 : struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar);
98 : :
99 [ + - ]: 26 : if (pnp_resource_valid(res))
100 [ - + ]: 52 : return pnp_resource_len(res);
101 : : return 0;
102 : : }
103 : :
104 : :
105 : 0 : static inline resource_size_t pnp_mem_start(struct pnp_dev *dev,
106 : : unsigned int bar)
107 : : {
108 : 0 : struct resource *res = pnp_get_resource(dev, IORESOURCE_MEM, bar);
109 : :
110 [ # # ]: 0 : if (pnp_resource_valid(res))
111 [ # # ]: 0 : return res->start;
112 : : return 0;
113 : : }
114 : :
115 : : static inline resource_size_t pnp_mem_end(struct pnp_dev *dev,
116 : : unsigned int bar)
117 : : {
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;
123 : : }
124 : :
125 : : static inline unsigned long pnp_mem_flags(struct pnp_dev *dev, unsigned int bar)
126 : : {
127 : : struct resource *res = pnp_get_resource(dev, IORESOURCE_MEM, bar);
128 : :
129 : : if (pnp_resource_valid(res))
130 : : return res->flags;
131 : : return IORESOURCE_MEM | IORESOURCE_AUTO;
132 : : }
133 : :
134 : 0 : static inline int pnp_mem_valid(struct pnp_dev *dev, unsigned int bar)
135 : : {
136 : 0 : return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_MEM, bar));
137 : : }
138 : :
139 : 0 : static inline resource_size_t pnp_mem_len(struct pnp_dev *dev,
140 : : unsigned int bar)
141 : : {
142 : 0 : struct resource *res = pnp_get_resource(dev, IORESOURCE_MEM, bar);
143 : :
144 [ # # ]: 0 : if (pnp_resource_valid(res))
145 [ # # ]: 0 : return pnp_resource_len(res);
146 : : return 0;
147 : : }
148 : :
149 : :
150 : 52 : static inline resource_size_t pnp_irq(struct pnp_dev *dev, unsigned int bar)
151 : : {
152 : 52 : struct resource *res = pnp_get_resource(dev, IORESOURCE_IRQ, bar);
153 : :
154 [ + - + - ]: 52 : if (pnp_resource_valid(res))
155 [ # # ]: 52 : return res->start;
156 : : return -1;
157 : : }
158 : :
159 : 13 : static inline unsigned long pnp_irq_flags(struct pnp_dev *dev, unsigned int bar)
160 : : {
161 : 13 : struct resource *res = pnp_get_resource(dev, IORESOURCE_IRQ, bar);
162 : :
163 [ + - ]: 13 : if (pnp_resource_valid(res))
164 : 13 : return res->flags;
165 : : return IORESOURCE_IRQ | IORESOURCE_AUTO;
166 : : }
167 : :
168 : 52 : static inline int pnp_irq_valid(struct pnp_dev *dev, unsigned int bar)
169 : : {
170 : 52 : return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_IRQ, bar));
171 : : }
172 : :
173 : :
174 : 0 : static inline resource_size_t pnp_dma(struct pnp_dev *dev, unsigned int bar)
175 : : {
176 : 0 : struct resource *res = pnp_get_resource(dev, IORESOURCE_DMA, bar);
177 : :
178 [ # # ]: 0 : if (pnp_resource_valid(res))
179 [ # # ]: 0 : return res->start;
180 : : return -1;
181 : : }
182 : :
183 : : static inline unsigned long pnp_dma_flags(struct pnp_dev *dev, unsigned int bar)
184 : : {
185 : : struct resource *res = pnp_get_resource(dev, IORESOURCE_DMA, bar);
186 : :
187 : : if (pnp_resource_valid(res))
188 : : return res->flags;
189 : : return IORESOURCE_DMA | IORESOURCE_AUTO;
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 : : }
196 : :
197 : :
198 : : /*
199 : : * Device Management
200 : : */
201 : :
202 : : struct pnp_card {
203 : : struct device dev; /* Driver Model device interface */
204 : : unsigned char number; /* used as an index, must be unique */
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 : :
209 : : struct pnp_protocol *protocol;
210 : : struct pnp_id *id; /* contains supported EISA IDs */
211 : :
212 : : char name[PNP_NAME_LEN]; /* contains a human-readable name */
213 : : unsigned char pnpver; /* Plug & Play version */
214 : : unsigned char productver; /* product version */
215 : : unsigned int serial; /* serial number */
216 : : unsigned char checksum; /* if zero - checksum passed */
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 {
229 : : struct pnp_card *card;
230 : : struct pnp_card_driver *driver;
231 : : void *driver_data;
232 : : pm_message_t pm_state;
233 : : };
234 : :
235 : : static inline void *pnp_get_card_drvdata(struct pnp_card_link *pcard)
236 : : {
237 : : return pcard->driver_data;
238 : : }
239 : :
240 : : static inline void pnp_set_card_drvdata(struct pnp_card_link *pcard, void *data)
241 : : {
242 : : pcard->driver_data = data;
243 : : }
244 : :
245 : : struct pnp_dev {
246 : : struct device dev; /* Driver Model device interface */
247 : : u64 dma_mask;
248 : : unsigned int number; /* used as an index, must be unique */
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 : :
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;
260 : :
261 : : struct pnp_id *id; /* supported EISA IDs */
262 : :
263 : : int active;
264 : : int capabilities;
265 : : unsigned int num_dependent_sets;
266 : : struct list_head resources;
267 : : struct list_head options;
268 : :
269 : : char name[PNP_NAME_LEN]; /* contains a human-readable name */
270 : : int flags; /* used by protocols */
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 : :
289 : 0 : static inline void *pnp_get_drvdata(struct pnp_dev *pdev)
290 : : {
291 [ # # ]: 0 : return dev_get_drvdata(&pdev->dev);
292 : : }
293 : :
294 : 13 : static inline void pnp_set_drvdata(struct pnp_dev *pdev, void *data)
295 : : {
296 : 13 : dev_set_drvdata(&pdev->dev, data);
297 : : }
298 : :
299 : : struct pnp_fixup {
300 : : char id[7];
301 : : void (*quirk_function) (struct pnp_dev * dev); /* fixup function */
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
314 : : #define PNP_CONSOLE 0x0020
315 : :
316 : : #define pnp_can_read(dev) (((dev)->protocol->get) && \
317 : : ((dev)->capabilities & PNP_READ))
318 : : #define pnp_can_write(dev) (((dev)->protocol->set) && \
319 : : ((dev)->capabilities & PNP_WRITE))
320 : : #define pnp_can_disable(dev) (((dev)->protocol->disable) && \
321 : : ((dev)->capabilities & PNP_DISABLE) && \
322 : : (!((dev)->capabilities & PNP_CONSOLE) || \
323 : : console_suspend_enabled))
324 : : #define pnp_can_configure(dev) ((!(dev)->active) && \
325 : : ((dev)->capabilities & PNP_CONFIGURABLE))
326 : : #define pnp_can_suspend(dev) (((dev)->protocol->suspend) && \
327 : : (!((dev)->capabilities & PNP_CONSOLE) || \
328 : : console_suspend_enabled))
329 : :
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
337 : : extern struct mutex pnp_res_mutex;
338 : :
339 : : #ifdef CONFIG_PNPBIOS
340 : : extern struct pnp_protocol pnpbios_protocol;
341 : : extern bool arch_pnpbios_disabled(void);
342 : : #define pnp_device_is_pnpbios(dev) ((dev)->protocol == (&pnpbios_protocol))
343 : : #else
344 : : #define pnp_device_is_pnpbios(dev) 0
345 : : #define arch_pnpbios_disabled() false
346 : : #endif
347 : :
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 : :
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];
378 : : struct pnp_id *next;
379 : : };
380 : :
381 : : struct pnp_driver {
382 : : char *name;
383 : : const struct pnp_device_id *id_table;
384 : : unsigned int flags;
385 : : int (*probe) (struct pnp_dev *dev, const struct pnp_device_id *dev_id);
386 : : void (*remove) (struct pnp_dev *dev);
387 : : void (*shutdown) (struct pnp_dev *dev);
388 : : int (*suspend) (struct pnp_dev *dev, pm_message_t state);
389 : : int (*resume) (struct pnp_dev *dev);
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;
397 : : char *name;
398 : : const struct pnp_card_device_id *id_table;
399 : : unsigned int flags;
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);
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 : :
414 : : /*
415 : : * Protocol Management
416 : : */
417 : :
418 : : struct pnp_protocol {
419 : : struct list_head protocol_list;
420 : : char *name;
421 : :
422 : : /* resource control functions */
423 : : int (*get) (struct pnp_dev *dev);
424 : : int (*set) (struct pnp_dev *dev);
425 : : int (*disable) (struct pnp_dev *dev);
426 : :
427 : : /* protocol specific suspend/resume */
428 : : bool (*can_wakeup) (struct pnp_dev *dev);
429 : : int (*suspend) (struct pnp_dev * dev, pm_message_t state);
430 : : int (*resume) (struct pnp_dev * dev);
431 : :
432 : : /* used by pnp layer only (look but don't touch) */
433 : : unsigned char number; /* protocol number */
434 : : struct device dev; /* link to driver model */
435 : : struct list_head cards;
436 : : struct list_head devices;
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 : :
449 : : extern struct bus_type pnp_bus_type;
450 : :
451 : : #if defined(CONFIG_PNP)
452 : :
453 : : /* device management */
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;
457 : : extern int pnp_platform_devices;
458 : :
459 : : /* multidevice card support */
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);
465 : : extern struct list_head pnp_cards;
466 : :
467 : : /* resource management */
468 : : int pnp_possible_config(struct pnp_dev *dev, int type, resource_size_t base,
469 : : resource_size_t size);
470 : : int pnp_auto_config_dev(struct pnp_dev *dev);
471 : : int pnp_start_dev(struct pnp_dev *dev);
472 : : int pnp_stop_dev(struct pnp_dev *dev);
473 : : int pnp_activate_dev(struct pnp_dev *dev);
474 : : int pnp_disable_dev(struct pnp_dev *dev);
475 : : int pnp_range_reserved(resource_size_t start, resource_size_t end);
476 : :
477 : : /* protocol helpers */
478 : : int pnp_is_active(struct pnp_dev *dev);
479 : : int compare_pnp_id(struct pnp_id *pos, const char *id);
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 */
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) { }
488 : :
489 : : #define pnp_platform_devices 0
490 : :
491 : : /* multidevice card support */
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) { }
496 : :
497 : : /* resource management */
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; }
501 : : static inline int pnp_auto_config_dev(struct pnp_dev *dev) { return -ENODEV; }
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; }
506 : : static inline int pnp_range_reserved(resource_size_t start, resource_size_t end) { return 0;}
507 : :
508 : : /* protocol helpers */
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; }
511 : : static inline int pnp_register_driver(struct pnp_driver *drv) { return -ENODEV; }
512 : : static inline void pnp_unregister_driver(struct pnp_driver *drv) { }
513 : :
514 : : #endif /* CONFIG_PNP */
515 : :
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 : :
528 : : #endif /* _LINUX_PNP_H */
|
