Definition:

struct subsys_interface {    const char *name;    const struct bus_type *subsys;    struct list_head node;    int (*add_dev)(struct device *dev, struct subsys_interface *sif);    void (*remove_dev)(struct device *dev, struct subsys_interface *sif);};

Members

name

name of the device function

subsys

subsystem of the devices to attach to

node

the list of functions registered at the subsystem

add_dev

device hookup to device function handler

remove_dev

device hookup to device function handler

Definition:

struct device_attribute {    struct attribute        attr;    ssize_t (*show)(struct device *dev, struct device_attribute *attr, char *buf);    ssize_t (*store)(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);};

Members

attr

sysfs attribute definition.

show

Show handler.

store

Store handler.

Definition:

struct dev_ext_attribute {    struct device_attribute attr;    void *var;};

Members

attr

Exported device attribute.

var

Pointer to context.

Parameters

_name

Attribute name.

_mode

File mode.

_show

Show handler. Optional, but mandatory if attribute is readable.

_store

Store handler. Optional, but mandatory if attribute is writable.

Description

Convenience macro for defining astructdevice_attribute.

For example,DEVICE_ATTR(foo,0644,foo_show,foo_store); expands to:

structdevice_attributedev_attr_foo={.attr={.name="foo",.mode=0644},.show=foo_show,.store=foo_store,};

Parameters

_name

Attribute name.

_mode

File mode.

_show

Show handler. Optional, but mandatory if attribute is readable.

_store

Store handler. Optional, but mandatory if attribute is writable.

Description

LikeDEVICE_ATTR(), butSYSFS_PREALLOC is set on_mode.

Parameters

_name

Attribute name.

Description

LikeDEVICE_ATTR(), but_mode is 0644,_show is <_name>_show,and_store is <_name>_store.

Parameters

_name

Attribute name.

Description

LikeDEVICE_ATTR_RW(), but_mode is 0600.

Parameters

_name

Attribute name.

Description

LikeDEVICE_ATTR(), but_mode is 0444 and_show is <_name>_show.

Parameters

_name

Attribute name.

Description

LikeDEVICE_ATTR_RO(), but_mode is 0400.

Parameters

_name

Attribute name.

Description

LikeDEVICE_ATTR(), but_mode is 0200 and_store is <_name>_store.

Parameters

_name

Attribute name.

_mode

File mode.

_var

Identifier of unsigned long.

Description

LikeDEVICE_ATTR(), but_show and_store are automatically providedsuch that reads and writes to the attribute from userspace affect_var.

Parameters

_name

Attribute name.

_mode

File mode.

_var

Identifier of int.

Description

LikeDEVICE_ULONG_ATTR(), but_var is an int.

Parameters

_name

Attribute name.

_mode

File mode.

_var

Identifier of bool.

Description

LikeDEVICE_ULONG_ATTR(), but_var is a bool.

Parameters

_name

Attribute name.

_mode

File mode.

_var

Identifier of string.

Description

LikeDEVICE_ULONG_ATTR(), but_var is a string. Because the length of thestring allocation is unknown, the attribute must be read-only.

Constants

DL_DEV_NO_DRIVER

There is no driver attached to the device.

DL_DEV_PROBING

A driver is probing.

DL_DEV_DRIVER_BOUND

The driver has been bound to the device.

DL_DEV_UNBINDING

The driver is unbinding from the device.

Constants

DEVICE_REMOVABLE_NOT_SUPPORTED

This attribute is not supported for thisdevice (default).

DEVICE_REMOVABLE_UNKNOWN

Device location is Unknown.

DEVICE_FIXED

Device is not removable by the user.

DEVICE_REMOVABLE

Device is removable by the user.

Definition:

struct dev_links_info {    struct list_head suppliers;    struct list_head consumers;    struct list_head defer_sync;    enum dl_dev_state status;};

Members

suppliers

List of links to supplier devices.

consumers

List of links to consumer devices.

defer_sync

Hook to global list of devices that have deferred sync_state.

status

Driver status information.

Definition:

struct dev_msi_info {#ifdef CONFIG_GENERIC_MSI_IRQ;    struct irq_domain       *domain;    struct msi_device_data  *data;#endif;};

Members

domain

The MSI interrupt domain associated to the device

data

Pointer to MSI device data

Constants

DEVICE_PANEL_TOP

Device connection point is on the top panel.

DEVICE_PANEL_BOTTOM

Device connection point is on the bottom panel.

DEVICE_PANEL_LEFT

Device connection point is on the left panel.

DEVICE_PANEL_RIGHT

Device connection point is on the right panel.

DEVICE_PANEL_FRONT

Device connection point is on the front panel.

DEVICE_PANEL_BACK

Device connection point is on the back panel.

DEVICE_PANEL_UNKNOWN

The panel with device connection point is unknown.

Constants

DEVICE_VERT_POS_UPPER

Device connection point is at upper part of panel.

DEVICE_VERT_POS_CENTER

Device connection point is at center part of panel.

DEVICE_VERT_POS_LOWER

Device connection point is at lower part of panel.

Constants

DEVICE_HORI_POS_LEFT

Device connection point is at left part of panel.

DEVICE_HORI_POS_CENTER

Device connection point is at center part of panel.

DEVICE_HORI_POS_RIGHT

Device connection point is at right part of panel.

Definition:

struct device_physical_location {    enum device_physical_location_panel panel;    enum device_physical_location_vertical_position vertical_position;    enum device_physical_location_horizontal_position horizontal_position;    bool dock;    bool lid;};

Members

panel

Panel surface of the system’s housing that the device connectionpoint resides on.

vertical_position

Vertical position of the device connection point withinthe panel.

horizontal_position

Horizontal position of the device connection pointwithin the panel.

dock

Set if the device connection point resides in a docking station orport replicator.

lid

Set if this device connection point resides on the lid of laptopsystem.

Definition:

struct device {    struct kobject kobj;    struct device           *parent;    struct device_private   *p;    const char              *init_name;    const struct device_type *type;    const struct bus_type   *bus;    struct device_driver *driver;    void *platform_data;    void *driver_data;    struct mutex            mutex;    struct dev_links_info   links;    struct dev_pm_info      power;    struct dev_pm_domain    *pm_domain;#ifdef CONFIG_ENERGY_MODEL;    struct em_perf_domain   *em_pd;#endif;#ifdef CONFIG_PINCTRL;    struct dev_pin_info     *pins;#endif;    struct dev_msi_info     msi;#ifdef CONFIG_ARCH_HAS_DMA_OPS;    const struct dma_map_ops *dma_ops;#endif;    u64 *dma_mask;    u64 coherent_dma_mask;    u64 bus_dma_limit;    const struct bus_dma_region *dma_range_map;    struct device_dma_parameters *dma_parms;    struct list_head        dma_pools;#ifdef CONFIG_DMA_DECLARE_COHERENT;    struct dma_coherent_mem *dma_mem;#endif;#ifdef CONFIG_DMA_CMA;    struct cma *cma_area;#endif;#ifdef CONFIG_SWIOTLB;    struct io_tlb_mem *dma_io_tlb_mem;#endif;#ifdef CONFIG_SWIOTLB_DYNAMIC;    struct list_head dma_io_tlb_pools;    spinlock_t dma_io_tlb_lock;    bool dma_uses_io_tlb;#endif;    struct dev_archdata     archdata;    struct device_node      *of_node;    struct fwnode_handle    *fwnode;#ifdef CONFIG_NUMA;    int numa_node;#endif;    dev_t devt;    u32 id;    spinlock_t devres_lock;    struct list_head        devres_head;    const struct class      *class;    const struct attribute_group **groups;    void (*release)(struct device *dev);    struct iommu_group      *iommu_group;    struct dev_iommu        *iommu;    struct device_physical_location *physical_location;    enum device_removable   removable;    bool offline_disabled:1;    bool offline:1;    bool of_node_reused:1;    bool state_synced:1;    bool can_match:1;#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) ||     defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) ||     defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL);    bool dma_coherent:1;#endif;#ifdef CONFIG_DMA_OPS_BYPASS;    bool dma_ops_bypass : 1;#endif;#ifdef CONFIG_DMA_NEED_SYNC;    bool dma_skip_sync:1;#endif;#ifdef CONFIG_IOMMU_DMA;    bool dma_iommu:1;#endif;};

Members

kobj

A top-level, abstract class from which other classes are derived.

parent

The device’s “parent” device, the device to which it is attached.In most cases, a parent device is some sort of bus or hostcontroller. If parent is NULL, the device, is a top-level device,which is not usually what you want.

p

Holds the private data of the driver core portions of the device.See the comment of thestructdevice_private for detail.

init_name

Initial name of the device.

type

The type of device.This identifies the device type and carries type-specificinformation.

bus

Type of bus device is on.

driver

Which driver has allocated this

platform_data

Platform data specific to the device.

driver_data

Private pointer for driver specific info.

mutex

Mutex to synchronize calls to its driver.

links

Links to suppliers and consumers of this device.

power

For device power management.SeeDevice Power Management Basics for details.

pm_domain

Provide callbacks that are executed during system suspend,hibernation, system resume and during runtime PM transitionsalong with subsystem-level and driver-level callbacks.

em_pd

device’s energy model performance domain

pins

For device pin management.SeePINCTRL (PIN CONTROL) subsystem for details.

msi

MSI related data

dma_ops

DMA mapping operations for this device.

dma_mask

Dma mask (if dma’ble device).

coherent_dma_mask

Like dma_mask, but for alloc_coherent mapping as not allhardware supports 64-bit addresses for consistent allocationssuch descriptors.

bus_dma_limit

Limit of an upstream bridge or bus which imposes a smallerDMA limit than the device itself supports.

dma_range_map

map for DMA memory ranges relative to that of RAM

dma_parms

A low level driver may set these to teach IOMMU code aboutsegment limitations.

dma_pools

Dma pools (if dma’ble device).

dma_mem

Internal for coherent mem override.

cma_area

Contiguous memory area for dma allocations

dma_io_tlb_mem

Software IO TLB allocator. Not for driver use.

dma_io_tlb_pools

List of transient swiotlb memory pools.

dma_io_tlb_lock

Protects changes to the list of active pools.

dma_uses_io_tlb

true if device has used the software IO TLB.

archdata

For arch-specific additions.

of_node

Associated device tree node.

fwnode

Associated device node supplied by platform firmware.

numa_node

NUMA node this device is close to.

devt

For creating the sysfs “dev”.

id

device instance

devres_lock

Spinlock to protect the resource of the device.

devres_head

The resources list of the device.

class

The class of the device.

groups

Optional attribute groups.

release

Callback to free the device after all references havegone away. This should be set by the allocator of thedevice (i.e. the bus driver that discovered the device).

iommu_group

IOMMU group the device belongs to.

iommu

Per device generic IOMMU runtime data

physical_location

Describes physical location of the device connectionpoint in the system housing.

removable

Whether the device can be removed from the system. Thisshould be set by the subsystem / bus driver that discoveredthe device.

offline_disabled

If set, the device is permanently online.

offline

Set after successful invocation of bus type’s .offline().

of_node_reused

Set if the device-tree node is shared with an ancestordevice.

state_synced

The hardware state of this device has been synced to matchthe software state of this device by calling the driver/bussync_state() callback.

can_match

The device has matched with a driver at least once or it is ina bus (like AMBA) which can’t check for matching drivers untilother devices probe successfully.

dma_coherent

this particular device is dma coherent, even if thearchitecture supports non-coherent devices.

dma_ops_bypass

If set totrue then the dma_ops are bypassed for thestreaming DMA operations (->map_* / ->unmap_* / ->sync_*),and optionall (if the coherent mask is large enough) alsofor dma allocations. This flag is managed by the dma opsinstance from ->dma_supported.

dma_skip_sync

DMA sync operations can be skipped for coherent buffers.

dma_iommu

Device is using default IOMMU implementation for DMA anddoesn’t rely on dma_ops structure.

Definition:

struct device_link {    struct device *supplier;    struct list_head s_node;    struct device *consumer;    struct list_head c_node;    struct device link_dev;    enum device_link_state status;    u32 flags;    refcount_t rpm_active;    struct kref kref;    struct work_struct rm_work;    bool supplier_preactivated;};

Members

supplier

The device on the supplier end of the link.

s_node

Hook to the supplier device’s list of links to consumers.

consumer

The device on the consumer end of the link.

c_node

Hook to the consumer device’s list of links to suppliers.

link_dev

device used to expose link details in sysfs

status

The state of the link (with respect to the presence of drivers).

flags

Link flags.

rpm_active

Whether or not the consumer device is runtime-PM-active.

kref

Count repeated addition of the same link.

rm_work

Work structure used for removing the link.

supplier_preactivated

Supplier has been made active before consumer probe.

Parameters

structdevice*dev

Device to perform the check on

Parameters

conststructdevice*dev

Device with name to get.

Return

The kobject name of the device, or its initial name if unavailable.

Parameters

conststructdevice*dev

structdevice to get the bus/class name of

Description

Will return the name of the bus/class the device is attached to. If it isnot attached to a bus/class, an empty string will be returned.

Parameters

structdevice*parent

parentstructdevice

constchar*name

name of the child device

Description

This is similar to thedevice_find_child() function above, but itreturns a reference to a device that has the namename.

NOTE

you will need to drop the reference withput_device() after use.

Parameters

structdevice*parent

parentstructdevice

Description

This is similar to thedevice_find_child() function above, but itreturns a reference to a child device, if any.

NOTE

you will need to drop the reference withput_device() after use.

Parameters

dev

device to modify

key

lock class key data

Description

This must be called with thedevice_lock() already held, for examplefrom driver ->probe(). Take care to only override the defaultlockdep_no_validate class.

Parameters

dev

device to modify

Description

This must be called with thedevice_lock() already held, for examplefrom driver ->remove().

Definition:

struct bus_type {    const char              *name;    const char              *dev_name;    const struct attribute_group **bus_groups;    const struct attribute_group **dev_groups;    const struct attribute_group **drv_groups;    int (*match)(struct device *dev, const struct device_driver *drv);    int (*uevent)(const struct device *dev, struct kobj_uevent_env *env);    int (*probe)(struct device *dev);    void (*sync_state)(struct device *dev);    void (*remove)(struct device *dev);    void (*shutdown)(struct device *dev);    const struct cpumask *(*irq_get_affinity)(struct device *dev, unsigned int irq_vec);    int (*online)(struct device *dev);    int (*offline)(struct device *dev);    int (*suspend)(struct device *dev, pm_message_t state);    int (*resume)(struct device *dev);    int (*num_vf)(struct device *dev);    int (*dma_configure)(struct device *dev);    void (*dma_cleanup)(struct device *dev);    const struct dev_pm_ops *pm;    bool need_parent_lock;};

Members

name

The name of the bus.

dev_name

Used for subsystems to enumerate devices like (“foo``u``”, dev->id).

bus_groups

Default attributes of the bus.

dev_groups

Default attributes of the devices on the bus.

drv_groups

Default attributes of the device drivers on the bus.

match

Called, perhaps multiple times, whenever a new device or driveris added for this bus. It should return a positive value if thegiven device can be handled by the given driver and zerootherwise. It may also return error code if determining thatthe driver supports the device is not possible. In case of-EPROBE_DEFER it will queue the device for deferred probing.

uevent

Called when a device is added, removed, or a few other thingsthat generate uevents to add the environment variables.

probe

Called when a new device or driver add to this bus, and callbackthe specific driver’s probe to initial the matched device.

sync_state

Called to sync device state to software state after all thestate tracking consumers linked to this device (present atthe time of late_initcall) have successfully bound to adriver. If the device has no consumers, this function willbe called at late_initcall_sync level. If the device hasconsumers that are never bound to a driver, this functionwill never get called until they do.

remove

Called when a device removed from this bus.

shutdown

Called at shut-down time to quiesce the device.

irq_get_affinity

Get IRQ affinity mask for the device on this bus.

online

Called to put the device back online (after offlining it).

offline

Called to put the device offline for hot-removal. May fail.

suspend

Called when a device on this bus wants to go to sleep mode.

resume

Called to bring a device on this bus out of sleep mode.

num_vf

Called to find out how many virtual functions a device on thisbus supports.

dma_configure

Called to setup DMA configuration on a device onthis bus.

dma_cleanup

Called to cleanup DMA configuration on a device onthis bus.

pm

Power management operations of this bus, callback the specificdevice driver’s pm-ops.

need_parent_lock

When probing or removing a device on this bus, thedevice core should lock the device’s parent.

Constants

BUS_NOTIFY_ADD_DEVICE

device is added to this bus

BUS_NOTIFY_DEL_DEVICE

device is about to be removed from this bus

BUS_NOTIFY_REMOVED_DEVICE

device is successfully removed from this bus

BUS_NOTIFY_BIND_DRIVER

a driver is about to be bound to this device on this bus

BUS_NOTIFY_BOUND_DRIVER

a driver is successfully bound to this device on this bus

BUS_NOTIFY_UNBIND_DRIVER

a driver is about to be unbound from this device on this bus

BUS_NOTIFY_UNBOUND_DRIVER

a driver is successfully unbound from this device on this bus

BUS_NOTIFY_DRIVER_NOT_BOUND

a driver failed to be bound to this device on this bus

Definition:

struct class {    const char              *name;    const struct attribute_group    **class_groups;    const struct attribute_group    **dev_groups;    int (*dev_uevent)(const struct device *dev, struct kobj_uevent_env *env);    char *(*devnode)(const struct device *dev, umode_t *mode);    void (*class_release)(const struct class *class);    void (*dev_release)(struct device *dev);    int (*shutdown_pre)(struct device *dev);    const struct kobj_ns_type_operations *ns_type;    const void *(*namespace)(const struct device *dev);    void (*get_ownership)(const struct device *dev, kuid_t *uid, kgid_t *gid);    const struct dev_pm_ops *pm;};

Members

name

Name of the class.

class_groups

Default attributes of this class.

dev_groups

Default attributes of the devices that belong to the class.

dev_uevent

Called when a device is added, removed from this class, or afew other things that generate uevents to add the environmentvariables.

devnode

Callback to provide the devtmpfs.

class_release

Called to release this class.

dev_release

Called to release the device.

shutdown_pre

Called at shut-down time before driver shutdown.

ns_type

Callbacks so sysfs can detemine namespaces.

namespace

Namespace of the device belongs to this class.

get_ownership

Allows class to specify uid/gid of the sysfs directoriesfor the devices belonging to the class. Usually tied todevice’s namespace.

pm

The default device power management operations of this class.

Constants

PROBE_DEFAULT_STRATEGY

Used by drivers that work equally wellwhether probed synchronously or asynchronously.

PROBE_PREFER_ASYNCHRONOUS

Drivers for “slow” devices whichprobing order is not essential for booting the system mayopt into executing their probes asynchronously.

PROBE_FORCE_SYNCHRONOUS

Use this to annotate drivers that needtheir probe routines to run synchronously with driver anddevice registration (with the exception of -EPROBE_DEFERhandling - re-probing always ends up being done asynchronously).

Definition:

struct device_driver {    const char              *name;    const struct bus_type   *bus;    struct module           *owner;    const char              *mod_name;    bool suppress_bind_attrs;    enum probe_type probe_type;    const struct of_device_id       *of_match_table;    const struct acpi_device_id     *acpi_match_table;    int (*probe) (struct device *dev);    void (*sync_state)(struct device *dev);    int (*remove) (struct device *dev);    void (*shutdown) (struct device *dev);    int (*suspend) (struct device *dev, pm_message_t state);    int (*resume) (struct device *dev);    const struct attribute_group **groups;    const struct attribute_group **dev_groups;    const struct dev_pm_ops *pm;    void (*coredump) (struct device *dev);    struct driver_private *p;    struct {        void (*post_unbind_rust)(struct device *dev);    } p_cb;};

Members

name

Name of the device driver.

bus

The bus which the device of this driver belongs to.

owner

The module owner.

mod_name

Used for built-in modules.

suppress_bind_attrs

Disables bind/unbind via sysfs.

probe_type

Type of the probe (synchronous or asynchronous) to use.

of_match_table

The open firmware table.

acpi_match_table

The ACPI match table.

probe

Called to query the existence of a specific device,whether this driver can work with it, and bind the driverto a specific device.

sync_state

Called to sync device state to software state after all thestate tracking consumers linked to this device (present atthe time of late_initcall) have successfully bound to adriver. If the device has no consumers, this function willbe called at late_initcall_sync level. If the device hasconsumers that are never bound to a driver, this functionwill never get called until they do.

remove

Called when the device is removed from the system tounbind a device from this driver.

shutdown

Called at shut-down time to quiesce the device.

suspend

Called to put the device to sleep mode. Usually to alow power state.

resume

Called to bring a device from sleep mode.

groups

Default attributes that get created by the driver coreautomatically.

dev_groups

Additional attributes attached to device instance onceit is bound to the driver.

pm

Power management operations of the device which matchedthis driver.

coredump

Called when sysfs entry is written to. The device driveris expected to call the dev_coredump API resulting in auevent.

p

Driver core’s private data, no one other than the drivercore can touch this.

p_cb

Callbacks private to the driver core; no one other than thedriver core is allowed to touch this.

Parameters

void

no arguments

Description

Call the driver model init functions to initialize theirsubsystems. Called early from init/main.c.

Parameters

conststructdevice_driver*drv

the driver we’re iterating

constchar*name

name of the device to match

Parameters

conststructdevice_driver*drv

the driver we’re iterating

conststructdevice_node*np

of_node pointer to match.

Parameters

structdevice_driver*drv

the driver we’re iterating

conststructfwnode_handle*fwnode

fwnode pointer to match.

Parameters

conststructdevice_driver*drv

the driver we’re iterating

dev_tdevt

devt pointer to match.

Parameters

conststructdevice_driver*drv

the driver we’re iterating

conststructacpi_device*adev

ACPI_COMPANION device to match.

Parameters

__driver

driver name

__register

register function for this driver type

__unregister

unregister function for this driver type

...

Additional arguments to be passed to __register and __unregister.

Description

Use this macro to construct bus specific macros for registeringdrivers, and do not use it on its own.

Parameters

__driver

driver name

__register

register function for this driver type

...

Additional arguments to be passed to __register

Description

Use this macro to construct bus specific macros for registeringdrivers, and do not use it on its own.

Parameters

structdevice*dev

Device to change

constchar**override

Address of string to change (e.g.device->driver_override);The contents will be freed and hold newly allocated override.

constchar*s

NUL-terminated string, new driver name to force a match, pass emptystring to clear it (”” or “n”, where the latter is only for sysfsinterface).

size_tlen

length ofs

Description

Helper to set or clear driver override in a device, intended for the caseswhen the driver_override field is allocated by driver/bus code.

Return

0 on success or a negative error code on failure.

Parameters

structdevice_driver*drv

Driver we’re iterating.

structdevice*start

Device to begin with

void*data

Data to pass to the callback.

device_iter_tfn

Function to call for each device.

Description

Iterate over thedrv’s list of devices callingfn for each one.

Parameters

conststructdevice_driver*drv

The device’s driver

structdevice*start

Device to begin with

constvoid*data

Data to pass to match function

device_match_tmatch

Callback function to check device

Description

This is similar to thedriver_for_each_device() function above, butit returns a reference to a device that is ‘found’ for later use, asdetermined by thematch callback.

The callback should return 0 if the device doesn’t match and non-zeroif it does. If the callback returns non-zero, this function willreturn to the caller and not iterate over any more devices.

Parameters

conststructdevice_driver*drv

driver.

conststructdriver_attribute*attr

driver attribute descriptor.

Parameters

conststructdevice_driver*drv

driver.

conststructdriver_attribute*attr

driver attribute descriptor.

Parameters

structdevice_driver*drv

driver to register

Description

We pass off most of the work to thebus_add_driver() call,since most of the things we have to do deal with the busstructures.

Parameters

structdevice_driver*drv

driver.

Description

Again, we pass off most of the work to the bus-level call.

Parameters

void

no arguments

Parameters

structdevice*consumer

Consumer end of the link.

structdevice*supplier

Supplier end of the link.

u32flags

Link flags.

Return

On success, a device_linkstructwill be returned.On error or invalid flag settings, NULL will be returned.

Description

The caller is responsible for the proper synchronization of the link creationwith runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause theruntime PM framework to take the link into account. Second, if theDL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices willbe forced into the active meta state and reference-counted upon the creationof the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will beignored.

If DL_FLAG_STATELESS is set inflags, the caller of this function isexpected to release the link returned by it directly with the help of eitherdevice_link_del() ordevice_link_remove().

If that flag is not set, however, the caller of this function is handing themanagement of the link over to the driver core entirely and its return valuecan only be used to check whether or not the link is present. In that case,the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device linkflags can be used to indicate to the driver core when the link can be safelydeleted. Namely, setting one of them inflags indicates to the driver corethat the link is not going to be used (by the given caller of this function)after unbinding the consumer or supplier driver, respectively, from itsdevice, so the link can be deleted at that point. If none of them is set,the link will be maintained until one of the devices pointed to by it (eitherthe consumer or the supplier) is unregistered.

Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER andDL_FLAG_AUTOREMOVE_SUPPLIER are not set inflags (that is, a persistentmanaged device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag canbe used to request the driver core to automatically probe for a consumerdriver after successfully binding a driver to the supplier device.

The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER,DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set inflags atthe same time is invalid and will cause NULL to be returned upfront.However, if a device link between the givenconsumer andsupplier pairexists already when this function is called for them, the existing link willbe returned regardless of its current type and status (the link’s flags maybe modified then). The caller of this function is then expected to treatthe link as though it has just been created, so (in particular) ifDL_FLAG_STATELESS was passed inflags, the link needs to be releasedexplicitly when not needed any more (as stated above).

A side effect of the link creation is re-ordering of dpm_list and thedevices_kset list by moving the consumer device and all devices dependingon it to the ends of these lists (that does not happen to devices that havenot been registered when this function is called).

The supplier device is required to be registered when this function is calledand NULL will be returned if that is not the case. The consumer device neednot be registered, however.

Parameters

structdevice_link*link

Device link to delete.

Description

The caller must ensure proper synchronization of this function with runtimePM. If the link was added multiple times, it needs to be deleted as often.Care is required for hotplugged devices: Their links are purged on removaland callingdevice_link_del() is then no longer allowed.

Parameters

void*consumer

Consumer end of the link.

structdevice*supplier

Supplier end of the link.

Description

The caller must ensure proper synchronization of this function with runtimePM.

Parameters

conststructdevice*dev

structdevice to get the name of

Description

Will return the device’s driver’s name if it is bound to a device. Ifthe device is not bound to a driver, it will return the name of the busit is attached to. If it is not attached to a bus either, an emptystring will be returned.

Parameters

structdevice*dev

The device to create the group for

conststructattribute_group*grp

The attribute group to create

Description

This function creates a group for the first time. It will explicitlywarn and error if any of the attribute files being created already exist.

Returns 0 on success or error code on failure.

Parameters

structdevice*dev

device.

conststructdevice_attribute*attr

device attribute descriptor.

Parameters

structdevice*dev

device.

conststructdevice_attribute*attr

device attribute descriptor.

Parameters

structdevice*dev

device.

conststructdevice_attribute*attr

device attribute descriptor.

Description

Seekernfs_remove_self() for details.

Parameters

structdevice*dev

device.

conststructbin_attribute*attr

device binary attribute descriptor.

Parameters

structdevice*dev

device.

conststructbin_attribute*attr

device binary attribute descriptor.

Parameters

structdevice*dev

device.

Description

This prepares the device for use by other layers by initializingits fields.It is the first half ofdevice_register(), if called bythat function, though it can also be called separately, so onemay usedev’s fields. In particular,get_device()/put_device()may be used for reference counting ofdev after calling thisfunction.

All fields indev must be initialized by the caller to 0, exceptfor those explicitly set to some other value. The simplestapproach is to usekzalloc() to allocate the structure containingdev.

NOTE

Useput_device() to give up your reference instead of freeingdev directly once you have called this function.

Parameters

structdevice*dev

device

constchar*fmt

format string for the device’s name

...

variable arguments

Parameters

structdevice*dev

device.

Description

This is part 2 ofdevice_register(), though may be calledseparately _iff_device_initialize() has been called separately.

This addsdev to the kobject hierarchy viakobject_add(), adds itto the global and sibling lists for the device, thenadds it to the other relevant subsystems of the driver model.

Do not call this routine ordevice_register() more than once forany device structure. The driver model core is not designed to workwith devices that get unregistered and then spring back to life.(Among other things, it’s very hard to guarantee that all referencesto the previous incarnation ofdev have been dropped.) Allocateand register a fresh newstructdevice instead.

NOTE

_Never_ directly freedev after calling this function, evenif it returned an error! Always useput_device() to give up yourreference instead.

Rule of thumb is: ifdevice_add() succeeds, you should calldevice_del() when you want to get rid of it. Ifdevice_add() hasnot succeeded, useonlyput_device() to drop the referencecount.

Parameters

structdevice*dev

pointer to the device structure

Description

This happens in two clean steps - initialize the deviceand add it to the system. The two steps can be calledseparately, but this is the easiest and most common.I.e. you should only call the two helpers separately ifhave a clearly defined need to use and refcount the devicebefore it is added to the hierarchy.

For more information, see the kerneldoc fordevice_initialize()anddevice_add().

NOTE

_Never_ directly freedev after calling this function, evenif it returned an error! Always useput_device() to give up thereference initialized in this function instead.

Parameters

structdevice*dev

device.

Description

This simply forwards the call tokobject_get(), thoughwe do take care to provide for the case that we get a NULLpointer passed in.

Parameters

structdevice*dev

device in question.

Parameters

structdevice*dev

device.

Description

This is the first part of the device unregistrationsequence. This removes the device from the lists we controlfrom here, has it removed from the other driver modelsubsystems it was added to indevice_add(), and removes itfrom the kobject hierarchy.

NOTE

this should be called manually _iff_device_add() wasalso called manually.

Parameters

structdevice*dev

device going away.

Description

We do this in two parts, like we dodevice_register(). First,we remove it from all the subsystems withdevice_del(), thenwe decrement the reference count viaput_device(). If thatis the final reference count, the device will be cleaned upviadevice_release() above. Otherwise, the structure willstick around until the final reference to the device is dropped.

Parameters

structdevice*parent

parentstructdevice.

void*data

data for the callback.

device_iter_tfn

function to be called for each device.

Description

Iterate overparent’s child devices, and callfn for each,passing itdata.

We check the return offn each time. If it returns anythingother than 0, we break out and return that value.

Parameters

structdevice*parent

parentstructdevice.

void*data

data for the callback.

device_iter_tfn

function to be called for each device.

Description

Iterate overparent’s child devices, and callfn for each,passing itdata.

We check the return offn each time. If it returns anythingother than 0, we break out and return that value.

Parameters

structdevice*parent

parentstructdevice.

structdevice*from

optional starting point in child list

void*data

data for the callback.

device_iter_tfn

function to be called for each device.

Description

Iterate overparent’s child devices, starting atfrom, and callfnfor each, passing itdata. This helper is identical todevice_for_each_child_reverse() whenfrom is NULL.

fn is checked each iteration. If it returns anything other than 0,iteration stop and that value is returned to the caller ofdevice_for_each_child_reverse_from();

Parameters

structdevice*parent

parentstructdevice

constvoid*data

Data to pass to match function

device_match_tmatch

Callback function to check device

Description

This is similar to thedevice_for_each_child() function above, but itreturns a reference to a device that is ‘found’ for later use, asdetermined by thematch callback.

The callback should return 0 if the device doesn’t match and non-zeroif it does. If the callback returns non-zero and a reference to thecurrent device can be obtained, this function will return to the callerand not iterate over any more devices.

NOTE

you will need to drop the reference withput_device() after use.

Parameters

constchar*name

root device name

structmodule*owner

owner module of the root device, usually THIS_MODULE

Description

This function allocates a root device and registers itusingdevice_register(). In order to free the returneddevice, useroot_device_unregister().

Root devices are dummy devices which allow other devicesto be grouped under /sys/devices. Use this function toallocate a root device and then use it as the parent ofany device which should appear under /sys/devices/{name}

The /sys/devices/{name} directory will also contain a‘module’ symlink which points to theowner directoryin sysfs.

Returnsstructdevice pointer on success, orERR_PTR() on error.

Note

You probably want to useroot_device_register().

Parameters

structdevice*dev

device going away

Description

This function unregisters and cleans up a device that was created byroot_device_register().

Parameters

conststructclass*class

pointer to thestructclass that this device should be registered to

structdevice*parent

pointer to the parentstructdevice of this new device, if any

dev_tdevt

the dev_t for the char device to be added

void*drvdata

the data to be added to the device for callbacks

constchar*fmt

string for the device’s name

...

variable arguments

Description

This function can be used by char device classes. Astructdevicewill be created in sysfs, registered to the specified class.

A “dev” file will be created, showing the dev_t for the device, ifthe dev_t is not 0,0.If a pointer to a parentstructdevice is passed in, the newly createdstructdevice will be a child of that device in sysfs.The pointer to thestructdevice will be returned from the call.Any further sysfs files that might be required can be created using thispointer.

Returnsstructdevice pointer on success, orERR_PTR() on error.

Parameters

conststructclass*class

pointer to thestructclass that this device should be registered to

structdevice*parent

pointer to the parentstructdevice of this new device, if any

dev_tdevt

the dev_t for the char device to be added

void*drvdata

the data to be added to the device for callbacks

conststructattribute_group**groups

NULL-terminated list of attribute groups to be created

constchar*fmt

string for the device’s name

...

variable arguments

Description

This function can be used by char device classes. Astructdevicewill be created in sysfs, registered to the specified class.Additional attributes specified in the groups parameter will alsobe created automatically.

A “dev” file will be created, showing the dev_t for the device, ifthe dev_t is not 0,0.If a pointer to a parentstructdevice is passed in, the newly createdstructdevice will be a child of that device in sysfs.The pointer to thestructdevice will be returned from the call.Any further sysfs files that might be required can be created using thispointer.

Returnsstructdevice pointer on success, orERR_PTR() on error.

Parameters

conststructclass*class

pointer to thestructclass that this device was registered with

dev_tdevt

the dev_t of the device that was previously registered

Description

This call unregisters and cleans up a device that was created with acall todevice_create().

Parameters

structdevice*dev

the pointer to thestructdevice to be renamed

constchar*new_name

the new name of the device

Description

It is the responsibility of the caller to provide mutualexclusion between two different calls of device_renameon the same device to ensure that new_name is valid andwon’t conflict with other devices.

Note

given that some subsystems (networking and infiniband) use thisfunction, with no immediate plans for this to change, we cannot assume orrequire that this function not be called at all.

However, if you’re writing new code, do not call this function. The followingtext from Kay Sievers offers some insight:

Renaming devices is racy at many levels, symlinks and other stuff are notreplaced atomically, and you get a “move” uevent, but it’s not easy toconnect the event to the old and new device. Device nodes are not renamed atall, there isn’t even support for that in the kernel now.

In the meantime, during renaming, your target name might be taken by anotherdriver, creating conflicts. Or the old name is taken directly after yourenamed it -- then you get events for the same DEVPATH, before you even seethe “move” event. It’s just a mess, and nothing new should ever rely onkernel device renaming. Besides that, it’s not even implemented now forother things than (driver-core wise very simple) network devices.

Make up a “real” name in the driver before you register anything, or addsome other attributes for userspace to find the device, or use udev to addsymlinks -- but never rename kernel devices later, it’s a complete mess. Wedon’t even want to get into that and try to implement the missing pieces inthe core. We really have other pieces to fix in the driver core mess. :)

Parameters

structdevice*dev

the pointer to thestructdevice to be moved

structdevice*new_parent

the new parent of the device (can be NULL)

enumdpm_orderdpm_order

how to reorder the dpm_list

Parameters

structdevice*dev

device.

kuid_tkuid

new owner’s kuid

kgid_tkgid

new owner’s kgid

Description

This changes the owner ofdev and its corresponding sysfs entries tokuid/kgid. This function closely mirrors howdev was added via drivercore.

Returns 0 on success or error code on failure.

Parameters

conststructdevice*dev

the pointer to thestructdevice

interr

error value to test

constchar*fmt

printf-style format string

...

arguments as specified in the format string

Description

This helper implements common pattern present in probe functions for errorchecking: print debug or error message depending if the error value is-EPROBE_DEFER and propagate error upwards.In case of -EPROBE_DEFER it sets also defer probe reason, which can bechecked later by reading devices_deferred debugfs attribute.It replaces the following code sequence:

if (err != -EPROBE_DEFER)        dev_err(dev, ...);else        dev_dbg(dev, ...);return err;

with:

return dev_err_probe(dev, err, ...);

Using this helper in your probe function is totally fine even iferris known to never be -EPROBE_DEFER.The benefit compared to a normaldev_err() is the standardized formatof the error code, which is emitted symbolically (i.e. you get “EAGAIN”instead of “-35”), and having the error code returned allows morecompact error paths.

Returnserr.

Parameters

conststructdevice*dev

the pointer to thestructdevice

interr

error value to test

constchar*fmt

printf-style format string

...

arguments as specified in the format string

Description

This helper implements common pattern present in probe functions for errorchecking: print debug or warning message depending if the error value is-EPROBE_DEFER and propagate error upwards.In case of -EPROBE_DEFER it sets also defer probe reason, which can bechecked later by reading devices_deferred debugfs attribute.It replaces the following code sequence:

if (err != -EPROBE_DEFER)        dev_warn(dev, ...);else        dev_dbg(dev, ...);return err;

with:

return dev_warn_probe(dev, err, ...);

Using this helper in your probe function is totally fine even iferris known to never be -EPROBE_DEFER.The benefit compared to a normaldev_warn() is the standardized formatof the error code, which is emitted symbolically (i.e. you get “EAGAIN”instead of “-35”), and having the error code returned allows morecompact error paths.

Returnserr.

Parameters

structdevice*dev

Device to handle.

structfwnode_handle*fwnode

New primary firmware node of the device.

Description

Set the device’s firmware node pointer tofwnode, but if a secondaryfirmware node of the device is present, preserve it.

Valid fwnode cases are:

• primary --> secondary --> -ENODEV

• primary --> NULL

• secondary --> -ENODEV

• NULL

Parameters

structdevice*dev

Device to handle.

structfwnode_handle*fwnode

New secondary firmware node of the device.

Description

If a primary firmware node of the device is present, set its secondarypointer tofwnode. Otherwise, set the device’s firmware node pointer tofwnode.

Parameters

structdevice*dev

device whose device tree node is being removed

Parameters

structdevice*dev

device whose device tree node is being added

structdevice_node*of_node

of_node to add

Return

0 on success or error code on failure.

Parameters

structdevice*dev

device whose device-tree node is being set

conststructdevice*dev2

device whose device-tree node is being reused

Description

Takes another reference to the new device-tree node after first droppingany reference held to the old node.

Parameters

structfwnode_handle*fwnode

The pointer to thestructfwnode_handle to obtain thestructdevicereference count of.

Description

This function obtains a reference count of the device the device pointerembedded in thestructfwnode_handle points to.

Note that thestructdevice pointer embedded instructfwnode_handle doesnot have a reference count of thestructdevice itself.

Hence, it is a UAF (and thus a bug) to call this function if the caller can’tguarantee that the last reference count of the correspondingstructdevice isnot dropped concurrently.

This is possible sincestructfwnode_handle has its own reference count andhence can out-live thestructdevice it is associated with.

Parameters

structsyscore*syscore

System core operations to register.

Parameters

structsyscore*syscore

System core operations to unregister.

Parameters

void

no arguments

Description

This function is executed with one CPU on-line and disabled interrupts.

Parameters

void

no arguments

Description

This function is executed with one CPU on-line and disabled interrupts.

Parameters

conststructclass*class

class type

constchar*name

name of the device to match

Parameters

conststructclass*class

class type

conststructdevice_node*np

of_node of the device to match.

Parameters

conststructclass*class

class type

conststructfwnode_handle*fwnode

fwnode of the device to match.

Parameters

conststructclass*class

class type

dev_tdevt

device type of the device to match.

Parameters

conststructclass*class

class type

conststructacpi_device*adev

ACPI_COMPANION device to match.

Parameters

constchar*name

pointer to a string for the name of this class.

Description

This is used to create astructclass pointer that can then be usedin calls todevice_create().

Returnsstructclass pointer on success, orERR_PTR() on error.

Note, the pointer created here is to be destroyed when finished bymaking a call toclass_destroy().

Parameters

conststructclass*cls

pointer to thestructclass that is to be destroyed

Description

Note, the pointer to be destroyed must have been created with a calltoclass_create().

Parameters

structclass_dev_iter*iter

class iterator to initialize

conststructclass*class

the class we wanna iterate over

conststructdevice*start

the device to start iterating from, if any

conststructdevice_type*type

device_type of the devices to iterate over, NULL for all

Description

Initialize class iteratoriter such that it iterates over devicesofclass. Ifstart is set, the list iteration will start there,otherwise if it is NULL, the iteration starts at the beginning ofthe list.

Parameters

structclass_dev_iter*iter

class iterator to proceed

Description

Proceediter to the next device and return it. Returns NULL ifiteration is complete.

The returned device is referenced and won’t be released tilliterator is proceed to the next device or exited. The caller isfree to do whatever it wants to do with the device includingcalling back into class code.

Parameters

structclass_dev_iter*iter

class iterator to finish

Description

Finish an iteration. Always call this function after iteration iscomplete whether the iteration ran till the end or not.

Parameters

conststructclass*class

the class we’re iterating

conststructdevice*start

the device to start with in the list, if any.

void*data

data for the callback

device_iter_tfn

function to be called for each device

Description

Iterate overclass’s list of devices, and callfn for each,passing itdata. Ifstart is set, the list iteration will startthere, otherwise if it is NULL, the iteration starts at thebeginning of the list.

We check the return offn each time. If it returns anythingother than 0, we break out and return that value.

fn is allowed to do anything including calling back into classcode. There’s no locking restriction.

Parameters

conststructclass*class

the class we’re iterating

conststructdevice*start

Device to begin with

constvoid*data

data for the match function

device_match_tmatch

function to check device

Description

This is similar to theclass_for_each_dev() function above, but itreturns a reference to a device that is ‘found’ for later use, asdetermined by thematch callback.

The callback should return 0 if the device doesn’t match and non-zeroif it does. If the callback returns non-zero, this function willreturn to the caller and not iterate over any more devices.

Note, you will need to drop the reference withput_device() after use.

match is allowed to do anything including calling back into classcode. There’s no locking restriction.

Parameters

constchar*name

the name of the class

Description

Compatibility class are meant as a temporary user-space compatibilityworkaround when converting a family of class devices to a bus devices.

Parameters

structclass_compat*cls

the class to unregister

Parameters

structclass_compat*cls

the compatibility class

structdevice*dev

the target bus device

Parameters

structclass_compat*cls

the compatibility class

structdevice*dev

the target bus device

Parameters

conststructclass*class

the class to check

Description

Returns a boolean to state if the class is registered in the driver coreor not. Note that the value could switch right after this call is made,so only use this in places where you “know” it is safe to do so (usuallyto determine if the specific class has been registered yet or not).

Be careful in using this.

Definition:

struct faux_device {    struct device dev;};

Members

dev

internalstructdevice of the object

Definition:

struct faux_device_ops {    int (*probe)(struct faux_device *faux_dev);    void (*remove)(struct faux_device *faux_dev);};

Members

probe

called when a faux device is probed by the driver corebefore the device is fully bound to the internal faux buscode. If probe succeeds, return 0, otherwise return anegative error number to stop the probe sequence fromsucceeding.

remove

called when a faux device is removed from the system

Parameters

constchar*name

The name of the device we are adding, must be unique forall faux devices.

structdevice*parent

Pointer to a potential parentstructdevice. If set toNULL, the device will be created in the “root” of the fauxdevice tree in sysfs.

conststructfaux_device_ops*faux_ops

structfaux_device_ops that the new device will call backinto, can be NULL.

conststructattribute_group**groups

The set of sysfs attributes that will be created for thisdevice when it is registered with the driver core.

Description

Create a new faux device and register it in the driver core properly.If present, callbacks infaux_ops will be called with the device thatfor the caller to do something with at the proper time given thedevice’s lifecycle.

Note, when this function is called, the functions specified instructfaux_ops can be called before the function returns, so be prepared foreverything to be properly initialized before that point in time. If theprobe callback (if one is present) does NOT succeed, the creation of thedevice will fail and NULL will be returned.

Return

• NULL if an error happened with creating the device

• pointer to a validstructfaux_device that is registered with sysfs

Parameters

constchar*name

The name of the device we are adding, must be unique for allfaux devices.

structdevice*parent

Pointer to a potential parentstructdevice. If set toNULL, the device will be created in the “root” of the fauxdevice tree in sysfs.

conststructfaux_device_ops*faux_ops

structfaux_device_ops that the new device will call backinto, can be NULL.

Description

Create a new faux device and register it in the driver core properly.If present, callbacks infaux_ops will be called with the device thatfor the caller to do something with at the proper time given thedevice’s lifecycle.

Note, when this function is called, the functions specified instructfaux_ops can be called before the function returns, so be prepared foreverything to be properly initialized before that point in time.

Return

• NULL if an error happened with creating the device

• pointer to a validstructfaux_device that is registered with sysfs

Parameters

structfaux_device*faux_dev

faux device to destroy

Description

Unregisters and cleans up a device that was created with a call tofaux_device_create()

Definition:

struct node_access_nodes {    struct device           dev;    struct list_head        list_node;    unsigned int            access;#ifdef CONFIG_HMEM_REPORTING;    struct access_coordinate        coord;#endif;};

Members

dev

Device for this memory access class

list_node

List element in the node’s access list

access

The access class rank

coord

Heterogeneous memory performance coordinates

Definition:

struct node_cache_info {    struct device dev;    struct list_head node;    struct node_cache_attrs cache_attrs;};

Members

dev

Device represeting the cache level

node

List element for tracking in the node

cache_attrs

Attributes for this cache level

Parameters

unsignedintnid

Node identifier that has new cache attributes

structnode_cache_attrs*cache_attrs

Attributes for the cache being added

Parameters

unsignedintmem_nid

Memory node number

unsignedintcpu_nid

Cpu node number

enumaccess_coordinate_classaccess

Access class to register

Description

For use with platforms that may have separate memory and compute nodes.This function will export node relationships linking which memoryinitiator nodes can access memory targets at a given ranked accessclass.

Parameters

intnid

Node number to use when creating the device.

Return

0 on success, -errno otherwise

Parameters

intnid

nid of the node going away

Description

Unregisters the node device at node idnid. All the devices on thenode must be unregistered before calling this function.

Parameters

structtransport_class*tclass

a pointer to the transport class structure to be initialised

Description

The transport class contains an embedded class which is used toidentify it. The caller should initialise this structure withzeros and then generic class must have been initialised with theactual transport class unique name. There’s a macroDECLARE_TRANSPORT_CLASS() to do this (declared classes still mustbe registered).

Returns 0 on success or error on failure.

Parameters

structtransport_class*tclass

The transport class to unregister

Description

Must be called prior to deallocating the memory for the transportclass.

Parameters

structanon_transport_class*atc

The anon transport class to register

Description

The anonymous transport class contains both a transport class and acontainer. The idea of an anonymous class is that it neveractually has any device attributes associated with it (and thussaves on container storage). So it can only be used for triggeringevents. Use prezero and then useDECLARE_ANON_TRANSPORT_CLASS() toinitialise the anon transport class storage.

Parameters

structanon_transport_class*atc

Pointer to the anon transport class to unregister

Description

Must be called prior to deallocating the memory for the anontransport class.

Parameters

structdevice*dev

the generic device representing the entity being added

Description

Usually, dev represents some component in the HBA system (eitherthe HBA itself or a device remote across the HBA bus). Thisroutine is simply a trigger point to see if any set of transportclasses wishes to associate with the added device. This allocatesstorage for the class device and initialises it, but does not yetadd it to the system or add attributes to it (you do this withtransport_add_device). If you have no need for a separate setupand add operations, use transport_register_device (seetransport_class.h).

Parameters

structdevice*dev

the generic device representing the entity being added

Description

Usually, dev represents some component in the HBA system (eitherthe HBA itself or a device remote across the HBA bus). Thisroutine is simply a trigger point used to add the device to thesystem and register attributes for it.

Parameters

structdevice*dev

generic device representing device to be configured

Description

The idea of configure is simply to provide a point within the setupprocess to allow the transport class to extract information from adevice after it has been setup. This is used in SCSI because wehave to have a setup device to begin using the HBA, but after wesend the initial inquiry, we use configure to extract the deviceparameters. The device need not have been added to be configured.

Parameters

structdevice*dev

generic device to remove

Description

This call removes the visibility of the device (to the user fromsysfs), but does not destroy it. To eliminate a device entirelyyou must also call transport_destroy_device. If you don’t need todo remove and destroy as separate operations, usetransport_unregister_device() (see transport_class.h) which willperform both calls for you.

Parameters

structdevice*dev

device to eliminate from the transport class.

Description

This call triggers the elimination of storage associated with thetransport classdev. Note: all it really does is relinquish areference to the classdev. The memory will not be freed until thelast reference goes to zero. Note also that the classdev retains areference count on dev, so dev too will remain for as long as thetransport class device remains around.

Parameters

structdevice*dev

device to check

Return

• -ENODEV if initcalls have completed and modules are disabled.

• -ETIMEDOUT if the deferred probe timeout was set and has expiredand modules are enabled.

• -EPROBE_DEFER in other cases.

Description

Drivers or subsystems can opt-in to calling this function instead of directlyreturning -EPROBE_DEFER.

Parameters

structdevice*dev

device to check

Description

Returns true if passed device has already finished probing successfullyagainst a driver.

This function must be called with the device lock held.

Parameters

structdevice*dev

device.

Description

Allow manual attachment of a driver to a device.Caller must have already setdev->driver.

Note that this does not modify the bus reference count.Please verify that is accounted for before calling this.(It is ok to call with no other effort from a driver’sprobe() method.)

This function must be called with the device lock held.

Callers should prefer to usedevice_driver_attach() instead.