There are the following functions to configure USB Module:

Before an USB host controller driver can use the USB Module it must register itself. Of course it must deregister itself if it wants to stop. One registration must be done for each USB. This means that the same USB host controller driver can control multiple USB controllers but it must register itself one time for each of USB controllers to the USB Module.

Devices

Due to USB concept connection of devices to the USB can be detected only by scanning the USB-Hubs. For USB-Hubs are a special kind of devices there is a special module to handle them. This module makes usage of device registration and deregistration functions of the USB module. It also usage the transfer functions of the USB module.

USB concept allows to select a configuration of a device by the programs on the host. A configuration is not only a single value but may change the behaviour of a device completely! It determines the interfaces which can used. The interfaces can be set to different choices which will determine the endpoints which can be used.

Device Constants

References

USB Module is keeping internal data structures and will pass pointers to this structures as results of many functions. In a lot of cases a program must only keep this pointers for the next function call. But there are some situations where a program can use the structures itself. However a lot of programs may access the same data structures parallel or may call functions which affects data structures used by other programs. USB Module is managing access to this structures internally by using semaphores and the programs must not worry about that. There is an ugly case which will cause trouble to the programs. This is the dropping of structures. Most structures are allocated dynamically from memory. If now a program calls a function which drops a structure which is used by another program, this other program would crash because its structure pointer is invalid but it is not knowing about this. Therefore a special concept has been implemented which grants that a structure will be only dropped after all programs which have been using it, had agreed that it can be dropped.

Therefore it is registered how many programs or other data structures are helding pointers to this structure. A structure may be marked as going dropped and every program which tries to access this structure is informed about this fact, but the pointer to the structure is still valid until the last program removes its pointer to this structure.

Normally this deregistration is done automatically inside some functions. There is an according remark inside the description of the functions. But there are some situations where a program must do the deregistration itself.

It is important to deregister references to structures which are no longer used, because this memory will be blocked for other applications. In worst case if a program forgots the deregistration of a reference memory will be kept until reset of computer.

Note that reference handling is an ugly part inside programming. If dropping a reference to early or assuming that a reference is still valid but in fact it has been automatically or manually deregistered nay cause a program crashing. If you are keeping to much references on a structure it will block unused memory. Therefore check carefully wether you have registered a reference for every structure you are using inside your programs and how the functions of the USB-Module will handle the reference.