1
2
3
4
5
6
7
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
17static 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
29
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
51static 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
108int 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
120static 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
134int 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(¶m0);
148 cpu_to_le32s(¶m1);
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
187 if (usb_endpoint_xfer_isoc(desc))
188 si += 3;
189
190
191
192
193
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
220
221
222int 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(¶m0);
232 cpu_to_le32s(¶m1);
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
241int 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
254int 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
272int 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
285int 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
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
297int 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
307
308
309 if (epnum != 1) {
310
311 if (!(ep->flags & BDC_EP_STALL)) {
312 ret = bdc_ep_set_stall(bdc, epnum);
313 if (ret)
314 return ret;
315 }
316 }
317
318 if (epnum != 1)
319 cmd_sc |= BDC_CMD_EPO_RST_SN;
320
321
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
335int 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
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
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