uhci               43 drivers/usb/host/uhci-debug.c static int uhci_show_td(struct uhci_hcd *uhci, struct uhci_td *td, char *buf,
uhci               50 drivers/usb/host/uhci-debug.c 	status = td_status(uhci, td);
uhci               52 drivers/usb/host/uhci-debug.c 		hc32_to_cpu(uhci, td->link));
uhci               69 drivers/usb/host/uhci-debug.c 	token = td_token(uhci, td);
uhci               92 drivers/usb/host/uhci-debug.c 	out += sprintf(out, "(buf=%08x)\n", hc32_to_cpu(uhci, td->buffer));
uhci              100 drivers/usb/host/uhci-debug.c static int uhci_show_urbp(struct uhci_hcd *uhci, struct urb_priv *urbp,
uhci              143 drivers/usb/host/uhci-debug.c 			out += uhci_show_td(uhci, td, out,
uhci              148 drivers/usb/host/uhci-debug.c 			if (td_status(uhci, td) & TD_CTRL_ACTIVE)
uhci              165 drivers/usb/host/uhci-debug.c static int uhci_show_qh(struct uhci_hcd *uhci,
uhci              183 drivers/usb/host/uhci-debug.c 			hc32_to_cpu(uhci, qh->link),
uhci              184 drivers/usb/host/uhci-debug.c 			hc32_to_cpu(uhci, element));
uhci              196 drivers/usb/host/uhci-debug.c 	if (element & UHCI_PTR_QH(uhci))
uhci              199 drivers/usb/host/uhci-debug.c 	if (element & UHCI_PTR_DEPTH(uhci))
uhci              202 drivers/usb/host/uhci-debug.c 	if (element & cpu_to_hc32(uhci, 8))
uhci              205 drivers/usb/host/uhci-debug.c 	if (!(element & ~(UHCI_PTR_QH(uhci) | UHCI_PTR_DEPTH(uhci))))
uhci              213 drivers/usb/host/uhci-debug.c 		if (qh == uhci->skel_async_qh) {
uhci              214 drivers/usb/host/uhci-debug.c 			out += uhci_show_td(uhci, uhci->term_td, out,
uhci              225 drivers/usb/host/uhci-debug.c 		if (element != LINK_TO_TD(uhci, td))
uhci              231 drivers/usb/host/uhci-debug.c 				out += uhci_show_urbp(uhci, urbp, out,
uhci              249 drivers/usb/host/uhci-debug.c 		out += uhci_show_td(uhci, qh->dummy_td, out,
uhci              279 drivers/usb/host/uhci-debug.c static int uhci_show_root_hub_state(struct uhci_hcd *uhci, char *buf)
uhci              283 drivers/usb/host/uhci-debug.c 	switch (uhci->rh_state) {
uhci              302 drivers/usb/host/uhci-debug.c 			rh_state, uhci->fsbr_is_on);
uhci              305 drivers/usb/host/uhci-debug.c static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
uhci              314 drivers/usb/host/uhci-debug.c 	usbcmd    = uhci_readw(uhci, USBCMD);
uhci              315 drivers/usb/host/uhci-debug.c 	usbstat   = uhci_readw(uhci, USBSTS);
uhci              316 drivers/usb/host/uhci-debug.c 	usbint    = uhci_readw(uhci, USBINTR);
uhci              317 drivers/usb/host/uhci-debug.c 	usbfrnum  = uhci_readw(uhci, USBFRNUM);
uhci              318 drivers/usb/host/uhci-debug.c 	flbaseadd = uhci_readl(uhci, USBFLBASEADD);
uhci              319 drivers/usb/host/uhci-debug.c 	sof       = uhci_readb(uhci, USBSOF);
uhci              320 drivers/usb/host/uhci-debug.c 	portsc1   = uhci_readw(uhci, USBPORTSC1);
uhci              321 drivers/usb/host/uhci-debug.c 	portsc2   = uhci_readw(uhci, USBPORTSC2);
uhci              365 drivers/usb/host/uhci-debug.c 			uhci->frame_number, uhci->frame_number & 1023,
uhci              366 drivers/usb/host/uhci-debug.c 			uhci->last_iso_frame, uhci->last_iso_frame & 1023);
uhci              374 drivers/usb/host/uhci-debug.c static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
uhci              390 drivers/usb/host/uhci-debug.c 	out += uhci_show_root_hub_state(uhci, out);
uhci              394 drivers/usb/host/uhci-debug.c 	out += uhci_show_status(uhci, out, len - (out - buf));
uhci              400 drivers/usb/host/uhci-debug.c 		out += sprintf(out, "\t%d", uhci->load[i]);
uhci              405 drivers/usb/host/uhci-debug.c 			uhci->total_load,
uhci              406 drivers/usb/host/uhci-debug.c 			uhci_to_hcd(uhci)->self.bandwidth_int_reqs,
uhci              407 drivers/usb/host/uhci-debug.c 			uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs);
uhci              420 drivers/usb/host/uhci-debug.c 		td = uhci->frame_cpu[i];
uhci              421 drivers/usb/host/uhci-debug.c 		link = uhci->frame[i];
uhci              427 drivers/usb/host/uhci-debug.c 					i, hc32_to_cpu(uhci, link));
uhci              436 drivers/usb/host/uhci-debug.c 			if (link != LINK_TO_TD(uhci, td)) {
uhci              446 drivers/usb/host/uhci-debug.c 				out += uhci_show_td(uhci, td, out,
uhci              455 drivers/usb/host/uhci-debug.c 		qh_dma = uhci_frame_skel_link(uhci, i);
uhci              461 drivers/usb/host/uhci-debug.c 						i, hc32_to_cpu(uhci, link));
uhci              466 drivers/usb/host/uhci-debug.c 					hc32_to_cpu(uhci, qh_dma));
uhci              486 drivers/usb/host/uhci-debug.c 		qh = uhci->skelqh[i];
uhci              488 drivers/usb/host/uhci-debug.c 		out += uhci_show_qh(uhci, qh, out, len - (out - buf), 4);
uhci              494 drivers/usb/host/uhci-debug.c 			if (qh_element(qh) != LINK_TO_TD(uhci, uhci->term_td)) {
uhci              502 drivers/usb/host/uhci-debug.c 				link = LINK_TO_QH(uhci, uhci->skel_term_qh);
uhci              513 drivers/usb/host/uhci-debug.c 				out += uhci_show_qh(uhci, qh, out,
uhci              519 drivers/usb/host/uhci-debug.c 				fsbr_link = LINK_TO_QH(uhci, qh);
uhci              524 drivers/usb/host/uhci-debug.c 		link = UHCI_PTR_TERM(uhci);
uhci              528 drivers/usb/host/uhci-debug.c 			link = LINK_TO_QH(uhci, uhci->skel_async_qh);
uhci              529 drivers/usb/host/uhci-debug.c 		else if (!uhci->fsbr_is_on)
uhci              532 drivers/usb/host/uhci-debug.c 			link = LINK_TO_QH(uhci, uhci->skel_term_qh);
uhci              560 drivers/usb/host/uhci-debug.c 	struct uhci_hcd *uhci = inode->i_private;
uhci              575 drivers/usb/host/uhci-debug.c 	spin_lock_irqsave(&uhci->lock, flags);
uhci              576 drivers/usb/host/uhci-debug.c 	if (uhci->is_initialized)
uhci              577 drivers/usb/host/uhci-debug.c 		up->size = uhci_sprint_schedule(uhci, up->data,
uhci              579 drivers/usb/host/uhci-debug.c 	spin_unlock_irqrestore(&uhci->lock, flags);
uhci              625 drivers/usb/host/uhci-debug.c static inline int uhci_show_qh(struct uhci_hcd *uhci,
uhci              631 drivers/usb/host/uhci-debug.c static inline int uhci_sprint_schedule(struct uhci_hcd *uhci,
uhci               28 drivers/usb/host/uhci-grlib.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci               39 drivers/usb/host/uhci-grlib.c 	if (!(uhci_readw(uhci, USBPORTSC1) & 0x80)) {
uhci               40 drivers/usb/host/uhci-grlib.c 		uhci->big_endian_mmio = 1;
uhci               41 drivers/usb/host/uhci-grlib.c 		uhci->big_endian_desc = 1;
uhci               44 drivers/usb/host/uhci-grlib.c 	uhci->rh_numports = uhci_count_ports(hcd);
uhci               47 drivers/usb/host/uhci-grlib.c 	uhci->reset_hc = uhci_generic_reset_hc;
uhci               48 drivers/usb/host/uhci-grlib.c 	uhci->check_and_reset_hc = uhci_generic_check_and_reset_hc;
uhci               50 drivers/usb/host/uhci-grlib.c 	uhci->configure_hc = NULL;
uhci               51 drivers/usb/host/uhci-grlib.c 	uhci->resume_detect_interrupts_are_broken = NULL;
uhci               52 drivers/usb/host/uhci-grlib.c 	uhci->global_suspend_mode_is_broken = NULL;
uhci               55 drivers/usb/host/uhci-grlib.c 	check_and_reset_hc(uhci);
uhci               94 drivers/usb/host/uhci-grlib.c 	struct uhci_hcd	*uhci = NULL;
uhci              131 drivers/usb/host/uhci-grlib.c 	uhci = hcd_to_uhci(hcd);
uhci              133 drivers/usb/host/uhci-grlib.c 	uhci->regs = hcd->regs;
uhci               92 drivers/usb/host/uhci-hcd.c static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state);
uhci               93 drivers/usb/host/uhci-hcd.c static void wakeup_rh(struct uhci_hcd *uhci);
uhci               94 drivers/usb/host/uhci-hcd.c static void uhci_get_current_frame_number(struct uhci_hcd *uhci);
uhci               99 drivers/usb/host/uhci-hcd.c static __hc32 uhci_frame_skel_link(struct uhci_hcd *uhci, int frame)
uhci              121 drivers/usb/host/uhci-hcd.c 	return LINK_TO_QH(uhci, uhci->skelqh[skelnum]);
uhci              131 drivers/usb/host/uhci-hcd.c static void finish_reset(struct uhci_hcd *uhci)
uhci              139 drivers/usb/host/uhci-hcd.c 	for (port = 0; port < uhci->rh_numports; ++port)
uhci              140 drivers/usb/host/uhci-hcd.c 		uhci_writew(uhci, 0, USBPORTSC1 + (port * 2));
uhci              142 drivers/usb/host/uhci-hcd.c 	uhci->port_c_suspend = uhci->resuming_ports = 0;
uhci              143 drivers/usb/host/uhci-hcd.c 	uhci->rh_state = UHCI_RH_RESET;
uhci              144 drivers/usb/host/uhci-hcd.c 	uhci->is_stopped = UHCI_IS_STOPPED;
uhci              145 drivers/usb/host/uhci-hcd.c 	clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
uhci              152 drivers/usb/host/uhci-hcd.c static void uhci_hc_died(struct uhci_hcd *uhci)
uhci              154 drivers/usb/host/uhci-hcd.c 	uhci_get_current_frame_number(uhci);
uhci              155 drivers/usb/host/uhci-hcd.c 	uhci->reset_hc(uhci);
uhci              156 drivers/usb/host/uhci-hcd.c 	finish_reset(uhci);
uhci              157 drivers/usb/host/uhci-hcd.c 	uhci->dead = 1;
uhci              160 drivers/usb/host/uhci-hcd.c 	++uhci->frame_number;
uhci              168 drivers/usb/host/uhci-hcd.c static void check_and_reset_hc(struct uhci_hcd *uhci)
uhci              170 drivers/usb/host/uhci-hcd.c 	if (uhci->check_and_reset_hc(uhci))
uhci              171 drivers/usb/host/uhci-hcd.c 		finish_reset(uhci);
uhci              185 drivers/usb/host/uhci-hcd.c static void uhci_generic_reset_hc(struct uhci_hcd *uhci)
uhci              192 drivers/usb/host/uhci-hcd.c 	uhci_writew(uhci, USBCMD_HCRESET, USBCMD);
uhci              195 drivers/usb/host/uhci-hcd.c 	if (uhci_readw(uhci, USBCMD) & USBCMD_HCRESET)
uhci              196 drivers/usb/host/uhci-hcd.c 		dev_warn(uhci_dev(uhci), "HCRESET not completed yet!\n");
uhci              201 drivers/usb/host/uhci-hcd.c 	uhci_writew(uhci, 0, USBINTR);
uhci              202 drivers/usb/host/uhci-hcd.c 	uhci_writew(uhci, 0, USBCMD);
uhci              211 drivers/usb/host/uhci-hcd.c static int uhci_generic_check_and_reset_hc(struct uhci_hcd *uhci)
uhci              225 drivers/usb/host/uhci-hcd.c 	cmd = uhci_readw(uhci, USBCMD);
uhci              227 drivers/usb/host/uhci-hcd.c 		dev_dbg(uhci_dev(uhci), "%s: cmd = 0x%04x\n",
uhci              232 drivers/usb/host/uhci-hcd.c 	intr = uhci_readw(uhci, USBINTR);
uhci              234 drivers/usb/host/uhci-hcd.c 		dev_dbg(uhci_dev(uhci), "%s: intr = 0x%04x\n",
uhci              241 drivers/usb/host/uhci-hcd.c 	dev_dbg(uhci_dev(uhci), "Performing full reset\n");
uhci              242 drivers/usb/host/uhci-hcd.c 	uhci_generic_reset_hc(uhci);
uhci              250 drivers/usb/host/uhci-hcd.c static void configure_hc(struct uhci_hcd *uhci)
uhci              253 drivers/usb/host/uhci-hcd.c 	uhci_writeb(uhci, USBSOF_DEFAULT, USBSOF);
uhci              256 drivers/usb/host/uhci-hcd.c 	uhci_writel(uhci, uhci->frame_dma_handle, USBFLBASEADD);
uhci              259 drivers/usb/host/uhci-hcd.c 	uhci_writew(uhci, uhci->frame_number & UHCI_MAX_SOF_NUMBER,
uhci              263 drivers/usb/host/uhci-hcd.c 	if (uhci->configure_hc)
uhci              264 drivers/usb/host/uhci-hcd.c 		uhci->configure_hc(uhci);
uhci              267 drivers/usb/host/uhci-hcd.c static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
uhci              275 drivers/usb/host/uhci-hcd.c 	if (ignore_oc || uhci_is_aspeed(uhci))
uhci              278 drivers/usb/host/uhci-hcd.c 	return uhci->resume_detect_interrupts_are_broken ?
uhci              279 drivers/usb/host/uhci-hcd.c 		uhci->resume_detect_interrupts_are_broken(uhci) : 0;
uhci              282 drivers/usb/host/uhci-hcd.c static int global_suspend_mode_is_broken(struct uhci_hcd *uhci)
uhci              284 drivers/usb/host/uhci-hcd.c 	return uhci->global_suspend_mode_is_broken ?
uhci              285 drivers/usb/host/uhci-hcd.c 		uhci->global_suspend_mode_is_broken(uhci) : 0;
uhci              288 drivers/usb/host/uhci-hcd.c static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state)
uhci              289 drivers/usb/host/uhci-hcd.c __releases(uhci->lock)
uhci              290 drivers/usb/host/uhci-hcd.c __acquires(uhci->lock)
uhci              294 drivers/usb/host/uhci-hcd.c 	struct usb_device *rhdev = uhci_to_hcd(uhci)->self.root_hub;
uhci              343 drivers/usb/host/uhci-hcd.c 	if (!wakeup_enable || global_suspend_mode_is_broken(uhci) ||
uhci              344 drivers/usb/host/uhci-hcd.c 			resume_detect_interrupts_are_broken(uhci))
uhci              347 drivers/usb/host/uhci-hcd.c 	uhci->RD_enable = !!int_enable;
uhci              348 drivers/usb/host/uhci-hcd.c 	uhci_writew(uhci, int_enable, USBINTR);
uhci              349 drivers/usb/host/uhci-hcd.c 	uhci_writew(uhci, egsm_enable | USBCMD_CF, USBCMD);
uhci              358 drivers/usb/host/uhci-hcd.c 	if (!auto_stop && !(uhci_readw(uhci, USBSTS) & USBSTS_HCH)) {
uhci              359 drivers/usb/host/uhci-hcd.c 		uhci->rh_state = UHCI_RH_SUSPENDING;
uhci              360 drivers/usb/host/uhci-hcd.c 		spin_unlock_irq(&uhci->lock);
uhci              362 drivers/usb/host/uhci-hcd.c 		spin_lock_irq(&uhci->lock);
uhci              363 drivers/usb/host/uhci-hcd.c 		if (uhci->dead)
uhci              366 drivers/usb/host/uhci-hcd.c 	if (!(uhci_readw(uhci, USBSTS) & USBSTS_HCH))
uhci              367 drivers/usb/host/uhci-hcd.c 		dev_warn(uhci_dev(uhci), "Controller not stopped yet!\n");
uhci              369 drivers/usb/host/uhci-hcd.c 	uhci_get_current_frame_number(uhci);
uhci              371 drivers/usb/host/uhci-hcd.c 	uhci->rh_state = new_state;
uhci              372 drivers/usb/host/uhci-hcd.c 	uhci->is_stopped = UHCI_IS_STOPPED;
uhci              380 drivers/usb/host/uhci-hcd.c 		set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
uhci              382 drivers/usb/host/uhci-hcd.c 		clear_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
uhci              384 drivers/usb/host/uhci-hcd.c 	uhci_scan_schedule(uhci);
uhci              385 drivers/usb/host/uhci-hcd.c 	uhci_fsbr_off(uhci);
uhci              388 drivers/usb/host/uhci-hcd.c static void start_rh(struct uhci_hcd *uhci)
uhci              390 drivers/usb/host/uhci-hcd.c 	uhci->is_stopped = 0;
uhci              396 drivers/usb/host/uhci-hcd.c 	if (uhci_is_aspeed(uhci))
uhci              397 drivers/usb/host/uhci-hcd.c 		uhci_writew(uhci, uhci_readw(uhci, USBSTS), USBSTS);
uhci              402 drivers/usb/host/uhci-hcd.c 	uhci_writew(uhci, USBCMD_RS | USBCMD_CF | USBCMD_MAXP, USBCMD);
uhci              403 drivers/usb/host/uhci-hcd.c 	uhci_writew(uhci, USBINTR_TIMEOUT | USBINTR_RESUME |
uhci              406 drivers/usb/host/uhci-hcd.c 	uhci->rh_state = UHCI_RH_RUNNING;
uhci              407 drivers/usb/host/uhci-hcd.c 	set_bit(HCD_FLAG_POLL_RH, &uhci_to_hcd(uhci)->flags);
uhci              410 drivers/usb/host/uhci-hcd.c static void wakeup_rh(struct uhci_hcd *uhci)
uhci              411 drivers/usb/host/uhci-hcd.c __releases(uhci->lock)
uhci              412 drivers/usb/host/uhci-hcd.c __acquires(uhci->lock)
uhci              414 drivers/usb/host/uhci-hcd.c 	dev_dbg(&uhci_to_hcd(uhci)->self.root_hub->dev,
uhci              416 drivers/usb/host/uhci-hcd.c 			uhci->rh_state == UHCI_RH_AUTO_STOPPED ?
uhci              423 drivers/usb/host/uhci-hcd.c 	if (uhci->rh_state == UHCI_RH_SUSPENDED) {
uhci              427 drivers/usb/host/uhci-hcd.c 		egsm = uhci_readw(uhci, USBCMD) & USBCMD_EGSM;
uhci              428 drivers/usb/host/uhci-hcd.c 		uhci->rh_state = UHCI_RH_RESUMING;
uhci              429 drivers/usb/host/uhci-hcd.c 		uhci_writew(uhci, USBCMD_FGR | USBCMD_CF | egsm, USBCMD);
uhci              430 drivers/usb/host/uhci-hcd.c 		spin_unlock_irq(&uhci->lock);
uhci              432 drivers/usb/host/uhci-hcd.c 		spin_lock_irq(&uhci->lock);
uhci              433 drivers/usb/host/uhci-hcd.c 		if (uhci->dead)
uhci              437 drivers/usb/host/uhci-hcd.c 		uhci_writew(uhci, USBCMD_CF, USBCMD);
uhci              440 drivers/usb/host/uhci-hcd.c 		if (uhci_readw(uhci, USBCMD) & USBCMD_FGR)
uhci              441 drivers/usb/host/uhci-hcd.c 			dev_warn(uhci_dev(uhci), "FGR not stopped yet!\n");
uhci              444 drivers/usb/host/uhci-hcd.c 	start_rh(uhci);
uhci              447 drivers/usb/host/uhci-hcd.c 	mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
uhci              452 drivers/usb/host/uhci-hcd.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              460 drivers/usb/host/uhci-hcd.c 	status = uhci_readw(uhci, USBSTS);
uhci              463 drivers/usb/host/uhci-hcd.c 	uhci_writew(uhci, status, USBSTS);		/* Clear it */
uhci              465 drivers/usb/host/uhci-hcd.c 	spin_lock(&uhci->lock);
uhci              466 drivers/usb/host/uhci-hcd.c 	if (unlikely(!uhci->is_initialized))	/* not yet configured */
uhci              471 drivers/usb/host/uhci-hcd.c 			dev_err(uhci_dev(uhci),
uhci              474 drivers/usb/host/uhci-hcd.c 			dev_err(uhci_dev(uhci),
uhci              477 drivers/usb/host/uhci-hcd.c 			if (uhci->rh_state >= UHCI_RH_RUNNING) {
uhci              478 drivers/usb/host/uhci-hcd.c 				dev_err(uhci_dev(uhci),
uhci              482 drivers/usb/host/uhci-hcd.c 					uhci_sprint_schedule(uhci, errbuf,
uhci              486 drivers/usb/host/uhci-hcd.c 				uhci_hc_died(uhci);
uhci              497 drivers/usb/host/uhci-hcd.c 		spin_unlock(&uhci->lock);
uhci              500 drivers/usb/host/uhci-hcd.c 		uhci_scan_schedule(uhci);
uhci              502 drivers/usb/host/uhci-hcd.c 		spin_unlock(&uhci->lock);
uhci              516 drivers/usb/host/uhci-hcd.c static void uhci_get_current_frame_number(struct uhci_hcd *uhci)
uhci              518 drivers/usb/host/uhci-hcd.c 	if (!uhci->is_stopped) {
uhci              521 drivers/usb/host/uhci-hcd.c 		delta = (uhci_readw(uhci, USBFRNUM) - uhci->frame_number) &
uhci              523 drivers/usb/host/uhci-hcd.c 		uhci->frame_number += delta;
uhci              530 drivers/usb/host/uhci-hcd.c static void release_uhci(struct uhci_hcd *uhci)
uhci              535 drivers/usb/host/uhci-hcd.c 	spin_lock_irq(&uhci->lock);
uhci              536 drivers/usb/host/uhci-hcd.c 	uhci->is_initialized = 0;
uhci              537 drivers/usb/host/uhci-hcd.c 	spin_unlock_irq(&uhci->lock);
uhci              539 drivers/usb/host/uhci-hcd.c 	debugfs_remove(uhci->dentry);
uhci              542 drivers/usb/host/uhci-hcd.c 		uhci_free_qh(uhci, uhci->skelqh[i]);
uhci              544 drivers/usb/host/uhci-hcd.c 	uhci_free_td(uhci, uhci->term_td);
uhci              546 drivers/usb/host/uhci-hcd.c 	dma_pool_destroy(uhci->qh_pool);
uhci              548 drivers/usb/host/uhci-hcd.c 	dma_pool_destroy(uhci->td_pool);
uhci              550 drivers/usb/host/uhci-hcd.c 	kfree(uhci->frame_cpu);
uhci              552 drivers/usb/host/uhci-hcd.c 	dma_free_coherent(uhci_dev(uhci),
uhci              553 drivers/usb/host/uhci-hcd.c 			UHCI_NUMFRAMES * sizeof(*uhci->frame),
uhci              554 drivers/usb/host/uhci-hcd.c 			uhci->frame, uhci->frame_dma_handle);
uhci              577 drivers/usb/host/uhci-hcd.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              587 drivers/usb/host/uhci-hcd.c 	spin_lock_init(&uhci->lock);
uhci              588 drivers/usb/host/uhci-hcd.c 	timer_setup(&uhci->fsbr_timer, uhci_fsbr_timeout, 0);
uhci              589 drivers/usb/host/uhci-hcd.c 	INIT_LIST_HEAD(&uhci->idle_qh_list);
uhci              590 drivers/usb/host/uhci-hcd.c 	init_waitqueue_head(&uhci->waitqh);
uhci              593 drivers/usb/host/uhci-hcd.c 	uhci->dentry = debugfs_create_file(hcd->self.bus_name,
uhci              595 drivers/usb/host/uhci-hcd.c 					   uhci_debugfs_root, uhci,
uhci              599 drivers/usb/host/uhci-hcd.c 	uhci->frame = dma_alloc_coherent(uhci_dev(uhci),
uhci              600 drivers/usb/host/uhci-hcd.c 					 UHCI_NUMFRAMES * sizeof(*uhci->frame),
uhci              601 drivers/usb/host/uhci-hcd.c 					 &uhci->frame_dma_handle, GFP_KERNEL);
uhci              602 drivers/usb/host/uhci-hcd.c 	if (!uhci->frame) {
uhci              603 drivers/usb/host/uhci-hcd.c 		dev_err(uhci_dev(uhci),
uhci              608 drivers/usb/host/uhci-hcd.c 	uhci->frame_cpu = kcalloc(UHCI_NUMFRAMES, sizeof(*uhci->frame_cpu),
uhci              610 drivers/usb/host/uhci-hcd.c 	if (!uhci->frame_cpu)
uhci              613 drivers/usb/host/uhci-hcd.c 	uhci->td_pool = dma_pool_create("uhci_td", uhci_dev(uhci),
uhci              615 drivers/usb/host/uhci-hcd.c 	if (!uhci->td_pool) {
uhci              616 drivers/usb/host/uhci-hcd.c 		dev_err(uhci_dev(uhci), "unable to create td dma_pool\n");
uhci              620 drivers/usb/host/uhci-hcd.c 	uhci->qh_pool = dma_pool_create("uhci_qh", uhci_dev(uhci),
uhci              622 drivers/usb/host/uhci-hcd.c 	if (!uhci->qh_pool) {
uhci              623 drivers/usb/host/uhci-hcd.c 		dev_err(uhci_dev(uhci), "unable to create qh dma_pool\n");
uhci              627 drivers/usb/host/uhci-hcd.c 	uhci->term_td = uhci_alloc_td(uhci);
uhci              628 drivers/usb/host/uhci-hcd.c 	if (!uhci->term_td) {
uhci              629 drivers/usb/host/uhci-hcd.c 		dev_err(uhci_dev(uhci), "unable to allocate terminating TD\n");
uhci              634 drivers/usb/host/uhci-hcd.c 		uhci->skelqh[i] = uhci_alloc_qh(uhci, NULL, NULL);
uhci              635 drivers/usb/host/uhci-hcd.c 		if (!uhci->skelqh[i]) {
uhci              636 drivers/usb/host/uhci-hcd.c 			dev_err(uhci_dev(uhci), "unable to allocate QH\n");
uhci              645 drivers/usb/host/uhci-hcd.c 		uhci->skelqh[i]->link = LINK_TO_QH(uhci, uhci->skel_async_qh);
uhci              646 drivers/usb/host/uhci-hcd.c 	uhci->skel_async_qh->link = UHCI_PTR_TERM(uhci);
uhci              647 drivers/usb/host/uhci-hcd.c 	uhci->skel_term_qh->link = LINK_TO_QH(uhci, uhci->skel_term_qh);
uhci              650 drivers/usb/host/uhci-hcd.c 	uhci_fill_td(uhci, uhci->term_td, 0, uhci_explen(0) |
uhci              652 drivers/usb/host/uhci-hcd.c 	uhci->term_td->link = UHCI_PTR_TERM(uhci);
uhci              653 drivers/usb/host/uhci-hcd.c 	uhci->skel_async_qh->element = uhci->skel_term_qh->element =
uhci              654 drivers/usb/host/uhci-hcd.c 		LINK_TO_TD(uhci, uhci->term_td);
uhci              663 drivers/usb/host/uhci-hcd.c 		uhci->frame[i] = uhci_frame_skel_link(uhci, i);
uhci              672 drivers/usb/host/uhci-hcd.c 	spin_lock_irq(&uhci->lock);
uhci              673 drivers/usb/host/uhci-hcd.c 	configure_hc(uhci);
uhci              674 drivers/usb/host/uhci-hcd.c 	uhci->is_initialized = 1;
uhci              675 drivers/usb/host/uhci-hcd.c 	start_rh(uhci);
uhci              676 drivers/usb/host/uhci-hcd.c 	spin_unlock_irq(&uhci->lock);
uhci              684 drivers/usb/host/uhci-hcd.c 		if (uhci->skelqh[i])
uhci              685 drivers/usb/host/uhci-hcd.c 			uhci_free_qh(uhci, uhci->skelqh[i]);
uhci              688 drivers/usb/host/uhci-hcd.c 	uhci_free_td(uhci, uhci->term_td);
uhci              691 drivers/usb/host/uhci-hcd.c 	dma_pool_destroy(uhci->qh_pool);
uhci              694 drivers/usb/host/uhci-hcd.c 	dma_pool_destroy(uhci->td_pool);
uhci              697 drivers/usb/host/uhci-hcd.c 	kfree(uhci->frame_cpu);
uhci              700 drivers/usb/host/uhci-hcd.c 	dma_free_coherent(uhci_dev(uhci),
uhci              701 drivers/usb/host/uhci-hcd.c 			UHCI_NUMFRAMES * sizeof(*uhci->frame),
uhci              702 drivers/usb/host/uhci-hcd.c 			uhci->frame, uhci->frame_dma_handle);
uhci              705 drivers/usb/host/uhci-hcd.c 	debugfs_remove(uhci->dentry);
uhci              712 drivers/usb/host/uhci-hcd.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              714 drivers/usb/host/uhci-hcd.c 	spin_lock_irq(&uhci->lock);
uhci              715 drivers/usb/host/uhci-hcd.c 	if (HCD_HW_ACCESSIBLE(hcd) && !uhci->dead)
uhci              716 drivers/usb/host/uhci-hcd.c 		uhci_hc_died(uhci);
uhci              717 drivers/usb/host/uhci-hcd.c 	uhci_scan_schedule(uhci);
uhci              718 drivers/usb/host/uhci-hcd.c 	spin_unlock_irq(&uhci->lock);
uhci              721 drivers/usb/host/uhci-hcd.c 	del_timer_sync(&uhci->fsbr_timer);
uhci              722 drivers/usb/host/uhci-hcd.c 	release_uhci(uhci);
uhci              728 drivers/usb/host/uhci-hcd.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              731 drivers/usb/host/uhci-hcd.c 	spin_lock_irq(&uhci->lock);
uhci              734 drivers/usb/host/uhci-hcd.c 	else if (uhci->dead)
uhci              743 drivers/usb/host/uhci-hcd.c 			uhci->resuming_ports) {
uhci              744 drivers/usb/host/uhci-hcd.c 		dev_dbg(uhci_dev(uhci),
uhci              748 drivers/usb/host/uhci-hcd.c 		suspend_rh(uhci, UHCI_RH_SUSPENDED);
uhci              749 drivers/usb/host/uhci-hcd.c 	spin_unlock_irq(&uhci->lock);
uhci              755 drivers/usb/host/uhci-hcd.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              758 drivers/usb/host/uhci-hcd.c 	spin_lock_irq(&uhci->lock);
uhci              761 drivers/usb/host/uhci-hcd.c 	else if (!uhci->dead)
uhci              762 drivers/usb/host/uhci-hcd.c 		wakeup_rh(uhci);
uhci              763 drivers/usb/host/uhci-hcd.c 	spin_unlock_irq(&uhci->lock);
uhci              773 drivers/usb/host/uhci-hcd.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              776 drivers/usb/host/uhci-hcd.c 	spin_lock_irq(&uhci->lock);
uhci              782 drivers/usb/host/uhci-hcd.c 		++uhci->num_waiting;
uhci              783 drivers/usb/host/uhci-hcd.c 		spin_unlock_irq(&uhci->lock);
uhci              784 drivers/usb/host/uhci-hcd.c 		wait_event_interruptible(uhci->waitqh,
uhci              786 drivers/usb/host/uhci-hcd.c 		spin_lock_irq(&uhci->lock);
uhci              787 drivers/usb/host/uhci-hcd.c 		--uhci->num_waiting;
uhci              790 drivers/usb/host/uhci-hcd.c 	uhci_free_qh(uhci, qh);
uhci              792 drivers/usb/host/uhci-hcd.c 	spin_unlock_irq(&uhci->lock);
uhci              797 drivers/usb/host/uhci-hcd.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              802 drivers/usb/host/uhci-hcd.c 	frame_number = uhci->frame_number;
uhci              804 drivers/usb/host/uhci-hcd.c 	delta = (uhci_readw(uhci, USBFRNUM) - frame_number) &
uhci              812 drivers/usb/host/uhci-hcd.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              827 drivers/usb/host/uhci-hcd.c 		portstatus = uhci_readw(uhci, USBPORTSC1 + (port * 2));
uhci              832 drivers/usb/host/uhci-hcd.c 		dev_info(uhci_dev(uhci), "detected %d ports\n", port);
uhci              836 drivers/usb/host/uhci-hcd.c 		dev_info(uhci_dev(uhci),
uhci               85 drivers/usb/host/uhci-hcd.h #define UHCI_PTR_BITS(uhci)	cpu_to_hc32((uhci), 0x000F)
uhci               86 drivers/usb/host/uhci-hcd.h #define UHCI_PTR_TERM(uhci)	cpu_to_hc32((uhci), 0x0001)
uhci               87 drivers/usb/host/uhci-hcd.h #define UHCI_PTR_QH(uhci)	cpu_to_hc32((uhci), 0x0002)
uhci               88 drivers/usb/host/uhci-hcd.h #define UHCI_PTR_DEPTH(uhci)	cpu_to_hc32((uhci), 0x0004)
uhci               89 drivers/usb/host/uhci-hcd.h #define UHCI_PTR_BREADTH(uhci)	cpu_to_hc32((uhci), 0x0000)
uhci              193 drivers/usb/host/uhci-hcd.h #define LINK_TO_QH(uhci, qh)	(UHCI_PTR_QH((uhci)) | \
uhci              194 drivers/usb/host/uhci-hcd.h 				cpu_to_hc32((uhci), (qh)->dma_handle))
uhci              227 drivers/usb/host/uhci-hcd.h #define td_token(uhci, td)	hc32_to_cpu((uhci), (td)->token)
uhci              278 drivers/usb/host/uhci-hcd.h #define td_status(uhci, td)		hc32_to_cpu((uhci), \
uhci              281 drivers/usb/host/uhci-hcd.h #define LINK_TO_TD(uhci, td)		(cpu_to_hc32((uhci), (td)->dma_handle))
uhci              454 drivers/usb/host/uhci-hcd.h 	void	(*reset_hc) (struct uhci_hcd *uhci);
uhci              455 drivers/usb/host/uhci-hcd.h 	int	(*check_and_reset_hc) (struct uhci_hcd *uhci);
uhci              457 drivers/usb/host/uhci-hcd.h 	void	(*configure_hc) (struct uhci_hcd *uhci);
uhci              459 drivers/usb/host/uhci-hcd.h 	int	(*resume_detect_interrupts_are_broken) (struct uhci_hcd *uhci);
uhci              461 drivers/usb/host/uhci-hcd.h 	int	(*global_suspend_mode_is_broken) (struct uhci_hcd *uhci);
uhci              469 drivers/usb/host/uhci-hcd.h static inline struct usb_hcd *uhci_to_hcd(struct uhci_hcd *uhci)
uhci              471 drivers/usb/host/uhci-hcd.h 	return container_of((void *) uhci, struct usb_hcd, hcd_priv);
uhci              501 drivers/usb/host/uhci-hcd.h static inline bool uhci_is_aspeed(const struct uhci_hcd *uhci)
uhci              503 drivers/usb/host/uhci-hcd.h 	return IS_ENABLED(CONFIG_USB_UHCI_ASPEED) && uhci->is_aspeed;
uhci              514 drivers/usb/host/uhci-hcd.h static inline u32 uhci_readl(const struct uhci_hcd *uhci, int reg)
uhci              516 drivers/usb/host/uhci-hcd.h 	return inl(uhci->io_addr + reg);
uhci              519 drivers/usb/host/uhci-hcd.h static inline void uhci_writel(const struct uhci_hcd *uhci, u32 val, int reg)
uhci              521 drivers/usb/host/uhci-hcd.h 	outl(val, uhci->io_addr + reg);
uhci              524 drivers/usb/host/uhci-hcd.h static inline u16 uhci_readw(const struct uhci_hcd *uhci, int reg)
uhci              526 drivers/usb/host/uhci-hcd.h 	return inw(uhci->io_addr + reg);
uhci              529 drivers/usb/host/uhci-hcd.h static inline void uhci_writew(const struct uhci_hcd *uhci, u16 val, int reg)
uhci              531 drivers/usb/host/uhci-hcd.h 	outw(val, uhci->io_addr + reg);
uhci              534 drivers/usb/host/uhci-hcd.h static inline u8 uhci_readb(const struct uhci_hcd *uhci, int reg)
uhci              536 drivers/usb/host/uhci-hcd.h 	return inb(uhci->io_addr + reg);
uhci              539 drivers/usb/host/uhci-hcd.h static inline void uhci_writeb(const struct uhci_hcd *uhci, u8 val, int reg)
uhci              541 drivers/usb/host/uhci-hcd.h 	outb(val, uhci->io_addr + reg);
uhci              591 drivers/usb/host/uhci-hcd.h static inline u32 uhci_readl(const struct uhci_hcd *uhci, int reg)
uhci              593 drivers/usb/host/uhci-hcd.h 	if (uhci_has_pci_registers(uhci))
uhci              594 drivers/usb/host/uhci-hcd.h 		return inl(uhci->io_addr + reg);
uhci              595 drivers/usb/host/uhci-hcd.h 	else if (uhci_is_aspeed(uhci))
uhci              596 drivers/usb/host/uhci-hcd.h 		return readl(uhci->regs + uhci_aspeed_reg(reg));
uhci              598 drivers/usb/host/uhci-hcd.h 	else if (uhci_big_endian_mmio(uhci))
uhci              599 drivers/usb/host/uhci-hcd.h 		return readl_be(uhci->regs + reg);
uhci              602 drivers/usb/host/uhci-hcd.h 		return readl(uhci->regs + reg);
uhci              605 drivers/usb/host/uhci-hcd.h static inline void uhci_writel(const struct uhci_hcd *uhci, u32 val, int reg)
uhci              607 drivers/usb/host/uhci-hcd.h 	if (uhci_has_pci_registers(uhci))
uhci              608 drivers/usb/host/uhci-hcd.h 		outl(val, uhci->io_addr + reg);
uhci              609 drivers/usb/host/uhci-hcd.h 	else if (uhci_is_aspeed(uhci))
uhci              610 drivers/usb/host/uhci-hcd.h 		writel(val, uhci->regs + uhci_aspeed_reg(reg));
uhci              612 drivers/usb/host/uhci-hcd.h 	else if (uhci_big_endian_mmio(uhci))
uhci              613 drivers/usb/host/uhci-hcd.h 		writel_be(val, uhci->regs + reg);
uhci              616 drivers/usb/host/uhci-hcd.h 		writel(val, uhci->regs + reg);
uhci              619 drivers/usb/host/uhci-hcd.h static inline u16 uhci_readw(const struct uhci_hcd *uhci, int reg)
uhci              621 drivers/usb/host/uhci-hcd.h 	if (uhci_has_pci_registers(uhci))
uhci              622 drivers/usb/host/uhci-hcd.h 		return inw(uhci->io_addr + reg);
uhci              623 drivers/usb/host/uhci-hcd.h 	else if (uhci_is_aspeed(uhci))
uhci              624 drivers/usb/host/uhci-hcd.h 		return readl(uhci->regs + uhci_aspeed_reg(reg));
uhci              626 drivers/usb/host/uhci-hcd.h 	else if (uhci_big_endian_mmio(uhci))
uhci              627 drivers/usb/host/uhci-hcd.h 		return readw_be(uhci->regs + reg);
uhci              630 drivers/usb/host/uhci-hcd.h 		return readw(uhci->regs + reg);
uhci              633 drivers/usb/host/uhci-hcd.h static inline void uhci_writew(const struct uhci_hcd *uhci, u16 val, int reg)
uhci              635 drivers/usb/host/uhci-hcd.h 	if (uhci_has_pci_registers(uhci))
uhci              636 drivers/usb/host/uhci-hcd.h 		outw(val, uhci->io_addr + reg);
uhci              637 drivers/usb/host/uhci-hcd.h 	else if (uhci_is_aspeed(uhci))
uhci              638 drivers/usb/host/uhci-hcd.h 		writel(val, uhci->regs + uhci_aspeed_reg(reg));
uhci              640 drivers/usb/host/uhci-hcd.h 	else if (uhci_big_endian_mmio(uhci))
uhci              641 drivers/usb/host/uhci-hcd.h 		writew_be(val, uhci->regs + reg);
uhci              644 drivers/usb/host/uhci-hcd.h 		writew(val, uhci->regs + reg);
uhci              647 drivers/usb/host/uhci-hcd.h static inline u8 uhci_readb(const struct uhci_hcd *uhci, int reg)
uhci              649 drivers/usb/host/uhci-hcd.h 	if (uhci_has_pci_registers(uhci))
uhci              650 drivers/usb/host/uhci-hcd.h 		return inb(uhci->io_addr + reg);
uhci              651 drivers/usb/host/uhci-hcd.h 	else if (uhci_is_aspeed(uhci))
uhci              652 drivers/usb/host/uhci-hcd.h 		return readl(uhci->regs + uhci_aspeed_reg(reg));
uhci              654 drivers/usb/host/uhci-hcd.h 	else if (uhci_big_endian_mmio(uhci))
uhci              655 drivers/usb/host/uhci-hcd.h 		return readb_be(uhci->regs + reg);
uhci              658 drivers/usb/host/uhci-hcd.h 		return readb(uhci->regs + reg);
uhci              661 drivers/usb/host/uhci-hcd.h static inline void uhci_writeb(const struct uhci_hcd *uhci, u8 val, int reg)
uhci              663 drivers/usb/host/uhci-hcd.h 	if (uhci_has_pci_registers(uhci))
uhci              664 drivers/usb/host/uhci-hcd.h 		outb(val, uhci->io_addr + reg);
uhci              665 drivers/usb/host/uhci-hcd.h 	else if (uhci_is_aspeed(uhci))
uhci              666 drivers/usb/host/uhci-hcd.h 		writel(val, uhci->regs + uhci_aspeed_reg(reg));
uhci              668 drivers/usb/host/uhci-hcd.h 	else if (uhci_big_endian_mmio(uhci))
uhci              669 drivers/usb/host/uhci-hcd.h 		writeb_be(val, uhci->regs + reg);
uhci              672 drivers/usb/host/uhci-hcd.h 		writeb(val, uhci->regs + reg);
uhci              686 drivers/usb/host/uhci-hcd.h static inline __hc32 cpu_to_hc32(const struct uhci_hcd *uhci, const u32 x)
uhci              688 drivers/usb/host/uhci-hcd.h 	return uhci_big_endian_desc(uhci)
uhci              694 drivers/usb/host/uhci-hcd.h static inline u32 hc32_to_cpu(const struct uhci_hcd *uhci, const __hc32 x)
uhci              696 drivers/usb/host/uhci-hcd.h 	return uhci_big_endian_desc(uhci)
uhci              703 drivers/usb/host/uhci-hcd.h static inline __hc32 cpu_to_hc32(const struct uhci_hcd *uhci, const u32 x)
uhci              709 drivers/usb/host/uhci-hcd.h static inline u32 hc32_to_cpu(const struct uhci_hcd *uhci, const __hc32 x)
uhci               44 drivers/usb/host/uhci-hub.c static int any_ports_active(struct uhci_hcd *uhci)
uhci               48 drivers/usb/host/uhci-hub.c 	for (port = 0; port < uhci->rh_numports; ++port) {
uhci               49 drivers/usb/host/uhci-hub.c 		if ((uhci_readw(uhci, USBPORTSC1 + port * 2) &
uhci               51 drivers/usb/host/uhci-hub.c 				test_bit(port, &uhci->port_c_suspend))
uhci               57 drivers/usb/host/uhci-hub.c static inline int get_hub_status_data(struct uhci_hcd *uhci, char *buf)
uhci               72 drivers/usb/host/uhci-hub.c 	for (port = 0; port < uhci->rh_numports; ++port) {
uhci               73 drivers/usb/host/uhci-hub.c 		if ((uhci_readw(uhci, USBPORTSC1 + port * 2) & mask) ||
uhci               74 drivers/usb/host/uhci-hub.c 				test_bit(port, &uhci->port_c_suspend))
uhci               81 drivers/usb/host/uhci-hub.c 	status = uhci_readw(uhci, port_addr);	\
uhci               85 drivers/usb/host/uhci-hub.c 	uhci_writew(uhci, status, port_addr)
uhci               88 drivers/usb/host/uhci-hub.c 	status = uhci_readw(uhci, port_addr);	\
uhci               91 drivers/usb/host/uhci-hub.c 	uhci_writew(uhci, status, port_addr)
uhci               96 drivers/usb/host/uhci-hub.c static void uhci_finish_suspend(struct uhci_hcd *uhci, int port,
uhci              102 drivers/usb/host/uhci-hub.c 	if (uhci_readw(uhci, port_addr) & SUSPEND_BITS) {
uhci              104 drivers/usb/host/uhci-hub.c 		if (test_bit(port, &uhci->resuming_ports))
uhci              105 drivers/usb/host/uhci-hub.c 			set_bit(port, &uhci->port_c_suspend);
uhci              113 drivers/usb/host/uhci-hub.c 			if (!(uhci_readw(uhci, port_addr) & SUSPEND_BITS))
uhci              118 drivers/usb/host/uhci-hub.c 	clear_bit(port, &uhci->resuming_ports);
uhci              119 drivers/usb/host/uhci-hub.c 	usb_hcd_end_port_resume(&uhci_to_hcd(uhci)->self, port);
uhci              125 drivers/usb/host/uhci-hub.c static void wait_for_HP(struct uhci_hcd *uhci, unsigned long port_addr)
uhci              130 drivers/usb/host/uhci-hub.c 		if (uhci_readw(uhci, port_addr) & USBPORTSC_CSC)
uhci              137 drivers/usb/host/uhci-hub.c static void uhci_check_ports(struct uhci_hcd *uhci)
uhci              143 drivers/usb/host/uhci-hub.c 	for (port = 0; port < uhci->rh_numports; ++port) {
uhci              145 drivers/usb/host/uhci-hub.c 		status = uhci_readw(uhci, port_addr);
uhci              147 drivers/usb/host/uhci-hub.c 			if (time_after_eq(jiffies, uhci->ports_timeout)) {
uhci              153 drivers/usb/host/uhci-hub.c 				if (uhci->wait_for_hp)
uhci              154 drivers/usb/host/uhci-hub.c 					wait_for_HP(uhci, port_addr);
uhci              165 drivers/usb/host/uhci-hub.c 			if (!test_bit(port, &uhci->resuming_ports)) {
uhci              168 drivers/usb/host/uhci-hub.c 				set_bit(port, &uhci->resuming_ports);
uhci              169 drivers/usb/host/uhci-hub.c 				uhci->ports_timeout = jiffies +
uhci              172 drivers/usb/host/uhci-hub.c 						&uhci_to_hcd(uhci)->self, port);
uhci              176 drivers/usb/host/uhci-hub.c 				mod_timer(&uhci_to_hcd(uhci)->rh_timer,
uhci              177 drivers/usb/host/uhci-hub.c 						uhci->ports_timeout);
uhci              179 drivers/usb/host/uhci-hub.c 						uhci->ports_timeout)) {
uhci              180 drivers/usb/host/uhci-hub.c 				uhci_finish_suspend(uhci, port, port_addr);
uhci              188 drivers/usb/host/uhci-hub.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              192 drivers/usb/host/uhci-hub.c 	spin_lock_irqsave(&uhci->lock, flags);
uhci              194 drivers/usb/host/uhci-hub.c 	uhci_scan_schedule(uhci);
uhci              195 drivers/usb/host/uhci-hub.c 	if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead)
uhci              197 drivers/usb/host/uhci-hub.c 	uhci_check_ports(uhci);
uhci              199 drivers/usb/host/uhci-hub.c 	status = get_hub_status_data(uhci, buf);
uhci              201 drivers/usb/host/uhci-hub.c 	switch (uhci->rh_state) {
uhci              204 drivers/usb/host/uhci-hub.c 		if (status || uhci->resuming_ports) {
uhci              213 drivers/usb/host/uhci-hub.c 			wakeup_rh(uhci);
uhci              218 drivers/usb/host/uhci-hub.c 		if (!any_ports_active(uhci)) {
uhci              219 drivers/usb/host/uhci-hub.c 			uhci->rh_state = UHCI_RH_RUNNING_NODEVS;
uhci              220 drivers/usb/host/uhci-hub.c 			uhci->auto_stop_time = jiffies + HZ;
uhci              226 drivers/usb/host/uhci-hub.c 		if (any_ports_active(uhci))
uhci              227 drivers/usb/host/uhci-hub.c 			uhci->rh_state = UHCI_RH_RUNNING;
uhci              228 drivers/usb/host/uhci-hub.c 		else if (time_after_eq(jiffies, uhci->auto_stop_time) &&
uhci              229 drivers/usb/host/uhci-hub.c 				!uhci->wait_for_hp)
uhci              230 drivers/usb/host/uhci-hub.c 			suspend_rh(uhci, UHCI_RH_AUTO_STOPPED);
uhci              238 drivers/usb/host/uhci-hub.c 	spin_unlock_irqrestore(&uhci->lock, flags);
uhci              246 drivers/usb/host/uhci-hub.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              253 drivers/usb/host/uhci-hub.c 	if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead)
uhci              256 drivers/usb/host/uhci-hub.c 	spin_lock_irqsave(&uhci->lock, flags);
uhci              264 drivers/usb/host/uhci-hub.c 		if (port >= uhci->rh_numports)
uhci              267 drivers/usb/host/uhci-hub.c 		uhci_check_ports(uhci);
uhci              268 drivers/usb/host/uhci-hub.c 		status = uhci_readw(uhci, port_addr);
uhci              274 drivers/usb/host/uhci-hub.c 		if (uhci->oc_low)
uhci              286 drivers/usb/host/uhci-hub.c 		if (test_bit(port, &uhci->port_c_suspend)) {
uhci              290 drivers/usb/host/uhci-hub.c 		if (test_bit(port, &uhci->resuming_ports))
uhci              310 drivers/usb/host/uhci-hub.c 			dev_dbg(uhci_dev(uhci), "port %d portsc %04x,%02x\n",
uhci              328 drivers/usb/host/uhci-hub.c 		if (port >= uhci->rh_numports)
uhci              339 drivers/usb/host/uhci-hub.c 			uhci_finish_suspend(uhci, port, port_addr);
uhci              342 drivers/usb/host/uhci-hub.c 			uhci->ports_timeout = jiffies +
uhci              353 drivers/usb/host/uhci-hub.c 		if (port >= uhci->rh_numports)
uhci              361 drivers/usb/host/uhci-hub.c 			uhci_finish_suspend(uhci, port, port_addr);
uhci              367 drivers/usb/host/uhci-hub.c 			if (!(uhci_readw(uhci, port_addr) & USBPORTSC_SUSP)) {
uhci              370 drivers/usb/host/uhci-hub.c 				uhci_finish_suspend(uhci, port, port_addr);
uhci              372 drivers/usb/host/uhci-hub.c 						&uhci->resuming_ports)) {
uhci              379 drivers/usb/host/uhci-hub.c 				if (!(uhci_readw(uhci, port_addr) &
uhci              381 drivers/usb/host/uhci-hub.c 					uhci_finish_suspend(uhci, port,
uhci              385 drivers/usb/host/uhci-hub.c 					uhci->ports_timeout = jiffies +
uhci              390 drivers/usb/host/uhci-hub.c 			clear_bit(port, &uhci->port_c_suspend);
uhci              412 drivers/usb/host/uhci-hub.c 			buf[2] = uhci->rh_numports;
uhci              418 drivers/usb/host/uhci-hub.c 	spin_unlock_irqrestore(&uhci->lock, flags);
uhci               27 drivers/usb/host/uhci-pci.c static void uhci_pci_reset_hc(struct uhci_hcd *uhci)
uhci               29 drivers/usb/host/uhci-pci.c 	uhci_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr);
uhci               38 drivers/usb/host/uhci-pci.c static int uhci_pci_check_and_reset_hc(struct uhci_hcd *uhci)
uhci               40 drivers/usb/host/uhci-pci.c 	return uhci_check_and_reset_hc(to_pci_dev(uhci_dev(uhci)),
uhci               41 drivers/usb/host/uhci-pci.c 				uhci->io_addr);
uhci               48 drivers/usb/host/uhci-pci.c static void uhci_pci_configure_hc(struct uhci_hcd *uhci)
uhci               50 drivers/usb/host/uhci-pci.c 	struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
uhci               60 drivers/usb/host/uhci-pci.c static int uhci_pci_resume_detect_interrupts_are_broken(struct uhci_hcd *uhci)
uhci               64 drivers/usb/host/uhci-pci.c 	switch (to_pci_dev(uhci_dev(uhci))->vendor) {
uhci               82 drivers/usb/host/uhci-pci.c 		for (port = 0; port < uhci->rh_numports; ++port) {
uhci               83 drivers/usb/host/uhci-pci.c 			if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
uhci               92 drivers/usb/host/uhci-pci.c static int uhci_pci_global_suspend_mode_is_broken(struct uhci_hcd *uhci)
uhci              104 drivers/usb/host/uhci-pci.c 		for (port = 0; port < uhci->rh_numports; ++port) {
uhci              105 drivers/usb/host/uhci-pci.c 			if (inw(uhci->io_addr + USBPORTSC1 + port * 2) &
uhci              116 drivers/usb/host/uhci-pci.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              118 drivers/usb/host/uhci-pci.c 	uhci->io_addr = (unsigned long) hcd->rsrc_start;
uhci              120 drivers/usb/host/uhci-pci.c 	uhci->rh_numports = uhci_count_ports(hcd);
uhci              126 drivers/usb/host/uhci-pci.c 	if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_VIA)
uhci              127 drivers/usb/host/uhci-pci.c 		uhci->oc_low = 1;
uhci              130 drivers/usb/host/uhci-pci.c 	if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_HP)
uhci              131 drivers/usb/host/uhci-pci.c 		uhci->wait_for_hp = 1;
uhci              134 drivers/usb/host/uhci-pci.c 	if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_INTEL)
uhci              135 drivers/usb/host/uhci-pci.c 		device_set_wakeup_capable(uhci_dev(uhci), true);
uhci              138 drivers/usb/host/uhci-pci.c 	uhci->reset_hc = uhci_pci_reset_hc;
uhci              139 drivers/usb/host/uhci-pci.c 	uhci->check_and_reset_hc = uhci_pci_check_and_reset_hc;
uhci              140 drivers/usb/host/uhci-pci.c 	uhci->configure_hc = uhci_pci_configure_hc;
uhci              141 drivers/usb/host/uhci-pci.c 	uhci->resume_detect_interrupts_are_broken =
uhci              143 drivers/usb/host/uhci-pci.c 	uhci->global_suspend_mode_is_broken =
uhci              150 drivers/usb/host/uhci-pci.c 	check_and_reset_hc(uhci);
uhci              174 drivers/usb/host/uhci-pci.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              175 drivers/usb/host/uhci-pci.c 	struct pci_dev *pdev = to_pci_dev(uhci_dev(uhci));
uhci              178 drivers/usb/host/uhci-pci.c 	dev_dbg(uhci_dev(uhci), "%s\n", __func__);
uhci              180 drivers/usb/host/uhci-pci.c 	spin_lock_irq(&uhci->lock);
uhci              181 drivers/usb/host/uhci-pci.c 	if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead)
uhci              199 drivers/usb/host/uhci-pci.c 	spin_unlock_irq(&uhci->lock);
uhci              213 drivers/usb/host/uhci-pci.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              215 drivers/usb/host/uhci-pci.c 	dev_dbg(uhci_dev(uhci), "%s\n", __func__);
uhci              222 drivers/usb/host/uhci-pci.c 	spin_lock_irq(&uhci->lock);
uhci              226 drivers/usb/host/uhci-pci.c 		uhci->reset_hc(uhci);
uhci              227 drivers/usb/host/uhci-pci.c 		finish_reset(uhci);
uhci              234 drivers/usb/host/uhci-pci.c 		check_and_reset_hc(uhci);
uhci              236 drivers/usb/host/uhci-pci.c 	configure_hc(uhci);
uhci              239 drivers/usb/host/uhci-pci.c 	if (uhci->rh_state == UHCI_RH_RESET)
uhci              242 drivers/usb/host/uhci-pci.c 	spin_unlock_irq(&uhci->lock);
uhci              247 drivers/usb/host/uhci-pci.c 	if (!uhci->RD_enable && hcd->self.root_hub->do_remote_wakeup)
uhci               17 drivers/usb/host/uhci-platform.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci               20 drivers/usb/host/uhci-platform.c 	if (!uhci->rh_numports)
uhci               21 drivers/usb/host/uhci-platform.c 		uhci->rh_numports = uhci_count_ports(hcd);
uhci               24 drivers/usb/host/uhci-platform.c 	uhci->reset_hc = uhci_generic_reset_hc;
uhci               25 drivers/usb/host/uhci-platform.c 	uhci->check_and_reset_hc = uhci_generic_check_and_reset_hc;
uhci               28 drivers/usb/host/uhci-platform.c 	uhci->configure_hc = NULL;
uhci               29 drivers/usb/host/uhci-platform.c 	uhci->resume_detect_interrupts_are_broken = NULL;
uhci               30 drivers/usb/host/uhci-platform.c 	uhci->global_suspend_mode_is_broken = NULL;
uhci               33 drivers/usb/host/uhci-platform.c 	check_and_reset_hc(uhci);
uhci               71 drivers/usb/host/uhci-platform.c 	struct uhci_hcd	*uhci;
uhci               92 drivers/usb/host/uhci-platform.c 	uhci = hcd_to_uhci(hcd);
uhci              103 drivers/usb/host/uhci-platform.c 	uhci->regs = hcd->regs;
uhci              110 drivers/usb/host/uhci-platform.c 			uhci->rh_numports = num_ports;
uhci              117 drivers/usb/host/uhci-platform.c 			uhci->is_aspeed = 1;
uhci              124 drivers/usb/host/uhci-platform.c 	uhci->clk = devm_clk_get(&pdev->dev, NULL);
uhci              125 drivers/usb/host/uhci-platform.c 	if (IS_ERR(uhci->clk)) {
uhci              126 drivers/usb/host/uhci-platform.c 		ret = PTR_ERR(uhci->clk);
uhci              129 drivers/usb/host/uhci-platform.c 	ret = clk_prepare_enable(uhci->clk);
uhci              143 drivers/usb/host/uhci-platform.c 	clk_disable_unprepare(uhci->clk);
uhci              153 drivers/usb/host/uhci-platform.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci              155 drivers/usb/host/uhci-platform.c 	clk_disable_unprepare(uhci->clk);
uhci               29 drivers/usb/host/uhci-q.c static void uhci_set_next_interrupt(struct uhci_hcd *uhci)
uhci               31 drivers/usb/host/uhci-q.c 	if (uhci->is_stopped)
uhci               32 drivers/usb/host/uhci-q.c 		mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
uhci               33 drivers/usb/host/uhci-q.c 	uhci->term_td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
uhci               36 drivers/usb/host/uhci-q.c static inline void uhci_clear_next_interrupt(struct uhci_hcd *uhci)
uhci               38 drivers/usb/host/uhci-q.c 	uhci->term_td->status &= ~cpu_to_hc32(uhci, TD_CTRL_IOC);
uhci               47 drivers/usb/host/uhci-q.c static void uhci_fsbr_on(struct uhci_hcd *uhci)
uhci               54 drivers/usb/host/uhci-q.c 	uhci->fsbr_is_on = 1;
uhci               55 drivers/usb/host/uhci-q.c 	lqh = list_entry(uhci->skel_async_qh->node.prev,
uhci               57 drivers/usb/host/uhci-q.c 	lqh->link = LINK_TO_QH(uhci, uhci->skel_term_qh);
uhci               60 drivers/usb/host/uhci-q.c static void uhci_fsbr_off(struct uhci_hcd *uhci)
uhci               66 drivers/usb/host/uhci-q.c 	uhci->fsbr_is_on = 0;
uhci               67 drivers/usb/host/uhci-q.c 	lqh = list_entry(uhci->skel_async_qh->node.prev,
uhci               69 drivers/usb/host/uhci-q.c 	lqh->link = UHCI_PTR_TERM(uhci);
uhci               72 drivers/usb/host/uhci-q.c static void uhci_add_fsbr(struct uhci_hcd *uhci, struct urb *urb)
uhci               79 drivers/usb/host/uhci-q.c static void uhci_urbp_wants_fsbr(struct uhci_hcd *uhci, struct urb_priv *urbp)
uhci               82 drivers/usb/host/uhci-q.c 		uhci->fsbr_is_wanted = 1;
uhci               83 drivers/usb/host/uhci-q.c 		if (!uhci->fsbr_is_on)
uhci               84 drivers/usb/host/uhci-q.c 			uhci_fsbr_on(uhci);
uhci               85 drivers/usb/host/uhci-q.c 		else if (uhci->fsbr_expiring) {
uhci               86 drivers/usb/host/uhci-q.c 			uhci->fsbr_expiring = 0;
uhci               87 drivers/usb/host/uhci-q.c 			del_timer(&uhci->fsbr_timer);
uhci               94 drivers/usb/host/uhci-q.c 	struct uhci_hcd *uhci = from_timer(uhci, t, fsbr_timer);
uhci               97 drivers/usb/host/uhci-q.c 	spin_lock_irqsave(&uhci->lock, flags);
uhci               98 drivers/usb/host/uhci-q.c 	if (uhci->fsbr_expiring) {
uhci               99 drivers/usb/host/uhci-q.c 		uhci->fsbr_expiring = 0;
uhci              100 drivers/usb/host/uhci-q.c 		uhci_fsbr_off(uhci);
uhci              102 drivers/usb/host/uhci-q.c 	spin_unlock_irqrestore(&uhci->lock, flags);
uhci              106 drivers/usb/host/uhci-q.c static struct uhci_td *uhci_alloc_td(struct uhci_hcd *uhci)
uhci              111 drivers/usb/host/uhci-q.c 	td = dma_pool_alloc(uhci->td_pool, GFP_ATOMIC, &dma_handle);
uhci              124 drivers/usb/host/uhci-q.c static void uhci_free_td(struct uhci_hcd *uhci, struct uhci_td *td)
uhci              127 drivers/usb/host/uhci-q.c 		dev_WARN(uhci_dev(uhci), "td %p still in list!\n", td);
uhci              129 drivers/usb/host/uhci-q.c 		dev_WARN(uhci_dev(uhci), "td %p still in fl_list!\n", td);
uhci              131 drivers/usb/host/uhci-q.c 	dma_pool_free(uhci->td_pool, td, td->dma_handle);
uhci              134 drivers/usb/host/uhci-q.c static inline void uhci_fill_td(struct uhci_hcd *uhci, struct uhci_td *td,
uhci              137 drivers/usb/host/uhci-q.c 	td->status = cpu_to_hc32(uhci, status);
uhci              138 drivers/usb/host/uhci-q.c 	td->token = cpu_to_hc32(uhci, token);
uhci              139 drivers/usb/host/uhci-q.c 	td->buffer = cpu_to_hc32(uhci, buffer);
uhci              155 drivers/usb/host/uhci-q.c static inline void uhci_insert_td_in_frame_list(struct uhci_hcd *uhci,
uhci              163 drivers/usb/host/uhci-q.c 	if (uhci->frame_cpu[framenum]) {
uhci              166 drivers/usb/host/uhci-q.c 		ftd = uhci->frame_cpu[framenum];
uhci              173 drivers/usb/host/uhci-q.c 		ltd->link = LINK_TO_TD(uhci, td);
uhci              175 drivers/usb/host/uhci-q.c 		td->link = uhci->frame[framenum];
uhci              177 drivers/usb/host/uhci-q.c 		uhci->frame[framenum] = LINK_TO_TD(uhci, td);
uhci              178 drivers/usb/host/uhci-q.c 		uhci->frame_cpu[framenum] = td;
uhci              182 drivers/usb/host/uhci-q.c static inline void uhci_remove_td_from_frame_list(struct uhci_hcd *uhci,
uhci              191 drivers/usb/host/uhci-q.c 	if (uhci->frame_cpu[td->frame] == td) {
uhci              193 drivers/usb/host/uhci-q.c 			uhci->frame[td->frame] = td->link;
uhci              194 drivers/usb/host/uhci-q.c 			uhci->frame_cpu[td->frame] = NULL;
uhci              201 drivers/usb/host/uhci-q.c 			uhci->frame[td->frame] = LINK_TO_TD(uhci, ntd);
uhci              202 drivers/usb/host/uhci-q.c 			uhci->frame_cpu[td->frame] = ntd;
uhci              215 drivers/usb/host/uhci-q.c static inline void uhci_remove_tds_from_frame(struct uhci_hcd *uhci,
uhci              222 drivers/usb/host/uhci-q.c 	ftd = uhci->frame_cpu[framenum];
uhci              225 drivers/usb/host/uhci-q.c 		uhci->frame[framenum] = ltd->link;
uhci              226 drivers/usb/host/uhci-q.c 		uhci->frame_cpu[framenum] = NULL;
uhci              236 drivers/usb/host/uhci-q.c static void uhci_unlink_isochronous_tds(struct uhci_hcd *uhci, struct urb *urb)
uhci              242 drivers/usb/host/uhci-q.c 		uhci_remove_td_from_frame_list(uhci, td);
uhci              245 drivers/usb/host/uhci-q.c static struct uhci_qh *uhci_alloc_qh(struct uhci_hcd *uhci,
uhci              251 drivers/usb/host/uhci-q.c 	qh = dma_pool_zalloc(uhci->qh_pool, GFP_ATOMIC, &dma_handle);
uhci              257 drivers/usb/host/uhci-q.c 	qh->element = UHCI_PTR_TERM(uhci);
uhci              258 drivers/usb/host/uhci-q.c 	qh->link = UHCI_PTR_TERM(uhci);
uhci              266 drivers/usb/host/uhci-q.c 			qh->dummy_td = uhci_alloc_td(uhci);
uhci              268 drivers/usb/host/uhci-q.c 				dma_pool_free(uhci->qh_pool, qh, dma_handle);
uhci              292 drivers/usb/host/uhci-q.c static void uhci_free_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              296 drivers/usb/host/uhci-q.c 		dev_WARN(uhci_dev(uhci), "qh %p list not empty!\n", qh);
uhci              302 drivers/usb/host/uhci-q.c 			uhci_free_td(uhci, qh->dummy_td);
uhci              304 drivers/usb/host/uhci-q.c 	dma_pool_free(uhci->qh_pool, qh, qh->dma_handle);
uhci              314 drivers/usb/host/uhci-q.c static int uhci_cleanup_queue(struct uhci_hcd *uhci, struct uhci_qh *qh,
uhci              326 drivers/usb/host/uhci-q.c 		ret = (uhci->frame_number + uhci->is_stopped !=
uhci              350 drivers/usb/host/uhci-q.c 	if (qh_element(qh) == UHCI_PTR_TERM(uhci))
uhci              352 drivers/usb/host/uhci-q.c 	qh->element = UHCI_PTR_TERM(uhci);
uhci              362 drivers/usb/host/uhci-q.c 	qh->initial_toggle = uhci_toggle(td_token(uhci, td));
uhci              372 drivers/usb/host/uhci-q.c static void uhci_fixup_toggles(struct uhci_hcd *uhci, struct uhci_qh *qh,
uhci              387 drivers/usb/host/uhci-q.c 	else if (qh_element(qh) != UHCI_PTR_TERM(uhci))
uhci              399 drivers/usb/host/uhci-q.c 		if (toggle > 1 || uhci_toggle(td_token(uhci, td)) == toggle) {
uhci              402 drivers/usb/host/uhci-q.c 			toggle = uhci_toggle(td_token(uhci, td)) ^ 1;
uhci              407 drivers/usb/host/uhci-q.c 				td->token ^= cpu_to_hc32(uhci,
uhci              424 drivers/usb/host/uhci-q.c static inline void link_iso(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              426 drivers/usb/host/uhci-q.c 	list_add_tail(&qh->node, &uhci->skel_iso_qh->node);
uhci              435 drivers/usb/host/uhci-q.c static void link_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              439 drivers/usb/host/uhci-q.c 	list_add_tail(&qh->node, &uhci->skelqh[qh->skel]->node);
uhci              444 drivers/usb/host/uhci-q.c 	pqh->link = LINK_TO_QH(uhci, qh);
uhci              451 drivers/usb/host/uhci-q.c static void link_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              459 drivers/usb/host/uhci-q.c 	list_for_each_entry_reverse(pqh, &uhci->skel_async_qh->node, node) {
uhci              468 drivers/usb/host/uhci-q.c 	link_to_new_qh = LINK_TO_QH(uhci, qh);
uhci              474 drivers/usb/host/uhci-q.c 		uhci->skel_term_qh->link = link_to_new_qh;
uhci              480 drivers/usb/host/uhci-q.c static void uhci_activate_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              486 drivers/usb/host/uhci-q.c 	if (qh_element(qh) == UHCI_PTR_TERM(uhci)) {
uhci              492 drivers/usb/host/uhci-q.c 		qh->element = LINK_TO_TD(uhci, td);
uhci              505 drivers/usb/host/uhci-q.c 	if (qh == uhci->next_qh)
uhci              506 drivers/usb/host/uhci-q.c 		uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
uhci              511 drivers/usb/host/uhci-q.c 		link_iso(uhci, qh);
uhci              513 drivers/usb/host/uhci-q.c 		link_interrupt(uhci, qh);
uhci              515 drivers/usb/host/uhci-q.c 		link_async(uhci, qh);
uhci              521 drivers/usb/host/uhci-q.c static void unlink_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              533 drivers/usb/host/uhci-q.c static void unlink_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              544 drivers/usb/host/uhci-q.c 		uhci->skel_term_qh->link = link_to_next_qh;
uhci              551 drivers/usb/host/uhci-q.c static void uhci_unlink_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              562 drivers/usb/host/uhci-q.c 		unlink_interrupt(uhci, qh);
uhci              564 drivers/usb/host/uhci-q.c 		unlink_async(uhci, qh);
uhci              566 drivers/usb/host/uhci-q.c 	uhci_get_current_frame_number(uhci);
uhci              567 drivers/usb/host/uhci-q.c 	qh->unlink_frame = uhci->frame_number;
uhci              570 drivers/usb/host/uhci-q.c 	if (list_empty(&uhci->skel_unlink_qh->node) || uhci->is_stopped)
uhci              571 drivers/usb/host/uhci-q.c 		uhci_set_next_interrupt(uhci);
uhci              574 drivers/usb/host/uhci-q.c 	if (qh == uhci->next_qh)
uhci              575 drivers/usb/host/uhci-q.c 		uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
uhci              577 drivers/usb/host/uhci-q.c 	list_move_tail(&qh->node, &uhci->skel_unlink_qh->node);
uhci              586 drivers/usb/host/uhci-q.c static void uhci_make_qh_idle(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              590 drivers/usb/host/uhci-q.c 	if (qh == uhci->next_qh)
uhci              591 drivers/usb/host/uhci-q.c 		uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
uhci              593 drivers/usb/host/uhci-q.c 	list_move(&qh->node, &uhci->idle_qh_list);
uhci              598 drivers/usb/host/uhci-q.c 		uhci_free_td(uhci, qh->post_td);
uhci              603 drivers/usb/host/uhci-q.c 	if (uhci->num_waiting)
uhci              604 drivers/usb/host/uhci-q.c 		wake_up_all(&uhci->waitqh);
uhci              610 drivers/usb/host/uhci-q.c static int uhci_highest_load(struct uhci_hcd *uhci, int phase, int period)
uhci              612 drivers/usb/host/uhci-q.c 	int highest_load = uhci->load[phase];
uhci              615 drivers/usb/host/uhci-q.c 		highest_load = max_t(int, highest_load, uhci->load[phase]);
uhci              623 drivers/usb/host/uhci-q.c static int uhci_check_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              630 drivers/usb/host/uhci-q.c 		minimax_load = uhci_highest_load(uhci, qh->phase, qh->period);
uhci              636 drivers/usb/host/uhci-q.c 		minimax_load = uhci_highest_load(uhci, qh->phase, qh->period);
uhci              638 drivers/usb/host/uhci-q.c 			load = uhci_highest_load(uhci, phase, qh->period);
uhci              648 drivers/usb/host/uhci-q.c 		dev_dbg(uhci_dev(uhci), "bandwidth allocation failed: "
uhci              659 drivers/usb/host/uhci-q.c static void uhci_reserve_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              666 drivers/usb/host/uhci-q.c 		uhci->load[i] += load;
uhci              667 drivers/usb/host/uhci-q.c 		uhci->total_load += load;
uhci              669 drivers/usb/host/uhci-q.c 	uhci_to_hcd(uhci)->self.bandwidth_allocated =
uhci              670 drivers/usb/host/uhci-q.c 			uhci->total_load / MAX_PHASE;
uhci              673 drivers/usb/host/uhci-q.c 		++uhci_to_hcd(uhci)->self.bandwidth_int_reqs;
uhci              677 drivers/usb/host/uhci-q.c 		++uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs;
uhci              682 drivers/usb/host/uhci-q.c 	dev_dbg(uhci_dev(uhci),
uhci              692 drivers/usb/host/uhci-q.c static void uhci_release_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci              699 drivers/usb/host/uhci-q.c 		uhci->load[i] -= load;
uhci              700 drivers/usb/host/uhci-q.c 		uhci->total_load -= load;
uhci              702 drivers/usb/host/uhci-q.c 	uhci_to_hcd(uhci)->self.bandwidth_allocated =
uhci              703 drivers/usb/host/uhci-q.c 			uhci->total_load / MAX_PHASE;
uhci              706 drivers/usb/host/uhci-q.c 		--uhci_to_hcd(uhci)->self.bandwidth_int_reqs;
uhci              710 drivers/usb/host/uhci-q.c 		--uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs;
uhci              715 drivers/usb/host/uhci-q.c 	dev_dbg(uhci_dev(uhci),
uhci              722 drivers/usb/host/uhci-q.c static inline struct urb_priv *uhci_alloc_urb_priv(struct uhci_hcd *uhci,
uhci              740 drivers/usb/host/uhci-q.c static void uhci_free_urb_priv(struct uhci_hcd *uhci,
uhci              746 drivers/usb/host/uhci-q.c 		dev_WARN(uhci_dev(uhci), "urb %p still on QH's list!\n",
uhci              751 drivers/usb/host/uhci-q.c 		uhci_free_td(uhci, td);
uhci              789 drivers/usb/host/uhci-q.c static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
uhci              814 drivers/usb/host/uhci-q.c 	uhci_fill_td(uhci, td, status, destination | uhci_explen(8),
uhci              844 drivers/usb/host/uhci-q.c 		td = uhci_alloc_td(uhci);
uhci              847 drivers/usb/host/uhci-q.c 		*plink = LINK_TO_TD(uhci, td);
uhci              853 drivers/usb/host/uhci-q.c 		uhci_fill_td(uhci, td, status,
uhci              864 drivers/usb/host/uhci-q.c 	td = uhci_alloc_td(uhci);
uhci              867 drivers/usb/host/uhci-q.c 	*plink = LINK_TO_TD(uhci, td);
uhci              874 drivers/usb/host/uhci-q.c 	uhci_fill_td(uhci, td, status | TD_CTRL_IOC,
uhci              881 drivers/usb/host/uhci-q.c 	td = uhci_alloc_td(uhci);
uhci              884 drivers/usb/host/uhci-q.c 	*plink = LINK_TO_TD(uhci, td);
uhci              886 drivers/usb/host/uhci-q.c 	uhci_fill_td(uhci, td, 0, USB_PID_OUT | uhci_explen(0), 0);
uhci              888 drivers/usb/host/uhci-q.c 	qh->dummy_td->status |= cpu_to_hc32(uhci, TD_CTRL_ACTIVE);
uhci              900 drivers/usb/host/uhci-q.c 		uhci_add_fsbr(uhci, urb);
uhci              915 drivers/usb/host/uhci-q.c static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
uhci              974 drivers/usb/host/uhci-q.c 			td = uhci_alloc_td(uhci);
uhci              977 drivers/usb/host/uhci-q.c 			*plink = LINK_TO_TD(uhci, td);
uhci              980 drivers/usb/host/uhci-q.c 		uhci_fill_td(uhci, td, status,
uhci             1010 drivers/usb/host/uhci-q.c 		td = uhci_alloc_td(uhci);
uhci             1013 drivers/usb/host/uhci-q.c 		*plink = LINK_TO_TD(uhci, td);
uhci             1016 drivers/usb/host/uhci-q.c 		uhci_fill_td(uhci, td, status,
uhci             1031 drivers/usb/host/uhci-q.c 	td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
uhci             1036 drivers/usb/host/uhci-q.c 	td = uhci_alloc_td(uhci);
uhci             1039 drivers/usb/host/uhci-q.c 	*plink = LINK_TO_TD(uhci, td);
uhci             1041 drivers/usb/host/uhci-q.c 	uhci_fill_td(uhci, td, 0, USB_PID_OUT | uhci_explen(0), 0);
uhci             1043 drivers/usb/host/uhci-q.c 	qh->dummy_td->status |= cpu_to_hc32(uhci, TD_CTRL_ACTIVE);
uhci             1056 drivers/usb/host/uhci-q.c static int uhci_submit_bulk(struct uhci_hcd *uhci, struct urb *urb,
uhci             1067 drivers/usb/host/uhci-q.c 	ret = uhci_submit_common(uhci, urb, qh);
uhci             1069 drivers/usb/host/uhci-q.c 		uhci_add_fsbr(uhci, urb);
uhci             1073 drivers/usb/host/uhci-q.c static int uhci_submit_interrupt(struct uhci_hcd *uhci, struct urb *urb,
uhci             1103 drivers/usb/host/uhci-q.c 			ret = uhci_check_bandwidth(uhci, qh);
uhci             1110 drivers/usb/host/uhci-q.c 	ret = uhci_submit_common(uhci, urb, qh);
uhci             1114 drivers/usb/host/uhci-q.c 			uhci_reserve_bandwidth(uhci, qh);
uhci             1122 drivers/usb/host/uhci-q.c static int uhci_fixup_short_transfer(struct uhci_hcd *uhci,
uhci             1136 drivers/usb/host/uhci-q.c 		qh->element = LINK_TO_TD(uhci, td);
uhci             1146 drivers/usb/host/uhci-q.c 			uhci_toggle(td_token(uhci, qh->post_td)) ^ 1;
uhci             1147 drivers/usb/host/uhci-q.c 		uhci_fixup_toggles(uhci, qh, 1);
uhci             1162 drivers/usb/host/uhci-q.c 		uhci_free_td(uhci, td);
uhci             1170 drivers/usb/host/uhci-q.c static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
uhci             1182 drivers/usb/host/uhci-q.c 		ctrlstat = td_status(uhci, td);
uhci             1192 drivers/usb/host/uhci-q.c 					uhci_packetout(td_token(uhci, td)));
uhci             1201 drivers/usb/host/uhci-q.c 					uhci_show_qh(uhci, urbp->qh, errbuf,
uhci             1208 drivers/usb/host/uhci-q.c 		} else if (len < uhci_expected_length(td_token(uhci, td))) {
uhci             1228 drivers/usb/host/uhci-q.c 			uhci_free_td(uhci, qh->post_td);
uhci             1240 drivers/usb/host/uhci-q.c 		qh->element = UHCI_PTR_TERM(uhci);
uhci             1243 drivers/usb/host/uhci-q.c 		qh->initial_toggle = uhci_toggle(td_token(uhci, td)) ^
uhci             1247 drivers/usb/host/uhci-q.c 		ret = uhci_fixup_short_transfer(uhci, qh, urbp);
uhci             1254 drivers/usb/host/uhci-q.c static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb,
uhci             1268 drivers/usb/host/uhci-q.c 	uhci_get_current_frame_number(uhci);
uhci             1274 drivers/usb/host/uhci-q.c 		i = uhci_check_bandwidth(uhci, qh);
uhci             1279 drivers/usb/host/uhci-q.c 		next = uhci->frame_number + 10;
uhci             1289 drivers/usb/host/uhci-q.c 		next = uhci->frame_number + 1;
uhci             1319 drivers/usb/host/uhci-q.c 				dev_dbg(uhci_dev(uhci), "iso underrun %p (%u+%u < %u)\n",
uhci             1328 drivers/usb/host/uhci-q.c 	if (uhci_frame_before_eq(uhci->last_iso_frame + UHCI_NUMFRAMES,
uhci             1337 drivers/usb/host/uhci-q.c 		td = uhci_alloc_td(uhci);
uhci             1342 drivers/usb/host/uhci-q.c 		uhci_fill_td(uhci, td, status, destination |
uhci             1349 drivers/usb/host/uhci-q.c 	td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
uhci             1354 drivers/usb/host/uhci-q.c 		uhci_insert_td_in_frame_list(uhci, td, frame);
uhci             1365 drivers/usb/host/uhci-q.c 		uhci_reserve_bandwidth(uhci, qh);
uhci             1369 drivers/usb/host/uhci-q.c static int uhci_result_isochronous(struct uhci_hcd *uhci, struct urb *urb)
uhci             1380 drivers/usb/host/uhci-q.c 		if (uhci_frame_before_eq(uhci->cur_iso_frame, qh->iso_frame))
uhci             1383 drivers/usb/host/uhci-q.c 		uhci_remove_tds_from_frame(uhci, qh->iso_frame);
uhci             1385 drivers/usb/host/uhci-q.c 		ctrlstat = td_status(uhci, td);
uhci             1401 drivers/usb/host/uhci-q.c 		uhci_free_td(uhci, td);
uhci             1412 drivers/usb/host/uhci-q.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci             1417 drivers/usb/host/uhci-q.c 	spin_lock_irqsave(&uhci->lock, flags);
uhci             1424 drivers/usb/host/uhci-q.c 	urbp = uhci_alloc_urb_priv(uhci, urb);
uhci             1431 drivers/usb/host/uhci-q.c 		qh = uhci_alloc_qh(uhci, urb->dev, urb->ep);
uhci             1439 drivers/usb/host/uhci-q.c 		ret = uhci_submit_control(uhci, urb, qh);
uhci             1442 drivers/usb/host/uhci-q.c 		ret = uhci_submit_bulk(uhci, urb, qh);
uhci             1445 drivers/usb/host/uhci-q.c 		ret = uhci_submit_interrupt(uhci, urb, qh);
uhci             1449 drivers/usb/host/uhci-q.c 		ret = uhci_submit_isochronous(uhci, urb, qh);
uhci             1463 drivers/usb/host/uhci-q.c 		uhci_activate_qh(uhci, qh);
uhci             1464 drivers/usb/host/uhci-q.c 		uhci_urbp_wants_fsbr(uhci, urbp);
uhci             1470 drivers/usb/host/uhci-q.c 		uhci_make_qh_idle(uhci, qh);	/* Reclaim unused QH */
uhci             1472 drivers/usb/host/uhci-q.c 	uhci_free_urb_priv(uhci, urbp);
uhci             1477 drivers/usb/host/uhci-q.c 	spin_unlock_irqrestore(&uhci->lock, flags);
uhci             1483 drivers/usb/host/uhci-q.c 	struct uhci_hcd *uhci = hcd_to_uhci(hcd);
uhci             1488 drivers/usb/host/uhci-q.c 	spin_lock_irqsave(&uhci->lock, flags);
uhci             1497 drivers/usb/host/uhci-q.c 		uhci_unlink_isochronous_tds(uhci, urb);
uhci             1501 drivers/usb/host/uhci-q.c 		uhci_get_current_frame_number(uhci);
uhci             1502 drivers/usb/host/uhci-q.c 		if (uhci_frame_before_eq(urb->start_frame, uhci->frame_number))
uhci             1503 drivers/usb/host/uhci-q.c 			qh->unlink_frame = uhci->frame_number;
uhci             1506 drivers/usb/host/uhci-q.c 	uhci_unlink_qh(uhci, qh);
uhci             1509 drivers/usb/host/uhci-q.c 	spin_unlock_irqrestore(&uhci->lock, flags);
uhci             1516 drivers/usb/host/uhci-q.c static void uhci_giveback_urb(struct uhci_hcd *uhci, struct uhci_qh *qh,
uhci             1518 drivers/usb/host/uhci-q.c __releases(uhci->lock)
uhci             1519 drivers/usb/host/uhci-q.c __acquires(uhci->lock)
uhci             1552 drivers/usb/host/uhci-q.c 	uhci_free_urb_priv(uhci, urbp);
uhci             1553 drivers/usb/host/uhci-q.c 	usb_hcd_unlink_urb_from_ep(uhci_to_hcd(uhci), urb);
uhci             1555 drivers/usb/host/uhci-q.c 	spin_unlock(&uhci->lock);
uhci             1556 drivers/usb/host/uhci-q.c 	usb_hcd_giveback_urb(uhci_to_hcd(uhci), urb, status);
uhci             1557 drivers/usb/host/uhci-q.c 	spin_lock(&uhci->lock);
uhci             1562 drivers/usb/host/uhci-q.c 		uhci_unlink_qh(uhci, qh);
uhci             1564 drivers/usb/host/uhci-q.c 			uhci_release_bandwidth(uhci, qh);
uhci             1573 drivers/usb/host/uhci-q.c 		uhci->frame_number + uhci->is_stopped != qh->unlink_frame)
uhci             1575 drivers/usb/host/uhci-q.c static void uhci_scan_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci             1586 drivers/usb/host/uhci-q.c 			status = uhci_result_isochronous(uhci, urb);
uhci             1588 drivers/usb/host/uhci-q.c 			status = uhci_result_common(uhci, urb);
uhci             1601 drivers/usb/host/uhci-q.c 		uhci_giveback_urb(uhci, qh, urb, status);
uhci             1622 drivers/usb/host/uhci-q.c 			if (!uhci_cleanup_queue(uhci, qh, urb)) {
uhci             1626 drivers/usb/host/uhci-q.c 			uhci_giveback_urb(uhci, qh, urb, 0);
uhci             1636 drivers/usb/host/uhci-q.c 			uhci_fixup_toggles(uhci, qh, 0);
uhci             1646 drivers/usb/host/uhci-q.c 			td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
uhci             1649 drivers/usb/host/uhci-q.c 		uhci_activate_qh(uhci, qh);
uhci             1655 drivers/usb/host/uhci-q.c 		uhci_make_qh_idle(uhci, qh);
uhci             1668 drivers/usb/host/uhci-q.c static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh)
uhci             1693 drivers/usb/host/uhci-q.c 		status = td_status(uhci, td);
uhci             1701 drivers/usb/host/uhci-q.c 		ret = uhci->is_stopped;
uhci             1712 drivers/usb/host/uhci-q.c 			LINK_TO_TD(uhci, qh->post_td)) {
uhci             1726 drivers/usb/host/uhci-q.c 			uhci_unlink_qh(uhci, qh);
uhci             1731 drivers/usb/host/uhci-q.c 			uhci_urbp_wants_fsbr(uhci, urbp);
uhci             1741 drivers/usb/host/uhci-q.c static void uhci_scan_schedule(struct uhci_hcd *uhci)
uhci             1747 drivers/usb/host/uhci-q.c 	if (uhci->scan_in_progress) {
uhci             1748 drivers/usb/host/uhci-q.c 		uhci->need_rescan = 1;
uhci             1751 drivers/usb/host/uhci-q.c 	uhci->scan_in_progress = 1;
uhci             1753 drivers/usb/host/uhci-q.c 	uhci->need_rescan = 0;
uhci             1754 drivers/usb/host/uhci-q.c 	uhci->fsbr_is_wanted = 0;
uhci             1756 drivers/usb/host/uhci-q.c 	uhci_clear_next_interrupt(uhci);
uhci             1757 drivers/usb/host/uhci-q.c 	uhci_get_current_frame_number(uhci);
uhci             1758 drivers/usb/host/uhci-q.c 	uhci->cur_iso_frame = uhci->frame_number;
uhci             1762 drivers/usb/host/uhci-q.c 		uhci->next_qh = list_entry(uhci->skelqh[i]->node.next,
uhci             1764 drivers/usb/host/uhci-q.c 		while ((qh = uhci->next_qh) != uhci->skelqh[i]) {
uhci             1765 drivers/usb/host/uhci-q.c 			uhci->next_qh = list_entry(qh->node.next,
uhci             1768 drivers/usb/host/uhci-q.c 			if (uhci_advance_check(uhci, qh)) {
uhci             1769 drivers/usb/host/uhci-q.c 				uhci_scan_qh(uhci, qh);
uhci             1771 drivers/usb/host/uhci-q.c 					uhci_urbp_wants_fsbr(uhci,
uhci             1778 drivers/usb/host/uhci-q.c 	uhci->last_iso_frame = uhci->cur_iso_frame;
uhci             1779 drivers/usb/host/uhci-q.c 	if (uhci->need_rescan)
uhci             1781 drivers/usb/host/uhci-q.c 	uhci->scan_in_progress = 0;
uhci             1783 drivers/usb/host/uhci-q.c 	if (uhci->fsbr_is_on && !uhci->fsbr_is_wanted &&
uhci             1784 drivers/usb/host/uhci-q.c 			!uhci->fsbr_expiring) {
uhci             1785 drivers/usb/host/uhci-q.c 		uhci->fsbr_expiring = 1;
uhci             1786 drivers/usb/host/uhci-q.c 		mod_timer(&uhci->fsbr_timer, jiffies + FSBR_OFF_DELAY);
uhci             1789 drivers/usb/host/uhci-q.c 	if (list_empty(&uhci->skel_unlink_qh->node))
uhci             1790 drivers/usb/host/uhci-q.c 		uhci_clear_next_interrupt(uhci);
uhci             1792 drivers/usb/host/uhci-q.c 		uhci_set_next_interrupt(uhci);