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>
19 #include <linux/scatterlist.h>
23 #define usbhsf_get_cfifo(p) (&((p)->fifo_info.cfifo))
24 #define usbhsf_get_d0fifo(p) (&((p)->fifo_info.d0fifo))
25 #define usbhsf_get_d1fifo(p) (&((p)->fifo_info.d1fifo))
26 #define usbhsf_is_cfifo(p, f) (usbhsf_get_cfifo(p) == f)
28 #define usbhsf_fifo_is_busy(f) ((f)->pipe) /* see usbhs_pipe_select_fifo */
33 void usbhs_pkt_init(struct usbhs_pkt
*pkt
)
35 INIT_LIST_HEAD(&pkt
->node
);
39 * packet control function
41 static int usbhsf_null_handle(struct usbhs_pkt
*pkt
, int *is_done
)
43 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pkt
->pipe
);
44 struct device
*dev
= usbhs_priv_to_dev(priv
);
46 dev_err(dev
, "null handler\n");
51 static struct usbhs_pkt_handle usbhsf_null_handler
= {
52 .prepare
= usbhsf_null_handle
,
53 .try_run
= usbhsf_null_handle
,
56 void usbhs_pkt_push(struct usbhs_pipe
*pipe
, struct usbhs_pkt
*pkt
,
57 void (*done
)(struct usbhs_priv
*priv
,
58 struct usbhs_pkt
*pkt
),
59 void *buf
, int len
, int zero
, int sequence
)
61 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
62 struct device
*dev
= usbhs_priv_to_dev(priv
);
66 dev_err(dev
, "no done function\n");
70 /******************** spin lock ********************/
71 usbhs_lock(priv
, flags
);
74 dev_err(dev
, "no handler function\n");
75 pipe
->handler
= &usbhsf_null_handler
;
78 list_move_tail(&pkt
->node
, &pipe
->list
);
81 * each pkt must hold own handler.
82 * because handler might be changed by its situation.
83 * dma handler -> pio handler.
87 pkt
->handler
= pipe
->handler
;
92 pkt
->sequence
= sequence
;
94 usbhs_unlock(priv
, flags
);
95 /******************** spin unlock ******************/
98 static void __usbhsf_pkt_del(struct usbhs_pkt
*pkt
)
100 list_del_init(&pkt
->node
);
103 static struct usbhs_pkt
*__usbhsf_pkt_get(struct usbhs_pipe
*pipe
)
105 if (list_empty(&pipe
->list
))
108 return list_first_entry(&pipe
->list
, struct usbhs_pkt
, node
);
111 struct usbhs_pkt
*usbhs_pkt_pop(struct usbhs_pipe
*pipe
, struct usbhs_pkt
*pkt
)
113 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
116 /******************** spin lock ********************/
117 usbhs_lock(priv
, flags
);
120 pkt
= __usbhsf_pkt_get(pipe
);
123 __usbhsf_pkt_del(pkt
);
125 usbhs_unlock(priv
, flags
);
126 /******************** spin unlock ******************/
137 static int usbhsf_pkt_handler(struct usbhs_pipe
*pipe
, int type
)
139 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
140 struct usbhs_pkt
*pkt
;
141 struct device
*dev
= usbhs_priv_to_dev(priv
);
142 int (*func
)(struct usbhs_pkt
*pkt
, int *is_done
);
147 /******************** spin lock ********************/
148 usbhs_lock(priv
, flags
);
150 pkt
= __usbhsf_pkt_get(pipe
);
152 goto __usbhs_pkt_handler_end
;
155 case USBHSF_PKT_PREPARE
:
156 func
= pkt
->handler
->prepare
;
158 case USBHSF_PKT_TRY_RUN
:
159 func
= pkt
->handler
->try_run
;
161 case USBHSF_PKT_DMA_DONE
:
162 func
= pkt
->handler
->dma_done
;
165 dev_err(dev
, "unknown pkt handler\n");
166 goto __usbhs_pkt_handler_end
;
169 ret
= func(pkt
, &is_done
);
172 __usbhsf_pkt_del(pkt
);
174 __usbhs_pkt_handler_end
:
175 usbhs_unlock(priv
, flags
);
176 /******************** spin unlock ******************/
179 pkt
->done(priv
, pkt
);
180 usbhs_pkt_start(pipe
);
186 void usbhs_pkt_start(struct usbhs_pipe
*pipe
)
188 usbhsf_pkt_handler(pipe
, USBHSF_PKT_PREPARE
);
192 * irq enable/disable function
194 #define usbhsf_irq_empty_ctrl(p, e) usbhsf_irq_callback_ctrl(p, irq_bempsts, e)
195 #define usbhsf_irq_ready_ctrl(p, e) usbhsf_irq_callback_ctrl(p, irq_brdysts, e)
196 #define usbhsf_irq_callback_ctrl(pipe, status, enable) \
198 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); \
199 struct usbhs_mod *mod = usbhs_mod_get_current(priv); \
200 u16 status = (1 << usbhs_pipe_number(pipe)); \
204 mod->status |= status; \
206 mod->status &= ~status; \
207 usbhs_irq_callback_update(priv, mod); \
210 static void usbhsf_tx_irq_ctrl(struct usbhs_pipe
*pipe
, int enable
)
213 * And DCP pipe can NOT use "ready interrupt" for "send"
214 * it should use "empty" interrupt.
216 * "Operation" - "Interrupt Function" - "BRDY Interrupt"
218 * on the other hand, normal pipe can use "ready interrupt" for "send"
219 * even though it is single/double buffer
221 if (usbhs_pipe_is_dcp(pipe
))
222 usbhsf_irq_empty_ctrl(pipe
, enable
);
224 usbhsf_irq_ready_ctrl(pipe
, enable
);
227 static void usbhsf_rx_irq_ctrl(struct usbhs_pipe
*pipe
, int enable
)
229 usbhsf_irq_ready_ctrl(pipe
, enable
);
235 static void usbhsf_send_terminator(struct usbhs_pipe
*pipe
,
236 struct usbhs_fifo
*fifo
)
238 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
240 usbhs_bset(priv
, fifo
->ctr
, BVAL
, BVAL
);
243 static int usbhsf_fifo_barrier(struct usbhs_priv
*priv
,
244 struct usbhs_fifo
*fifo
)
249 /* The FIFO port is accessible */
250 if (usbhs_read(priv
, fifo
->ctr
) & FRDY
)
259 static void usbhsf_fifo_clear(struct usbhs_pipe
*pipe
,
260 struct usbhs_fifo
*fifo
)
262 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
264 if (!usbhs_pipe_is_dcp(pipe
))
265 usbhsf_fifo_barrier(priv
, fifo
);
267 usbhs_write(priv
, fifo
->ctr
, BCLR
);
270 static int usbhsf_fifo_rcv_len(struct usbhs_priv
*priv
,
271 struct usbhs_fifo
*fifo
)
273 return usbhs_read(priv
, fifo
->ctr
) & DTLN_MASK
;
276 static void usbhsf_fifo_unselect(struct usbhs_pipe
*pipe
,
277 struct usbhs_fifo
*fifo
)
279 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
281 usbhs_pipe_select_fifo(pipe
, NULL
);
282 usbhs_write(priv
, fifo
->sel
, 0);
285 static int usbhsf_fifo_select(struct usbhs_pipe
*pipe
,
286 struct usbhs_fifo
*fifo
,
289 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
290 struct device
*dev
= usbhs_priv_to_dev(priv
);
292 u16 mask
= ((1 << 5) | 0xF); /* mask of ISEL | CURPIPE */
293 u16 base
= usbhs_pipe_number(pipe
); /* CURPIPE */
295 if (usbhs_pipe_is_busy(pipe
) ||
296 usbhsf_fifo_is_busy(fifo
))
299 if (usbhs_pipe_is_dcp(pipe
)) {
300 base
|= (1 == write
) << 5; /* ISEL */
302 if (usbhs_mod_is_host(priv
))
303 usbhs_dcp_dir_for_host(pipe
, write
);
306 /* "base" will be used below */
307 if (usbhs_get_dparam(priv
, has_sudmac
) && !usbhsf_is_cfifo(priv
, fifo
))
308 usbhs_write(priv
, fifo
->sel
, base
);
310 usbhs_write(priv
, fifo
->sel
, base
| MBW_32
);
312 /* check ISEL and CURPIPE value */
314 if (base
== (mask
& usbhs_read(priv
, fifo
->sel
))) {
315 usbhs_pipe_select_fifo(pipe
, fifo
);
321 dev_err(dev
, "fifo select error\n");
329 static int usbhs_dcp_dir_switch_to_write(struct usbhs_pkt
*pkt
, int *is_done
)
331 struct usbhs_pipe
*pipe
= pkt
->pipe
;
332 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
333 struct usbhs_fifo
*fifo
= usbhsf_get_cfifo(priv
); /* CFIFO */
334 struct device
*dev
= usbhs_priv_to_dev(priv
);
337 usbhs_pipe_disable(pipe
);
339 ret
= usbhsf_fifo_select(pipe
, fifo
, 1);
341 dev_err(dev
, "%s() faile\n", __func__
);
345 usbhs_pipe_sequence_data1(pipe
); /* DATA1 */
347 usbhsf_fifo_clear(pipe
, fifo
);
348 usbhsf_send_terminator(pipe
, fifo
);
350 usbhsf_fifo_unselect(pipe
, fifo
);
352 usbhsf_tx_irq_ctrl(pipe
, 1);
353 usbhs_pipe_enable(pipe
);
358 static int usbhs_dcp_dir_switch_to_read(struct usbhs_pkt
*pkt
, int *is_done
)
360 struct usbhs_pipe
*pipe
= pkt
->pipe
;
361 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
362 struct usbhs_fifo
*fifo
= usbhsf_get_cfifo(priv
); /* CFIFO */
363 struct device
*dev
= usbhs_priv_to_dev(priv
);
366 usbhs_pipe_disable(pipe
);
368 ret
= usbhsf_fifo_select(pipe
, fifo
, 0);
370 dev_err(dev
, "%s() fail\n", __func__
);
374 usbhs_pipe_sequence_data1(pipe
); /* DATA1 */
375 usbhsf_fifo_clear(pipe
, fifo
);
377 usbhsf_fifo_unselect(pipe
, fifo
);
379 usbhsf_rx_irq_ctrl(pipe
, 1);
380 usbhs_pipe_enable(pipe
);
386 static int usbhs_dcp_dir_switch_done(struct usbhs_pkt
*pkt
, int *is_done
)
388 struct usbhs_pipe
*pipe
= pkt
->pipe
;
390 if (pkt
->handler
== &usbhs_dcp_status_stage_in_handler
)
391 usbhsf_tx_irq_ctrl(pipe
, 0);
393 usbhsf_rx_irq_ctrl(pipe
, 0);
395 pkt
->actual
= pkt
->length
;
401 struct usbhs_pkt_handle usbhs_dcp_status_stage_in_handler
= {
402 .prepare
= usbhs_dcp_dir_switch_to_write
,
403 .try_run
= usbhs_dcp_dir_switch_done
,
406 struct usbhs_pkt_handle usbhs_dcp_status_stage_out_handler
= {
407 .prepare
= usbhs_dcp_dir_switch_to_read
,
408 .try_run
= usbhs_dcp_dir_switch_done
,
412 * DCP data stage (push)
414 static int usbhsf_dcp_data_stage_try_push(struct usbhs_pkt
*pkt
, int *is_done
)
416 struct usbhs_pipe
*pipe
= pkt
->pipe
;
418 usbhs_pipe_sequence_data1(pipe
); /* DATA1 */
421 * change handler to PIO push
423 pkt
->handler
= &usbhs_fifo_pio_push_handler
;
425 return pkt
->handler
->prepare(pkt
, is_done
);
428 struct usbhs_pkt_handle usbhs_dcp_data_stage_out_handler
= {
429 .prepare
= usbhsf_dcp_data_stage_try_push
,
433 * DCP data stage (pop)
435 static int usbhsf_dcp_data_stage_prepare_pop(struct usbhs_pkt
*pkt
,
438 struct usbhs_pipe
*pipe
= pkt
->pipe
;
439 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
440 struct usbhs_fifo
*fifo
= usbhsf_get_cfifo(priv
);
442 if (usbhs_pipe_is_busy(pipe
))
446 * prepare pop for DCP should
447 * - change DCP direction,
451 usbhs_pipe_disable(pipe
);
453 usbhs_pipe_sequence_data1(pipe
); /* DATA1 */
455 usbhsf_fifo_select(pipe
, fifo
, 0);
456 usbhsf_fifo_clear(pipe
, fifo
);
457 usbhsf_fifo_unselect(pipe
, fifo
);
460 * change handler to PIO pop
462 pkt
->handler
= &usbhs_fifo_pio_pop_handler
;
464 return pkt
->handler
->prepare(pkt
, is_done
);
467 struct usbhs_pkt_handle usbhs_dcp_data_stage_in_handler
= {
468 .prepare
= usbhsf_dcp_data_stage_prepare_pop
,
474 static int usbhsf_pio_try_push(struct usbhs_pkt
*pkt
, int *is_done
)
476 struct usbhs_pipe
*pipe
= pkt
->pipe
;
477 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
478 struct device
*dev
= usbhs_priv_to_dev(priv
);
479 struct usbhs_fifo
*fifo
= usbhsf_get_cfifo(priv
); /* CFIFO */
480 void __iomem
*addr
= priv
->base
+ fifo
->port
;
482 int maxp
= usbhs_pipe_get_maxpacket(pipe
);
487 usbhs_pipe_data_sequence(pipe
, pkt
->sequence
);
488 pkt
->sequence
= -1; /* -1 sequence will be ignored */
490 usbhs_pipe_set_trans_count_if_bulk(pipe
, pkt
->length
);
492 ret
= usbhsf_fifo_select(pipe
, fifo
, 1);
496 ret
= usbhs_pipe_is_accessible(pipe
);
498 /* inaccessible pipe is not an error */
500 goto usbhs_fifo_write_busy
;
503 ret
= usbhsf_fifo_barrier(priv
, fifo
);
505 goto usbhs_fifo_write_busy
;
507 buf
= pkt
->buf
+ pkt
->actual
;
508 len
= pkt
->length
- pkt
->actual
;
509 len
= min(len
, maxp
);
511 is_short
= total_len
< maxp
;
518 if (len
>= 4 && !((unsigned long)buf
& 0x03)) {
519 iowrite32_rep(addr
, buf
, len
/ 4);
521 buf
+= total_len
- len
;
524 /* the rest operation */
525 for (i
= 0; i
< len
; i
++)
526 iowrite8(buf
[i
], addr
+ (0x03 - (i
& 0x03)));
531 pkt
->actual
+= total_len
;
533 if (pkt
->actual
< pkt
->length
)
534 *is_done
= 0; /* there are remainder data */
536 *is_done
= 1; /* short packet */
538 *is_done
= !pkt
->zero
; /* send zero packet ? */
544 usbhsf_send_terminator(pipe
, fifo
);
546 usbhsf_tx_irq_ctrl(pipe
, !*is_done
);
547 usbhs_pipe_enable(pipe
);
549 dev_dbg(dev
, " send %d (%d/ %d/ %d/ %d)\n",
550 usbhs_pipe_number(pipe
),
551 pkt
->length
, pkt
->actual
, *is_done
, pkt
->zero
);
557 if (usbhs_pipe_is_dcp(pipe
))
558 usbhs_dcp_control_transfer_done(pipe
);
561 usbhsf_fifo_unselect(pipe
, fifo
);
565 usbhs_fifo_write_busy
:
566 usbhsf_fifo_unselect(pipe
, fifo
);
572 usbhsf_tx_irq_ctrl(pipe
, 1);
577 struct usbhs_pkt_handle usbhs_fifo_pio_push_handler
= {
578 .prepare
= usbhsf_pio_try_push
,
579 .try_run
= usbhsf_pio_try_push
,
585 static int usbhsf_prepare_pop(struct usbhs_pkt
*pkt
, int *is_done
)
587 struct usbhs_pipe
*pipe
= pkt
->pipe
;
589 if (usbhs_pipe_is_busy(pipe
))
593 * pipe enable to prepare packet receive
595 usbhs_pipe_data_sequence(pipe
, pkt
->sequence
);
596 pkt
->sequence
= -1; /* -1 sequence will be ignored */
598 usbhs_pipe_set_trans_count_if_bulk(pipe
, pkt
->length
);
599 usbhs_pipe_enable(pipe
);
600 usbhsf_rx_irq_ctrl(pipe
, 1);
605 static int usbhsf_pio_try_pop(struct usbhs_pkt
*pkt
, int *is_done
)
607 struct usbhs_pipe
*pipe
= pkt
->pipe
;
608 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
609 struct device
*dev
= usbhs_priv_to_dev(priv
);
610 struct usbhs_fifo
*fifo
= usbhsf_get_cfifo(priv
); /* CFIFO */
611 void __iomem
*addr
= priv
->base
+ fifo
->port
;
614 int maxp
= usbhs_pipe_get_maxpacket(pipe
);
619 ret
= usbhsf_fifo_select(pipe
, fifo
, 0);
623 ret
= usbhsf_fifo_barrier(priv
, fifo
);
625 goto usbhs_fifo_read_busy
;
627 rcv_len
= usbhsf_fifo_rcv_len(priv
, fifo
);
629 buf
= pkt
->buf
+ pkt
->actual
;
630 len
= pkt
->length
- pkt
->actual
;
631 len
= min(len
, rcv_len
);
635 * update actual length first here to decide disable pipe.
636 * if this pipe keeps BUF status and all data were popped,
637 * then, next interrupt/token will be issued again
639 pkt
->actual
+= total_len
;
641 if ((pkt
->actual
== pkt
->length
) || /* receive all data */
642 (total_len
< maxp
)) { /* short packet */
644 usbhsf_rx_irq_ctrl(pipe
, 0);
645 usbhs_pipe_disable(pipe
); /* disable pipe first */
649 * Buffer clear if Zero-Length packet
652 * "Operation" - "FIFO Buffer Memory" - "FIFO Port Function"
656 usbhsf_fifo_clear(pipe
, fifo
);
657 goto usbhs_fifo_read_end
;
665 if (len
>= 4 && !((unsigned long)buf
& 0x03)) {
666 ioread32_rep(addr
, buf
, len
/ 4);
668 buf
+= total_len
- len
;
671 /* the rest operation */
672 for (i
= 0; i
< len
; i
++) {
674 data
= ioread32(addr
);
676 buf
[i
] = (data
>> ((i
& 0x03) * 8)) & 0xff;
680 dev_dbg(dev
, " recv %d (%d/ %d/ %d/ %d)\n",
681 usbhs_pipe_number(pipe
),
682 pkt
->length
, pkt
->actual
, *is_done
, pkt
->zero
);
684 usbhs_fifo_read_busy
:
685 usbhsf_fifo_unselect(pipe
, fifo
);
690 struct usbhs_pkt_handle usbhs_fifo_pio_pop_handler
= {
691 .prepare
= usbhsf_prepare_pop
,
692 .try_run
= usbhsf_pio_try_pop
,
696 * DCP ctrol statge handler
698 static int usbhsf_ctrl_stage_end(struct usbhs_pkt
*pkt
, int *is_done
)
700 usbhs_dcp_control_transfer_done(pkt
->pipe
);
707 struct usbhs_pkt_handle usbhs_ctrl_stage_end_handler
= {
708 .prepare
= usbhsf_ctrl_stage_end
,
709 .try_run
= usbhsf_ctrl_stage_end
,
715 static struct dma_chan
*usbhsf_dma_chan_get(struct usbhs_fifo
*fifo
,
716 struct usbhs_pkt
*pkt
)
718 if (&usbhs_fifo_dma_push_handler
== pkt
->handler
)
719 return fifo
->tx_chan
;
721 if (&usbhs_fifo_dma_pop_handler
== pkt
->handler
)
722 return fifo
->rx_chan
;
727 static struct usbhs_fifo
*usbhsf_get_dma_fifo(struct usbhs_priv
*priv
,
728 struct usbhs_pkt
*pkt
)
730 struct usbhs_fifo
*fifo
;
733 fifo
= usbhsf_get_d0fifo(priv
);
734 if (usbhsf_dma_chan_get(fifo
, pkt
) &&
735 !usbhsf_fifo_is_busy(fifo
))
739 fifo
= usbhsf_get_d1fifo(priv
);
740 if (usbhsf_dma_chan_get(fifo
, pkt
) &&
741 !usbhsf_fifo_is_busy(fifo
))
747 #define usbhsf_dma_start(p, f) __usbhsf_dma_ctrl(p, f, DREQE)
748 #define usbhsf_dma_stop(p, f) __usbhsf_dma_ctrl(p, f, 0)
749 static void __usbhsf_dma_ctrl(struct usbhs_pipe
*pipe
,
750 struct usbhs_fifo
*fifo
,
753 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
755 usbhs_bset(priv
, fifo
->sel
, DREQE
, dreqe
);
758 #define usbhsf_dma_map(p) __usbhsf_dma_map_ctrl(p, 1)
759 #define usbhsf_dma_unmap(p) __usbhsf_dma_map_ctrl(p, 0)
760 static int __usbhsf_dma_map_ctrl(struct usbhs_pkt
*pkt
, int map
)
762 struct usbhs_pipe
*pipe
= pkt
->pipe
;
763 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
764 struct usbhs_pipe_info
*info
= usbhs_priv_to_pipeinfo(priv
);
766 return info
->dma_map_ctrl(pkt
, map
);
769 static void usbhsf_dma_complete(void *arg
);
770 static void xfer_work(struct work_struct
*work
)
772 struct usbhs_pkt
*pkt
= container_of(work
, struct usbhs_pkt
, work
);
773 struct usbhs_pipe
*pipe
= pkt
->pipe
;
774 struct usbhs_fifo
*fifo
= usbhs_pipe_to_fifo(pipe
);
775 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
776 struct dma_async_tx_descriptor
*desc
;
777 struct dma_chan
*chan
= usbhsf_dma_chan_get(fifo
, pkt
);
778 struct device
*dev
= usbhs_priv_to_dev(priv
);
779 enum dma_transfer_direction dir
;
781 dir
= usbhs_pipe_is_dir_in(pipe
) ? DMA_DEV_TO_MEM
: DMA_MEM_TO_DEV
;
783 desc
= dmaengine_prep_slave_single(chan
, pkt
->dma
+ pkt
->actual
,
785 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
789 desc
->callback
= usbhsf_dma_complete
;
790 desc
->callback_param
= pipe
;
792 if (dmaengine_submit(desc
) < 0) {
793 dev_err(dev
, "Failed to submit dma descriptor\n");
797 dev_dbg(dev
, " %s %d (%d/ %d)\n",
798 fifo
->name
, usbhs_pipe_number(pipe
), pkt
->length
, pkt
->zero
);
800 usbhs_pipe_set_trans_count_if_bulk(pipe
, pkt
->trans
);
801 usbhs_pipe_enable(pipe
);
802 usbhsf_dma_start(pipe
, fifo
);
803 dma_async_issue_pending(chan
);
809 static int usbhsf_dma_prepare_push(struct usbhs_pkt
*pkt
, int *is_done
)
811 struct usbhs_pipe
*pipe
= pkt
->pipe
;
812 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
813 struct usbhs_fifo
*fifo
;
814 int len
= pkt
->length
- pkt
->actual
;
817 if (usbhs_pipe_is_busy(pipe
))
820 /* use PIO if packet is less than pio_dma_border or pipe is DCP */
821 if ((len
< usbhs_get_dparam(priv
, pio_dma_border
)) ||
822 usbhs_pipe_is_dcp(pipe
))
823 goto usbhsf_pio_prepare_push
;
825 if (len
& 0x7) /* 8byte alignment */
826 goto usbhsf_pio_prepare_push
;
828 if ((uintptr_t)(pkt
->buf
+ pkt
->actual
) & 0x7) /* 8byte alignment */
829 goto usbhsf_pio_prepare_push
;
831 /* get enable DMA fifo */
832 fifo
= usbhsf_get_dma_fifo(priv
, pkt
);
834 goto usbhsf_pio_prepare_push
;
836 if (usbhsf_dma_map(pkt
) < 0)
837 goto usbhsf_pio_prepare_push
;
839 ret
= usbhsf_fifo_select(pipe
, fifo
, 0);
841 goto usbhsf_pio_prepare_push_unmap
;
845 INIT_WORK(&pkt
->work
, xfer_work
);
846 schedule_work(&pkt
->work
);
850 usbhsf_pio_prepare_push_unmap
:
851 usbhsf_dma_unmap(pkt
);
852 usbhsf_pio_prepare_push
:
854 * change handler to PIO
856 pkt
->handler
= &usbhs_fifo_pio_push_handler
;
858 return pkt
->handler
->prepare(pkt
, is_done
);
861 static int usbhsf_dma_push_done(struct usbhs_pkt
*pkt
, int *is_done
)
863 struct usbhs_pipe
*pipe
= pkt
->pipe
;
865 pkt
->actual
= pkt
->trans
;
867 *is_done
= !pkt
->zero
; /* send zero packet ? */
869 usbhsf_dma_stop(pipe
, pipe
->fifo
);
870 usbhsf_dma_unmap(pkt
);
871 usbhsf_fifo_unselect(pipe
, pipe
->fifo
);
876 struct usbhs_pkt_handle usbhs_fifo_dma_push_handler
= {
877 .prepare
= usbhsf_dma_prepare_push
,
878 .dma_done
= usbhsf_dma_push_done
,
884 static int usbhsf_dma_try_pop(struct usbhs_pkt
*pkt
, int *is_done
)
886 struct usbhs_pipe
*pipe
= pkt
->pipe
;
887 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
888 struct usbhs_fifo
*fifo
;
891 if (usbhs_pipe_is_busy(pipe
))
894 if (usbhs_pipe_is_dcp(pipe
))
895 goto usbhsf_pio_prepare_pop
;
897 /* get enable DMA fifo */
898 fifo
= usbhsf_get_dma_fifo(priv
, pkt
);
900 goto usbhsf_pio_prepare_pop
;
902 if ((uintptr_t)(pkt
->buf
+ pkt
->actual
) & 0x7) /* 8byte alignment */
903 goto usbhsf_pio_prepare_pop
;
905 ret
= usbhsf_fifo_select(pipe
, fifo
, 0);
907 goto usbhsf_pio_prepare_pop
;
909 /* use PIO if packet is less than pio_dma_border */
910 len
= usbhsf_fifo_rcv_len(priv
, fifo
);
911 len
= min(pkt
->length
- pkt
->actual
, len
);
912 if (len
& 0x7) /* 8byte alignment */
913 goto usbhsf_pio_prepare_pop_unselect
;
915 if (len
< usbhs_get_dparam(priv
, pio_dma_border
))
916 goto usbhsf_pio_prepare_pop_unselect
;
918 ret
= usbhsf_fifo_barrier(priv
, fifo
);
920 goto usbhsf_pio_prepare_pop_unselect
;
922 if (usbhsf_dma_map(pkt
) < 0)
923 goto usbhsf_pio_prepare_pop_unselect
;
928 * usbhs_fifo_dma_pop_handler :: prepare
929 * enabled irq to come here.
930 * but it is no longer needed for DMA. disable it.
932 usbhsf_rx_irq_ctrl(pipe
, 0);
936 INIT_WORK(&pkt
->work
, xfer_work
);
937 schedule_work(&pkt
->work
);
941 usbhsf_pio_prepare_pop_unselect
:
942 usbhsf_fifo_unselect(pipe
, fifo
);
943 usbhsf_pio_prepare_pop
:
946 * change handler to PIO
948 pkt
->handler
= &usbhs_fifo_pio_pop_handler
;
950 return pkt
->handler
->try_run(pkt
, is_done
);
953 static int usbhsf_dma_pop_done(struct usbhs_pkt
*pkt
, int *is_done
)
955 struct usbhs_pipe
*pipe
= pkt
->pipe
;
956 int maxp
= usbhs_pipe_get_maxpacket(pipe
);
958 usbhsf_dma_stop(pipe
, pipe
->fifo
);
959 usbhsf_dma_unmap(pkt
);
960 usbhsf_fifo_unselect(pipe
, pipe
->fifo
);
962 pkt
->actual
+= pkt
->trans
;
964 if ((pkt
->actual
== pkt
->length
) || /* receive all data */
965 (pkt
->trans
< maxp
)) { /* short packet */
969 usbhsf_prepare_pop(pkt
, is_done
);
975 struct usbhs_pkt_handle usbhs_fifo_dma_pop_handler
= {
976 .prepare
= usbhsf_prepare_pop
,
977 .try_run
= usbhsf_dma_try_pop
,
978 .dma_done
= usbhsf_dma_pop_done
984 static bool usbhsf_dma_filter(struct dma_chan
*chan
, void *param
)
986 struct sh_dmae_slave
*slave
= param
;
991 * usbhs doesn't recognize id = 0 as valid DMA
993 if (0 == slave
->shdma_slave
.slave_id
)
996 chan
->private = slave
;
1001 static void usbhsf_dma_quit(struct usbhs_priv
*priv
, struct usbhs_fifo
*fifo
)
1004 dma_release_channel(fifo
->tx_chan
);
1006 dma_release_channel(fifo
->rx_chan
);
1008 fifo
->tx_chan
= NULL
;
1009 fifo
->rx_chan
= NULL
;
1012 static void usbhsf_dma_init(struct usbhs_priv
*priv
,
1013 struct usbhs_fifo
*fifo
)
1015 struct device
*dev
= usbhs_priv_to_dev(priv
);
1016 dma_cap_mask_t mask
;
1019 dma_cap_set(DMA_SLAVE
, mask
);
1020 fifo
->tx_chan
= dma_request_channel(mask
, usbhsf_dma_filter
,
1024 dma_cap_set(DMA_SLAVE
, mask
);
1025 fifo
->rx_chan
= dma_request_channel(mask
, usbhsf_dma_filter
,
1028 if (fifo
->tx_chan
|| fifo
->rx_chan
)
1029 dev_dbg(dev
, "enable DMAEngine (%s%s%s)\n",
1031 fifo
->tx_chan
? "[TX]" : " ",
1032 fifo
->rx_chan
? "[RX]" : " ");
1038 static int usbhsf_irq_empty(struct usbhs_priv
*priv
,
1039 struct usbhs_irq_state
*irq_state
)
1041 struct usbhs_pipe
*pipe
;
1042 struct device
*dev
= usbhs_priv_to_dev(priv
);
1045 if (!irq_state
->bempsts
) {
1046 dev_err(dev
, "debug %s !!\n", __func__
);
1050 dev_dbg(dev
, "irq empty [0x%04x]\n", irq_state
->bempsts
);
1053 * search interrupted "pipe"
1056 usbhs_for_each_pipe_with_dcp(pipe
, priv
, i
) {
1057 if (!(irq_state
->bempsts
& (1 << i
)))
1060 ret
= usbhsf_pkt_handler(pipe
, USBHSF_PKT_TRY_RUN
);
1062 dev_err(dev
, "irq_empty run_error %d : %d\n", i
, ret
);
1068 static int usbhsf_irq_ready(struct usbhs_priv
*priv
,
1069 struct usbhs_irq_state
*irq_state
)
1071 struct usbhs_pipe
*pipe
;
1072 struct device
*dev
= usbhs_priv_to_dev(priv
);
1075 if (!irq_state
->brdysts
) {
1076 dev_err(dev
, "debug %s !!\n", __func__
);
1080 dev_dbg(dev
, "irq ready [0x%04x]\n", irq_state
->brdysts
);
1083 * search interrupted "pipe"
1086 usbhs_for_each_pipe_with_dcp(pipe
, priv
, i
) {
1087 if (!(irq_state
->brdysts
& (1 << i
)))
1090 ret
= usbhsf_pkt_handler(pipe
, USBHSF_PKT_TRY_RUN
);
1092 dev_err(dev
, "irq_ready run_error %d : %d\n", i
, ret
);
1098 static void usbhsf_dma_complete(void *arg
)
1100 struct usbhs_pipe
*pipe
= arg
;
1101 struct usbhs_priv
*priv
= usbhs_pipe_to_priv(pipe
);
1102 struct device
*dev
= usbhs_priv_to_dev(priv
);
1105 ret
= usbhsf_pkt_handler(pipe
, USBHSF_PKT_DMA_DONE
);
1107 dev_err(dev
, "dma_complete run_error %d : %d\n",
1108 usbhs_pipe_number(pipe
), ret
);
1114 void usbhs_fifo_init(struct usbhs_priv
*priv
)
1116 struct usbhs_mod
*mod
= usbhs_mod_get_current(priv
);
1117 struct usbhs_fifo
*cfifo
= usbhsf_get_cfifo(priv
);
1118 struct usbhs_fifo
*d0fifo
= usbhsf_get_d0fifo(priv
);
1119 struct usbhs_fifo
*d1fifo
= usbhsf_get_d1fifo(priv
);
1121 mod
->irq_empty
= usbhsf_irq_empty
;
1122 mod
->irq_ready
= usbhsf_irq_ready
;
1123 mod
->irq_bempsts
= 0;
1124 mod
->irq_brdysts
= 0;
1127 d0fifo
->pipe
= NULL
;
1128 d1fifo
->pipe
= NULL
;
1131 void usbhs_fifo_quit(struct usbhs_priv
*priv
)
1133 struct usbhs_mod
*mod
= usbhs_mod_get_current(priv
);
1135 mod
->irq_empty
= NULL
;
1136 mod
->irq_ready
= NULL
;
1137 mod
->irq_bempsts
= 0;
1138 mod
->irq_brdysts
= 0;
1141 int usbhs_fifo_probe(struct usbhs_priv
*priv
)
1143 struct usbhs_fifo
*fifo
;
1146 fifo
= usbhsf_get_cfifo(priv
);
1147 fifo
->name
= "CFIFO";
1149 fifo
->sel
= CFIFOSEL
;
1150 fifo
->ctr
= CFIFOCTR
;
1153 fifo
= usbhsf_get_d0fifo(priv
);
1154 fifo
->name
= "D0FIFO";
1155 fifo
->port
= D0FIFO
;
1156 fifo
->sel
= D0FIFOSEL
;
1157 fifo
->ctr
= D0FIFOCTR
;
1158 fifo
->tx_slave
.shdma_slave
.slave_id
= usbhs_get_dparam(priv
, d0_tx_id
);
1159 fifo
->rx_slave
.shdma_slave
.slave_id
= usbhs_get_dparam(priv
, d0_rx_id
);
1160 usbhsf_dma_init(priv
, fifo
);
1163 fifo
= usbhsf_get_d1fifo(priv
);
1164 fifo
->name
= "D1FIFO";
1165 fifo
->port
= D1FIFO
;
1166 fifo
->sel
= D1FIFOSEL
;
1167 fifo
->ctr
= D1FIFOCTR
;
1168 fifo
->tx_slave
.shdma_slave
.slave_id
= usbhs_get_dparam(priv
, d1_tx_id
);
1169 fifo
->rx_slave
.shdma_slave
.slave_id
= usbhs_get_dparam(priv
, d1_rx_id
);
1170 usbhsf_dma_init(priv
, fifo
);
1175 void usbhs_fifo_remove(struct usbhs_priv
*priv
)
1177 usbhsf_dma_quit(priv
, usbhsf_get_d0fifo(priv
));
1178 usbhsf_dma_quit(priv
, usbhsf_get_d1fifo(priv
));