1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Cadence CDNSP DRD Driver.
4 *
5 * Copyright (C) 2020 Cadence.
6 *
7 * Author: Pawel Laszczak <pawell@cadence.com>
8 *
9 */
10
11#include <linux/usb/composite.h>
12#include <linux/usb/gadget.h>
13#include <linux/list.h>
14
15#include "cdnsp-gadget.h"
16#include "cdnsp-trace.h"
17
18static void cdnsp_ep0_stall(struct cdnsp_device *pdev)
19{
20	struct cdnsp_request *preq;
21	struct cdnsp_ep *pep;
22
23	pep = &pdev->eps[0];
24	preq = next_request(&pep->pending_list);
25
26	if (pdev->three_stage_setup) {
27		cdnsp_halt_endpoint(pdev, pep, true);
28
29		if (preq)
30			cdnsp_gadget_giveback(pep, preq, -ECONNRESET);
31	} else {
32		pep->ep_state |= EP0_HALTED_STATUS;
33
34		if (preq)
35			list_del(&preq->list);
36
37		cdnsp_status_stage(pdev);
38	}
39}
40
41static int cdnsp_ep0_delegate_req(struct cdnsp_device *pdev,
42				  struct usb_ctrlrequest *ctrl)
43{
44	int ret;
45
46	spin_unlock(&pdev->lock);
47	ret = pdev->gadget_driver->setup(&pdev->gadget, ctrl);
48	spin_lock(&pdev->lock);
49
50	return ret;
51}
52
53static int cdnsp_ep0_set_config(struct cdnsp_device *pdev,
54				struct usb_ctrlrequest *ctrl)
55{
56	enum usb_device_state state = pdev->gadget.state;
57	u32 cfg;
58	int ret;
59
60	cfg = le16_to_cpu(ctrl->wValue);
61
62	switch (state) {
63	case USB_STATE_ADDRESS:
64		trace_cdnsp_ep0_set_config("from Address state");
65		break;
66	case USB_STATE_CONFIGURED:
67		trace_cdnsp_ep0_set_config("from Configured state");
68		break;
69	default:
70		dev_err(pdev->dev, "Set Configuration - bad device state\n");
71		return -EINVAL;
72	}
73
74	ret = cdnsp_ep0_delegate_req(pdev, ctrl);
75	if (ret)
76		return ret;
77
78	if (!cfg)
79		usb_gadget_set_state(&pdev->gadget, USB_STATE_ADDRESS);
80
81	return 0;
82}
83
84static int cdnsp_ep0_set_address(struct cdnsp_device *pdev,
85				 struct usb_ctrlrequest *ctrl)
86{
87	enum usb_device_state state = pdev->gadget.state;
88	struct cdnsp_slot_ctx *slot_ctx;
89	unsigned int slot_state;
90	int ret;
91	u32 addr;
92
93	addr = le16_to_cpu(ctrl->wValue);
94
95	if (addr > 127) {
96		dev_err(pdev->dev, "Invalid device address %d\n", addr);
97		return -EINVAL;
98	}
99
100	slot_ctx = cdnsp_get_slot_ctx(&pdev->out_ctx);
101
102	if (state == USB_STATE_CONFIGURED) {
103		dev_err(pdev->dev, "Can't Set Address from Configured State\n");
104		return -EINVAL;
105	}
106
107	pdev->device_address = le16_to_cpu(ctrl->wValue);
108
109	slot_ctx = cdnsp_get_slot_ctx(&pdev->out_ctx);
110	slot_state = GET_SLOT_STATE(le32_to_cpu(slot_ctx->dev_state));
111	if (slot_state == SLOT_STATE_ADDRESSED)
112		cdnsp_reset_device(pdev);
113
114	/*set device address*/
115	ret = cdnsp_setup_device(pdev, SETUP_CONTEXT_ADDRESS);
116	if (ret)
117		return ret;
118
119	if (addr)
120		usb_gadget_set_state(&pdev->gadget, USB_STATE_ADDRESS);
121	else
122		usb_gadget_set_state(&pdev->gadget, USB_STATE_DEFAULT);
123
124	return 0;
125}
126
127int cdnsp_status_stage(struct cdnsp_device *pdev)
128{
129	pdev->ep0_stage = CDNSP_STATUS_STAGE;
130	pdev->ep0_preq.request.length = 0;
131
132	return cdnsp_ep_enqueue(pdev->ep0_preq.pep, &pdev->ep0_preq);
133}
134
135static int cdnsp_w_index_to_ep_index(u16 wIndex)
136{
137	if (!(wIndex & USB_ENDPOINT_NUMBER_MASK))
138		return 0;
139
140	return ((wIndex & USB_ENDPOINT_NUMBER_MASK) * 2) +
141		(wIndex & USB_ENDPOINT_DIR_MASK ? 1 : 0) - 1;
142}
143
144static int cdnsp_ep0_handle_status(struct cdnsp_device *pdev,
145				   struct usb_ctrlrequest *ctrl)
146{
147	struct cdnsp_ep *pep;
148	__le16 *response;
149	int ep_sts = 0;
150	u16 status = 0;
151	u32 recipient;
152
153	recipient = ctrl->bRequestType & USB_RECIP_MASK;
154
155	switch (recipient) {
156	case USB_RECIP_DEVICE:
157		status = pdev->gadget.is_selfpowered;
158		status |= pdev->may_wakeup << USB_DEVICE_REMOTE_WAKEUP;
159
160		if (pdev->gadget.speed >= USB_SPEED_SUPER) {
161			status |= pdev->u1_allowed << USB_DEV_STAT_U1_ENABLED;
162			status |= pdev->u2_allowed << USB_DEV_STAT_U2_ENABLED;
163		}
164		break;
165	case USB_RECIP_INTERFACE:
166		/*
167		 * Function Remote Wake Capable	D0
168		 * Function Remote Wakeup	D1
169		 */
170		return cdnsp_ep0_delegate_req(pdev, ctrl);
171	case USB_RECIP_ENDPOINT:
172		ep_sts = cdnsp_w_index_to_ep_index(le16_to_cpu(ctrl->wIndex));
173		pep = &pdev->eps[ep_sts];
174		ep_sts = GET_EP_CTX_STATE(pep->out_ctx);
175
176		/* check if endpoint is stalled */
177		if (ep_sts == EP_STATE_HALTED)
178			status =  BIT(USB_ENDPOINT_HALT);
179		break;
180	default:
181		return -EINVAL;
182	}
183
184	response = (__le16 *)pdev->setup_buf;
185	*response = cpu_to_le16(status);
186
187	pdev->ep0_preq.request.length = sizeof(*response);
188	pdev->ep0_preq.request.buf = pdev->setup_buf;
189
190	return cdnsp_ep_enqueue(pdev->ep0_preq.pep, &pdev->ep0_preq);
191}
192
193static void cdnsp_enter_test_mode(struct cdnsp_device *pdev)
194{
195	u32 temp;
196
197	temp = readl(&pdev->active_port->regs->portpmsc) & ~GENMASK(31, 28);
198	temp |= PORT_TEST_MODE(pdev->test_mode);
199	writel(temp, &pdev->active_port->regs->portpmsc);
200}
201
202static int cdnsp_ep0_handle_feature_device(struct cdnsp_device *pdev,
203					   struct usb_ctrlrequest *ctrl,
204					   int set)
205{
206	enum usb_device_state state;
207	enum usb_device_speed speed;
208	u16 tmode;
209
210	state = pdev->gadget.state;
211	speed = pdev->gadget.speed;
212
213	switch (le16_to_cpu(ctrl->wValue)) {
214	case USB_DEVICE_REMOTE_WAKEUP:
215		pdev->may_wakeup = !!set;
216		trace_cdnsp_may_wakeup(set);
217		break;
218	case USB_DEVICE_U1_ENABLE:
219		if (state != USB_STATE_CONFIGURED || speed < USB_SPEED_SUPER)
220			return -EINVAL;
221
222		pdev->u1_allowed = !!set;
223		trace_cdnsp_u1(set);
224		break;
225	case USB_DEVICE_U2_ENABLE:
226		if (state != USB_STATE_CONFIGURED || speed < USB_SPEED_SUPER)
227			return -EINVAL;
228
229		pdev->u2_allowed = !!set;
230		trace_cdnsp_u2(set);
231		break;
232	case USB_DEVICE_LTM_ENABLE:
233		return -EINVAL;
234	case USB_DEVICE_TEST_MODE:
235		if (state != USB_STATE_CONFIGURED || speed > USB_SPEED_HIGH)
236			return -EINVAL;
237
238		tmode = le16_to_cpu(ctrl->wIndex);
239
240		if (!set || (tmode & 0xff) != 0)
241			return -EINVAL;
242
243		tmode = tmode >> 8;
244
245		if (tmode > USB_TEST_FORCE_ENABLE || tmode < USB_TEST_J)
246			return -EINVAL;
247
248		pdev->test_mode = tmode;
249
250		/*
251		 * Test mode must be set before Status Stage but controller
252		 * will start testing sequence after Status Stage.
253		 */
254		cdnsp_enter_test_mode(pdev);
255		break;
256	default:
257		return -EINVAL;
258	}
259
260	return 0;
261}
262
263static int cdnsp_ep0_handle_feature_intf(struct cdnsp_device *pdev,
264					 struct usb_ctrlrequest *ctrl,
265					 int set)
266{
267	u16 wValue, wIndex;
268	int ret;
269
270	wValue = le16_to_cpu(ctrl->wValue);
271	wIndex = le16_to_cpu(ctrl->wIndex);
272
273	switch (wValue) {
274	case USB_INTRF_FUNC_SUSPEND:
275		ret = cdnsp_ep0_delegate_req(pdev, ctrl);
276		if (ret)
277			return ret;
278
279		/*
280		 * Remote wakeup is enabled when any function within a device
281		 * is enabled for function remote wakeup.
282		 */
283		if (wIndex & USB_INTRF_FUNC_SUSPEND_RW)
284			pdev->may_wakeup++;
285		else
286			if (pdev->may_wakeup > 0)
287				pdev->may_wakeup--;
288
289		return 0;
290	default:
291		return -EINVAL;
292	}
293
294	return 0;
295}
296
297static int cdnsp_ep0_handle_feature_endpoint(struct cdnsp_device *pdev,
298					     struct usb_ctrlrequest *ctrl,
299					     int set)
300{
301	struct cdnsp_ep *pep;
302	u16 wValue;
303
304	wValue = le16_to_cpu(ctrl->wValue);
305	pep = &pdev->eps[cdnsp_w_index_to_ep_index(le16_to_cpu(ctrl->wIndex))];
306
307	switch (wValue) {
308	case USB_ENDPOINT_HALT:
309		if (!set && (pep->ep_state & EP_WEDGE)) {
310			/* Resets Sequence Number */
311			cdnsp_halt_endpoint(pdev, pep, 0);
312			cdnsp_halt_endpoint(pdev, pep, 1);
313			break;
314		}
315
316		return cdnsp_halt_endpoint(pdev, pep, set);
317	default:
318		dev_warn(pdev->dev, "WARN Incorrect wValue %04x\n", wValue);
319		return -EINVAL;
320	}
321
322	return 0;
323}
324
325static int cdnsp_ep0_handle_feature(struct cdnsp_device *pdev,
326				    struct usb_ctrlrequest *ctrl,
327				    int set)
328{
329	switch (ctrl->bRequestType & USB_RECIP_MASK) {
330	case USB_RECIP_DEVICE:
331		return cdnsp_ep0_handle_feature_device(pdev, ctrl, set);
332	case USB_RECIP_INTERFACE:
333		return cdnsp_ep0_handle_feature_intf(pdev, ctrl, set);
334	case USB_RECIP_ENDPOINT:
335		return cdnsp_ep0_handle_feature_endpoint(pdev, ctrl, set);
336	default:
337		return -EINVAL;
338	}
339}
340
341static int cdnsp_ep0_set_sel(struct cdnsp_device *pdev,
342			     struct usb_ctrlrequest *ctrl)
343{
344	enum usb_device_state state = pdev->gadget.state;
345	u16 wLength;
346
347	if (state == USB_STATE_DEFAULT)
348		return -EINVAL;
349
350	wLength = le16_to_cpu(ctrl->wLength);
351
352	if (wLength != 6) {
353		dev_err(pdev->dev, "Set SEL should be 6 bytes, got %d\n",
354			wLength);
355		return -EINVAL;
356	}
357
358	/*
359	 * To handle Set SEL we need to receive 6 bytes from Host. So let's
360	 * queue a usb_request for 6 bytes.
361	 */
362	pdev->ep0_preq.request.length = 6;
363	pdev->ep0_preq.request.buf = pdev->setup_buf;
364
365	return cdnsp_ep_enqueue(pdev->ep0_preq.pep, &pdev->ep0_preq);
366}
367
368static int cdnsp_ep0_set_isoch_delay(struct cdnsp_device *pdev,
369				     struct usb_ctrlrequest *ctrl)
370{
371	if (le16_to_cpu(ctrl->wIndex) || le16_to_cpu(ctrl->wLength))
372		return -EINVAL;
373
374	pdev->gadget.isoch_delay = le16_to_cpu(ctrl->wValue);
375
376	return 0;
377}
378
379static int cdnsp_ep0_std_request(struct cdnsp_device *pdev,
380				 struct usb_ctrlrequest *ctrl)
381{
382	int ret;
383
384	switch (ctrl->bRequest) {
385	case USB_REQ_GET_STATUS:
386		ret = cdnsp_ep0_handle_status(pdev, ctrl);
387		break;
388	case USB_REQ_CLEAR_FEATURE:
389		ret = cdnsp_ep0_handle_feature(pdev, ctrl, 0);
390		break;
391	case USB_REQ_SET_FEATURE:
392		ret = cdnsp_ep0_handle_feature(pdev, ctrl, 1);
393		break;
394	case USB_REQ_SET_ADDRESS:
395		ret = cdnsp_ep0_set_address(pdev, ctrl);
396		break;
397	case USB_REQ_SET_CONFIGURATION:
398		ret = cdnsp_ep0_set_config(pdev, ctrl);
399		break;
400	case USB_REQ_SET_SEL:
401		ret = cdnsp_ep0_set_sel(pdev, ctrl);
402		break;
403	case USB_REQ_SET_ISOCH_DELAY:
404		ret = cdnsp_ep0_set_isoch_delay(pdev, ctrl);
405		break;
406	default:
407		ret = cdnsp_ep0_delegate_req(pdev, ctrl);
408		break;
409	}
410
411	return ret;
412}
413
414void cdnsp_setup_analyze(struct cdnsp_device *pdev)
415{
416	struct usb_ctrlrequest *ctrl = &pdev->setup;
417	int ret = -EINVAL;
418	u16 len;
419
420	trace_cdnsp_ctrl_req(ctrl);
421
422	if (!pdev->gadget_driver)
423		goto out;
424
425	if (pdev->gadget.state == USB_STATE_NOTATTACHED) {
426		dev_err(pdev->dev, "ERR: Setup detected in unattached state\n");
427		goto out;
428	}
429
430	/* Restore the ep0 to Stopped/Running state. */
431	if (pdev->eps[0].ep_state & EP_HALTED) {
432		trace_cdnsp_ep0_halted("Restore to normal state");
433		cdnsp_halt_endpoint(pdev, &pdev->eps[0], 0);
434	}
435
436	/*
437	 * Finishing previous SETUP transfer by removing request from
438	 * list and informing upper layer
439	 */
440	if (!list_empty(&pdev->eps[0].pending_list)) {
441		struct cdnsp_request	*req;
442
443		trace_cdnsp_ep0_request("Remove previous");
444		req = next_request(&pdev->eps[0].pending_list);
445		cdnsp_ep_dequeue(&pdev->eps[0], req);
446	}
447
448	len = le16_to_cpu(ctrl->wLength);
449	if (!len) {
450		pdev->three_stage_setup = false;
451		pdev->ep0_expect_in = false;
452	} else {
453		pdev->three_stage_setup = true;
454		pdev->ep0_expect_in = !!(ctrl->bRequestType & USB_DIR_IN);
455	}
456
457	if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
458		ret = cdnsp_ep0_std_request(pdev, ctrl);
459	else
460		ret = cdnsp_ep0_delegate_req(pdev, ctrl);
461
462	if (ret == USB_GADGET_DELAYED_STATUS) {
463		trace_cdnsp_ep0_status_stage("delayed");
464		return;
465	}
466out:
467	if (ret < 0)
468		cdnsp_ep0_stall(pdev);
469	else if (!len && pdev->ep0_stage != CDNSP_STATUS_STAGE)
470		cdnsp_status_stage(pdev);
471}
472