LCOV - code coverage report
Current view: top level - include/linux - mod_devicetable.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 3 3 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : /*
       2             :  * Device tables which are exported to userspace via
       3             :  * scripts/mod/file2alias.c.  You must keep that file in sync with this
       4             :  * header.
       5             :  */
       6             : 
       7             : #ifndef LINUX_MOD_DEVICETABLE_H
       8             : #define LINUX_MOD_DEVICETABLE_H
       9             : 
      10             : #ifdef __KERNEL__
      11             : #include <linux/types.h>
      12           1 : typedef unsigned long kernel_ulong_t;
      13           1 : #endif
      14             : 
      15             : #define PCI_ANY_ID (~0)
      16             : 
      17             : struct pci_device_id {
      18             :         __u32 vendor, device;           /* Vendor and device ID or PCI_ANY_ID*/
      19             :         __u32 subvendor, subdevice;     /* Subsystem ID's or PCI_ANY_ID */
      20             :         __u32 class, class_mask;        /* (class,subclass,prog-if) triplet */
      21             :         kernel_ulong_t driver_data;     /* Data private to the driver */
      22             : };
      23             : 
      24             : 
      25             : #define IEEE1394_MATCH_VENDOR_ID        0x0001
      26             : #define IEEE1394_MATCH_MODEL_ID         0x0002
      27             : #define IEEE1394_MATCH_SPECIFIER_ID     0x0004
      28             : #define IEEE1394_MATCH_VERSION          0x0008
      29             : 
      30             : struct ieee1394_device_id {
      31             :         __u32 match_flags;
      32             :         __u32 vendor_id;
      33             :         __u32 model_id;
      34             :         __u32 specifier_id;
      35             :         __u32 version;
      36             :         kernel_ulong_t driver_data
      37             :                 __attribute__((aligned(sizeof(kernel_ulong_t))));
      38             : };
      39             : 
      40             : 
      41             : /*
      42             :  * Device table entry for "new style" table-driven USB drivers.
      43             :  * User mode code can read these tables to choose which modules to load.
      44             :  * Declare the table as a MODULE_DEVICE_TABLE.
      45             :  *
      46             :  * A probe() parameter will point to a matching entry from this table.
      47             :  * Use the driver_info field for each match to hold information tied
      48             :  * to that match:  device quirks, etc.
      49             :  *
      50             :  * Terminate the driver's table with an all-zeroes entry.
      51             :  * Use the flag values to control which fields are compared.
      52             :  */
      53             : 
      54             : /**
      55             :  * struct usb_device_id - identifies USB devices for probing and hotplugging
      56             :  * @match_flags: Bit mask controlling of the other fields are used to match
      57             :  *      against new devices.  Any field except for driver_info may be used,
      58             :  *      although some only make sense in conjunction with other fields.
      59             :  *      This is usually set by a USB_DEVICE_*() macro, which sets all
      60             :  *      other fields in this structure except for driver_info.
      61             :  * @idVendor: USB vendor ID for a device; numbers are assigned
      62             :  *      by the USB forum to its members.
      63             :  * @idProduct: Vendor-assigned product ID.
      64             :  * @bcdDevice_lo: Low end of range of vendor-assigned product version numbers.
      65             :  *      This is also used to identify individual product versions, for
      66             :  *      a range consisting of a single device.
      67             :  * @bcdDevice_hi: High end of version number range.  The range of product
      68             :  *      versions is inclusive.
      69             :  * @bDeviceClass: Class of device; numbers are assigned
      70             :  *      by the USB forum.  Products may choose to implement classes,
      71             :  *      or be vendor-specific.  Device classes specify behavior of all
      72             :  *      the interfaces on a devices.
      73             :  * @bDeviceSubClass: Subclass of device; associated with bDeviceClass.
      74             :  * @bDeviceProtocol: Protocol of device; associated with bDeviceClass.
      75             :  * @bInterfaceClass: Class of interface; numbers are assigned
      76             :  *      by the USB forum.  Products may choose to implement classes,
      77             :  *      or be vendor-specific.  Interface classes specify behavior only
      78             :  *      of a given interface; other interfaces may support other classes.
      79             :  * @bInterfaceSubClass: Subclass of interface; associated with bInterfaceClass.
      80             :  * @bInterfaceProtocol: Protocol of interface; associated with bInterfaceClass.
      81             :  * @driver_info: Holds information used by the driver.  Usually it holds
      82             :  *      a pointer to a descriptor understood by the driver, or perhaps
      83             :  *      device flags.
      84             :  *
      85             :  * In most cases, drivers will create a table of device IDs by using
      86             :  * USB_DEVICE(), or similar macros designed for that purpose.
      87             :  * They will then export it to userspace using MODULE_DEVICE_TABLE(),
      88             :  * and provide it to the USB core through their usb_driver structure.
      89             :  *
      90             :  * See the usb_match_id() function for information about how matches are
      91             :  * performed.  Briefly, you will normally use one of several macros to help
      92             :  * construct these entries.  Each entry you provide will either identify
      93             :  * one or more specific products, or will identify a class of products
      94             :  * which have agreed to behave the same.  You should put the more specific
      95             :  * matches towards the beginning of your table, so that driver_info can
      96             :  * record quirks of specific products.
      97             :  */
      98             : struct usb_device_id {
      99             :         /* which fields to match against? */
     100             :         __u16           match_flags;
     101             : 
     102             :         /* Used for product specific matches; range is inclusive */
     103             :         __u16           idVendor;
     104             :         __u16           idProduct;
     105             :         __u16           bcdDevice_lo;
     106             :         __u16           bcdDevice_hi;
     107             : 
     108             :         /* Used for device class matches */
     109             :         __u8            bDeviceClass;
     110             :         __u8            bDeviceSubClass;
     111             :         __u8            bDeviceProtocol;
     112             : 
     113             :         /* Used for interface class matches */
     114             :         __u8            bInterfaceClass;
     115             :         __u8            bInterfaceSubClass;
     116             :         __u8            bInterfaceProtocol;
     117             : 
     118             :         /* not matched against */
     119             :         kernel_ulong_t  driver_info;
     120             : };
     121             : 
     122             : /* Some useful macros to use to create struct usb_device_id */
     123             : #define USB_DEVICE_ID_MATCH_VENDOR              0x0001
     124             : #define USB_DEVICE_ID_MATCH_PRODUCT             0x0002
     125             : #define USB_DEVICE_ID_MATCH_DEV_LO              0x0004
     126             : #define USB_DEVICE_ID_MATCH_DEV_HI              0x0008
     127             : #define USB_DEVICE_ID_MATCH_DEV_CLASS           0x0010
     128             : #define USB_DEVICE_ID_MATCH_DEV_SUBCLASS        0x0020
     129             : #define USB_DEVICE_ID_MATCH_DEV_PROTOCOL        0x0040
     130             : #define USB_DEVICE_ID_MATCH_INT_CLASS           0x0080
     131             : #define USB_DEVICE_ID_MATCH_INT_SUBCLASS        0x0100
     132             : #define USB_DEVICE_ID_MATCH_INT_PROTOCOL        0x0200
     133             : 
     134             : #define HID_ANY_ID                              (~0)
     135             : 
     136             : struct hid_device_id {
     137             :         __u16 bus;
     138             :         __u16 pad1;
     139             :         __u32 vendor;
     140             :         __u32 product;
     141             :         kernel_ulong_t driver_data
     142             :                 __attribute__((aligned(sizeof(kernel_ulong_t))));
     143             : };
     144             : 
     145             : /* s390 CCW devices */
     146             : struct ccw_device_id {
     147             :         __u16   match_flags;    /* which fields to match against */
     148             : 
     149             :         __u16   cu_type;        /* control unit type     */
     150             :         __u16   dev_type;       /* device type           */
     151             :         __u8    cu_model;       /* control unit model    */
     152             :         __u8    dev_model;      /* device model          */
     153             : 
     154             :         kernel_ulong_t driver_info;
     155             : };
     156             : 
     157             : #define CCW_DEVICE_ID_MATCH_CU_TYPE             0x01
     158             : #define CCW_DEVICE_ID_MATCH_CU_MODEL            0x02
     159             : #define CCW_DEVICE_ID_MATCH_DEVICE_TYPE         0x04
     160             : #define CCW_DEVICE_ID_MATCH_DEVICE_MODEL        0x08
     161             : 
     162             : /* s390 AP bus devices */
     163             : struct ap_device_id {
     164             :         __u16 match_flags;      /* which fields to match against */
     165             :         __u8 dev_type;          /* device type */
     166             :         __u8 pad1;
     167             :         __u32 pad2;
     168             :         kernel_ulong_t driver_info;
     169             : };
     170             : 
     171             : #define AP_DEVICE_ID_MATCH_DEVICE_TYPE          0x01
     172             : 
     173             : /* s390 css bus devices (subchannels) */
     174             : struct css_device_id {
     175             :         __u8 match_flags;
     176             :         __u8 type; /* subchannel type */
     177             :         __u16 pad2;
     178             :         __u32 pad3;
     179             :         kernel_ulong_t driver_data;
     180             : };
     181             : 
     182             : #define ACPI_ID_LEN     16 /* only 9 bytes needed here, 16 bytes are used */
     183             :                            /* to workaround crosscompile issues */
     184             : 
     185             : struct acpi_device_id {
     186             :         __u8 id[ACPI_ID_LEN];
     187             :         kernel_ulong_t driver_data;
     188             : };
     189             : 
     190             : #define PNP_ID_LEN      8
     191             : #define PNP_MAX_DEVICES 8
     192             : 
     193             : struct pnp_device_id {
     194             :         __u8 id[PNP_ID_LEN];
     195             :         kernel_ulong_t driver_data;
     196             : };
     197             : 
     198             : struct pnp_card_device_id {
     199             :         __u8 id[PNP_ID_LEN];
     200             :         kernel_ulong_t driver_data;
     201             :         struct {
     202             :                 __u8 id[PNP_ID_LEN];
     203             :         } devs[PNP_MAX_DEVICES];
     204             : };
     205             : 
     206             : 
     207             : #define SERIO_ANY       0xff
     208             : 
     209             : struct serio_device_id {
     210             :         __u8 type;
     211             :         __u8 extra;
     212             :         __u8 id;
     213             :         __u8 proto;
     214             : };
     215             : 
     216             : /*
     217             :  * Struct used for matching a device
     218             :  */
     219             : struct of_device_id
     220             : {
     221             :         char    name[32];
     222             :         char    type[32];
     223             :         char    compatible[128];
     224             : #ifdef __KERNEL__
     225             :         void    *data;
     226             : #else
     227             :         kernel_ulong_t data;
     228             : #endif
     229             : };
     230             : 
     231             : /* VIO */
     232             : struct vio_device_id {
     233             :         char type[32];
     234             :         char compat[32];
     235             : };
     236             : 
     237             : /* PCMCIA */
     238             : 
     239             : struct pcmcia_device_id {
     240             :         __u16           match_flags;
     241             : 
     242             :         __u16           manf_id;
     243             :         __u16           card_id;
     244             : 
     245             :         __u8            func_id;
     246             : 
     247             :         /* for real multi-function devices */
     248             :         __u8            function;
     249             : 
     250             :         /* for pseudo multi-function devices */
     251             :         __u8            device_no;
     252             : 
     253             :         __u32           prod_id_hash[4]
     254             :                 __attribute__((aligned(sizeof(__u32))));
     255             : 
     256             :         /* not matched against in kernelspace*/
     257             : #ifdef __KERNEL__
     258             :         const char *    prod_id[4];
     259             : #else
     260             :         kernel_ulong_t  prod_id[4]
     261             :                 __attribute__((aligned(sizeof(kernel_ulong_t))));
     262             : #endif
     263             : 
     264             :         /* not matched against */
     265             :         kernel_ulong_t  driver_info;
     266             : #ifdef __KERNEL__
     267             :         char *          cisfile;
     268             : #else
     269             :         kernel_ulong_t  cisfile;
     270             : #endif
     271             : };
     272             : 
     273             : #define PCMCIA_DEV_ID_MATCH_MANF_ID     0x0001
     274             : #define PCMCIA_DEV_ID_MATCH_CARD_ID     0x0002
     275             : #define PCMCIA_DEV_ID_MATCH_FUNC_ID     0x0004
     276             : #define PCMCIA_DEV_ID_MATCH_FUNCTION    0x0008
     277             : #define PCMCIA_DEV_ID_MATCH_PROD_ID1    0x0010
     278             : #define PCMCIA_DEV_ID_MATCH_PROD_ID2    0x0020
     279             : #define PCMCIA_DEV_ID_MATCH_PROD_ID3    0x0040
     280             : #define PCMCIA_DEV_ID_MATCH_PROD_ID4    0x0080
     281             : #define PCMCIA_DEV_ID_MATCH_DEVICE_NO   0x0100
     282             : #define PCMCIA_DEV_ID_MATCH_FAKE_CIS    0x0200
     283             : #define PCMCIA_DEV_ID_MATCH_ANONYMOUS   0x0400
     284             : 
     285             : /* Input */
     286             : #define INPUT_DEVICE_ID_EV_MAX          0x1f
     287             : #define INPUT_DEVICE_ID_KEY_MIN_INTERESTING     0x71
     288             : #define INPUT_DEVICE_ID_KEY_MAX         0x2ff
     289             : #define INPUT_DEVICE_ID_REL_MAX         0x0f
     290             : #define INPUT_DEVICE_ID_ABS_MAX         0x3f
     291             : #define INPUT_DEVICE_ID_MSC_MAX         0x07
     292             : #define INPUT_DEVICE_ID_LED_MAX         0x0f
     293             : #define INPUT_DEVICE_ID_SND_MAX         0x07
     294             : #define INPUT_DEVICE_ID_FF_MAX          0x7f
     295             : #define INPUT_DEVICE_ID_SW_MAX          0x0f
     296             : 
     297             : #define INPUT_DEVICE_ID_MATCH_BUS       1
     298             : #define INPUT_DEVICE_ID_MATCH_VENDOR    2
     299             : #define INPUT_DEVICE_ID_MATCH_PRODUCT   4
     300             : #define INPUT_DEVICE_ID_MATCH_VERSION   8
     301             : 
     302             : #define INPUT_DEVICE_ID_MATCH_EVBIT     0x0010
     303             : #define INPUT_DEVICE_ID_MATCH_KEYBIT    0x0020
     304             : #define INPUT_DEVICE_ID_MATCH_RELBIT    0x0040
     305             : #define INPUT_DEVICE_ID_MATCH_ABSBIT    0x0080
     306             : #define INPUT_DEVICE_ID_MATCH_MSCIT     0x0100
     307             : #define INPUT_DEVICE_ID_MATCH_LEDBIT    0x0200
     308             : #define INPUT_DEVICE_ID_MATCH_SNDBIT    0x0400
     309             : #define INPUT_DEVICE_ID_MATCH_FFBIT     0x0800
     310             : #define INPUT_DEVICE_ID_MATCH_SWBIT     0x1000
     311             : 
     312             : struct input_device_id {
     313             : 
     314             :         kernel_ulong_t flags;
     315             : 
     316             :         __u16 bustype;
     317             :         __u16 vendor;
     318             :         __u16 product;
     319             :         __u16 version;
     320             : 
     321             :         kernel_ulong_t evbit[INPUT_DEVICE_ID_EV_MAX / BITS_PER_LONG + 1];
     322             :         kernel_ulong_t keybit[INPUT_DEVICE_ID_KEY_MAX / BITS_PER_LONG + 1];
     323             :         kernel_ulong_t relbit[INPUT_DEVICE_ID_REL_MAX / BITS_PER_LONG + 1];
     324             :         kernel_ulong_t absbit[INPUT_DEVICE_ID_ABS_MAX / BITS_PER_LONG + 1];
     325             :         kernel_ulong_t mscbit[INPUT_DEVICE_ID_MSC_MAX / BITS_PER_LONG + 1];
     326             :         kernel_ulong_t ledbit[INPUT_DEVICE_ID_LED_MAX / BITS_PER_LONG + 1];
     327             :         kernel_ulong_t sndbit[INPUT_DEVICE_ID_SND_MAX / BITS_PER_LONG + 1];
     328             :         kernel_ulong_t ffbit[INPUT_DEVICE_ID_FF_MAX / BITS_PER_LONG + 1];
     329             :         kernel_ulong_t swbit[INPUT_DEVICE_ID_SW_MAX / BITS_PER_LONG + 1];
     330             : 
     331             :         kernel_ulong_t driver_info;
     332             : };
     333           1 : 
     334             : /* EISA */
     335             : 
     336             : #define EISA_SIG_LEN   8
     337             : 
     338             : /* The EISA signature, in ASCII form, null terminated */
     339             : struct eisa_device_id {
     340             :         char          sig[EISA_SIG_LEN];
     341             :         kernel_ulong_t driver_data;
     342             : };
     343             : 
     344             : #define EISA_DEVICE_MODALIAS_FMT "eisa:s%s"
     345             : 
     346             : struct parisc_device_id {
     347             :         __u8    hw_type;        /* 5 bits used */
     348             :         __u8    hversion_rev;   /* 4 bits */
     349             :         __u16   hversion;       /* 12 bits */
     350             :         __u32   sversion;       /* 20 bits */
     351             : };
     352             : 
     353             : #define PA_HWTYPE_ANY_ID        0xff
     354             : #define PA_HVERSION_REV_ANY_ID  0xff
     355             : #define PA_HVERSION_ANY_ID      0xffff
     356             : #define PA_SVERSION_ANY_ID      0xffffffff
     357             : 
     358             : /* SDIO */
     359             : 
     360             : #define SDIO_ANY_ID (~0)
     361             : 
     362             : struct sdio_device_id {
     363             :         __u8    class;                  /* Standard interface or SDIO_ANY_ID */
     364             :         __u16   vendor;                 /* Vendor or SDIO_ANY_ID */
     365             :         __u16   device;                 /* Device ID or SDIO_ANY_ID */
     366             :         kernel_ulong_t driver_data      /* Data private to the driver */
     367             :                 __attribute__((aligned(sizeof(kernel_ulong_t))));
     368             : };
     369             : 
     370             : /* SSB core, see drivers/ssb/ */
     371             : struct ssb_device_id {
     372             :         __u16   vendor;
     373             :         __u16   coreid;
     374             :         __u8    revision;
     375             : };
     376             : #define SSB_DEVICE(_vendor, _coreid, _revision)  \
     377             :         { .vendor = _vendor, .coreid = _coreid, .revision = _revision, }
     378             : #define SSB_DEVTABLE_END  \
     379             :         { 0, },
     380             : 
     381             : #define SSB_ANY_VENDOR          0xFFFF
     382             : #define SSB_ANY_ID              0xFFFF
     383             : #define SSB_ANY_REV             0xFF
     384             : 
     385             : struct virtio_device_id {
     386             :         __u32 device;
     387             :         __u32 vendor;
     388             : };
     389             : #define VIRTIO_DEV_ANY_ID       0xffffffff
     390             : 
     391             : /* i2c */
     392             : 
     393             : #define I2C_NAME_SIZE   20
     394             : #define I2C_MODULE_PREFIX "i2c:"
     395             : 
     396             : struct i2c_device_id {
     397             :         char name[I2C_NAME_SIZE];
     398             :         kernel_ulong_t driver_data      /* Data private to the driver */
     399             :                         __attribute__((aligned(sizeof(kernel_ulong_t))));
     400             : };
     401             : 
     402             : /* spi */
     403             : 
     404             : #define SPI_NAME_SIZE   32
     405             : #define SPI_MODULE_PREFIX "spi:"
     406             : 
     407             : struct spi_device_id {
     408             :         char name[SPI_NAME_SIZE];
     409             :         kernel_ulong_t driver_data      /* Data private to the driver */
     410             :                         __attribute__((aligned(sizeof(kernel_ulong_t))));
     411             : };
     412             : 
     413             : /* dmi */
     414             : enum dmi_field {
     415             :         DMI_NONE,
     416             :         DMI_BIOS_VENDOR,
     417             :         DMI_BIOS_VERSION,
     418             :         DMI_BIOS_DATE,
     419             :         DMI_SYS_VENDOR,
     420             :         DMI_PRODUCT_NAME,
     421             :         DMI_PRODUCT_VERSION,
     422             :         DMI_PRODUCT_SERIAL,
     423             :         DMI_PRODUCT_UUID,
     424             :         DMI_BOARD_VENDOR,
     425             :         DMI_BOARD_NAME,
     426             :         DMI_BOARD_VERSION,
     427             :         DMI_BOARD_SERIAL,
     428             :         DMI_BOARD_ASSET_TAG,
     429             :         DMI_CHASSIS_VENDOR,
     430             :         DMI_CHASSIS_TYPE,
     431             :         DMI_CHASSIS_VERSION,
     432             :         DMI_CHASSIS_SERIAL,
     433             :         DMI_CHASSIS_ASSET_TAG,
     434             :         DMI_STRING_MAX,
     435             : };
     436             : 
     437             : struct dmi_strmatch {
     438             :         unsigned char slot;
     439             :         char substr[79];
     440             : };
     441             : 
     442             : #ifndef __KERNEL__
     443             : struct dmi_system_id {
     444             :         kernel_ulong_t callback;
     445             :         kernel_ulong_t ident;
     446             :         struct dmi_strmatch matches[4];
     447             :         kernel_ulong_t driver_data
     448             :                         __attribute__((aligned(sizeof(kernel_ulong_t))));
     449             : };
     450             : #else
     451             : struct dmi_system_id {
     452             :         int (*callback)(const struct dmi_system_id *);
     453             :         const char *ident;
     454             :         struct dmi_strmatch matches[4];
     455             :         void *driver_data;
     456             : };
     457             : /*
     458             :  * struct dmi_device_id appears during expansion of
     459             :  * "MODULE_DEVICE_TABLE(dmi, x)". Compiler doesn't look inside it
     460             :  * but this is enough for gcc 3.4.6 to error out:
     461             :  *      error: storage size of '__mod_dmi_device_table' isn't known
     462             :  */
     463             : #define dmi_device_id dmi_system_id
     464             : #endif
     465             : 
     466             : #define DMI_MATCH(a, b) { a, b }
     467             : 
     468             : #define PLATFORM_NAME_SIZE      20
     469             : #define PLATFORM_MODULE_PREFIX  "platform:"
     470             : 
     471             : struct platform_device_id {
     472             :         char name[PLATFORM_NAME_SIZE];
     473             :         kernel_ulong_t driver_data
     474             :                         __attribute__((aligned(sizeof(kernel_ulong_t))));
     475             : };
     476             : 
     477             : #endif /* LINUX_MOD_DEVICETABLE_H */

Generated by: LCOV version 1.10