ep0.c 25.0 KB
Newer Older
1 2 3 4 5 6 7 8
/**
 * ep0.c - DesignWare USB3 DRD Controller Endpoint 0 Handling
 *
 * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com
 *
 * Authors: Felipe Balbi <balbi@ti.com>,
 *	    Sebastian Andrzej Siewior <bigeasy@linutronix.de>
 *
F
Felipe Balbi 已提交
9 10 11
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2  of
 * the License as published by the Free Software Foundation.
12
 *
F
Felipe Balbi 已提交
13 14 15 16
 * This program 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.
17 18 19 20 21 22 23 24 25 26 27 28 29 30
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/list.h>
#include <linux/dma-mapping.h>

#include <linux/usb/ch9.h>
#include <linux/usb/gadget.h>
31
#include <linux/usb/composite.h>
32 33 34 35 36

#include "core.h"
#include "gadget.h"
#include "io.h"

37
static void __dwc3_ep0_do_control_status(struct dwc3 *dwc, struct dwc3_ep *dep);
38 39
static void __dwc3_ep0_do_control_data(struct dwc3 *dwc,
		struct dwc3_ep *dep, struct dwc3_request *req);
40

41 42 43 44 45
static const char *dwc3_ep0_state_string(enum dwc3_ep0_state state)
{
	switch (state) {
	case EP0_UNCONNECTED:
		return "Unconnected";
46 47 48 49 50 51
	case EP0_SETUP_PHASE:
		return "Setup Phase";
	case EP0_DATA_PHASE:
		return "Data Phase";
	case EP0_STATUS_PHASE:
		return "Status Phase";
52 53 54 55 56 57
	default:
		return "UNKNOWN";
	}
}

static int dwc3_ep0_start_trans(struct dwc3 *dwc, u8 epnum, dma_addr_t buf_dma,
58
		u32 len, u32 type)
59 60
{
	struct dwc3_gadget_ep_cmd_params params;
61
	struct dwc3_trb			*trb;
62 63 64 65 66
	struct dwc3_ep			*dep;

	int				ret;

	dep = dwc->eps[epnum];
67 68 69 70
	if (dep->flags & DWC3_EP_BUSY) {
		dev_vdbg(dwc->dev, "%s: still busy\n", dep->name);
		return 0;
	}
71

72
	trb = dwc->ep0_trb;
73

74 75 76 77
	trb->bpl = lower_32_bits(buf_dma);
	trb->bph = upper_32_bits(buf_dma);
	trb->size = len;
	trb->ctrl = type;
78

79 80 81 82
	trb->ctrl |= (DWC3_TRB_CTRL_HWO
			| DWC3_TRB_CTRL_LST
			| DWC3_TRB_CTRL_IOC
			| DWC3_TRB_CTRL_ISP_IMI);
83 84

	memset(&params, 0, sizeof(params));
85 86
	params.param0 = upper_32_bits(dwc->ep0_trb_addr);
	params.param1 = lower_32_bits(dwc->ep0_trb_addr);
87 88 89 90 91 92 93 94

	ret = dwc3_send_gadget_ep_cmd(dwc, dep->number,
			DWC3_DEPCMD_STARTTRANSFER, &params);
	if (ret < 0) {
		dev_dbg(dwc->dev, "failed to send STARTTRANSFER command\n");
		return ret;
	}

95
	dep->flags |= DWC3_EP_BUSY;
96
	dep->resource_index = dwc3_gadget_ep_get_transfer_index(dwc,
97 98
			dep->number);

99 100
	dwc->ep0_next_event = DWC3_EP0_COMPLETE;

101 102 103 104 105 106
	return 0;
}

static int __dwc3_gadget_ep0_queue(struct dwc3_ep *dep,
		struct dwc3_request *req)
{
107
	struct dwc3		*dwc = dep->dwc;
108 109 110 111 112 113

	req->request.actual	= 0;
	req->request.status	= -EINPROGRESS;
	req->epnum		= dep->number;

	list_add_tail(&req->list, &dep->request_list);
114

115 116 117 118 119 120 121 122 123 124 125 126 127 128
	/*
	 * Gadget driver might not be quick enough to queue a request
	 * before we get a Transfer Not Ready event on this endpoint.
	 *
	 * In that case, we will set DWC3_EP_PENDING_REQUEST. When that
	 * flag is set, it's telling us that as soon as Gadget queues the
	 * required request, we should kick the transfer here because the
	 * IRQ we were waiting for is long gone.
	 */
	if (dep->flags & DWC3_EP_PENDING_REQUEST) {
		unsigned	direction;

		direction = !!(dep->flags & DWC3_EP0_DIR_IN);

129 130
		if (dwc->ep0state != EP0_DATA_PHASE) {
			dev_WARN(dwc->dev, "Unexpected pending request\n");
131 132
			return 0;
		}
133

134 135
		__dwc3_ep0_do_control_data(dwc, dwc->eps[direction], req);

136 137
		dep->flags &= ~(DWC3_EP_PENDING_REQUEST |
				DWC3_EP0_DIR_IN);
138 139 140 141 142 143 144 145 146

		return 0;
	}

	/*
	 * In case gadget driver asked us to delay the STATUS phase,
	 * handle it here.
	 */
	if (dwc->delayed_status) {
147 148 149
		unsigned	direction;

		direction = !dwc->ep0_expect_in;
150
		dwc->delayed_status = false;
151
		usb_gadget_set_state(&dwc->gadget, USB_STATE_CONFIGURED);
152 153

		if (dwc->ep0state == EP0_STATUS_PHASE)
154
			__dwc3_ep0_do_control_status(dwc, dwc->eps[direction]);
155 156
		else
			dev_dbg(dwc->dev, "too early for delayed status\n");
157 158

		return 0;
159 160
	}

161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
	/*
	 * Unfortunately we have uncovered a limitation wrt the Data Phase.
	 *
	 * Section 9.4 says we can wait for the XferNotReady(DATA) event to
	 * come before issueing Start Transfer command, but if we do, we will
	 * miss situations where the host starts another SETUP phase instead of
	 * the DATA phase.  Such cases happen at least on TD.7.6 of the Link
	 * Layer Compliance Suite.
	 *
	 * The problem surfaces due to the fact that in case of back-to-back
	 * SETUP packets there will be no XferNotReady(DATA) generated and we
	 * will be stuck waiting for XferNotReady(DATA) forever.
	 *
	 * By looking at tables 9-13 and 9-14 of the Databook, we can see that
	 * it tells us to start Data Phase right away. It also mentions that if
	 * we receive a SETUP phase instead of the DATA phase, core will issue
	 * XferComplete for the DATA phase, before actually initiating it in
	 * the wire, with the TRB's status set to "SETUP_PENDING". Such status
	 * can only be used to print some debugging logs, as the core expects
	 * us to go through to the STATUS phase and start a CONTROL_STATUS TRB,
	 * just so it completes right away, without transferring anything and,
	 * only then, we can go back to the SETUP phase.
	 *
	 * Because of this scenario, SNPS decided to change the programming
	 * model of control transfers and support on-demand transfers only for
	 * the STATUS phase. To fix the issue we have now, we will always wait
	 * for gadget driver to queue the DATA phase's struct usb_request, then
	 * start it right away.
	 *
	 * If we're actually in a 2-stage transfer, we will wait for
	 * XferNotReady(STATUS).
	 */
	if (dwc->three_stage_setup) {
		unsigned        direction;

		direction = dwc->ep0_expect_in;
		dwc->ep0state = EP0_DATA_PHASE;

		__dwc3_ep0_do_control_data(dwc, dwc->eps[direction], req);

		dep->flags &= ~DWC3_EP0_DIR_IN;
	}

204
	return 0;
205 206 207 208 209 210 211 212 213 214 215 216 217 218
}

int dwc3_gadget_ep0_queue(struct usb_ep *ep, struct usb_request *request,
		gfp_t gfp_flags)
{
	struct dwc3_request		*req = to_dwc3_request(request);
	struct dwc3_ep			*dep = to_dwc3_ep(ep);
	struct dwc3			*dwc = dep->dwc;

	unsigned long			flags;

	int				ret;

	spin_lock_irqsave(&dwc->lock, flags);
219
	if (!dep->endpoint.desc) {
220 221 222 223 224 225 226
		dev_dbg(dwc->dev, "trying to queue request %p to disabled %s\n",
				request, dep->name);
		ret = -ESHUTDOWN;
		goto out;
	}

	/* we share one TRB for ep0/1 */
227
	if (!list_empty(&dep->request_list)) {
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
		ret = -EBUSY;
		goto out;
	}

	dev_vdbg(dwc->dev, "queueing request %p to %s length %d, state '%s'\n",
			request, dep->name, request->length,
			dwc3_ep0_state_string(dwc->ep0state));

	ret = __dwc3_gadget_ep0_queue(dep, req);

out:
	spin_unlock_irqrestore(&dwc->lock, flags);

	return ret;
}

static void dwc3_ep0_stall_and_restart(struct dwc3 *dwc)
{
246 247 248 249 250
	struct dwc3_ep		*dep;

	/* reinitialize physical ep1 */
	dep = dwc->eps[1];
	dep->flags = DWC3_EP_ENABLED;
251

252
	/* stall is always issued on EP0 */
253
	dep = dwc->eps[0];
254 255
	__dwc3_gadget_ep_set_halt(dep, 1);
	dep->flags = DWC3_EP_ENABLED;
256
	dwc->delayed_status = false;
257 258 259 260 261 262 263 264

	if (!list_empty(&dep->request_list)) {
		struct dwc3_request	*req;

		req = next_request(&dep->request_list);
		dwc3_gadget_giveback(dep, req, -ECONNRESET);
	}

265
	dwc->ep0state = EP0_SETUP_PHASE;
266 267 268
	dwc3_ep0_out_start(dwc);
}

269 270 271 272 273 274 275 276 277 278
int dwc3_gadget_ep0_set_halt(struct usb_ep *ep, int value)
{
	struct dwc3_ep			*dep = to_dwc3_ep(ep);
	struct dwc3			*dwc = dep->dwc;

	dwc3_ep0_stall_and_restart(dwc);

	return 0;
}

279 280 281 282
void dwc3_ep0_out_start(struct dwc3 *dwc)
{
	int				ret;

283 284
	ret = dwc3_ep0_start_trans(dwc, 0, dwc->ctrl_req_addr, 8,
			DWC3_TRBCTL_CONTROL_SETUP);
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
	WARN_ON(ret < 0);
}

static struct dwc3_ep *dwc3_wIndex_to_dep(struct dwc3 *dwc, __le16 wIndex_le)
{
	struct dwc3_ep		*dep;
	u32			windex = le16_to_cpu(wIndex_le);
	u32			epnum;

	epnum = (windex & USB_ENDPOINT_NUMBER_MASK) << 1;
	if ((windex & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN)
		epnum |= 1;

	dep = dwc->eps[epnum];
	if (dep->flags & DWC3_EP_ENABLED)
		return dep;

	return NULL;
}

305
static void dwc3_ep0_status_cmpl(struct usb_ep *ep, struct usb_request *req)
306 307 308 309 310
{
}
/*
 * ch 9.4.5
 */
311 312
static int dwc3_ep0_handle_status(struct dwc3 *dwc,
		struct usb_ctrlrequest *ctrl)
313 314 315
{
	struct dwc3_ep		*dep;
	u32			recip;
316
	u32			reg;
317 318 319 320 321 322 323
	u16			usb_status = 0;
	__le16			*response_pkt;

	recip = ctrl->bRequestType & USB_RECIP_MASK;
	switch (recip) {
	case USB_RECIP_DEVICE:
		/*
324
		 * LTM will be set once we know how to set this in HW.
325 326
		 */
		usb_status |= dwc->is_selfpowered << USB_DEVICE_SELF_POWERED;
327 328 329 330 331 332 333 334 335

		if (dwc->speed == DWC3_DSTS_SUPERSPEED) {
			reg = dwc3_readl(dwc->regs, DWC3_DCTL);
			if (reg & DWC3_DCTL_INITU1ENA)
				usb_status |= 1 << USB_DEV_STAT_U1_ENABLED;
			if (reg & DWC3_DCTL_INITU2ENA)
				usb_status |= 1 << USB_DEV_STAT_U2_ENABLED;
		}

336 337 338 339 340 341 342 343 344 345 346 347
		break;

	case USB_RECIP_INTERFACE:
		/*
		 * Function Remote Wake Capable	D0
		 * Function Remote Wakeup	D1
		 */
		break;

	case USB_RECIP_ENDPOINT:
		dep = dwc3_wIndex_to_dep(dwc, ctrl->wIndex);
		if (!dep)
348
			return -EINVAL;
349 350 351 352 353 354 355 356 357 358

		if (dep->flags & DWC3_EP_STALL)
			usb_status = 1 << USB_ENDPOINT_HALT;
		break;
	default:
		return -EINVAL;
	};

	response_pkt = (__le16 *) dwc->setup_buf;
	*response_pkt = cpu_to_le16(usb_status);
359 360 361

	dep = dwc->eps[0];
	dwc->ep0_usb_req.dep = dep;
362
	dwc->ep0_usb_req.request.length = sizeof(*response_pkt);
363
	dwc->ep0_usb_req.request.buf = dwc->setup_buf;
364
	dwc->ep0_usb_req.request.complete = dwc3_ep0_status_cmpl;
365 366

	return __dwc3_gadget_ep0_queue(dep, &dwc->ep0_usb_req);
367 368 369 370 371 372 373 374 375
}

static int dwc3_ep0_handle_feature(struct dwc3 *dwc,
		struct usb_ctrlrequest *ctrl, int set)
{
	struct dwc3_ep		*dep;
	u32			recip;
	u32			wValue;
	u32			wIndex;
376
	u32			reg;
377
	int			ret;
378
	enum usb_device_state	state;
379 380 381 382

	wValue = le16_to_cpu(ctrl->wValue);
	wIndex = le16_to_cpu(ctrl->wIndex);
	recip = ctrl->bRequestType & USB_RECIP_MASK;
383 384
	state = dwc->gadget.state;

385 386 387
	switch (recip) {
	case USB_RECIP_DEVICE:

388 389 390
		switch (wValue) {
		case USB_DEVICE_REMOTE_WAKEUP:
			break;
391 392 393 394 395
		/*
		 * 9.4.1 says only only for SS, in AddressState only for
		 * default control pipe
		 */
		case USB_DEVICE_U1_ENABLE:
396
			if (state != USB_STATE_CONFIGURED)
397 398 399 400
				return -EINVAL;
			if (dwc->speed != DWC3_DSTS_SUPERSPEED)
				return -EINVAL;

401 402 403 404 405 406
			reg = dwc3_readl(dwc->regs, DWC3_DCTL);
			if (set)
				reg |= DWC3_DCTL_INITU1ENA;
			else
				reg &= ~DWC3_DCTL_INITU1ENA;
			dwc3_writel(dwc->regs, DWC3_DCTL, reg);
407
			break;
408

409
		case USB_DEVICE_U2_ENABLE:
410
			if (state != USB_STATE_CONFIGURED)
411 412 413 414 415 416 417 418 419 420
				return -EINVAL;
			if (dwc->speed != DWC3_DSTS_SUPERSPEED)
				return -EINVAL;

			reg = dwc3_readl(dwc->regs, DWC3_DCTL);
			if (set)
				reg |= DWC3_DCTL_INITU2ENA;
			else
				reg &= ~DWC3_DCTL_INITU2ENA;
			dwc3_writel(dwc->regs, DWC3_DCTL, reg);
421
			break;
422

423
		case USB_DEVICE_LTM_ENABLE:
424
			return -EINVAL;
425 426 427 428 429 430 431 432
			break;

		case USB_DEVICE_TEST_MODE:
			if ((wIndex & 0xff) != 0)
				return -EINVAL;
			if (!set)
				return -EINVAL;

433 434
			dwc->test_mode_nr = wIndex >> 8;
			dwc->test_mode = true;
435 436 437
			break;
		default:
			return -EINVAL;
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
		}
		break;

	case USB_RECIP_INTERFACE:
		switch (wValue) {
		case USB_INTRF_FUNC_SUSPEND:
			if (wIndex & USB_INTRF_FUNC_SUSPEND_LP)
				/* XXX enable Low power suspend */
				;
			if (wIndex & USB_INTRF_FUNC_SUSPEND_RW)
				/* XXX enable remote wakeup */
				;
			break;
		default:
			return -EINVAL;
		}
		break;

	case USB_RECIP_ENDPOINT:
		switch (wValue) {
		case USB_ENDPOINT_HALT:
459
			dep = dwc3_wIndex_to_dep(dwc, wIndex);
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
			if (!dep)
				return -EINVAL;
			ret = __dwc3_gadget_ep_set_halt(dep, set);
			if (ret)
				return -EINVAL;
			break;
		default:
			return -EINVAL;
		}
		break;

	default:
		return -EINVAL;
	};

	return 0;
}

static int dwc3_ep0_set_address(struct dwc3 *dwc, struct usb_ctrlrequest *ctrl)
{
480
	enum usb_device_state state = dwc->gadget.state;
481 482 483 484
	u32 addr;
	u32 reg;

	addr = le16_to_cpu(ctrl->wValue);
485 486
	if (addr > 127) {
		dev_dbg(dwc->dev, "invalid device address %d\n", addr);
487
		return -EINVAL;
488 489
	}

490
	if (state == USB_STATE_CONFIGURED) {
491 492 493
		dev_dbg(dwc->dev, "trying to set address when configured\n");
		return -EINVAL;
	}
494

495 496 497 498
	reg = dwc3_readl(dwc->regs, DWC3_DCFG);
	reg &= ~(DWC3_DCFG_DEVADDR_MASK);
	reg |= DWC3_DCFG_DEVADDR(addr);
	dwc3_writel(dwc->regs, DWC3_DCFG, reg);
499

500
	if (addr)
501
		usb_gadget_set_state(&dwc->gadget, USB_STATE_ADDRESS);
502
	else
503
		usb_gadget_set_state(&dwc->gadget, USB_STATE_DEFAULT);
504

505
	return 0;
506 507 508 509 510 511 512 513 514 515 516 517 518 519
}

static int dwc3_ep0_delegate_req(struct dwc3 *dwc, struct usb_ctrlrequest *ctrl)
{
	int ret;

	spin_unlock(&dwc->lock);
	ret = dwc->gadget_driver->setup(&dwc->gadget, ctrl);
	spin_lock(&dwc->lock);
	return ret;
}

static int dwc3_ep0_set_config(struct dwc3 *dwc, struct usb_ctrlrequest *ctrl)
{
520
	enum usb_device_state state = dwc->gadget.state;
521 522
	u32 cfg;
	int ret;
523
	u32 reg;
524

525
	dwc->start_config_issued = false;
526 527
	cfg = le16_to_cpu(ctrl->wValue);

528 529
	switch (state) {
	case USB_STATE_DEFAULT:
530 531 532
		return -EINVAL;
		break;

533
	case USB_STATE_ADDRESS:
534 535
		ret = dwc3_ep0_delegate_req(dwc, ctrl);
		/* if the cfg matches and the cfg is non zero */
536
		if (cfg && (!ret || (ret == USB_GADGET_DELAYED_STATUS))) {
537 538 539 540 541 542 543 544 545 546

			/*
			 * only change state if set_config has already
			 * been processed. If gadget driver returns
			 * USB_GADGET_DELAYED_STATUS, we will wait
			 * to change the state on the next usb_ep_queue()
			 */
			if (ret == 0)
				usb_gadget_set_state(&dwc->gadget,
						USB_STATE_CONFIGURED);
547

548 549 550 551 552 553 554 555
			/*
			 * Enable transition to U1/U2 state when
			 * nothing is pending from application.
			 */
			reg = dwc3_readl(dwc->regs, DWC3_DCTL);
			reg |= (DWC3_DCTL_ACCEPTU1ENA | DWC3_DCTL_ACCEPTU2ENA);
			dwc3_writel(dwc->regs, DWC3_DCTL, reg);

556 557 558
			dwc->resize_fifos = true;
			dev_dbg(dwc->dev, "resize fifos flag SET\n");
		}
559 560
		break;

561
	case USB_STATE_CONFIGURED:
562
		ret = dwc3_ep0_delegate_req(dwc, ctrl);
563
		if (!cfg && !ret)
564 565
			usb_gadget_set_state(&dwc->gadget,
					USB_STATE_ADDRESS);
566
		break;
567 568
	default:
		ret = -EINVAL;
569
	}
570
	return ret;
571 572
}

573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
static void dwc3_ep0_set_sel_cmpl(struct usb_ep *ep, struct usb_request *req)
{
	struct dwc3_ep	*dep = to_dwc3_ep(ep);
	struct dwc3	*dwc = dep->dwc;

	u32		param = 0;
	u32		reg;

	struct timing {
		u8	u1sel;
		u8	u1pel;
		u16	u2sel;
		u16	u2pel;
	} __packed timing;

	int		ret;

	memcpy(&timing, req->buf, sizeof(timing));

	dwc->u1sel = timing.u1sel;
	dwc->u1pel = timing.u1pel;
594 595
	dwc->u2sel = le16_to_cpu(timing.u2sel);
	dwc->u2pel = le16_to_cpu(timing.u2pel);
596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619

	reg = dwc3_readl(dwc->regs, DWC3_DCTL);
	if (reg & DWC3_DCTL_INITU2ENA)
		param = dwc->u2pel;
	if (reg & DWC3_DCTL_INITU1ENA)
		param = dwc->u1pel;

	/*
	 * According to Synopsys Databook, if parameter is
	 * greater than 125, a value of zero should be
	 * programmed in the register.
	 */
	if (param > 125)
		param = 0;

	/* now that we have the time, issue DGCMD Set Sel */
	ret = dwc3_send_gadget_generic_command(dwc,
			DWC3_DGCMD_SET_PERIODIC_PAR, param);
	WARN_ON(ret < 0);
}

static int dwc3_ep0_set_sel(struct dwc3 *dwc, struct usb_ctrlrequest *ctrl)
{
	struct dwc3_ep	*dep;
620
	enum usb_device_state state = dwc->gadget.state;
621 622 623
	u16		wLength;
	u16		wValue;

624
	if (state == USB_STATE_DEFAULT)
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
		return -EINVAL;

	wValue = le16_to_cpu(ctrl->wValue);
	wLength = le16_to_cpu(ctrl->wLength);

	if (wLength != 6) {
		dev_err(dwc->dev, "Set SEL should be 6 bytes, got %d\n",
				wLength);
		return -EINVAL;
	}

	/*
	 * To handle Set SEL we need to receive 6 bytes from Host. So let's
	 * queue a usb_request for 6 bytes.
	 *
	 * Remember, though, this controller can't handle non-wMaxPacketSize
	 * aligned transfers on the OUT direction, so we queue a request for
	 * wMaxPacketSize instead.
	 */
	dep = dwc->eps[0];
	dwc->ep0_usb_req.dep = dep;
	dwc->ep0_usb_req.request.length = dep->endpoint.maxpacket;
	dwc->ep0_usb_req.request.buf = dwc->setup_buf;
	dwc->ep0_usb_req.request.complete = dwc3_ep0_set_sel_cmpl;

	return __dwc3_gadget_ep0_queue(dep, &dwc->ep0_usb_req);
}

653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
static int dwc3_ep0_set_isoch_delay(struct dwc3 *dwc, struct usb_ctrlrequest *ctrl)
{
	u16		wLength;
	u16		wValue;
	u16		wIndex;

	wValue = le16_to_cpu(ctrl->wValue);
	wLength = le16_to_cpu(ctrl->wLength);
	wIndex = le16_to_cpu(ctrl->wIndex);

	if (wIndex || wLength)
		return -EINVAL;

	/*
	 * REVISIT It's unclear from Databook what to do with this
	 * value. For now, just cache it.
	 */
	dwc->isoch_delay = wValue;

	return 0;
}

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
static int dwc3_ep0_std_request(struct dwc3 *dwc, struct usb_ctrlrequest *ctrl)
{
	int ret;

	switch (ctrl->bRequest) {
	case USB_REQ_GET_STATUS:
		dev_vdbg(dwc->dev, "USB_REQ_GET_STATUS\n");
		ret = dwc3_ep0_handle_status(dwc, ctrl);
		break;
	case USB_REQ_CLEAR_FEATURE:
		dev_vdbg(dwc->dev, "USB_REQ_CLEAR_FEATURE\n");
		ret = dwc3_ep0_handle_feature(dwc, ctrl, 0);
		break;
	case USB_REQ_SET_FEATURE:
		dev_vdbg(dwc->dev, "USB_REQ_SET_FEATURE\n");
		ret = dwc3_ep0_handle_feature(dwc, ctrl, 1);
		break;
	case USB_REQ_SET_ADDRESS:
		dev_vdbg(dwc->dev, "USB_REQ_SET_ADDRESS\n");
		ret = dwc3_ep0_set_address(dwc, ctrl);
		break;
	case USB_REQ_SET_CONFIGURATION:
		dev_vdbg(dwc->dev, "USB_REQ_SET_CONFIGURATION\n");
		ret = dwc3_ep0_set_config(dwc, ctrl);
		break;
700 701 702 703
	case USB_REQ_SET_SEL:
		dev_vdbg(dwc->dev, "USB_REQ_SET_SEL\n");
		ret = dwc3_ep0_set_sel(dwc, ctrl);
		break;
704 705 706 707
	case USB_REQ_SET_ISOCH_DELAY:
		dev_vdbg(dwc->dev, "USB_REQ_SET_ISOCH_DELAY\n");
		ret = dwc3_ep0_set_isoch_delay(dwc, ctrl);
		break;
708 709 710 711 712 713 714 715 716 717 718 719 720
	default:
		dev_vdbg(dwc->dev, "Forwarding to gadget driver\n");
		ret = dwc3_ep0_delegate_req(dwc, ctrl);
		break;
	};

	return ret;
}

static void dwc3_ep0_inspect_setup(struct dwc3 *dwc,
		const struct dwc3_event_depevt *event)
{
	struct usb_ctrlrequest *ctrl = dwc->ctrl_req;
721
	int ret = -EINVAL;
722 723 724
	u32 len;

	if (!dwc->gadget_driver)
725
		goto out;
726 727

	len = le16_to_cpu(ctrl->wLength);
728
	if (!len) {
729 730
		dwc->three_stage_setup = false;
		dwc->ep0_expect_in = false;
731 732
		dwc->ep0_next_event = DWC3_EP0_NRDY_STATUS;
	} else {
733 734
		dwc->three_stage_setup = true;
		dwc->ep0_expect_in = !!(ctrl->bRequestType & USB_DIR_IN);
735 736
		dwc->ep0_next_event = DWC3_EP0_NRDY_DATA;
	}
737 738 739 740 741 742

	if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
		ret = dwc3_ep0_std_request(dwc, ctrl);
	else
		ret = dwc3_ep0_delegate_req(dwc, ctrl);

743 744 745
	if (ret == USB_GADGET_DELAYED_STATUS)
		dwc->delayed_status = true;

746 747 748
out:
	if (ret < 0)
		dwc3_ep0_stall_and_restart(dwc);
749 750 751 752 753 754 755
}

static void dwc3_ep0_complete_data(struct dwc3 *dwc,
		const struct dwc3_event_depevt *event)
{
	struct dwc3_request	*r = NULL;
	struct usb_request	*ur;
756
	struct dwc3_trb		*trb;
757
	struct dwc3_ep		*ep0;
758
	u32			transferred;
759
	u32			status;
760
	u32			length;
761 762 763
	u8			epnum;

	epnum = event->endpoint_number;
764
	ep0 = dwc->eps[0];
765

766 767
	dwc->ep0_next_event = DWC3_EP0_NRDY_STATUS;

768
	r = next_request(&ep0->request_list);
769
	ur = &r->request;
770

771
	trb = dwc->ep0_trb;
772 773 774 775 776 777 778 779 780 781 782

	status = DWC3_TRB_SIZE_TRBSTS(trb->size);
	if (status == DWC3_TRBSTS_SETUP_PENDING) {
		dev_dbg(dwc->dev, "Setup Pending received\n");

		if (r)
			dwc3_gadget_giveback(ep0, r, -ECONNRESET);

		return;
	}

783
	length = trb->size & DWC3_TRB_SIZE_MASK;
784

785
	if (dwc->ep0_bounced) {
786 787 788 789
		unsigned transfer_size = ur->length;
		unsigned maxp = ep0->endpoint.maxpacket;

		transfer_size += (maxp - (transfer_size % maxp));
790
		transferred = min_t(u32, ur->length,
791
				transfer_size - length);
792 793
		memcpy(ur->buf, dwc->ep0_bounce, transferred);
	} else {
794
		transferred = ur->length - length;
795
	}
796

797 798
	ur->actual += transferred;

799 800 801 802 803 804 805 806 807 808
	if ((epnum & 1) && ur->actual < ur->length) {
		/* for some reason we did not get everything out */

		dwc3_ep0_stall_and_restart(dwc);
	} else {
		/*
		 * handle the case where we have to send a zero packet. This
		 * seems to be case when req.length > maxpacket. Could it be?
		 */
		if (r)
809
			dwc3_gadget_giveback(ep0, r, 0);
810 811 812
	}
}

813
static void dwc3_ep0_complete_status(struct dwc3 *dwc,
814 815 816 817
		const struct dwc3_event_depevt *event)
{
	struct dwc3_request	*r;
	struct dwc3_ep		*dep;
818 819
	struct dwc3_trb		*trb;
	u32			status;
820

821
	dep = dwc->eps[0];
822
	trb = dwc->ep0_trb;
823 824 825 826 827 828 829

	if (!list_empty(&dep->request_list)) {
		r = next_request(&dep->request_list);

		dwc3_gadget_giveback(dep, r, 0);
	}

830 831 832 833 834 835 836 837
	if (dwc->test_mode) {
		int ret;

		ret = dwc3_gadget_set_test_mode(dwc, dwc->test_mode_nr);
		if (ret < 0) {
			dev_dbg(dwc->dev, "Invalid Test #%d\n",
					dwc->test_mode_nr);
			dwc3_ep0_stall_and_restart(dwc);
838
			return;
839 840 841
		}
	}

842 843 844 845
	status = DWC3_TRB_SIZE_TRBSTS(trb->size);
	if (status == DWC3_TRBSTS_SETUP_PENDING)
		dev_dbg(dwc->dev, "Setup Pending received\n");

846
	dwc->ep0state = EP0_SETUP_PHASE;
847 848 849 850 851 852
	dwc3_ep0_out_start(dwc);
}

static void dwc3_ep0_xfer_complete(struct dwc3 *dwc,
			const struct dwc3_event_depevt *event)
{
853 854 855
	struct dwc3_ep		*dep = dwc->eps[event->endpoint_number];

	dep->flags &= ~DWC3_EP_BUSY;
856
	dep->resource_index = 0;
857
	dwc->setup_packet_pending = false;
858

859
	switch (dwc->ep0state) {
860 861
	case EP0_SETUP_PHASE:
		dev_vdbg(dwc->dev, "Inspecting Setup Bytes\n");
862 863 864
		dwc3_ep0_inspect_setup(dwc, event);
		break;

865 866
	case EP0_DATA_PHASE:
		dev_vdbg(dwc->dev, "Data Phase\n");
867 868 869
		dwc3_ep0_complete_data(dwc, event);
		break;

870 871
	case EP0_STATUS_PHASE:
		dev_vdbg(dwc->dev, "Status Phase\n");
872
		dwc3_ep0_complete_status(dwc, event);
873
		break;
874 875 876 877
	default:
		WARN(true, "UNKNOWN ep0state %d\n", dwc->ep0state);
	}
}
878

879 880
static void __dwc3_ep0_do_control_data(struct dwc3 *dwc,
		struct dwc3_ep *dep, struct dwc3_request *req)
881 882 883
{
	int			ret;

884
	req->direction = !!dep->number;
885 886

	if (req->request.length == 0) {
887
		ret = dwc3_ep0_start_trans(dwc, dep->number,
888 889
				dwc->ctrl_req_addr, 0,
				DWC3_TRBCTL_CONTROL_DATA);
890
	} else if (!IS_ALIGNED(req->request.length, dep->endpoint.maxpacket)
891
			&& (dep->number == 0)) {
892 893
		u32	transfer_size;
		u32	maxpacket;
894

895
		ret = usb_gadget_map_request(&dwc->gadget, &req->request,
896
				dep->number);
897 898 899 900
		if (ret) {
			dev_dbg(dwc->dev, "failed to map request\n");
			return;
		}
901

902
		WARN_ON(req->request.length > DWC3_EP0_BOUNCE_SIZE);
903

904 905
		maxpacket = dep->endpoint.maxpacket;
		transfer_size = roundup(req->request.length, maxpacket);
906

907 908 909
		dwc->ep0_bounced = true;

		/*
910 911 912
		 * REVISIT in case request length is bigger than
		 * DWC3_EP0_BOUNCE_SIZE we will need two chained
		 * TRBs to handle the transfer.
913
		 */
914 915
		ret = dwc3_ep0_start_trans(dwc, dep->number,
				dwc->ep0_bounce_addr, transfer_size,
916 917
				DWC3_TRBCTL_CONTROL_DATA);
	} else {
918
		ret = usb_gadget_map_request(&dwc->gadget, &req->request,
919
				dep->number);
920 921 922 923
		if (ret) {
			dev_dbg(dwc->dev, "failed to map request\n");
			return;
		}
924

925 926
		ret = dwc3_ep0_start_trans(dwc, dep->number, req->request.dma,
				req->request.length, DWC3_TRBCTL_CONTROL_DATA);
927 928 929
	}

	WARN_ON(ret < 0);
930 931
}

932
static int dwc3_ep0_start_control_status(struct dwc3_ep *dep)
933
{
934
	struct dwc3		*dwc = dep->dwc;
935
	u32			type;
936

937 938 939
	type = dwc->three_stage_setup ? DWC3_TRBCTL_CONTROL_STATUS3
		: DWC3_TRBCTL_CONTROL_STATUS2;

940
	return dwc3_ep0_start_trans(dwc, dep->number,
941
			dwc->ctrl_req_addr, 0, type);
942
}
943

944
static void __dwc3_ep0_do_control_status(struct dwc3 *dwc, struct dwc3_ep *dep)
945
{
946 947 948 949 950 951
	if (dwc->resize_fifos) {
		dev_dbg(dwc->dev, "starting to resize fifos\n");
		dwc3_gadget_resize_tx_fifos(dwc);
		dwc->resize_fifos = 0;
	}

952
	WARN_ON(dwc3_ep0_start_control_status(dep));
953 954
}

955 956 957 958 959 960 961 962
static void dwc3_ep0_do_control_status(struct dwc3 *dwc,
		const struct dwc3_event_depevt *event)
{
	struct dwc3_ep		*dep = dwc->eps[event->endpoint_number];

	__dwc3_ep0_do_control_status(dwc, dep);
}

963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980
static void dwc3_ep0_end_control_data(struct dwc3 *dwc, struct dwc3_ep *dep)
{
	struct dwc3_gadget_ep_cmd_params params;
	u32			cmd;
	int			ret;

	if (!dep->resource_index)
		return;

	cmd = DWC3_DEPCMD_ENDTRANSFER;
	cmd |= DWC3_DEPCMD_CMDIOC;
	cmd |= DWC3_DEPCMD_PARAM(dep->resource_index);
	memset(&params, 0, sizeof(params));
	ret = dwc3_send_gadget_ep_cmd(dwc, dep->number, cmd, &params);
	WARN_ON_ONCE(ret);
	dep->resource_index = 0;
}

981 982 983
static void dwc3_ep0_xfernotready(struct dwc3 *dwc,
		const struct dwc3_event_depevt *event)
{
984 985
	dwc->setup_packet_pending = true;

986 987 988
	switch (event->status) {
	case DEPEVT_STATUS_CONTROL_DATA:
		dev_vdbg(dwc->dev, "Control Data\n");
989

990
		/*
991 992 993
		 * We already have a DATA transfer in the controller's cache,
		 * if we receive a XferNotReady(DATA) we will ignore it, unless
		 * it's for the wrong direction.
994
		 *
995 996 997
		 * In that case, we must issue END_TRANSFER command to the Data
		 * Phase we already have started and issue SetStall on the
		 * control endpoint.
998 999
		 */
		if (dwc->ep0_expect_in != event->endpoint_number) {
1000 1001
			struct dwc3_ep	*dep = dwc->eps[dwc->ep0_expect_in];

1002
			dev_vdbg(dwc->dev, "Wrong direction for Data phase\n");
1003
			dwc3_ep0_end_control_data(dwc, dep);
1004 1005 1006 1007
			dwc3_ep0_stall_and_restart(dwc);
			return;
		}

1008
		break;
1009

1010
	case DEPEVT_STATUS_CONTROL_STATUS:
1011 1012 1013
		if (dwc->ep0_next_event != DWC3_EP0_NRDY_STATUS)
			return;

1014
		dev_vdbg(dwc->dev, "Control Status\n");
1015

1016 1017
		dwc->ep0state = EP0_STATUS_PHASE;

1018 1019 1020 1021 1022 1023
		if (dwc->delayed_status) {
			WARN_ON_ONCE(event->endpoint_number != 1);
			dev_vdbg(dwc->dev, "Mass Storage delayed status\n");
			return;
		}

1024
		dwc3_ep0_do_control_status(dwc, event);
1025 1026 1027 1028
	}
}

void dwc3_ep0_interrupt(struct dwc3 *dwc,
F
Felipe Balbi 已提交
1029
		const struct dwc3_event_depevt *event)
1030 1031 1032 1033 1034
{
	u8			epnum = event->endpoint_number;

	dev_dbg(dwc->dev, "%s while ep%d%s in state '%s'\n",
			dwc3_ep_event_string(event->endpoint_event),
1035
			epnum >> 1, (epnum & 1) ? "in" : "out",
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
			dwc3_ep0_state_string(dwc->ep0state));

	switch (event->endpoint_event) {
	case DWC3_DEPEVT_XFERCOMPLETE:
		dwc3_ep0_xfer_complete(dwc, event);
		break;

	case DWC3_DEPEVT_XFERNOTREADY:
		dwc3_ep0_xfernotready(dwc, event);
		break;

	case DWC3_DEPEVT_XFERINPROGRESS:
	case DWC3_DEPEVT_RXTXFIFOEVT:
	case DWC3_DEPEVT_STREAMEVT:
	case DWC3_DEPEVT_EPCMDCMPLT:
		break;
	}
}