usb/isp1760/isp1760-hcd.c

23 #include <linux/usb/hcd.h>
34 #include "isp1760-hcd.h"
41 typedef void (packet_enqueue)(struct usb_hcd *hcd, struct isp1760_qh *qh,
44 static inline struct isp1760_hcd *hcd_to_priv(struct usb_hcd *hcd)
46 	return *(struct isp1760_hcd **)hcd->hcd_priv;
200 static u32 isp1760_hcd_read(struct usb_hcd *hcd, u32 field)
202 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
225 static void isp1760_hcd_write(struct usb_hcd *hcd, u32 field, u32 val)
227 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
235 static void isp1760_hcd_set(struct usb_hcd *hcd, u32 field)
237 	isp1760_hcd_write(hcd, field, 0xFFFFFFFF);
240 static void isp1760_hcd_clear(struct usb_hcd *hcd, u32 field)
242 	isp1760_hcd_write(hcd, field, 0);
245 static int isp1760_hcd_set_and_wait(struct usb_hcd *hcd, u32 field,
248 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
251 	isp1760_hcd_set(hcd, field);
257 static int isp1760_hcd_set_and_wait_swap(struct usb_hcd *hcd, u32 field,
260 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
263 	isp1760_hcd_set(hcd, field);
269 static int isp1760_hcd_clear_and_wait(struct usb_hcd *hcd, u32 field,
272 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
275 	isp1760_hcd_clear(hcd, field);
281 static bool isp1760_hcd_is_set(struct usb_hcd *hcd, u32 field)
283 	return !!isp1760_hcd_read(hcd, field);
286 static bool isp1760_hcd_ppc_is_set(struct usb_hcd *hcd)
288 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
293 	return isp1760_hcd_is_set(hcd, HCS_PPC);
296 static u32 isp1760_hcd_n_ports(struct usb_hcd *hcd)
298 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
303 	return isp1760_hcd_read(hcd, HCS_N_PORTS);
366 static void isp1760_mem_read(struct usb_hcd *hcd, u32 src_offset, void *dst,
369 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
382 static void isp1763_mem_read(struct usb_hcd *hcd, u16 srcaddr,
385 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
387 	/* Write the starting device address to the hcd memory register */
405 static void mem_read(struct usb_hcd *hcd, u32 src_offset, __u32 *dst,
408 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
411 		return isp1760_mem_read(hcd, src_offset, (u16 *)dst, bytes);
413 	isp1763_mem_read(hcd, (u16)src_offset, (u16 *)dst, bytes);
451 static void isp1763_mem_write(struct usb_hcd *hcd, u16 dstaddr, u16 *src,
454 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
456 	/* Write the starting device address to the hcd memory register */
478 static void mem_write(struct usb_hcd *hcd, u32 dst_offset, __u32 *src,
481 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
486 	isp1763_mem_write(hcd, dst_offset, (u16 *)src, bytes);
493 static void isp1760_ptd_read(struct usb_hcd *hcd, u32 ptd_offset, u32 slot,
497 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
506 static void isp1763_ptd_read(struct usb_hcd *hcd, u32 ptd_offset, u32 slot,
512 	isp1763_mem_read(hcd, src_offset, (u16 *)&le32_ptd, sizeof(le32_ptd));
524 static void ptd_read(struct usb_hcd *hcd, u32 ptd_offset, u32 slot,
527 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
530 		return isp1760_ptd_read(hcd, ptd_offset, slot, ptd);
532 	isp1763_ptd_read(hcd, ptd_offset, slot, ptd);
535 static void isp1763_ptd_write(struct usb_hcd *hcd, u32 ptd_offset, u32 slot,
550 	isp1763_mem_write(hcd, dst_offset,  (u16 *)&ptd.dw0,
570 static void ptd_write(struct usb_hcd *hcd, u32 ptd_offset, u32 slot,
573 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
578 	isp1763_ptd_write(hcd, ptd_offset, slot, ptd);
603 static void alloc_mem(struct usb_hcd *hcd, struct isp1760_qtd *qtd)
605 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
624 static void free_mem(struct usb_hcd *hcd, struct isp1760_qtd *qtd)
626 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
642 	dev_err(hcd->self.controller, "%s: Invalid pointer: %08x\n",
649 static int ehci_reset(struct usb_hcd *hcd)
651 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
653 	hcd->state = HC_STATE_HALT;
656 	return isp1760_hcd_set_and_wait_swap(hcd, CMD_RESET, 250 * 1000);
682 static int priv_init(struct usb_hcd *hcd)
684 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
706 	isoc_cache = isp1760_hcd_read(hcd, HCC_ISOC_CACHE);
707 	isoc_thres = isp1760_hcd_read(hcd, HCC_ISOC_THRES);
718 static int isp1760_hc_setup(struct usb_hcd *hcd)
720 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
731 	isp1760_hcd_write(hcd, HC_SCRATCH, pattern);
737 	isp1760_hcd_read(hcd, HC_CHIP_ID_HIGH);
738 	scratch = isp1760_hcd_read(hcd, HC_SCRATCH);
740 		dev_err(hcd->self.controller, "Scratch test failed. 0x%08x\n",
753 	isp1760_hcd_clear(hcd, ISO_BUF_FILL);
754 	isp1760_hcd_clear(hcd, INT_BUF_FILL);
755 	isp1760_hcd_clear(hcd, ATL_BUF_FILL);
757 	isp1760_hcd_set(hcd, HC_ATL_PTD_SKIPMAP);
758 	isp1760_hcd_set(hcd, HC_INT_PTD_SKIPMAP);
759 	isp1760_hcd_set(hcd, HC_ISO_PTD_SKIPMAP);
761 	result = ehci_reset(hcd);
773 	isp1760_hcd_set(hcd, atx_reset);
775 	isp1760_hcd_clear(hcd, atx_reset);
778 		isp1760_hcd_set(hcd, HW_OTG_DISABLE);
779 		isp1760_hcd_set(hcd, HW_SW_SEL_HC_DC_CLEAR);
780 		isp1760_hcd_set(hcd, HW_HC_2_DIS_CLEAR);
783 		isp1760_hcd_set(hcd, HW_INTF_LOCK);
786 	isp1760_hcd_set(hcd, HC_INT_IRQ_ENABLE);
787 	isp1760_hcd_set(hcd, HC_ATL_IRQ_ENABLE);
789 	return priv_init(hcd);
950 static void isp1760_urb_done(struct usb_hcd *hcd, struct urb *urb)
954 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
970 	usb_hcd_unlink_urb_from_ep(hcd, urb);
972 	usb_hcd_giveback_urb(hcd, urb, urb->status);
1000 static void start_bus_transfer(struct usb_hcd *hcd, u32 ptd_offset, int slot,
1005 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
1020 		skip_map = isp1760_hcd_read(hcd, HC_ATL_PTD_SKIPMAP);
1021 		isp1760_hcd_write(hcd, HC_ATL_PTD_SKIPMAP,
1023 		priv->atl_done_map |= isp1760_hcd_read(hcd, HC_ATL_PTD_DONEMAP);
1026 		skip_map = isp1760_hcd_read(hcd, HC_INT_PTD_SKIPMAP);
1027 		isp1760_hcd_write(hcd, HC_INT_PTD_SKIPMAP,
1029 		priv->int_done_map |= isp1760_hcd_read(hcd, HC_INT_PTD_DONEMAP);
1039 	ptd_write(hcd, ptd_offset, slot, ptd);
1042 		isp1760_hcd_write(hcd, HC_ATL_PTD_SKIPMAP, skip_map);
1044 		isp1760_hcd_write(hcd, HC_INT_PTD_SKIPMAP, skip_map);
1053 static void collect_qtds(struct usb_hcd *hcd, struct isp1760_qh *qh,
1073 					mem_read(hcd, qtd->payload_addr,
1095 			free_mem(hcd, qtd);
1116 static void enqueue_qtds(struct usb_hcd *hcd, struct isp1760_qh *qh)
1118 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
1158 			alloc_mem(hcd, qtd);
1164 				mem_write(hcd, qtd->payload_addr,
1174 				dev_dbg(hcd->self.controller, "%s: No slot "
1184 				start_bus_transfer(hcd, ptd_offset, free_slot,
1196 static void schedule_ptds(struct usb_hcd *hcd)
1205 	if (!hcd) {
1210 	priv = hcd_to_priv(hcd);
1218 			collect_qtds(hcd, qh, &urb_list);
1226 		isp1760_urb_done(hcd, urb_listitem->urb);
1257 			enqueue_qtds(hcd, qh);
1265 static int check_int_transfer(struct usb_hcd *hcd, struct ptd *ptd,
1284 				dev_dbg(hcd->self.controller, "%s: underrun "
1290 				dev_dbg(hcd->self.controller, "%s: transaction "
1297 				dev_dbg(hcd->self.controller, "%s: babble "
1312 static int check_atl_transfer(struct usb_hcd *hcd, struct ptd *ptd,
1324 		dev_dbg(hcd->self.controller, "%s: ptd error:\n"
1336 		dev_dbg(hcd->self.controller, "PID error; reloading ptd\n");
1352 static void handle_done_ptds(struct usb_hcd *hcd)
1354 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
1365 	skip_map = isp1760_hcd_read(hcd, HC_INT_PTD_SKIPMAP);
1367 	skip_map = isp1760_hcd_read(hcd, HC_ATL_PTD_SKIPMAP);
1385 			ptd_read(hcd, INT_PTD_OFFSET, slot, &ptd);
1386 			state = check_int_transfer(hcd, &ptd,
1400 			ptd_read(hcd, ATL_PTD_OFFSET, slot, &ptd);
1401 			state = check_atl_transfer(hcd, &ptd,
1471 					dev_err(hcd->self.controller,
1481 			start_bus_transfer(hcd, ptd_offset, slot, slots, qtd,
1487 		schedule_ptds(hcd);
1490 static irqreturn_t isp1760_irq(struct usb_hcd *hcd)
1492 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
1499 	if (!(hcd->state & HC_STATE_RUNNING))
1502 	imask = isp1760_hcd_read(hcd, HC_INTERRUPT);
1510 	priv->int_done_map |= isp1760_hcd_read(hcd, HC_INT_PTD_DONEMAP);
1511 	priv->atl_done_map |= isp1760_hcd_read(hcd, HC_ATL_PTD_DONEMAP);
1513 	handle_done_ptds(hcd);
1555 	struct usb_hcd *hcd = errata2_timer_hcd;
1556 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
1568 			ptd_read(hcd, ATL_PTD_OFFSET, slot, &ptd);
1575 		handle_done_ptds(hcd);
1583 static int isp1763_run(struct usb_hcd *hcd)
1585 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
1593 	hcd->uses_new_polling = 1;
1594 	hcd->state = HC_STATE_RUNNING;
1596 	chipid_h = isp1760_hcd_read(hcd, HC_CHIP_ID_HIGH);
1597 	chipid_l = isp1760_hcd_read(hcd, HC_CHIP_ID_LOW);
1598 	chip_rev = isp1760_hcd_read(hcd, HC_CHIP_REV);
1599 	dev_info(hcd->self.controller, "USB ISP %02x%02x HW rev. %d started\n",
1602 	isp1760_hcd_clear(hcd, ISO_BUF_FILL);
1603 	isp1760_hcd_clear(hcd, INT_BUF_FILL);
1604 	isp1760_hcd_clear(hcd, ATL_BUF_FILL);
1606 	isp1760_hcd_set(hcd, HC_ATL_PTD_SKIPMAP);
1607 	isp1760_hcd_set(hcd, HC_INT_PTD_SKIPMAP);
1608 	isp1760_hcd_set(hcd, HC_ISO_PTD_SKIPMAP);
1610 	isp1760_hcd_clear(hcd, HC_ATL_PTD_DONEMAP);
1611 	isp1760_hcd_clear(hcd, HC_INT_PTD_DONEMAP);
1612 	isp1760_hcd_clear(hcd, HC_ISO_PTD_DONEMAP);
1614 	isp1760_hcd_set(hcd, HW_OTG_DISABLE);
1619 	isp1760_hcd_set(hcd, HC_INT_IRQ_ENABLE);
1620 	isp1760_hcd_set(hcd, HC_ATL_IRQ_ENABLE);
1622 	isp1760_hcd_set(hcd, HW_GLOBAL_INTR_EN);
1624 	isp1760_hcd_clear(hcd, HC_ATL_IRQ_MASK_AND);
1625 	isp1760_hcd_clear(hcd, HC_INT_IRQ_MASK_AND);
1626 	isp1760_hcd_clear(hcd, HC_ISO_IRQ_MASK_AND);
1628 	isp1760_hcd_set(hcd, HC_ATL_IRQ_MASK_OR);
1629 	isp1760_hcd_set(hcd, HC_INT_IRQ_MASK_OR);
1630 	isp1760_hcd_set(hcd, HC_ISO_IRQ_MASK_OR);
1635 	isp1760_hcd_write(hcd, HC_ATL_PTD_LASTPTD, ptd_atl_int);
1636 	isp1760_hcd_write(hcd, HC_INT_PTD_LASTPTD, ptd_atl_int);
1637 	isp1760_hcd_write(hcd, HC_ISO_PTD_LASTPTD, ptd_iso);
1639 	isp1760_hcd_set(hcd, ATL_BUF_FILL);
1640 	isp1760_hcd_set(hcd, INT_BUF_FILL);
1642 	isp1760_hcd_clear(hcd, CMD_LRESET);
1643 	isp1760_hcd_clear(hcd, CMD_RESET);
1645 	retval = isp1760_hcd_set_and_wait(hcd, CMD_RUN, 250 * 1000);
1650 	retval = isp1760_hcd_set_and_wait(hcd, FLAG_CF, 250 * 1000);
1658 static int isp1760_run(struct usb_hcd *hcd)
1660 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
1674 		return isp1763_run(hcd);
1676 	hcd->uses_new_polling = 1;
1678 	hcd->state = HC_STATE_RUNNING;
1681 	isp1760_hcd_clear(hcd, HC_ATL_IRQ_MASK_AND);
1682 	isp1760_hcd_clear(hcd, HC_INT_IRQ_MASK_AND);
1683 	isp1760_hcd_clear(hcd, HC_ISO_IRQ_MASK_AND);
1685 	isp1760_hcd_set(hcd, HC_ATL_IRQ_MASK_OR);
1686 	isp1760_hcd_set(hcd, HC_INT_IRQ_MASK_OR);
1687 	isp1760_hcd_set(hcd, HC_ISO_IRQ_MASK_OR);
1691 	isp1760_hcd_set(hcd, HW_GLOBAL_INTR_EN);
1693 	isp1760_hcd_clear(hcd, CMD_LRESET);
1694 	isp1760_hcd_clear(hcd, CMD_RESET);
1696 	retval = isp1760_hcd_set_and_wait(hcd, CMD_RUN, 250 * 1000);
1707 	retval = isp1760_hcd_set_and_wait(hcd, FLAG_CF, 250 * 1000);
1712 	errata2_timer_hcd = hcd;
1717 	chipid_h = isp1760_hcd_read(hcd, HC_CHIP_ID_HIGH);
1718 	chipid_l = isp1760_hcd_read(hcd, HC_CHIP_ID_LOW);
1719 	chip_rev = isp1760_hcd_read(hcd, HC_CHIP_REV);
1720 	dev_info(hcd->self.controller, "USB ISP %02x%02x HW rev. %d started\n",
1729 	isp1760_hcd_write(hcd, HC_ATL_PTD_LASTPTD, ptd_atl_int);
1730 	isp1760_hcd_write(hcd, HC_INT_PTD_LASTPTD, ptd_atl_int);
1731 	isp1760_hcd_write(hcd, HC_ISO_PTD_LASTPTD, ptd_iso);
1733 	isp1760_hcd_set(hcd, HC_ATL_PTD_SKIPMAP);
1734 	isp1760_hcd_set(hcd, HC_INT_PTD_SKIPMAP);
1735 	isp1760_hcd_set(hcd, HC_ISO_PTD_SKIPMAP);
1737 	isp1760_hcd_set(hcd, ATL_BUF_FILL);
1738 	isp1760_hcd_set(hcd, INT_BUF_FILL);
1770 static void packetize_urb(struct usb_hcd *hcd,
1773 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
1786 		dev_err(hcd->self.controller,
1878 static int isp1760_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
1881 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
1903 		dev_err(hcd->self.controller, "%s: isochronous USB packets "
1908 		dev_err(hcd->self.controller, "%s: unknown pipe type\n",
1916 	packetize_urb(hcd, urb, &new_qtds, mem_flags);
1922 	if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
1927 	retval = usb_hcd_link_urb_to_ep(hcd, urb);
1948 			usb_hcd_unlink_urb_from_ep(hcd, urb);
1957 	schedule_ptds(hcd);
1964 static void kill_transfer(struct usb_hcd *hcd, struct urb *urb,
1967 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
1976 			skip_map = isp1760_hcd_read(hcd, HC_ATL_PTD_SKIPMAP);
1978 			isp1760_hcd_write(hcd, HC_ATL_PTD_SKIPMAP, skip_map);
1985 			skip_map = isp1760_hcd_read(hcd, HC_INT_PTD_SKIPMAP);
1987 			isp1760_hcd_write(hcd, HC_INT_PTD_SKIPMAP, skip_map);
2000 static void dequeue_urb_from_qtd(struct usb_hcd *hcd, struct isp1760_qh *qh,
2019 			kill_transfer(hcd, urb, qh);
2031 static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
2034 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
2041 	retval = usb_hcd_check_unlink_urb(hcd, urb, status);
2053 			dequeue_urb_from_qtd(hcd, qh, qtd);
2059 	schedule_ptds(hcd);
2066 static void isp1760_endpoint_disable(struct usb_hcd *hcd,
2069 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
2092 	schedule_ptds(hcd);
2098 static int isp1760_hub_status_data(struct usb_hcd *hcd, char *buf)
2100 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
2106 	if (!HC_IS_RUNNING(hcd->state))
2114 	if (isp1760_hcd_is_set(hcd, PORT_OWNER) &&
2115 	    isp1760_hcd_is_set(hcd, PORT_CSC)) {
2116 		isp1760_hcd_clear(hcd, PORT_CSC);
2126 	if (isp1760_hcd_is_set(hcd, PORT_CSC) ||
2127 	    (isp1760_hcd_is_set(hcd, PORT_RESUME) &&
2144 	ports = isp1760_hcd_n_ports(priv->hcd);
2161 	if (isp1760_hcd_ppc_is_set(priv->hcd))
2172 static void check_reset_complete(struct usb_hcd *hcd, int index)
2174 	if (!(isp1760_hcd_is_set(hcd, PORT_CONNECT)))
2178 	if (!isp1760_hcd_is_set(hcd, PORT_PE)) {
2179 		dev_info(hcd->self.controller,
2182 		isp1760_hcd_set(hcd, PORT_OWNER);
2184 		isp1760_hcd_clear(hcd, PORT_CSC);
2186 		dev_info(hcd->self.controller, "port %d high speed\n",
2193 static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
2196 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
2202 	ports = isp1760_hcd_n_ports(hcd);
2237 			isp1760_hcd_clear(hcd, PORT_PE);
2243 			if (isp1760_hcd_is_set(hcd, PORT_RESET))
2246 			if (isp1760_hcd_is_set(hcd, PORT_SUSPEND)) {
2247 				if (!isp1760_hcd_is_set(hcd, PORT_PE))
2250 				isp1760_hcd_clear(hcd, PORT_CSC);
2251 				isp1760_hcd_set(hcd, PORT_RESUME);
2261 			if (isp1760_hcd_ppc_is_set(hcd))
2262 				isp1760_hcd_clear(hcd, PORT_POWER);
2265 			isp1760_hcd_set(hcd, PORT_CSC);
2276 		isp1760_hcd_read(hcd, CMD_RUN);
2293 		if (isp1760_hcd_is_set(hcd, PORT_CSC))
2297 		if (isp1760_hcd_is_set(hcd, PORT_RESUME)) {
2298 			dev_err(hcd->self.controller, "Port resume should be skipped.\n");
2306 				mod_timer(&hcd->rh_timer, priv->reset_done);
2316 				isp1760_hcd_clear(hcd, PORT_CSC);
2318 				retval = isp1760_hcd_clear_and_wait(hcd,
2321 					dev_err(hcd->self.controller,
2330 		if (isp1760_hcd_is_set(hcd, PORT_RESET) &&
2339 			retval = isp1760_hcd_clear_and_wait(hcd, PORT_RESET,
2342 				dev_err(hcd->self.controller, "port %d reset error %d\n",
2348 			check_reset_complete(hcd, wIndex);
2356 		if (isp1760_hcd_is_set(hcd, PORT_OWNER))
2357 			dev_err(hcd->self.controller, "PORT_OWNER is set\n");
2359 		if (isp1760_hcd_is_set(hcd, PORT_CONNECT)) {
2364 		if (isp1760_hcd_is_set(hcd, PORT_PE))
2366 		if (isp1760_hcd_is_set(hcd, PORT_SUSPEND) &&
2367 		    isp1760_hcd_is_set(hcd, PORT_RESUME))
2369 		if (isp1760_hcd_is_set(hcd, PORT_RESET))
2371 		if (isp1760_hcd_is_set(hcd, PORT_POWER))
2392 		if (isp1760_hcd_is_set(hcd, PORT_OWNER))
2397 			isp1760_hcd_set(hcd, PORT_PE);
2401 			if (!isp1760_hcd_is_set(hcd, PORT_PE) ||
2402 			    isp1760_hcd_is_set(hcd, PORT_RESET))
2405 			isp1760_hcd_set(hcd, PORT_SUSPEND);
2408 			if (isp1760_hcd_ppc_is_set(hcd))
2409 				isp1760_hcd_set(hcd, PORT_POWER);
2412 			if (isp1760_hcd_is_set(hcd, PORT_RESUME))
2418 			if ((isp1760_hcd_is_set(hcd, PORT_CONNECT) &&
2419 			     !isp1760_hcd_is_set(hcd, PORT_PE)) &&
2420 			    (isp1760_hcd_read(hcd, PORT_LSTATUS) == 1)) {
2421 				isp1760_hcd_set(hcd, PORT_OWNER);
2423 				isp1760_hcd_set(hcd, PORT_RESET);
2424 				isp1760_hcd_clear(hcd, PORT_PE);
2448 static int isp1760_get_frame(struct usb_hcd *hcd)
2450 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
2453 	fr = isp1760_hcd_read(hcd, HC_FRINDEX);
2457 static void isp1760_stop(struct usb_hcd *hcd)
2459 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
2463 	isp1760_hub_control(hcd, ClearPortFeature, USB_PORT_FEAT_POWER,	1,
2468 	ehci_reset(hcd);
2470 	isp1760_hcd_clear(hcd, HW_GLOBAL_INTR_EN);
2473 	isp1760_hcd_clear(hcd, FLAG_CF);
2476 static void isp1760_shutdown(struct usb_hcd *hcd)
2478 	isp1760_stop(hcd);
2480 	isp1760_hcd_clear(hcd, HW_GLOBAL_INTR_EN);
2482 	isp1760_hcd_clear(hcd, CMD_RUN);
2485 static void isp1760_clear_tt_buffer_complete(struct usb_hcd *hcd,
2488 	struct isp1760_hcd *priv = hcd_to_priv(hcd);
2497 	schedule_ptds(hcd);
2503 	.description		= "isp1760-hcd",
2564 	struct usb_hcd *hcd;
2567 	hcd = usb_create_hcd(&isp1760_hc_driver, dev, dev_name(dev));
2568 	if (!hcd)
2571 	*(struct isp1760_hcd **)hcd->hcd_priv = priv;
2573 	priv->hcd = hcd;
2591 	hcd->irq = irq;
2592 	hcd->rsrc_start = mem->start;
2593 	hcd->rsrc_len = resource_size(mem);
2596 	hcd->cant_recv_wakeups = 1;
2598 	ret = usb_add_hcd(hcd, irq, irqflags);
2602 	device_wakeup_enable(hcd->self.controller);
2611 	usb_put_hcd(hcd);
2617 	if (!priv->hcd)
2620 	usb_remove_hcd(priv->hcd);
2621 	usb_put_hcd(priv->hcd);