hcd.h 23.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Copyright (c) 2001-2002 by David Brownell
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

19 20
#ifndef __USB_CORE_HCD_H
#define __USB_CORE_HCD_H
L
Linus Torvalds 已提交
21 22 23

#ifdef __KERNEL__

24 25
#include <linux/rwsem.h>

26 27
#define MAX_TOPO_LEVEL		6

L
Linus Torvalds 已提交
28 29 30 31 32 33 34
/* This file contains declarations of usbcore internals that are mostly
 * used or exposed by Host Controller Drivers.
 */

/*
 * USB Packet IDs (PIDs)
 */
35
#define USB_PID_EXT			0xf0	/* USB 2.0 LPM ECN */
L
Linus Torvalds 已提交
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
#define USB_PID_OUT			0xe1
#define USB_PID_ACK			0xd2
#define USB_PID_DATA0			0xc3
#define USB_PID_PING			0xb4	/* USB 2.0 */
#define USB_PID_SOF			0xa5
#define USB_PID_NYET			0x96	/* USB 2.0 */
#define USB_PID_DATA2			0x87	/* USB 2.0 */
#define USB_PID_SPLIT			0x78	/* USB 2.0 */
#define USB_PID_IN			0x69
#define USB_PID_NAK			0x5a
#define USB_PID_DATA1			0x4b
#define USB_PID_PREAMBLE		0x3c	/* Token mode */
#define USB_PID_ERR			0x3c	/* USB 2.0: handshake mode */
#define USB_PID_SETUP			0x2d
#define USB_PID_STALL			0x1e
#define USB_PID_MDATA			0x0f	/* USB 2.0 */

/*-------------------------------------------------------------------------*/

/*
 * USB Host Controller Driver (usb_hcd) framework
 *
 * Since "struct usb_bus" is so thin, you can't share much code in it.
 * This framework is a layer over that, and should be more sharable.
60 61 62 63 64 65
 *
 * @authorized_default: Specifies if new devices are authorized to
 *                      connect by default or they require explicit
 *                      user space authorization; this bit is settable
 *                      through /sys/class/usb_host/X/authorized_default.
 *                      For the rest is RO, so we don't lock to r/w it.
L
Linus Torvalds 已提交
66 67 68 69
 */

/*-------------------------------------------------------------------------*/

70
struct usb_hcd {
L
Linus Torvalds 已提交
71 72 73 74 75

	/*
	 * housekeeping
	 */
	struct usb_bus		self;		/* hcd is-a bus */
76
	struct kref		kref;		/* reference counter */
L
Linus Torvalds 已提交
77 78

	const char		*product_desc;	/* product/vendor string */
79 80 81 82
	int			speed;		/* Speed for this roothub.
						 * May be different from
						 * hcd->driver->flags & HCD_MASK
						 */
L
Linus Torvalds 已提交
83 84
	char			irq_descr[24];	/* driver + bus # */

85 86
	struct timer_list	rh_timer;	/* drives root-hub polling */
	struct urb		*status_urb;	/* the current status urb */
87
#ifdef CONFIG_USB_SUSPEND
88 89
	struct work_struct	wakeup_work;	/* for remote wakeup */
#endif
L
Linus Torvalds 已提交
90 91 92 93 94

	/*
	 * hardware info/state
	 */
	const struct hc_driver	*driver;	/* hw-specific hooks */
95

96 97 98 99
	/* Flags that need to be manipulated atomically because they can
	 * change while the host controller is running.  Always use
	 * set_bit() or clear_bit() to change their values.
	 */
100
	unsigned long		flags;
101 102 103 104
#define HCD_FLAG_HW_ACCESSIBLE		0	/* at full power */
#define HCD_FLAG_SAW_IRQ		1
#define HCD_FLAG_POLL_RH		2	/* poll for rh status? */
#define HCD_FLAG_POLL_PENDING		3	/* status has changed? */
105
#define HCD_FLAG_WAKEUP_PENDING		4	/* root hub is resuming? */
106 107
#define HCD_FLAG_RH_RUNNING		5	/* root hub is running? */
#define HCD_FLAG_DEAD			6	/* controller has died? */
108 109 110 111 112 113 114 115

	/* The flags can be tested using these macros; they are likely to
	 * be slightly faster than test_bit().
	 */
#define HCD_HW_ACCESSIBLE(hcd)	((hcd)->flags & (1U << HCD_FLAG_HW_ACCESSIBLE))
#define HCD_SAW_IRQ(hcd)	((hcd)->flags & (1U << HCD_FLAG_SAW_IRQ))
#define HCD_POLL_RH(hcd)	((hcd)->flags & (1U << HCD_FLAG_POLL_RH))
#define HCD_POLL_PENDING(hcd)	((hcd)->flags & (1U << HCD_FLAG_POLL_PENDING))
116
#define HCD_WAKEUP_PENDING(hcd)	((hcd)->flags & (1U << HCD_FLAG_WAKEUP_PENDING))
117 118
#define HCD_RH_RUNNING(hcd)	((hcd)->flags & (1U << HCD_FLAG_RH_RUNNING))
#define HCD_DEAD(hcd)		((hcd)->flags & (1U << HCD_FLAG_DEAD))
119

120
	/* Flags that get set only during HCD registration or removal. */
L
Linus Torvalds 已提交
121
	unsigned		rh_registered:1;/* is root hub registered? */
122
	unsigned		rh_pollable:1;	/* may we poll the root hub? */
123
	unsigned		msix_enabled:1;	/* driver has MSI-X enabled? */
L
Linus Torvalds 已提交
124

125 126 127
	/* The next flag is a stopgap, to be removed when all the HCDs
	 * support the new root-hub polling mechanism. */
	unsigned		uses_new_polling:1;
128
	unsigned		wireless:1;	/* Wireless USB HCD */
129
	unsigned		authorized_default:1;
130
	unsigned		has_tt:1;	/* Integrated TT in root hub */
131

L
Linus Torvalds 已提交
132 133 134 135
	int			irq;		/* irq allocated */
	void __iomem		*regs;		/* device memory/io */
	u64			rsrc_start;	/* memory/io resource start */
	u64			rsrc_len;	/* memory/io resource length */
136
	unsigned		power_budget;	/* in mA, 0 = no limit */
L
Linus Torvalds 已提交
137

138 139 140 141 142 143 144 145 146 147 148
	/* bandwidth_mutex should be taken before adding or removing
	 * any new bus bandwidth constraints:
	 *   1. Before adding a configuration for a new device.
	 *   2. Before removing the configuration to put the device into
	 *      the addressed state.
	 *   3. Before selecting a different configuration.
	 *   4. Before selecting an alternate interface setting.
	 *
	 * bandwidth_mutex should be dropped after a successful control message
	 * to the device, or resetting the bandwidth after a failed attempt.
	 */
149
	struct mutex		*bandwidth_mutex;
150 151
	struct usb_hcd		*shared_hcd;
	struct usb_hcd		*primary_hcd;
152 153


L
Linus Torvalds 已提交
154
#define HCD_BUFFER_POOLS	4
155
	struct dma_pool		*pool[HCD_BUFFER_POOLS];
L
Linus Torvalds 已提交
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172

	int			state;
#	define	__ACTIVE		0x01
#	define	__SUSPEND		0x04
#	define	__TRANSIENT		0x80

#	define	HC_STATE_HALT		0
#	define	HC_STATE_RUNNING	(__ACTIVE)
#	define	HC_STATE_QUIESCING	(__SUSPEND|__TRANSIENT|__ACTIVE)
#	define	HC_STATE_RESUMING	(__SUSPEND|__TRANSIENT)
#	define	HC_STATE_SUSPENDED	(__SUSPEND)

#define	HC_IS_RUNNING(state) ((state) & __ACTIVE)
#define	HC_IS_SUSPENDED(state) ((state) & __SUSPEND)

	/* more shared queuing code would be good; it should support
	 * smarter scheduling, handle transaction translators, etc;
173
	 * input size of periodic table to an interrupt scheduler.
L
Linus Torvalds 已提交
174 175 176 177 178 179 180
	 * (ohci 32, uhci 1024, ehci 256/512/1024).
	 */

	/* The HC driver's private data is stored at the end of
	 * this structure.
	 */
	unsigned long hcd_priv[0]
181
			__attribute__ ((aligned(sizeof(unsigned long))));
L
Linus Torvalds 已提交
182 183 184
};

/* 2.4 does this a bit differently ... */
185
static inline struct usb_bus *hcd_to_bus(struct usb_hcd *hcd)
L
Linus Torvalds 已提交
186 187 188 189
{
	return &hcd->self;
}

190
static inline struct usb_hcd *bus_to_hcd(struct usb_bus *bus)
191 192 193
{
	return container_of(bus, struct usb_hcd, self);
}
L
Linus Torvalds 已提交
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208

struct hcd_timeout {	/* timeouts we allocate */
	struct list_head	timeout_list;
	struct timer_list	timer;
};

/*-------------------------------------------------------------------------*/


struct hc_driver {
	const char	*description;	/* "ehci-hcd" etc */
	const char	*product_desc;	/* product/vendor string */
	size_t		hcd_priv_size;	/* size of private data */

	/* irq handler */
209
	irqreturn_t	(*irq) (struct usb_hcd *hcd);
L
Linus Torvalds 已提交
210 211 212

	int	flags;
#define	HCD_MEMORY	0x0001		/* HC regs use memory (else I/O) */
M
Magnus Damm 已提交
213
#define	HCD_LOCAL_MEM	0x0002		/* HC needs local memory */
214
#define	HCD_SHARED	0x0004		/* Two (or more) usb_hcds share HW */
L
Linus Torvalds 已提交
215 216
#define	HCD_USB11	0x0010		/* USB 1.1 */
#define	HCD_USB2	0x0020		/* USB 2.0 */
217
#define	HCD_USB3	0x0040		/* USB 3.0 */
218
#define	HCD_MASK	0x0070
L
Linus Torvalds 已提交
219 220 221 222 223 224

	/* called to init HCD and root hub */
	int	(*reset) (struct usb_hcd *hcd);
	int	(*start) (struct usb_hcd *hcd);

	/* NOTE:  these suspend/resume calls relate to the HC as
225
	 * a whole, not just the root hub; they're for PCI bus glue.
L
Linus Torvalds 已提交
226
	 */
227
	/* called after suspending the hub, before entering D3 etc */
228
	int	(*pci_suspend)(struct usb_hcd *hcd, bool do_wakeup);
L
Linus Torvalds 已提交
229

230
	/* called after entering D0 (etc), before resuming the hub */
231
	int	(*pci_resume)(struct usb_hcd *hcd, bool hibernated);
L
Linus Torvalds 已提交
232 233 234 235

	/* cleanly make HCD stop writing memory and doing I/O */
	void	(*stop) (struct usb_hcd *hcd);

236 237 238
	/* shutdown HCD */
	void	(*shutdown) (struct usb_hcd *hcd);

L
Linus Torvalds 已提交
239 240 241 242
	/* return current frame number */
	int	(*get_frame_number) (struct usb_hcd *hcd);

	/* manage i/o requests, device state */
243 244 245 246
	int	(*urb_enqueue)(struct usb_hcd *hcd,
				struct urb *urb, gfp_t mem_flags);
	int	(*urb_dequeue)(struct usb_hcd *hcd,
				struct urb *urb, int status);
L
Linus Torvalds 已提交
247

248 249 250 251 252 253 254 255 256 257 258 259 260
	/*
	 * (optional) these hooks allow an HCD to override the default DMA
	 * mapping and unmapping routines.  In general, they shouldn't be
	 * necessary unless the host controller has special DMA requirements,
	 * such as alignment contraints.  If these are not specified, the
	 * general usb_hcd_(un)?map_urb_for_dma functions will be used instead
	 * (and it may be a good idea to call these functions in your HCD
	 * implementation)
	 */
	int	(*map_urb_for_dma)(struct usb_hcd *hcd, struct urb *urb,
				   gfp_t mem_flags);
	void    (*unmap_urb_for_dma)(struct usb_hcd *hcd, struct urb *urb);

L
Linus Torvalds 已提交
261
	/* hw synch, freeing endpoint resources that urb_dequeue can't */
262
	void	(*endpoint_disable)(struct usb_hcd *hcd,
L
Linus Torvalds 已提交
263 264
			struct usb_host_endpoint *ep);

265 266
	/* (optional) reset any endpoint state such as sequence number
	   and current window */
267
	void	(*endpoint_reset)(struct usb_hcd *hcd,
268 269
			struct usb_host_endpoint *ep);

L
Linus Torvalds 已提交
270
	/* root hub support */
271 272
	int	(*hub_status_data) (struct usb_hcd *hcd, char *buf);
	int	(*hub_control) (struct usb_hcd *hcd,
L
Linus Torvalds 已提交
273 274
				u16 typeReq, u16 wValue, u16 wIndex,
				char *buf, u16 wLength);
275 276 277
	int	(*bus_suspend)(struct usb_hcd *);
	int	(*bus_resume)(struct usb_hcd *);
	int	(*start_port_reset)(struct usb_hcd *, unsigned port_num);
278 279

		/* force handover of high-speed port to full-speed companion */
280
	void	(*relinquish_port)(struct usb_hcd *, int);
281 282
		/* has a port been handed over to a companion? */
	int	(*port_handed_over)(struct usb_hcd *, int);
283

284 285 286 287
		/* CLEAR_TT_BUFFER completion callback */
	void	(*clear_tt_buffer_complete)(struct usb_hcd *,
				struct usb_host_endpoint *);

288 289 290
	/* xHCI specific functions */
		/* Called by usb_alloc_dev to alloc HC device structures */
	int	(*alloc_dev)(struct usb_hcd *, struct usb_device *);
291
		/* Called by usb_disconnect to free HC device structures */
292
	void	(*free_dev)(struct usb_hcd *, struct usb_device *);
293 294 295 296 297 298 299 300 301 302
	/* Change a group of bulk endpoints to support multiple stream IDs */
	int	(*alloc_streams)(struct usb_hcd *hcd, struct usb_device *udev,
		struct usb_host_endpoint **eps, unsigned int num_eps,
		unsigned int num_streams, gfp_t mem_flags);
	/* Reverts a group of bulk endpoints back to not using stream IDs.
	 * Can fail if we run out of memory.
	 */
	int	(*free_streams)(struct usb_hcd *hcd, struct usb_device *udev,
		struct usb_host_endpoint **eps, unsigned int num_eps,
		gfp_t mem_flags);
303 304 305 306 307

	/* Bandwidth computation functions */
	/* Note that add_endpoint() can only be called once per endpoint before
	 * check_bandwidth() or reset_bandwidth() must be called.
	 * drop_endpoint() can only be called once per endpoint also.
308 309 310 311 312
	 * A call to xhci_drop_endpoint() followed by a call to
	 * xhci_add_endpoint() will add the endpoint to the schedule with
	 * possibly new parameters denoted by a different endpoint descriptor
	 * in usb_host_endpoint.  A call to xhci_add_endpoint() followed by a
	 * call to xhci_drop_endpoint() is not allowed.
313 314
	 */
		/* Allocate endpoint resources and add them to a new schedule */
315 316
	int	(*add_endpoint)(struct usb_hcd *, struct usb_device *,
				struct usb_host_endpoint *);
317
		/* Drop an endpoint from a new schedule */
318 319
	int	(*drop_endpoint)(struct usb_hcd *, struct usb_device *,
				 struct usb_host_endpoint *);
320 321 322 323 324 325 326 327 328 329 330 331 332 333
		/* Check that a new hardware configuration, set using
		 * endpoint_enable and endpoint_disable, does not exceed bus
		 * bandwidth.  This must be called before any set configuration
		 * or set interface requests are sent to the device.
		 */
	int	(*check_bandwidth)(struct usb_hcd *, struct usb_device *);
		/* Reset the device schedule to the last known good schedule,
		 * which was set from a previous successful call to
		 * check_bandwidth().  This reverts any add_endpoint() and
		 * drop_endpoint() calls since that last successful call.
		 * Used for when a check_bandwidth() call fails due to resource
		 * or bandwidth constraints.
		 */
	void	(*reset_bandwidth)(struct usb_hcd *, struct usb_device *);
334 335
		/* Returns the hardware-chosen device address */
	int	(*address_device)(struct usb_hcd *, struct usb_device *udev);
336 337 338 339 340
		/* Notifies the HCD after a hub descriptor is fetched.
		 * Will block.
		 */
	int	(*update_hub_device)(struct usb_hcd *, struct usb_device *hdev,
			struct usb_tt *tt, gfp_t mem_flags);
341
	int	(*reset_device)(struct usb_hcd *, struct usb_device *);
342 343 344 345
		/* Notifies the HCD after a device is connected and its
		 * address is set
		 */
	int	(*update_device)(struct usb_hcd *, struct usb_device *);
A
Andiry Xu 已提交
346
	int	(*set_usb2_hw_lpm)(struct usb_hcd *, struct usb_device *, int);
L
Linus Torvalds 已提交
347 348
};

349 350 351 352 353
extern int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb);
extern int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
		int status);
extern void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb);

354 355
extern int usb_hcd_submit_urb(struct urb *urb, gfp_t mem_flags);
extern int usb_hcd_unlink_urb(struct urb *urb, int status);
A
Alan Stern 已提交
356 357
extern void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb,
		int status);
358 359
extern int usb_hcd_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
		gfp_t mem_flags);
360 361
extern void usb_hcd_unmap_urb_setup_for_dma(struct usb_hcd *, struct urb *);
extern void usb_hcd_unmap_urb_for_dma(struct usb_hcd *, struct urb *);
362 363 364
extern void usb_hcd_flush_endpoint(struct usb_device *udev,
		struct usb_host_endpoint *ep);
extern void usb_hcd_disable_endpoint(struct usb_device *udev,
A
Alan Stern 已提交
365
		struct usb_host_endpoint *ep);
366 367
extern void usb_hcd_reset_endpoint(struct usb_device *udev,
		struct usb_host_endpoint *ep);
368
extern void usb_hcd_synchronize_unlinks(struct usb_device *udev);
369
extern int usb_hcd_alloc_bandwidth(struct usb_device *udev,
370
		struct usb_host_config *new_config,
371 372
		struct usb_host_interface *old_alt,
		struct usb_host_interface *new_alt);
373
extern int usb_hcd_get_frame_number(struct usb_device *udev);
L
Linus Torvalds 已提交
374

375
extern struct usb_hcd *usb_create_hcd(const struct hc_driver *driver,
376
		struct device *dev, const char *bus_name);
377 378 379
extern struct usb_hcd *usb_create_shared_hcd(const struct hc_driver *driver,
		struct device *dev, const char *bus_name,
		struct usb_hcd *shared_hcd);
380 381
extern struct usb_hcd *usb_get_hcd(struct usb_hcd *hcd);
extern void usb_put_hcd(struct usb_hcd *hcd);
382
extern int usb_hcd_is_primary_hcd(struct usb_hcd *hcd);
L
Linus Torvalds 已提交
383 384 385 386
extern int usb_add_hcd(struct usb_hcd *hcd,
		unsigned int irqnum, unsigned long irqflags);
extern void usb_remove_hcd(struct usb_hcd *hcd);

387
struct platform_device;
388
extern void usb_hcd_platform_shutdown(struct platform_device *dev);
389

L
Linus Torvalds 已提交
390 391 392
#ifdef CONFIG_PCI
struct pci_dev;
struct pci_device_id;
393
extern int usb_hcd_pci_probe(struct pci_dev *dev,
L
Linus Torvalds 已提交
394
				const struct pci_device_id *id);
395 396
extern void usb_hcd_pci_remove(struct pci_dev *dev);
extern void usb_hcd_pci_shutdown(struct pci_dev *dev);
397

398
#ifdef CONFIG_PM_SLEEP
399
extern const struct dev_pm_ops usb_hcd_pci_pm_ops;
400
#endif
L
Linus Torvalds 已提交
401 402 403
#endif /* CONFIG_PCI */

/* pci-ish (pdev null is ok) buffer alloc/mapping support */
404 405
int hcd_buffer_create(struct usb_hcd *hcd);
void hcd_buffer_destroy(struct usb_hcd *hcd);
L
Linus Torvalds 已提交
406

407
void *hcd_buffer_alloc(struct usb_bus *bus, size_t size,
A
Al Viro 已提交
408
	gfp_t mem_flags, dma_addr_t *dma);
409
void hcd_buffer_free(struct usb_bus *bus, size_t size,
L
Linus Torvalds 已提交
410 411 412
	void *addr, dma_addr_t dma);

/* generic bus glue, needed for host controllers that don't use PCI */
413
extern irqreturn_t usb_hcd_irq(int irq, void *__hcd);
414

415
extern void usb_hc_died(struct usb_hcd *hcd);
416
extern void usb_hcd_poll_rh_status(struct usb_hcd *hcd);
L
Linus Torvalds 已提交
417

418 419 420 421 422 423 424
/* The D0/D1 toggle bits ... USE WITH CAUTION (they're almost hcd-internal) */
#define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> (ep)) & 1)
#define	usb_dotoggle(dev, ep, out)  ((dev)->toggle[out] ^= (1 << (ep)))
#define usb_settoggle(dev, ep, out, bit) \
		((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << (ep))) | \
		 ((bit) << (ep)))

L
Linus Torvalds 已提交
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
/* -------------------------------------------------------------------------- */

/* Enumeration is only for the hub driver, or HCD virtual root hubs */
extern struct usb_device *usb_alloc_dev(struct usb_device *parent,
					struct usb_bus *, unsigned port);
extern int usb_new_device(struct usb_device *dev);
extern void usb_disconnect(struct usb_device **);

extern int usb_get_configuration(struct usb_device *dev);
extern void usb_destroy_configuration(struct usb_device *dev);

/*-------------------------------------------------------------------------*/

/*
 * HCD Root Hub support
 */

442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
#include <linux/usb/ch11.h>

/*
 * As of USB 2.0, full/low speed devices are segregated into trees.
 * One type grows from USB 1.1 host controllers (OHCI, UHCI etc).
 * The other type grows from high speed hubs when they connect to
 * full/low speed devices using "Transaction Translators" (TTs).
 *
 * TTs should only be known to the hub driver, and high speed bus
 * drivers (only EHCI for now).  They affect periodic scheduling and
 * sometimes control/bulk error recovery.
 */

struct usb_device;

struct usb_tt {
	struct usb_device	*hub;	/* upstream highspeed hub */
	int			multi;	/* true means one TT per port */
	unsigned		think_time;	/* think time in ns */

	/* for control/bulk error recovery (CLEAR_TT_BUFFER) */
	spinlock_t		lock;
	struct list_head	clear_list;	/* of usb_tt_clear */
	struct work_struct	clear_work;
};

struct usb_tt_clear {
	struct list_head	clear_list;
	unsigned		tt;
	u16			devinfo;
	struct usb_hcd		*hcd;
	struct usb_host_endpoint	*ep;
};

extern int usb_hub_clear_tt_buffer(struct urb *urb);
extern void usb_ep0_reinit(struct usb_device *);
L
Linus Torvalds 已提交
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504

/* (shifted) direction/type/recipient from the USB 2.0 spec, table 9.2 */
#define DeviceRequest \
	((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)
#define DeviceOutRequest \
	((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)

#define InterfaceRequest \
	((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)

#define EndpointRequest \
	((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)
#define EndpointOutRequest \
	((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)

/* class requests from the USB 2.0 hub spec, table 11-15 */
/* GetBusState and SetHubDescriptor are optional, omitted */
#define ClearHubFeature		(0x2000 | USB_REQ_CLEAR_FEATURE)
#define ClearPortFeature	(0x2300 | USB_REQ_CLEAR_FEATURE)
#define GetHubDescriptor	(0xa000 | USB_REQ_GET_DESCRIPTOR)
#define GetHubStatus		(0xa000 | USB_REQ_GET_STATUS)
#define GetPortStatus		(0xa300 | USB_REQ_GET_STATUS)
#define SetHubFeature		(0x2000 | USB_REQ_SET_FEATURE)
#define SetPortFeature		(0x2300 | USB_REQ_SET_FEATURE)


/*-------------------------------------------------------------------------*/
T
Tatyana Brokhman 已提交
505 506 507 508

/* class requests from USB 3.0 hub spec, table 10-5 */
#define SetHubDepth		(0x3000 | HUB_SET_DEPTH)
#define GetPortErrorCount	(0x8000 | HUB_GET_PORT_ERR_COUNT)
L
Linus Torvalds 已提交
509 510 511 512 513

/*
 * Generic bandwidth allocation constants/support
 */
#define FRAME_TIME_USECS	1000L
514
#define BitTime(bytecount) (7 * 8 * bytecount / 6) /* with integer truncation */
L
Linus Torvalds 已提交
515
		/* Trying not to use worst-case bit-stuffing
516
		 * of (7/6 * 8 * bytecount) = 9.33 * bytecount */
L
Linus Torvalds 已提交
517 518 519 520 521 522 523 524 525 526 527
		/* bytecount = data payload byte count */

#define NS_TO_US(ns)	((ns + 500L) / 1000L)
			/* convert & round nanoseconds to microseconds */


/*
 * Full/low speed bandwidth allocation constants/support.
 */
#define BW_HOST_DELAY	1000L		/* nanoseconds */
#define BW_HUB_LS_SETUP	333L		/* nanoseconds */
528
			/* 4 full-speed bit times (est.) */
L
Linus Torvalds 已提交
529

530
#define FRAME_TIME_BITS			12000L	/* frame = 1 millisecond */
L
Linus Torvalds 已提交
531 532 533 534
#define FRAME_TIME_MAX_BITS_ALLOC	(90L * FRAME_TIME_BITS / 100L)
#define FRAME_TIME_MAX_USECS_ALLOC	(90L * FRAME_TIME_USECS / 100L)

/*
535
 * Ceiling [nano/micro]seconds (typical) for that many bytes at high speed
L
Linus Torvalds 已提交
536 537 538 539
 * ISO is a bit less, no ACK ... from USB 2.0 spec, 5.11.3 (and needed
 * to preallocate bandwidth)
 */
#define USB2_HOST_DELAY	5	/* nsec, guess */
540
#define HS_NSECS(bytes) (((55 * 8 * 2083) \
541
	+ (2083UL * (3 + BitTime(bytes))))/1000 \
L
Linus Torvalds 已提交
542
	+ USB2_HOST_DELAY)
543
#define HS_NSECS_ISO(bytes) (((38 * 8 * 2083) \
544
	+ (2083UL * (3 + BitTime(bytes))))/1000 \
L
Linus Torvalds 已提交
545
	+ USB2_HOST_DELAY)
546 547
#define HS_USECS(bytes)		NS_TO_US(HS_NSECS(bytes))
#define HS_USECS_ISO(bytes)	NS_TO_US(HS_NSECS_ISO(bytes))
L
Linus Torvalds 已提交
548

549
extern long usb_calc_bus_time(int speed, int is_input,
L
Linus Torvalds 已提交
550 551 552 553 554 555 556 557 558 559 560 561
			int isoc, int bytecount);

/*-------------------------------------------------------------------------*/

extern void usb_set_device_state(struct usb_device *udev,
		enum usb_device_state new_state);

/*-------------------------------------------------------------------------*/

/* exported only within usbcore */

extern struct list_head usb_bus_list;
562
extern struct mutex usb_bus_list_lock;
L
Linus Torvalds 已提交
563 564
extern wait_queue_head_t usb_kill_urb_queue;

565
extern int usb_find_interface_driver(struct usb_device *dev,
L
Linus Torvalds 已提交
566 567 568 569
	struct usb_interface *interface);

#define usb_endpoint_out(ep_dir)	(!((ep_dir) & USB_DIR_IN))

570
#ifdef CONFIG_PM
571
extern void usb_root_hub_lost_power(struct usb_device *rhdev);
A
Alan Stern 已提交
572 573
extern int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg);
extern int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg);
574 575 576 577
#endif /* CONFIG_PM */

#ifdef CONFIG_USB_SUSPEND
extern void usb_hcd_resume_root_hub(struct usb_hcd *hcd);
578
#else
579 580 581 582
static inline void usb_hcd_resume_root_hub(struct usb_hcd *hcd)
{
	return;
}
583 584
#endif /* CONFIG_USB_SUSPEND */

585

L
Linus Torvalds 已提交
586 587 588 589 590 591 592 593 594 595
/*
 * USB device fs stuff
 */

#ifdef CONFIG_USB_DEVICEFS

/*
 * these are expected to be called from the USB core/hub thread
 * with the kernel lock held
 */
596
extern void usbfs_update_special(void);
L
Linus Torvalds 已提交
597 598 599 600 601
extern int usbfs_init(void);
extern void usbfs_cleanup(void);

#else /* CONFIG_USB_DEVICEFS */

602
static inline void usbfs_update_special(void) {}
L
Linus Torvalds 已提交
603 604 605 606 607 608 609
static inline int usbfs_init(void) { return 0; }
static inline void usbfs_cleanup(void) { }

#endif /* CONFIG_USB_DEVICEFS */

/*-------------------------------------------------------------------------*/

610
#if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
L
Linus Torvalds 已提交
611 612 613 614

struct usb_mon_operations {
	void (*urb_submit)(struct usb_bus *bus, struct urb *urb);
	void (*urb_submit_error)(struct usb_bus *bus, struct urb *urb, int err);
615
	void (*urb_complete)(struct usb_bus *bus, struct urb *urb, int status);
L
Linus Torvalds 已提交
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633
	/* void (*urb_unlink)(struct usb_bus *bus, struct urb *urb); */
};

extern struct usb_mon_operations *mon_ops;

static inline void usbmon_urb_submit(struct usb_bus *bus, struct urb *urb)
{
	if (bus->monitored)
		(*mon_ops->urb_submit)(bus, urb);
}

static inline void usbmon_urb_submit_error(struct usb_bus *bus, struct urb *urb,
    int error)
{
	if (bus->monitored)
		(*mon_ops->urb_submit_error)(bus, urb, error);
}

634 635
static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb,
		int status)
L
Linus Torvalds 已提交
636 637
{
	if (bus->monitored)
638
		(*mon_ops->urb_complete)(bus, urb, status);
L
Linus Torvalds 已提交
639 640 641 642 643 644 645 646 647 648
}

int usb_mon_register(struct usb_mon_operations *ops);
void usb_mon_deregister(void);

#else

static inline void usbmon_urb_submit(struct usb_bus *bus, struct urb *urb) {}
static inline void usbmon_urb_submit_error(struct usb_bus *bus, struct urb *urb,
    int error) {}
649 650
static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb,
		int status) {}
L
Linus Torvalds 已提交
651

652
#endif /* CONFIG_USB_MON || CONFIG_USB_MON_MODULE */
L
Linus Torvalds 已提交
653 654 655 656 657

/*-------------------------------------------------------------------------*/

/* random stuff */

658 659
#define	RUN_CONTEXT (in_irq() ? "in_irq" \
		: (in_interrupt() ? "in_interrupt" : "can sleep"))
L
Linus Torvalds 已提交
660 661


662 663 664 665
/* This rwsem is for use only by the hub driver and ehci-hcd.
 * Nobody else should touch it.
 */
extern struct rw_semaphore ehci_cf_port_reset_rwsem;
L
Linus Torvalds 已提交
666

667 668 669 670 671 672
/* Keep track of which host controller drivers are loaded */
#define USB_UHCI_LOADED		0
#define USB_OHCI_LOADED		1
#define USB_EHCI_LOADED		2
extern unsigned long usb_hcds_loaded;

673
#endif /* __KERNEL__ */
674 675

#endif /* __USB_CORE_HCD_H */