4 * Copyright (C) 2011 Renesas Solutions Corp.
5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
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.
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
17 #include <linux/delay.h>
18 #include <linux/slab.h>
25 #define usbhsp_addr_offset(p) ((usbhs_pipe_number(p) - 1) * 2)
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)
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",
43 * DCPCTR/PIPEnCTR functions
45 static void usbhsp_pipectrl_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
47 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
48 int offset = usbhsp_addr_offset(pipe);
50 if (usbhs_pipe_is_dcp(pipe))
51 usbhs_bset(priv, DCPCTR, mask, val);
53 usbhs_bset(priv, PIPEnCTR + offset, mask, val);
56 static u16 usbhsp_pipectrl_get(struct usbhs_pipe *pipe)
58 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
59 int offset = usbhsp_addr_offset(pipe);
61 if (usbhs_pipe_is_dcp(pipe))
62 return usbhs_read(priv, DCPCTR);
64 return usbhs_read(priv, PIPEnCTR + offset);
70 static void __usbhsp_pipe_xxx_set(struct usbhs_pipe *pipe,
71 u16 dcp_reg, u16 pipe_reg,
74 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
76 if (usbhs_pipe_is_dcp(pipe))
77 usbhs_bset(priv, dcp_reg, mask, val);
79 usbhs_bset(priv, pipe_reg, mask, val);
83 * DCPCFG/PIPECFG functions
85 static void usbhsp_pipe_cfg_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
87 __usbhsp_pipe_xxx_set(pipe, DCPCFG, PIPECFG, mask, val);
93 static void usbhsp_pipe_buf_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
95 if (usbhs_pipe_is_dcp(pipe))
98 __usbhsp_pipe_xxx_set(pipe, 0, PIPEBUF, mask, val);
104 static void usbhsp_pipe_maxp_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
106 __usbhsp_pipe_xxx_set(pipe, DCPMAXP, PIPEMAXP, mask, val);
110 * pipe control functions
112 static void usbhsp_pipe_select(struct usbhs_pipe *pipe)
114 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
117 * On pipe, this is necessary before
118 * accesses to below registers.
120 * PIPESEL : usbhsp_pipe_select
121 * PIPECFG : usbhsp_pipe_cfg_xxx
122 * PIPEBUF : usbhsp_pipe_buf_xxx
123 * PIPEMAXP : usbhsp_pipe_maxp_xxx
128 * if pipe is dcp, no pipe is selected.
129 * it is no problem, because dcp have its register
131 usbhs_write(priv, PIPESEL, 0xF & usbhs_pipe_number(pipe));
134 static int usbhsp_pipe_barrier(struct usbhs_pipe *pipe)
136 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
143 * Modify these bits when CSSTS = 0, PID = NAK, and no pipe number is
144 * specified by the CURPIPE bits.
145 * When changing the setting of this bit after changing
146 * the PID bits for the selected pipe from BUF to NAK,
147 * check that CSSTS = 0 and PBUSY = 0.
156 * - "Pipe Control Registers Switching Procedure"
158 usbhs_write(priv, CFIFOSEL, 0);
159 usbhs_pipe_disable(pipe);
162 val = usbhsp_pipectrl_get(pipe);
163 val &= CSSTS | PID_MASK;
174 int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe)
178 val = usbhsp_pipectrl_get(pipe);
188 static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe *pipe)
190 u16 pid = usbhsp_pipectrl_get(pipe);
196 * "Pipe n Control Register" - "PID"
200 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
203 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
207 void usbhs_pipe_disable(struct usbhs_pipe *pipe)
212 /* see "Pipe n Control Register" - "PID" */
213 __usbhsp_pid_try_nak_if_stall(pipe);
215 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
218 val = usbhsp_pipectrl_get(pipe);
227 void usbhs_pipe_enable(struct usbhs_pipe *pipe)
229 /* see "Pipe n Control Register" - "PID" */
230 __usbhsp_pid_try_nak_if_stall(pipe);
232 usbhsp_pipectrl_set(pipe, PID_MASK, PID_BUF);
235 void usbhs_pipe_stall(struct usbhs_pipe *pipe)
237 u16 pid = usbhsp_pipectrl_get(pipe);
243 * "Pipe n Control Register" - "PID"
247 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
250 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL11);
258 static int usbhsp_possible_double_buffer(struct usbhs_pipe *pipe)
261 * only ISO / BULK pipe can use double buffer
263 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) ||
264 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
270 static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe,
282 [USB_ENDPOINT_XFER_BULK] = TYPE_BULK,
283 [USB_ENDPOINT_XFER_INT] = TYPE_INT,
284 [USB_ENDPOINT_XFER_ISOC] = TYPE_ISO,
286 int is_double = usbhsp_possible_double_buffer(pipe);
288 if (usbhs_pipe_is_dcp(pipe))
295 * - "Register Descriptions" - "PIPECFG" register
296 * - "Features" - "Pipe configuration"
297 * - "Operation" - "Pipe Control"
301 type = type_array[usbhs_pipe_type(pipe)];
304 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
305 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
306 bfre = 0; /* FIXME */
309 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
310 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
311 dblb = (is_double) ? DBLB : 0;
314 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
315 cntmd = 0; /* FIXME */
319 usbhsp_flags_set(pipe, IS_DIR_HOST);
321 if ((is_host && !dir_in) ||
322 (!is_host && dir_in))
326 usbhsp_flags_set(pipe, IS_DIR_IN);
329 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) &&
334 epnum = 0; /* see usbhs_pipe_config_update() */
345 static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe)
347 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
348 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
349 struct device *dev = usbhs_priv_to_dev(priv);
350 int pipe_num = usbhs_pipe_number(pipe);
351 int is_double = usbhsp_possible_double_buffer(pipe);
360 * - "Register Descriptions" - "PIPEBUF" register
361 * - "Features" - "Pipe configuration"
362 * - "Operation" - "FIFO Buffer Memory"
363 * - "Operation" - "Pipe Control"
365 * ex) if pipe6 - pipe9 are USB_ENDPOINT_XFER_INT (SH7724)
368 * 0: pipe0 (DCP 256byte)
372 * 4: pipe6 (INT 64byte)
373 * 5: pipe7 (INT 64byte)
374 * 6: pipe8 (INT 64byte)
375 * 7: pipe9 (INT 64byte)
376 * 8 - xx: free (for BULK, ISOC)
382 * it doesn't have good buffer allocator
389 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_CONTROL))
391 else if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
396 /* change buff_size to register value */
397 bufnmb_cnt = (buff_size / 64) - 1;
399 /* BUFNMB has been reserved for INT pipe
401 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT)) {
402 bufnmb = pipe_num - 2;
404 bufnmb = info->bufnmb_last;
405 info->bufnmb_last += bufnmb_cnt + 1;
411 info->bufnmb_last += bufnmb_cnt + 1;
414 dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n",
415 pipe_num, buff_size, bufnmb);
417 return (0x1f & bufnmb_cnt) << 10 |
418 (0xff & bufnmb) << 0;
421 void usbhs_pipe_config_update(struct usbhs_pipe *pipe, u16 epnum, u16 maxp)
423 usbhsp_pipe_barrier(pipe);
427 usbhsp_pipe_select(pipe);
428 usbhsp_pipe_maxp_set(pipe, 0xFFFF, maxp);
430 if (!usbhs_pipe_is_dcp(pipe))
431 usbhsp_pipe_cfg_set(pipe, 0x000F, epnum);
437 int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe)
441 * usbhs_pipe_config_update()
447 int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe)
449 return usbhsp_flags_has(pipe, IS_DIR_IN);
452 int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe)
454 return usbhsp_flags_has(pipe, IS_DIR_HOST);
457 void usbhs_pipe_clear_sequence(struct usbhs_pipe *pipe)
459 usbhsp_pipectrl_set(pipe, SQCLR, SQCLR);
462 void usbhs_pipe_clear(struct usbhs_pipe *pipe)
464 usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
465 usbhsp_pipectrl_set(pipe, ACLRM, 0);
468 static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type)
470 struct usbhs_pipe *pos, *pipe;
477 usbhs_for_each_pipe_with_dcp(pos, priv, i) {
478 if (!usbhs_pipe_type_is(pos, type))
480 if (usbhsp_flags_has(pos, IS_USED))
491 * initialize pipe flags
493 usbhsp_flags_init(pipe);
494 usbhsp_flags_set(pipe, IS_USED);
499 void usbhs_pipe_init(struct usbhs_priv *priv,
500 void (*done)(struct usbhs_pkt *pkt),
501 int (*dma_map_ctrl)(struct usbhs_pkt *pkt, int map))
503 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
504 struct device *dev = usbhs_priv_to_dev(priv);
505 struct usbhs_pipe *pipe;
509 dev_err(dev, "no done function\n");
516 * driver needs good allocator.
518 * find first free buffer area (BULK, ISOC)
519 * (DCP, INT area is fixed)
521 * buffer number 0 - 3 have been reserved for DCP
525 info->bufnmb_last = 4;
526 usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
527 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
530 usbhsp_flags_init(pipe);
532 pipe->mod_private = NULL;
533 INIT_LIST_HEAD(&pipe->list);
535 /* pipe force init */
536 usbhs_pipe_clear(pipe);
540 info->dma_map_ctrl = dma_map_ctrl;
543 struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv,
547 struct device *dev = usbhs_priv_to_dev(priv);
548 struct usbhs_pipe *pipe;
549 int is_host = usbhs_mod_is_host(priv);
551 u16 pipecfg, pipebuf;
553 pipe = usbhsp_get_pipe(priv, endpoint_type);
555 dev_err(dev, "can't get pipe (%s)\n",
556 usbhsp_pipe_name[endpoint_type]);
560 INIT_LIST_HEAD(&pipe->list);
562 usbhs_pipe_disable(pipe);
564 /* make sure pipe is not busy */
565 ret = usbhsp_pipe_barrier(pipe);
567 dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe));
571 pipecfg = usbhsp_setup_pipecfg(pipe, is_host, dir_in);
572 pipebuf = usbhsp_setup_pipebuff(pipe);
574 usbhsp_pipe_select(pipe);
575 usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg);
576 usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf);
578 usbhs_pipe_clear_sequence(pipe);
580 dev_dbg(dev, "enable pipe %d : %s (%s)\n",
581 usbhs_pipe_number(pipe),
582 usbhsp_pipe_name[endpoint_type],
583 usbhs_pipe_is_dir_in(pipe) ? "in" : "out");
586 * epnum / maxp are still not set to this pipe.
587 * call usbhs_pipe_config_update() after this function !!
593 void usbhs_pipe_select_fifo(struct usbhs_pipe *pipe, struct usbhs_fifo *fifo)
596 pipe->fifo->pipe = NULL;
608 struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv)
610 struct usbhs_pipe *pipe;
612 pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL);
616 INIT_LIST_HEAD(&pipe->list);
619 * call usbhs_pipe_config_update() after this function !!
625 void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe)
627 WARN_ON(!usbhs_pipe_is_dcp(pipe));
629 usbhs_pipe_enable(pipe);
630 usbhsp_pipectrl_set(pipe, CCPL, CCPL);
634 * pipe module function
636 int usbhs_pipe_probe(struct usbhs_priv *priv)
638 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
639 struct usbhs_pipe *pipe;
640 struct device *dev = usbhs_priv_to_dev(priv);
641 u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
642 int pipe_size = usbhs_get_dparam(priv, pipe_size);
645 /* This driver expects 1st pipe is DCP */
646 if (pipe_type[0] != USB_ENDPOINT_XFER_CONTROL) {
647 dev_err(dev, "1st PIPE is not DCP\n");
651 info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL);
653 dev_err(dev, "Could not allocate pipe\n");
657 info->size = pipe_size;
662 usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
665 usbhs_pipe_type(pipe) =
666 pipe_type[i] & USB_ENDPOINT_XFERTYPE_MASK;
668 dev_dbg(dev, "pipe %x\t: %s\n",
669 i, usbhsp_pipe_name[pipe_type[i]]);
675 void usbhs_pipe_remove(struct usbhs_priv *priv)
677 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);