hcd.h 22.1 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 79 80

	const char		*product_desc;	/* product/vendor string */
	char			irq_descr[24];	/* driver + bus # */

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

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

92 93 94 95
	/* 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.
	 */
96
	unsigned long		flags;
97 98 99 100
#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? */
101
#define HCD_FLAG_WAKEUP_PENDING		4	/* root hub is resuming? */
102 103 104 105 106 107 108 109

	/* 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))
110
#define HCD_WAKEUP_PENDING(hcd)	((hcd)->flags & (1U << HCD_FLAG_WAKEUP_PENDING))
111

112
	/* Flags that get set only during HCD registration or removal. */
L
Linus Torvalds 已提交
113
	unsigned		rh_registered:1;/* is root hub registered? */
114
	unsigned		rh_pollable:1;	/* may we poll the root hub? */
L
Linus Torvalds 已提交
115

116 117 118
	/* 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;
119
	unsigned		wireless:1;	/* Wireless USB HCD */
120
	unsigned		authorized_default:1;
121
	unsigned		has_tt:1;	/* Integrated TT in root hub */
122

L
Linus Torvalds 已提交
123 124 125 126
	int			irq;		/* irq allocated */
	void __iomem		*regs;		/* device memory/io */
	u64			rsrc_start;	/* memory/io resource start */
	u64			rsrc_len;	/* memory/io resource length */
127
	unsigned		power_budget;	/* in mA, 0 = no limit */
L
Linus Torvalds 已提交
128

129 130 131 132 133 134 135 136 137 138 139 140 141 142
	/* 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.
	 */
	struct mutex		bandwidth_mutex;


L
Linus Torvalds 已提交
143
#define HCD_BUFFER_POOLS	4
144
	struct dma_pool		*pool[HCD_BUFFER_POOLS];
L
Linus Torvalds 已提交
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161

	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;
162
	 * input size of periodic table to an interrupt scheduler.
L
Linus Torvalds 已提交
163 164 165 166 167 168 169
	 * (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]
170
			__attribute__ ((aligned(sizeof(unsigned long))));
L
Linus Torvalds 已提交
171 172 173
};

/* 2.4 does this a bit differently ... */
174
static inline struct usb_bus *hcd_to_bus(struct usb_hcd *hcd)
L
Linus Torvalds 已提交
175 176 177 178
{
	return &hcd->self;
}

179
static inline struct usb_hcd *bus_to_hcd(struct usb_bus *bus)
180 181 182
{
	return container_of(bus, struct usb_hcd, self);
}
L
Linus Torvalds 已提交
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197

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 */
198
	irqreturn_t	(*irq) (struct usb_hcd *hcd);
L
Linus Torvalds 已提交
199 200 201

	int	flags;
#define	HCD_MEMORY	0x0001		/* HC regs use memory (else I/O) */
M
Magnus Damm 已提交
202
#define	HCD_LOCAL_MEM	0x0002		/* HC needs local memory */
L
Linus Torvalds 已提交
203 204
#define	HCD_USB11	0x0010		/* USB 1.1 */
#define	HCD_USB2	0x0020		/* USB 2.0 */
205
#define	HCD_USB3	0x0040		/* USB 3.0 */
206
#define	HCD_MASK	0x0070
L
Linus Torvalds 已提交
207 208 209 210 211 212

	/* 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
213
	 * a whole, not just the root hub; they're for PCI bus glue.
L
Linus Torvalds 已提交
214
	 */
215
	/* called after suspending the hub, before entering D3 etc */
216
	int	(*pci_suspend)(struct usb_hcd *hcd, bool do_wakeup);
L
Linus Torvalds 已提交
217

218
	/* called after entering D0 (etc), before resuming the hub */
219
	int	(*pci_resume)(struct usb_hcd *hcd, bool hibernated);
L
Linus Torvalds 已提交
220 221 222 223

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

224 225 226
	/* shutdown HCD */
	void	(*shutdown) (struct usb_hcd *hcd);

L
Linus Torvalds 已提交
227 228 229 230
	/* return current frame number */
	int	(*get_frame_number) (struct usb_hcd *hcd);

	/* manage i/o requests, device state */
231 232 233 234
	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 已提交
235 236

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

240 241
	/* (optional) reset any endpoint state such as sequence number
	   and current window */
242
	void	(*endpoint_reset)(struct usb_hcd *hcd,
243 244
			struct usb_host_endpoint *ep);

L
Linus Torvalds 已提交
245
	/* root hub support */
246 247
	int	(*hub_status_data) (struct usb_hcd *hcd, char *buf);
	int	(*hub_control) (struct usb_hcd *hcd,
L
Linus Torvalds 已提交
248 249
				u16 typeReq, u16 wValue, u16 wIndex,
				char *buf, u16 wLength);
250 251 252
	int	(*bus_suspend)(struct usb_hcd *);
	int	(*bus_resume)(struct usb_hcd *);
	int	(*start_port_reset)(struct usb_hcd *, unsigned port_num);
253 254

		/* force handover of high-speed port to full-speed companion */
255
	void	(*relinquish_port)(struct usb_hcd *, int);
256 257
		/* has a port been handed over to a companion? */
	int	(*port_handed_over)(struct usb_hcd *, int);
258

259 260 261 262
		/* CLEAR_TT_BUFFER completion callback */
	void	(*clear_tt_buffer_complete)(struct usb_hcd *,
				struct usb_host_endpoint *);

263 264 265
	/* xHCI specific functions */
		/* Called by usb_alloc_dev to alloc HC device structures */
	int	(*alloc_dev)(struct usb_hcd *, struct usb_device *);
266
		/* Called by usb_disconnect to free HC device structures */
267
	void	(*free_dev)(struct usb_hcd *, struct usb_device *);
268 269 270 271 272 273 274 275 276 277
	/* 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);
278 279 280 281 282

	/* 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.
283 284 285 286 287
	 * 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.
288 289
	 */
		/* Allocate endpoint resources and add them to a new schedule */
290 291
	int	(*add_endpoint)(struct usb_hcd *, struct usb_device *,
				struct usb_host_endpoint *);
292
		/* Drop an endpoint from a new schedule */
293 294
	int	(*drop_endpoint)(struct usb_hcd *, struct usb_device *,
				 struct usb_host_endpoint *);
295 296 297 298 299 300 301 302 303 304 305 306 307 308
		/* 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 *);
309 310
		/* Returns the hardware-chosen device address */
	int	(*address_device)(struct usb_hcd *, struct usb_device *udev);
311 312 313 314 315
		/* 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);
316
	int	(*reset_device)(struct usb_hcd *, struct usb_device *);
317 318 319 320
		/* Notifies the HCD after a device is connected and its
		 * address is set
		 */
	int	(*update_device)(struct usb_hcd *, struct usb_device *);
L
Linus Torvalds 已提交
321 322
};

323 324 325 326 327
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);

328 329
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 已提交
330 331
extern void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb,
		int status);
332 333
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 *);
334 335 336
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 已提交
337
		struct usb_host_endpoint *ep);
338 339
extern void usb_hcd_reset_endpoint(struct usb_device *udev,
		struct usb_host_endpoint *ep);
340
extern void usb_hcd_synchronize_unlinks(struct usb_device *udev);
341
extern int usb_hcd_alloc_bandwidth(struct usb_device *udev,
342
		struct usb_host_config *new_config,
343 344
		struct usb_host_interface *old_alt,
		struct usb_host_interface *new_alt);
345
extern int usb_hcd_get_frame_number(struct usb_device *udev);
L
Linus Torvalds 已提交
346

347
extern struct usb_hcd *usb_create_hcd(const struct hc_driver *driver,
348
		struct device *dev, const char *bus_name);
349 350
extern struct usb_hcd *usb_get_hcd(struct usb_hcd *hcd);
extern void usb_put_hcd(struct usb_hcd *hcd);
L
Linus Torvalds 已提交
351 352 353 354
extern int usb_add_hcd(struct usb_hcd *hcd,
		unsigned int irqnum, unsigned long irqflags);
extern void usb_remove_hcd(struct usb_hcd *hcd);

355
struct platform_device;
356
extern void usb_hcd_platform_shutdown(struct platform_device *dev);
357

L
Linus Torvalds 已提交
358 359 360
#ifdef CONFIG_PCI
struct pci_dev;
struct pci_device_id;
361
extern int usb_hcd_pci_probe(struct pci_dev *dev,
L
Linus Torvalds 已提交
362
				const struct pci_device_id *id);
363 364
extern void usb_hcd_pci_remove(struct pci_dev *dev);
extern void usb_hcd_pci_shutdown(struct pci_dev *dev);
365

366
#ifdef CONFIG_PM_SLEEP
367
extern const struct dev_pm_ops usb_hcd_pci_pm_ops;
368
#endif
L
Linus Torvalds 已提交
369 370 371
#endif /* CONFIG_PCI */

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

375
void *hcd_buffer_alloc(struct usb_bus *bus, size_t size,
A
Al Viro 已提交
376
	gfp_t mem_flags, dma_addr_t *dma);
377
void hcd_buffer_free(struct usb_bus *bus, size_t size,
L
Linus Torvalds 已提交
378 379 380
	void *addr, dma_addr_t dma);

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

383
extern void usb_hc_died(struct usb_hcd *hcd);
384
extern void usb_hcd_poll_rh_status(struct usb_hcd *hcd);
L
Linus Torvalds 已提交
385

386 387 388 389 390 391 392
/* 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 已提交
393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
/* -------------------------------------------------------------------------- */

/* 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
 */

410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
#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 已提交
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

/* (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 已提交
473 474 475 476

/* 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 已提交
477 478 479 480 481

/*
 * Generic bandwidth allocation constants/support
 */
#define FRAME_TIME_USECS	1000L
482
#define BitTime(bytecount) (7 * 8 * bytecount / 6) /* with integer truncation */
L
Linus Torvalds 已提交
483
		/* Trying not to use worst-case bit-stuffing
484
		 * of (7/6 * 8 * bytecount) = 9.33 * bytecount */
L
Linus Torvalds 已提交
485 486 487 488 489 490 491 492 493 494 495
		/* 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 */
496
			/* 4 full-speed bit times (est.) */
L
Linus Torvalds 已提交
497

498
#define FRAME_TIME_BITS			12000L	/* frame = 1 millisecond */
L
Linus Torvalds 已提交
499 500 501 502
#define FRAME_TIME_MAX_BITS_ALLOC	(90L * FRAME_TIME_BITS / 100L)
#define FRAME_TIME_MAX_USECS_ALLOC	(90L * FRAME_TIME_USECS / 100L)

/*
503
 * Ceiling [nano/micro]seconds (typical) for that many bytes at high speed
L
Linus Torvalds 已提交
504 505 506 507
 * 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 */
508
#define HS_NSECS(bytes) (((55 * 8 * 2083) \
509
	+ (2083UL * (3 + BitTime(bytes))))/1000 \
L
Linus Torvalds 已提交
510
	+ USB2_HOST_DELAY)
511
#define HS_NSECS_ISO(bytes) (((38 * 8 * 2083) \
512
	+ (2083UL * (3 + BitTime(bytes))))/1000 \
L
Linus Torvalds 已提交
513
	+ USB2_HOST_DELAY)
514 515
#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 已提交
516

517
extern long usb_calc_bus_time(int speed, int is_input,
L
Linus Torvalds 已提交
518 519 520 521 522 523 524 525 526 527 528 529
			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;
530
extern struct mutex usb_bus_list_lock;
L
Linus Torvalds 已提交
531 532
extern wait_queue_head_t usb_kill_urb_queue;

533
extern int usb_find_interface_driver(struct usb_device *dev,
L
Linus Torvalds 已提交
534 535 536 537
	struct usb_interface *interface);

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

538
#ifdef CONFIG_PM
539
extern void usb_root_hub_lost_power(struct usb_device *rhdev);
A
Alan Stern 已提交
540 541
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);
542 543 544 545
#endif /* CONFIG_PM */

#ifdef CONFIG_USB_SUSPEND
extern void usb_hcd_resume_root_hub(struct usb_hcd *hcd);
546
#else
547 548 549 550
static inline void usb_hcd_resume_root_hub(struct usb_hcd *hcd)
{
	return;
}
551 552
#endif /* CONFIG_USB_SUSPEND */

553

L
Linus Torvalds 已提交
554 555 556 557 558 559 560 561 562 563
/*
 * 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
 */
564
extern void usbfs_update_special(void);
L
Linus Torvalds 已提交
565 566 567 568 569
extern int usbfs_init(void);
extern void usbfs_cleanup(void);

#else /* CONFIG_USB_DEVICEFS */

570
static inline void usbfs_update_special(void) {}
L
Linus Torvalds 已提交
571 572 573 574 575 576 577
static inline int usbfs_init(void) { return 0; }
static inline void usbfs_cleanup(void) { }

#endif /* CONFIG_USB_DEVICEFS */

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

578
#if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
L
Linus Torvalds 已提交
579 580 581 582

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);
583
	void (*urb_complete)(struct usb_bus *bus, struct urb *urb, int status);
L
Linus Torvalds 已提交
584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
	/* 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);
}

602 603
static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb,
		int status)
L
Linus Torvalds 已提交
604 605
{
	if (bus->monitored)
606
		(*mon_ops->urb_complete)(bus, urb, status);
L
Linus Torvalds 已提交
607 608 609 610 611 612 613 614 615 616
}

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) {}
617 618
static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb,
		int status) {}
L
Linus Torvalds 已提交
619

620
#endif /* CONFIG_USB_MON || CONFIG_USB_MON_MODULE */
L
Linus Torvalds 已提交
621 622 623 624

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

/* hub.h ... DeviceRemovable in 2.4.2-ac11, gone in 2.4.10 */
625
/* bleech -- resurfaced in 2.4.11 or 2.4.12 */
626
#define bitmap	DeviceRemovable
L
Linus Torvalds 已提交
627 628 629 630 631 632


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

/* random stuff */

633 634
#define	RUN_CONTEXT (in_irq() ? "in_irq" \
		: (in_interrupt() ? "in_interrupt" : "can sleep"))
L
Linus Torvalds 已提交
635 636


637 638 639 640
/* 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 已提交
641

642 643 644 645 646 647
/* 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;

648
#endif /* __KERNEL__ */
649 650

#endif /* __USB_CORE_HCD_H */