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);
202 usbhs_pkt_start(pipe);
208 void usbhs_pkt_start(struct usbhs_pipe *pipe)
210 usbhsf_pkt_handler(pipe, USBHSF_PKT_PREPARE);
218 #define usbhsf_irq_callback_ctrl(pipe, status, enable) \
220 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); \
222 u16 status = (1 << usbhs_pipe_number(pipe)); \
232 static void usbhsf_tx_irq_ctrl(struct usbhs_pipe *pipe, int enable)
235 * And DCP pipe can NOT use "ready interrupt" for "send"
240 * on the other hand, normal pipe can use "ready interrupt" for "send"
243 if (usbhs_pipe_is_dcp(pipe))
244 usbhsf_irq_empty_ctrl(pipe, enable);
246 usbhsf_irq_ready_ctrl(pipe, enable);
249 static void usbhsf_rx_irq_ctrl(struct usbhs_pipe *pipe, int enable)
251 usbhsf_irq_ready_ctrl(pipe, enable);
257 static void usbhsf_send_terminator(struct usbhs_pipe *pipe,
260 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
275 static void usbhsf_fifo_clear(struct usbhs_pipe *pipe,
278 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
281 if (!usbhs_pipe_is_dcp(pipe)) {
283 * This driver checks the pipe condition first to avoid -EBUSY
284 * from usbhsf_fifo_barrier() if the pipe is RX direction and
287 if (usbhs_pipe_is_dir_in(pipe))
288 ret = usbhs_pipe_is_accessible(pipe);
294 * if non-DCP pipe, this driver should set BCLR when
307 static void usbhsf_fifo_unselect(struct usbhs_pipe *pipe,
310 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
312 usbhs_pipe_select_fifo(pipe, NULL);
316 static int usbhsf_fifo_select(struct usbhs_pipe *pipe,
320 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
324 u16 base = usbhs_pipe_number(pipe); /* CURPIPE */
326 if (usbhs_pipe_is_busy(pipe) ||
330 if (usbhs_pipe_is_dcp(pipe)) {
334 usbhs_dcp_dir_for_host(pipe, write);
343 usbhs_pipe_select_fifo(pipe, fifo);
359 struct usbhs_pipe *pipe = pkt->pipe;
360 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
365 usbhs_pipe_disable(pipe);
367 ret = usbhsf_fifo_select(pipe, fifo, 1);
373 usbhs_pipe_sequence_data1(pipe); /* DATA1 */
375 usbhsf_fifo_clear(pipe, fifo);
376 usbhsf_send_terminator(pipe, fifo);
378 usbhsf_fifo_unselect(pipe, fifo);
380 usbhsf_tx_irq_ctrl(pipe, 1);
381 usbhs_pipe_enable(pipe);
388 struct usbhs_pipe *pipe = pkt->pipe;
389 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
394 usbhs_pipe_disable(pipe);
396 ret = usbhsf_fifo_select(pipe, fifo, 0);
402 usbhs_pipe_sequence_data1(pipe); /* DATA1 */
403 usbhsf_fifo_clear(pipe, fifo);
405 usbhsf_fifo_unselect(pipe, fifo);
407 usbhsf_rx_irq_ctrl(pipe, 1);
408 usbhs_pipe_enable(pipe);
416 struct usbhs_pipe *pipe = pkt->pipe;
419 usbhsf_tx_irq_ctrl(pipe, 0);
421 usbhsf_rx_irq_ctrl(pipe, 0);
444 struct usbhs_pipe *pipe = pkt->pipe;
446 usbhs_pipe_sequence_data1(pipe); /* DATA1 */
466 struct usbhs_pipe *pipe = pkt->pipe;
467 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
470 if (usbhs_pipe_is_busy(pipe))
479 usbhs_pipe_disable(pipe);
481 usbhs_pipe_sequence_data1(pipe); /* DATA1 */
483 usbhsf_fifo_select(pipe, fifo, 0);
484 usbhsf_fifo_clear(pipe, fifo);
485 usbhsf_fifo_unselect(pipe, fifo);
504 struct usbhs_pipe *pipe = pkt->pipe;
505 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
510 int maxp = usbhs_pipe_get_maxpacket(pipe);
515 usbhs_pipe_data_sequence(pipe, pkt->sequence);
518 usbhs_pipe_set_trans_count_if_bulk(pipe, pkt->length);
520 ret = usbhsf_fifo_select(pipe, fifo, 1);
524 ret = usbhs_pipe_is_accessible(pipe);
526 /* inaccessible pipe is not an error */
574 * pipe/irq handling
577 usbhsf_send_terminator(pipe, fifo);
579 usbhsf_tx_irq_ctrl(pipe, !*is_done);
580 usbhs_pipe_running(pipe, !*is_done);
581 usbhs_pipe_enable(pipe);
584 usbhs_pipe_number(pipe),
587 usbhsf_fifo_unselect(pipe, fifo);
592 usbhsf_fifo_unselect(pipe, fifo);
595 * pipe is busy.
598 usbhsf_tx_irq_ctrl(pipe, 1);
599 usbhs_pipe_running(pipe, 1);
606 if (usbhs_pipe_is_running(pkt->pipe))
622 struct usbhs_pipe *pipe = pkt->pipe;
623 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
626 if (usbhs_pipe_is_busy(pipe))
629 if (usbhs_pipe_is_running(pipe))
633 * pipe enable to prepare packet receive
635 usbhs_pipe_data_sequence(pipe, pkt->sequence);
638 if (usbhs_pipe_is_dcp(pipe))
639 usbhsf_fifo_clear(pipe, fifo);
641 usbhs_pipe_set_trans_count_if_bulk(pipe, pkt->length);
642 usbhs_pipe_enable(pipe);
643 usbhs_pipe_running(pipe, 1);
644 usbhsf_rx_irq_ctrl(pipe, 1);
651 struct usbhs_pipe *pipe = pkt->pipe;
652 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
658 int maxp = usbhs_pipe_get_maxpacket(pipe);
663 ret = usbhsf_fifo_select(pipe, fifo, 0);
679 * update actual length first here to decide disable pipe.
680 * if this pipe keeps BUF status and all data were popped,
688 usbhsf_rx_irq_ctrl(pipe, 0);
689 usbhs_pipe_running(pipe, 0);
693 * should not disable the pipe. If such a case happens, this
696 if (!usbhs_mod_is_host(priv) && !usbhs_pipe_is_dcp(pipe))
697 usbhs_pipe_disable(pipe); /* disable pipe first */
708 usbhsf_fifo_clear(pipe, fifo);
733 usbhs_pipe_number(pipe),
737 usbhsf_fifo_unselect(pipe, fifo);
752 usbhs_dcp_control_transfer_done(pkt->pipe);
796 static void __usbhsf_dma_ctrl(struct usbhs_pipe *pipe,
800 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
807 struct usbhs_pipe *pipe = pkt->pipe;
808 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
810 struct usbhs_fifo *fifo = usbhs_pipe_to_fifo(pipe);
820 struct usbhs_pipe *pipe = pkt->pipe;
822 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
829 fifo = usbhs_pipe_to_fifo(pipe);
834 dir = usbhs_pipe_is_dir_in(pipe) ? DMA_DEV_TO_MEM : DMA_MEM_TO_DEV;
852 fifo->name, usbhs_pipe_number(pipe), pkt->length, pkt->zero);
854 usbhs_pipe_running(pipe, 1);
855 usbhs_pipe_set_trans_count_if_bulk(pipe, pkt->trans);
857 usbhsf_dma_start(pipe, fifo);
858 usbhs_pipe_enable(pipe);
864 struct usbhs_pipe *pipe = pkt->pipe;
865 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
878 struct usbhs_pipe *pipe = pkt->pipe;
879 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
885 if (usbhs_pipe_is_busy(pipe))
888 /* use PIO if packet is less than pio_dma_border or pipe is DCP */
890 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
903 /* return at this time if the pipe is running */
904 if (usbhs_pipe_is_running(pipe))
912 ret = usbhsf_fifo_select(pipe, fifo, 0);
921 usbhsf_tx_irq_ctrl(pipe, 0);
933 usbhsf_fifo_unselect(pipe, fifo);
945 struct usbhs_pipe *pipe = pkt->pipe;
946 int is_short = pkt->trans % usbhs_pipe_get_maxpacket(pipe);
957 usbhs_pipe_running(pipe, !*is_done);
959 usbhsf_dma_stop(pipe, pipe->fifo);
961 usbhsf_fifo_unselect(pipe, pipe->fifo);
990 struct usbhs_pipe *pipe = pkt->pipe;
991 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
995 if (usbhs_pipe_is_busy(pipe))
998 /* use PIO if packet is less than pio_dma_border or pipe is DCP */
1000 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
1010 /* return at this time if the pipe is running */
1011 if (usbhs_pipe_is_running(pipe))
1014 usbhs_pipe_config_change_bfre(pipe, 1);
1016 ret = usbhsf_fifo_select(pipe, fifo, 0);
1030 usbhsf_rx_irq_ctrl(pipe, 0);
1039 usbhsf_fifo_unselect(pipe, fifo);
1046 usbhs_pipe_config_change_bfre(pipe, 0);
1053 struct usbhs_priv *priv = usbhs_pipe_to_priv(pkt->pipe);
1063 struct usbhs_pipe *pipe = pkt->pipe;
1064 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
1068 if (usbhs_pipe_is_busy(pipe))
1071 if (usbhs_pipe_is_dcp(pipe))
1082 ret = usbhsf_fifo_select(pipe, fifo, 0);
1109 usbhsf_rx_irq_ctrl(pipe, 0);
1119 usbhsf_fifo_unselect(pipe, fifo);
1132 struct usbhs_priv *priv = usbhs_pipe_to_priv(pkt->pipe);
1141 struct usbhs_pipe *pipe = pkt->pipe;
1142 int maxp = usbhs_pipe_get_maxpacket(pipe);
1144 usbhsf_dma_stop(pipe, pipe->fifo);
1146 usbhsf_fifo_unselect(pipe, pipe->fifo);
1153 usbhs_pipe_running(pipe, 0);
1156 usbhs_pipe_running(pipe, 0);
1166 struct usbhs_pipe *pipe = pkt->pipe;
1168 int maxp = usbhs_pipe_get_maxpacket(pipe);
1184 struct usbhs_pipe *pipe = pkt->pipe;
1185 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
1186 struct usbhs_fifo *fifo = usbhs_pipe_to_fifo(pipe);
1195 usbhs_xxxsts_clear(priv, BRDYSTS, usbhs_pipe_number(pipe));
1198 usbhsf_fifo_clear(pipe, fifo);
1201 usbhs_pipe_running(pipe, 0);
1202 usbhsf_dma_stop(pipe, fifo);
1204 usbhsf_fifo_unselect(pipe, pipe->fifo);
1214 struct usbhs_priv *priv = usbhs_pipe_to_priv(pkt->pipe);
1319 struct usbhs_pipe *pipe;
1331 * search interrupted "pipe"
1334 usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
1338 ret = usbhsf_pkt_handler(pipe, USBHSF_PKT_TRY_RUN);
1349 struct usbhs_pipe *pipe;
1361 * search interrupted "pipe"
1364 usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
1368 ret = usbhsf_pkt_handler(pipe, USBHSF_PKT_TRY_RUN);
1380 struct usbhs_pipe *pipe = pkt->pipe;
1381 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
1386 ret = usbhsf_pkt_handler(pipe, USBHSF_PKT_DMA_DONE);
1389 usbhs_pipe_number(pipe), ret);
1392 void usbhs_fifo_clear_dcp(struct usbhs_pipe *pipe)
1394 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
1398 if (usbhsf_fifo_select(pipe, fifo, 1) < 0)
1400 usbhsf_fifo_clear(pipe, fifo);
1401 usbhsf_fifo_unselect(pipe, fifo);
1404 if (usbhsf_fifo_select(pipe, fifo, 0) < 0)
1406 usbhsf_fifo_clear(pipe, fifo);
1407 usbhsf_fifo_unselect(pipe, fifo);
1425 cfifo->pipe = NULL;
1427 dfifo->pipe = NULL;