Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 032ec49f authored by Felipe Balbi's avatar Felipe Balbi
Browse files

usb: musb: drop useless board_mode usage 



we are compiling the driver always with full OTG
capabilities, so that board_mode trick becomes
useless.

Signed-off-by: default avatarFelipe Balbi <balbi@ti.com>
parent 4f3e8d26

drivers/usb/musb/am35x.c

+7 −17
Original line number Diff line number Diff line
@@ -107,7 +107,6 @@ static void am35x_musb_enable(struct musb *musb) 
	musb_writel(reg_base, CORE_INTR_MASK_SET_REG, AM35X_INTR_USB_MASK);



	/* Force the DRVVBUS IRQ so we can start polling for ID change. */

	if (is_otg_enabled(musb))

	musb_writel(reg_base, CORE_INTR_SRC_SET_REG,

			AM35X_INTR_DRVVBUS << AM35X_INTR_USB_SHIFT);

}
@@ -173,9 +172,6 @@ static void otg_timer(unsigned long _musb) 
			    MUSB_INTR_VBUSERROR << AM35X_INTR_USB_SHIFT);

		break;

	case OTG_STATE_B_IDLE:

		if (!is_peripheral_enabled(musb))

			break;



		devctl = musb_readb(mregs, MUSB_DEVCTL);

		if (devctl & MUSB_DEVCTL_BDEVICE)

			mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
@@ -192,9 +188,6 @@ static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout) 
{

	static unsigned long last_timer;



	if (!is_otg_enabled(musb))

		return;



	if (timeout == 0)

		timeout = jiffies + msecs_to_jiffies(3);
@@ -271,8 +264,7 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci) 
		u8 devctl = musb_readb(mregs, MUSB_DEVCTL);

		int err;



		err = is_host_enabled(musb) && (musb->int_usb &

						MUSB_INTR_VBUSERROR);

		err = musb->int_usb & MUSB_INTR_VBUSERROR;

		if (err) {

			/*

			 * The Mentor core doesn't debounce VBUS as needed
@@ -289,7 +281,7 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci) 
			musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;

			mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);

			WARNING("VBUS error workaround (delay coming)\n");

		} else if (is_host_enabled(musb) && drvvbus) {

		} else if (drvvbus) {

			MUSB_HST_MODE(musb);

			otg->default_a = 1;

			musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -326,7 +318,7 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci) 
	}



	/* Poll for ID change */

	if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)

	if (musb->xceiv->state == OTG_STATE_B_IDLE)

		mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);



	spin_unlock_irqrestore(&musb->lock, flags);
@@ -369,7 +361,6 @@ static int am35x_musb_init(struct musb *musb) 
	if (IS_ERR_OR_NULL(musb->xceiv))

		return -ENODEV;



	if (is_host_enabled(musb))

	setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);



	/* Reset the musb */
@@ -400,7 +391,6 @@ static int am35x_musb_exit(struct musb *musb) 
	struct musb_hdrc_platform_data *plat = dev->platform_data;

	struct omap_musb_board_data *data = plat->board_data;



	if (is_host_enabled(musb))

	del_timer_sync(&otg_workaround);



	/* Shutdown the on-chip PHY and its PLL. */

drivers/usb/musb/blackfin.c

+10 −27
Original line number Diff line number Diff line
@@ -184,8 +184,8 @@ static irqreturn_t blackfin_interrupt(int irq, void *__hci) 
	}



	/* Start sampling ID pin, when plug is removed from MUSB */

	if ((is_otg_enabled(musb) && (musb->xceiv->state == OTG_STATE_B_IDLE

		|| musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) ||

	if ((musb->xceiv->state == OTG_STATE_B_IDLE

		|| musb->xceiv->state == OTG_STATE_A_WAIT_BCON) ||

		(musb->int_usb & MUSB_INTR_DISCONNECT && is_host_active(musb))) {

		mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);

		musb->a_wait_bcon = TIMER_DELAY;
@@ -228,18 +228,13 @@ static void musb_conn_timer_handler(unsigned long _musb) 


			val = MUSB_INTR_SUSPEND | MUSB_INTR_VBUSERROR;

			musb_writeb(musb->mregs, MUSB_INTRUSB, val);

			if (is_otg_enabled(musb))

			musb->xceiv->state = OTG_STATE_B_IDLE;

			else

				musb_writeb(musb->mregs, MUSB_POWER, MUSB_POWER_HSENAB);

		}

		mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);

		break;

	case OTG_STATE_B_IDLE:



		if (!is_peripheral_enabled(musb))

			break;

		/* Start a new session.  It seems that MUSB needs taking

		/*

		 * Start a new session.  It seems that MUSB needs taking

		 * some time to recognize the type of the plug inserted?

		 */

		val = musb_readw(musb->mregs, MUSB_DEVCTL);
@@ -295,10 +290,7 @@ static void musb_conn_timer_handler(unsigned long _musb) 


static void bfin_musb_enable(struct musb *musb)

{

	if (!is_otg_enabled(musb) && is_host_enabled(musb)) {

		mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);

		musb->a_wait_bcon = TIMER_DELAY;

	}

	/* REVISIT is this really correct ? */

}



static void bfin_musb_disable(struct musb *musb)
@@ -323,12 +315,6 @@ static int bfin_musb_set_power(struct usb_phy *x, unsigned mA) 
	return 0;

}



static void bfin_musb_try_idle(struct musb *musb, unsigned long timeout)

{

	if (!is_otg_enabled(musb) && is_host_enabled(musb))

		mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);

}



static int bfin_musb_vbus_status(struct musb *musb)

{

	return 0;
@@ -424,11 +410,9 @@ static int bfin_musb_init(struct musb *musb) 


	bfin_musb_reg_init(musb);



	if (is_host_enabled(musb)) {

		setup_timer(&musb_conn_timer,

			musb_conn_timer_handler, (unsigned long) musb);

	}

	if (is_peripheral_enabled(musb))

	setup_timer(&musb_conn_timer, musb_conn_timer_handler,

			(unsigned long) musb);



	musb->xceiv->set_power = bfin_musb_set_power;



	musb->isr = blackfin_interrupt;
@@ -454,7 +438,6 @@ static const struct musb_platform_ops bfin_ops = { 
	.disable	= bfin_musb_disable,



	.set_mode	= bfin_musb_set_mode,

	.try_idle	= bfin_musb_try_idle,



	.vbus_status	= bfin_musb_vbus_status,

	.set_vbus	= bfin_musb_set_vbus,

drivers/usb/musb/da8xx.c

+7 −17
Original line number Diff line number Diff line
@@ -155,7 +155,6 @@ static void da8xx_musb_enable(struct musb *musb) 
	musb_writel(reg_base, DA8XX_USB_INTR_MASK_SET_REG, mask);



	/* Force the DRVVBUS IRQ so we can start polling for ID change. */

	if (is_otg_enabled(musb))

	musb_writel(reg_base, DA8XX_USB_INTR_SRC_SET_REG,

			DA8XX_INTR_DRVVBUS << DA8XX_INTR_USB_SHIFT);

}
@@ -231,9 +230,6 @@ static void otg_timer(unsigned long _musb) 
			    MUSB_INTR_VBUSERROR << DA8XX_INTR_USB_SHIFT);

		break;

	case OTG_STATE_B_IDLE:

		if (!is_peripheral_enabled(musb))

			break;



		/*

		 * There's no ID-changed IRQ, so we have no good way to tell

		 * when to switch to the A-Default state machine (by setting
@@ -263,9 +259,6 @@ static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout) 
{

	static unsigned long last_timer;



	if (!is_otg_enabled(musb))

		return;



	if (timeout == 0)

		timeout = jiffies + msecs_to_jiffies(3);
@@ -333,8 +326,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci) 
		u8 devctl = musb_readb(mregs, MUSB_DEVCTL);

		int err;



		err = is_host_enabled(musb) && (musb->int_usb &

						MUSB_INTR_VBUSERROR);

		err = musb->int_usb & USB_INTR_VBUSERROR;

		if (err) {

			/*

			 * The Mentor core doesn't debounce VBUS as needed
@@ -351,7 +343,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci) 
			musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;

			mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);

			WARNING("VBUS error workaround (delay coming)\n");

		} else if (is_host_enabled(musb) && drvvbus) {

		} else if (drvvbus) {

			MUSB_HST_MODE(musb);

			otg->default_a = 1;

			musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -382,7 +374,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci) 
		musb_writel(reg_base, DA8XX_USB_END_OF_INTR_REG, 0);



	/* Poll for ID change */

	if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)

	if (musb->xceiv->state == OTG_STATE_B_IDLE)

		mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);



	spin_unlock_irqrestore(&musb->lock, flags);
@@ -430,7 +422,6 @@ static int da8xx_musb_init(struct musb *musb) 
	if (IS_ERR_OR_NULL(musb->xceiv))

		goto fail;



	if (is_host_enabled(musb))

	setup_timer(&otg_workaround, otg_timer, (unsigned long)musb);



	/* Reset the controller */
@@ -454,7 +445,6 @@ static int da8xx_musb_init(struct musb *musb) 


static int da8xx_musb_exit(struct musb *musb)

{

	if (is_host_enabled(musb))

	del_timer_sync(&otg_workaround);



	phy_off();

drivers/usb/musb/davinci.c

+10 −22
Original line number Diff line number Diff line
@@ -115,7 +115,6 @@ static void davinci_musb_enable(struct musb *musb) 
		dma_off = 0;



	/* force a DRVVBUS irq so we can start polling for ID change */

	if (is_otg_enabled(musb))

	musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,

			DAVINCI_INTR_DRVVBUS << DAVINCI_USB_USBINT_SHIFT);

}
@@ -234,10 +233,8 @@ static void otg_timer(unsigned long _musb) 
			MUSB_INTR_VBUSERROR << DAVINCI_USB_USBINT_SHIFT);

		break;

	case OTG_STATE_B_IDLE:

		if (!is_peripheral_enabled(musb))

			break;



		/* There's no ID-changed IRQ, so we have no good way to tell

		/*

		 * There's no ID-changed IRQ, so we have no good way to tell

		 * when to switch to the A-Default state machine (by setting

		 * the DEVCTL.SESSION flag).

		 *
@@ -315,8 +312,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci) 
		u8	devctl = musb_readb(mregs, MUSB_DEVCTL);

		int	err = musb->int_usb & MUSB_INTR_VBUSERROR;



		err = is_host_enabled(musb)

				&& (musb->int_usb & MUSB_INTR_VBUSERROR);

		err = musb->int_usb & MUSB_INTR_VBUSERROR;

		if (err) {

			/* The Mentor core doesn't debounce VBUS as needed

			 * to cope with device connect current spikes. This
@@ -332,7 +328,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci) 
			musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;

			mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);

			WARNING("VBUS error workaround (delay coming)\n");

		} else if (is_host_enabled(musb) && drvvbus) {

		} else if (drvvbus) {

			MUSB_HST_MODE(musb);

			otg->default_a = 1;

			musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -365,8 +361,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci) 
	musb_writel(tibase, DAVINCI_USB_EOI_REG, 0);



	/* poll for ID change */

	if (is_otg_enabled(musb)

			&& musb->xceiv->state == OTG_STATE_B_IDLE)

	if (musb->xceiv->state == OTG_STATE_B_IDLE)

		mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);



	spin_unlock_irqrestore(&musb->lock, flags);
@@ -397,7 +392,6 @@ static int davinci_musb_init(struct musb *musb) 
	if (revision == 0)

		goto fail;



	if (is_host_enabled(musb))

	setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);



	davinci_musb_source_power(musb, 0, 1);
@@ -419,12 +413,7 @@ static int davinci_musb_init(struct musb *musb) 
	if (cpu_is_davinci_dm355()) {

		u32	deepsleep = __raw_readl(DM355_DEEPSLEEP);



		if (is_host_enabled(musb)) {

			deepsleep &= ~DRVVBUS_OVERRIDE;

		} else {

		deepsleep &= ~DRVVBUS_FORCE;

			deepsleep |= DRVVBUS_OVERRIDE;

		}

		__raw_writel(deepsleep, DM355_DEEPSLEEP);

	}
@@ -453,7 +442,6 @@ static int davinci_musb_init(struct musb *musb) 


static int davinci_musb_exit(struct musb *musb)

{

	if (is_host_enabled(musb))

	del_timer_sync(&otg_workaround);



	/* force VBUS off */
@@ -468,7 +456,7 @@ static int davinci_musb_exit(struct musb *musb) 
	davinci_musb_source_power(musb, 0 /*off*/, 1);



	/* delay, to avoid problems with module reload */

	if (is_host_enabled(musb) && musb->xceiv->otg->default_a) {

	if (musb->xceiv->otg->default_a) {

		int	maxdelay = 30;

		u8	devctl, warn = 0;

drivers/usb/musb/musb_core.c

+71 −139
Original line number Diff line number Diff line
@@ -649,8 +649,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, 
				break;

		case OTG_STATE_B_PERIPHERAL:

			musb_g_suspend(musb);

			musb->is_active = is_otg_enabled(musb)

					&& otg->gadget->b_hnp_enable;

			musb->is_active = otg->gadget->b_hnp_enable;

			if (musb->is_active) {

				musb->xceiv->state = OTG_STATE_B_WAIT_ACON;

				dev_dbg(musb->controller, "HNP: Setting timer for b_ase0_brst\n");
@@ -666,8 +665,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, 
			break;

		case OTG_STATE_A_HOST:

			musb->xceiv->state = OTG_STATE_A_SUSPEND;

			musb->is_active = is_otg_enabled(musb)

					&& otg->host->b_hnp_enable;

			musb->is_active = otg->host->b_hnp_enable;

			break;

		case OTG_STATE_B_HOST:

			/* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */
@@ -755,7 +753,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, 
		case OTG_STATE_A_SUSPEND:

			usb_hcd_resume_root_hub(musb_to_hcd(musb));

			musb_root_disconnect(musb);

			if (musb->a_wait_bcon != 0 && is_otg_enabled(musb))

			if (musb->a_wait_bcon != 0)

				musb_platform_try_idle(musb, jiffies

					+ msecs_to_jiffies(musb->a_wait_bcon));

			break;
@@ -931,7 +929,6 @@ void musb_start(struct musb *musb) 
	devctl = musb_readb(regs, MUSB_DEVCTL);

	devctl &= ~MUSB_DEVCTL_SESSION;



	if (is_otg_enabled(musb)) {

	/* session started after:

	 * (a) ID-grounded irq, host mode;

	 * (b) vbus present/connect IRQ, peripheral mode;
@@ -942,14 +939,6 @@ void musb_start(struct musb *musb) 
	else

		devctl |= MUSB_DEVCTL_SESSION;



	} else if (is_host_enabled(musb)) {

		/* assume ID pin is hard-wired to ground */

		devctl |= MUSB_DEVCTL_SESSION;



	} else /* peripheral is enabled */ {

		if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)

			musb->is_active = 1;

	}

	musb_platform_enable(musb);

	musb_writeb(regs, MUSB_DEVCTL, devctl);

}
@@ -1013,8 +1002,6 @@ static void musb_shutdown(struct platform_device *pdev) 
	musb_generic_disable(musb);

	spin_unlock_irqrestore(&musb->lock, flags);



	if (!is_otg_enabled(musb) && is_host_enabled(musb))

		usb_remove_hcd(musb_to_hcd(musb));

	musb_writeb(musb->mregs, MUSB_DEVCTL, 0);

	musb_platform_exit(musb);
@@ -1885,6 +1872,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl) 
	int			status;

	struct musb		*musb;

	struct musb_hdrc_platform_data *plat = dev->platform_data;

	struct usb_hcd		*hcd;



	/* The driver might handle more features than the board; OK.

	 * Fail when the board needs a feature that's not enabled.
@@ -1907,7 +1895,6 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl) 
	pm_runtime_enable(musb->controller);



	spin_lock_init(&musb->lock);

	musb->board_mode = plat->mode;

	musb->board_set_power = plat->set_power;

	musb->min_power = plat->min_power;

	musb->ops = plat->platform_ops;
@@ -1987,12 +1974,8 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl) 
	}



	/* host side needs more setup */

	if (is_host_enabled(musb)) {

		struct usb_hcd	*hcd = musb_to_hcd(musb);



	hcd = musb_to_hcd(musb);

	otg_set_host(musb->xceiv->otg, &hcd->self);



		if (is_otg_enabled(musb))

	hcd->self.otg_port = 1;

	musb->xceiv->otg->host = &hcd->self;

	hcd->power_budget = 2 * (plat->power ? : 250);
@@ -2003,42 +1986,13 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl) 
		busctl |= MUSB_ULPI_USE_EXTVBUS;

		musb_write_ulpi_buscontrol(musb->mregs, busctl);

	}

	}



	/* For the host-only role, we can activate right away.

	 * (We expect the ID pin to be forcibly grounded!!)

	 * Otherwise, wait till the gadget driver hooks up.

	 */

	if (!is_otg_enabled(musb) && is_host_enabled(musb)) {

		struct usb_hcd	*hcd = musb_to_hcd(musb);



		MUSB_HST_MODE(musb);

		musb->xceiv->otg->default_a = 1;

		musb->xceiv->state = OTG_STATE_A_IDLE;



		status = usb_add_hcd(musb_to_hcd(musb), 0, 0);



		hcd->self.uses_pio_for_control = 1;

		dev_dbg(musb->controller, "%s mode, status %d, devctl %02x %c\n",

			"HOST", status,

			musb_readb(musb->mregs, MUSB_DEVCTL),

			(musb_readb(musb->mregs, MUSB_DEVCTL)

					& MUSB_DEVCTL_BDEVICE

				? 'B' : 'A'));



	} else /* peripheral is enabled */ {

	MUSB_DEV_MODE(musb);

	musb->xceiv->otg->default_a = 0;

	musb->xceiv->state = OTG_STATE_B_IDLE;



	status = musb_gadget_setup(musb);



		dev_dbg(musb->controller, "%s mode, status %d, dev%02x\n",

			is_otg_enabled(musb) ? "OTG" : "PERIPHERAL",

			status,

			musb_readb(musb->mregs, MUSB_DEVCTL));



	}

	if (status < 0)

		goto fail3;
@@ -2054,27 +2008,12 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl) 


	pm_runtime_put(musb->controller);



	dev_info(dev, "USB %s mode controller at %p using %s, IRQ %d\n",

			({char *s;

			 switch (musb->board_mode) {

			 case MUSB_HOST:		s = "Host"; break;

			 case MUSB_PERIPHERAL:	s = "Peripheral"; break;

			 default:		s = "OTG"; break;

			 }; s; }),

			ctrl,

			(is_dma_capable() && musb->dma_controller)

			? "DMA" : "PIO",

			musb->nIrq);



	return 0;



fail5:

	musb_exit_debugfs(musb);



fail4:

	if (!is_otg_enabled(musb) && is_host_enabled(musb))

		usb_remove_hcd(musb_to_hcd(musb));

	else

	musb_gadget_cleanup(musb);



fail3:
@@ -2166,11 +2105,9 @@ static void musb_save_context(struct musb *musb) 
	void __iomem *musb_base = musb->mregs;

	void __iomem *epio;



	if (is_host_enabled(musb)) {

	musb->context.frame = musb_readw(musb_base, MUSB_FRAME);

	musb->context.testmode = musb_readb(musb_base, MUSB_TESTMODE);

	musb->context.busctl = musb_read_ulpi_buscontrol(musb->mregs);

	}

	musb->context.power = musb_readb(musb_base, MUSB_POWER);

	musb->context.intrtxe = musb_readw(musb_base, MUSB_INTRTXE);

	musb->context.intrrxe = musb_readw(musb_base, MUSB_INTRRXE);
@@ -2209,7 +2146,7 @@ static void musb_save_context(struct musb *musb) 
			musb->context.index_regs[i].rxfifosz =

					musb_read_rxfifosz(musb_base);

		}

		if (is_host_enabled(musb)) {



		musb->context.index_regs[i].txtype =

			musb_readb(epio, MUSB_TXTYPE);

		musb->context.index_regs[i].txinterval =
@@ -2234,7 +2171,6 @@ static void musb_save_context(struct musb *musb) 
			musb_read_rxhubport(musb_base, i);

	}

}

}



static void musb_restore_context(struct musb *musb)

{
@@ -2243,11 +2179,9 @@ static void musb_restore_context(struct musb *musb) 
	void __iomem *ep_target_regs;

	void __iomem *epio;



	if (is_host_enabled(musb)) {

	musb_writew(musb_base, MUSB_FRAME, musb->context.frame);

	musb_writeb(musb_base, MUSB_TESTMODE, musb->context.testmode);

	musb_write_ulpi_buscontrol(musb->mregs, musb->context.busctl);

	}

	musb_writeb(musb_base, MUSB_POWER, musb->context.power);

	musb_writew(musb_base, MUSB_INTRTXE, musb->context.intrtxe);

	musb_writew(musb_base, MUSB_INTRRXE, musb->context.intrrxe);
@@ -2286,7 +2220,6 @@ static void musb_restore_context(struct musb *musb) 
				musb->context.index_regs[i].rxfifoadd);

		}



		if (is_host_enabled(musb)) {

		musb_writeb(epio, MUSB_TXTYPE,

				musb->context.index_regs[i].txtype);

		musb_writeb(epio, MUSB_TXINTERVAL,
@@ -2313,7 +2246,6 @@ static void musb_restore_context(struct musb *musb) 
		musb_write_rxhubport(ep_target_regs,

				musb->context.index_regs[i].rxhubport);

	}

	}

	musb_writeb(musb_base, MUSB_INDEX, musb->context.index);

}