omap2430.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (C) 2005-2007 by Texas Instruments
  4 * Some code has been taken from tusb6010.c
  5 * Copyrights for that are attributable to:
  6 * Copyright (C) 2006 Nokia Corporation
  7 * Tony Lindgren <tony@atomide.com>
  8 *
  9 * This file is part of the Inventra Controller Driver for Linux.
 10 */
 11#include <linux/module.h>
 12#include <linux/kernel.h>
 13#include <linux/sched.h>
 14#include <linux/init.h>
 15#include <linux/list.h>
 16#include <linux/io.h>
 17#include <linux/of.h>
 18#include <linux/of_irq.h>
 19#include <linux/platform_device.h>
 20#include <linux/dma-mapping.h>
 21#include <linux/pm_runtime.h>
 22#include <linux/err.h>
 23#include <linux/delay.h>
 24#include <linux/usb/musb.h>
 25#include <linux/phy/omap_control_phy.h>
 26#include <linux/of_platform.h>
 27
 28#include "musb_core.h"
 29#include "omap2430.h"
 30
 31struct omap2430_glue {
 32	struct device		*dev;
 33	struct platform_device	*musb;
 34	enum musb_vbus_id_status status;
 35	struct work_struct	omap_musb_mailbox_work;
 36	struct device		*control_otghs;
 37	unsigned int		is_runtime_suspended:1;
 38	unsigned int		needs_resume:1;
 39	unsigned int		phy_suspended:1;
 40};
 41#define glue_to_musb(g)		platform_get_drvdata(g->musb)
 42
 43static struct omap2430_glue	*_glue;
 44
 45static inline void omap2430_low_level_exit(struct musb *musb)
 46{
 47	u32 l;
 48
 49	/* in any role */
 50	l = musb_readl(musb->mregs, OTG_FORCESTDBY);
 51	l |= ENABLEFORCE;	/* enable MSTANDBY */
 52	musb_writel(musb->mregs, OTG_FORCESTDBY, l);
 53}
 54
 55static inline void omap2430_low_level_init(struct musb *musb)
 56{
 57	u32 l;
 58
 59	l = musb_readl(musb->mregs, OTG_FORCESTDBY);
 60	l &= ~ENABLEFORCE;	/* disable MSTANDBY */
 61	musb_writel(musb->mregs, OTG_FORCESTDBY, l);
 62}
 63
 64static int omap2430_musb_mailbox(enum musb_vbus_id_status status)
 65{
 66	struct omap2430_glue	*glue = _glue;
 67
 68	if (!glue) {
 69		pr_err("%s: musb core is not yet initialized\n", __func__);
 70		return -EPROBE_DEFER;
 71	}
 72	glue->status = status;
 73
 74	if (!glue_to_musb(glue)) {
 75		pr_err("%s: musb core is not yet ready\n", __func__);
 76		return -EPROBE_DEFER;
 77	}
 78
 79	schedule_work(&glue->omap_musb_mailbox_work);
 80
 81	return 0;
 82}
 83
 84/*
 85 * HDRC controls CPEN, but beware current surges during device connect.
 86 * They can trigger transient overcurrent conditions that must be ignored.
 87 *
 88 * Note that we're skipping A_WAIT_VFALL -> A_IDLE and jumping right to B_IDLE
 89 * as set by musb_set_peripheral().
 90 */
 91static void omap_musb_set_mailbox(struct omap2430_glue *glue)
 92{
 93	struct musb *musb = glue_to_musb(glue);
 94	int error;
 95
 96	pm_runtime_get_sync(musb->controller);
 97
 98	dev_dbg(musb->controller, "VBUS %s, devctl %02x\n",
 99		usb_otg_state_string(musb->xceiv->otg->state),
100		musb_readb(musb->mregs, MUSB_DEVCTL));
101
102	switch (glue->status) {
103	case MUSB_ID_GROUND:
104		dev_dbg(musb->controller, "ID GND\n");
105		switch (musb->xceiv->otg->state) {
106		case OTG_STATE_A_IDLE:
107			error = musb_set_host(musb);
108			if (error)
109				break;
110			musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
111			fallthrough;
112		case OTG_STATE_A_WAIT_VRISE:
113		case OTG_STATE_A_WAIT_BCON:
114		case OTG_STATE_A_HOST:
115			/*
116			 * On multiple ID ground interrupts just keep enabling
117			 * VBUS. At least cpcap VBUS shuts down otherwise.
118			 */
119			otg_set_vbus(musb->xceiv->otg, 1);
120			break;
121		default:
122			musb->xceiv->otg->state = OTG_STATE_A_IDLE;
123			musb->xceiv->last_event = USB_EVENT_ID;
124			if (musb->gadget_driver) {
125				omap_control_usb_set_mode(glue->control_otghs,
126							  USB_MODE_HOST);
127				otg_set_vbus(musb->xceiv->otg, 1);
128			}
129			break;
130		}
131		break;
132
133	case MUSB_VBUS_VALID:
134		dev_dbg(musb->controller, "VBUS Connect\n");
135
136		musb->xceiv->otg->state = OTG_STATE_B_IDLE;
137		musb->xceiv->last_event = USB_EVENT_VBUS;
138		omap_control_usb_set_mode(glue->control_otghs, USB_MODE_DEVICE);
139		break;
140
141	case MUSB_ID_FLOAT:
142	case MUSB_VBUS_OFF:
143		dev_dbg(musb->controller, "VBUS Disconnect\n");
144
145		musb->xceiv->last_event = USB_EVENT_NONE;
146		musb_set_peripheral(musb);
147		otg_set_vbus(musb->xceiv->otg, 0);
148		omap_control_usb_set_mode(glue->control_otghs,
149			USB_MODE_DISCONNECT);
150		break;
151	default:
152		dev_dbg(musb->controller, "ID float\n");
153	}
154	pm_runtime_put_autosuspend(musb->controller);
155	atomic_notifier_call_chain(&musb->xceiv->notifier,
156			musb->xceiv->last_event, NULL);
157}
158
159
160static void omap_musb_mailbox_work(struct work_struct *mailbox_work)
161{
162	struct omap2430_glue *glue = container_of(mailbox_work,
163				struct omap2430_glue, omap_musb_mailbox_work);
164
165	omap_musb_set_mailbox(glue);
166}
167
168static irqreturn_t omap2430_musb_interrupt(int irq, void *__hci)
169{
170	unsigned long   flags;
171	irqreturn_t     retval = IRQ_NONE;
172	struct musb     *musb = __hci;
173
174	spin_lock_irqsave(&musb->lock, flags);
175
176	musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
177	musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);
178	musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);
179
180	if (musb->int_usb || musb->int_tx || musb->int_rx)
181		retval = musb_interrupt(musb);
182
183	spin_unlock_irqrestore(&musb->lock, flags);
184
185	return retval;
186}
187
188static int omap2430_musb_init(struct musb *musb)
189{
190	u32 l;
191	int status = 0;
192	struct device *dev = musb->controller;
193	struct musb_hdrc_platform_data *plat = dev_get_platdata(dev);
194	struct omap_musb_board_data *data = plat->board_data;
195
196	/* We require some kind of external transceiver, hooked
197	 * up through ULPI.  TWL4030-family PMICs include one,
198	 * which needs a driver, drivers aren't always needed.
199	 */
200	musb->phy = devm_phy_get(dev->parent, "usb2-phy");
201
202	/* We can't totally remove musb->xceiv as of now because
203	 * musb core uses xceiv.state and xceiv.otg. Once we have
204	 * a separate state machine to handle otg, these can be moved
205	 * out of xceiv and then we can start using the generic PHY
206	 * framework
207	 */
208	musb->xceiv = devm_usb_get_phy_by_phandle(dev->parent, "usb-phy", 0);
209
210	if (IS_ERR(musb->xceiv)) {
211		status = PTR_ERR(musb->xceiv);
212
213		if (status == -ENXIO)
214			return status;
215
216		dev_dbg(dev, "HS USB OTG: no transceiver configured\n");
217		return -EPROBE_DEFER;
218	}
219
220	if (IS_ERR(musb->phy)) {
221		dev_err(dev, "HS USB OTG: no PHY configured\n");
222		return PTR_ERR(musb->phy);
223	}
224	musb->isr = omap2430_musb_interrupt;
225	phy_init(musb->phy);
226	phy_power_on(musb->phy);
227
228	l = musb_readl(musb->mregs, OTG_INTERFSEL);
229
230	if (data->interface_type == MUSB_INTERFACE_UTMI) {
231		/* OMAP4 uses Internal PHY GS70 which uses UTMI interface */
232		l &= ~ULPI_12PIN;       /* Disable ULPI */
233		l |= UTMI_8BIT;         /* Enable UTMI  */
234	} else {
235		l |= ULPI_12PIN;
236	}
237
238	musb_writel(musb->mregs, OTG_INTERFSEL, l);
239
240	dev_dbg(dev, "HS USB OTG: revision 0x%x, sysconfig 0x%02x, "
241			"sysstatus 0x%x, intrfsel 0x%x, simenable  0x%x\n",
242			musb_readl(musb->mregs, OTG_REVISION),
243			musb_readl(musb->mregs, OTG_SYSCONFIG),
244			musb_readl(musb->mregs, OTG_SYSSTATUS),
245			musb_readl(musb->mregs, OTG_INTERFSEL),
246			musb_readl(musb->mregs, OTG_SIMENABLE));
247
248	return 0;
249}
250
251static void omap2430_musb_enable(struct musb *musb)
252{
253	struct device *dev = musb->controller;
254	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
255
256	if (glue->status == MUSB_UNKNOWN)
257		glue->status = MUSB_VBUS_OFF;
258	omap_musb_set_mailbox(glue);
259}
260
261static void omap2430_musb_disable(struct musb *musb)
262{
263	struct device *dev = musb->controller;
264	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
265
266	if (glue->status != MUSB_UNKNOWN)
267		omap_control_usb_set_mode(glue->control_otghs,
268			USB_MODE_DISCONNECT);
269}
270
271static int omap2430_musb_exit(struct musb *musb)
272{
273	struct device *dev = musb->controller;
274	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
275
276	omap2430_low_level_exit(musb);
277	phy_power_off(musb->phy);
278	phy_exit(musb->phy);
279	musb->phy = NULL;
280	cancel_work_sync(&glue->omap_musb_mailbox_work);
281
282	return 0;
283}
284
285static const struct musb_platform_ops omap2430_ops = {
286	.quirks		= MUSB_DMA_INVENTRA,
287#ifdef CONFIG_USB_INVENTRA_DMA
288	.dma_init	= musbhs_dma_controller_create,
289	.dma_exit	= musbhs_dma_controller_destroy,
290#endif
291	.init		= omap2430_musb_init,
292	.exit		= omap2430_musb_exit,
293
294	.enable		= omap2430_musb_enable,
295	.disable	= omap2430_musb_disable,
296
297	.phy_callback	= omap2430_musb_mailbox,
298};
299
300static u64 omap2430_dmamask = DMA_BIT_MASK(32);
301
302static int omap2430_probe(struct platform_device *pdev)
303{
304	struct musb_hdrc_platform_data	*pdata = dev_get_platdata(&pdev->dev);
305	struct omap_musb_board_data	*data;
306	struct platform_device		*musb;
307	struct omap2430_glue		*glue;
308	struct device_node		*np = pdev->dev.of_node;
309	struct musb_hdrc_config		*config;
310	struct device_node		*control_node;
311	struct platform_device		*control_pdev;
312	int				ret = -ENOMEM, val;
313	bool				populate_irqs = false;
314
315	if (!np)
316		return -ENODEV;
317
318	glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL);
319	if (!glue)
320		return -ENOMEM;
321
322	musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
323	if (!musb)
324		return -ENOMEM;
325
326	musb->dev.parent		= &pdev->dev;
327	musb->dev.dma_mask		= &omap2430_dmamask;
328	musb->dev.coherent_dma_mask	= omap2430_dmamask;
329
330	/*
331	 * Legacy SoCs using omap_device get confused if node is moved
332	 * because of interconnect properties mixed into the node.
333	 */
334	if (of_property_present(np, "ti,hwmods")) {
335		dev_warn(&pdev->dev, "please update to probe with ti-sysc\n");
336		populate_irqs = true;
337	} else {
338		device_set_of_node_from_dev(&musb->dev, &pdev->dev);
339	}
340	of_node_put(np);
341
342	glue->dev			= &pdev->dev;
343	glue->musb			= musb;
344	glue->status			= MUSB_UNKNOWN;
345	glue->control_otghs = ERR_PTR(-ENODEV);
346
347	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
348	if (!pdata)
349		goto err_put_musb;
350
351	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
352	if (!data)
353		goto err_put_musb;
354
355	config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
356	if (!config)
357		goto err_put_musb;
358
359	of_property_read_u32(np, "mode", (u32 *)&pdata->mode);
360	of_property_read_u32(np, "interface-type",
361			(u32 *)&data->interface_type);
362	of_property_read_u32(np, "num-eps", (u32 *)&config->num_eps);
363	of_property_read_u32(np, "ram-bits", (u32 *)&config->ram_bits);
364	of_property_read_u32(np, "power", (u32 *)&pdata->power);
365
366	ret = of_property_read_u32(np, "multipoint", &val);
367	if (!ret && val)
368		config->multipoint = true;
369
370	pdata->board_data	= data;
371	pdata->config		= config;
372
373	control_node = of_parse_phandle(np, "ctrl-module", 0);
374	if (control_node) {
375		control_pdev = of_find_device_by_node(control_node);
376		of_node_put(control_node);
377		if (!control_pdev) {
378			dev_err(&pdev->dev, "Failed to get control device\n");
379			ret = -EINVAL;
380			goto err_put_musb;
381		}
382		glue->control_otghs = &control_pdev->dev;
383	}
384
385	pdata->platform_ops		= &omap2430_ops;
386
387	platform_set_drvdata(pdev, glue);
388
389	/*
390	 * REVISIT if we ever have two instances of the wrapper, we will be
391	 * in big trouble
392	 */
393	_glue	= glue;
394
395	INIT_WORK(&glue->omap_musb_mailbox_work, omap_musb_mailbox_work);
396
397	ret = platform_device_add_resources(musb, pdev->resource, pdev->num_resources);
398	if (ret) {
399		dev_err(&pdev->dev, "failed to add resources\n");
400		goto err_put_control_otghs;
401	}
402
403	if (populate_irqs) {
404		struct resource musb_res[3];
405		struct resource *res;
406		int i = 0;
407
408		memset(musb_res, 0, sizeof(*musb_res) * ARRAY_SIZE(musb_res));
409
410		res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
411		if (!res) {
412			ret = -EINVAL;
413			goto err_put_control_otghs;
414		}
415
416		musb_res[i].start = res->start;
417		musb_res[i].end = res->end;
418		musb_res[i].flags = res->flags;
419		musb_res[i].name = res->name;
420		i++;
421
422		ret = of_irq_get_byname(np, "mc");
423		if (ret > 0) {
424			musb_res[i].start = ret;
425			musb_res[i].flags = IORESOURCE_IRQ;
426			musb_res[i].name = "mc";
427			i++;
428		}
429
430		ret = of_irq_get_byname(np, "dma");
431		if (ret > 0) {
432			musb_res[i].start = ret;
433			musb_res[i].flags = IORESOURCE_IRQ;
434			musb_res[i].name = "dma";
435			i++;
436		}
437
438		ret = platform_device_add_resources(musb, musb_res, i);
439		if (ret) {
440			dev_err(&pdev->dev, "failed to add IRQ resources\n");
441			goto err_put_control_otghs;
442		}
443	}
444
445	ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
446	if (ret) {
447		dev_err(&pdev->dev, "failed to add platform_data\n");
448		goto err_put_control_otghs;
449	}
450
451	pm_runtime_enable(glue->dev);
452
453	ret = platform_device_add(musb);
454	if (ret) {
455		dev_err(&pdev->dev, "failed to register musb device\n");
456		goto err_disable_rpm;
457	}
458
459	return 0;
460
461err_disable_rpm:
462	pm_runtime_disable(glue->dev);
463err_put_control_otghs:
464	if (!IS_ERR(glue->control_otghs))
465		put_device(glue->control_otghs);
466err_put_musb:
467	platform_device_put(musb);
468
469	return ret;
470}
471
472static void omap2430_remove(struct platform_device *pdev)
473{
474	struct omap2430_glue *glue = platform_get_drvdata(pdev);
475
476	platform_device_unregister(glue->musb);
477	pm_runtime_disable(glue->dev);
478	if (!IS_ERR(glue->control_otghs))
479		put_device(glue->control_otghs);
480}
481
482#ifdef CONFIG_PM
483
484static int omap2430_runtime_suspend(struct device *dev)
485{
486	struct omap2430_glue		*glue = dev_get_drvdata(dev);
487	struct musb			*musb = glue_to_musb(glue);
488
489	if (!musb)
490		return 0;
491
492	musb->context.otg_interfsel = musb_readl(musb->mregs,
493						 OTG_INTERFSEL);
494
495	omap2430_low_level_exit(musb);
496
497	if (!glue->phy_suspended) {
498		phy_power_off(musb->phy);
499		phy_exit(musb->phy);
500	}
501
502	glue->is_runtime_suspended = 1;
503
504	return 0;
505}
506
507static int omap2430_runtime_resume(struct device *dev)
508{
509	struct omap2430_glue		*glue = dev_get_drvdata(dev);
510	struct musb			*musb = glue_to_musb(glue);
511
512	if (!musb)
513		return 0;
514
515	if (!glue->phy_suspended) {
516		phy_init(musb->phy);
517		phy_power_on(musb->phy);
518	}
519
520	omap2430_low_level_init(musb);
521	musb_writel(musb->mregs, OTG_INTERFSEL,
522		    musb->context.otg_interfsel);
523
524	/* Wait for musb to get oriented. Otherwise we can get babble */
525	usleep_range(200000, 250000);
526
527	glue->is_runtime_suspended = 0;
528
529	return 0;
530}
531
532/* I2C and SPI PHYs need to be suspended before the glue layer */
533static int omap2430_suspend(struct device *dev)
534{
535	struct omap2430_glue *glue = dev_get_drvdata(dev);
536	struct musb *musb = glue_to_musb(glue);
537
538	phy_power_off(musb->phy);
539	phy_exit(musb->phy);
540	glue->phy_suspended = 1;
541
542	return 0;
543}
544
545/* Glue layer needs to be suspended after musb_suspend() */
546static int omap2430_suspend_late(struct device *dev)
547{
548	struct omap2430_glue *glue = dev_get_drvdata(dev);
549
550	if (glue->is_runtime_suspended)
551		return 0;
552
553	glue->needs_resume = 1;
554
555	return omap2430_runtime_suspend(dev);
556}
557
558static int omap2430_resume_early(struct device *dev)
559{
560	struct omap2430_glue *glue = dev_get_drvdata(dev);
561
562	if (!glue->needs_resume)
563		return 0;
564
565	glue->needs_resume = 0;
566
567	return omap2430_runtime_resume(dev);
568}
569
570static int omap2430_resume(struct device *dev)
571{
572	struct omap2430_glue *glue = dev_get_drvdata(dev);
573	struct musb *musb = glue_to_musb(glue);
574
575	phy_init(musb->phy);
576	phy_power_on(musb->phy);
577	glue->phy_suspended = 0;
578
579	return 0;
580}
581
582static const struct dev_pm_ops omap2430_pm_ops = {
583	.runtime_suspend = omap2430_runtime_suspend,
584	.runtime_resume = omap2430_runtime_resume,
585	.suspend = omap2430_suspend,
586	.suspend_late = omap2430_suspend_late,
587	.resume_early = omap2430_resume_early,
588	.resume = omap2430_resume,
589};
590
591#define DEV_PM_OPS	(&omap2430_pm_ops)
592#else
593#define DEV_PM_OPS	NULL
594#endif
595
596#ifdef CONFIG_OF
597static const struct of_device_id omap2430_id_table[] = {
598	{
599		.compatible = "ti,omap4-musb"
600	},
601	{
602		.compatible = "ti,omap3-musb"
603	},
604	{},
605};
606MODULE_DEVICE_TABLE(of, omap2430_id_table);
607#endif
608
609static struct platform_driver omap2430_driver = {
610	.probe		= omap2430_probe,
611	.remove		= omap2430_remove,
612	.driver		= {
613		.name	= "musb-omap2430",
614		.pm	= DEV_PM_OPS,
615		.of_match_table = of_match_ptr(omap2430_id_table),
616	},
617};
618
619module_platform_driver(omap2430_driver);
620
621MODULE_DESCRIPTION("OMAP2PLUS MUSB Glue Layer");
622MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
623MODULE_LICENSE("GPL v2");