1/*
2 * Copyright 2003-2006, Haiku Inc. All rights reserved.
3 * Distributed under the terms of the MIT License.
4 *
5 * Authors:
6 *		Michael Lotz <mmlr@mlotz.ch>
7 *		Niels S. Reedijk
8 */
9#ifndef _USB_PRIVATE_H
10#define _USB_PRIVATE_H
11
12
13#include <device_manager.h>
14#include <bus/USB.h>
15
16#include "usbspec_private.h"
17#include <lock.h>
18#include <util/Vector.h>
19
20// include vm.h before iovec_support.h for generic_memcpy, which is used by the bus drivers.
21#include <vm/vm.h>
22#include <util/iovec_support.h>
23
24
25#define TRACE_OUTPUT(x, y, z...) \
26	{ \
27		dprintf("usb %s%s %" B_PRId32 ": ", y, (x)->TypeName(), (x)->USBID()); \
28		dprintf(z); \
29	}
30
31//#define TRACE_USB
32#ifdef TRACE_USB
33#define TRACE(x...)					TRACE_OUTPUT(this, "", x)
34#define TRACE_STATIC(x, y...)		TRACE_OUTPUT(x, "", y)
35#define TRACE_MODULE(x...)			dprintf("usb " USB_MODULE_NAME ": " x)
36#else
37#define TRACE(x...)					/* nothing */
38#define TRACE_STATIC(x, y...)		/* nothing */
39#define TRACE_MODULE(x...)			/* nothing */
40#endif
41
42#define TRACE_ALWAYS(x...)			TRACE_OUTPUT(this, "", x)
43#define TRACE_ERROR(x...)			TRACE_OUTPUT(this, "error ", x)
44#define TRACE_MODULE_ALWAYS(x...)	dprintf("usb " USB_MODULE_NAME ": " x)
45#define TRACE_MODULE_ERROR(x...)	dprintf("usb " USB_MODULE_NAME ": " x)
46
47extern device_manager_info *gDeviceManager;
48
49
50class Hub;
51class Stack;
52class Device;
53class Transfer;
54class BusManager;
55class Pipe;
56class ControlPipe;
57class Object;
58class PhysicalMemoryAllocator;
59
60
61struct usb_host_controller_info {
62	module_info info;
63	status_t (*control)(uint32 op, void *data, size_t length);
64	status_t (*add_to)(Stack *stack);
65};
66
67
68struct usb_driver_cookie {
69	usb_id device;
70	void *cookie;
71	usb_driver_cookie *link;
72};
73
74
75struct usb_driver_info {
76	const char *driver_name;
77	usb_support_descriptor *support_descriptors;
78	uint32 support_descriptor_count;
79	const char *republish_driver_name;
80	usb_notify_hooks notify_hooks;
81	usb_driver_cookie *cookies;
82	usb_driver_info *link;
83};
84
85
86struct change_item {
87	bool added;
88	Device *device;
89	change_item *link;
90};
91
92
93struct rescan_item {
94	const char *name;
95	rescan_item *link;
96};
97
98
99typedef enum {
100	USB_SPEED_LOWSPEED = 0,
101	USB_SPEED_FULLSPEED,
102	USB_SPEED_HIGHSPEED,
103	USB_SPEED_SUPERSPEED,
104	USB_SPEED_MAX = USB_SPEED_SUPERSPEED
105} usb_speed;
106
107
108typedef enum {
109	USB_CHANGE_CREATED = 0,
110	USB_CHANGE_DESTROYED,
111	USB_CHANGE_PIPE_POLICY_CHANGED
112} usb_change;
113
114
115#define USB_OBJECT_NONE					0x00000000
116#define USB_OBJECT_PIPE					0x00000001
117#define USB_OBJECT_CONTROL_PIPE			0x00000002
118#define USB_OBJECT_INTERRUPT_PIPE		0x00000004
119#define USB_OBJECT_BULK_PIPE			0x00000008
120#define USB_OBJECT_ISO_PIPE				0x00000010
121#define USB_OBJECT_INTERFACE			0x00000020
122#define USB_OBJECT_DEVICE				0x00000040
123#define USB_OBJECT_HUB					0x00000080
124
125
126class Stack {
127public:
128										Stack();
129										~Stack();
130
131		status_t						InitCheck();
132
133		bool							Lock();
134		void							Unlock();
135
136		usb_id							GetUSBID(Object *object);
137		void							PutUSBID(Object *object);
138
139		// This sets the object as busy; the caller must set it un-busy.
140		Object *						GetObject(usb_id id);
141
142		// only for the kernel debugger
143		Object *						GetObjectNoLock(usb_id id) const;
144
145		void							AddBusManager(BusManager *bus);
146		int32							IndexOfBusManager(BusManager *bus);
147		BusManager *					BusManagerAt(int32 index) const;
148
149		status_t						AllocateChunk(void **logicalAddress,
150											phys_addr_t *physicalAddress,
151											size_t size);
152		status_t						FreeChunk(void *logicalAddress,
153											phys_addr_t physicalAddress,
154											size_t size);
155
156		area_id							AllocateArea(void **logicalAddress,
157											phys_addr_t *physicalAddress,
158											size_t size, const char *name);
159
160		void							NotifyDeviceChange(Device *device,
161											rescan_item **rescanList,
162											bool added);
163		void							RescanDrivers(rescan_item *rescanItem);
164
165		// USB API
166		status_t						RegisterDriver(const char *driverName,
167											const usb_support_descriptor *
168												descriptors,
169											size_t descriptorCount,
170											const char *republishDriverName);
171
172		status_t						InstallNotify(const char *driverName,
173											const usb_notify_hooks *hooks);
174		status_t						UninstallNotify(const char *driverName);
175
176		usb_id							USBID() const { return 0; }
177		const char *					TypeName() const { return "stack"; }
178
179		void							Explore();
180
181private:
182static	int32							ExploreThread(void *data);
183
184		Vector<BusManager *>			fBusManagers;
185		thread_id						fExploreThread;
186		sem_id							fExploreSem;
187
188		mutex							fStackLock;
189		mutex							fExploreLock;
190		PhysicalMemoryAllocator *		fAllocator;
191
192		uint32							fObjectIndex;
193		uint32							fObjectMaxCount;
194		Object **						fObjectArray;
195
196		usb_driver_info *				fDriverList;
197};
198
199
200/*
201 * This class manages a bus. It is created by the Stack object
202 * after a host controller gives positive feedback on whether the hardware
203 * is found.
204 */
205class BusManager {
206public:
207										BusManager(Stack *stack, device_node* node);
208virtual									~BusManager();
209
210virtual	status_t						InitCheck();
211
212		bool							Lock();
213		void							Unlock();
214
215		int8							AllocateAddress();
216		void							FreeAddress(int8 address);
217
218virtual	Device *						AllocateDevice(Hub *parent,
219											int8 hubAddress, uint8 hubPort,
220											usb_speed speed);
221virtual void							FreeDevice(Device *device);
222
223virtual	status_t						Start();
224virtual	status_t						Stop();
225
226virtual	status_t						StartDebugTransfer(Transfer *transfer);
227virtual	status_t						CheckDebugTransfer(Transfer *transfer);
228virtual	void							CancelDebugTransfer(Transfer *transfer);
229
230virtual	status_t						SubmitTransfer(Transfer *transfer);
231virtual	status_t						CancelQueuedTransfers(Pipe *pipe,
232											bool force);
233
234virtual	status_t						NotifyPipeChange(Pipe *pipe,
235											usb_change change);
236
237		Object *						RootObject() const
238											{ return fRootObject; }
239
240		Hub *							GetRootHub() const { return fRootHub; }
241		void							SetRootHub(Hub *hub) { fRootHub = hub; }
242
243virtual	const char *					TypeName() const = 0;
244
245		device_node *					Node() const
246											{ return fNode; }
247protected:
248		usb_id							USBID() const { return fStackIndex; }
249
250protected:
251		bool							fInitOK;
252
253private:
254		ControlPipe *					_GetDefaultPipe(usb_speed);
255
256		mutex							fLock;
257
258		bool							fDeviceMap[128];
259		int8							fDeviceIndex;
260
261		Stack *							fStack;
262		ControlPipe *					fDefaultPipes[USB_SPEED_MAX + 1];
263		Hub *							fRootHub;
264		Object *						fRootObject;
265
266		usb_id							fStackIndex;
267
268		device_node*					fNode;
269};
270
271
272class Object {
273public:
274										Object(Stack *stack, BusManager *bus);
275										Object(Object *parent);
276virtual									~Object();
277
278		Object *						Parent() const { return fParent; }
279
280		BusManager *					GetBusManager() const
281											{ return fBusManager; }
282		Stack *							GetStack() const { return fStack; }
283
284		usb_id							USBID() const { return fUSBID; }
285		void							SetBusy(bool busy)
286											{ atomic_add(&fBusy, busy ? 1 : -1); }
287
288virtual	uint32							Type() const { return USB_OBJECT_NONE; }
289virtual	const char *					TypeName() const { return "object"; }
290
291		// Convenience functions for standard requests
292virtual	status_t						SetFeature(uint16 selector);
293virtual	status_t						ClearFeature(uint16 selector);
294virtual	status_t						GetStatus(uint16 *status);
295
296protected:
297		void							PutUSBID(bool waitForUnbusy = true);
298		void							WaitForUnbusy();
299
300private:
301		Object *						fParent;
302		BusManager *					fBusManager;
303		Stack *							fStack;
304		usb_id							fUSBID;
305		int32							fBusy;
306};
307
308
309/*
310 * The Pipe class is the communication management between the hardware and
311 * the stack. It creates packets, manages these and performs callbacks.
312 */
313class Pipe : public Object {
314public:
315		enum pipeDirection { In, Out, Default };
316
317										Pipe(Object *parent);
318virtual									~Pipe();
319
320virtual	void							InitCommon(int8 deviceAddress,
321											uint8 endpointAddress,
322											usb_speed speed,
323											pipeDirection direction,
324											size_t maxPacketSize,
325											uint8 interval,
326											int8 hubAddress, uint8 hubPort);
327virtual void							InitSuperSpeed(uint8 maxBurst,
328											uint16 bytesPerInterval);
329
330virtual	uint32							Type() const { return USB_OBJECT_PIPE; }
331virtual	const char *					TypeName() const { return "pipe"; }
332
333		int8							DeviceAddress() const
334											{ return fDeviceAddress; }
335		usb_speed						Speed() const { return fSpeed; }
336		pipeDirection					Direction() const { return fDirection; }
337		uint8							EndpointAddress() const
338											{ return fEndpointAddress; }
339		size_t							MaxPacketSize() const
340											{ return fMaxPacketSize; }
341		uint8							Interval() const { return fInterval; }
342
343		// SuperSpeed-only parameters
344		uint8							MaxBurst() const
345											{ return fMaxBurst; }
346		uint16							BytesPerInterval() const
347											{ return fBytesPerInterval; }
348
349		// Hub port being the one-based logical port number on the hub
350		void							SetHubInfo(int8 address, uint8 port);
351		int8							HubAddress() const
352											{ return fHubAddress; }
353		uint8							HubPort() const { return fHubPort; }
354
355virtual	bool							DataToggle() const
356											{ return fDataToggle; }
357virtual	void							SetDataToggle(bool toggle)
358											{ fDataToggle = toggle; }
359
360		status_t						SubmitTransfer(Transfer *transfer);
361virtual	status_t						CancelQueuedTransfers(bool force);
362
363		void							SetControllerCookie(void *cookie)
364											{ fControllerCookie = cookie; }
365		void *							ControllerCookie() const
366											{ return fControllerCookie; }
367
368		// Convenience functions for standard requests
369virtual	status_t						SetFeature(uint16 selector);
370virtual	status_t						ClearFeature(uint16 selector);
371virtual	status_t						GetStatus(uint16 *status);
372
373protected:
374		friend class					Device;
375
376private:
377		int8							fDeviceAddress;
378		uint8							fEndpointAddress;
379		pipeDirection					fDirection;
380		usb_speed						fSpeed;
381		size_t							fMaxPacketSize;
382		uint8							fInterval;
383		uint8							fMaxBurst;
384		uint16							fBytesPerInterval;
385		int8							fHubAddress;
386		uint8							fHubPort;
387		bool							fDataToggle;
388		void *							fControllerCookie;
389};
390
391
392class ControlPipe : public Pipe {
393public:
394										ControlPipe(Object *parent);
395virtual									~ControlPipe();
396
397virtual	void							InitCommon(int8 deviceAddress,
398											uint8 endpointAddress,
399											usb_speed speed,
400											pipeDirection direction,
401											size_t maxPacketSize,
402											uint8 interval,
403											int8 hubAddress, uint8 hubPort);
404
405virtual	uint32							Type() const { return USB_OBJECT_PIPE
406											| USB_OBJECT_CONTROL_PIPE; }
407virtual	const char *					TypeName() const
408											{ return "control pipe"; }
409
410										// The data toggle is not relevant
411										// for control transfers, as they are
412										// always enclosed by a setup and
413										// status packet. The toggle always
414										// starts at 1.
415virtual	bool							DataToggle() const { return true; }
416virtual	void							SetDataToggle(bool toggle) {}
417
418		status_t						SendRequest(uint8 requestType,
419											uint8 request, uint16 value,
420											uint16 index, uint16 length,
421											void *data, size_t dataLength,
422											size_t *actualLength);
423static	void							SendRequestCallback(void *cookie,
424											status_t status, void *data,
425											size_t actualLength);
426
427		status_t						QueueRequest(uint8 requestType,
428											uint8 request, uint16 value,
429											uint16 index, uint16 length,
430											void *data, size_t dataLength,
431											usb_callback_func callback,
432											void *callbackCookie);
433
434virtual	status_t						CancelQueuedTransfers(bool force);
435
436private:
437		mutex							fSendRequestLock;
438		sem_id							fNotifySem;
439		status_t						fTransferStatus;
440		size_t							fActualLength;
441};
442
443
444class InterruptPipe : public Pipe {
445public:
446										InterruptPipe(Object *parent);
447
448virtual	uint32							Type() const { return USB_OBJECT_PIPE
449											| USB_OBJECT_INTERRUPT_PIPE; }
450virtual	const char *					TypeName() const
451											{ return "interrupt pipe"; }
452
453		status_t						QueueInterrupt(void *data,
454											size_t dataLength,
455											usb_callback_func callback,
456											void *callbackCookie);
457};
458
459
460class BulkPipe : public Pipe {
461public:
462										BulkPipe(Object *parent);
463
464virtual	void							InitCommon(int8 deviceAddress,
465											uint8 endpointAddress,
466											usb_speed speed,
467											pipeDirection direction,
468											size_t maxPacketSize,
469											uint8 interval,
470											int8 hubAddress, uint8 hubPort);
471
472virtual	uint32							Type() const { return USB_OBJECT_PIPE
473											| USB_OBJECT_BULK_PIPE; }
474virtual	const char *					TypeName() const { return "bulk pipe"; }
475
476		status_t						QueueBulk(void *data,
477											size_t dataLength,
478											usb_callback_func callback,
479											void *callbackCookie);
480		status_t						QueueBulkV(iovec *vector, size_t vectorCount,
481											usb_callback_func callback, void *callbackCookie);
482		status_t						QueueBulkV(physical_entry *vector, size_t vectorCount,
483											usb_callback_func callback, void *callbackCookie);};
484
485
486class IsochronousPipe : public Pipe {
487public:
488										IsochronousPipe(Object *parent);
489
490virtual	uint32							Type() const { return USB_OBJECT_PIPE
491											| USB_OBJECT_ISO_PIPE; }
492virtual	const char *					TypeName() const { return "iso pipe"; }
493
494		status_t						QueueIsochronous(void *data,
495											size_t dataLength,
496											usb_iso_packet_descriptor *
497												packetDescriptor,
498											uint32 packetCount,
499											uint32 *startingFrameNumber,
500											uint32 flags,
501											usb_callback_func callback,
502											void *callbackCookie);
503
504		status_t						SetPipePolicy(uint8 maxQueuedPackets,
505											uint16 maxBufferDurationMS,
506											uint16 sampleSize);
507		status_t						GetPipePolicy(uint8 *maxQueuedPackets,
508											uint16 *maxBufferDurationMS,
509											uint16 *sampleSize);
510
511private:
512		uint8							fMaxQueuedPackets;
513		uint16							fMaxBufferDuration;
514		uint16							fSampleSize;
515};
516
517
518class Interface : public Object {
519public:
520										Interface(Object *parent,
521											uint8 interfaceIndex);
522
523virtual	uint32							Type() const
524											{ return USB_OBJECT_INTERFACE; }
525virtual	const char *					TypeName() const { return "interface"; }
526
527		// Convenience functions for standard requests
528virtual	status_t						SetFeature(uint16 selector);
529virtual	status_t						ClearFeature(uint16 selector);
530virtual	status_t						GetStatus(uint16 *status);
531
532private:
533		uint8							fInterfaceIndex;
534};
535
536
537class Device : public Object {
538public:
539										Device(Object *parent, int8 hubAddress,
540											uint8 hubPort,
541											usb_device_descriptor &desc,
542											int8 deviceAddress,
543											usb_speed speed, bool isRootHub,
544											void *controllerCookie = NULL);
545virtual									~Device();
546
547		status_t						InitCheck();
548
549virtual	status_t						Changed(change_item **changeList,
550											bool added);
551
552virtual	uint32							Type() const
553											{ return USB_OBJECT_DEVICE; }
554virtual	const char *					TypeName() const { return "device"; }
555
556		ControlPipe *					DefaultPipe() const
557											{ return fDefaultPipe; }
558
559virtual	status_t						GetDescriptor(uint8 descriptorType,
560											uint8 index, uint16 languageID,
561											void *data, size_t dataLength,
562											size_t *actualLength);
563
564		int8							DeviceAddress() const
565											{ return fDeviceAddress; }
566		const usb_device_descriptor *	DeviceDescriptor() const;
567		usb_speed						Speed() const { return fSpeed; }
568
569		const usb_configuration_info *	Configuration() const;
570		const usb_configuration_info *	ConfigurationAt(uint8 index) const;
571		status_t						SetConfiguration(
572											const usb_configuration_info *
573												configuration);
574		status_t						SetConfigurationAt(uint8 index);
575		status_t						Unconfigure(bool atDeviceLevel);
576
577		status_t						SetAltInterface(
578											const usb_interface_info *
579												interface);
580
581		void							InitEndpoints(int32 interfaceIndex);
582		void							ClearEndpoints(int32 interfaceIndex);
583
584virtual	status_t						ReportDevice(
585											usb_support_descriptor *
586												supportDescriptors,
587											uint32 supportDescriptorCount,
588											const usb_notify_hooks *hooks,
589											usb_driver_cookie **cookies,
590											bool added, bool recursive);
591virtual	status_t						BuildDeviceName(char *string,
592											uint32 *index, size_t bufferSize,
593											Device *device);
594
595		device_node *					RegisterNode(device_node* parent = NULL);
596
597		int8							HubAddress() const
598											{ return fHubAddress; }
599		uint8							HubPort() const { return fHubPort; }
600
601		void							SetControllerCookie(void *cookie)
602											{ fControllerCookie = cookie; }
603		void *							ControllerCookie() const
604											{ return fControllerCookie; }
605		device_node *					Node() const
606											{ return fNode; }
607		void							SetNode(device_node* node) { fNode = node; }
608
609		// Convenience functions for standard requests
610virtual	status_t						SetFeature(uint16 selector);
611virtual	status_t						ClearFeature(uint16 selector);
612virtual	status_t						GetStatus(uint16 *status);
613
614protected:
615		usb_device_descriptor			fDeviceDescriptor;
616		bool							fInitOK;
617
618private:
619		bool							fAvailable;
620		bool							fIsRootHub;
621		usb_configuration_info *		fConfigurations;
622		usb_configuration_info *		fCurrentConfiguration;
623		usb_speed						fSpeed;
624		int8							fDeviceAddress;
625		int8							fHubAddress;
626		uint8							fHubPort;
627		ControlPipe *					fDefaultPipe;
628		void *							fControllerCookie;
629		device_node*					fNode;
630};
631
632
633class Hub : public Device {
634public:
635										Hub(Object *parent, int8 hubAddress,
636											uint8 hubPort,
637											usb_device_descriptor &desc,
638											int8 deviceAddress,
639											usb_speed speed, bool isRootHub,
640											void *controllerCookie = NULL);
641virtual									~Hub();
642
643virtual	status_t						Changed(change_item **changeList,
644											bool added);
645
646virtual	uint32							Type() const { return USB_OBJECT_DEVICE
647											| USB_OBJECT_HUB; }
648virtual	const char *					TypeName() const { return "hub"; }
649
650virtual	status_t						GetDescriptor(uint8 descriptorType,
651											uint8 index, uint16 languageID,
652											void *data, size_t dataLength,
653											size_t *actualLength);
654
655		Device *						ChildAt(uint8 index) const
656											{ return fChildren[index]; }
657
658		status_t						UpdatePortStatus(uint8 index);
659		status_t						ResetPort(uint8 index);
660		status_t						DisablePort(uint8 index);
661
662		void							Explore(change_item **changeList);
663static	void							InterruptCallback(void *cookie,
664											status_t status, void *data,
665											size_t actualLength);
666
667virtual	status_t						ReportDevice(
668											usb_support_descriptor *
669												supportDescriptors,
670											uint32 supportDescriptorCount,
671											const usb_notify_hooks *hooks,
672											usb_driver_cookie **cookies,
673											bool added, bool recursive);
674virtual	status_t						BuildDeviceName(char *string,
675											uint32 *index, size_t bufferSize,
676											Device *device);
677
678private:
679		status_t						_DebouncePort(uint8 index);
680
681		InterruptPipe *					fInterruptPipe;
682		usb_hub_descriptor				fHubDescriptor;
683
684		usb_port_status					fInterruptStatus[USB_MAX_PORT_COUNT];
685		usb_port_status					fPortStatus[USB_MAX_PORT_COUNT];
686		Device *						fChildren[USB_MAX_PORT_COUNT];
687};
688
689
690/*
691 * A Transfer is allocated on the heap and passed to the Host Controller in
692 * SubmitTransfer(). It is generated for all queued transfers. If queuing
693 * succeds (SubmitTransfer() returns with >= B_OK) the Host Controller takes
694 * ownership of the Transfer and will delete it as soon as it has called the
695 * set callback function. If SubmitTransfer() failes, the calling function is
696 * responsible for deleting the Transfer.
697 * Also, the transfer takes ownership of the usb_request_data passed to it in
698 * SetRequestData(), but does not take ownership of the data buffer set by
699 * SetData().
700 */
701class Transfer {
702public:
703									Transfer(Pipe *pipe);
704									~Transfer();
705
706		Pipe *						TransferPipe() const { return fPipe; }
707
708		void						SetRequestData(usb_request_data *data);
709		usb_request_data *			RequestData() const { return fRequestData; }
710
711		void						SetIsochronousData(
712										usb_isochronous_data *data);
713		usb_isochronous_data *		IsochronousData() const
714										{ return fIsochronousData; }
715
716		void						SetData(uint8 *buffer, size_t length);
717		uint8 *						Data() const
718										{ return fPhysical ? NULL : (uint8 *)fData.base; }
719		size_t						DataLength() const { return fData.length; }
720
721		bool						IsPhysical() const { return fPhysical; }
722
723		void						SetVector(iovec *vector, size_t vectorCount);
724		void						SetVector(physical_entry *vector, size_t vectorCount);
725		generic_io_vec *			Vector() { return fVector; }
726		size_t						VectorCount() const { return fVectorCount; }
727
728		uint16						Bandwidth() const { return fBandwidth; }
729
730		bool						IsFragmented() const { return fFragmented; }
731		void						AdvanceByFragment(size_t actualLength);
732		size_t						FragmentLength() const;
733
734		status_t					InitKernelAccess();
735		status_t					PrepareKernelAccess();
736
737		void						SetCallback(usb_callback_func callback,
738										void *cookie);
739		usb_callback_func			Callback() const
740										{ return fCallback; }
741		void *						CallbackCookie() const
742										{ return fCallbackCookie; }
743
744		void						Finished(uint32 status,
745										size_t actualLength);
746
747		usb_id						USBID() const { return 0; }
748		const char *				TypeName() const { return "transfer"; }
749
750private:
751		void						_CheckFragmented();
752		status_t					_CalculateBandwidth();
753
754		// Data that is related to the transfer
755		Pipe *						fPipe;
756		generic_io_vec				fData;
757		generic_io_vec *			fVector;
758		size_t						fVectorCount;
759		void *						fBaseAddress;
760		bool						fPhysical;
761		bool						fFragmented;
762		size_t						fActualLength;
763		area_id						fUserArea;
764		area_id						fClonedArea;
765
766		usb_callback_func			fCallback;
767		void *						fCallbackCookie;
768
769		// For control transfers
770		usb_request_data *			fRequestData;
771
772		// For isochronous transfers
773		usb_isochronous_data *		fIsochronousData;
774
775		// For bandwidth management.
776		// It contains the bandwidth necessary in microseconds
777		// for either isochronous, interrupt or control transfers.
778		// Not used for bulk transactions.
779		uint16						fBandwidth;
780};
781
782
783// Interface between usb_bus and underlying implementation (xhci_pci)
784typedef struct usb_bus_interface {
785	driver_module_info info;
786} usb_bus_interface;
787
788
789typedef struct {
790	driver_module_info info;
791	status_t           (*get_stack)(void** stack);
792} usb_for_controller_interface;
793
794#define USB_FOR_CONTROLLER_MODULE_NAME "bus_managers/usb/controller/driver_v1"
795
796// bus manager device interface for peripheral driver
797typedef struct {
798	driver_module_info info;
799
800} usb_device_interface;
801
802
803#define USB_DEVICE_MODULE_NAME "bus_managers/usb/device/driver_v1"
804
805#endif // _USB_PRIVATE_H
806