xref: /openbmc/linux/drivers/usb/gadget/udc/bdc/bdc_cmd.c (revision 7563bc73)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * bdc_cmd.c - BRCM BDC USB3.0 device controller
4  *
5  * Copyright (C) 2014 Broadcom Corporation
6  *
7  * Author: Ashwini Pahuja
8  */
9 #include <linux/scatterlist.h>
10 #include <linux/slab.h>
11 
12 #include "bdc.h"
13 #include "bdc_cmd.h"
14 #include "bdc_dbg.h"
15 
16 /* Issues a cmd to cmd processor and waits for cmd completion */
bdc_issue_cmd(struct bdc * bdc,u32 cmd_sc,u32 param0,u32 param1,u32 param2)17 static int bdc_issue_cmd(struct bdc *bdc, u32 cmd_sc, u32 param0,
18 							u32 param1, u32 param2)
19 {
20 	u32 timeout = BDC_CMD_TIMEOUT;
21 	u32 cmd_status;
22 	u32 temp;
23 
24 	bdc_writel(bdc->regs, BDC_CMDPAR0, param0);
25 	bdc_writel(bdc->regs, BDC_CMDPAR1, param1);
26 	bdc_writel(bdc->regs, BDC_CMDPAR2, param2);
27 
28 	/* Issue the cmd */
29 	/* Make sure the cmd params are written before asking HW to exec cmd */
30 	wmb();
31 	bdc_writel(bdc->regs, BDC_CMDSC, cmd_sc | BDC_CMD_CWS | BDC_CMD_SRD);
32 	do {
33 		temp = bdc_readl(bdc->regs, BDC_CMDSC);
34 		dev_dbg_ratelimited(bdc->dev, "cmdsc=%x", temp);
35 		cmd_status =  BDC_CMD_CST(temp);
36 		if (cmd_status != BDC_CMDS_BUSY)  {
37 			dev_dbg(bdc->dev,
38 				"command completed cmd_sts:%x\n", cmd_status);
39 			return cmd_status;
40 		}
41 		udelay(1);
42 	} while (timeout--);
43 
44 	dev_err(bdc->dev,
45 		"command operation timedout cmd_status=%d\n", cmd_status);
46 
47 	return cmd_status;
48 }
49 
50 /* Submits cmd and analyze the return value of bdc_issue_cmd */
bdc_submit_cmd(struct bdc * bdc,u32 cmd_sc,u32 param0,u32 param1,u32 param2)51 static int bdc_submit_cmd(struct bdc *bdc, u32 cmd_sc,
52 					u32 param0, u32 param1,	u32 param2)
53 {
54 	u32 temp, cmd_status;
55 	int ret;
56 
57 	temp = bdc_readl(bdc->regs, BDC_CMDSC);
58 	dev_dbg(bdc->dev,
59 		"%s:CMDSC:%08x cmdsc:%08x param0=%08x param1=%08x param2=%08x\n",
60 		 __func__, temp, cmd_sc, param0, param1, param2);
61 
62 	cmd_status = BDC_CMD_CST(temp);
63 	if (cmd_status  ==  BDC_CMDS_BUSY) {
64 		dev_err(bdc->dev, "command processor busy: %x\n", cmd_status);
65 		return -EBUSY;
66 	}
67 	ret = bdc_issue_cmd(bdc, cmd_sc, param0, param1, param2);
68 	switch (ret) {
69 	case BDC_CMDS_SUCC:
70 		dev_dbg(bdc->dev, "command completed successfully\n");
71 		ret = 0;
72 		break;
73 
74 	case BDC_CMDS_PARA:
75 		dev_err(bdc->dev, "command parameter error\n");
76 		ret = -EINVAL;
77 		break;
78 
79 	case BDC_CMDS_STAT:
80 		dev_err(bdc->dev, "Invalid device/ep state\n");
81 		ret = -EINVAL;
82 		break;
83 
84 	case BDC_CMDS_FAIL:
85 		dev_err(bdc->dev, "Command failed?\n");
86 		ret = -EAGAIN;
87 		break;
88 
89 	case BDC_CMDS_INTL:
90 		dev_err(bdc->dev, "BDC Internal error\n");
91 		ret = -ECONNRESET;
92 		break;
93 
94 	case BDC_CMDS_BUSY:
95 		dev_err(bdc->dev,
96 			"command timedout waited for %dusec\n",
97 			BDC_CMD_TIMEOUT);
98 		ret = -ECONNRESET;
99 		break;
100 	default:
101 		dev_dbg(bdc->dev, "Unknown command completion code:%x\n", ret);
102 	}
103 
104 	return ret;
105 }
106 
107 /* Deconfigure the endpoint from HW */
bdc_dconfig_ep(struct bdc * bdc,struct bdc_ep * ep)108 int bdc_dconfig_ep(struct bdc *bdc, struct bdc_ep *ep)
109 {
110 	u32 cmd_sc;
111 
112 	cmd_sc = BDC_SUB_CMD_DRP_EP|BDC_CMD_EPN(ep->ep_num)|BDC_CMD_EPC;
113 	dev_dbg(bdc->dev, "%s ep->ep_num =%d cmd_sc=%x\n", __func__,
114 							ep->ep_num, cmd_sc);
115 
116 	return bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0);
117 }
118 
119 /* Reinitalize the bdlist after config ep command */
ep_bd_list_reinit(struct bdc_ep * ep)120 static void ep_bd_list_reinit(struct bdc_ep *ep)
121 {
122 	struct bdc *bdc = ep->bdc;
123 	struct bdc_bd *bd;
124 
125 	ep->bd_list.eqp_bdi = 0;
126 	ep->bd_list.hwd_bdi = 0;
127 	bd = ep->bd_list.bd_table_array[0]->start_bd;
128 	dev_dbg(bdc->dev, "%s ep:%p bd:%p\n", __func__, ep, bd);
129 	memset(bd, 0, sizeof(struct bdc_bd));
130 	bd->offset[3] |= cpu_to_le32(BD_SBF);
131 }
132 
133 /* Configure an endpoint */
bdc_config_ep(struct bdc * bdc,struct bdc_ep * ep)134 int bdc_config_ep(struct bdc *bdc, struct bdc_ep *ep)
135 {
136 	const struct usb_ss_ep_comp_descriptor *comp_desc;
137 	const struct usb_endpoint_descriptor	*desc;
138 	u32 param0, param1, param2, cmd_sc;
139 	u32 mps, mbs, mul, si;
140 	int ret;
141 
142 	desc = ep->desc;
143 	comp_desc = ep->comp_desc;
144 	cmd_sc = mul = mbs = param2 = 0;
145 	param0 = lower_32_bits(ep->bd_list.bd_table_array[0]->dma);
146 	param1 = upper_32_bits(ep->bd_list.bd_table_array[0]->dma);
147 	cpu_to_le32s(&param0);
148 	cpu_to_le32s(&param1);
149 
150 	dev_dbg(bdc->dev, "%s: param0=%08x param1=%08x",
151 						__func__, param0, param1);
152 	si = desc->bInterval;
153 	si = clamp_val(si, 1, 16) - 1;
154 
155 	mps = usb_endpoint_maxp(desc);
156 	param2 |= mps << MP_SHIFT;
157 	param2 |= usb_endpoint_type(desc) << EPT_SHIFT;
158 
159 	switch (bdc->gadget.speed) {
160 	case USB_SPEED_SUPER:
161 		if (usb_endpoint_xfer_int(desc) ||
162 					usb_endpoint_xfer_isoc(desc)) {
163 			param2 |= si;
164 			if (usb_endpoint_xfer_isoc(desc) && comp_desc)
165 				mul = comp_desc->bmAttributes;
166 
167 		}
168 		param2 |= mul << EPM_SHIFT;
169 		if (comp_desc)
170 			mbs = comp_desc->bMaxBurst;
171 		param2 |= mbs << MB_SHIFT;
172 		break;
173 
174 	case USB_SPEED_HIGH:
175 		if (usb_endpoint_xfer_isoc(desc) ||
176 					usb_endpoint_xfer_int(desc)) {
177 			param2 |= si;
178 
179 			mbs = usb_endpoint_maxp_mult(desc);
180 			param2 |= mbs << MB_SHIFT;
181 		}
182 		break;
183 
184 	case USB_SPEED_FULL:
185 	case USB_SPEED_LOW:
186 		/* the hardware accepts SI in 125usec range */
187 		if (usb_endpoint_xfer_isoc(desc))
188 			si += 3;
189 
190 		/*
191 		 * FS Int endpoints can have si of 1-255ms but the controller
192 		 * accepts 2^bInterval*125usec, so convert ms to nearest power
193 		 * of 2
194 		 */
195 		if (usb_endpoint_xfer_int(desc))
196 			si = fls(desc->bInterval * 8) - 1;
197 
198 		param2 |= si;
199 		break;
200 	default:
201 		dev_err(bdc->dev, "UNKNOWN speed ERR\n");
202 		return -EINVAL;
203 	}
204 
205 	cmd_sc |= BDC_CMD_EPC|BDC_CMD_EPN(ep->ep_num)|BDC_SUB_CMD_ADD_EP;
206 
207 	dev_dbg(bdc->dev, "cmd_sc=%x param2=%08x\n", cmd_sc, param2);
208 	ret = bdc_submit_cmd(bdc, cmd_sc, param0, param1, param2);
209 	if (ret) {
210 		dev_err(bdc->dev, "command failed :%x\n", ret);
211 		return ret;
212 	}
213 	ep_bd_list_reinit(ep);
214 
215 	return ret;
216 }
217 
218 /*
219  * Change the HW deq pointer, if this command is successful, HW will start
220  * fetching the next bd from address dma_addr.
221  */
bdc_ep_bla(struct bdc * bdc,struct bdc_ep * ep,dma_addr_t dma_addr)222 int bdc_ep_bla(struct bdc *bdc, struct bdc_ep *ep, dma_addr_t dma_addr)
223 {
224 	u32 param0, param1;
225 	u32 cmd_sc = 0;
226 
227 	dev_dbg(bdc->dev, "%s: add=%08llx\n", __func__,
228 				(unsigned long long)(dma_addr));
229 	param0 = lower_32_bits(dma_addr);
230 	param1 = upper_32_bits(dma_addr);
231 	cpu_to_le32s(&param0);
232 	cpu_to_le32s(&param1);
233 
234 	cmd_sc |= BDC_CMD_EPN(ep->ep_num)|BDC_CMD_BLA;
235 	dev_dbg(bdc->dev, "cmd_sc=%x\n", cmd_sc);
236 
237 	return bdc_submit_cmd(bdc, cmd_sc, param0, param1, 0);
238 }
239 
240 /* Set the address sent bu Host in SET_ADD request */
bdc_address_device(struct bdc * bdc,u32 add)241 int bdc_address_device(struct bdc *bdc, u32 add)
242 {
243 	u32 cmd_sc = 0;
244 	u32 param2;
245 
246 	dev_dbg(bdc->dev, "%s: add=%d\n", __func__, add);
247 	cmd_sc |=  BDC_SUB_CMD_ADD|BDC_CMD_DVC;
248 	param2 = add & 0x7f;
249 
250 	return bdc_submit_cmd(bdc, cmd_sc, 0, 0, param2);
251 }
252 
253 /* Send a Function Wake notification packet using FH command */
bdc_function_wake_fh(struct bdc * bdc,u8 intf)254 int bdc_function_wake_fh(struct bdc *bdc, u8 intf)
255 {
256 	u32 param0, param1;
257 	u32 cmd_sc = 0;
258 
259 	param0 = param1 = 0;
260 	dev_dbg(bdc->dev, "%s intf=%d\n", __func__, intf);
261 	cmd_sc  |=  BDC_CMD_FH;
262 	param0 |= TRA_PACKET;
263 	param0 |= (bdc->dev_addr << 25);
264 	param1 |= DEV_NOTF_TYPE;
265 	param1 |= (FWK_SUBTYPE<<4);
266 	dev_dbg(bdc->dev, "param0=%08x param1=%08x\n", param0, param1);
267 
268 	return bdc_submit_cmd(bdc, cmd_sc, param0, param1, 0);
269 }
270 
271 /* Send a Function Wake notification packet using DNC command */
bdc_function_wake(struct bdc * bdc,u8 intf)272 int bdc_function_wake(struct bdc *bdc, u8 intf)
273 {
274 	u32 cmd_sc = 0;
275 	u32 param2 = 0;
276 
277 	dev_dbg(bdc->dev, "%s intf=%d", __func__, intf);
278 	param2 |= intf;
279 	cmd_sc |= BDC_SUB_CMD_FWK|BDC_CMD_DNC;
280 
281 	return bdc_submit_cmd(bdc, cmd_sc, 0, 0, param2);
282 }
283 
284 /* Stall the endpoint */
bdc_ep_set_stall(struct bdc * bdc,int epnum)285 int bdc_ep_set_stall(struct bdc *bdc, int epnum)
286 {
287 	u32 cmd_sc = 0;
288 
289 	dev_dbg(bdc->dev, "%s epnum=%d\n", __func__, epnum);
290 	/* issue a stall endpoint command */
291 	cmd_sc |=  BDC_SUB_CMD_EP_STL | BDC_CMD_EPN(epnum) | BDC_CMD_EPO;
292 
293 	return bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0);
294 }
295 
296 /* resets the endpoint, called when host sends CLEAR_FEATURE(HALT) */
bdc_ep_clear_stall(struct bdc * bdc,int epnum)297 int bdc_ep_clear_stall(struct bdc *bdc, int epnum)
298 {
299 	struct bdc_ep *ep;
300 	u32 cmd_sc = 0;
301 	int ret;
302 
303 	dev_dbg(bdc->dev, "%s: epnum=%d\n", __func__, epnum);
304 	ep = bdc->bdc_ep_array[epnum];
305 	/*
306 	 * If we are not in stalled then stall Endpoint and issue clear stall,
307 	 * his will reset the seq number for non EP0.
308 	 */
309 	if (epnum != 1) {
310 		/* if the endpoint it not stalled */
311 		if (!(ep->flags & BDC_EP_STALL)) {
312 			ret = bdc_ep_set_stall(bdc, epnum);
313 			if (ret)
314 				return ret;
315 		}
316 	}
317 	/* Preserve the seq number for ep0 only */
318 	if (epnum != 1)
319 		cmd_sc |= BDC_CMD_EPO_RST_SN;
320 
321 	/* issue a reset endpoint command */
322 	cmd_sc |=  BDC_SUB_CMD_EP_RST | BDC_CMD_EPN(epnum) | BDC_CMD_EPO;
323 
324 	ret = bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0);
325 	if (ret) {
326 		dev_err(bdc->dev, "command failed:%x\n", ret);
327 		return ret;
328 	}
329 	bdc_notify_xfr(bdc, epnum);
330 
331 	return ret;
332 }
333 
334 /* Stop the endpoint, called when software wants to dequeue some request */
bdc_stop_ep(struct bdc * bdc,int epnum)335 int bdc_stop_ep(struct bdc *bdc, int epnum)
336 {
337 	struct bdc_ep *ep;
338 	u32 cmd_sc = 0;
339 	int ret;
340 
341 	ep = bdc->bdc_ep_array[epnum];
342 	dev_dbg(bdc->dev, "%s: ep:%s ep->flags:%08x\n", __func__,
343 						ep->name, ep->flags);
344 	/* Endpoint has to be in running state to execute stop ep command */
345 	if (!(ep->flags & BDC_EP_ENABLED)) {
346 		dev_err(bdc->dev, "stop endpoint called for disabled ep\n");
347 		return   -EINVAL;
348 	}
349 	if ((ep->flags & BDC_EP_STALL) || (ep->flags & BDC_EP_STOP))
350 		return 0;
351 
352 	/* issue a stop endpoint command */
353 	cmd_sc |= BDC_CMD_EP0_XSD | BDC_SUB_CMD_EP_STP
354 				| BDC_CMD_EPN(epnum) | BDC_CMD_EPO;
355 
356 	ret = bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0);
357 	if (ret) {
358 		dev_err(bdc->dev,
359 			"stop endpoint command didn't complete:%d ep:%s\n",
360 			ret, ep->name);
361 		return ret;
362 	}
363 	ep->flags |= BDC_EP_STOP;
364 	bdc_dump_epsts(bdc);
365 
366 	return ret;
367 }
368