License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 17:07:57 +03:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Device tables which are exported to userspace via
|
2005-08-17 10:42:59 +04:00
|
|
|
* scripts/mod/file2alias.c. You must keep that file in sync with this
|
2005-04-17 02:20:36 +04:00
|
|
|
* header.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef LINUX_MOD_DEVICETABLE_H
|
|
|
|
#define LINUX_MOD_DEVICETABLE_H
|
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
#include <linux/types.h>
|
2013-03-27 19:29:53 +04:00
|
|
|
#include <linux/uuid.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
typedef unsigned long kernel_ulong_t;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define PCI_ANY_ID (~0)
|
|
|
|
|
2019-05-14 17:47:24 +03:00
|
|
|
/**
|
|
|
|
* struct pci_device_id - PCI device ID structure
|
|
|
|
* @vendor: Vendor ID to match (or PCI_ANY_ID)
|
|
|
|
* @device: Device ID to match (or PCI_ANY_ID)
|
|
|
|
* @subvendor: Subsystem vendor ID to match (or PCI_ANY_ID)
|
|
|
|
* @subdevice: Subsystem device ID to match (or PCI_ANY_ID)
|
|
|
|
* @class: Device class, subclass, and "interface" to match.
|
|
|
|
* See Appendix D of the PCI Local Bus Spec or
|
|
|
|
* include/linux/pci_ids.h for a full list of classes.
|
|
|
|
* Most drivers do not need to specify class/class_mask
|
|
|
|
* as vendor/device is normally sufficient.
|
|
|
|
* @class_mask: Limit which sub-fields of the class field are compared.
|
|
|
|
* See drivers/scsi/sym53c8xx_2/ for example of usage.
|
|
|
|
* @driver_data: Data private to the driver.
|
|
|
|
* Most drivers don't need to use driver_data field.
|
|
|
|
* Best practice is to use driver_data as an index
|
|
|
|
* into a static list of equivalent device types,
|
|
|
|
* instead of using it as a pointer.
|
|
|
|
*/
|
2005-04-17 02:20:36 +04:00
|
|
|
struct pci_device_id {
|
|
|
|
__u32 vendor, device; /* Vendor and device ID or PCI_ANY_ID*/
|
|
|
|
__u32 subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */
|
|
|
|
__u32 class, class_mask; /* (class,subclass,prog-if) triplet */
|
|
|
|
kernel_ulong_t driver_data; /* Data private to the driver */
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
#define IEEE1394_MATCH_VENDOR_ID 0x0001
|
|
|
|
#define IEEE1394_MATCH_MODEL_ID 0x0002
|
|
|
|
#define IEEE1394_MATCH_SPECIFIER_ID 0x0004
|
|
|
|
#define IEEE1394_MATCH_VERSION 0x0008
|
|
|
|
|
|
|
|
struct ieee1394_device_id {
|
|
|
|
__u32 match_flags;
|
|
|
|
__u32 vendor_id;
|
|
|
|
__u32 model_id;
|
|
|
|
__u32 specifier_id;
|
|
|
|
__u32 version;
|
2013-01-20 20:58:47 +04:00
|
|
|
kernel_ulong_t driver_data;
|
2005-04-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Device table entry for "new style" table-driven USB drivers.
|
|
|
|
* User mode code can read these tables to choose which modules to load.
|
|
|
|
* Declare the table as a MODULE_DEVICE_TABLE.
|
|
|
|
*
|
|
|
|
* A probe() parameter will point to a matching entry from this table.
|
|
|
|
* Use the driver_info field for each match to hold information tied
|
|
|
|
* to that match: device quirks, etc.
|
|
|
|
*
|
|
|
|
* Terminate the driver's table with an all-zeroes entry.
|
|
|
|
* Use the flag values to control which fields are compared.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct usb_device_id - identifies USB devices for probing and hotplugging
|
2015-01-22 13:15:25 +03:00
|
|
|
* @match_flags: Bit mask controlling which of the other fields are used to
|
|
|
|
* match against new devices. Any field except for driver_info may be
|
|
|
|
* used, although some only make sense in conjunction with other fields.
|
2005-04-17 02:20:36 +04:00
|
|
|
* This is usually set by a USB_DEVICE_*() macro, which sets all
|
|
|
|
* other fields in this structure except for driver_info.
|
|
|
|
* @idVendor: USB vendor ID for a device; numbers are assigned
|
|
|
|
* by the USB forum to its members.
|
|
|
|
* @idProduct: Vendor-assigned product ID.
|
|
|
|
* @bcdDevice_lo: Low end of range of vendor-assigned product version numbers.
|
|
|
|
* This is also used to identify individual product versions, for
|
|
|
|
* a range consisting of a single device.
|
|
|
|
* @bcdDevice_hi: High end of version number range. The range of product
|
|
|
|
* versions is inclusive.
|
|
|
|
* @bDeviceClass: Class of device; numbers are assigned
|
|
|
|
* by the USB forum. Products may choose to implement classes,
|
|
|
|
* or be vendor-specific. Device classes specify behavior of all
|
2014-10-02 08:45:38 +04:00
|
|
|
* the interfaces on a device.
|
2005-04-17 02:20:36 +04:00
|
|
|
* @bDeviceSubClass: Subclass of device; associated with bDeviceClass.
|
|
|
|
* @bDeviceProtocol: Protocol of device; associated with bDeviceClass.
|
|
|
|
* @bInterfaceClass: Class of interface; numbers are assigned
|
|
|
|
* by the USB forum. Products may choose to implement classes,
|
|
|
|
* or be vendor-specific. Interface classes specify behavior only
|
|
|
|
* of a given interface; other interfaces may support other classes.
|
|
|
|
* @bInterfaceSubClass: Subclass of interface; associated with bInterfaceClass.
|
|
|
|
* @bInterfaceProtocol: Protocol of interface; associated with bInterfaceClass.
|
2012-05-18 23:27:43 +04:00
|
|
|
* @bInterfaceNumber: Number of interface; composite devices may use
|
|
|
|
* fixed interface numbers to differentiate between vendor-specific
|
|
|
|
* interfaces.
|
2005-04-17 02:20:36 +04:00
|
|
|
* @driver_info: Holds information used by the driver. Usually it holds
|
|
|
|
* a pointer to a descriptor understood by the driver, or perhaps
|
|
|
|
* device flags.
|
|
|
|
*
|
|
|
|
* In most cases, drivers will create a table of device IDs by using
|
|
|
|
* USB_DEVICE(), or similar macros designed for that purpose.
|
|
|
|
* They will then export it to userspace using MODULE_DEVICE_TABLE(),
|
|
|
|
* and provide it to the USB core through their usb_driver structure.
|
|
|
|
*
|
|
|
|
* See the usb_match_id() function for information about how matches are
|
|
|
|
* performed. Briefly, you will normally use one of several macros to help
|
|
|
|
* construct these entries. Each entry you provide will either identify
|
|
|
|
* one or more specific products, or will identify a class of products
|
|
|
|
* which have agreed to behave the same. You should put the more specific
|
|
|
|
* matches towards the beginning of your table, so that driver_info can
|
|
|
|
* record quirks of specific products.
|
|
|
|
*/
|
|
|
|
struct usb_device_id {
|
|
|
|
/* which fields to match against? */
|
|
|
|
__u16 match_flags;
|
|
|
|
|
|
|
|
/* Used for product specific matches; range is inclusive */
|
|
|
|
__u16 idVendor;
|
|
|
|
__u16 idProduct;
|
|
|
|
__u16 bcdDevice_lo;
|
|
|
|
__u16 bcdDevice_hi;
|
|
|
|
|
|
|
|
/* Used for device class matches */
|
|
|
|
__u8 bDeviceClass;
|
|
|
|
__u8 bDeviceSubClass;
|
|
|
|
__u8 bDeviceProtocol;
|
|
|
|
|
|
|
|
/* Used for interface class matches */
|
|
|
|
__u8 bInterfaceClass;
|
|
|
|
__u8 bInterfaceSubClass;
|
|
|
|
__u8 bInterfaceProtocol;
|
|
|
|
|
2012-05-18 23:27:43 +04:00
|
|
|
/* Used for vendor-specific interface matches */
|
|
|
|
__u8 bInterfaceNumber;
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* not matched against */
|
2012-06-19 02:38:22 +04:00
|
|
|
kernel_ulong_t driver_info
|
|
|
|
__attribute__((aligned(sizeof(kernel_ulong_t))));
|
2005-04-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Some useful macros to use to create struct usb_device_id */
|
|
|
|
#define USB_DEVICE_ID_MATCH_VENDOR 0x0001
|
|
|
|
#define USB_DEVICE_ID_MATCH_PRODUCT 0x0002
|
|
|
|
#define USB_DEVICE_ID_MATCH_DEV_LO 0x0004
|
|
|
|
#define USB_DEVICE_ID_MATCH_DEV_HI 0x0008
|
|
|
|
#define USB_DEVICE_ID_MATCH_DEV_CLASS 0x0010
|
|
|
|
#define USB_DEVICE_ID_MATCH_DEV_SUBCLASS 0x0020
|
|
|
|
#define USB_DEVICE_ID_MATCH_DEV_PROTOCOL 0x0040
|
|
|
|
#define USB_DEVICE_ID_MATCH_INT_CLASS 0x0080
|
|
|
|
#define USB_DEVICE_ID_MATCH_INT_SUBCLASS 0x0100
|
|
|
|
#define USB_DEVICE_ID_MATCH_INT_PROTOCOL 0x0200
|
2012-05-18 23:27:43 +04:00
|
|
|
#define USB_DEVICE_ID_MATCH_INT_NUMBER 0x0400
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2008-05-19 17:50:01 +04:00
|
|
|
#define HID_ANY_ID (~0)
|
2012-04-23 14:07:04 +04:00
|
|
|
#define HID_BUS_ANY 0xffff
|
2012-04-23 14:07:02 +04:00
|
|
|
#define HID_GROUP_ANY 0x0000
|
2008-05-19 17:50:01 +04:00
|
|
|
|
|
|
|
struct hid_device_id {
|
|
|
|
__u16 bus;
|
2012-04-23 14:07:02 +04:00
|
|
|
__u16 group;
|
2008-05-19 17:50:01 +04:00
|
|
|
__u32 vendor;
|
|
|
|
__u32 product;
|
2013-01-20 20:58:47 +04:00
|
|
|
kernel_ulong_t driver_data;
|
2008-05-19 17:50:01 +04:00
|
|
|
};
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* s390 CCW devices */
|
|
|
|
struct ccw_device_id {
|
|
|
|
__u16 match_flags; /* which fields to match against */
|
|
|
|
|
|
|
|
__u16 cu_type; /* control unit type */
|
|
|
|
__u16 dev_type; /* device type */
|
|
|
|
__u8 cu_model; /* control unit model */
|
|
|
|
__u8 dev_model; /* device model */
|
|
|
|
|
|
|
|
kernel_ulong_t driver_info;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define CCW_DEVICE_ID_MATCH_CU_TYPE 0x01
|
|
|
|
#define CCW_DEVICE_ID_MATCH_CU_MODEL 0x02
|
|
|
|
#define CCW_DEVICE_ID_MATCH_DEVICE_TYPE 0x04
|
|
|
|
#define CCW_DEVICE_ID_MATCH_DEVICE_MODEL 0x08
|
|
|
|
|
2006-09-20 17:58:25 +04:00
|
|
|
/* s390 AP bus devices */
|
|
|
|
struct ap_device_id {
|
|
|
|
__u16 match_flags; /* which fields to match against */
|
|
|
|
__u8 dev_type; /* device type */
|
|
|
|
kernel_ulong_t driver_info;
|
|
|
|
};
|
|
|
|
|
2016-08-25 12:16:03 +03:00
|
|
|
#define AP_DEVICE_ID_MATCH_CARD_TYPE 0x01
|
|
|
|
#define AP_DEVICE_ID_MATCH_QUEUE_TYPE 0x02
|
2006-09-20 17:58:25 +04:00
|
|
|
|
2008-07-14 11:58:44 +04:00
|
|
|
/* s390 css bus devices (subchannels) */
|
|
|
|
struct css_device_id {
|
2008-07-14 11:59:03 +04:00
|
|
|
__u8 match_flags;
|
2008-07-14 11:58:44 +04:00
|
|
|
__u8 type; /* subchannel type */
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
2013-01-20 20:58:47 +04:00
|
|
|
#define ACPI_ID_LEN 9
|
2007-07-23 16:43:51 +04:00
|
|
|
|
|
|
|
struct acpi_device_id {
|
|
|
|
__u8 id[ACPI_ID_LEN];
|
|
|
|
kernel_ulong_t driver_data;
|
ACPI / scan: Add support for ACPI _CLS device matching
Device drivers typically use ACPI _HIDs/_CIDs listed in struct device_driver
acpi_match_table to match devices. However, for generic drivers, we do not
want to list _HID for all supported devices. Also, certain classes of devices
do not have _CID (e.g. SATA, USB). Instead, we can leverage ACPI _CLS,
which specifies PCI-defined class code (i.e. base-class, subclass and
programming interface). This patch adds support for matching ACPI devices using
the _CLS method.
To support loadable module, current design uses _HID or _CID to match device's
modalias. With the new way of matching with _CLS this would requires modification
to the current ACPI modalias key to include _CLS. This patch appends PCI-defined
class-code to the existing ACPI modalias as following.
acpi:<HID>:<CID1>:<CID2>:..:<CIDn>:<bbsspp>:
E.g:
# cat /sys/devices/platform/AMDI0600:00/modalias
acpi:AMDI0600:010601:
where bb is th base-class code, ss is te sub-class code, and pp is the
programming interface code
Since there would not be _HID/_CID in the ACPI matching table of the driver,
this patch adds a field to acpi_device_id to specify the matching _CLS.
static const struct acpi_device_id ahci_acpi_match[] = {
{ ACPI_DEVICE_CLASS(PCI_CLASS_STORAGE_SATA_AHCI, 0xffffff) },
{},
};
In this case, the corresponded entry in modules.alias file would be:
alias acpi*:010601:* ahci_platform
Acked-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Signed-off-by: Suravee Suthikulpanit <Suravee.Suthikulpanit@amd.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2015-07-07 02:55:20 +03:00
|
|
|
__u32 cls;
|
|
|
|
__u32 cls_msk;
|
2007-07-23 16:43:51 +04:00
|
|
|
};
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
#define PNP_ID_LEN 8
|
|
|
|
#define PNP_MAX_DEVICES 8
|
|
|
|
|
|
|
|
struct pnp_device_id {
|
|
|
|
__u8 id[PNP_ID_LEN];
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct pnp_card_device_id {
|
|
|
|
__u8 id[PNP_ID_LEN];
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
struct {
|
|
|
|
__u8 id[PNP_ID_LEN];
|
|
|
|
} devs[PNP_MAX_DEVICES];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
#define SERIO_ANY 0xff
|
|
|
|
|
|
|
|
struct serio_device_id {
|
|
|
|
__u8 type;
|
|
|
|
__u8 extra;
|
|
|
|
__u8 id;
|
|
|
|
__u8 proto;
|
|
|
|
};
|
|
|
|
|
2015-09-29 11:26:10 +03:00
|
|
|
struct hda_device_id {
|
|
|
|
__u32 vendor_id;
|
|
|
|
__u32 rev_id;
|
|
|
|
__u8 api_version;
|
|
|
|
const char *name;
|
|
|
|
unsigned long driver_data;
|
|
|
|
};
|
|
|
|
|
2017-12-14 08:49:33 +03:00
|
|
|
struct sdw_device_id {
|
|
|
|
__u16 mfg_id;
|
|
|
|
__u16 part_id;
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
2005-07-06 23:44:41 +04:00
|
|
|
/*
|
|
|
|
* Struct used for matching a device
|
|
|
|
*/
|
2015-01-05 18:43:39 +03:00
|
|
|
struct of_device_id {
|
2005-07-06 23:44:41 +04:00
|
|
|
char name[32];
|
|
|
|
char type[32];
|
|
|
|
char compatible[128];
|
2012-06-07 14:20:14 +04:00
|
|
|
const void *data;
|
2005-07-06 23:44:41 +04:00
|
|
|
};
|
|
|
|
|
2005-08-17 10:42:59 +04:00
|
|
|
/* VIO */
|
|
|
|
struct vio_device_id {
|
|
|
|
char type[32];
|
|
|
|
char compat[32];
|
|
|
|
};
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2005-06-28 03:28:06 +04:00
|
|
|
/* PCMCIA */
|
|
|
|
|
|
|
|
struct pcmcia_device_id {
|
|
|
|
__u16 match_flags;
|
|
|
|
|
|
|
|
__u16 manf_id;
|
2019-05-14 17:47:24 +03:00
|
|
|
__u16 card_id;
|
2005-06-28 03:28:06 +04:00
|
|
|
|
2019-05-14 17:47:24 +03:00
|
|
|
__u8 func_id;
|
2005-06-28 03:28:06 +04:00
|
|
|
|
|
|
|
/* for real multi-function devices */
|
2019-05-14 17:47:24 +03:00
|
|
|
__u8 function;
|
2005-06-28 03:28:06 +04:00
|
|
|
|
2005-09-25 16:39:46 +04:00
|
|
|
/* for pseudo multi-function devices */
|
2019-05-14 17:47:24 +03:00
|
|
|
__u8 device_no;
|
2005-06-28 03:28:06 +04:00
|
|
|
|
2019-05-14 17:47:24 +03:00
|
|
|
__u32 prod_id_hash[4];
|
2005-06-28 03:28:06 +04:00
|
|
|
|
2014-09-04 02:58:23 +04:00
|
|
|
/* not matched against in kernelspace */
|
2005-06-28 03:28:56 +04:00
|
|
|
const char * prod_id[4];
|
|
|
|
|
2005-06-28 03:28:06 +04:00
|
|
|
/* not matched against */
|
|
|
|
kernel_ulong_t driver_info;
|
2005-06-28 03:28:07 +04:00
|
|
|
char * cisfile;
|
2005-06-28 03:28:06 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
#define PCMCIA_DEV_ID_MATCH_MANF_ID 0x0001
|
|
|
|
#define PCMCIA_DEV_ID_MATCH_CARD_ID 0x0002
|
|
|
|
#define PCMCIA_DEV_ID_MATCH_FUNC_ID 0x0004
|
|
|
|
#define PCMCIA_DEV_ID_MATCH_FUNCTION 0x0008
|
|
|
|
#define PCMCIA_DEV_ID_MATCH_PROD_ID1 0x0010
|
|
|
|
#define PCMCIA_DEV_ID_MATCH_PROD_ID2 0x0020
|
|
|
|
#define PCMCIA_DEV_ID_MATCH_PROD_ID3 0x0040
|
|
|
|
#define PCMCIA_DEV_ID_MATCH_PROD_ID4 0x0080
|
|
|
|
#define PCMCIA_DEV_ID_MATCH_DEVICE_NO 0x0100
|
2005-06-28 03:28:07 +04:00
|
|
|
#define PCMCIA_DEV_ID_MATCH_FAKE_CIS 0x0200
|
2005-06-28 03:28:09 +04:00
|
|
|
#define PCMCIA_DEV_ID_MATCH_ANONYMOUS 0x0400
|
2005-06-28 03:28:06 +04:00
|
|
|
|
2006-04-26 08:14:19 +04:00
|
|
|
/* Input */
|
|
|
|
#define INPUT_DEVICE_ID_EV_MAX 0x1f
|
2007-03-09 21:59:06 +03:00
|
|
|
#define INPUT_DEVICE_ID_KEY_MIN_INTERESTING 0x71
|
2008-06-23 18:47:34 +04:00
|
|
|
#define INPUT_DEVICE_ID_KEY_MAX 0x2ff
|
2006-04-26 08:14:19 +04:00
|
|
|
#define INPUT_DEVICE_ID_REL_MAX 0x0f
|
2013-09-07 20:48:41 +04:00
|
|
|
#define INPUT_DEVICE_ID_ABS_MAX 0x3f
|
2006-04-26 08:14:19 +04:00
|
|
|
#define INPUT_DEVICE_ID_MSC_MAX 0x07
|
|
|
|
#define INPUT_DEVICE_ID_LED_MAX 0x0f
|
|
|
|
#define INPUT_DEVICE_ID_SND_MAX 0x07
|
|
|
|
#define INPUT_DEVICE_ID_FF_MAX 0x7f
|
|
|
|
#define INPUT_DEVICE_ID_SW_MAX 0x0f
|
2017-10-09 22:01:14 +03:00
|
|
|
#define INPUT_DEVICE_ID_PROP_MAX 0x1f
|
2006-04-26 08:14:19 +04:00
|
|
|
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_BUS 1
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_VENDOR 2
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_PRODUCT 4
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_VERSION 8
|
|
|
|
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_EVBIT 0x0010
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_KEYBIT 0x0020
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_RELBIT 0x0040
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_ABSBIT 0x0080
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_MSCIT 0x0100
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_LEDBIT 0x0200
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_SNDBIT 0x0400
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_FFBIT 0x0800
|
|
|
|
#define INPUT_DEVICE_ID_MATCH_SWBIT 0x1000
|
2017-10-09 22:01:14 +03:00
|
|
|
#define INPUT_DEVICE_ID_MATCH_PROPBIT 0x2000
|
2006-04-26 08:14:19 +04:00
|
|
|
|
|
|
|
struct input_device_id {
|
|
|
|
|
|
|
|
kernel_ulong_t flags;
|
|
|
|
|
|
|
|
__u16 bustype;
|
|
|
|
__u16 vendor;
|
|
|
|
__u16 product;
|
|
|
|
__u16 version;
|
|
|
|
|
|
|
|
kernel_ulong_t evbit[INPUT_DEVICE_ID_EV_MAX / BITS_PER_LONG + 1];
|
|
|
|
kernel_ulong_t keybit[INPUT_DEVICE_ID_KEY_MAX / BITS_PER_LONG + 1];
|
|
|
|
kernel_ulong_t relbit[INPUT_DEVICE_ID_REL_MAX / BITS_PER_LONG + 1];
|
|
|
|
kernel_ulong_t absbit[INPUT_DEVICE_ID_ABS_MAX / BITS_PER_LONG + 1];
|
|
|
|
kernel_ulong_t mscbit[INPUT_DEVICE_ID_MSC_MAX / BITS_PER_LONG + 1];
|
|
|
|
kernel_ulong_t ledbit[INPUT_DEVICE_ID_LED_MAX / BITS_PER_LONG + 1];
|
|
|
|
kernel_ulong_t sndbit[INPUT_DEVICE_ID_SND_MAX / BITS_PER_LONG + 1];
|
|
|
|
kernel_ulong_t ffbit[INPUT_DEVICE_ID_FF_MAX / BITS_PER_LONG + 1];
|
|
|
|
kernel_ulong_t swbit[INPUT_DEVICE_ID_SW_MAX / BITS_PER_LONG + 1];
|
2017-10-09 22:01:14 +03:00
|
|
|
kernel_ulong_t propbit[INPUT_DEVICE_ID_PROP_MAX / BITS_PER_LONG + 1];
|
2006-04-26 08:14:19 +04:00
|
|
|
|
|
|
|
kernel_ulong_t driver_info;
|
|
|
|
};
|
|
|
|
|
2006-09-27 12:50:56 +04:00
|
|
|
/* EISA */
|
|
|
|
|
|
|
|
#define EISA_SIG_LEN 8
|
|
|
|
|
|
|
|
/* The EISA signature, in ASCII form, null terminated */
|
|
|
|
struct eisa_device_id {
|
|
|
|
char sig[EISA_SIG_LEN];
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define EISA_DEVICE_MODALIAS_FMT "eisa:s%s"
|
|
|
|
|
2007-01-13 22:57:25 +03:00
|
|
|
struct parisc_device_id {
|
|
|
|
__u8 hw_type; /* 5 bits used */
|
|
|
|
__u8 hversion_rev; /* 4 bits */
|
|
|
|
__u16 hversion; /* 12 bits */
|
|
|
|
__u32 sversion; /* 20 bits */
|
|
|
|
};
|
|
|
|
|
2007-01-13 23:02:09 +03:00
|
|
|
#define PA_HWTYPE_ANY_ID 0xff
|
|
|
|
#define PA_HVERSION_REV_ANY_ID 0xff
|
|
|
|
#define PA_HVERSION_ANY_ID 0xffff
|
|
|
|
#define PA_SVERSION_ANY_ID 0xffffffff
|
2007-01-13 22:57:25 +03:00
|
|
|
|
2007-06-16 17:54:55 +04:00
|
|
|
/* SDIO */
|
|
|
|
|
|
|
|
#define SDIO_ANY_ID (~0)
|
|
|
|
|
|
|
|
struct sdio_device_id {
|
|
|
|
__u8 class; /* Standard interface or SDIO_ANY_ID */
|
|
|
|
__u16 vendor; /* Vendor or SDIO_ANY_ID */
|
|
|
|
__u16 device; /* Device ID or SDIO_ANY_ID */
|
2013-01-20 20:58:47 +04:00
|
|
|
kernel_ulong_t driver_data; /* Data private to the driver */
|
2007-06-16 17:54:55 +04:00
|
|
|
};
|
|
|
|
|
2007-09-18 23:12:50 +04:00
|
|
|
/* SSB core, see drivers/ssb/ */
|
|
|
|
struct ssb_device_id {
|
|
|
|
__u16 vendor;
|
|
|
|
__u16 coreid;
|
|
|
|
__u8 revision;
|
2013-07-05 19:43:56 +04:00
|
|
|
__u8 __pad;
|
|
|
|
} __attribute__((packed, aligned(2)));
|
2007-09-18 23:12:50 +04:00
|
|
|
#define SSB_DEVICE(_vendor, _coreid, _revision) \
|
|
|
|
{ .vendor = _vendor, .coreid = _coreid, .revision = _revision, }
|
|
|
|
|
|
|
|
#define SSB_ANY_VENDOR 0xFFFF
|
|
|
|
#define SSB_ANY_ID 0xFFFF
|
|
|
|
#define SSB_ANY_REV 0xFF
|
|
|
|
|
2011-05-09 20:56:46 +04:00
|
|
|
/* Broadcom's specific AMBA core, see drivers/bcma/ */
|
|
|
|
struct bcma_device_id {
|
|
|
|
__u16 manuf;
|
|
|
|
__u16 id;
|
|
|
|
__u8 rev;
|
|
|
|
__u8 class;
|
2013-07-05 19:43:56 +04:00
|
|
|
} __attribute__((packed,aligned(2)));
|
2011-05-09 20:56:46 +04:00
|
|
|
#define BCMA_CORE(_manuf, _id, _rev, _class) \
|
|
|
|
{ .manuf = _manuf, .id = _id, .rev = _rev, .class = _class, }
|
|
|
|
|
|
|
|
#define BCMA_ANY_MANUF 0xFFFF
|
|
|
|
#define BCMA_ANY_ID 0xFFFF
|
|
|
|
#define BCMA_ANY_REV 0xFF
|
|
|
|
#define BCMA_ANY_CLASS 0xFF
|
|
|
|
|
2007-10-22 05:03:36 +04:00
|
|
|
struct virtio_device_id {
|
|
|
|
__u32 device;
|
|
|
|
__u32 vendor;
|
|
|
|
};
|
|
|
|
#define VIRTIO_DEV_ANY_ID 0xffffffff
|
|
|
|
|
2011-08-25 20:48:29 +04:00
|
|
|
/*
|
|
|
|
* For Hyper-V devices we use the device guid as the id.
|
|
|
|
*/
|
|
|
|
struct hv_vmbus_device_id {
|
2015-12-15 03:01:43 +03:00
|
|
|
uuid_le guid;
|
2013-01-20 20:58:47 +04:00
|
|
|
kernel_ulong_t driver_data; /* Data private to the driver */
|
2011-08-25 20:48:29 +04:00
|
|
|
};
|
|
|
|
|
2011-10-20 23:10:55 +04:00
|
|
|
/* rpmsg */
|
|
|
|
|
|
|
|
#define RPMSG_NAME_SIZE 32
|
|
|
|
#define RPMSG_DEVICE_MODALIAS_FMT "rpmsg:%s"
|
|
|
|
|
|
|
|
struct rpmsg_device_id {
|
|
|
|
char name[RPMSG_NAME_SIZE];
|
|
|
|
};
|
|
|
|
|
2008-04-30 01:11:39 +04:00
|
|
|
/* i2c */
|
|
|
|
|
|
|
|
#define I2C_NAME_SIZE 20
|
|
|
|
#define I2C_MODULE_PREFIX "i2c:"
|
|
|
|
|
|
|
|
struct i2c_device_id {
|
|
|
|
char name[I2C_NAME_SIZE];
|
2013-01-20 20:58:47 +04:00
|
|
|
kernel_ulong_t driver_data; /* Data private to the driver */
|
2008-04-30 01:11:39 +04:00
|
|
|
};
|
|
|
|
|
2017-04-10 16:55:10 +03:00
|
|
|
/* pci_epf */
|
|
|
|
|
|
|
|
#define PCI_EPF_NAME_SIZE 20
|
|
|
|
#define PCI_EPF_MODULE_PREFIX "pci_epf:"
|
|
|
|
|
|
|
|
struct pci_epf_device_id {
|
|
|
|
char name[PCI_EPF_NAME_SIZE];
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
i3c: Add core I3C infrastructure
Add core infrastructure to support I3C in Linux and document it.
This infrastructure adds basic I3C support. Advanced features will be
added afterwards.
There are a few design choices that are worth mentioning because they
impact the way I3C device drivers can interact with their devices:
- all functions used to send I3C/I2C frames must be called in
non-atomic context. Mainly done this way to ease implementation, but
this is not set in stone, and if anyone needs async support, new
functions can be added later on.
- the bus element is a separate object, but it's tightly coupled with
the master object. We thus have a 1:1 relationship between i3c_bus
and i3c_master_controller objects, and if 2 master controllers are
connected to the same bus and both exposed to the same Linux instance
they will appear as two distinct busses, and devices on this bus will
be exposed twice.
- I2C backward compatibility has been designed to be transparent to I2C
drivers and the I2C subsystem. The I3C master just registers an I2C
adapter which creates a new I2C bus. I'd say that, from a
representation PoV it's not ideal because what should appear as a
single I3C bus exposing I3C and I2C devices here appears as 2
different buses connected to each other through the parenting (the
I3C master is the parent of the I2C and I3C busses).
On the other hand, I don't see a better solution if we want something
that is not invasive.
Missing features:
- I3C HDR modes are not supported
- no support for multi-master and the associated concepts (mastership
handover, support for secondary masters, ...)
- I2C devices can only be described using DT because this is the only
use case I have. However, the framework can easily be extended with
ACPI and board info support
- I3C slave framework. This has been completely omitted, but shouldn't
have a huge impact on the I3C framework because I3C slaves don't see
the whole bus, it's only about handling master requests and generating
IBIs. Some of the struct, constant and enum definitions could be
shared, but most of the I3C slave framework logic will be different
Signed-off-by: Boris Brezillon <boris.brezillon@bootlin.com>
Reviewed-by: Arnd Bergmann <arnd@arndb.de>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-07-19 12:52:29 +03:00
|
|
|
/* i3c */
|
|
|
|
|
|
|
|
#define I3C_MATCH_DCR 0x1
|
|
|
|
#define I3C_MATCH_MANUF 0x2
|
|
|
|
#define I3C_MATCH_PART 0x4
|
|
|
|
#define I3C_MATCH_EXTRA_INFO 0x8
|
|
|
|
|
|
|
|
struct i3c_device_id {
|
|
|
|
__u8 match_flags;
|
|
|
|
__u8 dcr;
|
|
|
|
__u16 manuf_id;
|
|
|
|
__u16 part_id;
|
|
|
|
__u16 extra_info;
|
|
|
|
|
|
|
|
const void *data;
|
|
|
|
};
|
|
|
|
|
2009-09-23 03:46:04 +04:00
|
|
|
/* spi */
|
|
|
|
|
|
|
|
#define SPI_NAME_SIZE 32
|
2009-09-23 03:46:08 +04:00
|
|
|
#define SPI_MODULE_PREFIX "spi:"
|
2009-09-23 03:46:04 +04:00
|
|
|
|
|
|
|
struct spi_device_id {
|
|
|
|
char name[SPI_NAME_SIZE];
|
2013-01-20 20:58:47 +04:00
|
|
|
kernel_ulong_t driver_data; /* Data private to the driver */
|
2009-09-23 03:46:04 +04:00
|
|
|
};
|
|
|
|
|
2017-12-12 02:42:57 +03:00
|
|
|
/* SLIMbus */
|
|
|
|
|
|
|
|
#define SLIMBUS_NAME_SIZE 32
|
|
|
|
#define SLIMBUS_MODULE_PREFIX "slim:"
|
|
|
|
|
|
|
|
struct slim_device_id {
|
|
|
|
__u16 manf_id, prod_code;
|
|
|
|
__u16 dev_index, instance;
|
|
|
|
|
|
|
|
/* Data private to the driver */
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
2018-05-09 15:56:13 +03:00
|
|
|
#define APR_NAME_SIZE 32
|
|
|
|
#define APR_MODULE_PREFIX "apr:"
|
|
|
|
|
|
|
|
struct apr_device_id {
|
|
|
|
char name[APR_NAME_SIZE];
|
|
|
|
__u32 domain_id;
|
|
|
|
__u32 svc_id;
|
|
|
|
__u32 svc_version;
|
|
|
|
kernel_ulong_t driver_data; /* Data private to the driver */
|
|
|
|
};
|
|
|
|
|
2014-02-12 23:44:22 +04:00
|
|
|
#define SPMI_NAME_SIZE 32
|
|
|
|
#define SPMI_MODULE_PREFIX "spmi:"
|
|
|
|
|
|
|
|
struct spmi_device_id {
|
|
|
|
char name[SPMI_NAME_SIZE];
|
|
|
|
kernel_ulong_t driver_data; /* Data private to the driver */
|
|
|
|
};
|
|
|
|
|
2008-09-17 03:23:28 +04:00
|
|
|
/* dmi */
|
|
|
|
enum dmi_field {
|
|
|
|
DMI_NONE,
|
|
|
|
DMI_BIOS_VENDOR,
|
|
|
|
DMI_BIOS_VERSION,
|
|
|
|
DMI_BIOS_DATE,
|
|
|
|
DMI_SYS_VENDOR,
|
|
|
|
DMI_PRODUCT_NAME,
|
|
|
|
DMI_PRODUCT_VERSION,
|
|
|
|
DMI_PRODUCT_SERIAL,
|
|
|
|
DMI_PRODUCT_UUID,
|
2018-06-17 15:09:42 +03:00
|
|
|
DMI_PRODUCT_SKU,
|
2017-05-17 13:25:12 +03:00
|
|
|
DMI_PRODUCT_FAMILY,
|
2008-09-17 03:23:28 +04:00
|
|
|
DMI_BOARD_VENDOR,
|
|
|
|
DMI_BOARD_NAME,
|
|
|
|
DMI_BOARD_VERSION,
|
|
|
|
DMI_BOARD_SERIAL,
|
|
|
|
DMI_BOARD_ASSET_TAG,
|
|
|
|
DMI_CHASSIS_VENDOR,
|
|
|
|
DMI_CHASSIS_TYPE,
|
|
|
|
DMI_CHASSIS_VERSION,
|
|
|
|
DMI_CHASSIS_SERIAL,
|
|
|
|
DMI_CHASSIS_ASSET_TAG,
|
|
|
|
DMI_STRING_MAX,
|
2018-04-13 16:37:59 +03:00
|
|
|
DMI_OEM_STRING, /* special case - will not be in dmi_ident */
|
2008-09-17 03:23:28 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct dmi_strmatch {
|
2013-07-04 02:05:02 +04:00
|
|
|
unsigned char slot:7;
|
|
|
|
unsigned char exact_match:1;
|
2008-09-17 03:23:28 +04:00
|
|
|
char substr[79];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct dmi_system_id {
|
|
|
|
int (*callback)(const struct dmi_system_id *);
|
|
|
|
const char *ident;
|
|
|
|
struct dmi_strmatch matches[4];
|
|
|
|
void *driver_data;
|
|
|
|
};
|
2009-01-22 01:58:36 +03:00
|
|
|
/*
|
|
|
|
* struct dmi_device_id appears during expansion of
|
|
|
|
* "MODULE_DEVICE_TABLE(dmi, x)". Compiler doesn't look inside it
|
|
|
|
* but this is enough for gcc 3.4.6 to error out:
|
|
|
|
* error: storage size of '__mod_dmi_device_table' isn't known
|
|
|
|
*/
|
|
|
|
#define dmi_device_id dmi_system_id
|
2008-09-17 03:23:28 +04:00
|
|
|
|
2013-07-04 02:05:02 +04:00
|
|
|
#define DMI_MATCH(a, b) { .slot = a, .substr = b }
|
|
|
|
#define DMI_EXACT_MATCH(a, b) { .slot = a, .substr = b, .exact_match = 1 }
|
2008-04-30 01:11:39 +04:00
|
|
|
|
2009-02-04 06:52:40 +03:00
|
|
|
#define PLATFORM_NAME_SIZE 20
|
|
|
|
#define PLATFORM_MODULE_PREFIX "platform:"
|
|
|
|
|
|
|
|
struct platform_device_id {
|
|
|
|
char name[PLATFORM_NAME_SIZE];
|
2013-01-20 20:58:47 +04:00
|
|
|
kernel_ulong_t driver_data;
|
2009-02-04 06:52:40 +03:00
|
|
|
};
|
|
|
|
|
2017-02-05 00:02:44 +03:00
|
|
|
#define MDIO_NAME_SIZE 32
|
2010-04-02 05:05:27 +04:00
|
|
|
#define MDIO_MODULE_PREFIX "mdio:"
|
|
|
|
|
|
|
|
#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"
|
|
|
|
#define MDIO_ID_ARGS(_id) \
|
|
|
|
(_id)>>31, ((_id)>>30) & 1, ((_id)>>29) & 1, ((_id)>>28) & 1, \
|
|
|
|
((_id)>>27) & 1, ((_id)>>26) & 1, ((_id)>>25) & 1, ((_id)>>24) & 1, \
|
|
|
|
((_id)>>23) & 1, ((_id)>>22) & 1, ((_id)>>21) & 1, ((_id)>>20) & 1, \
|
|
|
|
((_id)>>19) & 1, ((_id)>>18) & 1, ((_id)>>17) & 1, ((_id)>>16) & 1, \
|
|
|
|
((_id)>>15) & 1, ((_id)>>14) & 1, ((_id)>>13) & 1, ((_id)>>12) & 1, \
|
|
|
|
((_id)>>11) & 1, ((_id)>>10) & 1, ((_id)>>9) & 1, ((_id)>>8) & 1, \
|
|
|
|
((_id)>>7) & 1, ((_id)>>6) & 1, ((_id)>>5) & 1, ((_id)>>4) & 1, \
|
|
|
|
((_id)>>3) & 1, ((_id)>>2) & 1, ((_id)>>1) & 1, (_id) & 1
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct mdio_device_id - identifies PHY devices on an MDIO/MII bus
|
|
|
|
* @phy_id: The result of
|
2018-12-13 23:00:11 +03:00
|
|
|
* (mdio_read(&MII_PHYSID1) << 16 | mdio_read(&MII_PHYSID2)) & @phy_id_mask
|
2010-04-02 05:05:27 +04:00
|
|
|
* for this PHY type
|
|
|
|
* @phy_id_mask: Defines the significant bits of @phy_id. A value of 0
|
|
|
|
* is used to terminate an array of struct mdio_device_id.
|
|
|
|
*/
|
|
|
|
struct mdio_device_id {
|
|
|
|
__u32 phy_id;
|
|
|
|
__u32 phy_id_mask;
|
|
|
|
};
|
|
|
|
|
2008-11-18 23:13:53 +03:00
|
|
|
struct zorro_device_id {
|
|
|
|
__u32 id; /* Device ID or ZORRO_WILDCARD */
|
|
|
|
kernel_ulong_t driver_data; /* Data private to the driver */
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ZORRO_WILDCARD (0xffffffff) /* not official */
|
|
|
|
|
|
|
|
#define ZORRO_DEVICE_MODALIAS_FMT "zorro:i%08X"
|
|
|
|
|
2010-05-20 03:33:38 +04:00
|
|
|
#define ISAPNP_ANY_ID 0xffff
|
|
|
|
struct isapnp_device_id {
|
|
|
|
unsigned short card_vendor, card_device;
|
|
|
|
unsigned short vendor, function;
|
|
|
|
kernel_ulong_t driver_data; /* data private to the driver */
|
|
|
|
};
|
|
|
|
|
2011-10-05 17:40:59 +04:00
|
|
|
/**
|
|
|
|
* struct amba_id - identifies a device on an AMBA bus
|
|
|
|
* @id: The significant bits if the hardware device ID
|
|
|
|
* @mask: Bitmask specifying which bits of the id field are significant when
|
|
|
|
* matching. A driver binds to a device when ((hardware device ID) & mask)
|
|
|
|
* == id.
|
|
|
|
* @data: Private data used by the driver.
|
|
|
|
*/
|
|
|
|
struct amba_id {
|
|
|
|
unsigned int id;
|
|
|
|
unsigned int mask;
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
2015-03-25 18:39:50 +03:00
|
|
|
/**
|
|
|
|
* struct mips_cdmm_device_id - identifies devices in MIPS CDMM bus
|
|
|
|
* @type: Device type identifier.
|
|
|
|
*/
|
|
|
|
struct mips_cdmm_device_id {
|
|
|
|
__u8 type;
|
|
|
|
};
|
|
|
|
|
2012-01-26 03:09:05 +04:00
|
|
|
/*
|
|
|
|
* Match x86 CPUs for CPU specific drivers.
|
|
|
|
* See documentation of "x86_match_cpu" for details.
|
|
|
|
*/
|
|
|
|
|
2014-02-14 00:21:48 +04:00
|
|
|
/*
|
|
|
|
* MODULE_DEVICE_TABLE expects this struct to be called x86cpu_device_id.
|
|
|
|
* Although gcc seems to ignore this error, clang fails without this define.
|
|
|
|
*/
|
|
|
|
#define x86cpu_device_id x86_cpu_id
|
2012-01-26 03:09:05 +04:00
|
|
|
struct x86_cpu_id {
|
|
|
|
__u16 vendor;
|
|
|
|
__u16 family;
|
|
|
|
__u16 model;
|
|
|
|
__u16 feature; /* bit index */
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define X86_FEATURE_MATCH(x) \
|
|
|
|
{ X86_VENDOR_ANY, X86_FAMILY_ANY, X86_MODEL_ANY, x }
|
|
|
|
|
|
|
|
#define X86_VENDOR_ANY 0xffff
|
|
|
|
#define X86_FAMILY_ANY 0
|
|
|
|
#define X86_MODEL_ANY 0
|
|
|
|
#define X86_FEATURE_ANY 0 /* Same as FPU, you can't test for that */
|
|
|
|
|
2014-02-08 16:34:09 +04:00
|
|
|
/*
|
|
|
|
* Generic table type for matching CPU features.
|
|
|
|
* @feature: the bit number of the feature (0 - 65535)
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct cpu_feature {
|
|
|
|
__u16 feature;
|
|
|
|
};
|
|
|
|
|
2012-09-07 12:29:19 +04:00
|
|
|
#define IPACK_ANY_FORMAT 0xff
|
2012-09-04 19:01:13 +04:00
|
|
|
#define IPACK_ANY_ID (~0)
|
|
|
|
struct ipack_device_id {
|
|
|
|
__u8 format; /* Format version or IPACK_ANY_ID */
|
|
|
|
__u32 vendor; /* Vendor ID or IPACK_ANY_ID */
|
|
|
|
__u32 device; /* Device ID or IPACK_ANY_ID */
|
|
|
|
};
|
|
|
|
|
2013-03-27 19:29:53 +04:00
|
|
|
#define MEI_CL_MODULE_PREFIX "mei:"
|
|
|
|
#define MEI_CL_NAME_SIZE 32
|
2015-09-10 10:18:01 +03:00
|
|
|
#define MEI_CL_VERSION_ANY 0xff
|
2013-03-27 19:29:53 +04:00
|
|
|
|
2015-05-07 15:54:02 +03:00
|
|
|
/**
|
|
|
|
* struct mei_cl_device_id - MEI client device identifier
|
|
|
|
* @name: helper name
|
|
|
|
* @uuid: client uuid
|
2015-09-10 10:18:01 +03:00
|
|
|
* @version: client protocol version
|
2015-05-07 15:54:02 +03:00
|
|
|
* @driver_info: information used by the driver.
|
|
|
|
*
|
|
|
|
* identifies mei client device by uuid and name
|
|
|
|
*/
|
2013-03-27 19:29:53 +04:00
|
|
|
struct mei_cl_device_id {
|
|
|
|
char name[MEI_CL_NAME_SIZE];
|
2015-05-28 03:17:27 +03:00
|
|
|
uuid_le uuid;
|
2015-09-10 10:18:01 +03:00
|
|
|
__u8 version;
|
2013-03-27 19:29:53 +04:00
|
|
|
kernel_ulong_t driver_info;
|
|
|
|
};
|
|
|
|
|
2013-07-04 02:08:58 +04:00
|
|
|
/* RapidIO */
|
|
|
|
|
|
|
|
#define RIO_ANY_ID 0xffff
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct rio_device_id - RIO device identifier
|
|
|
|
* @did: RapidIO device ID
|
|
|
|
* @vid: RapidIO vendor ID
|
|
|
|
* @asm_did: RapidIO assembly device ID
|
|
|
|
* @asm_vid: RapidIO assembly vendor ID
|
|
|
|
*
|
|
|
|
* Identifies a RapidIO device based on both the device/vendor IDs and
|
|
|
|
* the assembly device/vendor IDs.
|
|
|
|
*/
|
|
|
|
struct rio_device_id {
|
|
|
|
__u16 did, vid;
|
|
|
|
__u16 asm_did, asm_vid;
|
|
|
|
};
|
|
|
|
|
2014-02-26 20:29:05 +04:00
|
|
|
struct mcb_device_id {
|
|
|
|
__u16 device;
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
2015-05-13 15:26:42 +03:00
|
|
|
struct ulpi_device_id {
|
|
|
|
__u16 vendor;
|
|
|
|
__u16 product;
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
2016-06-23 00:40:45 +03:00
|
|
|
/**
|
|
|
|
* struct fsl_mc_device_id - MC object device identifier
|
|
|
|
* @vendor: vendor ID
|
|
|
|
* @obj_type: MC object type
|
|
|
|
*
|
|
|
|
* Type of entries in the "device Id" table for MC object devices supported by
|
|
|
|
* a MC object device driver. The last entry of the table has vendor set to 0x0
|
|
|
|
*/
|
|
|
|
struct fsl_mc_device_id {
|
|
|
|
__u16 vendor;
|
|
|
|
const char obj_type[16];
|
|
|
|
};
|
|
|
|
|
2017-10-02 13:38:34 +03:00
|
|
|
/**
|
|
|
|
* struct tb_service_id - Thunderbolt service identifiers
|
|
|
|
* @match_flags: Flags used to match the structure
|
|
|
|
* @protocol_key: Protocol key the service supports
|
|
|
|
* @protocol_id: Protocol id the service supports
|
|
|
|
* @protocol_version: Version of the protocol
|
|
|
|
* @protocol_revision: Revision of the protocol software
|
|
|
|
* @driver_data: Driver specific data
|
|
|
|
*
|
|
|
|
* Thunderbolt XDomain services are exposed as devices where each device
|
|
|
|
* carries the protocol information the service supports. Thunderbolt
|
|
|
|
* XDomain service drivers match against that information.
|
|
|
|
*/
|
|
|
|
struct tb_service_id {
|
|
|
|
__u32 match_flags;
|
|
|
|
char protocol_key[8 + 1];
|
|
|
|
__u32 protocol_id;
|
|
|
|
__u32 protocol_version;
|
|
|
|
__u32 protocol_revision;
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define TBSVC_MATCH_PROTOCOL_KEY 0x0001
|
|
|
|
#define TBSVC_MATCH_PROTOCOL_ID 0x0002
|
|
|
|
#define TBSVC_MATCH_PROTOCOL_VERSION 0x0004
|
|
|
|
#define TBSVC_MATCH_PROTOCOL_REVISION 0x0008
|
2016-06-23 00:40:45 +03:00
|
|
|
|
2018-06-27 18:19:50 +03:00
|
|
|
/* USB Type-C Alternate Modes */
|
|
|
|
|
|
|
|
#define TYPEC_ANY_MODE 0x7
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct typec_device_id - USB Type-C alternate mode identifiers
|
|
|
|
* @svid: Standard or Vendor ID
|
|
|
|
* @mode: Mode index
|
2018-09-03 22:51:59 +03:00
|
|
|
* @driver_data: Driver specific data
|
2018-06-27 18:19:50 +03:00
|
|
|
*/
|
|
|
|
struct typec_device_id {
|
|
|
|
__u16 svid;
|
|
|
|
__u8 mode;
|
|
|
|
kernel_ulong_t driver_data;
|
|
|
|
};
|
|
|
|
|
2019-01-29 08:49:35 +03:00
|
|
|
/**
|
|
|
|
* struct tee_client_device_id - tee based device identifier
|
|
|
|
* @uuid: For TEE based client devices we use the device uuid as
|
|
|
|
* the identifier.
|
|
|
|
*/
|
|
|
|
struct tee_client_device_id {
|
|
|
|
uuid_t uuid;
|
|
|
|
};
|
|
|
|
|
2019-02-19 22:59:49 +03:00
|
|
|
/* WMI */
|
|
|
|
|
|
|
|
#define WMI_MODULE_PREFIX "wmi:"
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct wmi_device_id - WMI device identifier
|
|
|
|
* @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
|
2019-07-19 20:51:45 +03:00
|
|
|
* @context: pointer to driver specific data
|
2019-02-19 22:59:49 +03:00
|
|
|
*/
|
|
|
|
struct wmi_device_id {
|
|
|
|
const char guid_string[UUID_STRING_LEN+1];
|
2019-05-27 19:21:29 +03:00
|
|
|
const void *context;
|
2019-02-19 22:59:49 +03:00
|
|
|
};
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif /* LINUX_MOD_DEVICETABLE_H */
|