1 // SPDX-License-Identifier: GPL-1.0+
5 * Copyright (C) 2011 Renesas Solutions Corp.
6 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
8 #include <linux/delay.h>
9 #include <linux/slab.h>
16 #define usbhsp_addr_offset(p) ((usbhs_pipe_number(p) - 1) * 2)
18 #define usbhsp_flags_set(p, f) ((p)->flags |= USBHS_PIPE_FLAGS_##f)
19 #define usbhsp_flags_clr(p, f) ((p)->flags &= ~USBHS_PIPE_FLAGS_##f)
20 #define usbhsp_flags_has(p, f) ((p)->flags & USBHS_PIPE_FLAGS_##f)
21 #define usbhsp_flags_init(p) do {(p)->flags = 0; } while (0)
26 static char *usbhsp_pipe_name
[] = {
27 [USB_ENDPOINT_XFER_CONTROL
] = "DCP",
28 [USB_ENDPOINT_XFER_BULK
] = "BULK",
29 [USB_ENDPOINT_XFER_INT
] = "INT",
30 [USB_ENDPOINT_XFER_ISOC
] = "ISO",
33 char *usbhs_pipe_name(struct usbhs_pipe
*pipe
)
35 return usbhsp_pipe_name
[usbhs_pipe_type(pipe
)];
38 static struct renesas_usbhs_driver_pipe_config
39 *usbhsp_get_pipe_config(struct usbhs_priv
*priv
, int pipe_num
)
41 struct renesas_usbhs_driver_pipe_config
*pipe_configs
=
42 usbhs_get_dparam(priv
, pipe_configs
);
44 return &pipe_configs
[pipe_num
];
48 * DCPCTR/PIPEnCTR functions
50 static void usbhsp_pipectrl_set(struct usbhs_pipe
*pipe
, u16 mask
, u16 val
)
52 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
53 int offset
= usbhsp_addr_offset(pipe
);
55 if (usbhs_pipe_is_dcp(pipe
))
56 usbhs_bset(priv
, DCPCTR
, mask
, val
);
58 usbhs_bset(priv
, PIPEnCTR
+ offset
, mask
, val
);
61 static u16
usbhsp_pipectrl_get(struct usbhs_pipe
*pipe
)
63 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
64 int offset
= usbhsp_addr_offset(pipe
);
66 if (usbhs_pipe_is_dcp(pipe
))
67 return usbhs_read(priv
, DCPCTR
);
69 return usbhs_read(priv
, PIPEnCTR
+ offset
);
75 static void __usbhsp_pipe_xxx_set(struct usbhs_pipe
*pipe
,
76 u16 dcp_reg
, u16 pipe_reg
,
79 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
81 if (usbhs_pipe_is_dcp(pipe
))
82 usbhs_bset(priv
, dcp_reg
, mask
, val
);
84 usbhs_bset(priv
, pipe_reg
, mask
, val
);
87 static u16
__usbhsp_pipe_xxx_get(struct usbhs_pipe
*pipe
,
88 u16 dcp_reg
, u16 pipe_reg
)
90 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
92 if (usbhs_pipe_is_dcp(pipe
))
93 return usbhs_read(priv
, dcp_reg
);
95 return usbhs_read(priv
, pipe_reg
);
99 * DCPCFG/PIPECFG functions
101 static void usbhsp_pipe_cfg_set(struct usbhs_pipe
*pipe
, u16 mask
, u16 val
)
103 __usbhsp_pipe_xxx_set(pipe
, DCPCFG
, PIPECFG
, mask
, val
);
106 static u16
usbhsp_pipe_cfg_get(struct usbhs_pipe
*pipe
)
108 return __usbhsp_pipe_xxx_get(pipe
, DCPCFG
, PIPECFG
);
112 * PIPEnTRN/PIPEnTRE functions
114 static void usbhsp_pipe_trn_set(struct usbhs_pipe
*pipe
, u16 mask
, u16 val
)
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
);
122 * It is impossible to calculate address,
123 * since PIPEnTRN addresses were mapped randomly.
125 #define CASE_PIPExTRN(a) \
127 reg = PIPE ## a ## TRN; \
144 dev_err(dev
, "unknown pipe (%d)\n", num
);
147 __usbhsp_pipe_xxx_set(pipe
, 0, reg
, mask
, val
);
150 static void usbhsp_pipe_tre_set(struct usbhs_pipe
*pipe
, u16 mask
, u16 val
)
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
);
158 * It is impossible to calculate address,
159 * since PIPEnTRE addresses were mapped randomly.
161 #define CASE_PIPExTRE(a) \
163 reg = PIPE ## a ## TRE; \
180 dev_err(dev
, "unknown pipe (%d)\n", num
);
184 __usbhsp_pipe_xxx_set(pipe
, 0, reg
, mask
, val
);
190 static void usbhsp_pipe_buf_set(struct usbhs_pipe
*pipe
, u16 mask
, u16 val
)
192 if (usbhs_pipe_is_dcp(pipe
))
195 __usbhsp_pipe_xxx_set(pipe
, 0, PIPEBUF
, mask
, val
);
201 static void usbhsp_pipe_maxp_set(struct usbhs_pipe
*pipe
, u16 mask
, u16 val
)
203 __usbhsp_pipe_xxx_set(pipe
, DCPMAXP
, PIPEMAXP
, mask
, val
);
207 * pipe control functions
209 static void usbhsp_pipe_select(struct usbhs_pipe
*pipe
)
211 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
214 * On pipe, this is necessary before
215 * accesses to below registers.
217 * PIPESEL : usbhsp_pipe_select
218 * PIPECFG : usbhsp_pipe_cfg_xxx
219 * PIPEBUF : usbhsp_pipe_buf_xxx
220 * PIPEMAXP : usbhsp_pipe_maxp_xxx
225 * if pipe is dcp, no pipe is selected.
226 * it is no problem, because dcp have its register
228 usbhs_write(priv
, PIPESEL
, 0xF & usbhs_pipe_number(pipe
));
231 static int usbhsp_pipe_barrier(struct usbhs_pipe
*pipe
)
233 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
235 u16 mask
= usbhs_mod_is_host(priv
) ? (CSSTS
| PID_MASK
) : PID_MASK
;
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.
253 * - "Pipe Control Registers Switching Procedure"
255 usbhs_write(priv
, CFIFOSEL
, 0);
256 usbhs_pipe_disable(pipe
);
259 if (!(usbhsp_pipectrl_get(pipe
) & mask
))
269 int usbhs_pipe_is_accessible(struct usbhs_pipe
*pipe
)
273 val
= usbhsp_pipectrl_get(pipe
);
283 static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe
*pipe
)
285 u16 pid
= usbhsp_pipectrl_get(pipe
);
291 * "Pipe n Control Register" - "PID"
295 usbhsp_pipectrl_set(pipe
, PID_MASK
, PID_STALL10
);
298 usbhsp_pipectrl_set(pipe
, PID_MASK
, PID_NAK
);
302 void usbhs_pipe_disable(struct usbhs_pipe
*pipe
)
307 /* see "Pipe n Control Register" - "PID" */
308 __usbhsp_pid_try_nak_if_stall(pipe
);
310 usbhsp_pipectrl_set(pipe
, PID_MASK
, PID_NAK
);
313 val
= usbhsp_pipectrl_get(pipe
);
322 void usbhs_pipe_enable(struct usbhs_pipe
*pipe
)
324 /* see "Pipe n Control Register" - "PID" */
325 __usbhsp_pid_try_nak_if_stall(pipe
);
327 usbhsp_pipectrl_set(pipe
, PID_MASK
, PID_BUF
);
330 void usbhs_pipe_stall(struct usbhs_pipe
*pipe
)
332 u16 pid
= usbhsp_pipectrl_get(pipe
);
338 * "Pipe n Control Register" - "PID"
342 usbhsp_pipectrl_set(pipe
, PID_MASK
, PID_STALL10
);
345 usbhsp_pipectrl_set(pipe
, PID_MASK
, PID_STALL11
);
350 int usbhs_pipe_is_stall(struct usbhs_pipe
*pipe
)
352 u16 pid
= usbhsp_pipectrl_get(pipe
) & PID_MASK
;
354 return (int)(pid
== PID_STALL10
|| pid
== PID_STALL11
);
357 void usbhs_pipe_set_trans_count_if_bulk(struct usbhs_pipe
*pipe
, int len
)
359 if (!usbhs_pipe_type_is(pipe
, USB_ENDPOINT_XFER_BULK
))
363 * clear and disable transfer counter for IN/OUT pipe
365 usbhsp_pipe_tre_set(pipe
, TRCLR
| TRENB
, TRCLR
);
368 * Only IN direction bulk pipe can use transfer count.
369 * Without using this function,
370 * received data will break if it was large data size.
371 * see PIPEnTRN/PIPEnTRE for detail
373 if (usbhs_pipe_is_dir_in(pipe
)) {
374 int maxp
= usbhs_pipe_get_maxpacket(pipe
);
376 usbhsp_pipe_trn_set(pipe
, 0xffff, DIV_ROUND_UP(len
, maxp
));
377 usbhsp_pipe_tre_set(pipe
, TRENB
, TRENB
); /* enable */
385 static int usbhsp_setup_pipecfg(struct usbhs_pipe
*pipe
, int is_host
,
386 int dir_in
, u16
*pipecfg
)
395 static const u16 type_array
[] = {
396 [USB_ENDPOINT_XFER_BULK
] = TYPE_BULK
,
397 [USB_ENDPOINT_XFER_INT
] = TYPE_INT
,
398 [USB_ENDPOINT_XFER_ISOC
] = TYPE_ISO
,
401 if (usbhs_pipe_is_dcp(pipe
))
408 * - "Register Descriptions" - "PIPECFG" register
409 * - "Features" - "Pipe configuration"
410 * - "Operation" - "Pipe Control"
414 type
= type_array
[usbhs_pipe_type(pipe
)];
417 if (usbhs_pipe_type_is(pipe
, USB_ENDPOINT_XFER_ISOC
) ||
418 usbhs_pipe_type_is(pipe
, USB_ENDPOINT_XFER_BULK
))
419 bfre
= 0; /* FIXME */
421 /* DBLB: see usbhs_pipe_config_update() */
424 if (usbhs_pipe_type_is(pipe
, USB_ENDPOINT_XFER_BULK
))
425 cntmd
= 0; /* FIXME */
429 usbhsp_flags_set(pipe
, IS_DIR_HOST
);
431 if (!!is_host
^ !!dir_in
)
435 usbhsp_flags_set(pipe
, IS_DIR_IN
);
438 if (usbhs_pipe_type_is(pipe
, USB_ENDPOINT_XFER_BULK
) &&
443 epnum
= 0; /* see usbhs_pipe_config_update() */
454 static u16
usbhsp_setup_pipebuff(struct usbhs_pipe
*pipe
)
456 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
457 struct device
*dev
= usbhs_priv_to_dev(priv
);
458 int pipe_num
= usbhs_pipe_number(pipe
);
462 struct renesas_usbhs_driver_pipe_config
*pipe_config
=
463 usbhsp_get_pipe_config(priv
, pipe_num
);
469 * - "Register Descriptions" - "PIPEBUF" register
470 * - "Features" - "Pipe configuration"
471 * - "Operation" - "FIFO Buffer Memory"
472 * - "Operation" - "Pipe Control"
474 buff_size
= pipe_config
->bufsize
;
475 bufnmb
= pipe_config
->bufnum
;
477 /* change buff_size to register value */
478 bufnmb_cnt
= (buff_size
/ 64) - 1;
480 dev_dbg(dev
, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n",
481 pipe_num
, buff_size
, bufnmb
);
483 return (0x1f & bufnmb_cnt
) << 10 |
484 (0xff & bufnmb
) << 0;
487 void usbhs_pipe_config_update(struct usbhs_pipe
*pipe
, u16 devsel
,
490 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
491 int pipe_num
= usbhs_pipe_number(pipe
);
492 struct renesas_usbhs_driver_pipe_config
*pipe_config
=
493 usbhsp_get_pipe_config(priv
, pipe_num
);
494 u16 dblb
= pipe_config
->double_buf
? DBLB
: 0;
497 struct device
*dev
= usbhs_priv_to_dev(priv
);
499 dev_err(dev
, "devsel error %d\n", devsel
);
504 usbhsp_pipe_barrier(pipe
);
508 usbhsp_pipe_select(pipe
);
509 usbhsp_pipe_maxp_set(pipe
, 0xFFFF,
513 if (!usbhs_pipe_is_dcp(pipe
))
514 usbhsp_pipe_cfg_set(pipe
, 0x000F | DBLB
, epnum
| dblb
);
520 int usbhs_pipe_get_maxpacket(struct usbhs_pipe
*pipe
)
524 * usbhs_pipe_config_update()
530 int usbhs_pipe_is_dir_in(struct usbhs_pipe
*pipe
)
532 return usbhsp_flags_has(pipe
, IS_DIR_IN
);
535 int usbhs_pipe_is_dir_host(struct usbhs_pipe
*pipe
)
537 return usbhsp_flags_has(pipe
, IS_DIR_HOST
);
540 int usbhs_pipe_is_running(struct usbhs_pipe
*pipe
)
542 return usbhsp_flags_has(pipe
, IS_RUNNING
);
545 void usbhs_pipe_running(struct usbhs_pipe
*pipe
, int running
)
548 usbhsp_flags_set(pipe
, IS_RUNNING
);
550 usbhsp_flags_clr(pipe
, IS_RUNNING
);
553 void usbhs_pipe_data_sequence(struct usbhs_pipe
*pipe
, int sequence
)
555 u16 mask
= (SQCLR
| SQSET
);
575 usbhsp_pipectrl_set(pipe
, mask
, val
);
578 static int usbhs_pipe_get_data_sequence(struct usbhs_pipe
*pipe
)
580 return !!(usbhsp_pipectrl_get(pipe
) & SQMON
);
583 void usbhs_pipe_clear(struct usbhs_pipe
*pipe
)
585 if (usbhs_pipe_is_dcp(pipe
)) {
586 usbhs_fifo_clear_dcp(pipe
);
588 usbhsp_pipectrl_set(pipe
, ACLRM
, ACLRM
);
589 usbhsp_pipectrl_set(pipe
, ACLRM
, 0);
593 /* Should call usbhsp_pipe_select() before */
594 void usbhs_pipe_clear_without_sequence(struct usbhs_pipe
*pipe
,
595 int needs_bfre
, int bfre_enable
)
599 usbhsp_pipe_select(pipe
);
600 sequence
= usbhs_pipe_get_data_sequence(pipe
);
602 usbhsp_pipe_cfg_set(pipe
, BFRE
, bfre_enable
? BFRE
: 0);
603 usbhs_pipe_clear(pipe
);
604 usbhs_pipe_data_sequence(pipe
, sequence
);
607 void usbhs_pipe_config_change_bfre(struct usbhs_pipe
*pipe
, int enable
)
609 if (usbhs_pipe_is_dcp(pipe
))
612 usbhsp_pipe_select(pipe
);
613 /* check if the driver needs to change the BFRE value */
614 if (!(enable
^ !!(usbhsp_pipe_cfg_get(pipe
) & BFRE
)))
617 usbhs_pipe_clear_without_sequence(pipe
, 1, enable
);
620 static struct usbhs_pipe
*usbhsp_get_pipe(struct usbhs_priv
*priv
, u32 type
)
622 struct usbhs_pipe
*pos
, *pipe
;
629 usbhs_for_each_pipe_with_dcp(pos
, priv
, i
) {
630 if (!usbhs_pipe_type_is(pos
, type
))
632 if (usbhsp_flags_has(pos
, IS_USED
))
643 * initialize pipe flags
645 usbhsp_flags_init(pipe
);
646 usbhsp_flags_set(pipe
, IS_USED
);
651 static void usbhsp_put_pipe(struct usbhs_pipe
*pipe
)
653 usbhsp_flags_init(pipe
);
656 void usbhs_pipe_init(struct usbhs_priv
*priv
,
657 int (*dma_map_ctrl
)(struct device
*dma_dev
,
658 struct usbhs_pkt
*pkt
, int map
))
660 struct usbhs_pipe_info
*info
= usbhs_priv_to_pipeinfo(priv
);
661 struct usbhs_pipe
*pipe
;
664 usbhs_for_each_pipe_with_dcp(pipe
, priv
, i
) {
665 usbhsp_flags_init(pipe
);
667 pipe
->mod_private
= NULL
;
668 INIT_LIST_HEAD(&pipe
->list
);
670 /* pipe force init */
671 usbhs_pipe_clear(pipe
);
674 info
->dma_map_ctrl
= dma_map_ctrl
;
677 struct usbhs_pipe
*usbhs_pipe_malloc(struct usbhs_priv
*priv
,
681 struct device
*dev
= usbhs_priv_to_dev(priv
);
682 struct usbhs_pipe
*pipe
;
683 int is_host
= usbhs_mod_is_host(priv
);
685 u16 pipecfg
, pipebuf
;
687 pipe
= usbhsp_get_pipe(priv
, endpoint_type
);
689 dev_err(dev
, "can't get pipe (%s)\n",
690 usbhsp_pipe_name
[endpoint_type
]);
694 INIT_LIST_HEAD(&pipe
->list
);
696 usbhs_pipe_disable(pipe
);
698 /* make sure pipe is not busy */
699 ret
= usbhsp_pipe_barrier(pipe
);
701 dev_err(dev
, "pipe setup failed %d\n", usbhs_pipe_number(pipe
));
705 if (usbhsp_setup_pipecfg(pipe
, is_host
, dir_in
, &pipecfg
)) {
706 dev_err(dev
, "can't setup pipe\n");
710 pipebuf
= usbhsp_setup_pipebuff(pipe
);
712 usbhsp_pipe_select(pipe
);
713 usbhsp_pipe_cfg_set(pipe
, 0xFFFF, pipecfg
);
714 usbhsp_pipe_buf_set(pipe
, 0xFFFF, pipebuf
);
715 usbhs_pipe_clear(pipe
);
717 usbhs_pipe_sequence_data0(pipe
);
719 dev_dbg(dev
, "enable pipe %d : %s (%s)\n",
720 usbhs_pipe_number(pipe
),
721 usbhs_pipe_name(pipe
),
722 usbhs_pipe_is_dir_in(pipe
) ? "in" : "out");
725 * epnum / maxp are still not set to this pipe.
726 * call usbhs_pipe_config_update() after this function !!
732 void usbhs_pipe_free(struct usbhs_pipe
*pipe
)
734 usbhsp_put_pipe(pipe
);
737 void usbhs_pipe_select_fifo(struct usbhs_pipe
*pipe
, struct usbhs_fifo
*fifo
)
740 pipe
->fifo
->pipe
= NULL
;
752 struct usbhs_pipe
*usbhs_dcp_malloc(struct usbhs_priv
*priv
)
754 struct usbhs_pipe
*pipe
;
756 pipe
= usbhsp_get_pipe(priv
, USB_ENDPOINT_XFER_CONTROL
);
760 INIT_LIST_HEAD(&pipe
->list
);
763 * call usbhs_pipe_config_update() after this function !!
769 void usbhs_dcp_control_transfer_done(struct usbhs_pipe
*pipe
)
771 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
773 WARN_ON(!usbhs_pipe_is_dcp(pipe
));
775 usbhs_pipe_enable(pipe
);
777 if (!usbhs_mod_is_host(priv
)) /* funconly */
778 usbhsp_pipectrl_set(pipe
, CCPL
, CCPL
);
781 void usbhs_dcp_dir_for_host(struct usbhs_pipe
*pipe
, int dir_out
)
783 usbhsp_pipe_cfg_set(pipe
, DIR_OUT
,
784 dir_out
? DIR_OUT
: 0);
788 * pipe module function
790 int usbhs_pipe_probe(struct usbhs_priv
*priv
)
792 struct usbhs_pipe_info
*info
= usbhs_priv_to_pipeinfo(priv
);
793 struct usbhs_pipe
*pipe
;
794 struct device
*dev
= usbhs_priv_to_dev(priv
);
795 struct renesas_usbhs_driver_pipe_config
*pipe_configs
=
796 usbhs_get_dparam(priv
, pipe_configs
);
797 int pipe_size
= usbhs_get_dparam(priv
, pipe_size
);
800 /* This driver expects 1st pipe is DCP */
801 if (pipe_configs
[0].type
!= USB_ENDPOINT_XFER_CONTROL
) {
802 dev_err(dev
, "1st PIPE is not DCP\n");
806 info
->pipe
= kzalloc(sizeof(struct usbhs_pipe
) * pipe_size
, GFP_KERNEL
);
810 info
->size
= pipe_size
;
815 usbhs_for_each_pipe_with_dcp(pipe
, priv
, i
) {
818 usbhs_pipe_type(pipe
) =
819 pipe_configs
[i
].type
& USB_ENDPOINT_XFERTYPE_MASK
;
821 dev_dbg(dev
, "pipe %x\t: %s\n",
822 i
, usbhsp_pipe_name
[pipe_configs
[i
].type
]);
828 void usbhs_pipe_remove(struct usbhs_priv
*priv
)
830 struct usbhs_pipe_info
*info
= usbhs_priv_to_pipeinfo(priv
);