#endif
 
 #ifdef CONFIG_USB_TUSB6010
-static ushort __devinitdata fifo_mode = 4;
+static ushort __initdata fifo_mode = 4;
 #else
-static ushort __devinitdata fifo_mode = 2;
+static ushort __initdata fifo_mode = 2;
 #endif
 
 /* "modprobe ... fifo_mode=1" etc */
  */
 
 /* mode 0 - fits in 2KB */
-static const struct fifo_cfg __devinitdata mode_0_cfg[] = {
+static struct fifo_cfg __initdata mode_0_cfg[] = {
 { .hw_ep_num = 1, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num = 1, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num = 2, .style = FIFO_RXTX, .maxpacket = 512, },
 };
 
 /* mode 1 - fits in 4KB */
-static const struct fifo_cfg __devinitdata mode_1_cfg[] = {
+static struct fifo_cfg __initdata mode_1_cfg[] = {
 { .hw_ep_num = 1, .style = FIFO_TX,   .maxpacket = 512, .mode = BUF_DOUBLE, },
 { .hw_ep_num = 1, .style = FIFO_RX,   .maxpacket = 512, .mode = BUF_DOUBLE, },
 { .hw_ep_num = 2, .style = FIFO_RXTX, .maxpacket = 512, .mode = BUF_DOUBLE, },
 };
 
 /* mode 2 - fits in 4KB */
-static const struct fifo_cfg __devinitdata mode_2_cfg[] = {
+static struct fifo_cfg __initdata mode_2_cfg[] = {
 { .hw_ep_num = 1, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num = 1, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num = 2, .style = FIFO_TX,   .maxpacket = 512, },
 };
 
 /* mode 3 - fits in 4KB */
-static const struct fifo_cfg __devinitdata mode_3_cfg[] = {
+static struct fifo_cfg __initdata mode_3_cfg[] = {
 { .hw_ep_num = 1, .style = FIFO_TX,   .maxpacket = 512, .mode = BUF_DOUBLE, },
 { .hw_ep_num = 1, .style = FIFO_RX,   .maxpacket = 512, .mode = BUF_DOUBLE, },
 { .hw_ep_num = 2, .style = FIFO_TX,   .maxpacket = 512, },
 };
 
 /* mode 4 - fits in 16KB */
-static const struct fifo_cfg __devinitdata mode_4_cfg[] = {
+static struct fifo_cfg __initdata mode_4_cfg[] = {
 { .hw_ep_num =  1, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  1, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  2, .style = FIFO_TX,   .maxpacket = 512, },
  *
  * returns negative errno or offset for next fifo.
  */
-static int __devinit
+static int __init
 fifo_setup(struct musb *musb, struct musb_hw_ep  *hw_ep,
                const struct fifo_cfg *cfg, u16 offset)
 {
        return offset + (maxpacket << ((c_size & MGC_M_FIFOSZ_DPB) ? 1 : 0));
 }
 
-static const struct fifo_cfg __devinitdata ep0_cfg = {
+static struct fifo_cfg __initdata ep0_cfg = {
        .style = FIFO_RXTX, .maxpacket = 64,
 };
 
-static int __devinit ep_config_from_table(struct musb *musb)
+static int __init ep_config_from_table(struct musb *musb)
 {
        const struct fifo_cfg   *cfg;
        unsigned                i, n;
  * ep_config_from_hw - when MUSB_C_DYNFIFO_DEF is false
  * @param pThis the controller
  */
-static int __devinit ep_config_from_hw(struct musb *musb)
+static int __init ep_config_from_hw(struct musb *musb)
 {
        u8 bEnd = 0, reg;
        struct musb_hw_ep *pEnd;
 /* Initialize MUSB (M)HDRC part of the USB hardware subsystem;
  * configure endpoints, or take their config from silicon
  */
-static int __devinit musb_core_init(u16 wType, struct musb *pThis)
+static int __init musb_core_init(u16 wType, struct musb *pThis)
 {
 #ifdef MUSB_AHB_ID
        u32 dwData;
 
 
 #ifndef CONFIG_USB_INVENTRA_FIFO
-static int __devinitdata use_dma = is_dma_capable();
+static int __initdata use_dma = 1;
 
 /* "modprobe ... use_dma=0" etc */
 module_param(use_dma, bool, 0);
 }
 
 #else
-#define use_dma                        is_dma_capable()
+#define use_dma                        0
 #endif
 
 /*-------------------------------------------------------------------------*/
  * Init support
  */
 
-static struct musb *__devinit
+static struct musb *__init
 allocate_instance(struct device *dev, void __iomem *mbase)
 {
        struct musb             *musb;
  * @pRegs: virtual address of controller registers,
  *     not yet corrected for platform-specific offsets
  */
-static int __devinit
+static int __init
 musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
 {
        int                     status;
        if (use_dma && dev->dma_mask) {
                struct dma_controller   *c;
 
+// FIXME get rid of dma_controller_factory and just call the methods
+// directly ... then create() can be in the init section, etc
+
                c = dma_controller_factory.create(pThis, pThis->pRegs);
                pThis->pDmaController = c;
                if (c)
                goto fail2;
        }
        pThis->nIrq = nIrq;
+// FIXME this handles wakeup irqs wrong
        if (enable_irq_wake(nIrq) == 0)
                device_init_wakeup(dev, 1);
 
 static u64     *orig_dma_mask;
 #endif
 
-static int __devinit musb_probe(struct platform_device *pdev)
+static int __init musb_probe(struct platform_device *pdev)
 {
        struct device   *dev = &pdev->dev;
        int             irq = platform_get_irq(pdev, 0);
                .bus            = &platform_bus_type,
                .owner          = THIS_MODULE,
        },
-       .probe          = musb_probe,
        .remove         = __devexit_p(musb_remove),
        .shutdown       = musb_shutdown,
        .suspend        = musb_suspend,
 #endif
                ", debug=%d\n",
                musb_driver_name, debug);
-       return platform_driver_register(&musb_driver);
+       return platform_driver_probe(&musb_driver, musb_probe);
 }
 
 /* make us init after usbcore and before usb