musb_dsps.c 27.2 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/*
 * Texas Instruments DSPS platforms "glue layer"
 *
 * Copyright (C) 2012, by Texas Instruments
 *
 * Based on the am35x "glue layer" code.
 *
 * This file is part of the Inventra Controller Driver for Linux.
 *
 * The Inventra Controller Driver for Linux is free software; you
 * can redistribute it and/or modify it under the terms of the GNU
 * General Public License version 2 as published by the Free Software
 * Foundation.
 *
 * The Inventra Controller Driver for Linux is distributed in
 * the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
 * License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with The Inventra Controller Driver for Linux ; if not,
 * write to the Free Software Foundation, Inc., 59 Temple Place,
 * Suite 330, Boston, MA  02111-1307  USA
 *
 * musb_dsps.c will be a common file for all the TI DSPS platforms
 * such as dm64x, dm36x, dm35x, da8x, am35x and ti81x.
 * For now only ti81x is using this and in future davinci.c, am35x.c
 * da8xx.c would be merged to this file after testing.
 */

#include <linux/io.h>
33
#include <linux/err.h>
34
35
36
37
#include <linux/platform_device.h>
#include <linux/dma-mapping.h>
#include <linux/pm_runtime.h>
#include <linux/module.h>
38
#include <linux/usb/usb_phy_generic.h>
39
#include <linux/platform_data/usb-omap.h>
40
#include <linux/sizes.h>
41
42
43
44

#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_address.h>
45
#include <linux/of_irq.h>
46
#include <linux/usb/of.h>
47

48
49
#include <linux/debugfs.h>

50
51
#include "musb_core.h"

52
53
static const struct of_device_id musb_dsps_of_match[];

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/**
 * DSPS musb wrapper register offset.
 * FIXME: This should be expanded to have all the wrapper registers from TI DSPS
 * musb ips.
 */
struct dsps_musb_wrapper {
	u16	revision;
	u16	control;
	u16	status;
	u16	epintr_set;
	u16	epintr_clear;
	u16	epintr_status;
	u16	coreintr_set;
	u16	coreintr_clear;
	u16	coreintr_status;
	u16	phy_utmi;
	u16	mode;
71
72
	u16	tx_mode;
	u16	rx_mode;
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

	/* bit positions for control */
	unsigned	reset:5;

	/* bit positions for interrupt */
	unsigned	usb_shift:5;
	u32		usb_mask;
	u32		usb_bitmap;
	unsigned	drvvbus:5;

	unsigned	txep_shift:5;
	u32		txep_mask;
	u32		txep_bitmap;

	unsigned	rxep_shift:5;
	u32		rxep_mask;
	u32		rxep_bitmap;

	/* bit positions for phy_utmi */
	unsigned	otg_disable:5;

	/* bit positions for mode */
	unsigned	iddig:5;
96
	unsigned	iddig_mux:5;
97
	/* miscellaneous stuff */
98
	unsigned	poll_timeout;
99
100
};

101
102
103
104
105
106
107
108
109
110
111
112
113
/*
 * register shadow for suspend
 */
struct dsps_context {
	u32 control;
	u32 epintr;
	u32 coreintr;
	u32 phy_utmi;
	u32 mode;
	u32 tx_mode;
	u32 rx_mode;
};

114
115
116
117
118
/**
 * DSPS glue structure.
 */
struct dsps_glue {
	struct device *dev;
119
	struct platform_device *musb;	/* child musb pdev */
120
	const struct dsps_musb_wrapper *wrp; /* wrapper register offsets */
121
	int vbus_irq;			/* optional vbus irq */
122
123
	struct timer_list timer;	/* otg_workaround timer */
	unsigned long last_timer;    /* last timer data for each instance */
124
	bool sw_babble_enabled;
125
	void __iomem *usbss_base;
126
127

	struct dsps_context context;
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
	struct debugfs_regset32 regset;
	struct dentry *dbgfs_root;
};

static const struct debugfs_reg32 dsps_musb_regs[] = {
	{ "revision",		0x00 },
	{ "control",		0x14 },
	{ "status",		0x18 },
	{ "eoi",		0x24 },
	{ "intr0_stat",		0x30 },
	{ "intr1_stat",		0x34 },
	{ "intr0_set",		0x38 },
	{ "intr1_set",		0x3c },
	{ "txmode",		0x70 },
	{ "rxmode",		0x74 },
	{ "autoreq",		0xd0 },
	{ "srpfixtime",		0xd4 },
	{ "tdown",		0xd8 },
	{ "phy_utmi",		0xe0 },
	{ "mode",		0xe8 },
148
149
};

150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
static void dsps_mod_timer(struct dsps_glue *glue, int wait_ms)
{
	int wait;

	if (wait_ms < 0)
		wait = msecs_to_jiffies(glue->wrp->poll_timeout);
	else
		wait = msecs_to_jiffies(wait_ms);

	mod_timer(&glue->timer, jiffies + wait);
}

/*
 * If no vbus irq from the PMIC is configured, we need to poll VBUS status.
 */
static void dsps_mod_timer_optional(struct dsps_glue *glue)
{
	if (glue->vbus_irq)
		return;

	dsps_mod_timer(glue, -1);
}

173
174
175
176
177
178
179
/* USBSS  / USB AM335x */
#define USBSS_IRQ_STATUS	0x28
#define USBSS_IRQ_ENABLER	0x2c
#define USBSS_IRQ_CLEARR	0x30

#define USBSS_IRQ_PD_COMP	(1 << 2)

180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
/**
 * dsps_musb_enable - enable interrupts
 */
static void dsps_musb_enable(struct musb *musb)
{
	struct device *dev = musb->controller;
	struct platform_device *pdev = to_platform_device(dev->parent);
	struct dsps_glue *glue = platform_get_drvdata(pdev);
	const struct dsps_musb_wrapper *wrp = glue->wrp;
	void __iomem *reg_base = musb->ctrl_base;
	u32 epmask, coremask;

	/* Workaround: setup IRQs through both register sets. */
	epmask = ((musb->epmask & wrp->txep_mask) << wrp->txep_shift) |
	       ((musb->epmask & wrp->rxep_mask) << wrp->rxep_shift);
	coremask = (wrp->usb_bitmap & ~MUSB_INTR_SOF);

197
198
	musb_writel(reg_base, wrp->epintr_set, epmask);
	musb_writel(reg_base, wrp->coreintr_set, coremask);
199
200
201
	/* start polling for ID change in dual-role idle mode */
	if (musb->xceiv->otg->state == OTG_STATE_B_IDLE &&
			musb->port_mode == MUSB_PORT_MODE_DUAL_ROLE)
202
		dsps_mod_timer(glue, -1);
203
204
205
206
207
208
209
210
211
212
213
214
215
}

/**
 * dsps_musb_disable - disable HDRC and flush interrupts
 */
static void dsps_musb_disable(struct musb *musb)
{
	struct device *dev = musb->controller;
	struct platform_device *pdev = to_platform_device(dev->parent);
	struct dsps_glue *glue = platform_get_drvdata(pdev);
	const struct dsps_musb_wrapper *wrp = glue->wrp;
	void __iomem *reg_base = musb->ctrl_base;

216
217
	musb_writel(reg_base, wrp->coreintr_clear, wrp->usb_bitmap);
	musb_writel(reg_base, wrp->epintr_clear,
218
			 wrp->txep_bitmap | wrp->rxep_bitmap);
219
	del_timer_sync(&glue->timer);
220
221
}

222
223
/* Caller must take musb->lock */
static int dsps_check_status(struct musb *musb, void *unused)
224
225
226
{
	void __iomem *mregs = musb->mregs;
	struct device *dev = musb->controller;
227
	struct dsps_glue *glue = dev_get_drvdata(dev->parent);
228
229
	const struct dsps_musb_wrapper *wrp = glue->wrp;
	u8 devctl;
230
	int skip_session = 0;
231

232
233
234
	if (glue->vbus_irq)
		del_timer(&glue->timer);

235
236
237
238
	/*
	 * We poll because DSPS IP's won't expose several OTG-critical
	 * status change events (from the transceiver) otherwise.
	 */
239
	devctl = musb_readb(mregs, MUSB_DEVCTL);
240
	dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,
241
				usb_otg_state_string(musb->xceiv->otg->state));
242

243
	switch (musb->xceiv->otg->state) {
244
	case OTG_STATE_A_WAIT_VRISE:
245
		dsps_mod_timer_optional(glue);
246
		break;
247
	case OTG_STATE_A_WAIT_BCON:
248
		musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
249
250
		skip_session = 1;
		/* fall */
251

252
253
	case OTG_STATE_A_IDLE:
	case OTG_STATE_B_IDLE:
254
255
256
257
258
259
260
261
262
263
264
		if (!glue->vbus_irq) {
			if (devctl & MUSB_DEVCTL_BDEVICE) {
				musb->xceiv->otg->state = OTG_STATE_B_IDLE;
				MUSB_DEV_MODE(musb);
			} else {
				musb->xceiv->otg->state = OTG_STATE_A_IDLE;
				MUSB_HST_MODE(musb);
			}
			if (!(devctl & MUSB_DEVCTL_SESSION) && !skip_session)
				musb_writeb(mregs, MUSB_DEVCTL,
					    MUSB_DEVCTL_SESSION);
265
		}
266
		dsps_mod_timer_optional(glue);
267
268
		break;
	case OTG_STATE_A_WAIT_VFALL:
269
		musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
270
		musb_writel(musb->ctrl_base, wrp->coreintr_set,
271
272
273
274
275
			    MUSB_INTR_VBUSERROR << wrp->usb_shift);
		break;
	default:
		break;
	}
276

277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
	return 0;
}

static void otg_timer(unsigned long _musb)
{
	struct musb *musb = (void *)_musb;
	struct device *dev = musb->controller;
	unsigned long flags;
	int err;

	err = pm_runtime_get(dev);
	if ((err != -EINPROGRESS) && err < 0) {
		dev_err(dev, "Poll could not pm_runtime_get: %i\n", err);
		pm_runtime_put_noidle(dev);

		return;
	}

	spin_lock_irqsave(&musb->lock, flags);
	err = musb_queue_resume_work(musb, dsps_check_status, NULL);
	if (err < 0)
		dev_err(dev, "%s resume work: %i\n", __func__, err);
	spin_unlock_irqrestore(&musb->lock, flags);
300
301
	pm_runtime_mark_last_busy(dev);
	pm_runtime_put_autosuspend(dev);
302
303
}

304
static void dsps_musb_clear_ep_rxintr(struct musb *musb, int epnum)
305
306
307
308
309
310
311
312
313
314
{
	u32 epintr;
	struct dsps_glue *glue = dev_get_drvdata(musb->controller->parent);
	const struct dsps_musb_wrapper *wrp = glue->wrp;

	/* musb->lock might already been held */
	epintr = (1 << epnum) << wrp->rxep_shift;
	musb_writel(musb->ctrl_base, wrp->epintr_status, epintr);
}

315
316
317
318
319
static irqreturn_t dsps_interrupt(int irq, void *hci)
{
	struct musb  *musb = hci;
	void __iomem *reg_base = musb->ctrl_base;
	struct device *dev = musb->controller;
320
	struct dsps_glue *glue = dev_get_drvdata(dev->parent);
321
322
323
324
325
326
327
328
	const struct dsps_musb_wrapper *wrp = glue->wrp;
	unsigned long flags;
	irqreturn_t ret = IRQ_NONE;
	u32 epintr, usbintr;

	spin_lock_irqsave(&musb->lock, flags);

	/* Get endpoint interrupts */
329
	epintr = musb_readl(reg_base, wrp->epintr_status);
330
331
332
333
	musb->int_rx = (epintr & wrp->rxep_bitmap) >> wrp->rxep_shift;
	musb->int_tx = (epintr & wrp->txep_bitmap) >> wrp->txep_shift;

	if (epintr)
334
		musb_writel(reg_base, wrp->epintr_status, epintr);
335
336

	/* Get usb core interrupts */
337
	usbintr = musb_readl(reg_base, wrp->coreintr_status);
338
	if (!usbintr && !epintr)
339
		goto out;
340
341
342

	musb->int_usb =	(usbintr & wrp->usb_bitmap) >> wrp->usb_shift;
	if (usbintr)
343
		musb_writel(reg_base, wrp->coreintr_status, usbintr);
344
345
346

	dev_dbg(musb->controller, "usbintr (%x) epintr(%x)\n",
			usbintr, epintr);
347

348
	if (usbintr & ((1 << wrp->drvvbus) << wrp->usb_shift)) {
349
		int drvvbus = musb_readl(reg_base, wrp->status);
350
		void __iomem *mregs = musb->mregs;
351
		u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
352
353
		int err;

354
		err = musb->int_usb & MUSB_INTR_VBUSERROR;
355
356
357
358
359
360
361
362
363
364
365
366
367
		if (err) {
			/*
			 * The Mentor core doesn't debounce VBUS as needed
			 * to cope with device connect current spikes. This
			 * means it's not uncommon for bus-powered devices
			 * to get VBUS errors during enumeration.
			 *
			 * This is a workaround, but newer RTL from Mentor
			 * seems to allow a better one: "re"-starting sessions
			 * without waiting for VBUS to stop registering in
			 * devctl.
			 */
			musb->int_usb &= ~MUSB_INTR_VBUSERROR;
368
			musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL;
369
			dsps_mod_timer_optional(glue);
370
			WARNING("VBUS error workaround (delay coming)\n");
371
		} else if (drvvbus) {
372
373
			MUSB_HST_MODE(musb);
			musb->xceiv->otg->default_a = 1;
374
			musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
375
			dsps_mod_timer_optional(glue);
376
377
378
379
		} else {
			musb->is_active = 0;
			MUSB_DEV_MODE(musb);
			musb->xceiv->otg->default_a = 0;
380
			musb->xceiv->otg->state = OTG_STATE_B_IDLE;
381
382
383
384
385
		}

		/* NOTE: this must complete power-on within 100 ms. */
		dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n",
				drvvbus ? "on" : "off",
386
				usb_otg_state_string(musb->xceiv->otg->state),
387
388
389
390
391
392
393
394
				err ? " ERROR" : "",
				devctl);
		ret = IRQ_HANDLED;
	}

	if (musb->int_tx || musb->int_rx || musb->int_usb)
		ret |= musb_interrupt(musb);

395
396
397
398
	/* Poll for ID change and connect */
	switch (musb->xceiv->otg->state) {
	case OTG_STATE_B_IDLE:
	case OTG_STATE_A_WAIT_BCON:
399
		dsps_mod_timer_optional(glue);
400
401
402
403
404
		break;
	default:
		break;
	}

405
out:
406
407
408
409
410
	spin_unlock_irqrestore(&musb->lock, flags);

	return ret;
}

411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
static int dsps_musb_dbg_init(struct musb *musb, struct dsps_glue *glue)
{
	struct dentry *root;
	struct dentry *file;
	char buf[128];

	sprintf(buf, "%s.dsps", dev_name(musb->controller));
	root = debugfs_create_dir(buf, NULL);
	if (!root)
		return -ENOMEM;
	glue->dbgfs_root = root;

	glue->regset.regs = dsps_musb_regs;
	glue->regset.nregs = ARRAY_SIZE(dsps_musb_regs);
	glue->regset.base = musb->ctrl_base;

	file = debugfs_create_regset32("regdump", S_IRUGO, root, &glue->regset);
	if (!file) {
		debugfs_remove_recursive(root);
		return -ENOMEM;
	}
	return 0;
}

435
436
437
static int dsps_musb_init(struct musb *musb)
{
	struct device *dev = musb->controller;
438
	struct dsps_glue *glue = dev_get_drvdata(dev->parent);
439
	struct platform_device *parent = to_platform_device(dev->parent);
440
	const struct dsps_musb_wrapper *wrp = glue->wrp;
441
442
	void __iomem *reg_base;
	struct resource *r;
443
	u32 rev, val;
444
	int ret;
445

446
447
	r = platform_get_resource_byname(parent, IORESOURCE_MEM, "control");
	reg_base = devm_ioremap_resource(dev, r);
448
449
	if (IS_ERR(reg_base))
		return PTR_ERR(reg_base);
450
	musb->ctrl_base = reg_base;
451

452
	/* NOP driver needs change if supporting dual instance */
453
	musb->xceiv = devm_usb_get_phy_by_phandle(dev->parent, "phys", 0);
454
455
	if (IS_ERR(musb->xceiv))
		return PTR_ERR(musb->xceiv);
456

457
458
	musb->phy = devm_phy_get(dev->parent, "usb2-phy");

459
	/* Returns zero if e.g. not clocked */
460
	rev = musb_readl(reg_base, wrp->revision);
461
462
	if (!rev)
		return -ENODEV;
463

464
	usb_phy_init(musb->xceiv);
465
466
467
468
469
470
471
472
473
474
475
476
477
	if (IS_ERR(musb->phy))  {
		musb->phy = NULL;
	} else {
		ret = phy_init(musb->phy);
		if (ret < 0)
			return ret;
		ret = phy_power_on(musb->phy);
		if (ret) {
			phy_exit(musb->phy);
			return ret;
		}
	}

478
	setup_timer(&glue->timer, otg_timer, (unsigned long) musb);
479
480

	/* Reset the musb */
481
	musb_writel(reg_base, wrp->control, (1 << wrp->reset));
482
483
484
485

	musb->isr = dsps_interrupt;

	/* reset the otgdisable bit, needed for host mode to work */
486
	val = musb_readl(reg_base, wrp->phy_utmi);
487
	val &= ~(1 << wrp->otg_disable);
488
	musb_writel(musb->ctrl_base, wrp->phy_utmi, val);
489

490
491
492
493
494
495
	/*
	 *  Check whether the dsps version has babble control enabled.
	 * In latest silicon revision the babble control logic is enabled.
	 * If MUSB_BABBLE_CTL returns 0x4 then we have the babble control
	 * logic enabled.
	 */
496
	val = musb_readb(musb->mregs, MUSB_BABBLE_CTL);
497
	if (val & MUSB_BABBLE_RCV_DISABLE) {
498
499
		glue->sw_babble_enabled = true;
		val |= MUSB_BABBLE_SW_SESSION_CTRL;
500
		musb_writeb(musb->mregs, MUSB_BABBLE_CTL, val);
501
502
	}

503
	dsps_mod_timer(glue, -1);
504

505
	return dsps_musb_dbg_init(musb, glue);
506
507
508
509
510
}

static int dsps_musb_exit(struct musb *musb)
{
	struct device *dev = musb->controller;
511
	struct dsps_glue *glue = dev_get_drvdata(dev->parent);
512

513
	del_timer_sync(&glue->timer);
514
	usb_phy_shutdown(musb->xceiv);
515
516
	phy_power_off(musb->phy);
	phy_exit(musb->phy);
517
518
	debugfs_remove_recursive(glue->dbgfs_root);

519
520
521
	return 0;
}

522
523
524
525
526
527
528
529
static int dsps_musb_set_mode(struct musb *musb, u8 mode)
{
	struct device *dev = musb->controller;
	struct dsps_glue *glue = dev_get_drvdata(dev->parent);
	const struct dsps_musb_wrapper *wrp = glue->wrp;
	void __iomem *ctrl_base = musb->ctrl_base;
	u32 reg;

530
	reg = musb_readl(ctrl_base, wrp->mode);
531
532
533
534
535
536
537
538
539
540
541
542

	switch (mode) {
	case MUSB_HOST:
		reg &= ~(1 << wrp->iddig);

		/*
		 * if we're setting mode to host-only or device-only, we're
		 * going to ignore whatever the PHY sends us and just force
		 * ID pin status by SW
		 */
		reg |= (1 << wrp->iddig_mux);

543
544
		musb_writel(ctrl_base, wrp->mode, reg);
		musb_writel(ctrl_base, wrp->phy_utmi, 0x02);
545
546
547
548
549
550
551
552
553
554
555
		break;
	case MUSB_PERIPHERAL:
		reg |= (1 << wrp->iddig);

		/*
		 * if we're setting mode to host-only or device-only, we're
		 * going to ignore whatever the PHY sends us and just force
		 * ID pin status by SW
		 */
		reg |= (1 << wrp->iddig_mux);

556
		musb_writel(ctrl_base, wrp->mode, reg);
557
558
		break;
	case MUSB_OTG:
559
		musb_writel(ctrl_base, wrp->phy_utmi, 0x02);
560
561
562
563
564
565
566
567
568
		break;
	default:
		dev_err(glue->dev, "unsupported mode %d\n", mode);
		return -EINVAL;
	}

	return 0;
}

569
static bool dsps_sw_babble_control(struct musb *musb)
570
571
572
573
{
	u8 babble_ctl;
	bool session_restart =  false;

574
	babble_ctl = musb_readb(musb->mregs, MUSB_BABBLE_CTL);
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
	dev_dbg(musb->controller, "babble: MUSB_BABBLE_CTL value %x\n",
		babble_ctl);
	/*
	 * check line monitor flag to check whether babble is
	 * due to noise
	 */
	dev_dbg(musb->controller, "STUCK_J is %s\n",
		babble_ctl & MUSB_BABBLE_STUCK_J ? "set" : "reset");

	if (babble_ctl & MUSB_BABBLE_STUCK_J) {
		int timeout = 10;

		/*
		 * babble is due to noise, then set transmit idle (d7 bit)
		 * to resume normal operation
		 */
591
		babble_ctl = musb_readb(musb->mregs, MUSB_BABBLE_CTL);
592
		babble_ctl |= MUSB_BABBLE_FORCE_TXIDLE;
593
		musb_writeb(musb->mregs, MUSB_BABBLE_CTL, babble_ctl);
594
595
596
597

		/* wait till line monitor flag cleared */
		dev_dbg(musb->controller, "Set TXIDLE, wait J to clear\n");
		do {
598
			babble_ctl = musb_readb(musb->mregs, MUSB_BABBLE_CTL);
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
			udelay(1);
		} while ((babble_ctl & MUSB_BABBLE_STUCK_J) && timeout--);

		/* check whether stuck_at_j bit cleared */
		if (babble_ctl & MUSB_BABBLE_STUCK_J) {
			/*
			 * real babble condition has occurred
			 * restart the controller to start the
			 * session again
			 */
			dev_dbg(musb->controller, "J not cleared, misc (%x)\n",
				babble_ctl);
			session_restart = true;
		}
	} else {
		session_restart = true;
	}

	return session_restart;
}

620
static int dsps_musb_recover(struct musb *musb)
621
622
623
{
	struct device *dev = musb->controller;
	struct dsps_glue *glue = dev_get_drvdata(dev->parent);
624
	int session_restart = 0;
625

626
	if (glue->sw_babble_enabled)
627
		session_restart = dsps_sw_babble_control(musb);
628
	else
629
		session_restart = 1;
630

631
	return session_restart ? 0 : -EPIPE;
632
633
}

634
635
636
637
638
639
/* Similar to am35x, dm81xx support only 32-bit read operation */
static void dsps_read_fifo32(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
{
	void __iomem *fifo = hw_ep->fifo;

	if (len >= 4) {
640
		ioread32_rep(fifo, dst, len >> 2);
641
642
643
644
645
646
647
648
649
650
651
		dst += len & ~0x03;
		len &= 0x03;
	}

	/* Read any remaining 1 to 3 bytes */
	if (len > 0) {
		u32 val = musb_readl(fifo, 0);
		memcpy(dst, &val, len);
	}
}

652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
#ifdef CONFIG_USB_TI_CPPI41_DMA
static void dsps_dma_controller_callback(struct dma_controller *c)
{
	struct musb *musb = c->musb;
	struct dsps_glue *glue = dev_get_drvdata(musb->controller->parent);
	void __iomem *usbss_base = glue->usbss_base;
	u32 status;

	status = musb_readl(usbss_base, USBSS_IRQ_STATUS);
	if (status & USBSS_IRQ_PD_COMP)
		musb_writel(usbss_base, USBSS_IRQ_STATUS, USBSS_IRQ_PD_COMP);
}

static struct dma_controller *
dsps_dma_controller_create(struct musb *musb, void __iomem *base)
{
	struct dma_controller *controller;
	struct dsps_glue *glue = dev_get_drvdata(musb->controller->parent);
	void __iomem *usbss_base = glue->usbss_base;

	controller = cppi41_dma_controller_create(musb, base);
	if (IS_ERR_OR_NULL(controller))
		return controller;

	musb_writel(usbss_base, USBSS_IRQ_ENABLER, USBSS_IRQ_PD_COMP);
	controller->dma_callback = dsps_dma_controller_callback;

	return controller;
}

static void dsps_dma_controller_destroy(struct dma_controller *c)
{
	struct musb *musb = c->musb;
	struct dsps_glue *glue = dev_get_drvdata(musb->controller->parent);
	void __iomem *usbss_base = glue->usbss_base;

	musb_writel(usbss_base, USBSS_IRQ_CLEARR, USBSS_IRQ_PD_COMP);
	cppi41_dma_controller_destroy(c);
}

#ifdef CONFIG_PM_SLEEP
static void dsps_dma_controller_suspend(struct dsps_glue *glue)
{
	void __iomem *usbss_base = glue->usbss_base;

	musb_writel(usbss_base, USBSS_IRQ_CLEARR, USBSS_IRQ_PD_COMP);
}

static void dsps_dma_controller_resume(struct dsps_glue *glue)
{
	void __iomem *usbss_base = glue->usbss_base;

	musb_writel(usbss_base, USBSS_IRQ_ENABLER, USBSS_IRQ_PD_COMP);
}
#endif
#else /* CONFIG_USB_TI_CPPI41_DMA */
#ifdef CONFIG_PM_SLEEP
static void dsps_dma_controller_suspend(struct dsps_glue *glue) {}
static void dsps_dma_controller_resume(struct dsps_glue *glue) {}
#endif
#endif /* CONFIG_USB_TI_CPPI41_DMA */

714
static struct musb_platform_ops dsps_ops = {
715
	.quirks		= MUSB_DMA_CPPI41 | MUSB_INDEXED_EP,
716
717
718
	.init		= dsps_musb_init,
	.exit		= dsps_musb_exit,

719
#ifdef CONFIG_USB_TI_CPPI41_DMA
720
721
	.dma_init	= dsps_dma_controller_create,
	.dma_exit	= dsps_dma_controller_destroy,
722
#endif
723
724
725
	.enable		= dsps_musb_enable,
	.disable	= dsps_musb_disable,

726
	.set_mode	= dsps_musb_set_mode,
727
	.recover	= dsps_musb_recover,
728
	.clear_ep_rxintr = dsps_musb_clear_ep_rxintr,
729
730
731
732
};

static u64 musb_dmamask = DMA_BIT_MASK(32);

733
static int get_int_prop(struct device_node *dn, const char *s)
734
{
735
736
737
738
739
740
741
742
743
	int ret;
	u32 val;

	ret = of_property_read_u32(dn, s, &val);
	if (ret)
		return 0;
	return val;
}

744
745
746
747
static int get_musb_port_mode(struct device *dev)
{
	enum usb_dr_mode mode;

748
	mode = usb_get_dr_mode(dev);
749
750
751
752
753
754
755
756
757
758
759
	switch (mode) {
	case USB_DR_MODE_HOST:
		return MUSB_PORT_MODE_HOST;

	case USB_DR_MODE_PERIPHERAL:
		return MUSB_PORT_MODE_GADGET;

	case USB_DR_MODE_UNKNOWN:
	case USB_DR_MODE_OTG:
	default:
		return MUSB_PORT_MODE_DUAL_ROLE;
760
	}
761
762
}

763
764
765
766
static int dsps_create_musb_pdev(struct dsps_glue *glue,
		struct platform_device *parent)
{
	struct musb_hdrc_platform_data pdata;
767
	struct resource	resources[2];
768
	struct resource	*res;
769
770
771
772
	struct device *dev = &parent->dev;
	struct musb_hdrc_config	*config;
	struct platform_device *musb;
	struct device_node *dn = parent->dev.of_node;
773
	int ret, val;
774

775
	memset(resources, 0, sizeof(resources));
776
777
	res = platform_get_resource_byname(parent, IORESOURCE_MEM, "mc");
	if (!res) {
778
		dev_err(dev, "failed to get memory.\n");
779
		return -EINVAL;
780
	}
781
	resources[0] = *res;
782

783
784
	res = platform_get_resource_byname(parent, IORESOURCE_IRQ, "mc");
	if (!res) {
785
		dev_err(dev, "failed to get irq.\n");
786
		return -EINVAL;
787
	}
788
	resources[1] = *res;
789
790

	/* allocate the child platform device */
791
792
	musb = platform_device_alloc("musb-hdrc",
			(resources[0].start & 0xFFF) == 0x400 ? 0 : 1);
793
794
	if (!musb) {
		dev_err(dev, "failed to allocate musb device\n");
795
		return -ENOMEM;
796
797
798
799
800
801
	}

	musb->dev.parent		= dev;
	musb->dev.dma_mask		= &musb_dmamask;
	musb->dev.coherent_dma_mask	= musb_dmamask;

802
	glue->musb = musb;
803

804
805
	ret = platform_device_add_resources(musb, resources,
			ARRAY_SIZE(resources));
806
807
	if (ret) {
		dev_err(dev, "failed to add resources\n");
808
		goto err;
809
810
	}

811
812
813
814
	config = devm_kzalloc(&parent->dev, sizeof(*config), GFP_KERNEL);
	if (!config) {
		ret = -ENOMEM;
		goto err;
815
	}
816
817
	pdata.config = config;
	pdata.platform_ops = &dsps_ops;
818

819
820
	config->num_eps = get_int_prop(dn, "mentor,num-eps");
	config->ram_bits = get_int_prop(dn, "mentor,ram-bits");
821
	config->host_port_deassert_reset_at_resume = 1;
822
823
824
	pdata.mode = get_musb_port_mode(dev);
	/* DT keeps this entry in mA, musb expects it as per USB spec */
	pdata.power = get_int_prop(dn, "mentor,power") / 2;
825
826
827
828

	ret = of_property_read_u32(dn, "mentor,multipoint", &val);
	if (!ret && val)
		config->multipoint = true;
829

830
	config->maximum_speed = usb_get_maximum_speed(&parent->dev);
831
832
833
834
835
836
837
838
839
840
841
842
	switch (config->maximum_speed) {
	case USB_SPEED_LOW:
	case USB_SPEED_FULL:
		break;
	case USB_SPEED_SUPER:
		dev_warn(dev, "ignore incorrect maximum_speed "
				"(super-speed) setting in dts");
		/* fall through */
	default:
		config->maximum_speed = USB_SPEED_HIGH;
	}

843
	ret = platform_device_add_data(musb, &pdata, sizeof(pdata));
844
845
	if (ret) {
		dev_err(dev, "failed to add platform_data\n");
846
		goto err;
847
848
849
850
851
	}

	ret = platform_device_add(musb);
	if (ret) {
		dev_err(dev, "failed to register musb device\n");
852
		goto err;
853
854
855
	}
	return 0;

856
err:
857
858
859
860
	platform_device_put(musb);
	return ret;
}

861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
static irqreturn_t dsps_vbus_threaded_irq(int irq, void *priv)
{
	struct dsps_glue *glue = priv;
	struct musb *musb = platform_get_drvdata(glue->musb);

	if (!musb)
		return IRQ_NONE;

	dev_dbg(glue->dev, "VBUS interrupt\n");
	dsps_mod_timer(glue, 0);

	return IRQ_HANDLED;
}

static int dsps_setup_optional_vbus_irq(struct platform_device *pdev,
					struct dsps_glue *glue)
{
	int error;

	glue->vbus_irq = platform_get_irq_byname(pdev, "vbus");
	if (glue->vbus_irq == -EPROBE_DEFER)
		return -EPROBE_DEFER;

	if (glue->vbus_irq <= 0) {
		glue->vbus_irq = 0;
		return 0;
	}

	error = devm_request_threaded_irq(glue->dev, glue->vbus_irq,
					  NULL, dsps_vbus_threaded_irq,
					  IRQF_ONESHOT,
					  "vbus", glue);
	if (error) {
		glue->vbus_irq = 0;
		return error;
	}
	dev_dbg(glue->dev, "VBUS irq %i configured\n", glue->vbus_irq);

	return 0;
}

Bill Pemberton's avatar
Bill Pemberton committed
902
static int dsps_probe(struct platform_device *pdev)
903
{
904
905
	const struct of_device_id *match;
	const struct dsps_musb_wrapper *wrp;
906
	struct dsps_glue *glue;
907
	int ret;
908

909
910
911
	if (!strcmp(pdev->name, "musb-hdrc"))
		return -ENODEV;

912
	match = of_match_node(musb_dsps_of_match, pdev->dev.of_node);
913
914
	if (!match) {
		dev_err(&pdev->dev, "fail to get matching of_match struct\n");
915
		return -EINVAL;
916
917
	}
	wrp = match->data;
918

919
920
921
	if (of_device_is_compatible(pdev->dev.of_node, "ti,musb-dm816"))
		dsps_ops.read_fifo = dsps_read_fifo32;

922
	/* allocate glue */
923
	glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL);
924
	if (!glue)
925
		return -ENOMEM;
926
927

	glue->dev = &pdev->dev;
928
	glue->wrp = wrp;
929
930
931
	glue->usbss_base = of_iomap(pdev->dev.parent->of_node, 0);
	if (!glue->usbss_base)
		return -ENXIO;
932

933
934
935
	if (usb_get_dr_mode(&pdev->dev) == USB_DR_MODE_PERIPHERAL) {
		ret = dsps_setup_optional_vbus_irq(pdev, glue);
		if (ret)
936
			goto err_iounmap;
937
938
	}

939
940
	platform_set_drvdata(pdev, glue);
	pm_runtime_enable(&pdev->dev);
941
942
	ret = dsps_create_musb_pdev(glue, pdev);
	if (ret)
943
		goto err;
944

945
946
	return 0;

947
err:
948
	pm_runtime_disable(&pdev->dev);
949
950
err_iounmap:
	iounmap(glue->usbss_base);
951
952
	return ret;
}
953

Bill Pemberton's avatar
Bill Pemberton committed
954
static int dsps_remove(struct platform_device *pdev)
955
956
957
{
	struct dsps_glue *glue = platform_get_drvdata(pdev);

958
	platform_device_unregister(glue->musb);
959
960

	pm_runtime_disable(&pdev->dev);
961
	iounmap(glue->usbss_base);
962

963
964
965
	return 0;
}

966
static const struct dsps_musb_wrapper am33xx_driver_data = {
967
968
969
970
971
972
973
974
975
976
977
	.revision		= 0x00,
	.control		= 0x14,
	.status			= 0x18,
	.epintr_set		= 0x38,
	.epintr_clear		= 0x40,
	.epintr_status		= 0x30,
	.coreintr_set		= 0x3c,
	.coreintr_clear		= 0x44,
	.coreintr_status	= 0x34,
	.phy_utmi		= 0xe0,
	.mode			= 0xe8,
978
979
	.tx_mode		= 0x70,
	.rx_mode		= 0x74,
980
981
982
	.reset			= 0,
	.otg_disable		= 21,
	.iddig			= 8,
983
	.iddig_mux		= 7,
984
985
986
987
988
989
990
991
992
993
	.usb_shift		= 0,
	.usb_mask		= 0x1ff,
	.usb_bitmap		= (0x1ff << 0),
	.drvvbus		= 8,
	.txep_shift		= 0,
	.txep_mask		= 0xffff,
	.txep_bitmap		= (0xffff << 0),
	.rxep_shift		= 16,
	.rxep_mask		= 0xfffe,
	.rxep_bitmap		= (0xfffe << 16),
994
	.poll_timeout		= 2000, /* ms */
995
996
};

997
static const struct of_device_id musb_dsps_of_match[] = {
998
	{ .compatible = "ti,musb-am33xx",
999
1000
		.data = &am33xx_driver_data, },
	{ .compatible = "ti,musb-dm816",