1 /*
2 * Renesas USB driver
3 *
4 * Copyright (C) 2011 Renesas Solutions Corp.
5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
15 *
16 */
17 #include <linux/delay.h>
18 #include <linux/slab.h>
19 #include "common.h"
20 #include "pipe.h"
21
22 /*
23 * macros
24 */
25 #define usbhsp_addr_offset(p) ((usbhs_pipe_number(p) - 1) * 2)
26
27 #define usbhsp_flags_set(p, f) ((p)->flags |= USBHS_PIPE_FLAGS_##f)
28 #define usbhsp_flags_clr(p, f) ((p)->flags &= ~USBHS_PIPE_FLAGS_##f)
29 #define usbhsp_flags_has(p, f) ((p)->flags & USBHS_PIPE_FLAGS_##f)
30 #define usbhsp_flags_init(p) do {(p)->flags = 0; } while (0)
31
32 /*
33 * for debug
34 */
35 static char *usbhsp_pipe_name[] = {
36 [USB_ENDPOINT_XFER_CONTROL] = "DCP",
37 [USB_ENDPOINT_XFER_BULK] = "BULK",
38 [USB_ENDPOINT_XFER_INT] = "INT",
39 [USB_ENDPOINT_XFER_ISOC] = "ISO",
40 };
41
usbhs_pipe_name(struct usbhs_pipe * pipe)42 char *usbhs_pipe_name(struct usbhs_pipe *pipe)
43 {
44 return usbhsp_pipe_name[usbhs_pipe_type(pipe)];
45 }
46
47 /*
48 * DCPCTR/PIPEnCTR functions
49 */
usbhsp_pipectrl_set(struct usbhs_pipe * pipe,u16 mask,u16 val)50 static void usbhsp_pipectrl_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
51 {
52 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
53 int offset = usbhsp_addr_offset(pipe);
54
55 if (usbhs_pipe_is_dcp(pipe))
56 usbhs_bset(priv, DCPCTR, mask, val);
57 else
58 usbhs_bset(priv, PIPEnCTR + offset, mask, val);
59 }
60
usbhsp_pipectrl_get(struct usbhs_pipe * pipe)61 static u16 usbhsp_pipectrl_get(struct usbhs_pipe *pipe)
62 {
63 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
64 int offset = usbhsp_addr_offset(pipe);
65
66 if (usbhs_pipe_is_dcp(pipe))
67 return usbhs_read(priv, DCPCTR);
68 else
69 return usbhs_read(priv, PIPEnCTR + offset);
70 }
71
72 /*
73 * DCP/PIPE functions
74 */
__usbhsp_pipe_xxx_set(struct usbhs_pipe * pipe,u16 dcp_reg,u16 pipe_reg,u16 mask,u16 val)75 static void __usbhsp_pipe_xxx_set(struct usbhs_pipe *pipe,
76 u16 dcp_reg, u16 pipe_reg,
77 u16 mask, u16 val)
78 {
79 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
80
81 if (usbhs_pipe_is_dcp(pipe))
82 usbhs_bset(priv, dcp_reg, mask, val);
83 else
84 usbhs_bset(priv, pipe_reg, mask, val);
85 }
86
__usbhsp_pipe_xxx_get(struct usbhs_pipe * pipe,u16 dcp_reg,u16 pipe_reg)87 static u16 __usbhsp_pipe_xxx_get(struct usbhs_pipe *pipe,
88 u16 dcp_reg, u16 pipe_reg)
89 {
90 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
91
92 if (usbhs_pipe_is_dcp(pipe))
93 return usbhs_read(priv, dcp_reg);
94 else
95 return usbhs_read(priv, pipe_reg);
96 }
97
98 /*
99 * DCPCFG/PIPECFG functions
100 */
usbhsp_pipe_cfg_set(struct usbhs_pipe * pipe,u16 mask,u16 val)101 static void usbhsp_pipe_cfg_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
102 {
103 __usbhsp_pipe_xxx_set(pipe, DCPCFG, PIPECFG, mask, val);
104 }
105
usbhsp_pipe_cfg_get(struct usbhs_pipe * pipe)106 static u16 usbhsp_pipe_cfg_get(struct usbhs_pipe *pipe)
107 {
108 return __usbhsp_pipe_xxx_get(pipe, DCPCFG, PIPECFG);
109 }
110
111 /*
112 * PIPEnTRN/PIPEnTRE functions
113 */
usbhsp_pipe_trn_set(struct usbhs_pipe * pipe,u16 mask,u16 val)114 static void usbhsp_pipe_trn_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
115 {
116 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
117 struct device *dev = usbhs_priv_to_dev(priv);
118 int num = usbhs_pipe_number(pipe);
119 u16 reg;
120
121 /*
122 * It is impossible to calculate address,
123 * since PIPEnTRN addresses were mapped randomly.
124 */
125 #define CASE_PIPExTRN(a) \
126 case 0x ## a: \
127 reg = PIPE ## a ## TRN; \
128 break;
129
130 switch (num) {
131 CASE_PIPExTRN(1);
132 CASE_PIPExTRN(2);
133 CASE_PIPExTRN(3);
134 CASE_PIPExTRN(4);
135 CASE_PIPExTRN(5);
136 CASE_PIPExTRN(B);
137 CASE_PIPExTRN(C);
138 CASE_PIPExTRN(D);
139 CASE_PIPExTRN(E);
140 CASE_PIPExTRN(F);
141 CASE_PIPExTRN(9);
142 CASE_PIPExTRN(A);
143 default:
144 dev_err(dev, "unknown pipe (%d)\n", num);
145 return;
146 }
147 __usbhsp_pipe_xxx_set(pipe, 0, reg, mask, val);
148 }
149
usbhsp_pipe_tre_set(struct usbhs_pipe * pipe,u16 mask,u16 val)150 static void usbhsp_pipe_tre_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
151 {
152 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
153 struct device *dev = usbhs_priv_to_dev(priv);
154 int num = usbhs_pipe_number(pipe);
155 u16 reg;
156
157 /*
158 * It is impossible to calculate address,
159 * since PIPEnTRE addresses were mapped randomly.
160 */
161 #define CASE_PIPExTRE(a) \
162 case 0x ## a: \
163 reg = PIPE ## a ## TRE; \
164 break;
165
166 switch (num) {
167 CASE_PIPExTRE(1);
168 CASE_PIPExTRE(2);
169 CASE_PIPExTRE(3);
170 CASE_PIPExTRE(4);
171 CASE_PIPExTRE(5);
172 CASE_PIPExTRE(B);
173 CASE_PIPExTRE(C);
174 CASE_PIPExTRE(D);
175 CASE_PIPExTRE(E);
176 CASE_PIPExTRE(F);
177 CASE_PIPExTRE(9);
178 CASE_PIPExTRE(A);
179 default:
180 dev_err(dev, "unknown pipe (%d)\n", num);
181 return;
182 }
183
184 __usbhsp_pipe_xxx_set(pipe, 0, reg, mask, val);
185 }
186
187 /*
188 * PIPEBUF
189 */
usbhsp_pipe_buf_set(struct usbhs_pipe * pipe,u16 mask,u16 val)190 static void usbhsp_pipe_buf_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
191 {
192 if (usbhs_pipe_is_dcp(pipe))
193 return;
194
195 __usbhsp_pipe_xxx_set(pipe, 0, PIPEBUF, mask, val);
196 }
197
198 /*
199 * DCPMAXP/PIPEMAXP
200 */
usbhsp_pipe_maxp_set(struct usbhs_pipe * pipe,u16 mask,u16 val)201 static void usbhsp_pipe_maxp_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
202 {
203 __usbhsp_pipe_xxx_set(pipe, DCPMAXP, PIPEMAXP, mask, val);
204 }
205
206 /*
207 * pipe control functions
208 */
usbhsp_pipe_select(struct usbhs_pipe * pipe)209 static void usbhsp_pipe_select(struct usbhs_pipe *pipe)
210 {
211 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
212
213 /*
214 * On pipe, this is necessary before
215 * accesses to below registers.
216 *
217 * PIPESEL : usbhsp_pipe_select
218 * PIPECFG : usbhsp_pipe_cfg_xxx
219 * PIPEBUF : usbhsp_pipe_buf_xxx
220 * PIPEMAXP : usbhsp_pipe_maxp_xxx
221 * PIPEPERI
222 */
223
224 /*
225 * if pipe is dcp, no pipe is selected.
226 * it is no problem, because dcp have its register
227 */
228 usbhs_write(priv, PIPESEL, 0xF & usbhs_pipe_number(pipe));
229 }
230
usbhsp_pipe_barrier(struct usbhs_pipe * pipe)231 static int usbhsp_pipe_barrier(struct usbhs_pipe *pipe)
232 {
233 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
234 int timeout = 1024;
235 u16 val;
236
237 /*
238 * make sure....
239 *
240 * Modify these bits when CSSTS = 0, PID = NAK, and no pipe number is
241 * specified by the CURPIPE bits.
242 * When changing the setting of this bit after changing
243 * the PID bits for the selected pipe from BUF to NAK,
244 * check that CSSTS = 0 and PBUSY = 0.
245 */
246
247 /*
248 * CURPIPE bit = 0
249 *
250 * see also
251 * "Operation"
252 * - "Pipe Control"
253 * - "Pipe Control Registers Switching Procedure"
254 */
255 usbhs_write(priv, CFIFOSEL, 0);
256 usbhs_pipe_disable(pipe);
257
258 do {
259 val = usbhsp_pipectrl_get(pipe);
260 val &= CSSTS | PID_MASK;
261 if (!val)
262 return 0;
263
264 udelay(10);
265
266 } while (timeout--);
267
268 return -EBUSY;
269 }
270
usbhs_pipe_is_accessible(struct usbhs_pipe * pipe)271 int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe)
272 {
273 u16 val;
274
275 val = usbhsp_pipectrl_get(pipe);
276 if (val & BSTS)
277 return 0;
278
279 return -EBUSY;
280 }
281
282 /*
283 * PID ctrl
284 */
__usbhsp_pid_try_nak_if_stall(struct usbhs_pipe * pipe)285 static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe *pipe)
286 {
287 u16 pid = usbhsp_pipectrl_get(pipe);
288
289 pid &= PID_MASK;
290
291 /*
292 * see
293 * "Pipe n Control Register" - "PID"
294 */
295 switch (pid) {
296 case PID_STALL11:
297 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
298 /* fall-through */
299 case PID_STALL10:
300 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
301 }
302 }
303
usbhs_pipe_disable(struct usbhs_pipe * pipe)304 void usbhs_pipe_disable(struct usbhs_pipe *pipe)
305 {
306 int timeout = 1024;
307 u16 val;
308
309 /* see "Pipe n Control Register" - "PID" */
310 __usbhsp_pid_try_nak_if_stall(pipe);
311
312 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
313
314 do {
315 val = usbhsp_pipectrl_get(pipe);
316 val &= PBUSY;
317 if (!val)
318 break;
319
320 udelay(10);
321 } while (timeout--);
322 }
323
usbhs_pipe_enable(struct usbhs_pipe * pipe)324 void usbhs_pipe_enable(struct usbhs_pipe *pipe)
325 {
326 /* see "Pipe n Control Register" - "PID" */
327 __usbhsp_pid_try_nak_if_stall(pipe);
328
329 usbhsp_pipectrl_set(pipe, PID_MASK, PID_BUF);
330 }
331
usbhs_pipe_stall(struct usbhs_pipe * pipe)332 void usbhs_pipe_stall(struct usbhs_pipe *pipe)
333 {
334 u16 pid = usbhsp_pipectrl_get(pipe);
335
336 pid &= PID_MASK;
337
338 /*
339 * see
340 * "Pipe n Control Register" - "PID"
341 */
342 switch (pid) {
343 case PID_NAK:
344 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
345 break;
346 case PID_BUF:
347 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL11);
348 break;
349 }
350 }
351
usbhs_pipe_is_stall(struct usbhs_pipe * pipe)352 int usbhs_pipe_is_stall(struct usbhs_pipe *pipe)
353 {
354 u16 pid = usbhsp_pipectrl_get(pipe) & PID_MASK;
355
356 return (int)(pid == PID_STALL10 || pid == PID_STALL11);
357 }
358
usbhs_pipe_set_trans_count_if_bulk(struct usbhs_pipe * pipe,int len)359 void usbhs_pipe_set_trans_count_if_bulk(struct usbhs_pipe *pipe, int len)
360 {
361 if (!usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
362 return;
363
364 /*
365 * clear and disable transfer counter for IN/OUT pipe
366 */
367 usbhsp_pipe_tre_set(pipe, TRCLR | TRENB, TRCLR);
368
369 /*
370 * Only IN direction bulk pipe can use transfer count.
371 * Without using this function,
372 * received data will break if it was large data size.
373 * see PIPEnTRN/PIPEnTRE for detail
374 */
375 if (usbhs_pipe_is_dir_in(pipe)) {
376 int maxp = usbhs_pipe_get_maxpacket(pipe);
377
378 usbhsp_pipe_trn_set(pipe, 0xffff, DIV_ROUND_UP(len, maxp));
379 usbhsp_pipe_tre_set(pipe, TRENB, TRENB); /* enable */
380 }
381 }
382
383
384 /*
385 * pipe setup
386 */
usbhsp_possible_double_buffer(struct usbhs_pipe * pipe)387 static int usbhsp_possible_double_buffer(struct usbhs_pipe *pipe)
388 {
389 /*
390 * only ISO / BULK pipe can use double buffer
391 */
392 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) ||
393 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
394 return 1;
395
396 return 0;
397 }
398
usbhsp_setup_pipecfg(struct usbhs_pipe * pipe,int is_host,int dir_in)399 static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe,
400 int is_host,
401 int dir_in)
402 {
403 u16 type = 0;
404 u16 bfre = 0;
405 u16 dblb = 0;
406 u16 cntmd = 0;
407 u16 dir = 0;
408 u16 epnum = 0;
409 u16 shtnak = 0;
410 u16 type_array[] = {
411 [USB_ENDPOINT_XFER_BULK] = TYPE_BULK,
412 [USB_ENDPOINT_XFER_INT] = TYPE_INT,
413 [USB_ENDPOINT_XFER_ISOC] = TYPE_ISO,
414 };
415 int is_double = usbhsp_possible_double_buffer(pipe);
416
417 if (usbhs_pipe_is_dcp(pipe))
418 return -EINVAL;
419
420 /*
421 * PIPECFG
422 *
423 * see
424 * - "Register Descriptions" - "PIPECFG" register
425 * - "Features" - "Pipe configuration"
426 * - "Operation" - "Pipe Control"
427 */
428
429 /* TYPE */
430 type = type_array[usbhs_pipe_type(pipe)];
431
432 /* BFRE */
433 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
434 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
435 bfre = 0; /* FIXME */
436
437 /* DBLB */
438 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
439 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
440 dblb = (is_double) ? DBLB : 0;
441
442 /* CNTMD */
443 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
444 cntmd = 0; /* FIXME */
445
446 /* DIR */
447 if (dir_in)
448 usbhsp_flags_set(pipe, IS_DIR_HOST);
449
450 if (!!is_host ^ !!dir_in)
451 dir |= DIR_OUT;
452
453 if (!dir)
454 usbhsp_flags_set(pipe, IS_DIR_IN);
455
456 /* SHTNAK */
457 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) &&
458 !dir)
459 shtnak = SHTNAK;
460
461 /* EPNUM */
462 epnum = 0; /* see usbhs_pipe_config_update() */
463
464 return type |
465 bfre |
466 dblb |
467 cntmd |
468 dir |
469 shtnak |
470 epnum;
471 }
472
usbhsp_setup_pipebuff(struct usbhs_pipe * pipe)473 static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe)
474 {
475 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
476 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
477 struct device *dev = usbhs_priv_to_dev(priv);
478 int pipe_num = usbhs_pipe_number(pipe);
479 int is_double = usbhsp_possible_double_buffer(pipe);
480 u16 buff_size;
481 u16 bufnmb;
482 u16 bufnmb_cnt;
483
484 /*
485 * PIPEBUF
486 *
487 * see
488 * - "Register Descriptions" - "PIPEBUF" register
489 * - "Features" - "Pipe configuration"
490 * - "Operation" - "FIFO Buffer Memory"
491 * - "Operation" - "Pipe Control"
492 *
493 * ex) if pipe6 - pipe9 are USB_ENDPOINT_XFER_INT (SH7724)
494 *
495 * BUFNMB: PIPE
496 * 0: pipe0 (DCP 256byte)
497 * 1: -
498 * 2: -
499 * 3: -
500 * 4: pipe6 (INT 64byte)
501 * 5: pipe7 (INT 64byte)
502 * 6: pipe8 (INT 64byte)
503 * 7: pipe9 (INT 64byte)
504 * 8 - xx: free (for BULK, ISOC)
505 */
506
507 /*
508 * FIXME
509 *
510 * it doesn't have good buffer allocator
511 *
512 * DCP : 256 byte
513 * BULK: 512 byte
514 * INT : 64 byte
515 * ISOC: 512 byte
516 */
517 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_CONTROL))
518 buff_size = 256;
519 else if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
520 buff_size = 64;
521 else
522 buff_size = 512;
523
524 /* change buff_size to register value */
525 bufnmb_cnt = (buff_size / 64) - 1;
526
527 /* BUFNMB has been reserved for INT pipe
528 * see above */
529 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT)) {
530 bufnmb = pipe_num - 2;
531 } else {
532 bufnmb = info->bufnmb_last;
533 info->bufnmb_last += bufnmb_cnt + 1;
534
535 /*
536 * double buffer
537 */
538 if (is_double)
539 info->bufnmb_last += bufnmb_cnt + 1;
540 }
541
542 dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n",
543 pipe_num, buff_size, bufnmb);
544
545 return (0x1f & bufnmb_cnt) << 10 |
546 (0xff & bufnmb) << 0;
547 }
548
usbhs_pipe_config_update(struct usbhs_pipe * pipe,u16 devsel,u16 epnum,u16 maxp)549 void usbhs_pipe_config_update(struct usbhs_pipe *pipe, u16 devsel,
550 u16 epnum, u16 maxp)
551 {
552 if (devsel > 0xA) {
553 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
554 struct device *dev = usbhs_priv_to_dev(priv);
555
556 dev_err(dev, "devsel error %d\n", devsel);
557
558 devsel = 0;
559 }
560
561 usbhsp_pipe_barrier(pipe);
562
563 pipe->maxp = maxp;
564
565 usbhsp_pipe_select(pipe);
566 usbhsp_pipe_maxp_set(pipe, 0xFFFF,
567 (devsel << 12) |
568 maxp);
569
570 if (!usbhs_pipe_is_dcp(pipe))
571 usbhsp_pipe_cfg_set(pipe, 0x000F, epnum);
572 }
573
574 /*
575 * pipe control
576 */
usbhs_pipe_get_maxpacket(struct usbhs_pipe * pipe)577 int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe)
578 {
579 /*
580 * see
581 * usbhs_pipe_config_update()
582 * usbhs_dcp_malloc()
583 */
584 return pipe->maxp;
585 }
586
usbhs_pipe_is_dir_in(struct usbhs_pipe * pipe)587 int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe)
588 {
589 return usbhsp_flags_has(pipe, IS_DIR_IN);
590 }
591
usbhs_pipe_is_dir_host(struct usbhs_pipe * pipe)592 int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe)
593 {
594 return usbhsp_flags_has(pipe, IS_DIR_HOST);
595 }
596
usbhs_pipe_is_running(struct usbhs_pipe * pipe)597 int usbhs_pipe_is_running(struct usbhs_pipe *pipe)
598 {
599 return usbhsp_flags_has(pipe, IS_RUNNING);
600 }
601
usbhs_pipe_running(struct usbhs_pipe * pipe,int running)602 void usbhs_pipe_running(struct usbhs_pipe *pipe, int running)
603 {
604 if (running)
605 usbhsp_flags_set(pipe, IS_RUNNING);
606 else
607 usbhsp_flags_clr(pipe, IS_RUNNING);
608 }
609
usbhs_pipe_data_sequence(struct usbhs_pipe * pipe,int sequence)610 void usbhs_pipe_data_sequence(struct usbhs_pipe *pipe, int sequence)
611 {
612 u16 mask = (SQCLR | SQSET);
613 u16 val;
614
615 /*
616 * sequence
617 * 0 : data0
618 * 1 : data1
619 * -1 : no change
620 */
621 switch (sequence) {
622 case 0:
623 val = SQCLR;
624 break;
625 case 1:
626 val = SQSET;
627 break;
628 default:
629 return;
630 }
631
632 usbhsp_pipectrl_set(pipe, mask, val);
633 }
634
usbhs_pipe_get_data_sequence(struct usbhs_pipe * pipe)635 static int usbhs_pipe_get_data_sequence(struct usbhs_pipe *pipe)
636 {
637 return !!(usbhsp_pipectrl_get(pipe) & SQMON);
638 }
639
usbhs_pipe_clear(struct usbhs_pipe * pipe)640 void usbhs_pipe_clear(struct usbhs_pipe *pipe)
641 {
642 if (usbhs_pipe_is_dcp(pipe)) {
643 usbhs_fifo_clear_dcp(pipe);
644 } else {
645 usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
646 usbhsp_pipectrl_set(pipe, ACLRM, 0);
647 }
648 }
649
usbhs_pipe_config_change_bfre(struct usbhs_pipe * pipe,int enable)650 void usbhs_pipe_config_change_bfre(struct usbhs_pipe *pipe, int enable)
651 {
652 int sequence;
653
654 if (usbhs_pipe_is_dcp(pipe))
655 return;
656
657 usbhsp_pipe_select(pipe);
658 /* check if the driver needs to change the BFRE value */
659 if (!(enable ^ !!(usbhsp_pipe_cfg_get(pipe) & BFRE)))
660 return;
661
662 sequence = usbhs_pipe_get_data_sequence(pipe);
663 usbhsp_pipe_cfg_set(pipe, BFRE, enable ? BFRE : 0);
664 usbhs_pipe_clear(pipe);
665 usbhs_pipe_data_sequence(pipe, sequence);
666 }
667
usbhsp_get_pipe(struct usbhs_priv * priv,u32 type)668 static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type)
669 {
670 struct usbhs_pipe *pos, *pipe;
671 int i;
672
673 /*
674 * find target pipe
675 */
676 pipe = NULL;
677 usbhs_for_each_pipe_with_dcp(pos, priv, i) {
678 if (!usbhs_pipe_type_is(pos, type))
679 continue;
680 if (usbhsp_flags_has(pos, IS_USED))
681 continue;
682
683 pipe = pos;
684 break;
685 }
686
687 if (!pipe)
688 return NULL;
689
690 /*
691 * initialize pipe flags
692 */
693 usbhsp_flags_init(pipe);
694 usbhsp_flags_set(pipe, IS_USED);
695
696 return pipe;
697 }
698
usbhsp_put_pipe(struct usbhs_pipe * pipe)699 static void usbhsp_put_pipe(struct usbhs_pipe *pipe)
700 {
701 usbhsp_flags_init(pipe);
702 }
703
usbhs_pipe_init(struct usbhs_priv * priv,int (* dma_map_ctrl)(struct usbhs_pkt * pkt,int map))704 void usbhs_pipe_init(struct usbhs_priv *priv,
705 int (*dma_map_ctrl)(struct usbhs_pkt *pkt, int map))
706 {
707 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
708 struct usbhs_pipe *pipe;
709 int i;
710
711 /*
712 * FIXME
713 *
714 * driver needs good allocator.
715 *
716 * find first free buffer area (BULK, ISOC)
717 * (DCP, INT area is fixed)
718 *
719 * buffer number 0 - 3 have been reserved for DCP
720 * see
721 * usbhsp_to_bufnmb
722 */
723 info->bufnmb_last = 4;
724 usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
725 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
726 info->bufnmb_last++;
727
728 usbhsp_flags_init(pipe);
729 pipe->fifo = NULL;
730 pipe->mod_private = NULL;
731 INIT_LIST_HEAD(&pipe->list);
732
733 /* pipe force init */
734 usbhs_pipe_clear(pipe);
735 }
736
737 info->dma_map_ctrl = dma_map_ctrl;
738 }
739
usbhs_pipe_malloc(struct usbhs_priv * priv,int endpoint_type,int dir_in)740 struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv,
741 int endpoint_type,
742 int dir_in)
743 {
744 struct device *dev = usbhs_priv_to_dev(priv);
745 struct usbhs_pipe *pipe;
746 int is_host = usbhs_mod_is_host(priv);
747 int ret;
748 u16 pipecfg, pipebuf;
749
750 pipe = usbhsp_get_pipe(priv, endpoint_type);
751 if (!pipe) {
752 dev_err(dev, "can't get pipe (%s)\n",
753 usbhsp_pipe_name[endpoint_type]);
754 return NULL;
755 }
756
757 INIT_LIST_HEAD(&pipe->list);
758
759 usbhs_pipe_disable(pipe);
760
761 /* make sure pipe is not busy */
762 ret = usbhsp_pipe_barrier(pipe);
763 if (ret < 0) {
764 dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe));
765 return NULL;
766 }
767
768 pipecfg = usbhsp_setup_pipecfg(pipe, is_host, dir_in);
769 pipebuf = usbhsp_setup_pipebuff(pipe);
770
771 usbhsp_pipe_select(pipe);
772 usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg);
773 usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf);
774 usbhs_pipe_clear(pipe);
775
776 usbhs_pipe_sequence_data0(pipe);
777
778 dev_dbg(dev, "enable pipe %d : %s (%s)\n",
779 usbhs_pipe_number(pipe),
780 usbhs_pipe_name(pipe),
781 usbhs_pipe_is_dir_in(pipe) ? "in" : "out");
782
783 /*
784 * epnum / maxp are still not set to this pipe.
785 * call usbhs_pipe_config_update() after this function !!
786 */
787
788 return pipe;
789 }
790
usbhs_pipe_free(struct usbhs_pipe * pipe)791 void usbhs_pipe_free(struct usbhs_pipe *pipe)
792 {
793 usbhsp_put_pipe(pipe);
794 }
795
usbhs_pipe_select_fifo(struct usbhs_pipe * pipe,struct usbhs_fifo * fifo)796 void usbhs_pipe_select_fifo(struct usbhs_pipe *pipe, struct usbhs_fifo *fifo)
797 {
798 if (pipe->fifo)
799 pipe->fifo->pipe = NULL;
800
801 pipe->fifo = fifo;
802
803 if (fifo)
804 fifo->pipe = pipe;
805 }
806
807
808 /*
809 * dcp control
810 */
usbhs_dcp_malloc(struct usbhs_priv * priv)811 struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv)
812 {
813 struct usbhs_pipe *pipe;
814
815 pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL);
816 if (!pipe)
817 return NULL;
818
819 INIT_LIST_HEAD(&pipe->list);
820
821 /*
822 * call usbhs_pipe_config_update() after this function !!
823 */
824
825 return pipe;
826 }
827
usbhs_dcp_control_transfer_done(struct usbhs_pipe * pipe)828 void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe)
829 {
830 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
831
832 WARN_ON(!usbhs_pipe_is_dcp(pipe));
833
834 usbhs_pipe_enable(pipe);
835
836 if (!usbhs_mod_is_host(priv)) /* funconly */
837 usbhsp_pipectrl_set(pipe, CCPL, CCPL);
838 }
839
usbhs_dcp_dir_for_host(struct usbhs_pipe * pipe,int dir_out)840 void usbhs_dcp_dir_for_host(struct usbhs_pipe *pipe, int dir_out)
841 {
842 usbhsp_pipe_cfg_set(pipe, DIR_OUT,
843 dir_out ? DIR_OUT : 0);
844 }
845
846 /*
847 * pipe module function
848 */
usbhs_pipe_probe(struct usbhs_priv * priv)849 int usbhs_pipe_probe(struct usbhs_priv *priv)
850 {
851 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
852 struct usbhs_pipe *pipe;
853 struct device *dev = usbhs_priv_to_dev(priv);
854 u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
855 int pipe_size = usbhs_get_dparam(priv, pipe_size);
856 int i;
857
858 /* This driver expects 1st pipe is DCP */
859 if (pipe_type[0] != USB_ENDPOINT_XFER_CONTROL) {
860 dev_err(dev, "1st PIPE is not DCP\n");
861 return -EINVAL;
862 }
863
864 info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL);
865 if (!info->pipe) {
866 dev_err(dev, "Could not allocate pipe\n");
867 return -ENOMEM;
868 }
869
870 info->size = pipe_size;
871
872 /*
873 * init pipe
874 */
875 usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
876 pipe->priv = priv;
877
878 usbhs_pipe_type(pipe) =
879 pipe_type[i] & USB_ENDPOINT_XFERTYPE_MASK;
880
881 dev_dbg(dev, "pipe %x\t: %s\n",
882 i, usbhsp_pipe_name[pipe_type[i]]);
883 }
884
885 return 0;
886 }
887
usbhs_pipe_remove(struct usbhs_priv * priv)888 void usbhs_pipe_remove(struct usbhs_priv *priv)
889 {
890 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
891
892 kfree(info->pipe);
893 }
894