usb: renesas_usbhs: shrink spin lock area
[pandora-kernel.git] / drivers / usb / renesas_usbhs / fifo.c
index 0983884..3cda71e 100644 (file)
 /*
  *             packet info function
  */
-void usbhs_pkt_update(struct usbhs_pkt *pkt,
-                     struct usbhs_pipe *pipe,
-                     void *buf, int len)
+static int usbhsf_null_handle(struct usbhs_pkt *pkt, int *is_done)
 {
+       struct usbhs_priv *priv = usbhs_pipe_to_priv(pkt->pipe);
+       struct device *dev = usbhs_priv_to_dev(priv);
+
+       dev_err(dev, "null handler\n");
+
+       return -EINVAL;
+}
+
+static struct usbhs_pkt_handle usbhsf_null_handler = {
+       .prepare = usbhsf_null_handle,
+       .try_run = usbhsf_null_handle,
+};
+
+void usbhs_pkt_init(struct usbhs_pkt *pkt)
+{
+       INIT_LIST_HEAD(&pkt->node);
+}
+
+void usbhs_pkt_push(struct usbhs_pipe *pipe, struct usbhs_pkt *pkt,
+                   struct usbhs_pkt_handle *handler,
+                   void *buf, int len, int zero)
+{
+       struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
+       struct device *dev = usbhs_priv_to_dev(priv);
+       unsigned long flags;
+
+       /********************  spin lock ********************/
+       usbhs_lock(priv, flags);
+
+       if (!handler) {
+               dev_err(dev, "no handler function\n");
+               handler = &usbhsf_null_handler;
+       }
+
+       list_del_init(&pkt->node);
+       list_add_tail(&pkt->node, &pipe->list);
+
        pkt->pipe       = pipe;
        pkt->buf        = buf;
+       pkt->handler    = handler;
        pkt->length     = len;
+       pkt->zero       = zero;
        pkt->actual     = 0;
-       pkt->maxp       = 0;
+
+       usbhs_unlock(priv, flags);
+       /********************  spin unlock ******************/
+}
+
+static void __usbhsf_pkt_del(struct usbhs_pkt *pkt)
+{
+       list_del_init(&pkt->node);
+}
+
+static struct usbhs_pkt *__usbhsf_pkt_get(struct usbhs_pipe *pipe)
+{
+       if (list_empty(&pipe->list))
+               return NULL;
+
+       return list_entry(pipe->list.next, struct usbhs_pkt, node);
+}
+
+struct usbhs_pkt *usbhs_pkt_pop(struct usbhs_pipe *pipe, struct usbhs_pkt *pkt)
+{
+       struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
+       unsigned long flags;
+
+       /********************  spin lock ********************/
+       usbhs_lock(priv, flags);
+
+       if (!pkt)
+               pkt = __usbhsf_pkt_get(pipe);
+
+       if (pkt)
+               __usbhsf_pkt_del(pkt);
+
+       usbhs_unlock(priv, flags);
+       /********************  spin unlock ******************/
+
+       return pkt;
+}
+
+int __usbhs_pkt_handler(struct usbhs_pipe *pipe, int type)
+{
+       struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
+       struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
+       struct usbhs_pkt *pkt;
+       struct device *dev = usbhs_priv_to_dev(priv);
+       int (*func)(struct usbhs_pkt *pkt, int *is_done);
+       unsigned long flags;
+       int ret = 0;
+       int is_done = 0;
+
+       /********************  spin lock ********************/
+       usbhs_lock(priv, flags);
+
+       pkt = __usbhsf_pkt_get(pipe);
+       if (!pkt)
+               goto __usbhs_pkt_handler_end;
+
+       switch (type) {
+       case USBHSF_PKT_PREPARE:
+               func = pkt->handler->prepare;
+               break;
+       case USBHSF_PKT_TRY_RUN:
+               func = pkt->handler->try_run;
+               break;
+       default:
+               dev_err(dev, "unknown pkt hander\n");
+               goto __usbhs_pkt_handler_end;
+       }
+
+       ret = func(pkt, &is_done);
+
+       if (is_done)
+               __usbhsf_pkt_del(pkt);
+
+__usbhs_pkt_handler_end:
+       usbhs_unlock(priv, flags);
+       /********************  spin unlock ******************/
+
+       if (is_done)
+               info->done(pkt);
+
+       return ret;
+}
+
+/*
+ *             irq enable/disable function
+ */
+#define usbhsf_irq_empty_ctrl(p, e) usbhsf_irq_callback_ctrl(p, bempsts, e)
+#define usbhsf_irq_ready_ctrl(p, e) usbhsf_irq_callback_ctrl(p, brdysts, e)
+#define usbhsf_irq_callback_ctrl(pipe, status, enable)                 \
+       ({                                                              \
+               struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);     \
+               struct usbhs_mod *mod = usbhs_mod_get_current(priv);    \
+               u16 status = (1 << usbhs_pipe_number(pipe));            \
+               if (!mod)                                               \
+                       return;                                         \
+               if (enable)                                             \
+                       mod->irq_##status |= status;                    \
+               else                                                    \
+                       mod->irq_##status &= ~status;                   \
+               usbhs_irq_callback_update(priv, mod);                   \
+       })
+
+static void usbhsf_tx_irq_ctrl(struct usbhs_pipe *pipe, int enable)
+{
+       /*
+        * And DCP pipe can NOT use "ready interrupt" for "send"
+        * it should use "empty" interrupt.
+        * see
+        *   "Operation" - "Interrupt Function" - "BRDY Interrupt"
+        *
+        * on the other hand, normal pipe can use "ready interrupt" for "send"
+        * even though it is single/double buffer
+        */
+       if (usbhs_pipe_is_dcp(pipe))
+               usbhsf_irq_empty_ctrl(pipe, enable);
+       else
+               usbhsf_irq_ready_ctrl(pipe, enable);
+}
+
+static void usbhsf_rx_irq_ctrl(struct usbhs_pipe *pipe, int enable)
+{
+       usbhsf_irq_ready_ctrl(pipe, enable);
 }
 
 /*
@@ -102,44 +260,42 @@ static int usbhsf_fifo_select(struct usbhs_pipe *pipe, int write)
 /*
  *             PIO fifo functions
  */
-int usbhs_fifo_prepare_write(struct usbhs_pipe *pipe)
-{
-       return usbhsf_fifo_select(pipe, 1);
-}
-
-int usbhs_fifo_write(struct usbhs_pkt *pkt)
+static int usbhsf_try_push(struct usbhs_pkt *pkt, int *is_done)
 {
        struct usbhs_pipe *pipe = pkt->pipe;
        struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
-       struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
+       struct device *dev = usbhs_priv_to_dev(priv);
        void __iomem *addr = priv->base + CFIFO;
+       u8 *buf;
        int maxp = usbhs_pipe_get_maxpacket(pipe);
        int total_len;
-       u8 *buf = pkt->buf;
        int i, ret, len;
+       int is_short;
 
-       ret = usbhs_pipe_is_accessible(pipe);
+       ret = usbhsf_fifo_select(pipe, 1);
        if (ret < 0)
-               return ret;
+               goto usbhs_fifo_write_busy;
 
-       ret = usbhsf_fifo_select(pipe, 1);
+       ret = usbhs_pipe_is_accessible(pipe);
        if (ret < 0)
-               return ret;
+               goto usbhs_fifo_write_busy;
 
        ret = usbhsf_fifo_barrier(priv);
        if (ret < 0)
-               return ret;
+               goto usbhs_fifo_write_busy;
 
-       len = min(pkt->length, maxp);
-       total_len = len;
+       buf             = pkt->buf    + pkt->actual;
+       len             = pkt->length - pkt->actual;
+       len             = min(len, maxp);
+       total_len       = len;
+       is_short        = total_len < maxp;
 
        /*
         * FIXME
         *
         * 32-bit access only
         */
-       if (len >= 4 &&
-           !((unsigned long)buf & 0x03)) {
+       if (len >= 4 && !((unsigned long)buf & 0x03)) {
                iowrite32_rep(addr, buf, len / 4);
                len %= 4;
                buf += total_len - len;
@@ -149,23 +305,59 @@ int usbhs_fifo_write(struct usbhs_pkt *pkt)
        for (i = 0; i < len; i++)
                iowrite8(buf[i], addr + (0x03 - (i & 0x03)));
 
-       if (total_len < maxp)
+       /*
+        * variable update
+        */
+       pkt->actual += total_len;
+
+       if (pkt->actual < pkt->length)
+               *is_done = 0;           /* there are remainder data */
+       else if (is_short)
+               *is_done = 1;           /* short packet */
+       else
+               *is_done = !pkt->zero;  /* send zero packet ? */
+
+       /*
+        * pipe/irq handling
+        */
+       if (is_short)
                usbhsf_send_terminator(pipe);
 
+       usbhsf_tx_irq_ctrl(pipe, !*is_done);
        usbhs_pipe_enable(pipe);
 
-       /* update pkt */
-       if (info->tx_done) {
-               pkt->actual     = total_len;
-               pkt->maxp       = maxp;
-               info->tx_done(pkt);
+       dev_dbg(dev, "  send %d (%d/ %d/ %d/ %d)\n",
+               usbhs_pipe_number(pipe),
+               pkt->length, pkt->actual, *is_done, pkt->zero);
+
+       /*
+        * Transmission end
+        */
+       if (*is_done) {
+               if (usbhs_pipe_is_dcp(pipe))
+                       usbhs_dcp_control_transfer_done(pipe);
        }
 
        return 0;
+
+usbhs_fifo_write_busy:
+       /*
+        * pipe is busy.
+        * retry in interrupt
+        */
+       usbhsf_tx_irq_ctrl(pipe, 1);
+
+       return ret;
 }
 
-int usbhs_fifo_prepare_read(struct usbhs_pipe *pipe)
+struct usbhs_pkt_handle usbhs_fifo_push_handler = {
+       .prepare = usbhsf_try_push,
+       .try_run = usbhsf_try_push,
+};
+
+static int usbhsf_prepare_pop(struct usbhs_pkt *pkt, int *is_done)
 {
+       struct usbhs_pipe *pipe = pkt->pipe;
        int ret;
 
        /*
@@ -176,21 +368,23 @@ int usbhs_fifo_prepare_read(struct usbhs_pipe *pipe)
                return ret;
 
        usbhs_pipe_enable(pipe);
+       usbhsf_rx_irq_ctrl(pipe, 1);
 
        return ret;
 }
 
-int usbhs_fifo_read(struct usbhs_pkt *pkt)
+static int usbhsf_try_pop(struct usbhs_pkt *pkt, int *is_done)
 {
        struct usbhs_pipe *pipe = pkt->pipe;
        struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
-       struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
+       struct device *dev = usbhs_priv_to_dev(priv);
        void __iomem *addr = priv->base + CFIFO;
-       u8 *buf = pkt->buf;
+       u8 *buf;
+       u32 data = 0;
+       int maxp = usbhs_pipe_get_maxpacket(pipe);
        int rcv_len, len;
        int i, ret;
        int total_len = 0;
-       u32 data = 0;
 
        ret = usbhsf_fifo_select(pipe, 0);
        if (ret < 0)
@@ -202,6 +396,11 @@ int usbhs_fifo_read(struct usbhs_pkt *pkt)
 
        rcv_len = usbhsf_fifo_rcv_len(priv);
 
+       buf             = pkt->buf    + pkt->actual;
+       len             = pkt->length - pkt->actual;
+       len             = min(len, rcv_len);
+       total_len       = len;
+
        /*
         * Buffer clear if Zero-Length packet
         *
@@ -213,19 +412,15 @@ int usbhs_fifo_read(struct usbhs_pkt *pkt)
                goto usbhs_fifo_read_end;
        }
 
-       len = min(rcv_len, pkt->length);
-       total_len = len;
-
        /*
         * FIXME
         *
         * 32-bit access only
         */
-       if (len >= 4 &&
-           !((unsigned long)buf & 0x03)) {
+       if (len >= 4 && !((unsigned long)buf & 0x03)) {
                ioread32_rep(addr, buf, len / 4);
                len %= 4;
-               buf += rcv_len - len;
+               buf += total_len - len;
        }
 
        /* the rest operation */
@@ -236,13 +431,127 @@ int usbhs_fifo_read(struct usbhs_pkt *pkt)
                buf[i] = (data >> ((i & 0x03) * 8)) & 0xff;
        }
 
+       pkt->actual += total_len;
+
 usbhs_fifo_read_end:
-       if (info->rx_done) {
-               /* update pkt */
-               pkt->actual     = total_len;
-               pkt->maxp       = usbhs_pipe_get_maxpacket(pipe);
-               info->rx_done(pkt);
+       if ((pkt->actual == pkt->length) ||     /* receive all data */
+           (total_len < maxp)) {               /* short packet */
+               *is_done = 1;
+               usbhsf_rx_irq_ctrl(pipe, 0);
+               usbhs_pipe_disable(pipe);
        }
 
+       dev_dbg(dev, "  recv %d (%d/ %d/ %d/ %d)\n",
+               usbhs_pipe_number(pipe),
+               pkt->length, pkt->actual, *is_done, pkt->zero);
+
        return 0;
 }
+
+struct usbhs_pkt_handle usbhs_fifo_pop_handler = {
+       .prepare = usbhsf_prepare_pop,
+       .try_run = usbhsf_try_pop,
+};
+
+/*
+ *             handler function
+ */
+static int usbhsf_ctrl_stage_end(struct usbhs_pkt *pkt, int *is_done)
+{
+       usbhs_dcp_control_transfer_done(pkt->pipe);
+
+       *is_done = 1;
+
+       return 0;
+}
+
+struct usbhs_pkt_handle usbhs_ctrl_stage_end_handler = {
+       .prepare = usbhsf_ctrl_stage_end,
+       .try_run = usbhsf_ctrl_stage_end,
+};
+
+/*
+ *             irq functions
+ */
+static int usbhsf_irq_empty(struct usbhs_priv *priv,
+                           struct usbhs_irq_state *irq_state)
+{
+       struct usbhs_pipe *pipe;
+       struct device *dev = usbhs_priv_to_dev(priv);
+       int i, ret;
+
+       if (!irq_state->bempsts) {
+               dev_err(dev, "debug %s !!\n", __func__);
+               return -EIO;
+       }
+
+       dev_dbg(dev, "irq empty [0x%04x]\n", irq_state->bempsts);
+
+       /*
+        * search interrupted "pipe"
+        * not "uep".
+        */
+       usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
+               if (!(irq_state->bempsts & (1 << i)))
+                       continue;
+
+               ret = usbhs_pkt_run(pipe);
+               if (ret < 0)
+                       dev_err(dev, "irq_empty run_error %d : %d\n", i, ret);
+       }
+
+       return 0;
+}
+
+static int usbhsf_irq_ready(struct usbhs_priv *priv,
+                           struct usbhs_irq_state *irq_state)
+{
+       struct usbhs_pipe *pipe;
+       struct device *dev = usbhs_priv_to_dev(priv);
+       int i, ret;
+
+       if (!irq_state->brdysts) {
+               dev_err(dev, "debug %s !!\n", __func__);
+               return -EIO;
+       }
+
+       dev_dbg(dev, "irq ready [0x%04x]\n", irq_state->brdysts);
+
+       /*
+        * search interrupted "pipe"
+        * not "uep".
+        */
+       usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
+               if (!(irq_state->brdysts & (1 << i)))
+                       continue;
+
+               ret = usbhs_pkt_run(pipe);
+               if (ret < 0)
+                       dev_err(dev, "irq_ready run_error %d : %d\n", i, ret);
+       }
+
+       return 0;
+}
+
+/*
+ *             fifo init
+ */
+void usbhs_fifo_init(struct usbhs_priv *priv)
+{
+       struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+
+       mod->irq_empty          = usbhsf_irq_empty;
+       mod->irq_ready          = usbhsf_irq_ready;
+       mod->irq_bempsts        = 0;
+       mod->irq_brdysts        = 0;
+}
+
+void usbhs_fifo_quit(struct usbhs_priv *priv)
+{
+       struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+
+       mod->irq_empty          = NULL;
+       mod->irq_ready          = NULL;
+       mod->irq_bempsts        = 0;
+       mod->irq_brdysts        = 0;
+}