LCOV - code coverage report
Current view: top level - include/linux - pnp.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 27 47 57.4 %
Date: 2022-04-01 13:59:58 Functions: 1 2 50.0 %
Branches: 17 88 19.3 %

           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                 :       1560 : static inline int pnp_resource_valid(struct resource *res)
      38                 :            : {
      39   [ +  +  -  +  :        702 :         if (res)
          +  -  +  -  +  
                -  +  - ]
      40                 :        624 :                 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                 :        156 : 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                 :        156 :         return resource_size(res);
      56                 :            : }
      57                 :            : 
      58                 :            : 
      59                 :        312 : static inline resource_size_t pnp_port_start(struct pnp_dev *dev,
      60                 :            :                                              unsigned int bar)
      61                 :            : {
      62                 :        312 :         struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar);
      63                 :            : 
      64   [ +  -  +  -  :        312 :         if (pnp_resource_valid(res))
             +  -  +  - ]
      65         [ +  - ]:        312 :                 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                 :        390 : static inline int pnp_port_valid(struct pnp_dev *dev, unsigned int bar)
      90                 :            : {
      91                 :        390 :         return pnp_resource_valid(pnp_get_resource(dev, IORESOURCE_IO, bar));
      92                 :            : }
      93                 :            : 
      94                 :        156 : static inline resource_size_t pnp_port_len(struct pnp_dev *dev,
      95                 :            :                                            unsigned int bar)
      96                 :            : {
      97                 :        156 :         struct resource *res = pnp_get_resource(dev, IORESOURCE_IO, bar);
      98                 :            : 
      99         [ +  - ]:        156 :         if (pnp_resource_valid(res))
     100         [ -  + ]:        312 :                 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                 :        312 : static inline resource_size_t pnp_irq(struct pnp_dev *dev, unsigned int bar)
     151                 :            : {
     152                 :        312 :         struct resource *res = pnp_get_resource(dev, IORESOURCE_IRQ, bar);
     153                 :            : 
     154   [ +  -  +  - ]:        312 :         if (pnp_resource_valid(res))
     155         [ #  # ]:        312 :                 return res->start;
     156                 :            :         return -1;
     157                 :            : }
     158                 :            : 
     159                 :         78 : static inline unsigned long pnp_irq_flags(struct pnp_dev *dev, unsigned int bar)
     160                 :            : {
     161                 :         78 :         struct resource *res = pnp_get_resource(dev, IORESOURCE_IRQ, bar);
     162                 :            : 
     163         [ +  - ]:         78 :         if (pnp_resource_valid(res))
     164                 :         78 :                 return res->flags;
     165                 :            :         return IORESOURCE_IRQ | IORESOURCE_AUTO;
     166                 :            : }
     167                 :            : 
     168                 :        312 : static inline int pnp_irq_valid(struct pnp_dev *dev, unsigned int bar)
     169                 :            : {
     170                 :        312 :         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                 :         78 : static inline void pnp_set_drvdata(struct pnp_dev *pdev, void *data)
     295                 :            : {
     296                 :         78 :         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 */

Generated by: LCOV version 1.14