Loading...
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * Device tables which are exported to userspace via
4 * scripts/mod/file2alias.c. You must keep that file in sync with this
5 * header.
6 */
7
8#ifndef LINUX_MOD_DEVICETABLE_H
9#define LINUX_MOD_DEVICETABLE_H
10
11#ifdef __KERNEL__
12#include <linux/types.h>
13#include <linux/uuid.h>
14typedef unsigned long kernel_ulong_t;
15#endif
16
17#define PCI_ANY_ID (~0)
18
19/**
20 * struct pci_device_id - PCI device ID structure
21 * @vendor: Vendor ID to match (or PCI_ANY_ID)
22 * @device: Device ID to match (or PCI_ANY_ID)
23 * @subvendor: Subsystem vendor ID to match (or PCI_ANY_ID)
24 * @subdevice: Subsystem device ID to match (or PCI_ANY_ID)
25 * @class: Device class, subclass, and "interface" to match.
26 * See Appendix D of the PCI Local Bus Spec or
27 * include/linux/pci_ids.h for a full list of classes.
28 * Most drivers do not need to specify class/class_mask
29 * as vendor/device is normally sufficient.
30 * @class_mask: Limit which sub-fields of the class field are compared.
31 * See drivers/scsi/sym53c8xx_2/ for example of usage.
32 * @driver_data: Data private to the driver.
33 * Most drivers don't need to use driver_data field.
34 * Best practice is to use driver_data as an index
35 * into a static list of equivalent device types,
36 * instead of using it as a pointer.
37 */
38struct pci_device_id {
39 __u32 vendor, device; /* Vendor and device ID or PCI_ANY_ID*/
40 __u32 subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */
41 __u32 class, class_mask; /* (class,subclass,prog-if) triplet */
42 kernel_ulong_t driver_data; /* Data private to the driver */
43};
44
45
46#define IEEE1394_MATCH_VENDOR_ID 0x0001
47#define IEEE1394_MATCH_MODEL_ID 0x0002
48#define IEEE1394_MATCH_SPECIFIER_ID 0x0004
49#define IEEE1394_MATCH_VERSION 0x0008
50
51struct ieee1394_device_id {
52 __u32 match_flags;
53 __u32 vendor_id;
54 __u32 model_id;
55 __u32 specifier_id;
56 __u32 version;
57 kernel_ulong_t driver_data;
58};
59
60
61/*
62 * Device table entry for "new style" table-driven USB drivers.
63 * User mode code can read these tables to choose which modules to load.
64 * Declare the table as a MODULE_DEVICE_TABLE.
65 *
66 * A probe() parameter will point to a matching entry from this table.
67 * Use the driver_info field for each match to hold information tied
68 * to that match: device quirks, etc.
69 *
70 * Terminate the driver's table with an all-zeroes entry.
71 * Use the flag values to control which fields are compared.
72 */
73
74/**
75 * struct usb_device_id - identifies USB devices for probing and hotplugging
76 * @match_flags: Bit mask controlling which of the other fields are used to
77 * match against new devices. Any field except for driver_info may be
78 * used, although some only make sense in conjunction with other fields.
79 * This is usually set by a USB_DEVICE_*() macro, which sets all
80 * other fields in this structure except for driver_info.
81 * @idVendor: USB vendor ID for a device; numbers are assigned
82 * by the USB forum to its members.
83 * @idProduct: Vendor-assigned product ID.
84 * @bcdDevice_lo: Low end of range of vendor-assigned product version numbers.
85 * This is also used to identify individual product versions, for
86 * a range consisting of a single device.
87 * @bcdDevice_hi: High end of version number range. The range of product
88 * versions is inclusive.
89 * @bDeviceClass: Class of device; numbers are assigned
90 * by the USB forum. Products may choose to implement classes,
91 * or be vendor-specific. Device classes specify behavior of all
92 * the interfaces on a device.
93 * @bDeviceSubClass: Subclass of device; associated with bDeviceClass.
94 * @bDeviceProtocol: Protocol of device; associated with bDeviceClass.
95 * @bInterfaceClass: Class of interface; numbers are assigned
96 * by the USB forum. Products may choose to implement classes,
97 * or be vendor-specific. Interface classes specify behavior only
98 * of a given interface; other interfaces may support other classes.
99 * @bInterfaceSubClass: Subclass of interface; associated with bInterfaceClass.
100 * @bInterfaceProtocol: Protocol of interface; associated with bInterfaceClass.
101 * @bInterfaceNumber: Number of interface; composite devices may use
102 * fixed interface numbers to differentiate between vendor-specific
103 * interfaces.
104 * @driver_info: Holds information used by the driver. Usually it holds
105 * a pointer to a descriptor understood by the driver, or perhaps
106 * device flags.
107 *
108 * In most cases, drivers will create a table of device IDs by using
109 * USB_DEVICE(), or similar macros designed for that purpose.
110 * They will then export it to userspace using MODULE_DEVICE_TABLE(),
111 * and provide it to the USB core through their usb_driver structure.
112 *
113 * See the usb_match_id() function for information about how matches are
114 * performed. Briefly, you will normally use one of several macros to help
115 * construct these entries. Each entry you provide will either identify
116 * one or more specific products, or will identify a class of products
117 * which have agreed to behave the same. You should put the more specific
118 * matches towards the beginning of your table, so that driver_info can
119 * record quirks of specific products.
120 */
121struct usb_device_id {
122 /* which fields to match against? */
123 __u16 match_flags;
124
125 /* Used for product specific matches; range is inclusive */
126 __u16 idVendor;
127 __u16 idProduct;
128 __u16 bcdDevice_lo;
129 __u16 bcdDevice_hi;
130
131 /* Used for device class matches */
132 __u8 bDeviceClass;
133 __u8 bDeviceSubClass;
134 __u8 bDeviceProtocol;
135
136 /* Used for interface class matches */
137 __u8 bInterfaceClass;
138 __u8 bInterfaceSubClass;
139 __u8 bInterfaceProtocol;
140
141 /* Used for vendor-specific interface matches */
142 __u8 bInterfaceNumber;
143
144 /* not matched against */
145 kernel_ulong_t driver_info
146 __attribute__((aligned(sizeof(kernel_ulong_t))));
147};
148
149/* Some useful macros to use to create struct usb_device_id */
150#define USB_DEVICE_ID_MATCH_VENDOR 0x0001
151#define USB_DEVICE_ID_MATCH_PRODUCT 0x0002
152#define USB_DEVICE_ID_MATCH_DEV_LO 0x0004
153#define USB_DEVICE_ID_MATCH_DEV_HI 0x0008
154#define USB_DEVICE_ID_MATCH_DEV_CLASS 0x0010
155#define USB_DEVICE_ID_MATCH_DEV_SUBCLASS 0x0020
156#define USB_DEVICE_ID_MATCH_DEV_PROTOCOL 0x0040
157#define USB_DEVICE_ID_MATCH_INT_CLASS 0x0080
158#define USB_DEVICE_ID_MATCH_INT_SUBCLASS 0x0100
159#define USB_DEVICE_ID_MATCH_INT_PROTOCOL 0x0200
160#define USB_DEVICE_ID_MATCH_INT_NUMBER 0x0400
161
162#define HID_ANY_ID (~0)
163#define HID_BUS_ANY 0xffff
164#define HID_GROUP_ANY 0x0000
165
166struct hid_device_id {
167 __u16 bus;
168 __u16 group;
169 __u32 vendor;
170 __u32 product;
171 kernel_ulong_t driver_data;
172};
173
174/* s390 CCW devices */
175struct ccw_device_id {
176 __u16 match_flags; /* which fields to match against */
177
178 __u16 cu_type; /* control unit type */
179 __u16 dev_type; /* device type */
180 __u8 cu_model; /* control unit model */
181 __u8 dev_model; /* device model */
182
183 kernel_ulong_t driver_info;
184};
185
186#define CCW_DEVICE_ID_MATCH_CU_TYPE 0x01
187#define CCW_DEVICE_ID_MATCH_CU_MODEL 0x02
188#define CCW_DEVICE_ID_MATCH_DEVICE_TYPE 0x04
189#define CCW_DEVICE_ID_MATCH_DEVICE_MODEL 0x08
190
191/* s390 AP bus devices */
192struct ap_device_id {
193 __u16 match_flags; /* which fields to match against */
194 __u8 dev_type; /* device type */
195 kernel_ulong_t driver_info;
196};
197
198#define AP_DEVICE_ID_MATCH_CARD_TYPE 0x01
199#define AP_DEVICE_ID_MATCH_QUEUE_TYPE 0x02
200
201/* s390 css bus devices (subchannels) */
202struct css_device_id {
203 __u8 match_flags;
204 __u8 type; /* subchannel type */
205 kernel_ulong_t driver_data;
206};
207
208#define ACPI_ID_LEN 9
209
210struct acpi_device_id {
211 __u8 id[ACPI_ID_LEN];
212 kernel_ulong_t driver_data;
213 __u32 cls;
214 __u32 cls_msk;
215};
216
217#define PNP_ID_LEN 8
218#define PNP_MAX_DEVICES 8
219
220struct pnp_device_id {
221 __u8 id[PNP_ID_LEN];
222 kernel_ulong_t driver_data;
223};
224
225struct pnp_card_device_id {
226 __u8 id[PNP_ID_LEN];
227 kernel_ulong_t driver_data;
228 struct {
229 __u8 id[PNP_ID_LEN];
230 } devs[PNP_MAX_DEVICES];
231};
232
233
234#define SERIO_ANY 0xff
235
236struct serio_device_id {
237 __u8 type;
238 __u8 extra;
239 __u8 id;
240 __u8 proto;
241};
242
243struct hda_device_id {
244 __u32 vendor_id;
245 __u32 rev_id;
246 __u8 api_version;
247 const char *name;
248 unsigned long driver_data;
249};
250
251struct sdw_device_id {
252 __u16 mfg_id;
253 __u16 part_id;
254 __u8 sdw_version;
255 __u8 class_id;
256 kernel_ulong_t driver_data;
257};
258
259/*
260 * Struct used for matching a device
261 */
262struct of_device_id {
263 char name[32];
264 char type[32];
265 char compatible[128];
266 const void *data;
267};
268
269/* VIO */
270struct vio_device_id {
271 char type[32];
272 char compat[32];
273};
274
275/* PCMCIA */
276
277struct pcmcia_device_id {
278 __u16 match_flags;
279
280 __u16 manf_id;
281 __u16 card_id;
282
283 __u8 func_id;
284
285 /* for real multi-function devices */
286 __u8 function;
287
288 /* for pseudo multi-function devices */
289 __u8 device_no;
290
291 __u32 prod_id_hash[4];
292
293 /* not matched against in kernelspace */
294 const char * prod_id[4];
295
296 /* not matched against */
297 kernel_ulong_t driver_info;
298 char * cisfile;
299};
300
301#define PCMCIA_DEV_ID_MATCH_MANF_ID 0x0001
302#define PCMCIA_DEV_ID_MATCH_CARD_ID 0x0002
303#define PCMCIA_DEV_ID_MATCH_FUNC_ID 0x0004
304#define PCMCIA_DEV_ID_MATCH_FUNCTION 0x0008
305#define PCMCIA_DEV_ID_MATCH_PROD_ID1 0x0010
306#define PCMCIA_DEV_ID_MATCH_PROD_ID2 0x0020
307#define PCMCIA_DEV_ID_MATCH_PROD_ID3 0x0040
308#define PCMCIA_DEV_ID_MATCH_PROD_ID4 0x0080
309#define PCMCIA_DEV_ID_MATCH_DEVICE_NO 0x0100
310#define PCMCIA_DEV_ID_MATCH_FAKE_CIS 0x0200
311#define PCMCIA_DEV_ID_MATCH_ANONYMOUS 0x0400
312
313/* Input */
314#define INPUT_DEVICE_ID_EV_MAX 0x1f
315#define INPUT_DEVICE_ID_KEY_MIN_INTERESTING 0x71
316#define INPUT_DEVICE_ID_KEY_MAX 0x2ff
317#define INPUT_DEVICE_ID_REL_MAX 0x0f
318#define INPUT_DEVICE_ID_ABS_MAX 0x3f
319#define INPUT_DEVICE_ID_MSC_MAX 0x07
320#define INPUT_DEVICE_ID_LED_MAX 0x0f
321#define INPUT_DEVICE_ID_SND_MAX 0x07
322#define INPUT_DEVICE_ID_FF_MAX 0x7f
323#define INPUT_DEVICE_ID_SW_MAX 0x10
324#define INPUT_DEVICE_ID_PROP_MAX 0x1f
325
326#define INPUT_DEVICE_ID_MATCH_BUS 1
327#define INPUT_DEVICE_ID_MATCH_VENDOR 2
328#define INPUT_DEVICE_ID_MATCH_PRODUCT 4
329#define INPUT_DEVICE_ID_MATCH_VERSION 8
330
331#define INPUT_DEVICE_ID_MATCH_EVBIT 0x0010
332#define INPUT_DEVICE_ID_MATCH_KEYBIT 0x0020
333#define INPUT_DEVICE_ID_MATCH_RELBIT 0x0040
334#define INPUT_DEVICE_ID_MATCH_ABSBIT 0x0080
335#define INPUT_DEVICE_ID_MATCH_MSCIT 0x0100
336#define INPUT_DEVICE_ID_MATCH_LEDBIT 0x0200
337#define INPUT_DEVICE_ID_MATCH_SNDBIT 0x0400
338#define INPUT_DEVICE_ID_MATCH_FFBIT 0x0800
339#define INPUT_DEVICE_ID_MATCH_SWBIT 0x1000
340#define INPUT_DEVICE_ID_MATCH_PROPBIT 0x2000
341
342struct input_device_id {
343
344 kernel_ulong_t flags;
345
346 __u16 bustype;
347 __u16 vendor;
348 __u16 product;
349 __u16 version;
350
351 kernel_ulong_t evbit[INPUT_DEVICE_ID_EV_MAX / BITS_PER_LONG + 1];
352 kernel_ulong_t keybit[INPUT_DEVICE_ID_KEY_MAX / BITS_PER_LONG + 1];
353 kernel_ulong_t relbit[INPUT_DEVICE_ID_REL_MAX / BITS_PER_LONG + 1];
354 kernel_ulong_t absbit[INPUT_DEVICE_ID_ABS_MAX / BITS_PER_LONG + 1];
355 kernel_ulong_t mscbit[INPUT_DEVICE_ID_MSC_MAX / BITS_PER_LONG + 1];
356 kernel_ulong_t ledbit[INPUT_DEVICE_ID_LED_MAX / BITS_PER_LONG + 1];
357 kernel_ulong_t sndbit[INPUT_DEVICE_ID_SND_MAX / BITS_PER_LONG + 1];
358 kernel_ulong_t ffbit[INPUT_DEVICE_ID_FF_MAX / BITS_PER_LONG + 1];
359 kernel_ulong_t swbit[INPUT_DEVICE_ID_SW_MAX / BITS_PER_LONG + 1];
360 kernel_ulong_t propbit[INPUT_DEVICE_ID_PROP_MAX / BITS_PER_LONG + 1];
361
362 kernel_ulong_t driver_info;
363};
364
365/* EISA */
366
367#define EISA_SIG_LEN 8
368
369/* The EISA signature, in ASCII form, null terminated */
370struct eisa_device_id {
371 char sig[EISA_SIG_LEN];
372 kernel_ulong_t driver_data;
373};
374
375#define EISA_DEVICE_MODALIAS_FMT "eisa:s%s"
376
377struct parisc_device_id {
378 __u8 hw_type; /* 5 bits used */
379 __u8 hversion_rev; /* 4 bits */
380 __u16 hversion; /* 12 bits */
381 __u32 sversion; /* 20 bits */
382};
383
384#define PA_HWTYPE_ANY_ID 0xff
385#define PA_HVERSION_REV_ANY_ID 0xff
386#define PA_HVERSION_ANY_ID 0xffff
387#define PA_SVERSION_ANY_ID 0xffffffff
388
389/* SDIO */
390
391#define SDIO_ANY_ID (~0)
392
393struct sdio_device_id {
394 __u8 class; /* Standard interface or SDIO_ANY_ID */
395 __u16 vendor; /* Vendor or SDIO_ANY_ID */
396 __u16 device; /* Device ID or SDIO_ANY_ID */
397 kernel_ulong_t driver_data; /* Data private to the driver */
398};
399
400/* SSB core, see drivers/ssb/ */
401struct ssb_device_id {
402 __u16 vendor;
403 __u16 coreid;
404 __u8 revision;
405 __u8 __pad;
406} __attribute__((packed, aligned(2)));
407#define SSB_DEVICE(_vendor, _coreid, _revision) \
408 { .vendor = _vendor, .coreid = _coreid, .revision = _revision, }
409
410#define SSB_ANY_VENDOR 0xFFFF
411#define SSB_ANY_ID 0xFFFF
412#define SSB_ANY_REV 0xFF
413
414/* Broadcom's specific AMBA core, see drivers/bcma/ */
415struct bcma_device_id {
416 __u16 manuf;
417 __u16 id;
418 __u8 rev;
419 __u8 class;
420} __attribute__((packed,aligned(2)));
421#define BCMA_CORE(_manuf, _id, _rev, _class) \
422 { .manuf = _manuf, .id = _id, .rev = _rev, .class = _class, }
423
424#define BCMA_ANY_MANUF 0xFFFF
425#define BCMA_ANY_ID 0xFFFF
426#define BCMA_ANY_REV 0xFF
427#define BCMA_ANY_CLASS 0xFF
428
429struct virtio_device_id {
430 __u32 device;
431 __u32 vendor;
432};
433#define VIRTIO_DEV_ANY_ID 0xffffffff
434
435/*
436 * For Hyper-V devices we use the device guid as the id.
437 */
438struct hv_vmbus_device_id {
439 guid_t guid;
440 kernel_ulong_t driver_data; /* Data private to the driver */
441};
442
443/* rpmsg */
444
445#define RPMSG_NAME_SIZE 32
446#define RPMSG_DEVICE_MODALIAS_FMT "rpmsg:%s"
447
448struct rpmsg_device_id {
449 char name[RPMSG_NAME_SIZE];
450};
451
452/* i2c */
453
454#define I2C_NAME_SIZE 20
455#define I2C_MODULE_PREFIX "i2c:"
456
457struct i2c_device_id {
458 char name[I2C_NAME_SIZE];
459 kernel_ulong_t driver_data; /* Data private to the driver */
460};
461
462/* pci_epf */
463
464#define PCI_EPF_NAME_SIZE 20
465#define PCI_EPF_MODULE_PREFIX "pci_epf:"
466
467struct pci_epf_device_id {
468 char name[PCI_EPF_NAME_SIZE];
469 kernel_ulong_t driver_data;
470};
471
472/* i3c */
473
474#define I3C_MATCH_DCR 0x1
475#define I3C_MATCH_MANUF 0x2
476#define I3C_MATCH_PART 0x4
477#define I3C_MATCH_EXTRA_INFO 0x8
478
479struct i3c_device_id {
480 __u8 match_flags;
481 __u8 dcr;
482 __u16 manuf_id;
483 __u16 part_id;
484 __u16 extra_info;
485
486 const void *data;
487};
488
489/* spi */
490
491#define SPI_NAME_SIZE 32
492#define SPI_MODULE_PREFIX "spi:"
493
494struct spi_device_id {
495 char name[SPI_NAME_SIZE];
496 kernel_ulong_t driver_data; /* Data private to the driver */
497};
498
499/* SLIMbus */
500
501#define SLIMBUS_NAME_SIZE 32
502#define SLIMBUS_MODULE_PREFIX "slim:"
503
504struct slim_device_id {
505 __u16 manf_id, prod_code;
506 __u16 dev_index, instance;
507
508 /* Data private to the driver */
509 kernel_ulong_t driver_data;
510};
511
512#define APR_NAME_SIZE 32
513#define APR_MODULE_PREFIX "apr:"
514
515struct apr_device_id {
516 char name[APR_NAME_SIZE];
517 __u32 domain_id;
518 __u32 svc_id;
519 __u32 svc_version;
520 kernel_ulong_t driver_data; /* Data private to the driver */
521};
522
523#define SPMI_NAME_SIZE 32
524#define SPMI_MODULE_PREFIX "spmi:"
525
526struct spmi_device_id {
527 char name[SPMI_NAME_SIZE];
528 kernel_ulong_t driver_data; /* Data private to the driver */
529};
530
531/* dmi */
532enum dmi_field {
533 DMI_NONE,
534 DMI_BIOS_VENDOR,
535 DMI_BIOS_VERSION,
536 DMI_BIOS_DATE,
537 DMI_BIOS_RELEASE,
538 DMI_EC_FIRMWARE_RELEASE,
539 DMI_SYS_VENDOR,
540 DMI_PRODUCT_NAME,
541 DMI_PRODUCT_VERSION,
542 DMI_PRODUCT_SERIAL,
543 DMI_PRODUCT_UUID,
544 DMI_PRODUCT_SKU,
545 DMI_PRODUCT_FAMILY,
546 DMI_BOARD_VENDOR,
547 DMI_BOARD_NAME,
548 DMI_BOARD_VERSION,
549 DMI_BOARD_SERIAL,
550 DMI_BOARD_ASSET_TAG,
551 DMI_CHASSIS_VENDOR,
552 DMI_CHASSIS_TYPE,
553 DMI_CHASSIS_VERSION,
554 DMI_CHASSIS_SERIAL,
555 DMI_CHASSIS_ASSET_TAG,
556 DMI_STRING_MAX,
557 DMI_OEM_STRING, /* special case - will not be in dmi_ident */
558};
559
560struct dmi_strmatch {
561 unsigned char slot:7;
562 unsigned char exact_match:1;
563 char substr[79];
564};
565
566struct dmi_system_id {
567 int (*callback)(const struct dmi_system_id *);
568 const char *ident;
569 struct dmi_strmatch matches[4];
570 void *driver_data;
571};
572/*
573 * struct dmi_device_id appears during expansion of
574 * "MODULE_DEVICE_TABLE(dmi, x)". Compiler doesn't look inside it
575 * but this is enough for gcc 3.4.6 to error out:
576 * error: storage size of '__mod_dmi_device_table' isn't known
577 */
578#define dmi_device_id dmi_system_id
579
580#define DMI_MATCH(a, b) { .slot = a, .substr = b }
581#define DMI_EXACT_MATCH(a, b) { .slot = a, .substr = b, .exact_match = 1 }
582
583#define PLATFORM_NAME_SIZE 20
584#define PLATFORM_MODULE_PREFIX "platform:"
585
586struct platform_device_id {
587 char name[PLATFORM_NAME_SIZE];
588 kernel_ulong_t driver_data;
589};
590
591#define MDIO_NAME_SIZE 32
592#define MDIO_MODULE_PREFIX "mdio:"
593
594#define MDIO_ID_FMT "%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u"
595#define MDIO_ID_ARGS(_id) \
596 ((_id)>>31) & 1, ((_id)>>30) & 1, ((_id)>>29) & 1, ((_id)>>28) & 1, \
597 ((_id)>>27) & 1, ((_id)>>26) & 1, ((_id)>>25) & 1, ((_id)>>24) & 1, \
598 ((_id)>>23) & 1, ((_id)>>22) & 1, ((_id)>>21) & 1, ((_id)>>20) & 1, \
599 ((_id)>>19) & 1, ((_id)>>18) & 1, ((_id)>>17) & 1, ((_id)>>16) & 1, \
600 ((_id)>>15) & 1, ((_id)>>14) & 1, ((_id)>>13) & 1, ((_id)>>12) & 1, \
601 ((_id)>>11) & 1, ((_id)>>10) & 1, ((_id)>>9) & 1, ((_id)>>8) & 1, \
602 ((_id)>>7) & 1, ((_id)>>6) & 1, ((_id)>>5) & 1, ((_id)>>4) & 1, \
603 ((_id)>>3) & 1, ((_id)>>2) & 1, ((_id)>>1) & 1, (_id) & 1
604
605/**
606 * struct mdio_device_id - identifies PHY devices on an MDIO/MII bus
607 * @phy_id: The result of
608 * (mdio_read(&MII_PHYSID1) << 16 | mdio_read(&MII_PHYSID2)) & @phy_id_mask
609 * for this PHY type
610 * @phy_id_mask: Defines the significant bits of @phy_id. A value of 0
611 * is used to terminate an array of struct mdio_device_id.
612 */
613struct mdio_device_id {
614 __u32 phy_id;
615 __u32 phy_id_mask;
616};
617
618struct zorro_device_id {
619 __u32 id; /* Device ID or ZORRO_WILDCARD */
620 kernel_ulong_t driver_data; /* Data private to the driver */
621};
622
623#define ZORRO_WILDCARD (0xffffffff) /* not official */
624
625#define ZORRO_DEVICE_MODALIAS_FMT "zorro:i%08X"
626
627#define ISAPNP_ANY_ID 0xffff
628struct isapnp_device_id {
629 unsigned short card_vendor, card_device;
630 unsigned short vendor, function;
631 kernel_ulong_t driver_data; /* data private to the driver */
632};
633
634/**
635 * struct amba_id - identifies a device on an AMBA bus
636 * @id: The significant bits if the hardware device ID
637 * @mask: Bitmask specifying which bits of the id field are significant when
638 * matching. A driver binds to a device when ((hardware device ID) & mask)
639 * == id.
640 * @data: Private data used by the driver.
641 */
642struct amba_id {
643 unsigned int id;
644 unsigned int mask;
645 void *data;
646};
647
648/**
649 * struct mips_cdmm_device_id - identifies devices in MIPS CDMM bus
650 * @type: Device type identifier.
651 */
652struct mips_cdmm_device_id {
653 __u8 type;
654};
655
656/*
657 * Match x86 CPUs for CPU specific drivers.
658 * See documentation of "x86_match_cpu" for details.
659 */
660
661/*
662 * MODULE_DEVICE_TABLE expects this struct to be called x86cpu_device_id.
663 * Although gcc seems to ignore this error, clang fails without this define.
664 */
665#define x86cpu_device_id x86_cpu_id
666struct x86_cpu_id {
667 __u16 vendor;
668 __u16 family;
669 __u16 model;
670 __u16 steppings;
671 __u16 feature; /* bit index */
672 kernel_ulong_t driver_data;
673};
674
675/* Wild cards for x86_cpu_id::vendor, family, model and feature */
676#define X86_VENDOR_ANY 0xffff
677#define X86_FAMILY_ANY 0
678#define X86_MODEL_ANY 0
679#define X86_STEPPING_ANY 0
680#define X86_FEATURE_ANY 0 /* Same as FPU, you can't test for that */
681
682/*
683 * Generic table type for matching CPU features.
684 * @feature: the bit number of the feature (0 - 65535)
685 */
686
687struct cpu_feature {
688 __u16 feature;
689};
690
691#define IPACK_ANY_FORMAT 0xff
692#define IPACK_ANY_ID (~0)
693struct ipack_device_id {
694 __u8 format; /* Format version or IPACK_ANY_ID */
695 __u32 vendor; /* Vendor ID or IPACK_ANY_ID */
696 __u32 device; /* Device ID or IPACK_ANY_ID */
697};
698
699#define MEI_CL_MODULE_PREFIX "mei:"
700#define MEI_CL_NAME_SIZE 32
701#define MEI_CL_VERSION_ANY 0xff
702
703/**
704 * struct mei_cl_device_id - MEI client device identifier
705 * @name: helper name
706 * @uuid: client uuid
707 * @version: client protocol version
708 * @driver_info: information used by the driver.
709 *
710 * identifies mei client device by uuid and name
711 */
712struct mei_cl_device_id {
713 char name[MEI_CL_NAME_SIZE];
714 uuid_le uuid;
715 __u8 version;
716 kernel_ulong_t driver_info;
717};
718
719/* RapidIO */
720
721#define RIO_ANY_ID 0xffff
722
723/**
724 * struct rio_device_id - RIO device identifier
725 * @did: RapidIO device ID
726 * @vid: RapidIO vendor ID
727 * @asm_did: RapidIO assembly device ID
728 * @asm_vid: RapidIO assembly vendor ID
729 *
730 * Identifies a RapidIO device based on both the device/vendor IDs and
731 * the assembly device/vendor IDs.
732 */
733struct rio_device_id {
734 __u16 did, vid;
735 __u16 asm_did, asm_vid;
736};
737
738struct mcb_device_id {
739 __u16 device;
740 kernel_ulong_t driver_data;
741};
742
743struct ulpi_device_id {
744 __u16 vendor;
745 __u16 product;
746 kernel_ulong_t driver_data;
747};
748
749/**
750 * struct fsl_mc_device_id - MC object device identifier
751 * @vendor: vendor ID
752 * @obj_type: MC object type
753 *
754 * Type of entries in the "device Id" table for MC object devices supported by
755 * a MC object device driver. The last entry of the table has vendor set to 0x0
756 */
757struct fsl_mc_device_id {
758 __u16 vendor;
759 const char obj_type[16];
760};
761
762/**
763 * struct tb_service_id - Thunderbolt service identifiers
764 * @match_flags: Flags used to match the structure
765 * @protocol_key: Protocol key the service supports
766 * @protocol_id: Protocol id the service supports
767 * @protocol_version: Version of the protocol
768 * @protocol_revision: Revision of the protocol software
769 * @driver_data: Driver specific data
770 *
771 * Thunderbolt XDomain services are exposed as devices where each device
772 * carries the protocol information the service supports. Thunderbolt
773 * XDomain service drivers match against that information.
774 */
775struct tb_service_id {
776 __u32 match_flags;
777 char protocol_key[8 + 1];
778 __u32 protocol_id;
779 __u32 protocol_version;
780 __u32 protocol_revision;
781 kernel_ulong_t driver_data;
782};
783
784#define TBSVC_MATCH_PROTOCOL_KEY 0x0001
785#define TBSVC_MATCH_PROTOCOL_ID 0x0002
786#define TBSVC_MATCH_PROTOCOL_VERSION 0x0004
787#define TBSVC_MATCH_PROTOCOL_REVISION 0x0008
788
789/* USB Type-C Alternate Modes */
790
791#define TYPEC_ANY_MODE 0x7
792
793/**
794 * struct typec_device_id - USB Type-C alternate mode identifiers
795 * @svid: Standard or Vendor ID
796 * @mode: Mode index
797 * @driver_data: Driver specific data
798 */
799struct typec_device_id {
800 __u16 svid;
801 __u8 mode;
802 kernel_ulong_t driver_data;
803};
804
805/**
806 * struct tee_client_device_id - tee based device identifier
807 * @uuid: For TEE based client devices we use the device uuid as
808 * the identifier.
809 */
810struct tee_client_device_id {
811 uuid_t uuid;
812};
813
814/* WMI */
815
816#define WMI_MODULE_PREFIX "wmi:"
817
818/**
819 * struct wmi_device_id - WMI device identifier
820 * @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
821 * @context: pointer to driver specific data
822 */
823struct wmi_device_id {
824 const char guid_string[UUID_STRING_LEN+1];
825 const void *context;
826};
827
828#define MHI_DEVICE_MODALIAS_FMT "mhi:%s"
829#define MHI_NAME_SIZE 32
830
831/**
832 * struct mhi_device_id - MHI device identification
833 * @chan: MHI channel name
834 * @driver_data: driver data;
835 */
836struct mhi_device_id {
837 const char chan[MHI_NAME_SIZE];
838 kernel_ulong_t driver_data;
839};
840
841#endif /* LINUX_MOD_DEVICETABLE_H */
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>
12typedef unsigned long kernel_ulong_t;
13#endif
14
15#define PCI_ANY_ID (~0)
16
17struct 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
30struct 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 */
98struct 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#define HID_BUS_ANY 0xffff
136#define HID_GROUP_ANY 0x0000
137
138struct hid_device_id {
139 __u16 bus;
140 __u16 group;
141 __u32 vendor;
142 __u32 product;
143 kernel_ulong_t driver_data
144 __attribute__((aligned(sizeof(kernel_ulong_t))));
145};
146
147/* s390 CCW devices */
148struct ccw_device_id {
149 __u16 match_flags; /* which fields to match against */
150
151 __u16 cu_type; /* control unit type */
152 __u16 dev_type; /* device type */
153 __u8 cu_model; /* control unit model */
154 __u8 dev_model; /* device model */
155
156 kernel_ulong_t driver_info;
157};
158
159#define CCW_DEVICE_ID_MATCH_CU_TYPE 0x01
160#define CCW_DEVICE_ID_MATCH_CU_MODEL 0x02
161#define CCW_DEVICE_ID_MATCH_DEVICE_TYPE 0x04
162#define CCW_DEVICE_ID_MATCH_DEVICE_MODEL 0x08
163
164/* s390 AP bus devices */
165struct ap_device_id {
166 __u16 match_flags; /* which fields to match against */
167 __u8 dev_type; /* device type */
168 __u8 pad1;
169 __u32 pad2;
170 kernel_ulong_t driver_info;
171};
172
173#define AP_DEVICE_ID_MATCH_DEVICE_TYPE 0x01
174
175/* s390 css bus devices (subchannels) */
176struct css_device_id {
177 __u8 match_flags;
178 __u8 type; /* subchannel type */
179 __u16 pad2;
180 __u32 pad3;
181 kernel_ulong_t driver_data;
182};
183
184#define ACPI_ID_LEN 16 /* only 9 bytes needed here, 16 bytes are used */
185 /* to workaround crosscompile issues */
186
187struct acpi_device_id {
188 __u8 id[ACPI_ID_LEN];
189 kernel_ulong_t driver_data;
190};
191
192#define PNP_ID_LEN 8
193#define PNP_MAX_DEVICES 8
194
195struct pnp_device_id {
196 __u8 id[PNP_ID_LEN];
197 kernel_ulong_t driver_data;
198};
199
200struct pnp_card_device_id {
201 __u8 id[PNP_ID_LEN];
202 kernel_ulong_t driver_data;
203 struct {
204 __u8 id[PNP_ID_LEN];
205 } devs[PNP_MAX_DEVICES];
206};
207
208
209#define SERIO_ANY 0xff
210
211struct serio_device_id {
212 __u8 type;
213 __u8 extra;
214 __u8 id;
215 __u8 proto;
216};
217
218/*
219 * Struct used for matching a device
220 */
221struct of_device_id
222{
223 char name[32];
224 char type[32];
225 char compatible[128];
226#ifdef __KERNEL__
227 void *data;
228#else
229 kernel_ulong_t data;
230#endif
231};
232
233/* VIO */
234struct vio_device_id {
235 char type[32];
236 char compat[32];
237};
238
239/* PCMCIA */
240
241struct pcmcia_device_id {
242 __u16 match_flags;
243
244 __u16 manf_id;
245 __u16 card_id;
246
247 __u8 func_id;
248
249 /* for real multi-function devices */
250 __u8 function;
251
252 /* for pseudo multi-function devices */
253 __u8 device_no;
254
255 __u32 prod_id_hash[4]
256 __attribute__((aligned(sizeof(__u32))));
257
258 /* not matched against in kernelspace*/
259#ifdef __KERNEL__
260 const char * prod_id[4];
261#else
262 kernel_ulong_t prod_id[4]
263 __attribute__((aligned(sizeof(kernel_ulong_t))));
264#endif
265
266 /* not matched against */
267 kernel_ulong_t driver_info;
268#ifdef __KERNEL__
269 char * cisfile;
270#else
271 kernel_ulong_t cisfile;
272#endif
273};
274
275#define PCMCIA_DEV_ID_MATCH_MANF_ID 0x0001
276#define PCMCIA_DEV_ID_MATCH_CARD_ID 0x0002
277#define PCMCIA_DEV_ID_MATCH_FUNC_ID 0x0004
278#define PCMCIA_DEV_ID_MATCH_FUNCTION 0x0008
279#define PCMCIA_DEV_ID_MATCH_PROD_ID1 0x0010
280#define PCMCIA_DEV_ID_MATCH_PROD_ID2 0x0020
281#define PCMCIA_DEV_ID_MATCH_PROD_ID3 0x0040
282#define PCMCIA_DEV_ID_MATCH_PROD_ID4 0x0080
283#define PCMCIA_DEV_ID_MATCH_DEVICE_NO 0x0100
284#define PCMCIA_DEV_ID_MATCH_FAKE_CIS 0x0200
285#define PCMCIA_DEV_ID_MATCH_ANONYMOUS 0x0400
286
287/* Input */
288#define INPUT_DEVICE_ID_EV_MAX 0x1f
289#define INPUT_DEVICE_ID_KEY_MIN_INTERESTING 0x71
290#define INPUT_DEVICE_ID_KEY_MAX 0x2ff
291#define INPUT_DEVICE_ID_REL_MAX 0x0f
292#define INPUT_DEVICE_ID_ABS_MAX 0x3f
293#define INPUT_DEVICE_ID_MSC_MAX 0x07
294#define INPUT_DEVICE_ID_LED_MAX 0x0f
295#define INPUT_DEVICE_ID_SND_MAX 0x07
296#define INPUT_DEVICE_ID_FF_MAX 0x7f
297#define INPUT_DEVICE_ID_SW_MAX 0x0f
298
299#define INPUT_DEVICE_ID_MATCH_BUS 1
300#define INPUT_DEVICE_ID_MATCH_VENDOR 2
301#define INPUT_DEVICE_ID_MATCH_PRODUCT 4
302#define INPUT_DEVICE_ID_MATCH_VERSION 8
303
304#define INPUT_DEVICE_ID_MATCH_EVBIT 0x0010
305#define INPUT_DEVICE_ID_MATCH_KEYBIT 0x0020
306#define INPUT_DEVICE_ID_MATCH_RELBIT 0x0040
307#define INPUT_DEVICE_ID_MATCH_ABSBIT 0x0080
308#define INPUT_DEVICE_ID_MATCH_MSCIT 0x0100
309#define INPUT_DEVICE_ID_MATCH_LEDBIT 0x0200
310#define INPUT_DEVICE_ID_MATCH_SNDBIT 0x0400
311#define INPUT_DEVICE_ID_MATCH_FFBIT 0x0800
312#define INPUT_DEVICE_ID_MATCH_SWBIT 0x1000
313
314struct input_device_id {
315
316 kernel_ulong_t flags;
317
318 __u16 bustype;
319 __u16 vendor;
320 __u16 product;
321 __u16 version;
322
323 kernel_ulong_t evbit[INPUT_DEVICE_ID_EV_MAX / BITS_PER_LONG + 1];
324 kernel_ulong_t keybit[INPUT_DEVICE_ID_KEY_MAX / BITS_PER_LONG + 1];
325 kernel_ulong_t relbit[INPUT_DEVICE_ID_REL_MAX / BITS_PER_LONG + 1];
326 kernel_ulong_t absbit[INPUT_DEVICE_ID_ABS_MAX / BITS_PER_LONG + 1];
327 kernel_ulong_t mscbit[INPUT_DEVICE_ID_MSC_MAX / BITS_PER_LONG + 1];
328 kernel_ulong_t ledbit[INPUT_DEVICE_ID_LED_MAX / BITS_PER_LONG + 1];
329 kernel_ulong_t sndbit[INPUT_DEVICE_ID_SND_MAX / BITS_PER_LONG + 1];
330 kernel_ulong_t ffbit[INPUT_DEVICE_ID_FF_MAX / BITS_PER_LONG + 1];
331 kernel_ulong_t swbit[INPUT_DEVICE_ID_SW_MAX / BITS_PER_LONG + 1];
332
333 kernel_ulong_t driver_info;
334};
335
336/* EISA */
337
338#define EISA_SIG_LEN 8
339
340/* The EISA signature, in ASCII form, null terminated */
341struct eisa_device_id {
342 char sig[EISA_SIG_LEN];
343 kernel_ulong_t driver_data;
344};
345
346#define EISA_DEVICE_MODALIAS_FMT "eisa:s%s"
347
348struct parisc_device_id {
349 __u8 hw_type; /* 5 bits used */
350 __u8 hversion_rev; /* 4 bits */
351 __u16 hversion; /* 12 bits */
352 __u32 sversion; /* 20 bits */
353};
354
355#define PA_HWTYPE_ANY_ID 0xff
356#define PA_HVERSION_REV_ANY_ID 0xff
357#define PA_HVERSION_ANY_ID 0xffff
358#define PA_SVERSION_ANY_ID 0xffffffff
359
360/* SDIO */
361
362#define SDIO_ANY_ID (~0)
363
364struct sdio_device_id {
365 __u8 class; /* Standard interface or SDIO_ANY_ID */
366 __u16 vendor; /* Vendor or SDIO_ANY_ID */
367 __u16 device; /* Device ID or SDIO_ANY_ID */
368 kernel_ulong_t driver_data /* Data private to the driver */
369 __attribute__((aligned(sizeof(kernel_ulong_t))));
370};
371
372/* SSB core, see drivers/ssb/ */
373struct ssb_device_id {
374 __u16 vendor;
375 __u16 coreid;
376 __u8 revision;
377};
378#define SSB_DEVICE(_vendor, _coreid, _revision) \
379 { .vendor = _vendor, .coreid = _coreid, .revision = _revision, }
380#define SSB_DEVTABLE_END \
381 { 0, },
382
383#define SSB_ANY_VENDOR 0xFFFF
384#define SSB_ANY_ID 0xFFFF
385#define SSB_ANY_REV 0xFF
386
387/* Broadcom's specific AMBA core, see drivers/bcma/ */
388struct bcma_device_id {
389 __u16 manuf;
390 __u16 id;
391 __u8 rev;
392 __u8 class;
393};
394#define BCMA_CORE(_manuf, _id, _rev, _class) \
395 { .manuf = _manuf, .id = _id, .rev = _rev, .class = _class, }
396#define BCMA_CORETABLE_END \
397 { 0, },
398
399#define BCMA_ANY_MANUF 0xFFFF
400#define BCMA_ANY_ID 0xFFFF
401#define BCMA_ANY_REV 0xFF
402#define BCMA_ANY_CLASS 0xFF
403
404struct virtio_device_id {
405 __u32 device;
406 __u32 vendor;
407};
408#define VIRTIO_DEV_ANY_ID 0xffffffff
409
410/*
411 * For Hyper-V devices we use the device guid as the id.
412 */
413struct hv_vmbus_device_id {
414 __u8 guid[16];
415 kernel_ulong_t driver_data /* Data private to the driver */
416 __attribute__((aligned(sizeof(kernel_ulong_t))));
417};
418
419/* rpmsg */
420
421#define RPMSG_NAME_SIZE 32
422#define RPMSG_DEVICE_MODALIAS_FMT "rpmsg:%s"
423
424struct rpmsg_device_id {
425 char name[RPMSG_NAME_SIZE];
426};
427
428/* i2c */
429
430#define I2C_NAME_SIZE 20
431#define I2C_MODULE_PREFIX "i2c:"
432
433struct i2c_device_id {
434 char name[I2C_NAME_SIZE];
435 kernel_ulong_t driver_data /* Data private to the driver */
436 __attribute__((aligned(sizeof(kernel_ulong_t))));
437};
438
439/* spi */
440
441#define SPI_NAME_SIZE 32
442#define SPI_MODULE_PREFIX "spi:"
443
444struct spi_device_id {
445 char name[SPI_NAME_SIZE];
446 kernel_ulong_t driver_data /* Data private to the driver */
447 __attribute__((aligned(sizeof(kernel_ulong_t))));
448};
449
450/* dmi */
451enum dmi_field {
452 DMI_NONE,
453 DMI_BIOS_VENDOR,
454 DMI_BIOS_VERSION,
455 DMI_BIOS_DATE,
456 DMI_SYS_VENDOR,
457 DMI_PRODUCT_NAME,
458 DMI_PRODUCT_VERSION,
459 DMI_PRODUCT_SERIAL,
460 DMI_PRODUCT_UUID,
461 DMI_BOARD_VENDOR,
462 DMI_BOARD_NAME,
463 DMI_BOARD_VERSION,
464 DMI_BOARD_SERIAL,
465 DMI_BOARD_ASSET_TAG,
466 DMI_CHASSIS_VENDOR,
467 DMI_CHASSIS_TYPE,
468 DMI_CHASSIS_VERSION,
469 DMI_CHASSIS_SERIAL,
470 DMI_CHASSIS_ASSET_TAG,
471 DMI_STRING_MAX,
472};
473
474struct dmi_strmatch {
475 unsigned char slot;
476 char substr[79];
477};
478
479#ifndef __KERNEL__
480struct dmi_system_id {
481 kernel_ulong_t callback;
482 kernel_ulong_t ident;
483 struct dmi_strmatch matches[4];
484 kernel_ulong_t driver_data
485 __attribute__((aligned(sizeof(kernel_ulong_t))));
486};
487#else
488struct dmi_system_id {
489 int (*callback)(const struct dmi_system_id *);
490 const char *ident;
491 struct dmi_strmatch matches[4];
492 void *driver_data;
493};
494/*
495 * struct dmi_device_id appears during expansion of
496 * "MODULE_DEVICE_TABLE(dmi, x)". Compiler doesn't look inside it
497 * but this is enough for gcc 3.4.6 to error out:
498 * error: storage size of '__mod_dmi_device_table' isn't known
499 */
500#define dmi_device_id dmi_system_id
501#endif
502
503#define DMI_MATCH(a, b) { a, b }
504
505#define PLATFORM_NAME_SIZE 20
506#define PLATFORM_MODULE_PREFIX "platform:"
507
508struct platform_device_id {
509 char name[PLATFORM_NAME_SIZE];
510 kernel_ulong_t driver_data
511 __attribute__((aligned(sizeof(kernel_ulong_t))));
512};
513
514#define MDIO_MODULE_PREFIX "mdio:"
515
516#define MDIO_ID_FMT "%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d"
517#define MDIO_ID_ARGS(_id) \
518 (_id)>>31, ((_id)>>30) & 1, ((_id)>>29) & 1, ((_id)>>28) & 1, \
519 ((_id)>>27) & 1, ((_id)>>26) & 1, ((_id)>>25) & 1, ((_id)>>24) & 1, \
520 ((_id)>>23) & 1, ((_id)>>22) & 1, ((_id)>>21) & 1, ((_id)>>20) & 1, \
521 ((_id)>>19) & 1, ((_id)>>18) & 1, ((_id)>>17) & 1, ((_id)>>16) & 1, \
522 ((_id)>>15) & 1, ((_id)>>14) & 1, ((_id)>>13) & 1, ((_id)>>12) & 1, \
523 ((_id)>>11) & 1, ((_id)>>10) & 1, ((_id)>>9) & 1, ((_id)>>8) & 1, \
524 ((_id)>>7) & 1, ((_id)>>6) & 1, ((_id)>>5) & 1, ((_id)>>4) & 1, \
525 ((_id)>>3) & 1, ((_id)>>2) & 1, ((_id)>>1) & 1, (_id) & 1
526
527/**
528 * struct mdio_device_id - identifies PHY devices on an MDIO/MII bus
529 * @phy_id: The result of
530 * (mdio_read(&MII_PHYSID1) << 16 | mdio_read(&PHYSID2)) & @phy_id_mask
531 * for this PHY type
532 * @phy_id_mask: Defines the significant bits of @phy_id. A value of 0
533 * is used to terminate an array of struct mdio_device_id.
534 */
535struct mdio_device_id {
536 __u32 phy_id;
537 __u32 phy_id_mask;
538};
539
540struct zorro_device_id {
541 __u32 id; /* Device ID or ZORRO_WILDCARD */
542 kernel_ulong_t driver_data; /* Data private to the driver */
543};
544
545#define ZORRO_WILDCARD (0xffffffff) /* not official */
546
547#define ZORRO_DEVICE_MODALIAS_FMT "zorro:i%08X"
548
549#define ISAPNP_ANY_ID 0xffff
550struct isapnp_device_id {
551 unsigned short card_vendor, card_device;
552 unsigned short vendor, function;
553 kernel_ulong_t driver_data; /* data private to the driver */
554};
555
556/**
557 * struct amba_id - identifies a device on an AMBA bus
558 * @id: The significant bits if the hardware device ID
559 * @mask: Bitmask specifying which bits of the id field are significant when
560 * matching. A driver binds to a device when ((hardware device ID) & mask)
561 * == id.
562 * @data: Private data used by the driver.
563 */
564struct amba_id {
565 unsigned int id;
566 unsigned int mask;
567#ifndef __KERNEL__
568 kernel_ulong_t data;
569#else
570 void *data;
571#endif
572};
573
574/*
575 * Match x86 CPUs for CPU specific drivers.
576 * See documentation of "x86_match_cpu" for details.
577 */
578
579struct x86_cpu_id {
580 __u16 vendor;
581 __u16 family;
582 __u16 model;
583 __u16 feature; /* bit index */
584 kernel_ulong_t driver_data;
585};
586
587#define X86_FEATURE_MATCH(x) \
588 { X86_VENDOR_ANY, X86_FAMILY_ANY, X86_MODEL_ANY, x }
589
590#define X86_VENDOR_ANY 0xffff
591#define X86_FAMILY_ANY 0
592#define X86_MODEL_ANY 0
593#define X86_FEATURE_ANY 0 /* Same as FPU, you can't test for that */
594
595#endif /* LINUX_MOD_DEVICETABLE_H */