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