hub.c 120.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * USB hub driver.
 *
 * (C) Copyright 1999 Linus Torvalds
 * (C) Copyright 1999 Johannes Erdfelt
 * (C) Copyright 1999 Gregory P. Smith
 * (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)
 *
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/completion.h>
#include <linux/sched.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <linux/ioctl.h>
#include <linux/usb.h>
#include <linux/usbdevice_fs.h>
22
#include <linux/usb/hcd.h>
23
#include <linux/usb/quirks.h>
24
#include <linux/kthread.h>
25
#include <linux/mutex.h>
26
#include <linux/freezer.h>
L
Linus Torvalds 已提交
27 28 29 30 31 32

#include <asm/uaccess.h>
#include <asm/byteorder.h>

#include "usb.h"

33 34 35 36 37 38 39
/* if we are in debug mode, always announce new devices */
#ifdef DEBUG
#ifndef CONFIG_USB_ANNOUNCE_NEW_DEVICES
#define CONFIG_USB_ANNOUNCE_NEW_DEVICES
#endif
#endif

40 41 42 43
struct usb_hub_port {
	void			*port_owner;
};

44 45 46
struct usb_hub {
	struct device		*intfdev;	/* the "interface" device */
	struct usb_device	*hdev;
47
	struct kref		kref;
48 49 50 51 52 53 54 55
	struct urb		*urb;		/* for interrupt polling pipe */

	/* buffer for urb ... with extra space in case of babble */
	char			(*buffer)[8];
	union {
		struct usb_hub_status	hub;
		struct usb_port_status	port;
	}			*status;	/* buffer for status reports */
56
	struct mutex		status_mutex;	/* for the status buffer */
57 58 59 60 61 62 63 64 65 66

	int			error;		/* last reported error */
	int			nerrors;	/* track consecutive errors */

	struct list_head	event_list;	/* hubs w/data or errs ready */
	unsigned long		event_bits[1];	/* status change bitmask */
	unsigned long		change_bits[1];	/* ports with logical connect
							status change */
	unsigned long		busy_bits[1];	/* ports being reset or
							resumed */
67 68
	unsigned long		removed_bits[1]; /* ports with a "removed"
							device present */
69 70
	unsigned long		wakeup_bits[1];	/* ports that have signaled
							remote wakeup */
71 72 73 74 75 76 77 78 79 80 81
#if USB_MAXCHILDREN > 31 /* 8*sizeof(unsigned long) - 1 */
#error event_bits[] is too short!
#endif

	struct usb_hub_descriptor *descriptor;	/* class descriptor */
	struct usb_tt		tt;		/* Transaction Translator */

	unsigned		mA_per_port;	/* current for each child */

	unsigned		limited_power:1;
	unsigned		quiescing:1;
82
	unsigned		disconnected:1;
83 84 85

	unsigned		has_indicators:1;
	u8			indicator[USB_MAXCHILDREN];
86
	struct delayed_work	leds;
87
	struct delayed_work	init_work;
88
	struct usb_hub_port	*port_data;
89 90
};

J
John Youn 已提交
91 92
static inline int hub_is_superspeed(struct usb_device *hdev)
{
93
	return (hdev->descriptor.bDeviceProtocol == USB_HUB_PR_SS);
J
John Youn 已提交
94
}
95

L
Linus Torvalds 已提交
96
/* Protect struct usb_device->state and ->children members
97
 * Note: Both are also protected by ->dev.sem, except that ->state can
L
Linus Torvalds 已提交
98 99 100 101 102 103 104 105 106 107
 * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
static DEFINE_SPINLOCK(device_state_lock);

/* khubd's worklist and its lock */
static DEFINE_SPINLOCK(hub_event_lock);
static LIST_HEAD(hub_event_list);	/* List of hubs needing servicing */

/* Wakes up khubd */
static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);

108
static struct task_struct *khubd_task;
L
Linus Torvalds 已提交
109 110

/* cycle leds on hubs that aren't blinking for attention */
111
static bool blinkenlights = 0;
L
Linus Torvalds 已提交
112 113 114
module_param (blinkenlights, bool, S_IRUGO);
MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs");

115 116 117 118 119 120 121
/*
 * Device SATA8000 FW1.0 from DATAST0R Technology Corp requires about
 * 10 seconds to send reply for the initial 64-byte descriptor request.
 */
/* define initial 64-byte descriptor request timeout in milliseconds */
static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT;
module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR);
122 123 124
MODULE_PARM_DESC(initial_descriptor_timeout,
		"initial 64-byte descriptor request timeout in milliseconds "
		"(default 5000 - 5.0 seconds)");
125

L
Linus Torvalds 已提交
126 127 128 129 130 131 132 133 134 135 136 137 138 139
/*
 * As of 2.6.10 we introduce a new USB device initialization scheme which
 * closely resembles the way Windows works.  Hopefully it will be compatible
 * with a wider range of devices than the old scheme.  However some previously
 * working devices may start giving rise to "device not accepting address"
 * errors; if that happens the user can try the old scheme by adjusting the
 * following module parameters.
 *
 * For maximum flexibility there are two boolean parameters to control the
 * hub driver's behavior.  On the first initialization attempt, if the
 * "old_scheme_first" parameter is set then the old scheme will be used,
 * otherwise the new scheme is used.  If that fails and "use_both_schemes"
 * is set, then the driver will make another attempt, using the other scheme.
 */
140
static bool old_scheme_first = 0;
L
Linus Torvalds 已提交
141 142 143 144
module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(old_scheme_first,
		 "start with the old device initialization scheme");

145
static bool use_both_schemes = 1;
L
Linus Torvalds 已提交
146 147 148 149 150
module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(use_both_schemes,
		"try the other device initialization scheme if the "
		"first one fails");

151 152 153 154 155 156
/* Mutual exclusion for EHCI CF initialization.  This interferes with
 * port reset on some companion controllers.
 */
DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);

157 158 159 160
#define HUB_DEBOUNCE_TIMEOUT	1500
#define HUB_DEBOUNCE_STEP	  25
#define HUB_DEBOUNCE_STABLE	 100

L
Linus Torvalds 已提交
161

162 163
static int usb_reset_and_verify_device(struct usb_device *udev);

164
static inline char *portspeed(struct usb_hub *hub, int portstatus)
L
Linus Torvalds 已提交
165
{
166 167
	if (hub_is_superspeed(hub->hdev))
		return "5.0 Gb/s";
168
	if (portstatus & USB_PORT_STAT_HIGH_SPEED)
L
Linus Torvalds 已提交
169
    		return "480 Mb/s";
170
	else if (portstatus & USB_PORT_STAT_LOW_SPEED)
L
Linus Torvalds 已提交
171 172 173 174 175 176
		return "1.5 Mb/s";
	else
		return "12 Mb/s";
}

/* Note that hdev or one of its children must be locked! */
177
static struct usb_hub *hdev_to_hub(struct usb_device *hdev)
L
Linus Torvalds 已提交
178
{
179 180
	if (!hdev || !hdev->actconfig)
		return NULL;
L
Linus Torvalds 已提交
181 182 183 184
	return usb_get_intfdata(hdev->actconfig->interface[0]);
}

/* USB 2.0 spec Section 11.24.4.5 */
J
John Youn 已提交
185
static int get_hub_descriptor(struct usb_device *hdev, void *data)
L
Linus Torvalds 已提交
186
{
J
John Youn 已提交
187 188 189 190 191 192 193 194 195 196
	int i, ret, size;
	unsigned dtype;

	if (hub_is_superspeed(hdev)) {
		dtype = USB_DT_SS_HUB;
		size = USB_DT_SS_HUB_SIZE;
	} else {
		dtype = USB_DT_HUB;
		size = sizeof(struct usb_hub_descriptor);
	}
L
Linus Torvalds 已提交
197 198 199 200

	for (i = 0; i < 3; i++) {
		ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
			USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
J
John Youn 已提交
201
			dtype << 8, 0, data, size,
L
Linus Torvalds 已提交
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
			USB_CTRL_GET_TIMEOUT);
		if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))
			return ret;
	}
	return -EINVAL;
}

/*
 * USB 2.0 spec Section 11.24.2.1
 */
static int clear_hub_feature(struct usb_device *hdev, int feature)
{
	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
		USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
}

/*
 * USB 2.0 spec Section 11.24.2.2
 */
static int clear_port_feature(struct usb_device *hdev, int port1, int feature)
{
	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
		USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
		NULL, 0, 1000);
}

/*
 * USB 2.0 spec Section 11.24.2.13
 */
static int set_port_feature(struct usb_device *hdev, int port1, int feature)
{
	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
		USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
		NULL, 0, 1000);
}

/*
 * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
 * for info about using port indicators
 */
static void set_port_led(
	struct usb_hub *hub,
	int port1,
	int selector
)
{
	int status = set_port_feature(hub->hdev, (selector << 8) | port1,
			USB_PORT_FEAT_INDICATOR);
	if (status < 0)
		dev_dbg (hub->intfdev,
			"port %d indicator %s status %d\n",
			port1,
			({ char *s; switch (selector) {
			case HUB_LED_AMBER: s = "amber"; break;
			case HUB_LED_GREEN: s = "green"; break;
			case HUB_LED_OFF: s = "off"; break;
			case HUB_LED_AUTO: s = "auto"; break;
			default: s = "??"; break;
			}; s; }),
			status);
}

#define	LED_CYCLE_PERIOD	((2*HZ)/3)

D
David Howells 已提交
266
static void led_work (struct work_struct *work)
L
Linus Torvalds 已提交
267
{
D
David Howells 已提交
268 269
	struct usb_hub		*hub =
		container_of(work, struct usb_hub, leds.work);
L
Linus Torvalds 已提交
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
	struct usb_device	*hdev = hub->hdev;
	unsigned		i;
	unsigned		changed = 0;
	int			cursor = -1;

	if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
		return;

	for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
		unsigned	selector, mode;

		/* 30%-50% duty cycle */

		switch (hub->indicator[i]) {
		/* cycle marker */
		case INDICATOR_CYCLE:
			cursor = i;
			selector = HUB_LED_AUTO;
			mode = INDICATOR_AUTO;
			break;
		/* blinking green = sw attention */
		case INDICATOR_GREEN_BLINK:
			selector = HUB_LED_GREEN;
			mode = INDICATOR_GREEN_BLINK_OFF;
			break;
		case INDICATOR_GREEN_BLINK_OFF:
			selector = HUB_LED_OFF;
			mode = INDICATOR_GREEN_BLINK;
			break;
		/* blinking amber = hw attention */
		case INDICATOR_AMBER_BLINK:
			selector = HUB_LED_AMBER;
			mode = INDICATOR_AMBER_BLINK_OFF;
			break;
		case INDICATOR_AMBER_BLINK_OFF:
			selector = HUB_LED_OFF;
			mode = INDICATOR_AMBER_BLINK;
			break;
		/* blink green/amber = reserved */
		case INDICATOR_ALT_BLINK:
			selector = HUB_LED_GREEN;
			mode = INDICATOR_ALT_BLINK_OFF;
			break;
		case INDICATOR_ALT_BLINK_OFF:
			selector = HUB_LED_AMBER;
			mode = INDICATOR_ALT_BLINK;
			break;
		default:
			continue;
		}
		if (selector != HUB_LED_AUTO)
			changed = 1;
		set_port_led(hub, i + 1, selector);
		hub->indicator[i] = mode;
	}
	if (!changed && blinkenlights) {
		cursor++;
		cursor %= hub->descriptor->bNbrPorts;
		set_port_led(hub, cursor + 1, HUB_LED_GREEN);
		hub->indicator[cursor] = INDICATOR_CYCLE;
		changed++;
	}
	if (changed)
		schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
}

/* use a short timeout for hub/port status fetches */
#define	USB_STS_TIMEOUT		1000
#define	USB_STS_RETRIES		5

/*
 * USB 2.0 spec Section 11.24.2.6
 */
static int get_hub_status(struct usb_device *hdev,
		struct usb_hub_status *data)
{
	int i, status = -ETIMEDOUT;

348 349
	for (i = 0; i < USB_STS_RETRIES &&
			(status == -ETIMEDOUT || status == -EPIPE); i++) {
L
Linus Torvalds 已提交
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
		status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
			data, sizeof(*data), USB_STS_TIMEOUT);
	}
	return status;
}

/*
 * USB 2.0 spec Section 11.24.2.7
 */
static int get_port_status(struct usb_device *hdev, int port1,
		struct usb_port_status *data)
{
	int i, status = -ETIMEDOUT;

365 366
	for (i = 0; i < USB_STS_RETRIES &&
			(status == -ETIMEDOUT || status == -EPIPE); i++) {
L
Linus Torvalds 已提交
367 368 369 370 371 372 373
		status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1,
			data, sizeof(*data), USB_STS_TIMEOUT);
	}
	return status;
}

A
Alan Stern 已提交
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
static int hub_port_status(struct usb_hub *hub, int port1,
		u16 *status, u16 *change)
{
	int ret;

	mutex_lock(&hub->status_mutex);
	ret = get_port_status(hub->hdev, port1, &hub->status->port);
	if (ret < 4) {
		dev_err(hub->intfdev,
			"%s failed (err = %d)\n", __func__, ret);
		if (ret >= 0)
			ret = -EIO;
	} else {
		*status = le16_to_cpu(hub->status->port.wPortStatus);
		*change = le16_to_cpu(hub->status->port.wPortChange);
J
John Youn 已提交
389

A
Alan Stern 已提交
390 391 392 393 394 395
		ret = 0;
	}
	mutex_unlock(&hub->status_mutex);
	return ret;
}

L
Linus Torvalds 已提交
396 397 398 399 400
static void kick_khubd(struct usb_hub *hub)
{
	unsigned long	flags;

	spin_lock_irqsave(&hub_event_lock, flags);
401
	if (!hub->disconnected && list_empty(&hub->event_list)) {
L
Linus Torvalds 已提交
402
		list_add_tail(&hub->event_list, &hub_event_list);
403 404 405 406

		/* Suppress autosuspend until khubd runs */
		usb_autopm_get_interface_no_resume(
				to_usb_interface(hub->intfdev));
L
Linus Torvalds 已提交
407 408 409 410 411 412 413
		wake_up(&khubd_wait);
	}
	spin_unlock_irqrestore(&hub_event_lock, flags);
}

void usb_kick_khubd(struct usb_device *hdev)
{
414 415 416 417
	struct usb_hub *hub = hdev_to_hub(hdev);

	if (hub)
		kick_khubd(hub);
L
Linus Torvalds 已提交
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
/*
 * Let the USB core know that a USB 3.0 device has sent a Function Wake Device
 * Notification, which indicates it had initiated remote wakeup.
 *
 * USB 3.0 hubs do not report the port link state change from U3 to U0 when the
 * device initiates resume, so the USB core will not receive notice of the
 * resume through the normal hub interrupt URB.
 */
void usb_wakeup_notification(struct usb_device *hdev,
		unsigned int portnum)
{
	struct usb_hub *hub;

	if (!hdev)
		return;

	hub = hdev_to_hub(hdev);
	if (hub) {
		set_bit(portnum, hub->wakeup_bits);
		kick_khubd(hub);
	}
}
EXPORT_SYMBOL_GPL(usb_wakeup_notification);
L
Linus Torvalds 已提交
443 444

/* completion function, fires on port status changes and various faults */
445
static void hub_irq(struct urb *urb)
L
Linus Torvalds 已提交
446
{
447
	struct usb_hub *hub = urb->context;
448
	int status = urb->status;
449
	unsigned i;
L
Linus Torvalds 已提交
450 451
	unsigned long bits;

452
	switch (status) {
L
Linus Torvalds 已提交
453 454 455 456 457 458 459
	case -ENOENT:		/* synchronous unlink */
	case -ECONNRESET:	/* async unlink */
	case -ESHUTDOWN:	/* hardware going away */
		return;

	default:		/* presumably an error */
		/* Cause a hub reset after 10 consecutive errors */
460
		dev_dbg (hub->intfdev, "transfer --> %d\n", status);
L
Linus Torvalds 已提交
461 462
		if ((++hub->nerrors < 10) || hub->error)
			goto resubmit;
463
		hub->error = status;
L
Linus Torvalds 已提交
464
		/* FALL THROUGH */
465

L
Linus Torvalds 已提交
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
	/* let khubd handle things */
	case 0:			/* we got data:  port status changed */
		bits = 0;
		for (i = 0; i < urb->actual_length; ++i)
			bits |= ((unsigned long) ((*hub->buffer)[i]))
					<< (i*8);
		hub->event_bits[0] = bits;
		break;
	}

	hub->nerrors = 0;

	/* Something happened, let khubd figure it out */
	kick_khubd(hub);

resubmit:
	if (hub->quiescing)
		return;

	if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0
			&& status != -ENODEV && status != -EPERM)
		dev_err (hub->intfdev, "resubmit --> %d\n", status);
}

/* USB 2.0 spec Section 11.24.2.3 */
static inline int
hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)
{
494
	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
L
Linus Torvalds 已提交
495 496 497 498 499 500 501 502 503 504
			       HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
			       tt, NULL, 0, 1000);
}

/*
 * enumeration blocks khubd for a long time. we use keventd instead, since
 * long blocking there is the exception, not the rule.  accordingly, HCDs
 * talking to TTs must queue control transfers (not just bulk and iso), so
 * both can talk to the same hub concurrently.
 */
505
static void hub_tt_work(struct work_struct *work)
L
Linus Torvalds 已提交
506
{
D
David Howells 已提交
507
	struct usb_hub		*hub =
508
		container_of(work, struct usb_hub, tt.clear_work);
L
Linus Torvalds 已提交
509
	unsigned long		flags;
510
	int			limit = 100;
L
Linus Torvalds 已提交
511 512

	spin_lock_irqsave (&hub->tt.lock, flags);
513
	while (--limit && !list_empty (&hub->tt.clear_list)) {
514
		struct list_head	*next;
L
Linus Torvalds 已提交
515 516
		struct usb_tt_clear	*clear;
		struct usb_device	*hdev = hub->hdev;
517
		const struct hc_driver	*drv;
L
Linus Torvalds 已提交
518 519
		int			status;

520 521
		next = hub->tt.clear_list.next;
		clear = list_entry (next, struct usb_tt_clear, clear_list);
L
Linus Torvalds 已提交
522 523 524 525 526 527 528 529 530
		list_del (&clear->clear_list);

		/* drop lock so HCD can concurrently report other TT errors */
		spin_unlock_irqrestore (&hub->tt.lock, flags);
		status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt);
		if (status)
			dev_err (&hdev->dev,
				"clear tt %d (%04x) error %d\n",
				clear->tt, clear->devinfo, status);
531 532 533 534 535 536

		/* Tell the HCD, even if the operation failed */
		drv = clear->hcd->driver;
		if (drv->clear_tt_buffer_complete)
			(drv->clear_tt_buffer_complete)(clear->hcd, clear->ep);

537
		kfree(clear);
538
		spin_lock_irqsave(&hub->tt.lock, flags);
L
Linus Torvalds 已提交
539 540 541 542 543
	}
	spin_unlock_irqrestore (&hub->tt.lock, flags);
}

/**
544 545
 * usb_hub_clear_tt_buffer - clear control/bulk TT state in high speed hub
 * @urb: an URB associated with the failed or incomplete split transaction
L
Linus Torvalds 已提交
546 547 548 549 550 551 552 553 554
 *
 * High speed HCDs use this to tell the hub driver that some split control or
 * bulk transaction failed in a way that requires clearing internal state of
 * a transaction translator.  This is normally detected (and reported) from
 * interrupt context.
 *
 * It may not be possible for that hub to handle additional full (or low)
 * speed transactions until that state is fully cleared out.
 */
555
int usb_hub_clear_tt_buffer(struct urb *urb)
L
Linus Torvalds 已提交
556
{
557 558
	struct usb_device	*udev = urb->dev;
	int			pipe = urb->pipe;
L
Linus Torvalds 已提交
559 560 561 562 563 564 565 566
	struct usb_tt		*tt = udev->tt;
	unsigned long		flags;
	struct usb_tt_clear	*clear;

	/* we've got to cope with an arbitrary number of pending TT clears,
	 * since each TT has "at least two" buffers that can need it (and
	 * there can be many TTs per hub).  even if they're uncommon.
	 */
567
	if ((clear = kmalloc (sizeof *clear, GFP_ATOMIC)) == NULL) {
L
Linus Torvalds 已提交
568 569
		dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
		/* FIXME recover somehow ... RESET_TT? */
570
		return -ENOMEM;
L
Linus Torvalds 已提交
571 572 573 574 575 576 577 578 579 580 581
	}

	/* info that CLEAR_TT_BUFFER needs */
	clear->tt = tt->multi ? udev->ttport : 1;
	clear->devinfo = usb_pipeendpoint (pipe);
	clear->devinfo |= udev->devnum << 4;
	clear->devinfo |= usb_pipecontrol (pipe)
			? (USB_ENDPOINT_XFER_CONTROL << 11)
			: (USB_ENDPOINT_XFER_BULK << 11);
	if (usb_pipein (pipe))
		clear->devinfo |= 1 << 15;
582 583 584 585 586

	/* info for completion callback */
	clear->hcd = bus_to_hcd(udev->bus);
	clear->ep = urb->ep;

L
Linus Torvalds 已提交
587 588 589
	/* tell keventd to clear state for this TT */
	spin_lock_irqsave (&tt->lock, flags);
	list_add_tail (&clear->clear_list, &tt->clear_list);
590
	schedule_work(&tt->clear_work);
L
Linus Torvalds 已提交
591
	spin_unlock_irqrestore (&tt->lock, flags);
592
	return 0;
L
Linus Torvalds 已提交
593
}
594
EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
L
Linus Torvalds 已提交
595

596 597 598 599
/* If do_delay is false, return the number of milliseconds the caller
 * needs to delay.
 */
static unsigned hub_power_on(struct usb_hub *hub, bool do_delay)
L
Linus Torvalds 已提交
600 601
{
	int port1;
602
	unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
603
	unsigned delay;
604 605 606 607 608 609 610 611 612 613
	u16 wHubCharacteristics =
			le16_to_cpu(hub->descriptor->wHubCharacteristics);

	/* Enable power on each port.  Some hubs have reserved values
	 * of LPSM (> 2) in their descriptors, even though they are
	 * USB 2.0 hubs.  Some hubs do not implement port-power switching
	 * but only emulate it.  In all cases, the ports won't work
	 * unless we send these messages to the hub.
	 */
	if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2)
L
Linus Torvalds 已提交
614
		dev_dbg(hub->intfdev, "enabling power on all ports\n");
615 616 617 618 619
	else
		dev_dbg(hub->intfdev, "trying to enable port power on "
				"non-switchable hub\n");
	for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++)
		set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
L
Linus Torvalds 已提交
620

621
	/* Wait at least 100 msec for power to become stable */
622 623 624 625
	delay = max(pgood_delay, (unsigned) 100);
	if (do_delay)
		msleep(delay);
	return delay;
L
Linus Torvalds 已提交
626 627 628 629 630 631 632
}

static int hub_hub_status(struct usb_hub *hub,
		u16 *status, u16 *change)
{
	int ret;

633
	mutex_lock(&hub->status_mutex);
L
Linus Torvalds 已提交
634 635 636
	ret = get_hub_status(hub->hdev, &hub->status->hub);
	if (ret < 0)
		dev_err (hub->intfdev,
637
			"%s failed (err = %d)\n", __func__, ret);
L
Linus Torvalds 已提交
638 639 640 641 642
	else {
		*status = le16_to_cpu(hub->status->hub.wHubStatus);
		*change = le16_to_cpu(hub->status->hub.wHubChange); 
		ret = 0;
	}
643
	mutex_unlock(&hub->status_mutex);
L
Linus Torvalds 已提交
644 645 646
	return ret;
}

647 648 649
static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
{
	struct usb_device *hdev = hub->hdev;
A
Alan Stern 已提交
650
	int ret = 0;
651

A
Alan Stern 已提交
652
	if (hdev->children[port1-1] && set_state)
653 654
		usb_set_device_state(hdev->children[port1-1],
				USB_STATE_NOTATTACHED);
J
John Youn 已提交
655
	if (!hub->error && !hub_is_superspeed(hub->hdev))
A
Alan Stern 已提交
656
		ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
657 658
	if (ret)
		dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
A
Alan Stern 已提交
659
				port1, ret);
660 661 662
	return ret;
}

A
Alan Stern 已提交
663
/*
664
 * Disable a port and mark a logical connect-change event, so that some
A
Alan Stern 已提交
665 666 667 668 669 670 671
 * time later khubd will disconnect() any existing usb_device on the port
 * and will re-enumerate if there actually is a device attached.
 */
static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
{
	dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1);
	hub_port_disable(hub, port1, 1);
672

A
Alan Stern 已提交
673 674 675 676 677 678 679 680 681 682 683 684 685
	/* FIXME let caller ask to power down the port:
	 *  - some devices won't enumerate without a VBUS power cycle
	 *  - SRP saves power that way
	 *  - ... new call, TBD ...
	 * That's easy if this hub can switch power per-port, and
	 * khubd reactivates the port later (timer, SRP, etc).
	 * Powerdown must be optional, because of reset/DFU.
	 */

	set_bit(port1, hub->change_bits);
 	kick_khubd(hub);
}

686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
/**
 * usb_remove_device - disable a device's port on its parent hub
 * @udev: device to be disabled and removed
 * Context: @udev locked, must be able to sleep.
 *
 * After @udev's port has been disabled, khubd is notified and it will
 * see that the device has been disconnected.  When the device is
 * physically unplugged and something is plugged in, the events will
 * be received and processed normally.
 */
int usb_remove_device(struct usb_device *udev)
{
	struct usb_hub *hub;
	struct usb_interface *intf;

	if (!udev->parent)	/* Can't remove a root hub */
		return -EINVAL;
	hub = hdev_to_hub(udev->parent);
	intf = to_usb_interface(hub->intfdev);

	usb_autopm_get_interface(intf);
	set_bit(udev->portnum, hub->removed_bits);
	hub_port_logical_disconnect(hub, udev->portnum);
	usb_autopm_put_interface(intf);
	return 0;
}

A
Alan Stern 已提交
713
enum hub_activation_type {
714
	HUB_INIT, HUB_INIT2, HUB_INIT3,		/* INITs must come first */
715
	HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
A
Alan Stern 已提交
716
};
717

718 719 720
static void hub_init_func2(struct work_struct *ws);
static void hub_init_func3(struct work_struct *ws);

721
static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
722 723
{
	struct usb_device *hdev = hub->hdev;
724 725
	struct usb_hcd *hcd;
	int ret;
726
	int port1;
727
	int status;
728
	bool need_debounce_delay = false;
729 730 731 732 733 734 735
	unsigned delay;

	/* Continue a partial initialization */
	if (type == HUB_INIT2)
		goto init2;
	if (type == HUB_INIT3)
		goto init3;
736

737 738 739 740 741 742 743 744
	/* The superspeed hub except for root hub has to use Hub Depth
	 * value as an offset into the route string to locate the bits
	 * it uses to determine the downstream port number. So hub driver
	 * should send a set hub depth request to superspeed hub after
	 * the superspeed hub is set configuration in initialization or
	 * reset procedure.
	 *
	 * After a resume, port power should still be on.
745 746
	 * For any other type of activation, turn it on.
	 */
747
	if (type != HUB_RESUME) {
748 749 750 751 752 753 754 755 756
		if (hdev->parent && hub_is_superspeed(hdev)) {
			ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
					HUB_SET_DEPTH, USB_RT_HUB,
					hdev->level - 1, 0, NULL, 0,
					USB_CTRL_SET_TIMEOUT);
			if (ret < 0)
				dev_err(hub->intfdev,
						"set hub depth failed\n");
		}
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774

		/* Speed up system boot by using a delayed_work for the
		 * hub's initial power-up delays.  This is pretty awkward
		 * and the implementation looks like a home-brewed sort of
		 * setjmp/longjmp, but it saves at least 100 ms for each
		 * root hub (assuming usbcore is compiled into the kernel
		 * rather than as a module).  It adds up.
		 *
		 * This can't be done for HUB_RESUME or HUB_RESET_RESUME
		 * because for those activation types the ports have to be
		 * operational when we return.  In theory this could be done
		 * for HUB_POST_RESET, but it's easier not to.
		 */
		if (type == HUB_INIT) {
			delay = hub_power_on(hub, false);
			PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func2);
			schedule_delayed_work(&hub->init_work,
					msecs_to_jiffies(delay));
775 776

			/* Suppress autosuspend until init is done */
777 778
			usb_autopm_get_interface_no_resume(
					to_usb_interface(hub->intfdev));
779
			return;		/* Continues at init2: below */
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
		} else if (type == HUB_RESET_RESUME) {
			/* The internal host controller state for the hub device
			 * may be gone after a host power loss on system resume.
			 * Update the device's info so the HW knows it's a hub.
			 */
			hcd = bus_to_hcd(hdev->bus);
			if (hcd->driver->update_hub_device) {
				ret = hcd->driver->update_hub_device(hcd, hdev,
						&hub->tt, GFP_NOIO);
				if (ret < 0) {
					dev_err(hub->intfdev, "Host not "
							"accepting hub info "
							"update.\n");
					dev_err(hub->intfdev, "LS/FS devices "
							"and hubs may not work "
							"under this hub\n.");
				}
			}
			hub_power_on(hub, true);
799 800 801 802 803
		} else {
			hub_power_on(hub, true);
		}
	}
 init2:
804

A
Alan Stern 已提交
805 806
	/* Check each port and set hub->change_bits to let khubd know
	 * which ports need attention.
807 808 809 810 811
	 */
	for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
		struct usb_device *udev = hdev->children[port1-1];
		u16 portstatus, portchange;

A
Alan Stern 已提交
812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
		portstatus = portchange = 0;
		status = hub_port_status(hub, port1, &portstatus, &portchange);
		if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
			dev_dbg(hub->intfdev,
					"port %d: status %04x change %04x\n",
					port1, portstatus, portchange);

		/* After anything other than HUB_RESUME (i.e., initialization
		 * or any sort of reset), every port should be disabled.
		 * Unconnected ports should likewise be disabled (paranoia),
		 * and so should ports for which we have no usb_device.
		 */
		if ((portstatus & USB_PORT_STAT_ENABLE) && (
				type != HUB_RESUME ||
				!(portstatus & USB_PORT_STAT_CONNECTION) ||
				!udev ||
				udev->state == USB_STATE_NOTATTACHED)) {
829 830 831 832 833
			/*
			 * USB3 protocol ports will automatically transition
			 * to Enabled state when detect an USB3.0 device attach.
			 * Do not disable USB3 protocol ports.
			 */
834
			if (!hub_is_superspeed(hdev)) {
835 836 837
				clear_port_feature(hdev, port1,
						   USB_PORT_FEAT_ENABLE);
				portstatus &= ~USB_PORT_STAT_ENABLE;
838 839 840
			} else {
				/* Pretend that power was lost for USB3 devs */
				portstatus &= ~USB_PORT_STAT_ENABLE;
841
			}
842 843
		}

844 845 846 847 848 849 850 851 852 853 854
		/* Clear status-change flags; we'll debounce later */
		if (portchange & USB_PORT_STAT_C_CONNECTION) {
			need_debounce_delay = true;
			clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_CONNECTION);
		}
		if (portchange & USB_PORT_STAT_C_ENABLE) {
			need_debounce_delay = true;
			clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_ENABLE);
		}
855 856 857 858 859 860
		if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
				hub_is_superspeed(hub->hdev)) {
			need_debounce_delay = true;
			clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_BH_PORT_RESET);
		}
861 862 863 864 865 866 867
		/* We can forget about a "removed" device when there's a
		 * physical disconnect or the connect status changes.
		 */
		if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
				(portchange & USB_PORT_STAT_C_CONNECTION))
			clear_bit(port1, hub->removed_bits);

A
Alan Stern 已提交
868 869 870 871 872 873 874 875
		if (!udev || udev->state == USB_STATE_NOTATTACHED) {
			/* Tell khubd to disconnect the device or
			 * check for a new connection
			 */
			if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
				set_bit(port1, hub->change_bits);

		} else if (portstatus & USB_PORT_STAT_ENABLE) {
876 877 878
			bool port_resumed = (portstatus &
					USB_PORT_STAT_LINK_STATE) ==
				USB_SS_PORT_LS_U0;
A
Alan Stern 已提交
879 880 881
			/* The power session apparently survived the resume.
			 * If there was an overcurrent or suspend change
			 * (i.e., remote wakeup request), have khubd
882 883 884 885
			 * take care of it.  Look at the port link state
			 * for USB 3.0 hubs, since they don't have a suspend
			 * change bit, and they don't set the port link change
			 * bit on device-initiated resume.
A
Alan Stern 已提交
886
			 */
887 888
			if (portchange || (hub_is_superspeed(hub->hdev) &&
						port_resumed))
A
Alan Stern 已提交
889
				set_bit(port1, hub->change_bits);
890

A
Alan Stern 已提交
891 892
		} else if (udev->persist_enabled) {
#ifdef CONFIG_PM
893
			udev->reset_resume = 1;
A
Alan Stern 已提交
894
#endif
895 896
			set_bit(port1, hub->change_bits);

A
Alan Stern 已提交
897 898 899 900
		} else {
			/* The power session is gone; tell khubd */
			usb_set_device_state(udev, USB_STATE_NOTATTACHED);
			set_bit(port1, hub->change_bits);
901 902 903
		}
	}

904 905 906 907 908 909 910 911
	/* If no port-status-change flags were set, we don't need any
	 * debouncing.  If flags were set we can try to debounce the
	 * ports all at once right now, instead of letting khubd do them
	 * one at a time later on.
	 *
	 * If any port-status changes do occur during this delay, khubd
	 * will see them later and handle them normally.
	 */
912 913 914 915 916 917 918 919 920 921 922 923 924 925
	if (need_debounce_delay) {
		delay = HUB_DEBOUNCE_STABLE;

		/* Don't do a long sleep inside a workqueue routine */
		if (type == HUB_INIT2) {
			PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func3);
			schedule_delayed_work(&hub->init_work,
					msecs_to_jiffies(delay));
			return;		/* Continues at init3: below */
		} else {
			msleep(delay);
		}
	}
 init3:
926 927 928 929 930 931 932 933 934 935
	hub->quiescing = 0;

	status = usb_submit_urb(hub->urb, GFP_NOIO);
	if (status < 0)
		dev_err(hub->intfdev, "activate --> %d\n", status);
	if (hub->has_indicators && blinkenlights)
		schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);

	/* Scan all ports that need attention */
	kick_khubd(hub);
936 937 938 939

	/* Allow autosuspend if it was suppressed */
	if (type <= HUB_INIT3)
		usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
940 941
}

942 943 944 945 946 947 948 949 950 951 952 953 954 955 956
/* Implement the continuations for the delays above */
static void hub_init_func2(struct work_struct *ws)
{
	struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);

	hub_activate(hub, HUB_INIT2);
}

static void hub_init_func3(struct work_struct *ws)
{
	struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);

	hub_activate(hub, HUB_INIT3);
}

957 958 959 960 961 962 963 964 965
enum hub_quiescing_type {
	HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
};

static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
{
	struct usb_device *hdev = hub->hdev;
	int i;

966 967
	cancel_delayed_work_sync(&hub->init_work);

968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983
	/* khubd and related activity won't re-trigger */
	hub->quiescing = 1;

	if (type != HUB_SUSPEND) {
		/* Disconnect all the children */
		for (i = 0; i < hdev->maxchild; ++i) {
			if (hdev->children[i])
				usb_disconnect(&hdev->children[i]);
		}
	}

	/* Stop khubd and related activity */
	usb_kill_urb(hub->urb);
	if (hub->has_indicators)
		cancel_delayed_work_sync(&hub->leds);
	if (hub->tt.hub)
984
		cancel_work_sync(&hub->tt.clear_work);
985 986
}

A
Alan Stern 已提交
987 988 989 990 991
/* caller has locked the hub device */
static int hub_pre_reset(struct usb_interface *intf)
{
	struct usb_hub *hub = usb_get_intfdata(intf);

992
	hub_quiesce(hub, HUB_PRE_RESET);
A
Alan Stern 已提交
993
	return 0;
994 995 996
}

/* caller has locked the hub device */
A
Alan Stern 已提交
997
static int hub_post_reset(struct usb_interface *intf)
998
{
999 1000
	struct usb_hub *hub = usb_get_intfdata(intf);

1001
	hub_activate(hub, HUB_POST_RESET);
A
Alan Stern 已提交
1002
	return 0;
1003 1004
}

L
Linus Torvalds 已提交
1005 1006 1007
static int hub_configure(struct usb_hub *hub,
	struct usb_endpoint_descriptor *endpoint)
{
1008
	struct usb_hcd *hcd;
L
Linus Torvalds 已提交
1009 1010 1011
	struct usb_device *hdev = hub->hdev;
	struct device *hub_dev = hub->intfdev;
	u16 hubstatus, hubchange;
1012
	u16 wHubCharacteristics;
L
Linus Torvalds 已提交
1013 1014
	unsigned int pipe;
	int maxp, ret;
1015
	char *message = "out of memory";
L
Linus Torvalds 已提交
1016

1017
	hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
L
Linus Torvalds 已提交
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
	if (!hub->buffer) {
		ret = -ENOMEM;
		goto fail;
	}

	hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
	if (!hub->status) {
		ret = -ENOMEM;
		goto fail;
	}
1028
	mutex_init(&hub->status_mutex);
L
Linus Torvalds 已提交
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039

	hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
	if (!hub->descriptor) {
		ret = -ENOMEM;
		goto fail;
	}

	/* Request the entire hub descriptor.
	 * hub->descriptor can handle USB_MAXCHILDREN ports,
	 * but the hub can/will return fewer bytes here.
	 */
J
John Youn 已提交
1040
	ret = get_hub_descriptor(hdev, hub->descriptor);
L
Linus Torvalds 已提交
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
	if (ret < 0) {
		message = "can't read hub descriptor";
		goto fail;
	} else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {
		message = "hub has too many ports!";
		ret = -ENODEV;
		goto fail;
	}

	hdev->maxchild = hub->descriptor->bNbrPorts;
	dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
		(hdev->maxchild == 1) ? "" : "s");

1054 1055
	hdev->children = kzalloc(hdev->maxchild *
				sizeof(struct usb_device *), GFP_KERNEL);
1056 1057 1058
	hub->port_data = kzalloc(hdev->maxchild * sizeof(struct usb_hub_port),
			GFP_KERNEL);
	if (!hub->port_data || !hdev->children) {
1059 1060 1061 1062
		ret = -ENOMEM;
		goto fail;
	}

1063
	wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
L
Linus Torvalds 已提交
1064

J
John Youn 已提交
1065 1066 1067
	/* FIXME for USB 3.0, skip for now */
	if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
			!(hub_is_superspeed(hdev))) {
L
Linus Torvalds 已提交
1068 1069 1070 1071
		int	i;
		char	portstr [USB_MAXCHILDREN + 1];

		for (i = 0; i < hdev->maxchild; i++)
J
John Youn 已提交
1072
			portstr[i] = hub->descriptor->u.hs.DeviceRemovable
L
Linus Torvalds 已提交
1073 1074 1075 1076 1077 1078 1079
				    [((i + 1) / 8)] & (1 << ((i + 1) % 8))
				? 'F' : 'R';
		portstr[hdev->maxchild] = 0;
		dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
	} else
		dev_dbg(hub_dev, "standalone hub\n");

1080
	switch (wHubCharacteristics & HUB_CHAR_LPSM) {
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
	case HUB_CHAR_COMMON_LPSM:
		dev_dbg(hub_dev, "ganged power switching\n");
		break;
	case HUB_CHAR_INDV_PORT_LPSM:
		dev_dbg(hub_dev, "individual port power switching\n");
		break;
	case HUB_CHAR_NO_LPSM:
	case HUB_CHAR_LPSM:
		dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
		break;
L
Linus Torvalds 已提交
1091 1092
	}

1093
	switch (wHubCharacteristics & HUB_CHAR_OCPM) {
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
	case HUB_CHAR_COMMON_OCPM:
		dev_dbg(hub_dev, "global over-current protection\n");
		break;
	case HUB_CHAR_INDV_PORT_OCPM:
		dev_dbg(hub_dev, "individual port over-current protection\n");
		break;
	case HUB_CHAR_NO_OCPM:
	case HUB_CHAR_OCPM:
		dev_dbg(hub_dev, "no over-current protection\n");
		break;
L
Linus Torvalds 已提交
1104 1105 1106 1107
	}

	spin_lock_init (&hub->tt.lock);
	INIT_LIST_HEAD (&hub->tt.clear_list);
1108
	INIT_WORK(&hub->tt.clear_work, hub_tt_work);
L
Linus Torvalds 已提交
1109
	switch (hdev->descriptor.bDeviceProtocol) {
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
	case USB_HUB_PR_FS:
		break;
	case USB_HUB_PR_HS_SINGLE_TT:
		dev_dbg(hub_dev, "Single TT\n");
		hub->tt.hub = hdev;
		break;
	case USB_HUB_PR_HS_MULTI_TT:
		ret = usb_set_interface(hdev, 0, 1);
		if (ret == 0) {
			dev_dbg(hub_dev, "TT per port\n");
			hub->tt.multi = 1;
		} else
			dev_err(hub_dev, "Using single TT (err %d)\n",
				ret);
		hub->tt.hub = hdev;
		break;
	case USB_HUB_PR_SS:
		/* USB 3.0 hubs don't have a TT */
		break;
	default:
		dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
			hdev->descriptor.bDeviceProtocol);
		break;
L
Linus Torvalds 已提交
1133 1134
	}

1135
	/* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
1136
	switch (wHubCharacteristics & HUB_CHAR_TTTT) {
1137 1138 1139 1140 1141 1142 1143
		case HUB_TTTT_8_BITS:
			if (hdev->descriptor.bDeviceProtocol != 0) {
				hub->tt.think_time = 666;
				dev_dbg(hub_dev, "TT requires at most %d "
						"FS bit times (%d ns)\n",
					8, hub->tt.think_time);
			}
L
Linus Torvalds 已提交
1144
			break;
1145 1146 1147 1148 1149
		case HUB_TTTT_16_BITS:
			hub->tt.think_time = 666 * 2;
			dev_dbg(hub_dev, "TT requires at most %d "
					"FS bit times (%d ns)\n",
				16, hub->tt.think_time);
L
Linus Torvalds 已提交
1150
			break;
1151 1152 1153 1154 1155
		case HUB_TTTT_24_BITS:
			hub->tt.think_time = 666 * 3;
			dev_dbg(hub_dev, "TT requires at most %d "
					"FS bit times (%d ns)\n",
				24, hub->tt.think_time);
L
Linus Torvalds 已提交
1156
			break;
1157 1158 1159 1160 1161
		case HUB_TTTT_32_BITS:
			hub->tt.think_time = 666 * 4;
			dev_dbg(hub_dev, "TT requires at most %d "
					"FS bit times (%d ns)\n",
				32, hub->tt.think_time);
L
Linus Torvalds 已提交
1162 1163 1164 1165
			break;
	}

	/* probe() zeroes hub->indicator[] */
1166
	if (wHubCharacteristics & HUB_CHAR_PORTIND) {
L
Linus Torvalds 已提交
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177
		hub->has_indicators = 1;
		dev_dbg(hub_dev, "Port indicators are supported\n");
	}

	dev_dbg(hub_dev, "power on to power good time: %dms\n",
		hub->descriptor->bPwrOn2PwrGood * 2);

	/* power budgeting mostly matters with bus-powered hubs,
	 * and battery-powered root hubs (may provide just 8 mA).
	 */
	ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
1178
	if (ret < 2) {
L
Linus Torvalds 已提交
1179 1180 1181
		message = "can't get hub status";
		goto fail;
	}
1182 1183
	le16_to_cpus(&hubstatus);
	if (hdev == hdev->bus->root_hub) {
1184 1185 1186 1187 1188 1189
		if (hdev->bus_mA == 0 || hdev->bus_mA >= 500)
			hub->mA_per_port = 500;
		else {
			hub->mA_per_port = hdev->bus_mA;
			hub->limited_power = 1;
		}
1190
	} else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
L
Linus Torvalds 已提交
1191 1192
		dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
			hub->descriptor->bHubContrCurrent);
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
		hub->limited_power = 1;
		if (hdev->maxchild > 0) {
			int remaining = hdev->bus_mA -
					hub->descriptor->bHubContrCurrent;

			if (remaining < hdev->maxchild * 100)
				dev_warn(hub_dev,
					"insufficient power available "
					"to use all downstream ports\n");
			hub->mA_per_port = 100;		/* 7.2.1.1 */
		}
	} else {	/* Self-powered external hub */
		/* FIXME: What about battery-powered external hubs that
		 * provide less current per port? */
		hub->mA_per_port = 500;
1208
	}
1209 1210 1211
	if (hub->mA_per_port < 500)
		dev_dbg(hub_dev, "%umA bus power budget for each child\n",
				hub->mA_per_port);
L
Linus Torvalds 已提交
1212

1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
	/* Update the HCD's internal representation of this hub before khubd
	 * starts getting port status changes for devices under the hub.
	 */
	hcd = bus_to_hcd(hdev->bus);
	if (hcd->driver->update_hub_device) {
		ret = hcd->driver->update_hub_device(hcd, hdev,
				&hub->tt, GFP_KERNEL);
		if (ret < 0) {
			message = "can't update HCD hub info";
			goto fail;
		}
	}

L
Linus Torvalds 已提交
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
	ret = hub_hub_status(hub, &hubstatus, &hubchange);
	if (ret < 0) {
		message = "can't get hub status";
		goto fail;
	}

	/* local power status reports aren't always correct */
	if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
		dev_dbg(hub_dev, "local power source is %s\n",
			(hubstatus & HUB_STATUS_LOCAL_POWER)
			? "lost (inactive)" : "good");

1238
	if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
L
Linus Torvalds 已提交
1239 1240 1241
		dev_dbg(hub_dev, "%sover-current condition exists\n",
			(hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");

1242 1243 1244 1245 1246 1247
	/* set up the interrupt endpoint
	 * We use the EP's maxpacket size instead of (PORTS+1+7)/8
	 * bytes as USB2.0[11.12.3] says because some hubs are known
	 * to send more data (and thus cause overflow). For root hubs,
	 * maxpktsize is defined in hcd.c's fake endpoint descriptors
	 * to be big enough for at least USB_MAXCHILDREN ports. */
L
Linus Torvalds 已提交
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
	pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
	maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));

	if (maxp > sizeof(*hub->buffer))
		maxp = sizeof(*hub->buffer);

	hub->urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!hub->urb) {
		ret = -ENOMEM;
		goto fail;
	}

	usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
		hub, endpoint->bInterval);

	/* maybe cycle the hub leds */
	if (hub->has_indicators && blinkenlights)
		hub->indicator [0] = INDICATOR_CYCLE;

1267
	hub_activate(hub, HUB_INIT);
L
Linus Torvalds 已提交
1268 1269 1270 1271 1272 1273 1274 1275 1276
	return 0;

fail:
	dev_err (hub_dev, "config failed, %s (err %d)\n",
			message, ret);
	/* hub_disconnect() frees urb and descriptor */
	return ret;
}

1277 1278 1279 1280 1281 1282 1283 1284
static void hub_release(struct kref *kref)
{
	struct usb_hub *hub = container_of(kref, struct usb_hub, kref);

	usb_put_intf(to_usb_interface(hub->intfdev));
	kfree(hub);
}

L
Linus Torvalds 已提交
1285 1286 1287 1288
static unsigned highspeed_hubs;

static void hub_disconnect(struct usb_interface *intf)
{
1289 1290
	struct usb_hub *hub = usb_get_intfdata(intf);
	struct usb_device *hdev = interface_to_usbdev(intf);
1291 1292 1293

	/* Take the hub off the event list and don't let it be added again */
	spin_lock_irq(&hub_event_lock);
1294 1295 1296 1297
	if (!list_empty(&hub->event_list)) {
		list_del_init(&hub->event_list);
		usb_autopm_put_interface_no_suspend(intf);
	}
1298 1299
	hub->disconnected = 1;
	spin_unlock_irq(&hub_event_lock);
L
Linus Torvalds 已提交
1300

1301 1302
	/* Disconnect all children and quiesce the hub */
	hub->error = 0;
1303
	hub_quiesce(hub, HUB_DISCONNECT);
1304

1305
	usb_set_intfdata (intf, NULL);
1306
	hub->hdev->maxchild = 0;
L
Linus Torvalds 已提交
1307

1308
	if (hub->hdev->speed == USB_SPEED_HIGH)
L
Linus Torvalds 已提交
1309 1310 1311
		highspeed_hubs--;

	usb_free_urb(hub->urb);
1312
	kfree(hdev->children);
1313
	kfree(hub->port_data);
1314 1315
	kfree(hub->descriptor);
	kfree(hub->status);
1316
	kfree(hub->buffer);
L
Linus Torvalds 已提交
1317

1318
	kref_put(&hub->kref, hub_release);
L
Linus Torvalds 已提交
1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
}

static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
	struct usb_host_interface *desc;
	struct usb_endpoint_descriptor *endpoint;
	struct usb_device *hdev;
	struct usb_hub *hub;

	desc = intf->cur_altsetting;
	hdev = interface_to_usbdev(intf);

1331 1332
	/* Hubs have proper suspend/resume support. */
	usb_enable_autosuspend(hdev);
1333

1334
	if (hdev->level == MAX_TOPO_LEVEL) {
1335 1336
		dev_err(&intf->dev,
			"Unsupported bus topology: hub nested too deep\n");
1337 1338 1339
		return -E2BIG;
	}

1340 1341 1342 1343 1344 1345 1346
#ifdef	CONFIG_USB_OTG_BLACKLIST_HUB
	if (hdev->parent) {
		dev_warn(&intf->dev, "ignoring external hub\n");
		return -ENODEV;
	}
#endif

L
Linus Torvalds 已提交
1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361
	/* Some hubs have a subclass of 1, which AFAICT according to the */
	/*  specs is not defined, but it works */
	if ((desc->desc.bInterfaceSubClass != 0) &&
	    (desc->desc.bInterfaceSubClass != 1)) {
descriptor_error:
		dev_err (&intf->dev, "bad descriptor, ignoring hub\n");
		return -EIO;
	}

	/* Multiple endpoints? What kind of mutant ninja-hub is this? */
	if (desc->desc.bNumEndpoints != 1)
		goto descriptor_error;

	endpoint = &desc->endpoint[0].desc;

1362 1363
	/* If it's not an interrupt in endpoint, we'd better punt! */
	if (!usb_endpoint_is_int_in(endpoint))
L
Linus Torvalds 已提交
1364 1365 1366 1367 1368
		goto descriptor_error;

	/* We found a hub */
	dev_info (&intf->dev, "USB hub found\n");

1369
	hub = kzalloc(sizeof(*hub), GFP_KERNEL);
L
Linus Torvalds 已提交
1370 1371 1372 1373 1374
	if (!hub) {
		dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
		return -ENOMEM;
	}

1375
	kref_init(&hub->kref);
L
Linus Torvalds 已提交
1376 1377 1378
	INIT_LIST_HEAD(&hub->event_list);
	hub->intfdev = &intf->dev;
	hub->hdev = hdev;
D
David Howells 已提交
1379
	INIT_DELAYED_WORK(&hub->leds, led_work);
1380
	INIT_DELAYED_WORK(&hub->init_work, NULL);
1381
	usb_get_intf(intf);
L
Linus Torvalds 已提交
1382 1383

	usb_set_intfdata (intf, hub);
1384
	intf->needs_remote_wakeup = 1;
L
Linus Torvalds 已提交
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429

	if (hdev->speed == USB_SPEED_HIGH)
		highspeed_hubs++;

	if (hub_configure(hub, endpoint) >= 0)
		return 0;

	hub_disconnect (intf);
	return -ENODEV;
}

static int
hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
{
	struct usb_device *hdev = interface_to_usbdev (intf);

	/* assert ifno == 0 (part of hub spec) */
	switch (code) {
	case USBDEVFS_HUB_PORTINFO: {
		struct usbdevfs_hub_portinfo *info = user_data;
		int i;

		spin_lock_irq(&device_state_lock);
		if (hdev->devnum <= 0)
			info->nports = 0;
		else {
			info->nports = hdev->maxchild;
			for (i = 0; i < info->nports; i++) {
				if (hdev->children[i] == NULL)
					info->port[i] = 0;
				else
					info->port[i] =
						hdev->children[i]->devnum;
			}
		}
		spin_unlock_irq(&device_state_lock);

		return info->nports + 1;
		}

	default:
		return -ENOSYS;
	}
}

1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444
/*
 * Allow user programs to claim ports on a hub.  When a device is attached
 * to one of these "claimed" ports, the program will "own" the device.
 */
static int find_port_owner(struct usb_device *hdev, unsigned port1,
		void ***ppowner)
{
	if (hdev->state == USB_STATE_NOTATTACHED)
		return -ENODEV;
	if (port1 == 0 || port1 > hdev->maxchild)
		return -EINVAL;

	/* This assumes that devices not managed by the hub driver
	 * will always have maxchild equal to 0.
	 */
1445
	*ppowner = &(hdev_to_hub(hdev)->port_data[port1 - 1].port_owner);
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
	return 0;
}

/* In the following three functions, the caller must hold hdev's lock */
int usb_hub_claim_port(struct usb_device *hdev, unsigned port1, void *owner)
{
	int rc;
	void **powner;

	rc = find_port_owner(hdev, port1, &powner);
	if (rc)
		return rc;
	if (*powner)
		return -EBUSY;
	*powner = owner;
	return rc;
}

int usb_hub_release_port(struct usb_device *hdev, unsigned port1, void *owner)
{
	int rc;
	void **powner;

	rc = find_port_owner(hdev, port1, &powner);
	if (rc)
		return rc;
	if (*powner != owner)
		return -ENOENT;
	*powner = NULL;
	return rc;
}

void usb_hub_release_all_ports(struct usb_device *hdev, void *owner)
{
1480
	struct usb_hub *hub = hdev_to_hub(hdev);
1481 1482
	int n;

1483 1484 1485
	for (n = 0; n < hdev->maxchild; n++) {
		if (hub->port_data[n].port_owner == owner)
			hub->port_data[n].port_owner = NULL;
1486
	}
1487

1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
}

/* The caller must hold udev's lock */
bool usb_device_is_owned(struct usb_device *udev)
{
	struct usb_hub *hub;

	if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
		return false;
	hub = hdev_to_hub(udev->parent);
1498
	return !!hub->port_data[udev->portnum - 1].port_owner;
1499 1500
}

L
Linus Torvalds 已提交
1501 1502 1503 1504 1505 1506 1507 1508 1509

static void recursively_mark_NOTATTACHED(struct usb_device *udev)
{
	int i;

	for (i = 0; i < udev->maxchild; ++i) {
		if (udev->children[i])
			recursively_mark_NOTATTACHED(udev->children[i]);
	}
1510
	if (udev->state == USB_STATE_SUSPENDED)
S
Sarah Sharp 已提交
1511
		udev->active_duration -= jiffies;
L
Linus Torvalds 已提交
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
	udev->state = USB_STATE_NOTATTACHED;
}

/**
 * usb_set_device_state - change a device's current state (usbcore, hcds)
 * @udev: pointer to device whose state should be changed
 * @new_state: new state value to be stored
 *
 * udev->state is _not_ fully protected by the device lock.  Although
 * most transitions are made only while holding the lock, the state can
 * can change to USB_STATE_NOTATTACHED at almost any time.  This
 * is so that devices can be marked as disconnected as soon as possible,
 * without having to wait for any semaphores to be released.  As a result,
 * all changes to any device's state must be protected by the
 * device_state_lock spinlock.
 *
 * Once a device has been added to the device tree, all changes to its state
 * should be made using this routine.  The state should _not_ be set directly.
 *
 * If udev->state is already USB_STATE_NOTATTACHED then no change is made.
 * Otherwise udev->state is set to new_state, and if new_state is
 * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set
 * to USB_STATE_NOTATTACHED.
 */
void usb_set_device_state(struct usb_device *udev,
		enum usb_device_state new_state)
{
	unsigned long flags;
1540
	int wakeup = -1;
L
Linus Torvalds 已提交
1541 1542 1543 1544

	spin_lock_irqsave(&device_state_lock, flags);
	if (udev->state == USB_STATE_NOTATTACHED)
		;	/* do nothing */
D
David Brownell 已提交
1545
	else if (new_state != USB_STATE_NOTATTACHED) {
1546 1547 1548 1549 1550

		/* root hub wakeup capabilities are managed out-of-band
		 * and may involve silicon errata ... ignore them here.
		 */
		if (udev->parent) {
1551 1552 1553 1554
			if (udev->state == USB_STATE_SUSPENDED
					|| new_state == USB_STATE_SUSPENDED)
				;	/* No change to wakeup settings */
			else if (new_state == USB_STATE_CONFIGURED)
1555 1556
				wakeup = udev->actconfig->desc.bmAttributes
					 & USB_CONFIG_ATT_WAKEUP;
1557
			else
1558
				wakeup = 0;
1559
		}
S
Sarah Sharp 已提交
1560 1561 1562 1563 1564 1565
		if (udev->state == USB_STATE_SUSPENDED &&
			new_state != USB_STATE_SUSPENDED)
			udev->active_duration -= jiffies;
		else if (new_state == USB_STATE_SUSPENDED &&
				udev->state != USB_STATE_SUSPENDED)
			udev->active_duration += jiffies;
1566
		udev->state = new_state;
D
David Brownell 已提交
1567
	} else
L
Linus Torvalds 已提交
1568 1569
		recursively_mark_NOTATTACHED(udev);
	spin_unlock_irqrestore(&device_state_lock, flags);
1570 1571
	if (wakeup >= 0)
		device_set_wakeup_capable(&udev->dev, wakeup);
L
Linus Torvalds 已提交
1572
}
1573
EXPORT_SYMBOL_GPL(usb_set_device_state);
L
Linus Torvalds 已提交
1574

1575
/*
1576 1577 1578 1579 1580 1581 1582
 * Choose a device number.
 *
 * Device numbers are used as filenames in usbfs.  On USB-1.1 and
 * USB-2.0 buses they are also used as device addresses, however on
 * USB-3.0 buses the address is assigned by the controller hardware
 * and it usually is not the same as the device number.
 *
1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
 * WUSB devices are simple: they have no hubs behind, so the mapping
 * device <-> virtual port number becomes 1:1. Why? to simplify the
 * life of the device connection logic in
 * drivers/usb/wusbcore/devconnect.c. When we do the initial secret
 * handshake we need to assign a temporary address in the unauthorized
 * space. For simplicity we use the first virtual port number found to
 * be free [drivers/usb/wusbcore/devconnect.c:wusbhc_devconnect_ack()]
 * and that becomes it's address [X < 128] or its unauthorized address
 * [X | 0x80].
 *
 * We add 1 as an offset to the one-based USB-stack port number
 * (zero-based wusb virtual port index) for two reasons: (a) dev addr
 * 0 is reserved by USB for default address; (b) Linux's USB stack
 * uses always #1 for the root hub of the controller. So USB stack's
 * port #1, which is wusb virtual-port #0 has address #2.
1598 1599 1600 1601 1602
 *
 * Devices connected under xHCI are not as simple.  The host controller
 * supports virtualization, so the hardware assigns device addresses and
 * the HCD must setup data structures before issuing a set address
 * command to the hardware.
1603
 */
1604
static void choose_devnum(struct usb_device *udev)
L
Linus Torvalds 已提交
1605 1606 1607 1608 1609
{
	int		devnum;
	struct usb_bus	*bus = udev->bus;

	/* If khubd ever becomes multithreaded, this will need a lock */
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
	if (udev->wusb) {
		devnum = udev->portnum + 1;
		BUG_ON(test_bit(devnum, bus->devmap.devicemap));
	} else {
		/* Try to allocate the next devnum beginning at
		 * bus->devnum_next. */
		devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
					    bus->devnum_next);
		if (devnum >= 128)
			devnum = find_next_zero_bit(bus->devmap.devicemap,
						    128, 1);
		bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1);
	}
L
Linus Torvalds 已提交
1623 1624 1625 1626 1627 1628
	if (devnum < 128) {
		set_bit(devnum, bus->devmap.devicemap);
		udev->devnum = devnum;
	}
}

1629
static void release_devnum(struct usb_device *udev)
L
Linus Torvalds 已提交
1630 1631 1632 1633 1634 1635 1636
{
	if (udev->devnum > 0) {
		clear_bit(udev->devnum, udev->bus->devmap.devicemap);
		udev->devnum = -1;
	}
}

1637
static void update_devnum(struct usb_device *udev, int devnum)
1638 1639 1640 1641 1642 1643
{
	/* The address for a WUSB device is managed by wusbcore. */
	if (!udev->wusb)
		udev->devnum = devnum;
}

1644 1645 1646 1647 1648 1649 1650 1651 1652
static void hub_free_dev(struct usb_device *udev)
{
	struct usb_hcd *hcd = bus_to_hcd(udev->bus);

	/* Root hubs aren't real devices, so don't free HCD resources */
	if (hcd->driver->free_dev && udev->parent)
		hcd->driver->free_dev(hcd, udev);
}

L
Linus Torvalds 已提交
1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675
/**
 * usb_disconnect - disconnect a device (usbcore-internal)
 * @pdev: pointer to device being disconnected
 * Context: !in_interrupt ()
 *
 * Something got disconnected. Get rid of it and all of its children.
 *
 * If *pdev is a normal device then the parent hub must already be locked.
 * If *pdev is a root hub then this routine will acquire the
 * usb_bus_list_lock on behalf of the caller.
 *
 * Only hub drivers (including virtual root hub drivers for host
 * controllers) should ever call this.
 *
 * This call is synchronous, and may not be used in an interrupt context.
 */
void usb_disconnect(struct usb_device **pdev)
{
	struct usb_device	*udev = *pdev;
	int			i;

	/* mark the device as inactive, so any further urb submissions for
	 * this device (and any of its children) will fail immediately.
L
Lucas De Marchi 已提交
1676
	 * this quiesces everything except pending urbs.
L
Linus Torvalds 已提交
1677 1678
	 */
	usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1679 1680
	dev_info(&udev->dev, "USB disconnect, device number %d\n",
			udev->devnum);
L
Linus Torvalds 已提交
1681

1682 1683
	usb_lock_device(udev);

L
Linus Torvalds 已提交
1684
	/* Free up all the children before we remove this device */
1685
	for (i = 0; i < udev->maxchild; i++) {
L
Linus Torvalds 已提交
1686 1687 1688 1689 1690 1691 1692 1693
		if (udev->children[i])
			usb_disconnect(&udev->children[i]);
	}

	/* deallocate hcd/hardware state ... nuking all pending urbs and
	 * cleaning up all state associated with the current configuration
	 * so that the hardware is now fully quiesced.
	 */
1694
	dev_dbg (&udev->dev, "unregistering device\n");
L
Linus Torvalds 已提交
1695
	usb_disable_device(udev, 0);
1696
	usb_hcd_synchronize_unlinks(udev);
L
Linus Torvalds 已提交
1697

A
Alan Stern 已提交
1698
	usb_remove_ep_devs(&udev->ep0);
1699 1700 1701
	usb_unlock_device(udev);

	/* Unregister the device.  The device driver is responsible
A
Alan Stern 已提交
1702 1703
	 * for de-configuring the device and invoking the remove-device
	 * notifier chain (used by usbfs and possibly others).
1704 1705
	 */
	device_del(&udev->dev);
1706

1707
	/* Free the device number and delete the parent's children[]
L
Linus Torvalds 已提交
1708 1709
	 * (or root_hub) pointer.
	 */
1710
	release_devnum(udev);
L
Linus Torvalds 已提交
1711 1712 1713 1714 1715 1716

	/* Avoid races with recursively_mark_NOTATTACHED() */
	spin_lock_irq(&device_state_lock);
	*pdev = NULL;
	spin_unlock_irq(&device_state_lock);

1717 1718
	hub_free_dev(udev);

1719
	put_device(&udev->dev);
L
Linus Torvalds 已提交
1720 1721
}

1722
#ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
L
Linus Torvalds 已提交
1723 1724 1725 1726 1727 1728 1729
static void show_string(struct usb_device *udev, char *id, char *string)
{
	if (!string)
		return;
	dev_printk(KERN_INFO, &udev->dev, "%s: %s\n", id, string);
}

1730 1731 1732 1733 1734
static void announce_device(struct usb_device *udev)
{
	dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n",
		le16_to_cpu(udev->descriptor.idVendor),
		le16_to_cpu(udev->descriptor.idProduct));
1735 1736
	dev_info(&udev->dev,
		"New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
1737 1738 1739 1740 1741 1742 1743
		udev->descriptor.iManufacturer,
		udev->descriptor.iProduct,
		udev->descriptor.iSerialNumber);
	show_string(udev, "Product", udev->product);
	show_string(udev, "Manufacturer", udev->manufacturer);
	show_string(udev, "SerialNumber", udev->serial);
}
L
Linus Torvalds 已提交
1744
#else
1745
static inline void announce_device(struct usb_device *udev) { }
L
Linus Torvalds 已提交
1746 1747 1748 1749 1750 1751
#endif

#ifdef	CONFIG_USB_OTG
#include "otg_whitelist.h"
#endif

1752
/**
A
Alan Stern 已提交
1753
 * usb_enumerate_device_otg - FIXME (usbcore-internal)
1754 1755
 * @udev: newly addressed device (in ADDRESS state)
 *
A
Alan Stern 已提交
1756
 * Finish enumeration for On-The-Go devices
1757
 */
A
Alan Stern 已提交
1758
static int usb_enumerate_device_otg(struct usb_device *udev)
L
Linus Torvalds 已提交
1759
{
1760
	int err = 0;
L
Linus Torvalds 已提交
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770

#ifdef	CONFIG_USB_OTG
	/*
	 * OTG-aware devices on OTG-capable root hubs may be able to use SRP,
	 * to wake us after we've powered off VBUS; and HNP, switching roles
	 * "host" to "peripheral".  The OTG descriptor helps figure this out.
	 */
	if (!udev->bus->is_b_host
			&& udev->config
			&& udev->parent == udev->bus->root_hub) {
F
Felipe Balbi 已提交
1771
		struct usb_otg_descriptor	*desc = NULL;
L
Linus Torvalds 已提交
1772 1773 1774 1775 1776 1777 1778
		struct usb_bus			*bus = udev->bus;

		/* descriptor may appear anywhere in config */
		if (__usb_get_extra_descriptor (udev->rawdescriptors[0],
					le16_to_cpu(udev->config[0].desc.wTotalLength),
					USB_DT_OTG, (void **) &desc) == 0) {
			if (desc->bmAttributes & USB_OTG_HNP) {
1779
				unsigned		port1 = udev->portnum;
D
David Brownell 已提交
1780

L
Linus Torvalds 已提交
1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800
				dev_info(&udev->dev,
					"Dual-Role OTG device on %sHNP port\n",
					(port1 == bus->otg_port)
						? "" : "non-");

				/* enable HNP before suspend, it's simpler */
				if (port1 == bus->otg_port)
					bus->b_hnp_enable = 1;
				err = usb_control_msg(udev,
					usb_sndctrlpipe(udev, 0),
					USB_REQ_SET_FEATURE, 0,
					bus->b_hnp_enable
						? USB_DEVICE_B_HNP_ENABLE
						: USB_DEVICE_A_ALT_HNP_SUPPORT,
					0, NULL, 0, USB_CTRL_SET_TIMEOUT);
				if (err < 0) {
					/* OTG MESSAGE: report errors here,
					 * customize to match your product.
					 */
					dev_info(&udev->dev,
1801
						"can't set HNP mode: %d\n",
L
Linus Torvalds 已提交
1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814
						err);
					bus->b_hnp_enable = 0;
				}
			}
		}
	}

	if (!is_targeted(udev)) {

		/* Maybe it can talk to us, though we can't talk to it.
		 * (Includes HNP test device.)
		 */
		if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {
1815
			err = usb_port_suspend(udev, PMSG_SUSPEND);
L
Linus Torvalds 已提交
1816 1817 1818
			if (err < 0)
				dev_dbg(&udev->dev, "HNP fail, %d\n", err);
		}
1819
		err = -ENOTSUPP;
L
Linus Torvalds 已提交
1820 1821
		goto fail;
	}
1822
fail:
L
Linus Torvalds 已提交
1823
#endif
1824 1825 1826 1827 1828
	return err;
}


/**
A
Alan Stern 已提交
1829
 * usb_enumerate_device - Read device configs/intfs/otg (usbcore-internal)
1830 1831 1832 1833 1834 1835 1836 1837 1838 1839
 * @udev: newly addressed device (in ADDRESS state)
 *
 * This is only called by usb_new_device() and usb_authorize_device()
 * and FIXME -- all comments that apply to them apply here wrt to
 * environment.
 *
 * If the device is WUSB and not authorized, we don't attempt to read
 * the string descriptors, as they will be errored out by the device
 * until it has been authorized.
 */
A
Alan Stern 已提交
1840
static int usb_enumerate_device(struct usb_device *udev)
1841 1842
{
	int err;
L
Linus Torvalds 已提交
1843

1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
	if (udev->config == NULL) {
		err = usb_get_configuration(udev);
		if (err < 0) {
			dev_err(&udev->dev, "can't read configurations, error %d\n",
				err);
			goto fail;
		}
	}
	if (udev->wusb == 1 && udev->authorized == 0) {
		udev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
		udev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
		udev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
	}
	else {
		/* read the standard strings and cache them if present */
		udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
		udev->manufacturer = usb_cache_string(udev,
						      udev->descriptor.iManufacturer);
		udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
	}
A
Alan Stern 已提交
1864
	err = usb_enumerate_device_otg(udev);
1865 1866 1867 1868
fail:
	return err;
}

1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899
static void set_usb_port_removable(struct usb_device *udev)
{
	struct usb_device *hdev = udev->parent;
	struct usb_hub *hub;
	u8 port = udev->portnum;
	u16 wHubCharacteristics;
	bool removable = true;

	if (!hdev)
		return;

	hub = hdev_to_hub(udev->parent);

	wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);

	if (!(wHubCharacteristics & HUB_CHAR_COMPOUND))
		return;

	if (hub_is_superspeed(hdev)) {
		if (hub->descriptor->u.ss.DeviceRemovable & (1 << port))
			removable = false;
	} else {
		if (hub->descriptor->u.hs.DeviceRemovable[port / 8] & (1 << (port % 8)))
			removable = false;
	}

	if (removable)
		udev->removable = USB_DEVICE_REMOVABLE;
	else
		udev->removable = USB_DEVICE_FIXED;
}
1900 1901 1902 1903 1904

/**
 * usb_new_device - perform initial device setup (usbcore-internal)
 * @udev: newly addressed device (in ADDRESS state)
 *
A
Alan Stern 已提交
1905 1906
 * This is called with devices which have been detected but not fully
 * enumerated.  The device descriptor is available, but not descriptors
1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924
 * for any device configuration.  The caller must have locked either
 * the parent hub (if udev is a normal device) or else the
 * usb_bus_list_lock (if udev is a root hub).  The parent's pointer to
 * udev has already been installed, but udev is not yet visible through
 * sysfs or other filesystem code.
 *
 * It will return if the device is configured properly or not.  Zero if
 * the interface was registered with the driver core; else a negative
 * errno value.
 *
 * This call is synchronous, and may not be used in an interrupt context.
 *
 * Only the hub driver or root-hub registrar should ever call this.
 */
int usb_new_device(struct usb_device *udev)
{
	int err;

1925 1926 1927 1928 1929 1930 1931 1932
	if (udev->parent) {
		/* Initialize non-root-hub device wakeup to disabled;
		 * device (un)configuration controls wakeup capable
		 * sysfs power/wakeup controls wakeup enabled/disabled
		 */
		device_init_wakeup(&udev->dev, 0);
	}

1933 1934
	/* Tell the runtime-PM framework the device is active */
	pm_runtime_set_active(&udev->dev);
1935
	pm_runtime_get_noresume(&udev->dev);
1936
	pm_runtime_use_autosuspend(&udev->dev);
1937 1938
	pm_runtime_enable(&udev->dev);

1939 1940 1941 1942 1943
	/* By default, forbid autosuspend for all devices.  It will be
	 * allowed for hubs during binding.
	 */
	usb_disable_autosuspend(udev);

A
Alan Stern 已提交
1944
	err = usb_enumerate_device(udev);	/* Read descriptors */
1945 1946
	if (err < 0)
		goto fail;
1947 1948 1949
	dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
			udev->devnum, udev->bus->busnum,
			(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
1950 1951 1952 1953
	/* export the usbdev device-node for libusb */
	udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
			(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));

A
Alan Stern 已提交
1954 1955
	/* Tell the world! */
	announce_device(udev);
1956

1957
	device_enable_async_suspend(&udev->dev);
1958 1959 1960 1961 1962 1963 1964 1965 1966

	/*
	 * check whether the hub marks this port as non-removable. Do it
	 * now so that platform-specific data can override it in
	 * device_add()
	 */
	if (udev->parent)
		set_usb_port_removable(udev);

1967
	/* Register the device.  The device driver is responsible
A
Alan Stern 已提交
1968 1969
	 * for configuring the device and invoking the add-device
	 * notifier chain (used by usbfs and possibly others).
1970
	 */
1971
	err = device_add(&udev->dev);
L
Linus Torvalds 已提交
1972 1973 1974 1975
	if (err) {
		dev_err(&udev->dev, "can't device_add, error %d\n", err);
		goto fail;
	}
1976

A
Alan Stern 已提交
1977
	(void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
1978 1979
	usb_mark_last_busy(udev);
	pm_runtime_put_sync_autosuspend(&udev->dev);
1980
	return err;
L
Linus Torvalds 已提交
1981 1982 1983

fail:
	usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1984 1985
	pm_runtime_disable(&udev->dev);
	pm_runtime_set_suspended(&udev->dev);
1986
	return err;
L
Linus Torvalds 已提交
1987 1988
}

1989 1990

/**
R
Randy Dunlap 已提交
1991 1992 1993 1994 1995
 * usb_deauthorize_device - deauthorize a device (usbcore-internal)
 * @usb_dev: USB device
 *
 * Move the USB device to a very basic state where interfaces are disabled
 * and the device is in fact unconfigured and unusable.
1996 1997 1998 1999 2000 2001 2002 2003 2004
 *
 * We share a lock (that we have) with device_del(), so we need to
 * defer its call.
 */
int usb_deauthorize_device(struct usb_device *usb_dev)
{
	usb_lock_device(usb_dev);
	if (usb_dev->authorized == 0)
		goto out_unauthorized;
2005

2006 2007
	usb_dev->authorized = 0;
	usb_set_configuration(usb_dev, -1);
2008 2009

	kfree(usb_dev->product);
2010
	usb_dev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
2011
	kfree(usb_dev->manufacturer);
2012
	usb_dev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
2013
	kfree(usb_dev->serial);
2014
	usb_dev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
2015 2016

	usb_destroy_configuration(usb_dev);
2017
	usb_dev->descriptor.bNumConfigurations = 0;
2018

2019 2020 2021 2022 2023 2024 2025 2026 2027
out_unauthorized:
	usb_unlock_device(usb_dev);
	return 0;
}


int usb_authorize_device(struct usb_device *usb_dev)
{
	int result = 0, c;
2028

2029 2030 2031
	usb_lock_device(usb_dev);
	if (usb_dev->authorized == 1)
		goto out_authorized;
2032

2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044
	result = usb_autoresume_device(usb_dev);
	if (result < 0) {
		dev_err(&usb_dev->dev,
			"can't autoresume for authorization: %d\n", result);
		goto error_autoresume;
	}
	result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
	if (result < 0) {
		dev_err(&usb_dev->dev, "can't re-read device descriptor for "
			"authorization: %d\n", result);
		goto error_device_descriptor;
	}
2045 2046 2047 2048 2049 2050 2051 2052

	kfree(usb_dev->product);
	usb_dev->product = NULL;
	kfree(usb_dev->manufacturer);
	usb_dev->manufacturer = NULL;
	kfree(usb_dev->serial);
	usb_dev->serial = NULL;

2053
	usb_dev->authorized = 1;
A
Alan Stern 已提交
2054
	result = usb_enumerate_device(usb_dev);
2055
	if (result < 0)
A
Alan Stern 已提交
2056
		goto error_enumerate;
2057 2058 2059
	/* Choose and set the configuration.  This registers the interfaces
	 * with the driver core and lets interface drivers bind to them.
	 */
2060
	c = usb_choose_configuration(usb_dev);
2061 2062 2063 2064 2065 2066 2067 2068 2069 2070
	if (c >= 0) {
		result = usb_set_configuration(usb_dev, c);
		if (result) {
			dev_err(&usb_dev->dev,
				"can't set config #%d, error %d\n", c, result);
			/* This need not be fatal.  The user can try to
			 * set other configurations. */
		}
	}
	dev_info(&usb_dev->dev, "authorized to connect\n");
2071

A
Alan Stern 已提交
2072
error_enumerate:
2073
error_device_descriptor:
2074
	usb_autosuspend_device(usb_dev);
2075 2076 2077 2078 2079 2080 2081
error_autoresume:
out_authorized:
	usb_unlock_device(usb_dev);	// complements locktree
	return result;
}


2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092
/* Returns 1 if @hub is a WUSB root hub, 0 otherwise */
static unsigned hub_is_wusb(struct usb_hub *hub)
{
	struct usb_hcd *hcd;
	if (hub->hdev->parent != NULL)  /* not a root hub? */
		return 0;
	hcd = container_of(hub->hdev->bus, struct usb_hcd, self);
	return hcd->wireless;
}


L
Linus Torvalds 已提交
2093 2094 2095 2096
#define PORT_RESET_TRIES	5
#define SET_ADDRESS_TRIES	2
#define GET_DESCRIPTOR_TRIES	2
#define SET_CONFIG_TRIES	(2 * (use_both_schemes + 1))
2097
#define USE_NEW_SCHEME(i)	((i) / 2 == (int)old_scheme_first)
L
Linus Torvalds 已提交
2098 2099 2100

#define HUB_ROOT_RESET_TIME	50	/* times are in msec */
#define HUB_SHORT_RESET_TIME	10
A
Andiry Xu 已提交
2101
#define HUB_BH_RESET_TIME	50
L
Linus Torvalds 已提交
2102 2103 2104
#define HUB_LONG_RESET_TIME	200
#define HUB_RESET_TIMEOUT	500

2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115
static int hub_port_reset(struct usb_hub *hub, int port1,
			struct usb_device *udev, unsigned int delay, bool warm);

/* Is a USB 3.0 port in the Inactive state? */
static bool hub_port_inactive(struct usb_hub *hub, u16 portstatus)
{
	return hub_is_superspeed(hub->hdev) &&
		(portstatus & USB_PORT_STAT_LINK_STATE) ==
		USB_SS_PORT_LS_SS_INACTIVE;
}

L
Linus Torvalds 已提交
2116
static int hub_port_wait_reset(struct usb_hub *hub, int port1,
A
Andiry Xu 已提交
2117
			struct usb_device *udev, unsigned int delay, bool warm)
L
Linus Torvalds 已提交
2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133
{
	int delay_time, ret;
	u16 portstatus;
	u16 portchange;

	for (delay_time = 0;
			delay_time < HUB_RESET_TIMEOUT;
			delay_time += delay) {
		/* wait to give the device a chance to reset */
		msleep(delay);

		/* read and decode port status */
		ret = hub_port_status(hub, port1, &portstatus, &portchange);
		if (ret < 0)
			return ret;

A
Andiry Xu 已提交
2134 2135 2136 2137 2138
		/*
		 * Some buggy devices require a warm reset to be issued even
		 * when the port appears not to be connected.
		 */
		if (!warm) {
2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170
			/*
			 * Some buggy devices can cause an NEC host controller
			 * to transition to the "Error" state after a hot port
			 * reset.  This will show up as the port state in
			 * "Inactive", and the port may also report a
			 * disconnect.  Forcing a warm port reset seems to make
			 * the device work.
			 *
			 * See https://bugzilla.kernel.org/show_bug.cgi?id=41752
			 */
			if (hub_port_inactive(hub, portstatus)) {
				int ret;

				if ((portchange & USB_PORT_STAT_C_CONNECTION))
					clear_port_feature(hub->hdev, port1,
							USB_PORT_FEAT_C_CONNECTION);
				if (portchange & USB_PORT_STAT_C_LINK_STATE)
					clear_port_feature(hub->hdev, port1,
							USB_PORT_FEAT_C_PORT_LINK_STATE);
				if (portchange & USB_PORT_STAT_C_RESET)
					clear_port_feature(hub->hdev, port1,
							USB_PORT_FEAT_C_RESET);
				dev_dbg(hub->intfdev, "hot reset failed, warm reset port %d\n",
						port1);
				ret = hub_port_reset(hub, port1,
						udev, HUB_BH_RESET_TIME,
						true);
				if ((portchange & USB_PORT_STAT_C_CONNECTION))
					clear_port_feature(hub->hdev, port1,
							USB_PORT_FEAT_C_CONNECTION);
				return ret;
			}
A
Andiry Xu 已提交
2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198
			/* Device went away? */
			if (!(portstatus & USB_PORT_STAT_CONNECTION))
				return -ENOTCONN;

			/* bomb out completely if the connection bounced */
			if ((portchange & USB_PORT_STAT_C_CONNECTION))
				return -ENOTCONN;

			/* if we`ve finished resetting, then break out of
			 * the loop
			 */
			if (!(portstatus & USB_PORT_STAT_RESET) &&
			    (portstatus & USB_PORT_STAT_ENABLE)) {
				if (hub_is_wusb(hub))
					udev->speed = USB_SPEED_WIRELESS;
				else if (hub_is_superspeed(hub->hdev))
					udev->speed = USB_SPEED_SUPER;
				else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
					udev->speed = USB_SPEED_HIGH;
				else if (portstatus & USB_PORT_STAT_LOW_SPEED)
					udev->speed = USB_SPEED_LOW;
				else
					udev->speed = USB_SPEED_FULL;
				return 0;
			}
		} else {
			if (portchange & USB_PORT_STAT_C_BH_RESET)
				return 0;
L
Linus Torvalds 已提交
2199 2200 2201 2202 2203 2204 2205
		}

		/* switch to the long delay after two short delay failures */
		if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
			delay = HUB_LONG_RESET_TIME;

		dev_dbg (hub->intfdev,
A
Andiry Xu 已提交
2206 2207
			"port %d not %sreset yet, waiting %dms\n",
			port1, warm ? "warm " : "", delay);
L
Linus Torvalds 已提交
2208 2209 2210 2211 2212
	}

	return -EBUSY;
}

A
Andiry Xu 已提交
2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253
static void hub_port_finish_reset(struct usb_hub *hub, int port1,
			struct usb_device *udev, int *status, bool warm)
{
	switch (*status) {
	case 0:
		if (!warm) {
			struct usb_hcd *hcd;
			/* TRSTRCY = 10 ms; plus some extra */
			msleep(10 + 40);
			update_devnum(udev, 0);
			hcd = bus_to_hcd(udev->bus);
			if (hcd->driver->reset_device) {
				*status = hcd->driver->reset_device(hcd, udev);
				if (*status < 0) {
					dev_err(&udev->dev, "Cannot reset "
							"HCD device state\n");
					break;
				}
			}
		}
		/* FALL THROUGH */
	case -ENOTCONN:
	case -ENODEV:
		clear_port_feature(hub->hdev,
				port1, USB_PORT_FEAT_C_RESET);
		/* FIXME need disconnect() for NOTATTACHED device */
		if (warm) {
			clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_BH_PORT_RESET);
			clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_PORT_LINK_STATE);
		} else {
			usb_set_device_state(udev, *status
					? USB_STATE_NOTATTACHED
					: USB_STATE_DEFAULT);
		}
		break;
	}
}

/* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */
L
Linus Torvalds 已提交
2254
static int hub_port_reset(struct usb_hub *hub, int port1,
A
Andiry Xu 已提交
2255
			struct usb_device *udev, unsigned int delay, bool warm)
L
Linus Torvalds 已提交
2256 2257 2258
{
	int i, status;

A
Andiry Xu 已提交
2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270
	if (!warm) {
		/* Block EHCI CF initialization during the port reset.
		 * Some companion controllers don't like it when they mix.
		 */
		down_read(&ehci_cf_port_reset_rwsem);
	} else {
		if (!hub_is_superspeed(hub->hdev)) {
			dev_err(hub->intfdev, "only USB3 hub support "
						"warm reset\n");
			return -EINVAL;
		}
	}
2271

L
Linus Torvalds 已提交
2272 2273
	/* Reset the port */
	for (i = 0; i < PORT_RESET_TRIES; i++) {
A
Andiry Xu 已提交
2274 2275 2276 2277
		status = set_port_feature(hub->hdev, port1, (warm ?
					USB_PORT_FEAT_BH_PORT_RESET :
					USB_PORT_FEAT_RESET));
		if (status) {
L
Linus Torvalds 已提交
2278
			dev_err(hub->intfdev,
A
Andiry Xu 已提交
2279 2280 2281 2282 2283
					"cannot %sreset port %d (err = %d)\n",
					warm ? "warm " : "", port1, status);
		} else {
			status = hub_port_wait_reset(hub, port1, udev, delay,
								warm);
2284
			if (status && status != -ENOTCONN)
L
Linus Torvalds 已提交
2285 2286 2287 2288 2289 2290
				dev_dbg(hub->intfdev,
						"port_wait_reset: err = %d\n",
						status);
		}

		/* return on disconnect or reset */
A
Andiry Xu 已提交
2291 2292
		if (status == 0 || status == -ENOTCONN || status == -ENODEV) {
			hub_port_finish_reset(hub, port1, udev, &status, warm);
2293
			goto done;
L
Linus Torvalds 已提交
2294 2295 2296
		}

		dev_dbg (hub->intfdev,
A
Andiry Xu 已提交
2297 2298
			"port %d not enabled, trying %sreset again...\n",
			port1, warm ? "warm " : "");
L
Linus Torvalds 已提交
2299 2300 2301 2302 2303 2304 2305
		delay = HUB_LONG_RESET_TIME;
	}

	dev_err (hub->intfdev,
		"Cannot enable port %i.  Maybe the USB cable is bad?\n",
		port1);

A
Andiry Xu 已提交
2306 2307 2308
done:
	if (!warm)
		up_read(&ehci_cf_port_reset_rwsem);
2309

A
Andiry Xu 已提交
2310
	return status;
2311 2312
}

2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328
/* Check if a port is power on */
static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
{
	int ret = 0;

	if (hub_is_superspeed(hub->hdev)) {
		if (portstatus & USB_SS_PORT_STAT_POWER)
			ret = 1;
	} else {
		if (portstatus & USB_PORT_STAT_POWER)
			ret = 1;
	}

	return ret;
}

A
Alan Stern 已提交
2329
#ifdef	CONFIG_PM
L
Linus Torvalds 已提交
2330

2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346
/* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
{
	int ret = 0;

	if (hub_is_superspeed(hub->hdev)) {
		if ((portstatus & USB_PORT_STAT_LINK_STATE)
				== USB_SS_PORT_LS_U3)
			ret = 1;
	} else {
		if (portstatus & USB_PORT_STAT_SUSPEND)
			ret = 1;
	}

	return ret;
}
2347 2348 2349 2350 2351 2352 2353 2354 2355

/* Determine whether the device on a port is ready for a normal resume,
 * is ready for a reset-resume, or should be disconnected.
 */
static int check_port_resume_type(struct usb_device *udev,
		struct usb_hub *hub, int port1,
		int status, unsigned portchange, unsigned portstatus)
{
	/* Is the device still present? */
2356 2357 2358
	if (status || port_is_suspended(hub, portstatus) ||
			!port_is_power_on(hub, portstatus) ||
			!(portstatus & USB_PORT_STAT_CONNECTION)) {
2359 2360 2361 2362
		if (status >= 0)
			status = -ENODEV;
	}

2363 2364 2365 2366 2367 2368 2369 2370 2371
	/* Can't do a normal resume if the port isn't enabled,
	 * so try a reset-resume instead.
	 */
	else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
		if (udev->persist_enabled)
			udev->reset_resume = 1;
		else
			status = -ENODEV;
	}
2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390

	if (status) {
		dev_dbg(hub->intfdev,
				"port %d status %04x.%04x after resume, %d\n",
				port1, portchange, portstatus, status);
	} else if (udev->reset_resume) {

		/* Late port handoff can set status-change bits */
		if (portchange & USB_PORT_STAT_C_CONNECTION)
			clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_CONNECTION);
		if (portchange & USB_PORT_STAT_C_ENABLE)
			clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_ENABLE);
	}

	return status;
}

L
Linus Torvalds 已提交
2391 2392 2393
#ifdef	CONFIG_USB_SUSPEND

/*
A
Alan Stern 已提交
2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406
 * usb_port_suspend - suspend a usb device's upstream port
 * @udev: device that's no longer in active use, not a root hub
 * Context: must be able to sleep; device not locked; pm locks held
 *
 * Suspends a USB device that isn't in active use, conserving power.
 * Devices may wake out of a suspend, if anything important happens,
 * using the remote wakeup mechanism.  They may also be taken out of
 * suspend by the host, using usb_port_resume().  It's also routine
 * to disconnect devices while they are suspended.
 *
 * This only affects the USB hardware for a device; its interfaces
 * (and, for hubs, child devices) must already have been suspended.
 *
L
Linus Torvalds 已提交
2407 2408 2409 2410 2411 2412 2413 2414
 * Selective port suspend reduces power; most suspended devices draw
 * less than 500 uA.  It's also used in OTG, along with remote wakeup.
 * All devices below the suspended port are also suspended.
 *
 * Devices leave suspend state when the host wakes them up.  Some devices
 * also support "remote wakeup", where the device can activate the USB
 * tree above them to deliver data, such as a keypress or packet.  In
 * some cases, this wakes the USB host.
A
Alan Stern 已提交
2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437
 *
 * Suspending OTG devices may trigger HNP, if that's been enabled
 * between a pair of dual-role devices.  That will change roles, such
 * as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.
 *
 * Devices on USB hub ports have only one "suspend" state, corresponding
 * to ACPI D2, "may cause the device to lose some context".
 * State transitions include:
 *
 *   - suspend, resume ... when the VBUS power link stays live
 *   - suspend, disconnect ... VBUS lost
 *
 * Once VBUS drop breaks the circuit, the port it's using has to go through
 * normal re-enumeration procedures, starting with enabling VBUS power.
 * Other than re-initializing the hub (plug/unplug, except for root hubs),
 * Linux (2.6) currently has NO mechanisms to initiate that:  no khubd
 * timer, no SRP, no requests through sysfs.
 *
 * If CONFIG_USB_SUSPEND isn't enabled, devices only really suspend when
 * the root hub for their bus goes into global suspend ... so we don't
 * (falsely) update the device power state to say it suspended.
 *
 * Returns 0 on success, else negative errno.
L
Linus Torvalds 已提交
2438
 */
A
Alan Stern 已提交
2439
int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
L
Linus Torvalds 已提交
2440
{
A
Alan Stern 已提交
2441 2442 2443
	struct usb_hub	*hub = hdev_to_hub(udev->parent);
	int		port1 = udev->portnum;
	int		status;
L
Linus Torvalds 已提交
2444 2445 2446 2447 2448 2449 2450

	/* enable remote wakeup when appropriate; this lets the device
	 * wake up the upstream hub (including maybe the root hub).
	 *
	 * NOTE:  OTG devices may issue remote wakeup (or SRP) even when
	 * we don't explicitly enable it here.
	 */
2451
	if (udev->do_remote_wakeup) {
2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
		if (!hub_is_superspeed(hub->hdev)) {
			status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
					USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
					USB_DEVICE_REMOTE_WAKEUP, 0,
					NULL, 0,
					USB_CTRL_SET_TIMEOUT);
		} else {
			/* Assume there's only one function on the USB 3.0
			 * device and enable remote wake for the first
			 * interface. FIXME if the interface association
			 * descriptor shows there's more than one function.
			 */
			status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
					USB_REQ_SET_FEATURE,
					USB_RECIP_INTERFACE,
					USB_INTRF_FUNC_SUSPEND,
2468 2469
					USB_INTRF_FUNC_SUSPEND_RW |
					USB_INTRF_FUNC_SUSPEND_LP,
2470 2471 2472
					NULL, 0,
					USB_CTRL_SET_TIMEOUT);
		}
2473
		if (status) {
A
Alan Stern 已提交
2474 2475
			dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
					status);
2476
			/* bail if autosuspend is requested */
2477
			if (PMSG_IS_AUTO(msg))
2478 2479
				return status;
		}
L
Linus Torvalds 已提交
2480 2481
	}

A
Andiry Xu 已提交
2482 2483 2484 2485
	/* disable USB2 hardware LPM */
	if (udev->usb2_hw_lpm_enabled == 1)
		usb_set_usb2_hardware_lpm(udev, 0);

L
Linus Torvalds 已提交
2486
	/* see 7.1.7.6 */
2487 2488 2489 2490
	if (hub_is_superspeed(hub->hdev))
		status = set_port_feature(hub->hdev,
				port1 | (USB_SS_PORT_LS_U3 << 3),
				USB_PORT_FEAT_LINK_STATE);
2491 2492 2493
	else
		status = set_port_feature(hub->hdev, port1,
						USB_PORT_FEAT_SUSPEND);
L
Linus Torvalds 已提交
2494
	if (status) {
A
Alan Stern 已提交
2495 2496
		dev_dbg(hub->intfdev, "can't suspend port %d, status %d\n",
				port1, status);
L
Linus Torvalds 已提交
2497
		/* paranoia:  "should not happen" */
2498 2499
		if (udev->do_remote_wakeup)
			(void) usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
L
Linus Torvalds 已提交
2500 2501 2502 2503
				USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
				USB_DEVICE_REMOTE_WAKEUP, 0,
				NULL, 0,
				USB_CTRL_SET_TIMEOUT);
2504 2505

		/* System sleep transitions should never fail */
2506
		if (!PMSG_IS_AUTO(msg))
2507
			status = 0;
L
Linus Torvalds 已提交
2508 2509
	} else {
		/* device has up to 10 msec to fully suspend */
2510 2511 2512
		dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n",
				(PMSG_IS_AUTO(msg) ? "auto-" : ""),
				udev->do_remote_wakeup);
L
Linus Torvalds 已提交
2513 2514 2515
		usb_set_device_state(udev, USB_STATE_SUSPENDED);
		msleep(10);
	}
2516
	usb_mark_last_busy(hub->hdev);
L
Linus Torvalds 已提交
2517 2518 2519 2520
	return status;
}

/*
2521 2522
 * If the USB "suspend" state is in use (rather than "global suspend"),
 * many devices will be individually taken out of suspend state using
2523
 * special "resume" signaling.  This routine kicks in shortly after
L
Linus Torvalds 已提交
2524 2525 2526
 * hardware resume signaling is finished, either because of selective
 * resume (by host) or remote wakeup (by device) ... now see what changed
 * in the tree that's rooted at this device.
2527 2528 2529
 *
 * If @udev->reset_resume is set then the device is reset before the
 * status check is done.
L
Linus Torvalds 已提交
2530
 */
2531
static int finish_port_resume(struct usb_device *udev)
L
Linus Torvalds 已提交
2532
{
2533
	int	status = 0;
L
Linus Torvalds 已提交
2534 2535 2536
	u16	devstatus;

	/* caller owns the udev device lock */
2537 2538
	dev_dbg(&udev->dev, "%s\n",
		udev->reset_resume ? "finish reset-resume" : "finish resume");
L
Linus Torvalds 已提交
2539 2540 2541 2542 2543 2544 2545 2546 2547 2548

	/* usb ch9 identifies four variants of SUSPENDED, based on what
	 * state the device resumes to.  Linux currently won't see the
	 * first two on the host side; they'd be inside hub_port_init()
	 * during many timeouts, but khubd can't suspend until later.
	 */
	usb_set_device_state(udev, udev->actconfig
			? USB_STATE_CONFIGURED
			: USB_STATE_ADDRESS);

2549 2550 2551 2552 2553 2554
	/* 10.5.4.5 says not to reset a suspended port if the attached
	 * device is enabled for remote wakeup.  Hence the reset
	 * operation is carried out here, after the port has been
	 * resumed.
	 */
	if (udev->reset_resume)
2555
 retry_reset_resume:
2556
		status = usb_reset_and_verify_device(udev);
2557

L
Linus Torvalds 已提交
2558 2559 2560 2561
 	/* 10.5.4.5 says be sure devices in the tree are still there.
 	 * For now let's assume the device didn't go crazy on resume,
	 * and device drivers will know about any resume quirks.
	 */
2562
	if (status == 0) {
2563
		devstatus = 0;
2564 2565
		status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
		if (status >= 0)
2566
			status = (status > 0 ? 0 : -ENODEV);
2567 2568 2569 2570 2571 2572 2573

		/* If a normal resume failed, try doing a reset-resume */
		if (status && !udev->reset_resume && udev->persist_enabled) {
			dev_dbg(&udev->dev, "retry with reset-resume\n");
			udev->reset_resume = 1;
			goto retry_reset_resume;
		}
2574
	}
2575

A
Alan Stern 已提交
2576 2577 2578 2579
	if (status) {
		dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
				status);
	} else if (udev->actconfig) {
L
Linus Torvalds 已提交
2580
		le16_to_cpus(&devstatus);
2581
		if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) {
L
Linus Torvalds 已提交
2582 2583 2584 2585 2586 2587 2588
			status = usb_control_msg(udev,
					usb_sndctrlpipe(udev, 0),
					USB_REQ_CLEAR_FEATURE,
						USB_RECIP_DEVICE,
					USB_DEVICE_REMOTE_WAKEUP, 0,
					NULL, 0,
					USB_CTRL_SET_TIMEOUT);
2589
			if (status)
2590 2591 2592
				dev_dbg(&udev->dev,
					"disable remote wakeup, status %d\n",
					status);
2593
		}
L
Linus Torvalds 已提交
2594 2595 2596 2597 2598
		status = 0;
	}
	return status;
}

A
Alan Stern 已提交
2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609
/*
 * usb_port_resume - re-activate a suspended usb device's upstream port
 * @udev: device to re-activate, not a root hub
 * Context: must be able to sleep; device not locked; pm locks held
 *
 * This will re-activate the suspended device, increasing power usage
 * while letting drivers communicate again with its endpoints.
 * USB resume explicitly guarantees that the power session between
 * the host and the device is the same as it was when the device
 * suspended.
 *
2610 2611
 * If @udev->reset_resume is set then this routine won't check that the
 * port is still enabled.  Furthermore, finish_port_resume() above will
2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622
 * reset @udev.  The end result is that a broken power session can be
 * recovered and @udev will appear to persist across a loss of VBUS power.
 *
 * For example, if a host controller doesn't maintain VBUS suspend current
 * during a system sleep or is reset when the system wakes up, all the USB
 * power sessions below it will be broken.  This is especially troublesome
 * for mass-storage devices containing mounted filesystems, since the
 * device will appear to have disconnected and all the memory mappings
 * to it will be lost.  Using the USB_PERSIST facility, the device can be
 * made to appear as if it had not disconnected.
 *
2623
 * This facility can be dangerous.  Although usb_reset_and_verify_device() makes
2624
 * every effort to insure that the same device is present after the
2625 2626 2627 2628 2629 2630
 * reset as before, it cannot provide a 100% guarantee.  Furthermore it's
 * quite possible for a device to remain unaltered but its media to be
 * changed.  If the user replaces a flash memory card while the system is
 * asleep, he will have only himself to blame when the filesystem on the
 * new card is corrupted and the system crashes.
 *
A
Alan Stern 已提交
2631 2632
 * Returns 0 on success, else negative errno.
 */
A
Alan Stern 已提交
2633
int usb_port_resume(struct usb_device *udev, pm_message_t msg)
L
Linus Torvalds 已提交
2634
{
A
Alan Stern 已提交
2635 2636 2637 2638
	struct usb_hub	*hub = hdev_to_hub(udev->parent);
	int		port1 = udev->portnum;
	int		status;
	u16		portchange, portstatus;
2639 2640 2641

	/* Skip the initial Clear-Suspend step for a remote wakeup */
	status = hub_port_status(hub, port1, &portstatus, &portchange);
2642
	if (status == 0 && !port_is_suspended(hub, portstatus))
2643
		goto SuspendCleared;
L
Linus Torvalds 已提交
2644 2645 2646

	// dev_dbg(hub->intfdev, "resume port %d\n", port1);

2647 2648
	set_bit(port1, hub->busy_bits);

L
Linus Torvalds 已提交
2649
	/* see 7.1.7.7; affects power usage, but not budgeting */
2650 2651 2652 2653 2654 2655 2656
	if (hub_is_superspeed(hub->hdev))
		status = set_port_feature(hub->hdev,
				port1 | (USB_SS_PORT_LS_U0 << 3),
				USB_PORT_FEAT_LINK_STATE);
	else
		status = clear_port_feature(hub->hdev,
				port1, USB_PORT_FEAT_SUSPEND);
L
Linus Torvalds 已提交
2657
	if (status) {
A
Alan Stern 已提交
2658 2659
		dev_dbg(hub->intfdev, "can't resume port %d, status %d\n",
				port1, status);
L
Linus Torvalds 已提交
2660 2661
	} else {
		/* drive resume for at least 20 msec */
2662
		dev_dbg(&udev->dev, "usb %sresume\n",
2663
				(PMSG_IS_AUTO(msg) ? "auto-" : ""));
L
Linus Torvalds 已提交
2664 2665 2666 2667 2668 2669
		msleep(25);

		/* Virtual root hubs can trigger on GET_PORT_STATUS to
		 * stop resume signaling.  Then finish the resume
		 * sequence.
		 */
2670
		status = hub_port_status(hub, port1, &portstatus, &portchange);
2671

2672 2673 2674 2675
		/* TRSMRCY = 10 msec */
		msleep(10);
	}

2676
 SuspendCleared:
2677
	if (status == 0) {
2678 2679 2680 2681 2682 2683 2684 2685 2686
		if (hub_is_superspeed(hub->hdev)) {
			if (portchange & USB_PORT_STAT_C_LINK_STATE)
				clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_PORT_LINK_STATE);
		} else {
			if (portchange & USB_PORT_STAT_C_SUSPEND)
				clear_port_feature(hub->hdev, port1,
						USB_PORT_FEAT_C_SUSPEND);
		}
L
Linus Torvalds 已提交
2687 2688
	}

2689 2690
	clear_bit(port1, hub->busy_bits);

2691 2692
	status = check_port_resume_type(udev,
			hub, port1, status, portchange, portstatus);
2693 2694 2695 2696 2697
	if (status == 0)
		status = finish_port_resume(udev);
	if (status < 0) {
		dev_dbg(&udev->dev, "can't resume, status %d\n", status);
		hub_port_logical_disconnect(hub, port1);
A
Andiry Xu 已提交
2698 2699 2700 2701
	} else  {
		/* Try to enable USB2 hardware LPM */
		if (udev->usb2_hw_lpm_capable == 1)
			usb_set_usb2_hardware_lpm(udev, 1);
2702
	}
A
Andiry Xu 已提交
2703

L
Linus Torvalds 已提交
2704 2705 2706
	return status;
}

2707
/* caller has locked udev */
2708
int usb_remote_wakeup(struct usb_device *udev)
L
Linus Torvalds 已提交
2709 2710 2711 2712
{
	int	status = 0;

	if (udev->state == USB_STATE_SUSPENDED) {
2713
		dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
2714 2715 2716 2717 2718
		status = usb_autoresume_device(udev);
		if (status == 0) {
			/* Let the drivers do their thing, then... */
			usb_autosuspend_device(udev);
		}
L
Linus Torvalds 已提交
2719 2720 2721 2722
	}
	return status;
}

A
Alan Stern 已提交
2723 2724 2725 2726
#else	/* CONFIG_USB_SUSPEND */

/* When CONFIG_USB_SUSPEND isn't set, we never suspend or resume any ports. */

A
Alan Stern 已提交
2727
int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
A
Alan Stern 已提交
2728 2729 2730 2731
{
	return 0;
}

2732 2733
/* However we may need to do a reset-resume */

A
Alan Stern 已提交
2734
int usb_port_resume(struct usb_device *udev, pm_message_t msg)
A
Alan Stern 已提交
2735
{
2736 2737 2738 2739 2740 2741 2742 2743
	struct usb_hub	*hub = hdev_to_hub(udev->parent);
	int		port1 = udev->portnum;
	int		status;
	u16		portchange, portstatus;

	status = hub_port_status(hub, port1, &portstatus, &portchange);
	status = check_port_resume_type(udev,
			hub, port1, status, portchange, portstatus);
2744

2745 2746 2747 2748
	if (status) {
		dev_dbg(&udev->dev, "can't resume, status %d\n", status);
		hub_port_logical_disconnect(hub, port1);
	} else if (udev->reset_resume) {
2749
		dev_dbg(&udev->dev, "reset-resume\n");
2750
		status = usb_reset_and_verify_device(udev);
2751 2752
	}
	return status;
A
Alan Stern 已提交
2753 2754 2755 2756
}

#endif

D
David Brownell 已提交
2757
static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
L
Linus Torvalds 已提交
2758 2759 2760 2761
{
	struct usb_hub		*hub = usb_get_intfdata (intf);
	struct usb_device	*hdev = hub->hdev;
	unsigned		port1;
2762
	int			status;
L
Linus Torvalds 已提交
2763

2764
	/* Warn if children aren't already suspended */
L
Linus Torvalds 已提交
2765 2766 2767 2768
	for (port1 = 1; port1 <= hdev->maxchild; port1++) {
		struct usb_device	*udev;

		udev = hdev->children [port1-1];
2769
		if (udev && udev->can_submit) {
2770
			dev_warn(&intf->dev, "port %d nyet suspended\n", port1);
2771
			if (PMSG_IS_AUTO(msg))
2772
				return -EBUSY;
2773
		}
L
Linus Torvalds 已提交
2774
	}
2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785
	if (hub_is_superspeed(hdev) && hdev->do_remote_wakeup) {
		/* Enable hub to send remote wakeup for all ports. */
		for (port1 = 1; port1 <= hdev->maxchild; port1++) {
			status = set_port_feature(hdev,
					port1 |
					USB_PORT_FEAT_REMOTE_WAKE_CONNECT |
					USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT |
					USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT,
					USB_PORT_FEAT_REMOTE_WAKE_MASK);
		}
	}
L
Linus Torvalds 已提交
2786

2787
	dev_dbg(&intf->dev, "%s\n", __func__);
2788

2789
	/* stop khubd and related activity */
2790
	hub_quiesce(hub, HUB_SUSPEND);
2791
	return 0;
L
Linus Torvalds 已提交
2792 2793 2794 2795
}

static int hub_resume(struct usb_interface *intf)
{
2796
	struct usb_hub *hub = usb_get_intfdata(intf);
2797

2798
	dev_dbg(&intf->dev, "%s\n", __func__);
2799
	hub_activate(hub, HUB_RESUME);
L
Linus Torvalds 已提交
2800 2801 2802
	return 0;
}

2803
static int hub_reset_resume(struct usb_interface *intf)
A
Alan Stern 已提交
2804
{
2805
	struct usb_hub *hub = usb_get_intfdata(intf);
A
Alan Stern 已提交
2806

2807
	dev_dbg(&intf->dev, "%s\n", __func__);
2808
	hub_activate(hub, HUB_RESET_RESUME);
A
Alan Stern 已提交
2809 2810 2811
	return 0;
}

2812 2813 2814 2815 2816 2817
/**
 * usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power
 * @rhdev: struct usb_device for the root hub
 *
 * The USB host controller driver calls this function when its root hub
 * is resumed and Vbus power has been interrupted or the controller
2818 2819 2820 2821
 * has been reset.  The routine marks @rhdev as having lost power.
 * When the hub driver is resumed it will take notice and carry out
 * power-session recovery for all the "USB-PERSIST"-enabled child devices;
 * the others will be disconnected.
2822 2823 2824 2825 2826 2827 2828 2829
 */
void usb_root_hub_lost_power(struct usb_device *rhdev)
{
	dev_warn(&rhdev->dev, "root hub lost power or was reset\n");
	rhdev->reset_resume = 1;
}
EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);

A
Alan Stern 已提交
2830 2831
#else	/* CONFIG_PM */

A
Alan Stern 已提交
2832 2833 2834
#define hub_suspend		NULL
#define hub_resume		NULL
#define hub_reset_resume	NULL
A
Alan Stern 已提交
2835 2836
#endif

L
Linus Torvalds 已提交
2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893

/* USB 2.0 spec, 7.1.7.3 / fig 7-29:
 *
 * Between connect detection and reset signaling there must be a delay
 * of 100ms at least for debounce and power-settling.  The corresponding
 * timer shall restart whenever the downstream port detects a disconnect.
 * 
 * Apparently there are some bluetooth and irda-dongles and a number of
 * low-speed devices for which this debounce period may last over a second.
 * Not covered by the spec - but easy to deal with.
 *
 * This implementation uses a 1500ms total debounce timeout; if the
 * connection isn't stable by then it returns -ETIMEDOUT.  It checks
 * every 25ms for transient disconnects.  When the port status has been
 * unchanged for 100ms it returns the port status.
 */
static int hub_port_debounce(struct usb_hub *hub, int port1)
{
	int ret;
	int total_time, stable_time = 0;
	u16 portchange, portstatus;
	unsigned connection = 0xffff;

	for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
		ret = hub_port_status(hub, port1, &portstatus, &portchange);
		if (ret < 0)
			return ret;

		if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
		     (portstatus & USB_PORT_STAT_CONNECTION) == connection) {
			stable_time += HUB_DEBOUNCE_STEP;
			if (stable_time >= HUB_DEBOUNCE_STABLE)
				break;
		} else {
			stable_time = 0;
			connection = portstatus & USB_PORT_STAT_CONNECTION;
		}

		if (portchange & USB_PORT_STAT_C_CONNECTION) {
			clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_CONNECTION);
		}

		if (total_time >= HUB_DEBOUNCE_TIMEOUT)
			break;
		msleep(HUB_DEBOUNCE_STEP);
	}

	dev_dbg (hub->intfdev,
		"debounce: port %d: total %dms stable %dms status 0x%x\n",
		port1, total_time, stable_time, portstatus);

	if (stable_time < HUB_DEBOUNCE_STABLE)
		return -ETIMEDOUT;
	return portstatus;
}

2894
void usb_ep0_reinit(struct usb_device *udev)
L
Linus Torvalds 已提交
2895
{
2896 2897
	usb_disable_endpoint(udev, 0 + USB_DIR_IN, true);
	usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true);
2898
	usb_enable_endpoint(udev, &udev->ep0, true);
L
Linus Torvalds 已提交
2899
}
2900
EXPORT_SYMBOL_GPL(usb_ep0_reinit);
L
Linus Torvalds 已提交
2901 2902 2903 2904

#define usb_sndaddr0pipe()	(PIPE_CONTROL << 30)
#define usb_rcvaddr0pipe()	((PIPE_CONTROL << 30) | USB_DIR_IN)

2905
static int hub_set_address(struct usb_device *udev, int devnum)
L
Linus Torvalds 已提交
2906 2907
{
	int retval;
2908
	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
L
Linus Torvalds 已提交
2909

2910 2911 2912 2913 2914
	/*
	 * The host controller will choose the device address,
	 * instead of the core having chosen it earlier
	 */
	if (!hcd->driver->address_device && devnum <= 1)
L
Linus Torvalds 已提交
2915 2916 2917 2918 2919
		return -EINVAL;
	if (udev->state == USB_STATE_ADDRESS)
		return 0;
	if (udev->state != USB_STATE_DEFAULT)
		return -EINVAL;
2920
	if (hcd->driver->address_device)
2921
		retval = hcd->driver->address_device(hcd, udev);
2922
	else
2923 2924 2925
		retval = usb_control_msg(udev, usb_sndaddr0pipe(),
				USB_REQ_SET_ADDRESS, 0, devnum, 0,
				NULL, 0, USB_CTRL_SET_TIMEOUT);
L
Linus Torvalds 已提交
2926
	if (retval == 0) {
2927
		update_devnum(udev, devnum);
2928
		/* Device now using proper address. */
L
Linus Torvalds 已提交
2929
		usb_set_device_state(udev, USB_STATE_ADDRESS);
2930
		usb_ep0_reinit(udev);
L
Linus Torvalds 已提交
2931 2932 2933 2934 2935 2936 2937 2938 2939
	}
	return retval;
}

/* Reset device, (re)assign address, get device descriptor.
 * Device connection must be stable, no more debouncing needed.
 * Returns device in USB_STATE_ADDRESS, except on error.
 *
 * If this is called for an already-existing device (as part of
2940
 * usb_reset_and_verify_device), the caller must own the device lock.  For a
L
Linus Torvalds 已提交
2941 2942 2943 2944 2945 2946 2947
 * newly detected device that is not accessible through any global
 * pointers, it's not necessary to lock the device.
 */
static int
hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
		int retry_counter)
{
2948
	static DEFINE_MUTEX(usb_address0_mutex);
L
Linus Torvalds 已提交
2949 2950

	struct usb_device	*hdev = hub->hdev;
2951
	struct usb_hcd		*hcd = bus_to_hcd(hdev->bus);
L
Linus Torvalds 已提交
2952 2953 2954
	int			i, j, retval;
	unsigned		delay = HUB_SHORT_RESET_TIME;
	enum usb_device_speed	oldspeed = udev->speed;
2955
	const char		*speed;
2956
	int			devnum = udev->devnum;
L
Linus Torvalds 已提交
2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971

	/* root hub ports have a slightly longer reset period
	 * (from USB 2.0 spec, section 7.1.7.5)
	 */
	if (!hdev->parent) {
		delay = HUB_ROOT_RESET_TIME;
		if (port1 == hdev->bus->otg_port)
			hdev->bus->b_hnp_enable = 0;
	}

	/* Some low speed devices have problems with the quick delay, so */
	/*  be a bit pessimistic with those devices. RHbug #23670 */
	if (oldspeed == USB_SPEED_LOW)
		delay = HUB_LONG_RESET_TIME;

2972
	mutex_lock(&usb_address0_mutex);
L
Linus Torvalds 已提交
2973

2974 2975
	/* Reset the device; full speed may morph to high speed */
	/* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
A
Andiry Xu 已提交
2976
	retval = hub_port_reset(hub, port1, udev, delay, false);
2977 2978 2979 2980
	if (retval < 0)		/* error or disconnect */
		goto fail;
	/* success, speed is known */

L
Linus Torvalds 已提交
2981 2982 2983 2984 2985 2986 2987
	retval = -ENODEV;

	if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) {
		dev_dbg(&udev->dev, "device reset changed speed!\n");
		goto fail;
	}
	oldspeed = udev->speed;
2988

L
Linus Torvalds 已提交
2989 2990
	/* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
	 * it's fixed size except for full speed devices.
2991 2992
	 * For Wireless USB devices, ep0 max packet is always 512 (tho
	 * reported as 0xff in the device descriptor). WUSB1.0[4.8.1].
L
Linus Torvalds 已提交
2993 2994
	 */
	switch (udev->speed) {
2995
	case USB_SPEED_SUPER:
2996
	case USB_SPEED_WIRELESS:	/* fixed at 512 */
2997
		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
2998
		break;
L
Linus Torvalds 已提交
2999
	case USB_SPEED_HIGH:		/* fixed at 64 */
3000
		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
L
Linus Torvalds 已提交
3001 3002 3003 3004 3005 3006
		break;
	case USB_SPEED_FULL:		/* 8, 16, 32, or 64 */
		/* to determine the ep0 maxpacket size, try to read
		 * the device descriptor to get bMaxPacketSize0 and
		 * then correct our initial guess.
		 */
3007
		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
L
Linus Torvalds 已提交
3008 3009
		break;
	case USB_SPEED_LOW:		/* fixed at 8 */
3010
		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
L
Linus Torvalds 已提交
3011 3012 3013 3014
		break;
	default:
		goto fail;
	}
3015 3016 3017 3018 3019 3020

	if (udev->speed == USB_SPEED_WIRELESS)
		speed = "variable speed Wireless";
	else
		speed = usb_speed_string(udev->speed);

3021 3022
	if (udev->speed != USB_SPEED_SUPER)
		dev_info(&udev->dev,
3023 3024
				"%s %s USB device number %d using %s\n",
				(udev->config) ? "reset" : "new", speed,
3025
				devnum, udev->bus->controller->driver->name);
L
Linus Torvalds 已提交
3026 3027 3028 3029 3030 3031 3032

	/* Set up TT records, if needed  */
	if (hdev->tt) {
		udev->tt = hdev->tt;
		udev->ttport = hdev->ttport;
	} else if (udev->speed != USB_SPEED_HIGH
			&& hdev->speed == USB_SPEED_HIGH) {
3033 3034 3035 3036 3037
		if (!hub->tt.hub) {
			dev_err(&udev->dev, "parent hub has no TT\n");
			retval = -EINVAL;
			goto fail;
		}
L
Linus Torvalds 已提交
3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054
		udev->tt = &hub->tt;
		udev->ttport = port1;
	}
 
	/* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way?
	 * Because device hardware and firmware is sometimes buggy in
	 * this area, and this is how Linux has done it for ages.
	 * Change it cautiously.
	 *
	 * NOTE:  If USE_NEW_SCHEME() is true we will start by issuing
	 * a 64-byte GET_DESCRIPTOR request.  This is what Windows does,
	 * so it may help with some non-standards-compliant devices.
	 * Otherwise we start with SET_ADDRESS and then try to read the
	 * first 8 bytes of the device descriptor to get the ep0 maxpacket
	 * value.
	 */
	for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {
3055
		if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3)) {
L
Linus Torvalds 已提交
3056 3057 3058 3059 3060 3061 3062 3063 3064 3065
			struct usb_device_descriptor *buf;
			int r = 0;

#define GET_DESCRIPTOR_BUFSIZE	64
			buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
			if (!buf) {
				retval = -ENOMEM;
				continue;
			}

3066 3067 3068
			/* Retry on all errors; some devices are flakey.
			 * 255 is for WUSB devices, we actually need to use
			 * 512 (WUSB1.0[4.8.1]).
L
Linus Torvalds 已提交
3069 3070 3071 3072 3073 3074 3075
			 */
			for (j = 0; j < 3; ++j) {
				buf->bMaxPacketSize0 = 0;
				r = usb_control_msg(udev, usb_rcvaddr0pipe(),
					USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
					USB_DT_DEVICE << 8, 0,
					buf, GET_DESCRIPTOR_BUFSIZE,
3076
					initial_descriptor_timeout);
L
Linus Torvalds 已提交
3077
				switch (buf->bMaxPacketSize0) {
3078
				case 8: case 16: case 32: case 64: case 255:
L
Linus Torvalds 已提交
3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096
					if (buf->bDescriptorType ==
							USB_DT_DEVICE) {
						r = 0;
						break;
					}
					/* FALL THROUGH */
				default:
					if (r == 0)
						r = -EPROTO;
					break;
				}
				if (r == 0)
					break;
			}
			udev->descriptor.bMaxPacketSize0 =
					buf->bMaxPacketSize0;
			kfree(buf);

A
Andiry Xu 已提交
3097
			retval = hub_port_reset(hub, port1, udev, delay, false);
L
Linus Torvalds 已提交
3098 3099 3100 3101 3102 3103 3104 3105 3106
			if (retval < 0)		/* error or disconnect */
				goto fail;
			if (oldspeed != udev->speed) {
				dev_dbg(&udev->dev,
					"device reset changed speed!\n");
				retval = -ENODEV;
				goto fail;
			}
			if (r) {
3107 3108 3109
				dev_err(&udev->dev,
					"device descriptor read/64, error %d\n",
					r);
L
Linus Torvalds 已提交
3110 3111 3112 3113 3114 3115
				retval = -EMSGSIZE;
				continue;
			}
#undef GET_DESCRIPTOR_BUFSIZE
		}

3116 3117 3118 3119 3120
 		/*
 		 * If device is WUSB, we already assigned an
 		 * unauthorized address in the Connect Ack sequence;
 		 * authorization will assign the final address.
 		 */
3121
		if (udev->wusb == 0) {
3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133
			for (j = 0; j < SET_ADDRESS_TRIES; ++j) {
				retval = hub_set_address(udev, devnum);
				if (retval >= 0)
					break;
				msleep(200);
			}
			if (retval < 0) {
				dev_err(&udev->dev,
					"device not accepting address %d, error %d\n",
					devnum, retval);
				goto fail;
			}
3134 3135 3136
			if (udev->speed == USB_SPEED_SUPER) {
				devnum = udev->devnum;
				dev_info(&udev->dev,
3137
						"%s SuperSpeed USB device number %d using %s\n",
3138
						(udev->config) ? "reset" : "new",
3139
						devnum, udev->bus->controller->driver->name);
3140
			}
3141 3142 3143 3144 3145 3146

			/* cope with hardware quirkiness:
			 *  - let SET_ADDRESS settle, some device hardware wants it
			 *  - read ep0 maxpacket even for high and low speed,
			 */
			msleep(10);
3147
			if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3))
L
Linus Torvalds 已提交
3148
				break;
3149
  		}
L
Linus Torvalds 已提交
3150 3151 3152

		retval = usb_get_device_descriptor(udev, 8);
		if (retval < 8) {
3153 3154 3155
			dev_err(&udev->dev,
					"device descriptor read/8, error %d\n",
					retval);
L
Linus Torvalds 已提交
3156 3157 3158 3159 3160 3161 3162 3163 3164 3165
			if (retval >= 0)
				retval = -EMSGSIZE;
		} else {
			retval = 0;
			break;
		}
	}
	if (retval)
		goto fail;

3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181
	/*
	 * Some superspeed devices have finished the link training process
	 * and attached to a superspeed hub port, but the device descriptor
	 * got from those devices show they aren't superspeed devices. Warm
	 * reset the port attached by the devices can fix them.
	 */
	if ((udev->speed == USB_SPEED_SUPER) &&
			(le16_to_cpu(udev->descriptor.bcdUSB) < 0x0300)) {
		dev_err(&udev->dev, "got a wrong device descriptor, "
				"warm reset device\n");
		hub_port_reset(hub, port1, udev,
				HUB_BH_RESET_TIME, true);
		retval = -EINVAL;
		goto fail;
	}

3182 3183 3184 3185 3186
	if (udev->descriptor.bMaxPacketSize0 == 0xff ||
			udev->speed == USB_SPEED_SUPER)
		i = 512;
	else
		i = udev->descriptor.bMaxPacketSize0;
3187
	if (usb_endpoint_maxp(&udev->ep0.desc) != i) {
3188
		if (udev->speed == USB_SPEED_LOW ||
L
Linus Torvalds 已提交
3189
				!(i == 8 || i == 16 || i == 32 || i == 64)) {
3190
			dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
L
Linus Torvalds 已提交
3191 3192 3193
			retval = -EMSGSIZE;
			goto fail;
		}
3194 3195 3196 3197
		if (udev->speed == USB_SPEED_FULL)
			dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
		else
			dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i);
L
Linus Torvalds 已提交
3198
		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
3199
		usb_ep0_reinit(udev);
L
Linus Torvalds 已提交
3200 3201 3202 3203
	}
  
	retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
	if (retval < (signed)sizeof(udev->descriptor)) {
3204 3205
		dev_err(&udev->dev, "device descriptor read/all, error %d\n",
			retval);
L
Linus Torvalds 已提交
3206 3207 3208 3209 3210
		if (retval >= 0)
			retval = -ENOMSG;
		goto fail;
	}

3211 3212 3213 3214 3215 3216 3217 3218
	if (udev->wusb == 0 && le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0201) {
		retval = usb_get_bos_descriptor(udev);
		if (!retval) {
			if (udev->bos->ext_cap && (USB_LPM_SUPPORT &
				le32_to_cpu(udev->bos->ext_cap->bmAttributes)))
					udev->lpm_capable = 1;
		}
	}
A
Andiry Xu 已提交
3219

L
Linus Torvalds 已提交
3220
	retval = 0;
3221 3222 3223
	/* notify HCD that we have a device connected and addressed */
	if (hcd->driver->update_device)
		hcd->driver->update_device(hcd, udev);
L
Linus Torvalds 已提交
3224
fail:
3225
	if (retval) {
L
Linus Torvalds 已提交
3226
		hub_port_disable(hub, port1, 0);
3227
		update_devnum(udev, devnum);	/* for disconnect processing */
3228
	}
3229
	mutex_unlock(&usb_address0_mutex);
L
Linus Torvalds 已提交
3230 3231 3232 3233 3234 3235 3236 3237 3238
	return retval;
}

static void
check_highspeed (struct usb_hub *hub, struct usb_device *udev, int port1)
{
	struct usb_qualifier_descriptor	*qual;
	int				status;

3239
	qual = kmalloc (sizeof *qual, GFP_KERNEL);
L
Linus Torvalds 已提交
3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250
	if (qual == NULL)
		return;

	status = usb_get_descriptor (udev, USB_DT_DEVICE_QUALIFIER, 0,
			qual, sizeof *qual);
	if (status == sizeof *qual) {
		dev_info(&udev->dev, "not running at top speed; "
			"connect to a high speed hub\n");
		/* hub LEDs are probably harder to miss than syslog */
		if (hub->has_indicators) {
			hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;
D
David Howells 已提交
3251
			schedule_delayed_work (&hub->leds, 0);
L
Linus Torvalds 已提交
3252 3253
		}
	}
3254
	kfree(qual);
L
Linus Torvalds 已提交
3255 3256 3257 3258 3259 3260 3261
}

static unsigned
hub_power_remaining (struct usb_hub *hub)
{
	struct usb_device *hdev = hub->hdev;
	int remaining;
3262
	int port1;
L
Linus Torvalds 已提交
3263

3264
	if (!hub->limited_power)
L
Linus Torvalds 已提交
3265 3266
		return 0;

3267 3268 3269 3270
	remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
	for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
		struct usb_device	*udev = hdev->children[port1 - 1];
		int			delta;
L
Linus Torvalds 已提交
3271 3272 3273 3274

		if (!udev)
			continue;

3275 3276
		/* Unconfigured devices may not use more than 100mA,
		 * or 8mA for OTG ports */
L
Linus Torvalds 已提交
3277
		if (udev->actconfig)
3278 3279 3280
			delta = udev->actconfig->desc.bMaxPower * 2;
		else if (port1 != udev->bus->otg_port || hdev->parent)
			delta = 100;
L
Linus Torvalds 已提交
3281
		else
3282 3283
			delta = 8;
		if (delta > hub->mA_per_port)
3284 3285 3286
			dev_warn(&udev->dev,
				 "%dmA is over %umA budget for port %d!\n",
				 delta, hub->mA_per_port, port1);
L
Linus Torvalds 已提交
3287 3288 3289
		remaining -= delta;
	}
	if (remaining < 0) {
3290 3291
		dev_warn(hub->intfdev, "%dmA over power budget!\n",
			- remaining);
L
Linus Torvalds 已提交
3292 3293 3294 3295 3296 3297 3298 3299 3300
		remaining = 0;
	}
	return remaining;
}

/* Handle physical or logical connection change events.
 * This routine is called when:
 * 	a port connection-change occurs;
 *	a port enable-change occurs (often caused by EMI);
3301
 *	usb_reset_and_verify_device() encounters changed descriptors (as from
L
Linus Torvalds 已提交
3302 3303 3304 3305 3306 3307 3308 3309
 *		a firmware download)
 * caller already locked the hub
 */
static void hub_port_connect_change(struct usb_hub *hub, int port1,
					u16 portstatus, u16 portchange)
{
	struct usb_device *hdev = hub->hdev;
	struct device *hub_dev = hub->intfdev;
3310
	struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
A
Alan Stern 已提交
3311 3312
	unsigned wHubCharacteristics =
			le16_to_cpu(hub->descriptor->wHubCharacteristics);
3313
	struct usb_device *udev;
L
Linus Torvalds 已提交
3314
	int status, i;
A
Alan Stern 已提交
3315

L
Linus Torvalds 已提交
3316 3317
	dev_dbg (hub_dev,
		"port %d, status %04x, change %04x, %s\n",
3318
		port1, portstatus, portchange, portspeed(hub, portstatus));
L
Linus Torvalds 已提交
3319 3320 3321 3322 3323 3324 3325 3326 3327

	if (hub->has_indicators) {
		set_port_led(hub, port1, HUB_LED_AUTO);
		hub->indicator[port1-1] = INDICATOR_AUTO;
	}

#ifdef	CONFIG_USB_OTG
	/* during HNP, don't repeat the debounce */
	if (hdev->bus->is_b_host)
A
Alan Stern 已提交
3328 3329
		portchange &= ~(USB_PORT_STAT_C_CONNECTION |
				USB_PORT_STAT_C_ENABLE);
L
Linus Torvalds 已提交
3330 3331
#endif

3332 3333 3334 3335 3336 3337 3338 3339 3340
	/* Try to resuscitate an existing device */
	udev = hdev->children[port1-1];
	if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
			udev->state != USB_STATE_NOTATTACHED) {
		usb_lock_device(udev);
		if (portstatus & USB_PORT_STAT_ENABLE) {
			status = 0;		/* Nothing to do */

#ifdef CONFIG_USB_SUSPEND
3341 3342
		} else if (udev->state == USB_STATE_SUSPENDED &&
				udev->persist_enabled) {
3343 3344 3345
			/* For a suspended device, treat this as a
			 * remote wakeup event.
			 */
3346
			status = usb_remote_wakeup(udev);
3347 3348 3349
#endif

		} else {
3350
			status = -ENODEV;	/* Don't resuscitate */
3351 3352 3353 3354 3355 3356 3357 3358 3359
		}
		usb_unlock_device(udev);

		if (status == 0) {
			clear_bit(port1, hub->change_bits);
			return;
		}
	}

A
Alan Stern 已提交
3360
	/* Disconnect any existing devices under this port */
3361
	if (udev)
A
Alan Stern 已提交
3362 3363 3364
		usb_disconnect(&hdev->children[port1-1]);
	clear_bit(port1, hub->change_bits);

3365 3366 3367 3368 3369 3370 3371
	/* We can forget about a "removed" device when there's a physical
	 * disconnect or the connect status changes.
	 */
	if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
			(portchange & USB_PORT_STAT_C_CONNECTION))
		clear_bit(port1, hub->removed_bits);

3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384
	if (portchange & (USB_PORT_STAT_C_CONNECTION |
				USB_PORT_STAT_C_ENABLE)) {
		status = hub_port_debounce(hub, port1);
		if (status < 0) {
			if (printk_ratelimit())
				dev_err(hub_dev, "connect-debounce failed, "
						"port %d disabled\n", port1);
			portstatus &= ~USB_PORT_STAT_CONNECTION;
		} else {
			portstatus = status;
		}
	}

3385 3386 3387 3388 3389
	/* Return now if debouncing failed or nothing is connected or
	 * the device was "removed".
	 */
	if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
			test_bit(port1, hub->removed_bits)) {
L
Linus Torvalds 已提交
3390 3391

		/* maybe switch power back on (e.g. root hub was reset) */
3392
		if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
3393
				&& !port_is_power_on(hub, portstatus))
L
Linus Torvalds 已提交
3394
			set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
3395

L
Linus Torvalds 已提交
3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414
		if (portstatus & USB_PORT_STAT_ENABLE)
  			goto done;
		return;
	}

	for (i = 0; i < SET_CONFIG_TRIES; i++) {

		/* reallocate for each attempt, since references
		 * to the previous one can escape in various ways
		 */
		udev = usb_alloc_dev(hdev, hdev->bus, port1);
		if (!udev) {
			dev_err (hub_dev,
				"couldn't allocate port %d usb_device\n",
				port1);
			goto done;
		}

		usb_set_device_state(udev, USB_STATE_POWERED);
3415
 		udev->bus_mA = hub->mA_per_port;
3416
		udev->level = hdev->level + 1;
3417
		udev->wusb = hub_is_wusb(hub);
3418

3419 3420
		/* Only USB 3.0 devices are connected to SuperSpeed hubs. */
		if (hub_is_superspeed(hub->hdev))
3421 3422 3423 3424
			udev->speed = USB_SPEED_SUPER;
		else
			udev->speed = USB_SPEED_UNKNOWN;

3425
		choose_devnum(udev);
3426 3427 3428
		if (udev->devnum <= 0) {
			status = -ENOTCONN;	/* Don't retry */
			goto loop;
3429 3430
		}

3431
		/* reset (non-USB 3.0 devices) and get descriptor */
L
Linus Torvalds 已提交
3432 3433 3434 3435
		status = hub_port_init(hub, udev, port1, i);
		if (status < 0)
			goto loop;

3436 3437 3438 3439
		usb_detect_quirks(udev);
		if (udev->quirks & USB_QUIRK_DELAY_INIT)
			msleep(1000);

L
Linus Torvalds 已提交
3440 3441 3442 3443 3444 3445 3446
		/* consecutive bus-powered hubs aren't reliable; they can
		 * violate the voltage drop budget.  if the new child has
		 * a "powered" LED, users should notice we didn't enable it
		 * (without reading syslog), even without per-port LEDs
		 * on the parent.
		 */
		if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
3447
				&& udev->bus_mA <= 100) {
L
Linus Torvalds 已提交
3448 3449 3450 3451
			u16	devstat;

			status = usb_get_status(udev, USB_RECIP_DEVICE, 0,
					&devstat);
3452
			if (status < 2) {
L
Linus Torvalds 已提交
3453 3454 3455
				dev_dbg(&udev->dev, "get status %d ?\n", status);
				goto loop_disable;
			}
3456
			le16_to_cpus(&devstat);
L
Linus Torvalds 已提交
3457 3458 3459 3460 3461 3462 3463
			if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
				dev_err(&udev->dev,
					"can't connect bus-powered hub "
					"to this port\n");
				if (hub->has_indicators) {
					hub->indicator[port1-1] =
						INDICATOR_AMBER_BLINK;
D
David Howells 已提交
3464
					schedule_delayed_work (&hub->leds, 0);
L
Linus Torvalds 已提交
3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508
				}
				status = -ENOTCONN;	/* Don't retry */
				goto loop_disable;
			}
		}
 
		/* check for devices running slower than they could */
		if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
				&& udev->speed == USB_SPEED_FULL
				&& highspeed_hubs != 0)
			check_highspeed (hub, udev, port1);

		/* Store the parent's children[] pointer.  At this point
		 * udev becomes globally accessible, although presumably
		 * no one will look at it until hdev is unlocked.
		 */
		status = 0;

		/* We mustn't add new devices if the parent hub has
		 * been disconnected; we would race with the
		 * recursively_mark_NOTATTACHED() routine.
		 */
		spin_lock_irq(&device_state_lock);
		if (hdev->state == USB_STATE_NOTATTACHED)
			status = -ENOTCONN;
		else
			hdev->children[port1-1] = udev;
		spin_unlock_irq(&device_state_lock);

		/* Run it through the hoops (find a driver, etc) */
		if (!status) {
			status = usb_new_device(udev);
			if (status) {
				spin_lock_irq(&device_state_lock);
				hdev->children[port1-1] = NULL;
				spin_unlock_irq(&device_state_lock);
			}
		}

		if (status)
			goto loop_disable;

		status = hub_power_remaining(hub);
		if (status)
3509
			dev_dbg(hub_dev, "%dmA power budget left\n", status);
L
Linus Torvalds 已提交
3510 3511 3512 3513 3514 3515

		return;

loop_disable:
		hub_port_disable(hub, port1, 1);
loop:
3516
		usb_ep0_reinit(udev);
3517
		release_devnum(udev);
3518
		hub_free_dev(udev);
L
Linus Torvalds 已提交
3519
		usb_put_dev(udev);
3520
		if ((status == -ENOTCONN) || (status == -ENOTSUPP))
L
Linus Torvalds 已提交
3521 3522
			break;
	}
3523 3524 3525 3526 3527
	if (hub->hdev->parent ||
			!hcd->driver->port_handed_over ||
			!(hcd->driver->port_handed_over)(hcd, port1))
		dev_err(hub_dev, "unable to enumerate USB device on port %d\n",
				port1);
L
Linus Torvalds 已提交
3528 3529 3530
 
done:
	hub_port_disable(hub, port1, 1);
3531 3532
	if (hcd->driver->relinquish_port && !hub->hdev->parent)
		hcd->driver->relinquish_port(hcd, port1);
L
Linus Torvalds 已提交
3533 3534
}

3535 3536
/* Returns 1 if there was a remote wakeup and a connect status change. */
static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
3537
		u16 portstatus, u16 portchange)
3538 3539 3540 3541 3542 3543 3544 3545
{
	struct usb_device *hdev;
	struct usb_device *udev;
	int connect_change = 0;
	int ret;

	hdev = hub->hdev;
	udev = hdev->children[port-1];
3546 3547 3548 3549 3550 3551
	if (!hub_is_superspeed(hdev)) {
		if (!(portchange & USB_PORT_STAT_C_SUSPEND))
			return 0;
		clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
	} else {
		if (!udev || udev->state != USB_STATE_SUSPENDED ||
3552 3553
				 (portstatus & USB_PORT_STAT_LINK_STATE) !=
				 USB_SS_PORT_LS_U0)
3554 3555 3556
			return 0;
	}

3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574
	if (udev) {
		/* TRSMRCY = 10 msec */
		msleep(10);

		usb_lock_device(udev);
		ret = usb_remote_wakeup(udev);
		usb_unlock_device(udev);
		if (ret < 0)
			connect_change = 1;
	} else {
		ret = -ENODEV;
		hub_port_disable(hub, port, 1);
	}
	dev_dbg(hub->intfdev, "resume on port %d, status %d\n",
			port, ret);
	return connect_change;
}

L
Linus Torvalds 已提交
3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586
static void hub_events(void)
{
	struct list_head *tmp;
	struct usb_device *hdev;
	struct usb_interface *intf;
	struct usb_hub *hub;
	struct device *hub_dev;
	u16 hubstatus;
	u16 hubchange;
	u16 portstatus;
	u16 portchange;
	int i, ret;
3587
	int connect_change, wakeup_change;
L
Linus Torvalds 已提交
3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607

	/*
	 *  We restart the list every time to avoid a deadlock with
	 * deleting hubs downstream from this one. This should be
	 * safe since we delete the hub from the event list.
	 * Not the most efficient, but avoids deadlocks.
	 */
	while (1) {

		/* Grab the first entry at the beginning of the list */
		spin_lock_irq(&hub_event_lock);
		if (list_empty(&hub_event_list)) {
			spin_unlock_irq(&hub_event_lock);
			break;
		}

		tmp = hub_event_list.next;
		list_del_init(tmp);

		hub = list_entry(tmp, struct usb_hub, event_list);
3608 3609
		kref_get(&hub->kref);
		spin_unlock_irq(&hub_event_lock);
L
Linus Torvalds 已提交
3610

3611 3612 3613
		hdev = hub->hdev;
		hub_dev = hub->intfdev;
		intf = to_usb_interface(hub_dev);
3614
		dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
L
Linus Torvalds 已提交
3615 3616 3617 3618 3619
				hdev->state, hub->descriptor
					? hub->descriptor->bNbrPorts
					: 0,
				/* NOTE: expects max 15 ports... */
				(u16) hub->change_bits[0],
3620
				(u16) hub->event_bits[0]);
L
Linus Torvalds 已提交
3621 3622 3623

		/* Lock the device, then check to see if we were
		 * disconnected while waiting for the lock to succeed. */
3624
		usb_lock_device(hdev);
3625
		if (unlikely(hub->disconnected))
3626
			goto loop_disconnected;
L
Linus Torvalds 已提交
3627 3628 3629

		/* If the hub has died, clean up after it */
		if (hdev->state == USB_STATE_NOTATTACHED) {
3630
			hub->error = -ENODEV;
3631
			hub_quiesce(hub, HUB_DISCONNECT);
L
Linus Torvalds 已提交
3632 3633 3634
			goto loop;
		}

3635 3636 3637 3638 3639 3640
		/* Autoresume */
		ret = usb_autopm_get_interface(intf);
		if (ret) {
			dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
			goto loop;
		}
3641

3642
		/* If this is an inactive hub, do nothing */
L
Linus Torvalds 已提交
3643
		if (hub->quiescing)
3644
			goto loop_autopm;
L
Linus Torvalds 已提交
3645 3646 3647 3648 3649

		if (hub->error) {
			dev_dbg (hub_dev, "resetting for error %d\n",
				hub->error);

3650
			ret = usb_reset_device(hdev);
L
Linus Torvalds 已提交
3651 3652 3653
			if (ret) {
				dev_dbg (hub_dev,
					"error resetting hub: %d\n", ret);
3654
				goto loop_autopm;
L
Linus Torvalds 已提交
3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665
			}

			hub->nerrors = 0;
			hub->error = 0;
		}

		/* deal with port status changes */
		for (i = 1; i <= hub->descriptor->bNbrPorts; i++) {
			if (test_bit(i, hub->busy_bits))
				continue;
			connect_change = test_bit(i, hub->change_bits);
3666
			wakeup_change = test_and_clear_bit(i, hub->wakeup_bits);
L
Linus Torvalds 已提交
3667
			if (!test_and_clear_bit(i, hub->event_bits) &&
3668
					!connect_change && !wakeup_change)
L
Linus Torvalds 已提交
3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708
				continue;

			ret = hub_port_status(hub, i,
					&portstatus, &portchange);
			if (ret < 0)
				continue;

			if (portchange & USB_PORT_STAT_C_CONNECTION) {
				clear_port_feature(hdev, i,
					USB_PORT_FEAT_C_CONNECTION);
				connect_change = 1;
			}

			if (portchange & USB_PORT_STAT_C_ENABLE) {
				if (!connect_change)
					dev_dbg (hub_dev,
						"port %d enable change, "
						"status %08x\n",
						i, portstatus);
				clear_port_feature(hdev, i,
					USB_PORT_FEAT_C_ENABLE);

				/*
				 * EM interference sometimes causes badly
				 * shielded USB devices to be shutdown by
				 * the hub, this hack enables them again.
				 * Works at least with mouse driver. 
				 */
				if (!(portstatus & USB_PORT_STAT_ENABLE)
				    && !connect_change
				    && hdev->children[i-1]) {
					dev_err (hub_dev,
					    "port %i "
					    "disabled by hub (EMI?), "
					    "re-enabling...\n",
						i);
					connect_change = 1;
				}
			}

3709 3710
			if (hub_handle_remote_wakeup(hub, i,
						portstatus, portchange))
3711
				connect_change = 1;
3712

L
Linus Torvalds 已提交
3713
			if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
3714 3715 3716 3717 3718
				u16 status = 0;
				u16 unused;

				dev_dbg(hub_dev, "over-current change on port "
					"%d\n", i);
L
Linus Torvalds 已提交
3719 3720
				clear_port_feature(hdev, i,
					USB_PORT_FEAT_C_OVER_CURRENT);
3721
				msleep(100);	/* Cool down */
3722
				hub_power_on(hub, true);
3723 3724 3725 3726
				hub_port_status(hub, i, &status, &unused);
				if (status & USB_PORT_STAT_OVERCURRENT)
					dev_err(hub_dev, "over-current "
						"condition on port %d\n", i);
L
Linus Torvalds 已提交
3727 3728 3729 3730 3731 3732 3733 3734 3735
			}

			if (portchange & USB_PORT_STAT_C_RESET) {
				dev_dbg (hub_dev,
					"reset change on port %d\n",
					i);
				clear_port_feature(hdev, i,
					USB_PORT_FEAT_C_RESET);
			}
3736 3737 3738 3739 3740 3741 3742 3743
			if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
					hub_is_superspeed(hub->hdev)) {
				dev_dbg(hub_dev,
					"warm reset change on port %d\n",
					i);
				clear_port_feature(hdev, i,
					USB_PORT_FEAT_C_BH_PORT_RESET);
			}
J
John Youn 已提交
3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754
			if (portchange & USB_PORT_STAT_C_LINK_STATE) {
				clear_port_feature(hub->hdev, i,
						USB_PORT_FEAT_C_PORT_LINK_STATE);
			}
			if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
				dev_warn(hub_dev,
					"config error on port %d\n",
					i);
				clear_port_feature(hub->hdev, i,
						USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
			}
L
Linus Torvalds 已提交
3755

3756 3757 3758 3759 3760 3761 3762
			/* Warm reset a USB3 protocol port if it's in
			 * SS.Inactive state.
			 */
			if (hub_is_superspeed(hub->hdev) &&
				(portstatus & USB_PORT_STAT_LINK_STATE)
					== USB_SS_PORT_LS_SS_INACTIVE) {
				dev_dbg(hub_dev, "warm reset port %d\n", i);
A
Andiry Xu 已提交
3763 3764
				hub_port_reset(hub, i, NULL,
						HUB_BH_RESET_TIME, true);
3765 3766
			}

L
Linus Torvalds 已提交
3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780
			if (connect_change)
				hub_port_connect_change(hub, i,
						portstatus, portchange);
		} /* end for i */

		/* deal with hub status changes */
		if (test_and_clear_bit(0, hub->event_bits) == 0)
			;	/* do nothing */
		else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
			dev_err (hub_dev, "get_hub_status failed\n");
		else {
			if (hubchange & HUB_CHANGE_LOCAL_POWER) {
				dev_dbg (hub_dev, "power change\n");
				clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
3781 3782 3783
				if (hubstatus & HUB_STATUS_LOCAL_POWER)
					/* FIXME: Is this always true? */
					hub->limited_power = 1;
3784 3785
				else
					hub->limited_power = 0;
L
Linus Torvalds 已提交
3786 3787
			}
			if (hubchange & HUB_CHANGE_OVERCURRENT) {
3788 3789 3790 3791
				u16 status = 0;
				u16 unused;

				dev_dbg(hub_dev, "over-current change\n");
L
Linus Torvalds 已提交
3792
				clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
3793
				msleep(500);	/* Cool down */
3794
                        	hub_power_on(hub, true);
3795 3796 3797 3798
				hub_hub_status(hub, &status, &unused);
				if (status & HUB_STATUS_OVERCURRENT)
					dev_err(hub_dev, "over-current "
						"condition\n");
L
Linus Torvalds 已提交
3799 3800 3801
			}
		}

3802 3803 3804 3805 3806 3807 3808 3809
 loop_autopm:
		/* Balance the usb_autopm_get_interface() above */
		usb_autopm_put_interface_no_suspend(intf);
 loop:
		/* Balance the usb_autopm_get_interface_no_resume() in
		 * kick_khubd() and allow autosuspend.
		 */
		usb_autopm_put_interface(intf);
3810
 loop_disconnected:
L
Linus Torvalds 已提交
3811
		usb_unlock_device(hdev);
3812
		kref_put(&hub->kref, hub_release);
L
Linus Torvalds 已提交
3813 3814 3815 3816 3817 3818

        } /* end while (1) */
}

static int hub_thread(void *__unused)
{
3819 3820 3821 3822 3823
	/* khubd needs to be freezable to avoid intefering with USB-PERSIST
	 * port handover.  Otherwise it might see that a full-speed device
	 * was gone before the EHCI controller had handed its port over to
	 * the companion full-speed controller.
	 */
3824
	set_freezable();
3825

L
Linus Torvalds 已提交
3826 3827
	do {
		hub_events();
3828
		wait_event_freezable(khubd_wait,
3829 3830 3831
				!list_empty(&hub_event_list) ||
				kthread_should_stop());
	} while (!kthread_should_stop() || !list_empty(&hub_event_list));
L
Linus Torvalds 已提交
3832

3833 3834
	pr_debug("%s: khubd exiting\n", usbcore_name);
	return 0;
L
Linus Torvalds 已提交
3835 3836
}

3837
static const struct usb_device_id hub_id_table[] = {
L
Linus Torvalds 已提交
3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852
    { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
      .bDeviceClass = USB_CLASS_HUB},
    { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
      .bInterfaceClass = USB_CLASS_HUB},
    { }						/* Terminating entry */
};

MODULE_DEVICE_TABLE (usb, hub_id_table);

static struct usb_driver hub_driver = {
	.name =		"hub",
	.probe =	hub_probe,
	.disconnect =	hub_disconnect,
	.suspend =	hub_suspend,
	.resume =	hub_resume,
A
Alan Stern 已提交
3853
	.reset_resume =	hub_reset_resume,
3854 3855
	.pre_reset =	hub_pre_reset,
	.post_reset =	hub_post_reset,
3856
	.unlocked_ioctl = hub_ioctl,
L
Linus Torvalds 已提交
3857
	.id_table =	hub_id_table,
3858
	.supports_autosuspend =	1,
L
Linus Torvalds 已提交
3859 3860 3861 3862 3863 3864 3865 3866 3867 3868
};

int usb_hub_init(void)
{
	if (usb_register(&hub_driver) < 0) {
		printk(KERN_ERR "%s: can't register hub driver\n",
			usbcore_name);
		return -1;
	}

3869 3870
	khubd_task = kthread_run(hub_thread, NULL, "khubd");
	if (!IS_ERR(khubd_task))
L
Linus Torvalds 已提交
3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881
		return 0;

	/* Fall through if kernel_thread failed */
	usb_deregister(&hub_driver);
	printk(KERN_ERR "%s: can't start khubd\n", usbcore_name);

	return -1;
}

void usb_hub_cleanup(void)
{
3882
	kthread_stop(khubd_task);
L
Linus Torvalds 已提交
3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893

	/*
	 * Hub resources are freed for us by usb_deregister. It calls
	 * usb_driver_purge on every device which in turn calls that
	 * devices disconnect function if it is using this driver.
	 * The hub_disconnect function takes care of releasing the
	 * individual hub resources. -greg
	 */
	usb_deregister(&hub_driver);
} /* usb_hub_cleanup() */

3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916
static int descriptors_changed(struct usb_device *udev,
		struct usb_device_descriptor *old_device_descriptor)
{
	int		changed = 0;
	unsigned	index;
	unsigned	serial_len = 0;
	unsigned	len;
	unsigned	old_length;
	int		length;
	char		*buf;

	if (memcmp(&udev->descriptor, old_device_descriptor,
			sizeof(*old_device_descriptor)) != 0)
		return 1;

	/* Since the idVendor, idProduct, and bcdDevice values in the
	 * device descriptor haven't changed, we will assume the
	 * Manufacturer and Product strings haven't changed either.
	 * But the SerialNumber string could be different (e.g., a
	 * different flash card of the same brand).
	 */
	if (udev->serial)
		serial_len = strlen(udev->serial) + 1;
L
Linus Torvalds 已提交
3917

3918
	len = serial_len;
L
Linus Torvalds 已提交
3919
	for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
3920 3921
		old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
		len = max(len, old_length);
L
Linus Torvalds 已提交
3922
	}
3923

O
Oliver Neukum 已提交
3924
	buf = kmalloc(len, GFP_NOIO);
L
Linus Torvalds 已提交
3925 3926 3927 3928 3929 3930
	if (buf == NULL) {
		dev_err(&udev->dev, "no mem to re-read configs after reset\n");
		/* assume the worst */
		return 1;
	}
	for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
3931
		old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
L
Linus Torvalds 已提交
3932 3933
		length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
				old_length);
3934
		if (length != old_length) {
L
Linus Torvalds 已提交
3935 3936
			dev_dbg(&udev->dev, "config index %d, error %d\n",
					index, length);
3937
			changed = 1;
L
Linus Torvalds 已提交
3938 3939 3940 3941 3942
			break;
		}
		if (memcmp (buf, udev->rawdescriptors[index], old_length)
				!= 0) {
			dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
3943 3944 3945 3946
				index,
				((struct usb_config_descriptor *) buf)->
					bConfigurationValue);
			changed = 1;
L
Linus Torvalds 已提交
3947 3948 3949
			break;
		}
	}
3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963

	if (!changed && serial_len) {
		length = usb_string(udev, udev->descriptor.iSerialNumber,
				buf, serial_len);
		if (length + 1 != serial_len) {
			dev_dbg(&udev->dev, "serial string error %d\n",
					length);
			changed = 1;
		} else if (memcmp(buf, udev->serial, length) != 0) {
			dev_dbg(&udev->dev, "serial string changed\n");
			changed = 1;
		}
	}

L
Linus Torvalds 已提交
3964
	kfree(buf);
3965
	return changed;
L
Linus Torvalds 已提交
3966 3967 3968
}

/**
3969
 * usb_reset_and_verify_device - perform a USB port reset to reinitialize a device
L
Linus Torvalds 已提交
3970 3971
 * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
 *
3972 3973
 * WARNING - don't use this routine to reset a composite device
 * (one with multiple interfaces owned by separate drivers)!
3974
 * Use usb_reset_device() instead.
L
Linus Torvalds 已提交
3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991
 *
 * Do a port reset, reassign the device's address, and establish its
 * former operating configuration.  If the reset fails, or the device's
 * descriptors change from their values before the reset, or the original
 * configuration and altsettings cannot be restored, a flag will be set
 * telling khubd to pretend the device has been disconnected and then
 * re-connected.  All drivers will be unbound, and the device will be
 * re-enumerated and probed all over again.
 *
 * Returns 0 if the reset succeeded, -ENODEV if the device has been
 * flagged for logical disconnection, or some other negative error code
 * if the reset wasn't even attempted.
 *
 * The caller must own the device lock.  For example, it's safe to use
 * this from a driver probe() routine after downloading new firmware.
 * For calls that might not occur during probe(), drivers should lock
 * the device using usb_lock_device_for_reset().
A
Alan Stern 已提交
3992 3993 3994 3995 3996
 *
 * Locking exception: This routine may also be called from within an
 * autoresume handler.  Such usage won't conflict with other tasks
 * holding the device lock because these tasks should always call
 * usb_autopm_resume_device(), thereby preventing any unwanted autoresume.
L
Linus Torvalds 已提交
3997
 */
3998
static int usb_reset_and_verify_device(struct usb_device *udev)
L
Linus Torvalds 已提交
3999 4000 4001
{
	struct usb_device		*parent_hdev = udev->parent;
	struct usb_hub			*parent_hub;
4002
	struct usb_hcd			*hcd = bus_to_hcd(udev->bus);
L
Linus Torvalds 已提交
4003
	struct usb_device_descriptor	descriptor = udev->descriptor;
4004 4005
	int 				i, ret = 0;
	int				port1 = udev->portnum;
L
Linus Torvalds 已提交
4006 4007 4008 4009 4010 4011 4012 4013 4014

	if (udev->state == USB_STATE_NOTATTACHED ||
			udev->state == USB_STATE_SUSPENDED) {
		dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
				udev->state);
		return -EINVAL;
	}

	if (!parent_hdev) {
4015
		/* this requires hcd-specific logic; see ohci_restart() */
4016
		dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
L
Linus Torvalds 已提交
4017 4018 4019 4020 4021 4022 4023 4024 4025
		return -EISDIR;
	}
	parent_hub = hdev_to_hub(parent_hdev);

	set_bit(port1, parent_hub->busy_bits);
	for (i = 0; i < SET_CONFIG_TRIES; ++i) {

		/* ep0 maxpacket size may change; let the HCD know about it.
		 * Other endpoints will be handled by re-enumeration. */
4026
		usb_ep0_reinit(udev);
L
Linus Torvalds 已提交
4027
		ret = hub_port_init(parent_hub, udev, port1, i);
4028
		if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
L
Linus Torvalds 已提交
4029 4030 4031
			break;
	}
	clear_bit(port1, parent_hub->busy_bits);
4032

L
Linus Torvalds 已提交
4033 4034 4035 4036
	if (ret < 0)
		goto re_enumerate;
 
	/* Device might have changed firmware (DFU or similar) */
4037
	if (descriptors_changed(udev, &descriptor)) {
L
Linus Torvalds 已提交
4038 4039 4040 4041
		dev_info(&udev->dev, "device firmware changed\n");
		udev->descriptor = descriptor;	/* for disconnect() calls */
		goto re_enumerate;
  	}
4042 4043

	/* Restore the device's previous configuration */
L
Linus Torvalds 已提交
4044 4045
	if (!udev->actconfig)
		goto done;
4046

4047
	mutex_lock(hcd->bandwidth_mutex);
4048 4049 4050 4051 4052
	ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL);
	if (ret < 0) {
		dev_warn(&udev->dev,
				"Busted HC?  Not enough HCD resources for "
				"old configuration.\n");
4053
		mutex_unlock(hcd->bandwidth_mutex);
4054 4055
		goto re_enumerate;
	}
L
Linus Torvalds 已提交
4056 4057 4058 4059 4060 4061 4062 4063
	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
			USB_REQ_SET_CONFIGURATION, 0,
			udev->actconfig->desc.bConfigurationValue, 0,
			NULL, 0, USB_CTRL_SET_TIMEOUT);
	if (ret < 0) {
		dev_err(&udev->dev,
			"can't restore configuration #%d (error=%d)\n",
			udev->actconfig->desc.bConfigurationValue, ret);
4064
		mutex_unlock(hcd->bandwidth_mutex);
L
Linus Torvalds 已提交
4065 4066
		goto re_enumerate;
  	}
4067
	mutex_unlock(hcd->bandwidth_mutex);
L
Linus Torvalds 已提交
4068 4069
	usb_set_device_state(udev, USB_STATE_CONFIGURED);

4070 4071 4072 4073 4074 4075
	/* Put interfaces back into the same altsettings as before.
	 * Don't bother to send the Set-Interface request for interfaces
	 * that were already in altsetting 0; besides being unnecessary,
	 * many devices can't handle it.  Instead just reset the host-side
	 * endpoint state.
	 */
L
Linus Torvalds 已提交
4076
	for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
4077 4078
		struct usb_host_config *config = udev->actconfig;
		struct usb_interface *intf = config->interface[i];
L
Linus Torvalds 已提交
4079 4080 4081
		struct usb_interface_descriptor *desc;

		desc = &intf->cur_altsetting->desc;
4082 4083 4084 4085 4086
		if (desc->bAlternateSetting == 0) {
			usb_disable_interface(udev, intf, true);
			usb_enable_interface(udev, intf, true);
			ret = 0;
		} else {
4087 4088 4089
			/* Let the bandwidth allocation function know that this
			 * device has been reset, and it will have to use
			 * alternate setting 0 as the current alternate setting.
4090
			 */
4091
			intf->resetting_device = 1;
4092 4093
			ret = usb_set_interface(udev, desc->bInterfaceNumber,
					desc->bAlternateSetting);
4094
			intf->resetting_device = 0;
4095
		}
L
Linus Torvalds 已提交
4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112
		if (ret < 0) {
			dev_err(&udev->dev, "failed to restore interface %d "
				"altsetting %d (error=%d)\n",
				desc->bInterfaceNumber,
				desc->bAlternateSetting,
				ret);
			goto re_enumerate;
		}
	}

done:
	return 0;
 
re_enumerate:
	hub_port_logical_disconnect(parent_hub, port1);
	return -ENODEV;
}
4113 4114

/**
4115
 * usb_reset_device - warn interface drivers and perform a USB port reset
4116 4117 4118 4119 4120 4121
 * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
 *
 * Warns all drivers bound to registered interfaces (using their pre_reset
 * method), performs the port reset, and then lets the drivers know that
 * the reset is over (using their post_reset method).
 *
4122
 * Return value is the same as for usb_reset_and_verify_device().
4123 4124 4125 4126 4127
 *
 * The caller must own the device lock.  For example, it's safe to use
 * this from a driver probe() routine after downloading new firmware.
 * For calls that might not occur during probe(), drivers should lock
 * the device using usb_lock_device_for_reset().
4128 4129 4130 4131 4132
 *
 * If an interface is currently being probed or disconnected, we assume
 * its driver knows how to handle resets.  For all other interfaces,
 * if the driver doesn't have pre_reset and post_reset methods then
 * we attempt to unbind it and rebind afterward.
4133
 */
4134
int usb_reset_device(struct usb_device *udev)
4135 4136
{
	int ret;
4137
	int i;
4138 4139 4140 4141 4142 4143 4144 4145 4146
	struct usb_host_config *config = udev->actconfig;

	if (udev->state == USB_STATE_NOTATTACHED ||
			udev->state == USB_STATE_SUSPENDED) {
		dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
				udev->state);
		return -EINVAL;
	}

4147
	/* Prevent autosuspend during the reset */
4148
	usb_autoresume_device(udev);
4149

4150 4151
	if (config) {
		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
4152 4153
			struct usb_interface *cintf = config->interface[i];
			struct usb_driver *drv;
4154
			int unbind = 0;
4155 4156

			if (cintf->dev.driver) {
4157
				drv = to_usb_driver(cintf->dev.driver);
4158 4159 4160 4161 4162 4163 4164
				if (drv->pre_reset && drv->post_reset)
					unbind = (drv->pre_reset)(cintf);
				else if (cintf->condition ==
						USB_INTERFACE_BOUND)
					unbind = 1;
				if (unbind)
					usb_forced_unbind_intf(cintf);
4165 4166 4167 4168
			}
		}
	}

4169
	ret = usb_reset_and_verify_device(udev);
4170 4171 4172

	if (config) {
		for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
4173 4174
			struct usb_interface *cintf = config->interface[i];
			struct usb_driver *drv;
4175
			int rebind = cintf->needs_binding;
4176

4177
			if (!rebind && cintf->dev.driver) {
4178 4179
				drv = to_usb_driver(cintf->dev.driver);
				if (drv->post_reset)
4180 4181 4182 4183
					rebind = (drv->post_reset)(cintf);
				else if (cintf->condition ==
						USB_INTERFACE_BOUND)
					rebind = 1;
4184
			}
4185
			if (ret == 0 && rebind)
4186
				usb_rebind_intf(cintf);
4187 4188 4189
		}
	}

4190
	usb_autosuspend_device(udev);
4191 4192
	return ret;
}
4193
EXPORT_SYMBOL_GPL(usb_reset_device);
4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236


/**
 * usb_queue_reset_device - Reset a USB device from an atomic context
 * @iface: USB interface belonging to the device to reset
 *
 * This function can be used to reset a USB device from an atomic
 * context, where usb_reset_device() won't work (as it blocks).
 *
 * Doing a reset via this method is functionally equivalent to calling
 * usb_reset_device(), except for the fact that it is delayed to a
 * workqueue. This means that any drivers bound to other interfaces
 * might be unbound, as well as users from usbfs in user space.
 *
 * Corner cases:
 *
 * - Scheduling two resets at the same time from two different drivers
 *   attached to two different interfaces of the same device is
 *   possible; depending on how the driver attached to each interface
 *   handles ->pre_reset(), the second reset might happen or not.
 *
 * - If a driver is unbound and it had a pending reset, the reset will
 *   be cancelled.
 *
 * - This function can be called during .probe() or .disconnect()
 *   times. On return from .disconnect(), any pending resets will be
 *   cancelled.
 *
 * There is no no need to lock/unlock the @reset_ws as schedule_work()
 * does its own.
 *
 * NOTE: We don't do any reference count tracking because it is not
 *     needed. The lifecycle of the work_struct is tied to the
 *     usb_interface. Before destroying the interface we cancel the
 *     work_struct, so the fact that work_struct is queued and or
 *     running means the interface (and thus, the device) exist and
 *     are referenced.
 */
void usb_queue_reset_device(struct usb_interface *iface)
{
	schedule_work(&iface->reset_ws);
}
EXPORT_SYMBOL_GPL(usb_queue_reset_device);