Lines Matching refs:pipe
13 #include "pipe.h"
17 #define usbhsf_fifo_is_busy(f) ((f)->pipe) /* see usbhs_pipe_select_fifo */
32 struct usbhs_priv *priv = usbhs_pipe_to_priv(pkt->pipe);
45 void usbhs_pkt_push(struct usbhs_pipe *pipe, struct usbhs_pkt *pkt,
50 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
62 if (!pipe->handler) {
64 pipe->handler = &usbhsf_null_handler;
67 list_move_tail(&pkt->node, &pipe->list);
74 pkt->pipe = pipe;
76 pkt->handler = pipe->handler;
92 struct usbhs_pkt *__usbhsf_pkt_get(struct usbhs_pipe *pipe)
94 return list_first_entry_or_null(&pipe->list, struct usbhs_pkt, node);
97 static void usbhsf_fifo_unselect(struct usbhs_pipe *pipe,
104 static void usbhsf_tx_irq_ctrl(struct usbhs_pipe *pipe, int enable);
105 static void usbhsf_rx_irq_ctrl(struct usbhs_pipe *pipe, int enable);
106 struct usbhs_pkt *usbhs_pkt_pop(struct usbhs_pipe *pipe, struct usbhs_pkt *pkt)
108 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
109 struct usbhs_fifo *fifo = usbhs_pipe_to_fifo(pipe);
115 usbhs_pipe_disable(pipe);
118 pkt = __usbhsf_pkt_get(pipe);
129 if (usbhs_pipe_is_dir_in(pipe))
130 usbhsf_rx_irq_ctrl(pipe, 0);
132 usbhsf_tx_irq_ctrl(pipe, 0);
135 usbhs_pipe_clear_without_sequence(pipe, 0, 0);
136 usbhs_pipe_running(pipe, 0);
142 usbhsf_fifo_unselect(pipe, fifo);
156 static int usbhsf_pkt_handler(struct usbhs_pipe *pipe, int type)
158 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
169 pkt = __usbhsf_pkt_get(pipe);
200 usbhs_pkt_start(pipe);
206 void usbhs_pkt_start(struct usbhs_pipe *pipe)
208 usbhsf_pkt_handler(pipe, USBHSF_PKT_PREPARE);
216 #define usbhsf_irq_callback_ctrl(pipe, status, enable) \
218 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); \
220 u16 status = (1 << usbhs_pipe_number(pipe)); \
230 static void usbhsf_tx_irq_ctrl(struct usbhs_pipe *pipe, int enable)
233 * And DCP pipe can NOT use "ready interrupt" for "send"
238 * on the other hand, normal pipe can use "ready interrupt" for "send"
241 if (usbhs_pipe_is_dcp(pipe))
242 usbhsf_irq_empty_ctrl(pipe, enable);
244 usbhsf_irq_ready_ctrl(pipe, enable);
247 static void usbhsf_rx_irq_ctrl(struct usbhs_pipe *pipe, int enable)
249 usbhsf_irq_ready_ctrl(pipe, enable);
255 static void usbhsf_send_terminator(struct usbhs_pipe *pipe,
258 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
273 static void usbhsf_fifo_clear(struct usbhs_pipe *pipe,
276 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
279 if (!usbhs_pipe_is_dcp(pipe)) {
281 * This driver checks the pipe condition first to avoid -EBUSY
282 * from usbhsf_fifo_barrier() if the pipe is RX direction and
285 if (usbhs_pipe_is_dir_in(pipe))
286 ret = usbhs_pipe_is_accessible(pipe);
292 * if non-DCP pipe, this driver should set BCLR when
305 static void usbhsf_fifo_unselect(struct usbhs_pipe *pipe,
308 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
310 usbhs_pipe_select_fifo(pipe, NULL);
314 static int usbhsf_fifo_select(struct usbhs_pipe *pipe,
318 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
322 u16 base = usbhs_pipe_number(pipe); /* CURPIPE */
324 if (usbhs_pipe_is_busy(pipe) ||
328 if (usbhs_pipe_is_dcp(pipe)) {
332 usbhs_dcp_dir_for_host(pipe, write);
341 usbhs_pipe_select_fifo(pipe, fifo);
357 struct usbhs_pipe *pipe = pkt->pipe;
358 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
363 usbhs_pipe_disable(pipe);
365 ret = usbhsf_fifo_select(pipe, fifo, 1);
371 usbhs_pipe_sequence_data1(pipe); /* DATA1 */
373 usbhsf_fifo_clear(pipe, fifo);
374 usbhsf_send_terminator(pipe, fifo);
376 usbhsf_fifo_unselect(pipe, fifo);
378 usbhsf_tx_irq_ctrl(pipe, 1);
379 usbhs_pipe_enable(pipe);
386 struct usbhs_pipe *pipe = pkt->pipe;
387 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
392 usbhs_pipe_disable(pipe);
394 ret = usbhsf_fifo_select(pipe, fifo, 0);
400 usbhs_pipe_sequence_data1(pipe); /* DATA1 */
401 usbhsf_fifo_clear(pipe, fifo);
403 usbhsf_fifo_unselect(pipe, fifo);
405 usbhsf_rx_irq_ctrl(pipe, 1);
406 usbhs_pipe_enable(pipe);
414 struct usbhs_pipe *pipe = pkt->pipe;
417 usbhsf_tx_irq_ctrl(pipe, 0);
419 usbhsf_rx_irq_ctrl(pipe, 0);
442 struct usbhs_pipe *pipe = pkt->pipe;
444 usbhs_pipe_sequence_data1(pipe); /* DATA1 */
464 struct usbhs_pipe *pipe = pkt->pipe;
465 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
468 if (usbhs_pipe_is_busy(pipe))
477 usbhs_pipe_disable(pipe);
479 usbhs_pipe_sequence_data1(pipe); /* DATA1 */
481 usbhsf_fifo_select(pipe, fifo, 0);
482 usbhsf_fifo_clear(pipe, fifo);
483 usbhsf_fifo_unselect(pipe, fifo);
502 struct usbhs_pipe *pipe = pkt->pipe;
503 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
508 int maxp = usbhs_pipe_get_maxpacket(pipe);
513 usbhs_pipe_data_sequence(pipe, pkt->sequence);
516 usbhs_pipe_set_trans_count_if_bulk(pipe, pkt->length);
518 ret = usbhsf_fifo_select(pipe, fifo, 1);
522 ret = usbhs_pipe_is_accessible(pipe);
524 /* inaccessible pipe is not an error */
572 * pipe/irq handling
575 usbhsf_send_terminator(pipe, fifo);
577 usbhsf_tx_irq_ctrl(pipe, !*is_done);
578 usbhs_pipe_running(pipe, !*is_done);
579 usbhs_pipe_enable(pipe);
582 usbhs_pipe_number(pipe),
585 usbhsf_fifo_unselect(pipe, fifo);
590 usbhsf_fifo_unselect(pipe, fifo);
593 * pipe is busy.
596 usbhsf_tx_irq_ctrl(pipe, 1);
597 usbhs_pipe_running(pipe, 1);
604 if (usbhs_pipe_is_running(pkt->pipe))
620 struct usbhs_pipe *pipe = pkt->pipe;
621 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
624 if (usbhs_pipe_is_busy(pipe))
627 if (usbhs_pipe_is_running(pipe))
631 * pipe enable to prepare packet receive
633 usbhs_pipe_data_sequence(pipe, pkt->sequence);
636 if (usbhs_pipe_is_dcp(pipe))
637 usbhsf_fifo_clear(pipe, fifo);
639 usbhs_pipe_set_trans_count_if_bulk(pipe, pkt->length);
640 usbhs_pipe_enable(pipe);
641 usbhs_pipe_running(pipe, 1);
642 usbhsf_rx_irq_ctrl(pipe, 1);
649 struct usbhs_pipe *pipe = pkt->pipe;
650 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
656 int maxp = usbhs_pipe_get_maxpacket(pipe);
661 ret = usbhsf_fifo_select(pipe, fifo, 0);
677 * update actual length first here to decide disable pipe.
678 * if this pipe keeps BUF status and all data were popped,
686 usbhsf_rx_irq_ctrl(pipe, 0);
687 usbhs_pipe_running(pipe, 0);
691 * should not disable the pipe. If such a case happens, this
694 if (!usbhs_mod_is_host(priv) && !usbhs_pipe_is_dcp(pipe))
695 usbhs_pipe_disable(pipe); /* disable pipe first */
706 usbhsf_fifo_clear(pipe, fifo);
731 usbhs_pipe_number(pipe),
735 usbhsf_fifo_unselect(pipe, fifo);
750 usbhs_dcp_control_transfer_done(pkt->pipe);
794 static void __usbhsf_dma_ctrl(struct usbhs_pipe *pipe,
798 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
805 struct usbhs_pipe *pipe = pkt->pipe;
806 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
808 struct usbhs_fifo *fifo = usbhs_pipe_to_fifo(pipe);
818 struct usbhs_pipe *pipe = pkt->pipe;
820 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
827 fifo = usbhs_pipe_to_fifo(pipe);
832 dir = usbhs_pipe_is_dir_in(pipe) ? DMA_DEV_TO_MEM : DMA_MEM_TO_DEV;
850 fifo->name, usbhs_pipe_number(pipe), pkt->length, pkt->zero);
852 usbhs_pipe_running(pipe, 1);
853 usbhs_pipe_set_trans_count_if_bulk(pipe, pkt->trans);
855 usbhsf_dma_start(pipe, fifo);
856 usbhs_pipe_enable(pipe);
862 struct usbhs_pipe *pipe = pkt->pipe;
863 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
876 struct usbhs_pipe *pipe = pkt->pipe;
877 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
883 if (usbhs_pipe_is_busy(pipe))
886 /* use PIO if packet is less than pio_dma_border or pipe is DCP */
888 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
901 /* return at this time if the pipe is running */
902 if (usbhs_pipe_is_running(pipe))
910 ret = usbhsf_fifo_select(pipe, fifo, 0);
919 usbhsf_tx_irq_ctrl(pipe, 0);
931 usbhsf_fifo_unselect(pipe, fifo);
943 struct usbhs_pipe *pipe = pkt->pipe;
944 int is_short = pkt->trans % usbhs_pipe_get_maxpacket(pipe);
955 usbhs_pipe_running(pipe, !*is_done);
957 usbhsf_dma_stop(pipe, pipe->fifo);
959 usbhsf_fifo_unselect(pipe, pipe->fifo);
988 struct usbhs_pipe *pipe = pkt->pipe;
989 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
993 if (usbhs_pipe_is_busy(pipe))
996 /* use PIO if packet is less than pio_dma_border or pipe is DCP */
998 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
1008 /* return at this time if the pipe is running */
1009 if (usbhs_pipe_is_running(pipe))
1012 usbhs_pipe_config_change_bfre(pipe, 1);
1014 ret = usbhsf_fifo_select(pipe, fifo, 0);
1028 usbhsf_rx_irq_ctrl(pipe, 0);
1037 usbhsf_fifo_unselect(pipe, fifo);
1044 usbhs_pipe_config_change_bfre(pipe, 0);
1051 struct usbhs_priv *priv = usbhs_pipe_to_priv(pkt->pipe);
1061 struct usbhs_pipe *pipe = pkt->pipe;
1062 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
1066 if (usbhs_pipe_is_busy(pipe))
1069 if (usbhs_pipe_is_dcp(pipe))
1080 ret = usbhsf_fifo_select(pipe, fifo, 0);
1107 usbhsf_rx_irq_ctrl(pipe, 0);
1117 usbhsf_fifo_unselect(pipe, fifo);
1130 struct usbhs_priv *priv = usbhs_pipe_to_priv(pkt->pipe);
1139 struct usbhs_pipe *pipe = pkt->pipe;
1140 int maxp = usbhs_pipe_get_maxpacket(pipe);
1142 usbhsf_dma_stop(pipe, pipe->fifo);
1144 usbhsf_fifo_unselect(pipe, pipe->fifo);
1151 usbhs_pipe_running(pipe, 0);
1154 usbhs_pipe_running(pipe, 0);
1164 struct usbhs_pipe *pipe = pkt->pipe;
1166 int maxp = usbhs_pipe_get_maxpacket(pipe);
1182 struct usbhs_pipe *pipe = pkt->pipe;
1183 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
1184 struct usbhs_fifo *fifo = usbhs_pipe_to_fifo(pipe);
1193 usbhs_xxxsts_clear(priv, BRDYSTS, usbhs_pipe_number(pipe));
1196 usbhsf_fifo_clear(pipe, fifo);
1199 usbhs_pipe_running(pipe, 0);
1200 usbhsf_dma_stop(pipe, fifo);
1202 usbhsf_fifo_unselect(pipe, pipe->fifo);
1212 struct usbhs_priv *priv = usbhs_pipe_to_priv(pkt->pipe);
1317 struct usbhs_pipe *pipe;
1329 * search interrupted "pipe"
1332 usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
1336 ret = usbhsf_pkt_handler(pipe, USBHSF_PKT_TRY_RUN);
1347 struct usbhs_pipe *pipe;
1359 * search interrupted "pipe"
1362 usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
1366 ret = usbhsf_pkt_handler(pipe, USBHSF_PKT_TRY_RUN);
1378 struct usbhs_pipe *pipe = pkt->pipe;
1379 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
1384 ret = usbhsf_pkt_handler(pipe, USBHSF_PKT_DMA_DONE);
1387 usbhs_pipe_number(pipe), ret);
1390 void usbhs_fifo_clear_dcp(struct usbhs_pipe *pipe)
1392 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
1396 if (usbhsf_fifo_select(pipe, fifo, 1) < 0)
1398 usbhsf_fifo_clear(pipe, fifo);
1399 usbhsf_fifo_unselect(pipe, fifo);
1402 if (usbhsf_fifo_select(pipe, fifo, 0) < 0)
1404 usbhsf_fifo_clear(pipe, fifo);
1405 usbhsf_fifo_unselect(pipe, fifo);
1423 cfifo->pipe = NULL;
1425 dfifo->pipe = NULL;