usb/musb/musb_dsps.c

40  * DSPS musb wrapper register offset.
42  * musb ips.
104 	struct platform_device *musb;	/* child musb pdev */
136 	struct musb *musb = platform_get_drvdata(glue->musb);
144 	mod_timer(&musb->dev_timer, jiffies + wait);
168 static void dsps_musb_enable(struct musb *musb)
170 	struct device *dev = musb->controller;
173 	void __iomem *reg_base = musb->ctrl_base;
177 	epmask = ((musb->epmask & wrp->txep_mask) << wrp->txep_shift) |
178 	       ((musb->epmask & wrp->rxep_mask) << wrp->rxep_shift);
187 	if (musb->xceiv->otg->state == OTG_STATE_B_IDLE)
194 static void dsps_musb_disable(struct musb *musb)
196 	struct device *dev = musb->controller;
199 	void __iomem *reg_base = musb->ctrl_base;
204 	timer_delete_sync(&musb->dev_timer);
207 /* Caller must take musb->lock */
208 static int dsps_check_status(struct musb *musb, void *unused)
210 	void __iomem *mregs = musb->mregs;
211 	struct device *dev = musb->controller;
218 		timer_delete(&musb->dev_timer);
225 	dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,
226 				usb_otg_state_string(musb->xceiv->otg->state));
228 	switch (musb->xceiv->otg->state) {
230 		if (musb->port_mode == MUSB_HOST) {
231 			musb->xceiv->otg->state = OTG_STATE_A_WAIT_BCON;
239 		if (musb->port_mode == MUSB_HOST) {
243 		musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
251 				musb->xceiv->otg->state = OTG_STATE_B_IDLE;
252 				MUSB_DEV_MODE(musb);
254 				musb->xceiv->otg->state = OTG_STATE_A_IDLE;
255 				MUSB_HST_MODE(musb);
258 			if (musb->port_mode == MUSB_PERIPHERAL)
268 		musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
269 		musb_writel(musb->ctrl_base, wrp->coreintr_set,
281 	struct musb *musb = timer_container_of(musb, t, dev_timer);
282 	struct device *dev = musb->controller;
294 	spin_lock_irqsave(&musb->lock, flags);
295 	err = musb_queue_resume_work(musb, dsps_check_status, NULL);
298 	spin_unlock_irqrestore(&musb->lock, flags);
303 static void dsps_musb_clear_ep_rxintr(struct musb *musb, int epnum)
306 	struct dsps_glue *glue = dev_get_drvdata(musb->controller->parent);
309 	/* musb->lock might already been held */
311 	musb_writel(musb->ctrl_base, wrp->epintr_status, epintr);
316 	struct musb  *musb = hci;
317 	void __iomem *reg_base = musb->ctrl_base;
318 	struct device *dev = musb->controller;
325 	spin_lock_irqsave(&musb->lock, flags);
329 	musb->int_rx = (epintr & wrp->rxep_bitmap) >> wrp->rxep_shift;
330 	musb->int_tx = (epintr & wrp->txep_bitmap) >> wrp->txep_shift;
340 	musb->int_usb =	(usbintr & wrp->usb_bitmap) >> wrp->usb_shift;
344 	dev_dbg(musb->controller, "usbintr (%x) epintr(%x)\n",
349 		void __iomem *mregs = musb->mregs;
353 		err = musb->int_usb & MUSB_INTR_VBUSERROR;
366 			musb->int_usb &= ~MUSB_INTR_VBUSERROR;
367 			musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL;
371 			MUSB_HST_MODE(musb);
372 			musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
375 			musb->is_active = 0;
376 			MUSB_DEV_MODE(musb);
377 			musb->xceiv->otg->state = OTG_STATE_B_IDLE;
381 		dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n",
383 				usb_otg_state_string(musb->xceiv->otg->state),
389 	if (musb->int_tx || musb->int_rx || musb->int_usb)
390 		ret |= musb_interrupt(musb);
393 	switch (musb->xceiv->otg->state) {
403 	spin_unlock_irqrestore(&musb->lock, flags);
408 static int dsps_musb_dbg_init(struct musb *musb, struct dsps_glue *glue)
413 	sprintf(buf, "%s.dsps", dev_name(musb->controller));
419 	glue->regset.base = musb->ctrl_base;
425 static int dsps_musb_init(struct musb *musb)
427 	struct device *dev = musb->controller;
440 	musb->ctrl_base = reg_base;
443 	musb->xceiv = devm_usb_get_phy_by_phandle(dev->parent, "phys", 0);
444 	if (IS_ERR(musb->xceiv))
445 		return PTR_ERR(musb->xceiv);
447 	musb->phy = devm_phy_get(dev->parent, "usb2-phy");
454 	if (IS_ERR(musb->phy))  {
455 		musb->phy = NULL;
457 		ret = phy_init(musb->phy);
460 		ret = phy_power_on(musb->phy);
462 			phy_exit(musb->phy);
467 	timer_setup(&musb->dev_timer, otg_timer, 0);
469 	/* Reset the musb */
472 	musb->isr = dsps_interrupt;
477 	musb_writel(musb->ctrl_base, wrp->phy_utmi, val);
485 	val = musb_readb(musb->mregs, MUSB_BABBLE_CTL);
489 		musb_writeb(musb->mregs, MUSB_BABBLE_CTL, val);
494 	return dsps_musb_dbg_init(musb, glue);
497 static int dsps_musb_exit(struct musb *musb)
499 	struct device *dev = musb->controller;
502 	timer_delete_sync(&musb->dev_timer);
503 	phy_power_off(musb->phy);
504 	phy_exit(musb->phy);
510 static int dsps_musb_set_mode(struct musb *musb, u8 mode)
512 	struct device *dev = musb->controller;
515 	void __iomem *ctrl_base = musb->ctrl_base;
557 static bool dsps_sw_babble_control(struct musb *musb)
562 	babble_ctl = musb_readb(musb->mregs, MUSB_BABBLE_CTL);
563 	dev_dbg(musb->controller, "babble: MUSB_BABBLE_CTL value %x\n",
569 	dev_dbg(musb->controller, "STUCK_J is %s\n",
579 		babble_ctl = musb_readb(musb->mregs, MUSB_BABBLE_CTL);
581 		musb_writeb(musb->mregs, MUSB_BABBLE_CTL, babble_ctl);
584 		dev_dbg(musb->controller, "Set TXIDLE, wait J to clear\n");
586 			babble_ctl = musb_readb(musb->mregs, MUSB_BABBLE_CTL);
597 			dev_dbg(musb->controller, "J not cleared, misc (%x)\n",
608 static int dsps_musb_recover(struct musb *musb)
610 	struct device *dev = musb->controller;
615 		session_restart = dsps_sw_babble_control(musb);
643 	struct musb *musb = c->musb;
644 	struct dsps_glue *glue = dev_get_drvdata(musb->controller->parent);
654 dsps_dma_controller_create(struct musb *musb, void __iomem *base)
657 	struct dsps_glue *glue = dev_get_drvdata(musb->controller->parent);
660 	controller = cppi41_dma_controller_create(musb, base);
730 	struct platform_device *musb;
752 	musb = platform_device_alloc("musb-hdrc",
754 	if (!musb) {
755 		dev_err(dev, "failed to allocate musb device\n");
759 	musb->dev.parent		= dev;
760 	musb->dev.dma_mask		= &musb_dmamask;
761 	musb->dev.coherent_dma_mask	= musb_dmamask;
762 	device_set_of_node_from_dev(&musb->dev, &parent->dev);
764 	glue->musb = musb;
766 	ret = platform_device_add_resources(musb, resources,
785 	/* DT keeps this entry in mA, musb expects it as per USB spec */
805 	ret = platform_device_add_data(musb, &pdata, sizeof(pdata));
811 	ret = platform_device_add(musb);
813 		dev_err(dev, "failed to register musb device\n");
819 	platform_device_put(musb);
826 	struct musb *musb = platform_get_drvdata(glue->musb);
828 	if (!musb)
871 	if (!strcmp(pdev->name, "musb-hdrc"))
881 	if (of_device_is_compatible(pdev->dev.of_node, "ti,musb-dm816"))
910 	platform_device_unregister(glue->musb);
921 	platform_device_unregister(glue->musb);
959 	{ .compatible = "ti,musb-am33xx",
961 	{ .compatible = "ti,musb-dm816",
972 	struct musb *musb = platform_get_drvdata(glue->musb);
976 	if (!musb)
977 		/* This can happen if the musb device is in -EPROBE_DEFER */
986 	timer_delete_sync(&musb->dev_timer);
988 	mbase = musb->ctrl_base;
1006 	struct musb *musb = platform_get_drvdata(glue->musb);
1009 	if (!musb)
1014 	mbase = musb->ctrl_base;
1022 	if (musb->xceiv->otg->state == OTG_STATE_B_IDLE &&
1023 	    musb->port_mode == MUSB_OTG)
1038 		.name   = "musb-dsps",