1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * Copyright (C) 2011 Marvell International Ltd. All rights reserved.
  4 * Author: Chao Xie <chao.xie@marvell.com>
  5 *	   Neil Zhang <zhangwm@marvell.com>
  6 */
  7
  8#include <linux/module.h>
  9#include <linux/kernel.h>
 10#include <linux/io.h>
 11#include <linux/uaccess.h>
 12#include <linux/device.h>
 13#include <linux/proc_fs.h>
 14#include <linux/clk.h>
 15#include <linux/workqueue.h>
 16#include <linux/platform_device.h>
 17
 18#include <linux/usb.h>
 19#include <linux/usb/ch9.h>
 20#include <linux/usb/otg.h>
 21#include <linux/usb/gadget.h>
 22#include <linux/usb/hcd.h>
 23#include <linux/platform_data/mv_usb.h>
 24
 25#include "phy-mv-usb.h"
 26
 27#define	DRIVER_DESC	"Marvell USB OTG transceiver driver"
 28
 29MODULE_DESCRIPTION(DRIVER_DESC);
 30MODULE_LICENSE("GPL");
 31
 32static const char driver_name[] = "mv-otg";
 33
 34static char *state_string[] = {
 35	"undefined",
 36	"b_idle",
 37	"b_srp_init",
 38	"b_peripheral",
 39	"b_wait_acon",
 40	"b_host",
 41	"a_idle",
 42	"a_wait_vrise",
 43	"a_wait_bcon",
 44	"a_host",
 45	"a_suspend",
 46	"a_peripheral",
 47	"a_wait_vfall",
 48	"a_vbus_err"
 49};
 50
 51static int mv_otg_set_vbus(struct usb_otg *otg, bool on)
 52{
 53	struct mv_otg *mvotg = container_of(otg->usb_phy, struct mv_otg, phy);
 54	if (mvotg->pdata->set_vbus == NULL)
 55		return -ENODEV;
 56
 57	return mvotg->pdata->set_vbus(on);
 58}
 59
 60static int mv_otg_set_host(struct usb_otg *otg,
 61			   struct usb_bus *host)
 62{
 63	otg->host = host;
 64
 65	return 0;
 66}
 67
 68static int mv_otg_set_peripheral(struct usb_otg *otg,
 69				 struct usb_gadget *gadget)
 70{
 71	otg->gadget = gadget;
 72
 73	return 0;
 74}
 75
 76static void mv_otg_run_state_machine(struct mv_otg *mvotg,
 77				     unsigned long delay)
 78{
 79	dev_dbg(&mvotg->pdev->dev, "transceiver is updated\n");
 80	if (!mvotg->qwork)
 81		return;
 82
 83	queue_delayed_work(mvotg->qwork, &mvotg->work, delay);
 84}
 85
 86static void mv_otg_timer_await_bcon(struct timer_list *t)
 87{
 88	struct mv_otg *mvotg = from_timer(mvotg, t,
 89					  otg_ctrl.timer[A_WAIT_BCON_TIMER]);
 90
 91	mvotg->otg_ctrl.a_wait_bcon_timeout = 1;
 92
 93	dev_info(&mvotg->pdev->dev, "B Device No Response!\n");
 94
 95	if (spin_trylock(&mvotg->wq_lock)) {
 96		mv_otg_run_state_machine(mvotg, 0);
 97		spin_unlock(&mvotg->wq_lock);
 98	}
 99}
100
101static int mv_otg_cancel_timer(struct mv_otg *mvotg, unsigned int id)
102{
103	struct timer_list *timer;
104
105	if (id >= OTG_TIMER_NUM)
106		return -EINVAL;
107
108	timer = &mvotg->otg_ctrl.timer[id];
109
110	if (timer_pending(timer))
111		del_timer(timer);
112
113	return 0;
114}
115
116static int mv_otg_set_timer(struct mv_otg *mvotg, unsigned int id,
117			    unsigned long interval)
118{
119	struct timer_list *timer;
120
121	if (id >= OTG_TIMER_NUM)
122		return -EINVAL;
123
124	timer = &mvotg->otg_ctrl.timer[id];
125	if (timer_pending(timer)) {
126		dev_err(&mvotg->pdev->dev, "Timer%d is already running\n", id);
127		return -EBUSY;
128	}
129
130	timer->expires = jiffies + interval;
131	add_timer(timer);
132
133	return 0;
134}
135
136static int mv_otg_reset(struct mv_otg *mvotg)
137{
138	unsigned int loops;
139	u32 tmp;
140
141	/* Stop the controller */
142	tmp = readl(&mvotg->op_regs->usbcmd);
143	tmp &= ~USBCMD_RUN_STOP;
144	writel(tmp, &mvotg->op_regs->usbcmd);
145
146	/* Reset the controller to get default values */
147	writel(USBCMD_CTRL_RESET, &mvotg->op_regs->usbcmd);
148
149	loops = 500;
150	while (readl(&mvotg->op_regs->usbcmd) & USBCMD_CTRL_RESET) {
151		if (loops == 0) {
152			dev_err(&mvotg->pdev->dev,
153				"Wait for RESET completed TIMEOUT\n");
154			return -ETIMEDOUT;
155		}
156		loops--;
157		udelay(20);
158	}
159
160	writel(0x0, &mvotg->op_regs->usbintr);
161	tmp = readl(&mvotg->op_regs->usbsts);
162	writel(tmp, &mvotg->op_regs->usbsts);
163
164	return 0;
165}
166
167static void mv_otg_init_irq(struct mv_otg *mvotg)
168{
169	u32 otgsc;
170
171	mvotg->irq_en = OTGSC_INTR_A_SESSION_VALID
172	    | OTGSC_INTR_A_VBUS_VALID;
173	mvotg->irq_status = OTGSC_INTSTS_A_SESSION_VALID
174	    | OTGSC_INTSTS_A_VBUS_VALID;
175
176	if (mvotg->pdata->vbus == NULL) {
177		mvotg->irq_en |= OTGSC_INTR_B_SESSION_VALID
178		    | OTGSC_INTR_B_SESSION_END;
179		mvotg->irq_status |= OTGSC_INTSTS_B_SESSION_VALID
180		    | OTGSC_INTSTS_B_SESSION_END;
181	}
182
183	if (mvotg->pdata->id == NULL) {
184		mvotg->irq_en |= OTGSC_INTR_USB_ID;
185		mvotg->irq_status |= OTGSC_INTSTS_USB_ID;
186	}
187
188	otgsc = readl(&mvotg->op_regs->otgsc);
189	otgsc |= mvotg->irq_en;
190	writel(otgsc, &mvotg->op_regs->otgsc);
191}
192
193static void mv_otg_start_host(struct mv_otg *mvotg, int on)
194{
195#ifdef CONFIG_USB
196	struct usb_otg *otg = mvotg->phy.otg;
197	struct usb_hcd *hcd;
198
199	if (!otg->host)
200		return;
201
202	dev_info(&mvotg->pdev->dev, "%s host\n", on ? "start" : "stop");
203
204	hcd = bus_to_hcd(otg->host);
205
206	if (on) {
207		usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
208		device_wakeup_enable(hcd->self.controller);
209	} else {
210		usb_remove_hcd(hcd);
211	}
212#endif /* CONFIG_USB */
213}
214
215static void mv_otg_start_periphrals(struct mv_otg *mvotg, int on)
216{
217	struct usb_otg *otg = mvotg->phy.otg;
218
219	if (!otg->gadget)
220		return;
221
222	dev_info(mvotg->phy.dev, "gadget %s\n", on ? "on" : "off");
223
224	if (on)
225		usb_gadget_vbus_connect(otg->gadget);
226	else
227		usb_gadget_vbus_disconnect(otg->gadget);
228}
229
230static void otg_clock_enable(struct mv_otg *mvotg)
231{
232	clk_prepare_enable(mvotg->clk);
233}
234
235static void otg_clock_disable(struct mv_otg *mvotg)
236{
237	clk_disable_unprepare(mvotg->clk);
238}
239
240static int mv_otg_enable_internal(struct mv_otg *mvotg)
241{
242	int retval = 0;
243
244	if (mvotg->active)
245		return 0;
246
247	dev_dbg(&mvotg->pdev->dev, "otg enabled\n");
248
249	otg_clock_enable(mvotg);
250	if (mvotg->pdata->phy_init) {
251		retval = mvotg->pdata->phy_init(mvotg->phy_regs);
252		if (retval) {
253			dev_err(&mvotg->pdev->dev,
254				"init phy error %d\n", retval);
255			otg_clock_disable(mvotg);
256			return retval;
257		}
258	}
259	mvotg->active = 1;
260
261	return 0;
262
263}
264
265static int mv_otg_enable(struct mv_otg *mvotg)
266{
267	if (mvotg->clock_gating)
268		return mv_otg_enable_internal(mvotg);
269
270	return 0;
271}
272
273static void mv_otg_disable_internal(struct mv_otg *mvotg)
274{
275	if (mvotg->active) {
276		dev_dbg(&mvotg->pdev->dev, "otg disabled\n");
277		if (mvotg->pdata->phy_deinit)
278			mvotg->pdata->phy_deinit(mvotg->phy_regs);
279		otg_clock_disable(mvotg);
280		mvotg->active = 0;
281	}
282}
283
284static void mv_otg_disable(struct mv_otg *mvotg)
285{
286	if (mvotg->clock_gating)
287		mv_otg_disable_internal(mvotg);
288}
289
290static void mv_otg_update_inputs(struct mv_otg *mvotg)
291{
292	struct mv_otg_ctrl *otg_ctrl = &mvotg->otg_ctrl;
293	u32 otgsc;
294
295	otgsc = readl(&mvotg->op_regs->otgsc);
296
297	if (mvotg->pdata->vbus) {
298		if (mvotg->pdata->vbus->poll() == VBUS_HIGH) {
299			otg_ctrl->b_sess_vld = 1;
300			otg_ctrl->b_sess_end = 0;
301		} else {
302			otg_ctrl->b_sess_vld = 0;
303			otg_ctrl->b_sess_end = 1;
304		}
305	} else {
306		otg_ctrl->b_sess_vld = !!(otgsc & OTGSC_STS_B_SESSION_VALID);
307		otg_ctrl->b_sess_end = !!(otgsc & OTGSC_STS_B_SESSION_END);
308	}
309
310	if (mvotg->pdata->id)
311		otg_ctrl->id = !!mvotg->pdata->id->poll();
312	else
313		otg_ctrl->id = !!(otgsc & OTGSC_STS_USB_ID);
314
315	if (mvotg->pdata->otg_force_a_bus_req && !otg_ctrl->id)
316		otg_ctrl->a_bus_req = 1;
317
318	otg_ctrl->a_sess_vld = !!(otgsc & OTGSC_STS_A_SESSION_VALID);
319	otg_ctrl->a_vbus_vld = !!(otgsc & OTGSC_STS_A_VBUS_VALID);
320
321	dev_dbg(&mvotg->pdev->dev, "%s: ", __func__);
322	dev_dbg(&mvotg->pdev->dev, "id %d\n", otg_ctrl->id);
323	dev_dbg(&mvotg->pdev->dev, "b_sess_vld %d\n", otg_ctrl->b_sess_vld);
324	dev_dbg(&mvotg->pdev->dev, "b_sess_end %d\n", otg_ctrl->b_sess_end);
325	dev_dbg(&mvotg->pdev->dev, "a_vbus_vld %d\n", otg_ctrl->a_vbus_vld);
326	dev_dbg(&mvotg->pdev->dev, "a_sess_vld %d\n", otg_ctrl->a_sess_vld);
327}
328
329static void mv_otg_update_state(struct mv_otg *mvotg)
330{
331	struct mv_otg_ctrl *otg_ctrl = &mvotg->otg_ctrl;
332	int old_state = mvotg->phy.otg->state;
333
334	switch (old_state) {
335	case OTG_STATE_UNDEFINED:
336		mvotg->phy.otg->state = OTG_STATE_B_IDLE;
337		fallthrough;
338	case OTG_STATE_B_IDLE:
339		if (otg_ctrl->id == 0)
340			mvotg->phy.otg->state = OTG_STATE_A_IDLE;
341		else if (otg_ctrl->b_sess_vld)
342			mvotg->phy.otg->state = OTG_STATE_B_PERIPHERAL;
343		break;
344	case OTG_STATE_B_PERIPHERAL:
345		if (!otg_ctrl->b_sess_vld || otg_ctrl->id == 0)
346			mvotg->phy.otg->state = OTG_STATE_B_IDLE;
347		break;
348	case OTG_STATE_A_IDLE:
349		if (otg_ctrl->id)
350			mvotg->phy.otg->state = OTG_STATE_B_IDLE;
351		else if (!(otg_ctrl->a_bus_drop) &&
352			 (otg_ctrl->a_bus_req || otg_ctrl->a_srp_det))
353			mvotg->phy.otg->state = OTG_STATE_A_WAIT_VRISE;
354		break;
355	case OTG_STATE_A_WAIT_VRISE:
356		if (otg_ctrl->a_vbus_vld)
357			mvotg->phy.otg->state = OTG_STATE_A_WAIT_BCON;
358		break;
359	case OTG_STATE_A_WAIT_BCON:
360		if (otg_ctrl->id || otg_ctrl->a_bus_drop
361		    || otg_ctrl->a_wait_bcon_timeout) {
362			mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER);
363			mvotg->otg_ctrl.a_wait_bcon_timeout = 0;
364			mvotg->phy.otg->state = OTG_STATE_A_WAIT_VFALL;
365			otg_ctrl->a_bus_req = 0;
366		} else if (!otg_ctrl->a_vbus_vld) {
367			mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER);
368			mvotg->otg_ctrl.a_wait_bcon_timeout = 0;
369			mvotg->phy.otg->state = OTG_STATE_A_VBUS_ERR;
370		} else if (otg_ctrl->b_conn) {
371			mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER);
372			mvotg->otg_ctrl.a_wait_bcon_timeout = 0;
373			mvotg->phy.otg->state = OTG_STATE_A_HOST;
374		}
375		break;
376	case OTG_STATE_A_HOST:
377		if (otg_ctrl->id || !otg_ctrl->b_conn
378		    || otg_ctrl->a_bus_drop)
379			mvotg->phy.otg->state = OTG_STATE_A_WAIT_BCON;
380		else if (!otg_ctrl->a_vbus_vld)
381			mvotg->phy.otg->state = OTG_STATE_A_VBUS_ERR;
382		break;
383	case OTG_STATE_A_WAIT_VFALL:
384		if (otg_ctrl->id
385		    || (!otg_ctrl->b_conn && otg_ctrl->a_sess_vld)
386		    || otg_ctrl->a_bus_req)
387			mvotg->phy.otg->state = OTG_STATE_A_IDLE;
388		break;
389	case OTG_STATE_A_VBUS_ERR:
390		if (otg_ctrl->id || otg_ctrl->a_clr_err
391		    || otg_ctrl->a_bus_drop) {
392			otg_ctrl->a_clr_err = 0;
393			mvotg->phy.otg->state = OTG_STATE_A_WAIT_VFALL;
394		}
395		break;
396	default:
397		break;
398	}
399}
400
401static void mv_otg_work(struct work_struct *work)
402{
403	struct mv_otg *mvotg;
 
404	struct usb_otg *otg;
405	int old_state;
406
407	mvotg = container_of(to_delayed_work(work), struct mv_otg, work);
408
409run:
410	/* work queue is single thread, or we need spin_lock to protect */
 
411	otg = mvotg->phy.otg;
412	old_state = otg->state;
413
414	if (!mvotg->active)
415		return;
416
417	mv_otg_update_inputs(mvotg);
418	mv_otg_update_state(mvotg);
419
420	if (old_state != mvotg->phy.otg->state) {
421		dev_info(&mvotg->pdev->dev, "change from state %s to %s\n",
422			 state_string[old_state],
423			 state_string[mvotg->phy.otg->state]);
424
425		switch (mvotg->phy.otg->state) {
426		case OTG_STATE_B_IDLE:
427			otg->default_a = 0;
428			if (old_state == OTG_STATE_B_PERIPHERAL)
429				mv_otg_start_periphrals(mvotg, 0);
430			mv_otg_reset(mvotg);
431			mv_otg_disable(mvotg);
432			usb_phy_set_event(&mvotg->phy, USB_EVENT_NONE);
433			break;
434		case OTG_STATE_B_PERIPHERAL:
435			mv_otg_enable(mvotg);
436			mv_otg_start_periphrals(mvotg, 1);
437			usb_phy_set_event(&mvotg->phy, USB_EVENT_ENUMERATED);
438			break;
439		case OTG_STATE_A_IDLE:
440			otg->default_a = 1;
441			mv_otg_enable(mvotg);
442			if (old_state == OTG_STATE_A_WAIT_VFALL)
443				mv_otg_start_host(mvotg, 0);
444			mv_otg_reset(mvotg);
445			break;
446		case OTG_STATE_A_WAIT_VRISE:
447			mv_otg_set_vbus(otg, 1);
448			break;
449		case OTG_STATE_A_WAIT_BCON:
450			if (old_state != OTG_STATE_A_HOST)
451				mv_otg_start_host(mvotg, 1);
452			mv_otg_set_timer(mvotg, A_WAIT_BCON_TIMER,
453					 T_A_WAIT_BCON);
454			/*
455			 * Now, we directly enter A_HOST. So set b_conn = 1
456			 * here. In fact, it need host driver to notify us.
457			 */
458			mvotg->otg_ctrl.b_conn = 1;
459			break;
460		case OTG_STATE_A_HOST:
461			break;
462		case OTG_STATE_A_WAIT_VFALL:
463			/*
464			 * Now, we has exited A_HOST. So set b_conn = 0
465			 * here. In fact, it need host driver to notify us.
466			 */
467			mvotg->otg_ctrl.b_conn = 0;
468			mv_otg_set_vbus(otg, 0);
469			break;
470		case OTG_STATE_A_VBUS_ERR:
471			break;
472		default:
473			break;
474		}
475		goto run;
476	}
477}
478
479static irqreturn_t mv_otg_irq(int irq, void *dev)
480{
481	struct mv_otg *mvotg = dev;
482	u32 otgsc;
483
484	otgsc = readl(&mvotg->op_regs->otgsc);
485	writel(otgsc, &mvotg->op_regs->otgsc);
486
487	/*
488	 * if we have vbus, then the vbus detection for B-device
489	 * will be done by mv_otg_inputs_irq().
490	 */
491	if (mvotg->pdata->vbus)
492		if ((otgsc & OTGSC_STS_USB_ID) &&
493		    !(otgsc & OTGSC_INTSTS_USB_ID))
494			return IRQ_NONE;
495
496	if ((otgsc & mvotg->irq_status) == 0)
497		return IRQ_NONE;
498
499	mv_otg_run_state_machine(mvotg, 0);
500
501	return IRQ_HANDLED;
502}
503
504static irqreturn_t mv_otg_inputs_irq(int irq, void *dev)
505{
506	struct mv_otg *mvotg = dev;
507
508	/* The clock may disabled at this time */
509	if (!mvotg->active) {
510		mv_otg_enable(mvotg);
511		mv_otg_init_irq(mvotg);
512	}
513
514	mv_otg_run_state_machine(mvotg, 0);
515
516	return IRQ_HANDLED;
517}
518
519static ssize_t
520a_bus_req_show(struct device *dev, struct device_attribute *attr, char *buf)
521{
522	struct mv_otg *mvotg = dev_get_drvdata(dev);
523	return scnprintf(buf, PAGE_SIZE, "%d\n",
524			 mvotg->otg_ctrl.a_bus_req);
525}
526
527static ssize_t
528a_bus_req_store(struct device *dev, struct device_attribute *attr,
529	      const char *buf, size_t count)
530{
531	struct mv_otg *mvotg = dev_get_drvdata(dev);
532
533	if (count > 2)
534		return -1;
535
536	/* We will use this interface to change to A device */
537	if (mvotg->phy.otg->state != OTG_STATE_B_IDLE
538	    && mvotg->phy.otg->state != OTG_STATE_A_IDLE)
539		return -1;
540
541	/* The clock may disabled and we need to set irq for ID detected */
542	mv_otg_enable(mvotg);
543	mv_otg_init_irq(mvotg);
544
545	if (buf[0] == '1') {
546		mvotg->otg_ctrl.a_bus_req = 1;
547		mvotg->otg_ctrl.a_bus_drop = 0;
548		dev_dbg(&mvotg->pdev->dev,
549			"User request: a_bus_req = 1\n");
550
551		if (spin_trylock(&mvotg->wq_lock)) {
552			mv_otg_run_state_machine(mvotg, 0);
553			spin_unlock(&mvotg->wq_lock);
554		}
555	}
556
557	return count;
558}
559
560static DEVICE_ATTR_RW(a_bus_req);
561
562static ssize_t
563a_clr_err_store(struct device *dev, struct device_attribute *attr,
564	      const char *buf, size_t count)
565{
566	struct mv_otg *mvotg = dev_get_drvdata(dev);
567	if (!mvotg->phy.otg->default_a)
568		return -1;
569
570	if (count > 2)
571		return -1;
572
573	if (buf[0] == '1') {
574		mvotg->otg_ctrl.a_clr_err = 1;
575		dev_dbg(&mvotg->pdev->dev,
576			"User request: a_clr_err = 1\n");
577	}
578
579	if (spin_trylock(&mvotg->wq_lock)) {
580		mv_otg_run_state_machine(mvotg, 0);
581		spin_unlock(&mvotg->wq_lock);
582	}
583
584	return count;
585}
586
587static DEVICE_ATTR_WO(a_clr_err);
588
589static ssize_t
590a_bus_drop_show(struct device *dev, struct device_attribute *attr,
591	       char *buf)
592{
593	struct mv_otg *mvotg = dev_get_drvdata(dev);
594	return scnprintf(buf, PAGE_SIZE, "%d\n",
595			 mvotg->otg_ctrl.a_bus_drop);
596}
597
598static ssize_t
599a_bus_drop_store(struct device *dev, struct device_attribute *attr,
600	       const char *buf, size_t count)
601{
602	struct mv_otg *mvotg = dev_get_drvdata(dev);
603	if (!mvotg->phy.otg->default_a)
604		return -1;
605
606	if (count > 2)
607		return -1;
608
609	if (buf[0] == '0') {
610		mvotg->otg_ctrl.a_bus_drop = 0;
611		dev_dbg(&mvotg->pdev->dev,
612			"User request: a_bus_drop = 0\n");
613	} else if (buf[0] == '1') {
614		mvotg->otg_ctrl.a_bus_drop = 1;
615		mvotg->otg_ctrl.a_bus_req = 0;
616		dev_dbg(&mvotg->pdev->dev,
617			"User request: a_bus_drop = 1\n");
618		dev_dbg(&mvotg->pdev->dev,
619			"User request: and a_bus_req = 0\n");
620	}
621
622	if (spin_trylock(&mvotg->wq_lock)) {
623		mv_otg_run_state_machine(mvotg, 0);
624		spin_unlock(&mvotg->wq_lock);
625	}
626
627	return count;
628}
629
630static DEVICE_ATTR_RW(a_bus_drop);
631
632static struct attribute *inputs_attrs[] = {
633	&dev_attr_a_bus_req.attr,
634	&dev_attr_a_clr_err.attr,
635	&dev_attr_a_bus_drop.attr,
636	NULL,
637};
638
639static const struct attribute_group inputs_attr_group = {
640	.name = "inputs",
641	.attrs = inputs_attrs,
642};
643
644static const struct attribute_group *mv_otg_groups[] = {
645	&inputs_attr_group,
646	NULL,
647};
648
649static int mv_otg_remove(struct platform_device *pdev)
650{
651	struct mv_otg *mvotg = platform_get_drvdata(pdev);
652
 
 
653	if (mvotg->qwork) {
654		flush_workqueue(mvotg->qwork);
655		destroy_workqueue(mvotg->qwork);
656	}
657
658	mv_otg_disable(mvotg);
659
660	usb_remove_phy(&mvotg->phy);
661
662	return 0;
663}
664
665static int mv_otg_probe(struct platform_device *pdev)
666{
667	struct mv_usb_platform_data *pdata = dev_get_platdata(&pdev->dev);
668	struct mv_otg *mvotg;
669	struct usb_otg *otg;
670	struct resource *r;
671	int retval = 0, i;
672
673	if (pdata == NULL) {
674		dev_err(&pdev->dev, "failed to get platform data\n");
675		return -ENODEV;
676	}
677
678	mvotg = devm_kzalloc(&pdev->dev, sizeof(*mvotg), GFP_KERNEL);
679	if (!mvotg)
680		return -ENOMEM;
681
682	otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
683	if (!otg)
684		return -ENOMEM;
685
686	platform_set_drvdata(pdev, mvotg);
687
688	mvotg->pdev = pdev;
689	mvotg->pdata = pdata;
690
691	mvotg->clk = devm_clk_get(&pdev->dev, NULL);
692	if (IS_ERR(mvotg->clk))
693		return PTR_ERR(mvotg->clk);
694
695	mvotg->qwork = create_singlethread_workqueue("mv_otg_queue");
696	if (!mvotg->qwork) {
697		dev_dbg(&pdev->dev, "cannot create workqueue for OTG\n");
698		return -ENOMEM;
699	}
700
701	INIT_DELAYED_WORK(&mvotg->work, mv_otg_work);
702
703	/* OTG common part */
704	mvotg->pdev = pdev;
705	mvotg->phy.dev = &pdev->dev;
706	mvotg->phy.otg = otg;
707	mvotg->phy.label = driver_name;
708
709	otg->state = OTG_STATE_UNDEFINED;
710	otg->usb_phy = &mvotg->phy;
711	otg->set_host = mv_otg_set_host;
712	otg->set_peripheral = mv_otg_set_peripheral;
713	otg->set_vbus = mv_otg_set_vbus;
714
715	for (i = 0; i < OTG_TIMER_NUM; i++)
716		timer_setup(&mvotg->otg_ctrl.timer[i],
717			    mv_otg_timer_await_bcon, 0);
718
719	r = platform_get_resource_byname(mvotg->pdev,
720					 IORESOURCE_MEM, "phyregs");
721	if (r == NULL) {
722		dev_err(&pdev->dev, "no phy I/O memory resource defined\n");
723		retval = -ENODEV;
724		goto err_destroy_workqueue;
725	}
726
727	mvotg->phy_regs = devm_ioremap(&pdev->dev, r->start, resource_size(r));
728	if (mvotg->phy_regs == NULL) {
729		dev_err(&pdev->dev, "failed to map phy I/O memory\n");
730		retval = -EFAULT;
731		goto err_destroy_workqueue;
732	}
733
734	r = platform_get_resource_byname(mvotg->pdev,
735					 IORESOURCE_MEM, "capregs");
736	if (r == NULL) {
737		dev_err(&pdev->dev, "no I/O memory resource defined\n");
738		retval = -ENODEV;
739		goto err_destroy_workqueue;
740	}
741
742	mvotg->cap_regs = devm_ioremap(&pdev->dev, r->start, resource_size(r));
743	if (mvotg->cap_regs == NULL) {
744		dev_err(&pdev->dev, "failed to map I/O memory\n");
745		retval = -EFAULT;
746		goto err_destroy_workqueue;
747	}
748
749	/* we will acces controller register, so enable the udc controller */
750	retval = mv_otg_enable_internal(mvotg);
751	if (retval) {
752		dev_err(&pdev->dev, "mv otg enable error %d\n", retval);
753		goto err_destroy_workqueue;
754	}
755
756	mvotg->op_regs =
757		(struct mv_otg_regs __iomem *) ((unsigned long) mvotg->cap_regs
758			+ (readl(mvotg->cap_regs) & CAPLENGTH_MASK));
759
760	if (pdata->id) {
761		retval = devm_request_threaded_irq(&pdev->dev, pdata->id->irq,
762						NULL, mv_otg_inputs_irq,
763						IRQF_ONESHOT, "id", mvotg);
764		if (retval) {
765			dev_info(&pdev->dev,
766				 "Failed to request irq for ID\n");
767			pdata->id = NULL;
768		}
769	}
770
771	if (pdata->vbus) {
772		mvotg->clock_gating = 1;
773		retval = devm_request_threaded_irq(&pdev->dev, pdata->vbus->irq,
774						NULL, mv_otg_inputs_irq,
775						IRQF_ONESHOT, "vbus", mvotg);
776		if (retval) {
777			dev_info(&pdev->dev,
778				 "Failed to request irq for VBUS, "
779				 "disable clock gating\n");
780			mvotg->clock_gating = 0;
781			pdata->vbus = NULL;
782		}
783	}
784
785	if (pdata->disable_otg_clock_gating)
786		mvotg->clock_gating = 0;
787
788	mv_otg_reset(mvotg);
789	mv_otg_init_irq(mvotg);
790
791	r = platform_get_resource(mvotg->pdev, IORESOURCE_IRQ, 0);
792	if (r == NULL) {
793		dev_err(&pdev->dev, "no IRQ resource defined\n");
794		retval = -ENODEV;
795		goto err_disable_clk;
796	}
797
798	mvotg->irq = r->start;
799	if (devm_request_irq(&pdev->dev, mvotg->irq, mv_otg_irq, IRQF_SHARED,
800			driver_name, mvotg)) {
801		dev_err(&pdev->dev, "Request irq %d for OTG failed\n",
802			mvotg->irq);
803		mvotg->irq = 0;
804		retval = -ENODEV;
805		goto err_disable_clk;
806	}
807
808	retval = usb_add_phy(&mvotg->phy, USB_PHY_TYPE_USB2);
809	if (retval < 0) {
810		dev_err(&pdev->dev, "can't register transceiver, %d\n",
811			retval);
812		goto err_disable_clk;
813	}
814
 
 
 
 
 
 
 
815	spin_lock_init(&mvotg->wq_lock);
816	if (spin_trylock(&mvotg->wq_lock)) {
817		mv_otg_run_state_machine(mvotg, 2 * HZ);
818		spin_unlock(&mvotg->wq_lock);
819	}
820
821	dev_info(&pdev->dev,
822		 "successful probe OTG device %s clock gating.\n",
823		 mvotg->clock_gating ? "with" : "without");
824
825	return 0;
826
 
 
827err_disable_clk:
828	mv_otg_disable_internal(mvotg);
829err_destroy_workqueue:
830	flush_workqueue(mvotg->qwork);
831	destroy_workqueue(mvotg->qwork);
832
833	return retval;
834}
835
836#ifdef CONFIG_PM
837static int mv_otg_suspend(struct platform_device *pdev, pm_message_t state)
838{
839	struct mv_otg *mvotg = platform_get_drvdata(pdev);
840
841	if (mvotg->phy.otg->state != OTG_STATE_B_IDLE) {
842		dev_info(&pdev->dev,
843			 "OTG state is not B_IDLE, it is %d!\n",
844			 mvotg->phy.otg->state);
845		return -EAGAIN;
846	}
847
848	if (!mvotg->clock_gating)
849		mv_otg_disable_internal(mvotg);
850
851	return 0;
852}
853
854static int mv_otg_resume(struct platform_device *pdev)
855{
856	struct mv_otg *mvotg = platform_get_drvdata(pdev);
857	u32 otgsc;
858
859	if (!mvotg->clock_gating) {
860		mv_otg_enable_internal(mvotg);
861
862		otgsc = readl(&mvotg->op_regs->otgsc);
863		otgsc |= mvotg->irq_en;
864		writel(otgsc, &mvotg->op_regs->otgsc);
865
866		if (spin_trylock(&mvotg->wq_lock)) {
867			mv_otg_run_state_machine(mvotg, 0);
868			spin_unlock(&mvotg->wq_lock);
869		}
870	}
871	return 0;
872}
873#endif
874
875static struct platform_driver mv_otg_driver = {
876	.probe = mv_otg_probe,
877	.remove = mv_otg_remove,
878	.driver = {
879		   .name = driver_name,
880		   .dev_groups = mv_otg_groups,
881		   },
882#ifdef CONFIG_PM
883	.suspend = mv_otg_suspend,
884	.resume = mv_otg_resume,
885#endif
886};
887module_platform_driver(mv_otg_driver);