xref: /linux/drivers/usb/cdns3/cdnsp-ep0.c (revision 1ac731c529cd4d6adbce134754b51ff7d822b145)
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 
cdnsp_ep0_stall(struct cdnsp_device * pdev)18 static 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 
cdnsp_ep0_delegate_req(struct cdnsp_device * pdev,struct usb_ctrlrequest * ctrl)41 static 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 
cdnsp_ep0_set_config(struct cdnsp_device * pdev,struct usb_ctrlrequest * ctrl)53 static 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 
cdnsp_ep0_set_address(struct cdnsp_device * pdev,struct usb_ctrlrequest * ctrl)84 static 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 
cdnsp_status_stage(struct cdnsp_device * pdev)127 int 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 
cdnsp_w_index_to_ep_index(u16 wIndex)135 static 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 
cdnsp_ep0_handle_status(struct cdnsp_device * pdev,struct usb_ctrlrequest * ctrl)144 static 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 
cdnsp_enter_test_mode(struct cdnsp_device * pdev)193 static 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 
cdnsp_ep0_handle_feature_device(struct cdnsp_device * pdev,struct usb_ctrlrequest * ctrl,int set)202 static 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 
cdnsp_ep0_handle_feature_intf(struct cdnsp_device * pdev,struct usb_ctrlrequest * ctrl,int set)263 static 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 
cdnsp_ep0_handle_feature_endpoint(struct cdnsp_device * pdev,struct usb_ctrlrequest * ctrl,int set)297 static 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 
cdnsp_ep0_handle_feature(struct cdnsp_device * pdev,struct usb_ctrlrequest * ctrl,int set)325 static 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 
cdnsp_ep0_set_sel(struct cdnsp_device * pdev,struct usb_ctrlrequest * ctrl)341 static 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 
cdnsp_ep0_set_isoch_delay(struct cdnsp_device * pdev,struct usb_ctrlrequest * ctrl)368 static 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 
cdnsp_ep0_std_request(struct cdnsp_device * pdev,struct usb_ctrlrequest * ctrl)379 static 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 
cdnsp_setup_analyze(struct cdnsp_device * pdev)414 void 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 	}
466 out:
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