Dec 04, 2010 Details: The device, Photosmart Plus B209a-m, is disabled. If this device is no longer used it may be intentionally disabled. The Plug and Play ID for this device is ROOT MULTIFUNCTION 0000. Determine if you need the device. If you need the device, enable it in Device Manager. If you do not use the device it can be left. Most of the multi-uard designs I've encountered (especially from Altera) require a bus driver and a modified serial.sys to handle the interrupts. Unless the device is a true multi-function device i.e. 8 interrupts one for each UART you are going to have to do something like this.

-->

If a multifunction PCI device conforms completely to the PCI multifunction standard, the PCI bus driver enumerates the individual functions. The PCI bus driver manages the fact that there is more than one function residing at a single device location. To the rest of the system, the individual functions operate like independent devices.

Vendors of a PCI multifunction device on an NT-based platform must do the following:

• Ensure that the device conforms to the PCI multifunction specification.

• Provide a PnP function driver for each function of the device.

  Since the system-supplied bus driver handles the multifunction semantics, the function drivers can be the same drivers that would be used if the functions were packaged as individual devices.

• Provide an INF file for each function of the device.

  The INF files can be the same files that would be used if the functions were packaged as a individual devices. The INF files do not need any special multifunction semantics.

For example, the following figure shows the sample device stacks that might be created for a multifunction PCI device with ISDN and modem functions.

As shown in the previous figure, rather than enumerating one multifunction device, the PCI driver enumerates two child devices. The PnP manager treats each child device like a typical device, locating INF files, loading the appropriate drivers, calling their AddDevice routines, and so forth until a device stack is created for each device. The PCI driver arbitrates the resources for the child devices and manages any other multifunction aspects of the device. The vendor of the multifunction card provides function drivers and INFs for the ISDN and modem devices, just as if they were separate devices.

The illustration focuses on the function driver and bus driver for each function and their associated FDO and PDO. Any filter drivers (and filter DOs) are omitted for simplicity.

LWN.net needs you! Without subscribers, LWN would simply not exist. Please consider signing up for a subscription and helping to keep LWN publishing

December 17, 2020

This article was contributed by Marta Rybczyńska

Device drivers usually live within a single kernel subsystem. Sometimes,however, developers need to handle functionalities outside of this model.Consider, for example, a network interface card (NIC) exposing both Ethernet andRDMA functionalities. There is one hardware block, but two drivers for thetwo functions. Those drivers need to work within their respectivesubsystems, but they must also share access to the same hardware. There isno standard way in current kernels to connect those drivers together, sodevelopers invent ad-hoc methods to handle the interaction betweenthem. Recently, Dave Ertman posteda patch set introducing a new type of a bus, called the 'auxiliary bus', toaddress this problem.

Complex devices

Linux already includes a number of drivers for multi-functiondevices. One of the ways to support them is the Multi-FunctionDevices (MFD) subsystem. It handles independent devices 'glued'together into one hardware block which may contain some sharedresources. MFD allows access to device registers either directly, or usinga common bus. In this second case, it conveniently multiplexes accesses onInter-Integrated Circuit(I2C) or SerialPeripheral Interface (SPI) buses. As the MFD sub-devices are separate,MFD drivers do not share a common state.

The devices Ertman addresses do not fit well into the MFD model.Devices using the auxiliary bus provide subsets of the capabilities of asingle hardware device. They do not expose separate register sets for eachfunction; thus they cannot be described by devicetrees or discovered byACPI. Their drivers need to share access to the hardware. Events concerning allsub-functionalities (like power management) need to be properly handled byall drivers. These devices will often be specialized processors runningfirmware and communicating with the host system (and the Linux drivers) bymessaging. The available functions may not be known in advance, and thusmust be discovered at run time.

The documentationpatch in the auxiliary bus series cites a number of examples. The SoundOpen Firmware (SOF) driver interacts with a single device exposinginterfaces like HDMI output, microphones, speakers, testing, and debughooks. NICs implementing both Ethernet and RDMA may need a driversupporting a common part of the functionalities, and then the specificEthernet and RDMA drivers can implement specific parts on top of that.

Current kernels do not have a generic way to describe dependenciesbetween drivers for this kind of device. A solution to the problem could beto have a way to attach secondary drivers to the primaryone; this is exactly what the auxiliary bus implements.

Auxiliary devices and drivers

The patch set introduces two main concepts: The 'auxiliary device' and'auxiliary driver'. These implement the relationship between the main andthe secondary drivers. The main driver maintains the device state, allocating and managing all shared data. It also unregisters all secondarydrivers when shutting down. Secondary drivers, instead, handle theinteractions with the specific subsystem they are implementing a devicefor.

Each main driver may expose a number of functionalities (devices) forsecondary drivers. Only one secondary driver can attach to each of thosefunctionalities.

The main driver creates an auxiliary device, represented by structauxiliary_device:

The combination of name and id must be unique; thecomplete device name is a combination of the module name and those twofields, connected by dots (.). That yields a result likemodname.device_name.id.

The developer embeds this structure in the device structure ofthe main driver, with all shared data necessary for the communicationbetween the main driver and secondary drivers. They may also addsupplementary callbacks.

The sequence to initialize the main driver contains two steps. The firstone is to call auxiliary_device_init():

It verifies the arguments and returns anerror code if need be; in such case the initialization of the deviceshould be aborted.If the first call succeeds, the second step is to call the macroauxiliary_device_add() with the initialized device; this willset up the device name and register the deviceitself.

The unregistration procedure also has two steps, consisting of calls toauxiliary_device_uninit() (necessary from the point whenauxiliary_device_init() has succeeded) andauxiliary_device_delete(). Those functions have the followingprototypes:

This two-step approach was implemented inresponse to comments on earlier versions of the patch set. It allows the driver to allocate itsown data between auxiliary_device_init() andauxiliary_device_add() with a possibility to free it correctly inthe case of a failure.

The secondary devices, which will connect to the main driver,are represented by struct auxiliary_driver:

This structure includes a number of callbacks to manage thedevice's life cycle, and the id_table containing names of thedevices the driver can bind with. All callbacks receive pointers to theparent's auxiliary_device, allowing access to the shareddata.

The secondary devices are set up with auxiliary_driver_register():

This function requires the probe() callback and theid_table to be filled in. When successful, it causes aprobe() callback call for any matching devices. The secondarydevices can access the shared data using container_of() and theauxiliary_device structure.

When unregistering a driver, the developer should callauxiliary_driver_unregister():

First users

Together with the auxiliary bus implementation, Ertman postedchanges to the SOF driver. The modified driver uses thisinfrastructure to implementa test driver, and aprobes driver, allowing the creation of a new virtual audio device thatcan tap into the pipeline and allow listening in at any point.

Drivers Lecroy Multifunction Devices Software

Another user can be found in the networking subsystem; Leon Romanovskyposteda conversion of the mlx5 driver to use the auxiliary bus. The updateddriver creates network, VDPA, and RDMAdrivers for one physical device. Those changes allowthe removal of a bunch of custom driver code. Parav Pandit followed upby using this functionality to implement device sub-functions.

The patch set has come to its fourth iteration in its current form, andwitnessed a number of earlier ones under the names of ancillaryand virtualbus.The development of the auxiliary bus patch set took time, and it createddependencies in other work. This caused a fair amount of pressure to get itupstream, and that led to some pushing on thelist. In an attempt to push things forward, Dan Williams repostedthe patch set, stating that 'it looks good to me and several otherstakeholders'. After a review from GregKroah-Hartman, the auxiliary bus code was merged into the mainline for the5.11 kernel release.

Drivers Lecroy Multifunction Devices Manual

Index entries for this article
Kernel	Auxiliary bus
Kernel	Device drivers/Support APIs
GuestArticles	Rybczynska, Marta

(Log in to post comments)