Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 /*
0003  * Linux Plug and Play Support
0004  * Copyright by Adam Belay <ambx1@neo.rr.com>
0005  * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
0006  *  Bjorn Helgaas <bjorn.helgaas@hp.com>
0007  */
0008 
0009 #ifndef _LINUX_PNP_H
0010 #define _LINUX_PNP_H
0011 
0012 #include <linux/device.h>
0013 #include <linux/list.h>
0014 #include <linux/errno.h>
0015 #include <linux/mod_devicetable.h>
0016 #include <linux/console.h>
0017 
0018 #define PNP_NAME_LEN        50
0019 
0020 struct pnp_protocol;
0021 struct pnp_dev;
0022 
0023 /*
0024  * Resource Management
0025  */
0026 #ifdef CONFIG_PNP
0027 struct resource *pnp_get_resource(struct pnp_dev *dev, unsigned long type,
0028                 unsigned int num);
0029 #else
0030 static inline struct resource *pnp_get_resource(struct pnp_dev *dev,
0031             unsigned long type, unsigned int num)
0032 {
0033     return NULL;
0034 }
0035 #endif
0036 
0037 static inline int pnp_resource_valid(struct resource *res)
0038 {
0039     if (res)
0040         return 1;
0041     return 0;
0042 }
0043 
0044 static inline int pnp_resource_enabled(struct resource *res)
0045 {
0046     if (res && !(res->flags & IORESOURCE_DISABLED))
0047         return 1;
0048     return 0;
0049 }
0050 
0051 static inline resource_size_t pnp_resource_len(struct resource *res)
0052 {
0053     if (res->start == 0 && res->end == 0)
0054         return 0;
0055     return resource_size(res);
0056 }
0057 
0058 
0059 static inline resource_size_t pnp_port_start(struct pnp_dev *dev,
0060                          unsigned int bar)
0061 {
0062     struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar);
0063 
0064     if (pnp_resource_valid(res))
0065         return res->start;
0066     return 0;
0067 }
0068 
0069 static inline resource_size_t pnp_port_end(struct pnp_dev *dev,
0070                        unsigned int bar)
0071 {
0072     struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar);
0073 
0074     if (pnp_resource_valid(res))
0075         return res->end;
0076     return 0;
0077 }
0078 
0079 static inline unsigned long pnp_port_flags(struct pnp_dev *dev,
0080                        unsigned int bar)
0081 {
0082     struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar);
0083 
0084     if (pnp_resource_valid(res))
0085         return res->flags;
0086     return IORESOURCE_IO | IORESOURCE_AUTO;
0087 }
0088 
0089 static inline int pnp_port_valid(struct pnp_dev *dev, unsigned int bar)
0090 {
0091     return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_IO, bar));
0092 }
0093 
0094 static inline resource_size_t pnp_port_len(struct pnp_dev *dev,
0095                        unsigned int bar)
0096 {
0097     struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar);
0098 
0099     if (pnp_resource_valid(res))
0100         return pnp_resource_len(res);
0101     return 0;
0102 }
0103 
0104 
0105 static inline resource_size_t pnp_mem_start(struct pnp_dev *dev,
0106                         unsigned int bar)
0107 {
0108     struct resource *res = pnp_get_resource(dev, IORESOURCE_MEM, bar);
0109 
0110     if (pnp_resource_valid(res))
0111         return res->start;
0112     return 0;
0113 }
0114 
0115 static inline resource_size_t pnp_mem_end(struct pnp_dev *dev,
0116                       unsigned int bar)
0117 {
0118     struct resource *res = pnp_get_resource(dev, IORESOURCE_MEM, bar);
0119 
0120     if (pnp_resource_valid(res))
0121         return res->end;
0122     return 0;
0123 }
0124 
0125 static inline unsigned long pnp_mem_flags(struct pnp_dev *dev, unsigned int bar)
0126 {
0127     struct resource *res = pnp_get_resource(dev, IORESOURCE_MEM, bar);
0128 
0129     if (pnp_resource_valid(res))
0130         return res->flags;
0131     return IORESOURCE_MEM | IORESOURCE_AUTO;
0132 }
0133 
0134 static inline int pnp_mem_valid(struct pnp_dev *dev, unsigned int bar)
0135 {
0136     return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_MEM, bar));
0137 }
0138 
0139 static inline resource_size_t pnp_mem_len(struct pnp_dev *dev,
0140                       unsigned int bar)
0141 {
0142     struct resource *res = pnp_get_resource(dev, IORESOURCE_MEM, bar);
0143 
0144     if (pnp_resource_valid(res))
0145         return pnp_resource_len(res);
0146     return 0;
0147 }
0148 
0149 
0150 static inline resource_size_t pnp_irq(struct pnp_dev *dev, unsigned int bar)
0151 {
0152     struct resource *res = pnp_get_resource(dev, IORESOURCE_IRQ, bar);
0153 
0154     if (pnp_resource_valid(res))
0155         return res->start;
0156     return -1;
0157 }
0158 
0159 static inline unsigned long pnp_irq_flags(struct pnp_dev *dev, unsigned int bar)
0160 {
0161     struct resource *res = pnp_get_resource(dev, IORESOURCE_IRQ, bar);
0162 
0163     if (pnp_resource_valid(res))
0164         return res->flags;
0165     return IORESOURCE_IRQ | IORESOURCE_AUTO;
0166 }
0167 
0168 static inline int pnp_irq_valid(struct pnp_dev *dev, unsigned int bar)
0169 {
0170     return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_IRQ, bar));
0171 }
0172 
0173 
0174 static inline resource_size_t pnp_dma(struct pnp_dev *dev, unsigned int bar)
0175 {
0176     struct resource *res = pnp_get_resource(dev, IORESOURCE_DMA, bar);
0177 
0178     if (pnp_resource_valid(res))
0179         return res->start;
0180     return -1;
0181 }
0182 
0183 static inline unsigned long pnp_dma_flags(struct pnp_dev *dev, unsigned int bar)
0184 {
0185     struct resource *res = pnp_get_resource(dev, IORESOURCE_DMA, bar);
0186 
0187     if (pnp_resource_valid(res))
0188         return res->flags;
0189     return IORESOURCE_DMA | IORESOURCE_AUTO;
0190 }
0191 
0192 static inline int pnp_dma_valid(struct pnp_dev *dev, unsigned int bar)
0193 {
0194     return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_DMA, bar));
0195 }
0196 
0197 
0198 /*
0199  * Device Management
0200  */
0201 
0202 struct pnp_card {
0203     struct device dev;      /* Driver Model device interface */
0204     unsigned char number;       /* used as an index, must be unique */
0205     struct list_head global_list;   /* node in global list of cards */
0206     struct list_head protocol_list; /* node in protocol's list of cards */
0207     struct list_head devices;   /* devices attached to the card */
0208 
0209     struct pnp_protocol *protocol;
0210     struct pnp_id *id;      /* contains supported EISA IDs */
0211 
0212     char name[PNP_NAME_LEN];    /* contains a human-readable name */
0213     unsigned char pnpver;       /* Plug & Play version */
0214     unsigned char productver;   /* product version */
0215     unsigned int serial;        /* serial number */
0216     unsigned char checksum;     /* if zero - checksum passed */
0217     struct proc_dir_entry *procdir; /* directory entry in /proc/bus/isapnp */
0218 };
0219 
0220 #define global_to_pnp_card(n) list_entry(n, struct pnp_card, global_list)
0221 #define protocol_to_pnp_card(n) list_entry(n, struct pnp_card, protocol_list)
0222 #define to_pnp_card(n) container_of(n, struct pnp_card, dev)
0223 #define pnp_for_each_card(card) \
0224     list_for_each_entry(card, &pnp_cards, global_list)
0225 
0226 struct pnp_card_link {
0227     struct pnp_card *card;
0228     struct pnp_card_driver *driver;
0229     void *driver_data;
0230     pm_message_t pm_state;
0231 };
0232 
0233 static inline void *pnp_get_card_drvdata(struct pnp_card_link *pcard)
0234 {
0235     return pcard->driver_data;
0236 }
0237 
0238 static inline void pnp_set_card_drvdata(struct pnp_card_link *pcard, void *data)
0239 {
0240     pcard->driver_data = data;
0241 }
0242 
0243 struct pnp_dev {
0244     struct device dev;      /* Driver Model device interface */
0245     u64 dma_mask;
0246     unsigned int number;        /* used as an index, must be unique */
0247     int status;
0248 
0249     struct list_head global_list;   /* node in global list of devices */
0250     struct list_head protocol_list; /* node in list of device's protocol */
0251     struct list_head card_list; /* node in card's list of devices */
0252     struct list_head rdev_list; /* node in cards list of requested devices */
0253 
0254     struct pnp_protocol *protocol;
0255     struct pnp_card *card;  /* card the device is attached to, none if NULL */
0256     struct pnp_driver *driver;
0257     struct pnp_card_link *card_link;
0258 
0259     struct pnp_id *id;      /* supported EISA IDs */
0260 
0261     int active;
0262     int capabilities;
0263     unsigned int num_dependent_sets;
0264     struct list_head resources;
0265     struct list_head options;
0266 
0267     char name[PNP_NAME_LEN];    /* contains a human-readable name */
0268     int flags;          /* used by protocols */
0269     struct proc_dir_entry *procent; /* device entry in /proc/bus/isapnp */
0270     void *data;
0271 };
0272 
0273 #define global_to_pnp_dev(n) list_entry(n, struct pnp_dev, global_list)
0274 #define card_to_pnp_dev(n) list_entry(n, struct pnp_dev, card_list)
0275 #define protocol_to_pnp_dev(n) list_entry(n, struct pnp_dev, protocol_list)
0276 #define to_pnp_dev(n) container_of(n, struct pnp_dev, dev)
0277 #define pnp_for_each_dev(dev) list_for_each_entry(dev, &pnp_global, global_list)
0278 #define card_for_each_dev(card, dev)    \
0279     list_for_each_entry(dev, &(card)->devices, card_list)
0280 #define pnp_dev_name(dev) (dev)->name
0281 
0282 static inline void *pnp_get_drvdata(struct pnp_dev *pdev)
0283 {
0284     return dev_get_drvdata(&pdev->dev);
0285 }
0286 
0287 static inline void pnp_set_drvdata(struct pnp_dev *pdev, void *data)
0288 {
0289     dev_set_drvdata(&pdev->dev, data);
0290 }
0291 
0292 struct pnp_fixup {
0293     char id[7];
0294     void (*quirk_function) (struct pnp_dev * dev);  /* fixup function */
0295 };
0296 
0297 /* config parameters */
0298 #define PNP_CONFIG_NORMAL   0x0001
0299 #define PNP_CONFIG_FORCE    0x0002  /* disables validity checking */
0300 
0301 /* capabilities */
0302 #define PNP_READ        0x0001
0303 #define PNP_WRITE       0x0002
0304 #define PNP_DISABLE     0x0004
0305 #define PNP_CONFIGURABLE    0x0008
0306 #define PNP_REMOVABLE       0x0010
0307 #define PNP_CONSOLE     0x0020
0308 
0309 #define pnp_can_read(dev)   (((dev)->protocol->get) && \
0310                  ((dev)->capabilities & PNP_READ))
0311 #define pnp_can_write(dev)  (((dev)->protocol->set) && \
0312                  ((dev)->capabilities & PNP_WRITE))
0313 #define pnp_can_disable(dev)    (((dev)->protocol->disable) &&        \
0314                  ((dev)->capabilities & PNP_DISABLE) &&   \
0315                  (!((dev)->capabilities & PNP_CONSOLE) || \
0316                   console_suspend_enabled))
0317 #define pnp_can_configure(dev)  ((!(dev)->active) && \
0318                  ((dev)->capabilities & PNP_CONFIGURABLE))
0319 #define pnp_can_suspend(dev)    (((dev)->protocol->suspend) &&        \
0320                  (!((dev)->capabilities & PNP_CONSOLE) || \
0321                   console_suspend_enabled))
0322 
0323 
0324 #ifdef CONFIG_ISAPNP
0325 extern struct pnp_protocol isapnp_protocol;
0326 #define pnp_device_is_isapnp(dev) ((dev)->protocol == (&isapnp_protocol))
0327 #else
0328 #define pnp_device_is_isapnp(dev) 0
0329 #endif
0330 extern struct mutex pnp_res_mutex;
0331 
0332 #ifdef CONFIG_PNPBIOS
0333 extern struct pnp_protocol pnpbios_protocol;
0334 extern bool arch_pnpbios_disabled(void);
0335 #define pnp_device_is_pnpbios(dev) ((dev)->protocol == (&pnpbios_protocol))
0336 #else
0337 #define pnp_device_is_pnpbios(dev) 0
0338 #define arch_pnpbios_disabled() false
0339 #endif
0340 
0341 #ifdef CONFIG_PNPACPI
0342 extern struct pnp_protocol pnpacpi_protocol;
0343 
0344 static inline struct acpi_device *pnp_acpi_device(struct pnp_dev *dev)
0345 {
0346     if (dev->protocol == &pnpacpi_protocol)
0347         return dev->data;
0348     return NULL;
0349 }
0350 #else
0351 #define pnp_acpi_device(dev) 0
0352 #endif
0353 
0354 /* status */
0355 #define PNP_READY       0x0000
0356 #define PNP_ATTACHED        0x0001
0357 #define PNP_BUSY        0x0002
0358 #define PNP_FAULTY      0x0004
0359 
0360 /* isapnp specific macros */
0361 
0362 #define isapnp_card_number(dev) ((dev)->card ? (dev)->card->number : -1)
0363 #define isapnp_csn_number(dev)  ((dev)->number)
0364 
0365 /*
0366  * Driver Management
0367  */
0368 
0369 struct pnp_id {
0370     char id[PNP_ID_LEN];
0371     struct pnp_id *next;
0372 };
0373 
0374 struct pnp_driver {
0375     const char *name;
0376     const struct pnp_device_id *id_table;
0377     unsigned int flags;
0378     int (*probe) (struct pnp_dev *dev, const struct pnp_device_id *dev_id);
0379     void (*remove) (struct pnp_dev *dev);
0380     void (*shutdown) (struct pnp_dev *dev);
0381     int (*suspend) (struct pnp_dev *dev, pm_message_t state);
0382     int (*resume) (struct pnp_dev *dev);
0383     struct device_driver driver;
0384 };
0385 
0386 #define to_pnp_driver(drv) container_of(drv, struct pnp_driver, driver)
0387 
0388 struct pnp_card_driver {
0389     struct list_head global_list;
0390     char *name;
0391     const struct pnp_card_device_id *id_table;
0392     unsigned int flags;
0393     int (*probe) (struct pnp_card_link *card,
0394               const struct pnp_card_device_id *card_id);
0395     void (*remove) (struct pnp_card_link *card);
0396     int (*suspend) (struct pnp_card_link *card, pm_message_t state);
0397     int (*resume) (struct pnp_card_link *card);
0398     struct pnp_driver link;
0399 };
0400 
0401 #define to_pnp_card_driver(drv) container_of(drv, struct pnp_card_driver, link)
0402 
0403 /* pnp driver flags */
0404 #define PNP_DRIVER_RES_DO_NOT_CHANGE    0x0001  /* do not change the state of the device */
0405 #define PNP_DRIVER_RES_DISABLE      0x0003  /* ensure the device is disabled */
0406 
0407 /*
0408  * Protocol Management
0409  */
0410 
0411 struct pnp_protocol {
0412     struct list_head protocol_list;
0413     char *name;
0414 
0415     /* resource control functions */
0416     int (*get) (struct pnp_dev *dev);
0417     int (*set) (struct pnp_dev *dev);
0418     int (*disable) (struct pnp_dev *dev);
0419 
0420     /* protocol specific suspend/resume */
0421     bool (*can_wakeup) (struct pnp_dev *dev);
0422     int (*suspend) (struct pnp_dev * dev, pm_message_t state);
0423     int (*resume) (struct pnp_dev * dev);
0424 
0425     /* used by pnp layer only (look but don't touch) */
0426     unsigned char number;   /* protocol number */
0427     struct device dev;  /* link to driver model */
0428     struct list_head cards;
0429     struct list_head devices;
0430 };
0431 
0432 #define to_pnp_protocol(n) list_entry(n, struct pnp_protocol, protocol_list)
0433 #define protocol_for_each_card(protocol, card)  \
0434     list_for_each_entry(card, &(protocol)->cards, protocol_list)
0435 #define protocol_for_each_dev(protocol, dev)    \
0436     list_for_each_entry(dev, &(protocol)->devices, protocol_list)
0437 
0438 extern struct bus_type pnp_bus_type;
0439 
0440 #if defined(CONFIG_PNP)
0441 
0442 /* device management */
0443 int pnp_device_attach(struct pnp_dev *pnp_dev);
0444 void pnp_device_detach(struct pnp_dev *pnp_dev);
0445 extern struct list_head pnp_global;
0446 extern int pnp_platform_devices;
0447 
0448 /* multidevice card support */
0449 struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink,
0450                     const char *id, struct pnp_dev *from);
0451 void pnp_release_card_device(struct pnp_dev *dev);
0452 int pnp_register_card_driver(struct pnp_card_driver *drv);
0453 void pnp_unregister_card_driver(struct pnp_card_driver *drv);
0454 extern struct list_head pnp_cards;
0455 
0456 /* resource management */
0457 int pnp_possible_config(struct pnp_dev *dev, int type, resource_size_t base,
0458             resource_size_t size);
0459 int pnp_auto_config_dev(struct pnp_dev *dev);
0460 int pnp_start_dev(struct pnp_dev *dev);
0461 int pnp_stop_dev(struct pnp_dev *dev);
0462 int pnp_activate_dev(struct pnp_dev *dev);
0463 int pnp_disable_dev(struct pnp_dev *dev);
0464 int pnp_range_reserved(resource_size_t start, resource_size_t end);
0465 
0466 /* protocol helpers */
0467 int pnp_is_active(struct pnp_dev *dev);
0468 int compare_pnp_id(struct pnp_id *pos, const char *id);
0469 int pnp_register_driver(struct pnp_driver *drv);
0470 void pnp_unregister_driver(struct pnp_driver *drv);
0471 
0472 #else
0473 
0474 /* device management */
0475 static inline int pnp_device_attach(struct pnp_dev *pnp_dev) { return -ENODEV; }
0476 static inline void pnp_device_detach(struct pnp_dev *pnp_dev) { }
0477 
0478 #define pnp_platform_devices 0
0479 
0480 /* multidevice card support */
0481 static inline struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink, const char *id, struct pnp_dev *from) { return NULL; }
0482 static inline void pnp_release_card_device(struct pnp_dev *dev) { }
0483 static inline int pnp_register_card_driver(struct pnp_card_driver *drv) { return -ENODEV; }
0484 static inline void pnp_unregister_card_driver(struct pnp_card_driver *drv) { }
0485 
0486 /* resource management */
0487 static inline int pnp_possible_config(struct pnp_dev *dev, int type,
0488                       resource_size_t base,
0489                       resource_size_t size) { return 0; }
0490 static inline int pnp_auto_config_dev(struct pnp_dev *dev) { return -ENODEV; }
0491 static inline int pnp_start_dev(struct pnp_dev *dev) { return -ENODEV; }
0492 static inline int pnp_stop_dev(struct pnp_dev *dev) { return -ENODEV; }
0493 static inline int pnp_activate_dev(struct pnp_dev *dev) { return -ENODEV; }
0494 static inline int pnp_disable_dev(struct pnp_dev *dev) { return -ENODEV; }
0495 static inline int pnp_range_reserved(resource_size_t start, resource_size_t end) { return 0;}
0496 
0497 /* protocol helpers */
0498 static inline int pnp_is_active(struct pnp_dev *dev) { return 0; }
0499 static inline int compare_pnp_id(struct pnp_id *pos, const char *id) { return -ENODEV; }
0500 static inline int pnp_register_driver(struct pnp_driver *drv) { return -ENODEV; }
0501 static inline void pnp_unregister_driver(struct pnp_driver *drv) { }
0502 
0503 #endif /* CONFIG_PNP */
0504 
0505 /**
0506  * module_pnp_driver() - Helper macro for registering a PnP driver
0507  * @__pnp_driver: pnp_driver struct
0508  *
0509  * Helper macro for PnP drivers which do not do anything special in module
0510  * init/exit. This eliminates a lot of boilerplate. Each module may only
0511  * use this macro once, and calling it replaces module_init() and module_exit()
0512  */
0513 #define module_pnp_driver(__pnp_driver) \
0514     module_driver(__pnp_driver, pnp_register_driver, \
0515                     pnp_unregister_driver)
0516 
0517 #endif /* _LINUX_PNP_H */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!