usb: musb: Make busctl_offset an io-op rather then a define

The Allwinner (sunxi) implementation of the musb has its busctl registers
indexed by the MUSB_INDEX register rather then in a flat address space.

This commit turns MUSB_BUSCTL_OFFSET from a macro into an io-op which can
be overridden from the platform ops.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Felipe Balbi <balbi@ti.com>

diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index a3bc06d56fcb4a7e687b37fb24a4391f05cd6116..fea3402f12d55395af2c9d005a33fa475f0a3ddd 100644 (file)
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -251,6 +251,11 @@ static u32 musb_indexed_ep_offset(u8 epnum, u16 offset)
        return 0x10 + offset;
 }
 
+static u32 musb_default_busctl_offset(u8 epnum, u16 offset)
+{
+       return 0x80 + (0x08 * epnum) + offset;
+}
+
 static u8 musb_default_readb(const void __iomem *addr, unsigned offset)
 {
        return __raw_readb(addr + offset);
@@ -2052,6 +2057,11 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
        else
                musb->io.fifo_offset = musb_default_fifo_offset;
 
+       if (musb->ops->busctl_offset)
+               musb->io.busctl_offset = musb->ops->busctl_offset;
+       else
+               musb->io.busctl_offset = musb_default_busctl_offset;
+
        if (musb->ops->readb)
                musb_readb = musb->ops->readb;
        if (musb->ops->writeb)
@@ -2332,18 +2342,18 @@ static void musb_save_context(struct musb *musb)
                        musb_readb(epio, MUSB_RXINTERVAL);
 
                musb->context.index_regs[i].txfunaddr =
-                       musb_read_txfunaddr(musb_base, i);
+                       musb_read_txfunaddr(musb, i);
                musb->context.index_regs[i].txhubaddr =
-                       musb_read_txhubaddr(musb_base, i);
+                       musb_read_txhubaddr(musb, i);
                musb->context.index_regs[i].txhubport =
-                       musb_read_txhubport(musb_base, i);
+                       musb_read_txhubport(musb, i);
 
                musb->context.index_regs[i].rxfunaddr =
-                       musb_read_rxfunaddr(musb_base, i);
+                       musb_read_rxfunaddr(musb, i);
                musb->context.index_regs[i].rxhubaddr =
-                       musb_read_rxhubaddr(musb_base, i);
+                       musb_read_rxhubaddr(musb, i);
                musb->context.index_regs[i].rxhubport =
-                       musb_read_rxhubport(musb_base, i);
+                       musb_read_rxhubport(musb, i);
        }
 }
 
@@ -2411,18 +2421,18 @@ static void musb_restore_context(struct musb *musb)
                musb_writeb(epio, MUSB_RXINTERVAL,
 
                                musb->context.index_regs[i].rxinterval);
-               musb_write_txfunaddr(musb_base, i,
+               musb_write_txfunaddr(musb, i,
                                musb->context.index_regs[i].txfunaddr);
-               musb_write_txhubaddr(musb_base, i,
+               musb_write_txhubaddr(musb, i,
                                musb->context.index_regs[i].txhubaddr);
-               musb_write_txhubport(musb_base, i,
+               musb_write_txhubport(musb, i,
                                musb->context.index_regs[i].txhubport);
 
-               musb_write_rxfunaddr(musb_base, i,
+               musb_write_rxfunaddr(musb, i,
                                musb->context.index_regs[i].rxfunaddr);
-               musb_write_rxhubaddr(musb_base, i,
+               musb_write_rxhubaddr(musb, i,
                                musb->context.index_regs[i].rxhubaddr);
-               musb_write_rxhubport(musb_base, i,
+               musb_write_rxhubport(musb, i,
                                musb->context.index_regs[i].rxhubport);
        }
        musb_writeb(musb_base, MUSB_INDEX, musb->context.index);

diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index b8372f6006e36570a64a7420fe082174f0ae1e3c..4b886d0f6bdf1bcf10ca5477b9ea0820efc8d5b1 100644 (file)
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -67,7 +67,6 @@ struct musb_ep;
 #include "musb_dma.h"
 
 #include "musb_io.h"
-#include "musb_regs.h"
 
 #include "musb_gadget.h"
 #include <linux/usb/hcd.h>
@@ -191,6 +190,7 @@ struct musb_platform_ops {
        void    (*ep_select)(void __iomem *mbase, u8 epnum);
        u16     fifo_mode;
        u32     (*fifo_offset)(u8 epnum);
+       u32     (*busctl_offset)(u8 epnum, u16 offset);
        u8      (*readb)(const void __iomem *addr, unsigned offset);
        void    (*writeb)(void __iomem *addr, unsigned offset, u8 data);
        u16     (*readw)(const void __iomem *addr, unsigned offset);
@@ -444,6 +444,9 @@ struct musb {
 #endif
 };
 
+/* This must be included after struct musb is defined */
+#include "musb_regs.h"
+
 static inline struct musb *gadget_to_musb(struct usb_gadget *g)
 {
        return container_of(g, struct musb, g);

diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 4a19c8110e7aa026ecca71f4916687de8c0ef174..26c65e66cc0f1db8680933d13ed2d2b960603906 100644 (file)
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -595,9 +595,9 @@ musb_rx_reinit(struct musb *musb, struct musb_qh *qh, u8 epnum)
 
        /* target addr and (for multipoint) hub addr/port */
        if (musb->is_multipoint) {
-               musb_write_rxfunaddr(musb->mregs, epnum, qh->addr_reg);
-               musb_write_rxhubaddr(musb->mregs, epnum, qh->h_addr_reg);
-               musb_write_rxhubport(musb->mregs, epnum, qh->h_port_reg);
+               musb_write_rxfunaddr(musb, epnum, qh->addr_reg);
+               musb_write_rxhubaddr(musb, epnum, qh->h_addr_reg);
+               musb_write_rxhubport(musb, epnum, qh->h_port_reg);
        } else
                musb_writeb(musb->mregs, MUSB_FADDR, qh->addr_reg);
 
@@ -836,9 +836,9 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
 
                /* target addr and (for multipoint) hub addr/port */
                if (musb->is_multipoint) {
-                       musb_write_txfunaddr(mbase, epnum, qh->addr_reg);
-                       musb_write_txhubaddr(mbase, epnum, qh->h_addr_reg);
-                       musb_write_txhubport(mbase, epnum, qh->h_port_reg);
+                       musb_write_txfunaddr(musb, epnum, qh->addr_reg);
+                       musb_write_txhubaddr(musb, epnum, qh->h_addr_reg);
+                       musb_write_txhubport(musb, epnum, qh->h_port_reg);
 /* FIXME if !epnum, do the same for RX ... */
                } else
                        musb_writeb(mbase, MUSB_FADDR, qh->addr_reg);

diff --git a/drivers/usb/musb/musb_io.h b/drivers/usb/musb/musb_io.h
index 8a57a6f4b3a637705260b3c20fb6ee5f0503b8cc..17a80ae206746927eb79452d2ee180b598270a0f 100644 (file)
--- a/drivers/usb/musb/musb_io.h
+++ b/drivers/usb/musb/musb_io.h
@@ -47,6 +47,7 @@
  * @fifo_offset: platform specific function to get fifo offset
  * @read_fifo: platform specific function to read fifo
  * @write_fifo:        platform specific function to write fifo
+ * @busctl_offset: platform specific function to get busctl offset
  */
 struct musb_io {
        u32     quirks;
@@ -55,6 +56,7 @@ struct musb_io {
        u32     (*fifo_offset)(u8 epnum);
        void    (*read_fifo)(struct musb_hw_ep *hw_ep, u16 len, u8 *buf);
        void    (*write_fifo)(struct musb_hw_ep *hw_ep, u16 len, const u8 *buf);
+       u32     (*busctl_offset)(u8 epnum, u16 offset);
 };
 
 /* Do not add new entries here, add them the struct musb_io instead */

diff --git a/drivers/usb/musb/musb_regs.h b/drivers/usb/musb/musb_regs.h
index edfc730f0ab203767f3d8271c7fd6199ea02ec52..cff5bcf0d00f61915912f5bd80de152dc2795bfb 100644 (file)
--- a/drivers/usb/musb/musb_regs.h
+++ b/drivers/usb/musb/musb_regs.h
@@ -300,9 +300,6 @@
 #define MUSB_RXHUBADDR         0x06
 #define MUSB_RXHUBPORT         0x07
 
-#define MUSB_BUSCTL_OFFSET(_epnum, _offset) \
-       (0x80 + (8*(_epnum)) + (_offset))
-
 static inline void musb_write_txfifosz(void __iomem *mbase, u8 c_size)
 {
        musb_writeb(mbase, MUSB_TXFIFOSZ, c_size);
@@ -364,76 +361,84 @@ static inline u16 musb_read_hwvers(void __iomem *mbase)
        return musb_readw(mbase, MUSB_HWVERS);
 }
 
-static inline void musb_write_rxfunaddr(void __iomem *mbase, u8 epnum,
+static inline void musb_write_rxfunaddr(struct musb *musb, u8 epnum,
                u8 qh_addr_reg)
 {
-       musb_writeb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_RXFUNCADDR),
-                       qh_addr_reg);
+       musb_writeb(musb->mregs,
+                   musb->io.busctl_offset(epnum, MUSB_RXFUNCADDR),
+                   qh_addr_reg);
 }
 
-static inline void musb_write_rxhubaddr(void __iomem *mbase, u8 epnum,
+static inline void musb_write_rxhubaddr(struct musb *musb, u8 epnum,
                u8 qh_h_addr_reg)
 {
-       musb_writeb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_RXHUBADDR),
+       musb_writeb(musb->mregs, musb->io.busctl_offset(epnum, MUSB_RXHUBADDR),
                        qh_h_addr_reg);
 }
 
-static inline void musb_write_rxhubport(void __iomem *mbase, u8 epnum,
+static inline void musb_write_rxhubport(struct musb *musb, u8 epnum,
                u8 qh_h_port_reg)
 {
-       musb_writeb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_RXHUBPORT),
+       musb_writeb(musb->mregs, musb->io.busctl_offset(epnum, MUSB_RXHUBPORT),
                        qh_h_port_reg);
 }
 
-static inline void  musb_write_txfunaddr(void __iomem *mbase, u8 epnum,
+static inline void musb_write_txfunaddr(struct musb *musb, u8 epnum,
                u8 qh_addr_reg)
 {
-       musb_writeb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXFUNCADDR),
-                       qh_addr_reg);
+       musb_writeb(musb->mregs,
+                   musb->io.busctl_offset(epnum, MUSB_TXFUNCADDR),
+                   qh_addr_reg);
 }
 
-static inline void  musb_write_txhubaddr(void __iomem *mbase, u8 epnum,
+static inline void musb_write_txhubaddr(struct musb *musb, u8 epnum,
                u8 qh_addr_reg)
 {
-       musb_writeb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXHUBADDR),
+       musb_writeb(musb->mregs, musb->io.busctl_offset(epnum, MUSB_TXHUBADDR),
                        qh_addr_reg);
 }
 
-static inline void  musb_write_txhubport(void __iomem *mbase, u8 epnum,
+static inline void musb_write_txhubport(struct musb *musb, u8 epnum,
                u8 qh_h_port_reg)
 {
-       musb_writeb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXHUBPORT),
+       musb_writeb(musb->mregs, musb->io.busctl_offset(epnum, MUSB_TXHUBPORT),
                        qh_h_port_reg);
 }
 
-static inline u8 musb_read_rxfunaddr(void __iomem *mbase, u8 epnum)
+static inline u8 musb_read_rxfunaddr(struct musb *musb, u8 epnum)
 {
-       return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_RXFUNCADDR));
+       return musb_readb(musb->mregs,
+                         musb->io.busctl_offset(epnum, MUSB_RXFUNCADDR));
 }
 
-static inline u8 musb_read_rxhubaddr(void __iomem *mbase, u8 epnum)
+static inline u8 musb_read_rxhubaddr(struct musb *musb, u8 epnum)
 {
-       return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_RXHUBADDR));
+       return musb_readb(musb->mregs,
+                         musb->io.busctl_offset(epnum, MUSB_RXHUBADDR));
 }
 
-static inline u8 musb_read_rxhubport(void __iomem *mbase, u8 epnum)
+static inline u8 musb_read_rxhubport(struct musb *musb, u8 epnum)
 {
-       return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_RXHUBPORT));
+       return musb_readb(musb->mregs,
+                         musb->io.busctl_offset(epnum, MUSB_RXHUBPORT));
 }
 
-static inline u8  musb_read_txfunaddr(void __iomem *mbase, u8 epnum)
+static inline u8 musb_read_txfunaddr(struct musb *musb, u8 epnum)
 {
-       return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXFUNCADDR));
+       return musb_readb(musb->mregs,
+                         musb->io.busctl_offset(epnum, MUSB_TXFUNCADDR));
 }
 
-static inline u8  musb_read_txhubaddr(void __iomem *mbase, u8 epnum)
+static inline u8 musb_read_txhubaddr(struct musb *musb, u8 epnum)
 {
-       return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXHUBADDR));
+       return musb_readb(musb->mregs,
+                         musb->io.busctl_offset(epnum, MUSB_TXHUBADDR));
 }
 
-static inline u8  musb_read_txhubport(void __iomem *mbase, u8 epnum)
+static inline u8 musb_read_txhubport(struct musb *musb, u8 epnum)
 {
-       return musb_readb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXHUBPORT));
+       return musb_readb(musb->mregs,
+                         musb->io.busctl_offset(epnum, MUSB_TXHUBPORT));
 }
 
 #else /* CONFIG_BLACKFIN */