usb: musb: drop a gigantic amount of ifdeferry
authorFelipe Balbi <balbi@ti.com>
Wed, 22 Jun 2011 14:28:09 +0000 (17:28 +0300)
committerGreg Kroah-Hartman <gregkh@suse.de>
Fri, 1 Jul 2011 21:31:10 +0000 (14:31 -0700)
the MUSB IP is always OTG, so there's no point
in adding so many ifdefs on the code. Drop those
and always compile the driver for OTG support.

This also allows us to drop the useless "driver
mode" choice. For doing that, we need to make
musb depend on both Host and Peripheral side.

Signed-off-by: Felipe Balbi <balbi@ti.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
14 files changed:
drivers/usb/musb/Kconfig
drivers/usb/musb/Makefile
drivers/usb/musb/am35x.c
drivers/usb/musb/blackfin.h
drivers/usb/musb/da8xx.c
drivers/usb/musb/davinci.c
drivers/usb/musb/musb_core.c
drivers/usb/musb/musb_core.h
drivers/usb/musb/musb_gadget.c
drivers/usb/musb/musb_gadget_ep0.c
drivers/usb/musb/musb_host.h
drivers/usb/musb/musb_virthub.c
drivers/usb/musb/omap2430.c
drivers/usb/musb/tusb6010.c

index 13093481f9180ae67d41dcc503d80d6572eb0548..6192b45959f434d2e32b10a9e404f0f7c02fbd47 100644 (file)
@@ -8,7 +8,7 @@ comment "Enable Host or Gadget support to see Inventra options"
 
 # (M)HDRC = (Multipoint) Highspeed Dual-Role Controller
 config USB_MUSB_HDRC
-       depends on (USB || USB_GADGET)
+       depends on USB && USB_GADGET
        depends on (ARM || (BF54x && !BF544) || (BF52x && !BF522 && !BF523))
        select NOP_USB_XCEIV if (ARCH_DAVINCI || MACH_OMAP3EVM || BLACKFIN)
        select TWL4030_USB if MACH_OMAP_3430SDP
@@ -67,79 +67,6 @@ config USB_MUSB_UX500
 
 endchoice
 
-choice
-       prompt "Driver Mode"
-       depends on USB_MUSB_HDRC
-       help
-         Dual-Role devices can support both host and peripheral roles,
-         as well as a the special "OTG Device" role which can switch
-         between both roles as needed.
-
-# use USB_MUSB_HDRC_HCD not USB_MUSB_HOST to #ifdef host side support;
-# OTG needs both roles, not just USB_MUSB_HOST.
-config USB_MUSB_HOST
-       depends on USB
-       bool "USB Host"
-       help
-         Say Y here if your system supports the USB host role.
-         If it has a USB "A" (rectangular), "Mini-A" (uncommon),
-         or "Mini-AB" connector, it supports the host role.
-         (With a "Mini-AB" connector, you should enable USB OTG.)
-
-# use USB_GADGET_MUSB_HDRC not USB_MUSB_PERIPHERAL to #ifdef peripheral
-# side support ... OTG needs both roles
-config USB_MUSB_PERIPHERAL
-       depends on USB_GADGET
-       bool "USB Peripheral (gadget stack)"
-       select USB_GADGET_MUSB_HDRC
-       help
-         Say Y here if your system supports the USB peripheral role.
-         If it has a USB "B" (squarish), "Mini-B", or "Mini-AB"
-         connector, it supports the peripheral role.
-         (With a "Mini-AB" connector, you should enable USB OTG.)
-
-config USB_MUSB_OTG
-       depends on USB && USB_GADGET && PM && EXPERIMENTAL
-       bool "Both host and peripheral:  USB OTG (On The Go) Device"
-       select USB_GADGET_MUSB_HDRC
-       select USB_OTG
-       help
-          The most notable feature of USB OTG is support for a
-          "Dual-Role" device, which can act as either a device
-          or a host.  The initial role choice can be changed
-          later, when two dual-role devices talk to each other.
-
-          At this writing, the OTG support in this driver is incomplete,
-          omitting the mandatory HNP or SRP protocols.  However, some
-          of the cable based role switching works.  (That is, grounding
-          the ID pin switches the controller to host mode, while leaving
-          it floating leaves it in peripheral mode.)
-
-          Select this if your system has a Mini-AB connector, or
-          to simplify certain kinds of configuration.
-
-          To implement your OTG Targeted Peripherals List (TPL), enable
-          USB_OTG_WHITELIST and update "drivers/usb/core/otg_whitelist.h"
-          to match your requirements.
-
-endchoice
-
-# enable peripheral support (including with OTG)
-config USB_GADGET_MUSB_HDRC
-       bool
-       depends on USB_MUSB_HDRC && (USB_MUSB_PERIPHERAL || USB_MUSB_OTG)
-#      default y
-#      select USB_GADGET_DUALSPEED
-#      select USB_GADGET_SELECTED
-
-# enables host support (including with OTG)
-config USB_MUSB_HDRC_HCD
-       bool
-       depends on USB_MUSB_HDRC && (USB_MUSB_HOST || USB_MUSB_OTG)
-       select USB_OTG if USB_GADGET_MUSB_HDRC
-       default y
-
-
 config MUSB_PIO_ONLY
        bool 'Disable DMA (always use PIO)'
        depends on USB_MUSB_HDRC
index c4d228b6ef8a5e2e752782e09d312c8cc526d732..d8fd9d092dec55a4691e9c41124f60e08b540c9c 100644 (file)
@@ -6,8 +6,8 @@ obj-$(CONFIG_USB_MUSB_HDRC) += musb_hdrc.o
 
 musb_hdrc-y := musb_core.o
 
-musb_hdrc-$(CONFIG_USB_GADGET_MUSB_HDRC)       += musb_gadget_ep0.o musb_gadget.o
-musb_hdrc-$(CONFIG_USB_MUSB_HDRC_HCD)          += musb_virthub.o musb_host.o
+musb_hdrc-y                                    += musb_gadget_ep0.o musb_gadget.o
+musb_hdrc-y                                    += musb_virthub.o musb_host.o
 musb_hdrc-$(CONFIG_DEBUG_FS)                   += musb_debugfs.o
 
 # Hardware Glue Layer
index 23ac28f98d916f61d1031adee11b0e0e12eb07f1..08f1d0b662a37b64558e70777bf13f609da1bb47 100644 (file)
@@ -124,11 +124,7 @@ static void am35x_musb_disable(struct musb *musb)
        musb_writel(reg_base, USB_END_OF_INTR_REG, 0);
 }
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
 #define portstate(stmt)                stmt
-#else
-#define portstate(stmt)
-#endif
 
 static void am35x_musb_set_vbus(struct musb *musb, int is_on)
 {
index bd9352a2ef2a0b89f867121f998a9d3ef486bbed..c84dae546dc60f0e4a5f775698406f73600c60c3 100644 (file)
@@ -47,7 +47,7 @@
  * So, need to either use silicon v0.2+ or disable DMA mode in MUSB.
  */
 #if ANOMALY_05000380 && defined(CONFIG_BF52x) && \
-    defined(CONFIG_USB_MUSB_HDRC) && !defined(CONFIG_MUSB_PIO_ONLY)
+       !defined(CONFIG_MUSB_PIO_ONLY)
 # error "Please use PIO mode in MUSB driver on bf52x chip v0.0 and v0.1"
 #endif
 
index 662ed34980bd3ea854071c089a27e1ab09bdf67b..4da7492ddbdba25768f4acbce91c1802195f48da 100644 (file)
@@ -172,11 +172,7 @@ static void da8xx_musb_disable(struct musb *musb)
        musb_writel(reg_base, DA8XX_USB_END_OF_INTR_REG, 0);
 }
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
-#define portstate(stmt)        stmt
-#else
-#define portstate(stmt)
-#endif
+#define portstate(stmt)                stmt
 
 static void da8xx_musb_set_vbus(struct musb *musb, int is_on)
 {
@@ -397,21 +393,15 @@ static int da8xx_musb_set_mode(struct musb *musb, u8 musb_mode)
 
        cfgchip2 &= ~CFGCHIP2_OTGMODE;
        switch (musb_mode) {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        case MUSB_HOST:         /* Force VBUS valid, ID = 0 */
                cfgchip2 |= CFGCHIP2_FORCE_HOST;
                break;
-#endif
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
        case MUSB_PERIPHERAL:   /* Force VBUS valid, ID = 1 */
                cfgchip2 |= CFGCHIP2_FORCE_DEVICE;
                break;
-#endif
-#ifdef CONFIG_USB_MUSB_OTG
        case MUSB_OTG:          /* Don't override the VBUS/ID comparators */
                cfgchip2 |= CFGCHIP2_NO_OVERRIDE;
                break;
-#endif
        default:
                dev_dbg(musb->controller, "Trying to set unsupported mode %u\n", musb_mode);
        }
index 2a2adf6492cde9cc71fbd523a898e89d85e1e6ec..8bdf25a8b023645ec839361cdc18f86dc624c7bb 100644 (file)
@@ -143,12 +143,7 @@ static void davinci_musb_disable(struct musb *musb)
 }
 
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
 #define        portstate(stmt)         stmt
-#else
-#define        portstate(stmt)
-#endif
-
 
 /*
  * VBUS SWITCHING IS BOARD-SPECIFIC ... at least for the DM6446 EVM,
index b1faed7806f5e13a73692af36fcfc7ccfaaf9bc2..7ab9497955890703c98fd3f22afef5a5573a1e2b 100644 (file)
@@ -328,8 +328,6 @@ void musb_load_testpacket(struct musb *musb)
 
 /*-------------------------------------------------------------------------*/
 
-#ifdef CONFIG_USB_MUSB_OTG
-
 /*
  * Handles OTG hnp timeouts, such as b_ase0_brst
  */
@@ -401,8 +399,6 @@ void musb_hnp_stop(struct musb *musb)
        musb->port1_status &= ~(USB_PORT_STAT_C_CONNECTION << 16);
 }
 
-#endif
-
 /*
  * Interrupt Service Routine to record USB "global" interrupts.
  * Since these do not happen often and signify things of
@@ -432,7 +428,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                dev_dbg(musb->controller, "RESUME (%s)\n", otg_state_string(musb->xceiv->state));
 
                if (devctl & MUSB_DEVCTL_HM) {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                        void __iomem *mbase = musb->mregs;
 
                        switch (musb->xceiv->state) {
@@ -472,17 +467,13 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                        "host",
                                        otg_state_string(musb->xceiv->state));
                        }
-#endif
                } else {
                        switch (musb->xceiv->state) {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                        case OTG_STATE_A_SUSPEND:
                                /* possibly DISCONNECT is upcoming */
                                musb->xceiv->state = OTG_STATE_A_HOST;
                                usb_hcd_resume_root_hub(musb_to_hcd(musb));
                                break;
-#endif
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
                        case OTG_STATE_B_WAIT_ACON:
                        case OTG_STATE_B_PERIPHERAL:
                                /* disconnect while suspended?  we may
@@ -500,7 +491,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                        case OTG_STATE_B_IDLE:
                                musb->int_usb &= ~MUSB_INTR_SUSPEND;
                                break;
-#endif
                        default:
                                WARNING("bogus %s RESUME (%s)\n",
                                        "peripheral",
@@ -509,7 +499,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                }
        }
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        /* see manual for the order of the tests */
        if (int_usb & MUSB_INTR_SESSREQ) {
                void __iomem *mbase = musb->mregs;
@@ -609,14 +598,12 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                handled = IRQ_HANDLED;
        }
 
-#endif
        if (int_usb & MUSB_INTR_SUSPEND) {
                dev_dbg(musb->controller, "SUSPEND (%s) devctl %02x power %02x\n",
                        otg_state_string(musb->xceiv->state), devctl, power);
                handled = IRQ_HANDLED;
 
                switch (musb->xceiv->state) {
-#ifdef CONFIG_USB_MUSB_OTG
                case OTG_STATE_A_PERIPHERAL:
                        /* We also come here if the cable is removed, since
                         * this silicon doesn't report ID-no-longer-grounded.
@@ -633,7 +620,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                                ? : OTG_TIME_A_WAIT_BCON));
 
                        break;
-#endif
                case OTG_STATE_B_IDLE:
                        if (!musb->is_active)
                                break;
@@ -642,13 +628,11 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                        musb->is_active = is_otg_enabled(musb)
                                        && musb->xceiv->gadget->b_hnp_enable;
                        if (musb->is_active) {
-#ifdef CONFIG_USB_MUSB_OTG
                                musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
                                dev_dbg(musb->controller, "HNP: Setting timer for b_ase0_brst\n");
                                mod_timer(&musb->otg_timer, jiffies
                                        + msecs_to_jiffies(
                                                        OTG_TIME_B_ASE0_BRST));
-#endif
                        }
                        break;
                case OTG_STATE_A_WAIT_BCON:
@@ -672,7 +656,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                }
        }
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        if (int_usb & MUSB_INTR_CONNECT) {
                struct usb_hcd *hcd = musb_to_hcd(musb);
 
@@ -682,7 +665,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 
                musb->ep0_stage = MUSB_EP0_START;
 
-#ifdef CONFIG_USB_MUSB_OTG
                /* flush endpoints when transitioning from Device Mode */
                if (is_peripheral_active(musb)) {
                        /* REVISIT HNP; just force disconnect */
@@ -690,7 +672,6 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                musb_writew(musb->mregs, MUSB_INTRTXE, musb->epmask);
                musb_writew(musb->mregs, MUSB_INTRRXE, musb->epmask & 0xfffe);
                musb_writeb(musb->mregs, MUSB_INTRUSBE, 0xf7);
-#endif
                musb->port1_status &= ~(USB_PORT_STAT_LOW_SPEED
                                        |USB_PORT_STAT_HIGH_SPEED
                                        |USB_PORT_STAT_ENABLE
@@ -739,7 +720,6 @@ b_host:
                dev_dbg(musb->controller, "CONNECT (%s) devctl %02x\n",
                                otg_state_string(musb->xceiv->state), devctl);
        }
-#endif /* CONFIG_USB_MUSB_HDRC_HCD */
 
        if ((int_usb & MUSB_INTR_DISCONNECT) && !musb->ignore_disconnect) {
                dev_dbg(musb->controller, "DISCONNECT (%s) as %s, devctl %02x\n",
@@ -748,7 +728,6 @@ b_host:
                handled = IRQ_HANDLED;
 
                switch (musb->xceiv->state) {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                case OTG_STATE_A_HOST:
                case OTG_STATE_A_SUSPEND:
                        usb_hcd_resume_root_hub(musb_to_hcd(musb));
@@ -757,8 +736,6 @@ b_host:
                                musb_platform_try_idle(musb, jiffies
                                        + msecs_to_jiffies(musb->a_wait_bcon));
                        break;
-#endif /* HOST */
-#ifdef CONFIG_USB_MUSB_OTG
                case OTG_STATE_B_HOST:
                        /* REVISIT this behaves for "real disconnect"
                         * cases; make sure the other transitions from
@@ -777,13 +754,10 @@ b_host:
                        /* FALLTHROUGH */
                case OTG_STATE_B_WAIT_ACON:
                        /* FALLTHROUGH */
-#endif /* OTG */
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
                case OTG_STATE_B_PERIPHERAL:
                case OTG_STATE_B_IDLE:
                        musb_g_disconnect(musb);
                        break;
-#endif /* GADGET */
                default:
                        WARNING("unhandled DISCONNECT transition (%s)\n",
                                otg_state_string(musb->xceiv->state));
@@ -814,7 +788,6 @@ b_host:
                        dev_dbg(musb->controller, "BUS RESET as %s\n",
                                otg_state_string(musb->xceiv->state));
                        switch (musb->xceiv->state) {
-#ifdef CONFIG_USB_OTG
                        case OTG_STATE_A_SUSPEND:
                                /* We need to ignore disconnect on suspend
                                 * otherwise tusb 2.0 won't reconnect after a
@@ -842,7 +815,6 @@ b_host:
                                musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
                                musb_g_reset(musb);
                                break;
-#endif
                        case OTG_STATE_B_IDLE:
                                musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
                                /* FALLTHROUGH */
@@ -1191,14 +1163,12 @@ fifo_setup(struct musb *musb, struct musb_hw_ep  *hw_ep,
        /* configure the FIFO */
        musb_writeb(mbase, MUSB_INDEX, hw_ep->epnum);
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        /* EP0 reserved endpoint for control, bidirectional;
         * EP1 reserved for bulk, two unidirection halves.
         */
        if (hw_ep->epnum == 1)
                musb->bulk_ep = hw_ep;
        /* REVISIT error check:  be sure ep0 can both rx and tx ... */
-#endif
        switch (cfg->style) {
        case FIFO_TX:
                musb_write_txfifosz(mbase, c_size);
@@ -1317,12 +1287,10 @@ done:
                        n + 1, musb->config->num_eps * 2 - 1,
                        offset, (1 << (musb->config->ram_bits + 2)));
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        if (!musb->bulk_ep) {
                pr_debug("%s: missing bulk\n", musb_driver_name);
                return -EINVAL;
        }
-#endif
 
        return 0;
 }
@@ -1353,7 +1321,6 @@ static int __init ep_config_from_hw(struct musb *musb)
 
                /* FIXME set up hw_ep->{rx,tx}_double_buffered */
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                /* pick an RX/TX endpoint for bulk */
                if (hw_ep->max_packet_sz_tx < 512
                                || hw_ep->max_packet_sz_rx < 512)
@@ -1365,15 +1332,12 @@ static int __init ep_config_from_hw(struct musb *musb)
                if (musb->bulk_ep)
                        continue;
                musb->bulk_ep = hw_ep;
-#endif
        }
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        if (!musb->bulk_ep) {
                pr_debug("%s: missing bulk\n", musb_driver_name);
                return -EINVAL;
        }
-#endif
 
        return 0;
 }
@@ -1429,12 +1393,10 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
        } else {
                musb->is_multipoint = 0;
                type = "";
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
 #ifndef        CONFIG_USB_OTG_BLACKLIST_HUB
                printk(KERN_ERR
                        "%s: kernel must blacklist external hubs\n",
                        musb_driver_name);
-#endif
 #endif
        }
 
@@ -1479,11 +1441,9 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
 #endif
 
                hw_ep->regs = MUSB_EP_OFFSET(i, 0) + mbase;
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                hw_ep->target_regs = musb_read_target_reg_base(i, mbase);
                hw_ep->rx_reinit = 1;
                hw_ep->tx_reinit = 1;
-#endif
 
                if (hw_ep->max_packet_sz_tx) {
                        dev_dbg(musb->controller,
@@ -1561,13 +1521,11 @@ irqreturn_t musb_interrupt(struct musb *musb)
                (devctl & MUSB_DEVCTL_HM) ? "host" : "peripheral",
                musb->int_usb, musb->int_tx, musb->int_rx);
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
        if (is_otg_enabled(musb) || is_peripheral_enabled(musb))
                if (!musb->gadget_driver) {
                        dev_dbg(musb->controller, "No gadget driver loaded\n");
                        return IRQ_HANDLED;
                }
-#endif
 
        /* the core can interrupt us for multiple reasons; docs have
         * a generic interrupt flowchart to follow
@@ -1767,8 +1725,6 @@ musb_vbus_show(struct device *dev, struct device_attribute *attr, char *buf)
 }
 static DEVICE_ATTR(vbus, 0644, musb_vbus_show, musb_vbus_store);
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-
 /* Gadget drivers can't know that a host is connected so they might want
  * to start SRP, but users can.  This allows userspace to trigger SRP.
  */
@@ -1792,14 +1748,10 @@ musb_srp_store(struct device *dev, struct device_attribute *attr,
 }
 static DEVICE_ATTR(srp, 0644, NULL, musb_srp_store);
 
-#endif /* CONFIG_USB_GADGET_MUSB_HDRC */
-
 static struct attribute *musb_attributes[] = {
        &dev_attr_mode.attr,
        &dev_attr_vbus.attr,
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
        &dev_attr_srp.attr,
-#endif
        NULL
 };
 
@@ -1832,7 +1784,6 @@ allocate_instance(struct device *dev,
        struct musb             *musb;
        struct musb_hw_ep       *ep;
        int                     epnum;
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        struct usb_hcd  *hcd;
 
        hcd = usb_create_hcd(&musb_hc_driver, dev, dev_name(dev));
@@ -1850,12 +1801,6 @@ allocate_instance(struct device *dev,
 
        musb->vbuserr_retry = VBUSERR_RETRY_COUNT;
        musb->a_wait_bcon = OTG_TIME_A_WAIT_BCON;
-#else
-       musb = kzalloc(sizeof *musb, GFP_KERNEL);
-       if (!musb)
-               return NULL;
-
-#endif
        dev_set_drvdata(dev, musb);
        musb->mregs = mbase;
        musb->ctrl_base = mbase;
@@ -1885,9 +1830,7 @@ static void musb_free(struct musb *musb)
        sysfs_remove_group(&musb->controller->kobj, &musb_attr_group);
 #endif
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
        musb_gadget_cleanup(musb);
-#endif
 
        if (musb->nIrq >= 0) {
                if (musb->irq_wake)
@@ -1901,11 +1844,7 @@ static void musb_free(struct musb *musb)
                dma_controller_destroy(c);
        }
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
-       usb_put_hcd(musb_to_hcd(musb));
-#else
        kfree(musb);
-#endif
 }
 
 /*
@@ -2000,9 +1939,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
        if (status < 0)
                goto fail3;
 
-#ifdef CONFIG_USB_MUSB_OTG
        setup_timer(&musb->otg_timer, musb_otg_timer_func, (unsigned long) musb);
-#endif
 
        /* Init IRQ workqueue before request_irq */
        INIT_WORK(&musb->irq_work, musb_irq_work);
@@ -2444,34 +2381,13 @@ static struct platform_driver musb_driver = {
 
 static int __init musb_init(void)
 {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        if (usb_disabled())
                return 0;
-#endif
 
        pr_info("%s: version " MUSB_VERSION ", "
-#ifdef CONFIG_MUSB_PIO_ONLY
-               "pio"
-#elif defined(CONFIG_USB_TI_CPPI_DMA)
-               "cppi-dma"
-#elif defined(CONFIG_USB_INVENTRA_DMA)
-               "musb-dma"
-#elif defined(CONFIG_USB_TUSB_OMAP_DMA)
-               "tusb-omap-dma"
-#elif defined(CONFIG_USB_UX500_DMA)
-               "ux500-dma"
-#else
                "?dma?"
-#endif
                ", "
-#ifdef CONFIG_USB_MUSB_OTG
-               "otg (peripheral+host)"
-#elif defined(CONFIG_USB_GADGET_MUSB_HDRC)
-               "peripheral"
-#elif defined(CONFIG_USB_MUSB_HDRC_HCD)
-               "host"
-#endif
-               ,
+               "otg (peripheral+host)",
                musb_driver_name);
        return platform_driver_probe(&musb_driver, musb_probe);
 }
index 12542a48a64e916e4fbc3e4e29d1542996034951..668eeef601ae94f093fa925706afcbcc2b1f5e37 100644 (file)
@@ -72,10 +72,6 @@ struct musb_ep;
 #include <linux/usb/hcd.h>
 #include "musb_host.h"
 
-
-
-#ifdef CONFIG_USB_MUSB_OTG
-
 #define        is_peripheral_enabled(musb)     ((musb)->board_mode != MUSB_HOST)
 #define        is_host_enabled(musb)           ((musb)->board_mode != MUSB_PERIPHERAL)
 #define        is_otg_enabled(musb)            ((musb)->board_mode == MUSB_OTG)
@@ -86,24 +82,6 @@ struct musb_ep;
 #define is_peripheral_active(m)                (!(m)->is_host)
 #define is_host_active(m)              ((m)->is_host)
 
-#else
-#define        is_peripheral_enabled(musb)     is_peripheral_capable()
-#define        is_host_enabled(musb)           is_host_capable()
-#define        is_otg_enabled(musb)            0
-
-#define        is_peripheral_active(musb)      is_peripheral_capable()
-#define        is_host_active(musb)            is_host_capable()
-#endif
-
-#if defined(CONFIG_USB_MUSB_OTG) || defined(CONFIG_USB_MUSB_PERIPHERAL)
-/* for some reason, the "select USB_GADGET_MUSB_HDRC" doesn't always
- * override that choice selection (often USB_GADGET_DUMMY_HCD).
- */
-#ifndef CONFIG_USB_GADGET_MUSB_HDRC
-#error bogus Kconfig output ... select CONFIG_USB_GADGET_MUSB_HDRC
-#endif
-#endif /* need MUSB gadget selection */
-
 #ifndef CONFIG_HAVE_CLK
 /* Dummy stub for clk framework */
 #define clk_get(dev, id)       NULL
@@ -119,8 +97,6 @@ struct musb_ep;
 
 /****************************** PERIPHERAL ROLE *****************************/
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-
 #define        is_peripheral_capable() (1)
 
 extern irqreturn_t musb_g_ep0_irq(struct musb *);
@@ -132,40 +108,14 @@ extern void musb_g_resume(struct musb *);
 extern void musb_g_wakeup(struct musb *);
 extern void musb_g_disconnect(struct musb *);
 
-#else
-
-#define        is_peripheral_capable() (0)
-
-static inline irqreturn_t musb_g_ep0_irq(struct musb *m) { return IRQ_NONE; }
-static inline void musb_g_reset(struct musb *m) {}
-static inline void musb_g_suspend(struct musb *m) {}
-static inline void musb_g_resume(struct musb *m) {}
-static inline void musb_g_wakeup(struct musb *m) {}
-static inline void musb_g_disconnect(struct musb *m) {}
-
-#endif
-
 /****************************** HOST ROLE ***********************************/
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
-
 #define        is_host_capable()       (1)
 
 extern irqreturn_t musb_h_ep0_irq(struct musb *);
 extern void musb_host_tx(struct musb *, u8);
 extern void musb_host_rx(struct musb *, u8);
 
-#else
-
-#define        is_host_capable()       (0)
-
-static inline irqreturn_t musb_h_ep0_irq(struct musb *m) { return IRQ_NONE; }
-static inline void musb_host_tx(struct musb *m, u8 e) {}
-static inline void musb_host_rx(struct musb *m, u8 e) {}
-
-#endif
-
-
 /****************************** CONSTANTS ********************************/
 
 #ifndef MUSB_C_NUM_EPS
@@ -315,7 +265,6 @@ struct musb_hw_ep {
        void __iomem            *fifo_sync_va;
 #endif
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        void __iomem            *target_regs;
 
        /* currently scheduled peripheral endpoint */
@@ -324,31 +273,20 @@ struct musb_hw_ep {
 
        u8                      rx_reinit;
        u8                      tx_reinit;
-#endif
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
        /* peripheral side */
        struct musb_ep          ep_in;                  /* TX */
        struct musb_ep          ep_out;                 /* RX */
-#endif
 };
 
 static inline struct musb_request *next_in_request(struct musb_hw_ep *hw_ep)
 {
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
        return next_request(&hw_ep->ep_in);
-#else
-       return NULL;
-#endif
 }
 
 static inline struct musb_request *next_out_request(struct musb_hw_ep *hw_ep)
 {
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
        return next_request(&hw_ep->ep_out);
-#else
-       return NULL;
-#endif
 }
 
 struct musb_csr_regs {
@@ -393,7 +331,6 @@ struct musb {
 
        u32                     port1_status;
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        unsigned long           rh_timer;
 
        enum musb_h_ep0_state   ep0_stage;
@@ -411,7 +348,6 @@ struct musb {
        struct list_head        out_bulk;       /* of musb_qh */
 
        struct timer_list       otg_timer;
-#endif
        struct notifier_block   nb;
 
        struct dma_controller   *dma_controller;
@@ -472,7 +408,6 @@ struct musb {
 #define        can_bulk_combine(musb,type) \
        (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_combine)
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
        /* is_suspended means USB B_PERIPHERAL suspend */
        unsigned                is_suspended:1;
 
@@ -496,7 +431,6 @@ struct musb {
        enum musb_g_ep0_state   ep0_state;
        struct usb_gadget       g;                      /* the gadget */
        struct usb_gadget_driver *gadget_driver;        /* its driver */
-#endif
 
        /*
         * FIXME: Remove this flag.
@@ -518,12 +452,10 @@ struct musb {
 #endif
 };
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
 static inline struct musb *gadget_to_musb(struct usb_gadget *g)
 {
        return container_of(g, struct musb, g);
 }
-#endif
 
 #ifdef CONFIG_BLACKFIN
 static inline int musb_read_fifosize(struct musb *musb,
index 728572cf709cf6ae3b24ca96dbe65dd8d50f4acd..37e70d390de8ad4d1218d548da1f169875fd4974 100644 (file)
@@ -2048,9 +2048,7 @@ static int musb_gadget_stop(struct usb_gadget_driver *driver)
 
        spin_lock_irqsave(&musb->lock, flags);
 
-#ifdef CONFIG_USB_MUSB_OTG
        musb_hnp_stop(musb);
-#endif
 
        (void) musb_gadget_vbus_draw(&musb->g, 0);
 
@@ -2171,7 +2169,6 @@ void musb_g_disconnect(struct musb *musb)
 
        switch (musb->xceiv->state) {
        default:
-#ifdef CONFIG_USB_MUSB_OTG
                dev_dbg(musb->controller, "Unhandled disconnect %s, setting a_idle\n",
                        otg_state_string(musb->xceiv->state));
                musb->xceiv->state = OTG_STATE_A_IDLE;
@@ -2183,7 +2180,6 @@ void musb_g_disconnect(struct musb *musb)
                break;
        case OTG_STATE_B_WAIT_ACON:
        case OTG_STATE_B_HOST:
-#endif
        case OTG_STATE_B_PERIPHERAL:
        case OTG_STATE_B_IDLE:
                musb->xceiv->state = OTG_STATE_B_IDLE;
index b2faff2355070bf0c4bf3473f05d33969a1676bb..9378b359c1f012d6abcacd358b7366bcafb32912 100644 (file)
@@ -88,7 +88,6 @@ static int service_tx_status_request(
        case USB_RECIP_DEVICE:
                result[0] = musb->is_self_powered << USB_DEVICE_SELF_POWERED;
                result[0] |= musb->may_wakeup << USB_DEVICE_REMOTE_WAKEUP;
-#ifdef CONFIG_USB_MUSB_OTG
                if (musb->g.is_otg) {
                        result[0] |= musb->g.b_hnp_enable
                                << USB_DEVICE_B_HNP_ENABLE;
@@ -97,7 +96,6 @@ static int service_tx_status_request(
                        result[0] |= musb->g.a_hnp_support
                                << USB_DEVICE_A_HNP_SUPPORT;
                }
-#endif
                break;
 
        case USB_RECIP_INTERFACE:
@@ -392,7 +390,6 @@ __acquires(musb->lock)
                                        if (handled > 0)
                                                musb->test_mode = true;
                                        break;
-#ifdef CONFIG_USB_MUSB_OTG
                                case USB_DEVICE_B_HNP_ENABLE:
                                        if (!musb->g.is_otg)
                                                goto stall;
@@ -409,7 +406,6 @@ __acquires(musb->lock)
                                                goto stall;
                                        musb->g.a_alt_hnp_support = 1;
                                        break;
-#endif
                                case USB_DEVICE_DEBUG_MODE:
                                        handled = 0;
                                        break;
index 14b00776638dab987c233d72b9b66da462214e90..622d09fb9abadbdd8fb8d43baa425e034499641d 100644 (file)
@@ -95,7 +95,6 @@ extern const struct hc_driver musb_hc_driver;
 
 static inline struct urb *next_urb(struct musb_qh *qh)
 {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        struct list_head        *queue;
 
        if (!qh)
@@ -104,9 +103,6 @@ static inline struct urb *next_urb(struct musb_qh *qh)
        if (list_empty(queue))
                return NULL;
        return list_entry(queue->next, struct urb, urb_list);
-#else
-       return NULL;
-#endif
 }
 
 #endif                         /* _MUSB_HOST_H */
index 2d80a575883881c742dee131bf6b4d3fb8e12c96..e9f80adc45a48686b87b1269a3a27129f0d9c822 100644 (file)
@@ -88,14 +88,12 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
                                                OTG_TIME_A_AIDL_BDIS));
                        musb_platform_try_idle(musb, 0);
                        break;
-#ifdef CONFIG_USB_MUSB_OTG
                case OTG_STATE_B_HOST:
                        musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
                        musb->is_active = is_otg_enabled(musb)
                                        && musb->xceiv->host->b_hnp_enable;
                        musb_platform_try_idle(musb, 0);
                        break;
-#endif
                default:
                        dev_dbg(musb->controller, "bogus rh suspend? %s\n",
                                otg_state_string(musb->xceiv->state));
@@ -118,13 +116,11 @@ static void musb_port_reset(struct musb *musb, bool do_reset)
        u8              power;
        void __iomem    *mbase = musb->mregs;
 
-#ifdef CONFIG_USB_MUSB_OTG
        if (musb->xceiv->state == OTG_STATE_B_IDLE) {
                dev_dbg(musb->controller, "HNP: Returning from HNP; no hub reset from b_idle\n");
                musb->port1_status &= ~USB_PORT_STAT_RESET;
                return;
        }
-#endif
 
        if (!is_host_active(musb))
                return;
@@ -191,14 +187,12 @@ void musb_root_disconnect(struct musb *musb)
 
        switch (musb->xceiv->state) {
        case OTG_STATE_A_SUSPEND:
-#ifdef CONFIG_USB_MUSB_OTG
                if (is_otg_enabled(musb)
                                && musb->xceiv->host->b_hnp_enable) {
                        musb->xceiv->state = OTG_STATE_A_PERIPHERAL;
                        musb->g.is_a_peripheral = 1;
                        break;
                }
-#endif
                /* FALLTHROUGH */
        case OTG_STATE_A_HOST:
                musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
index c5d4c44d0ffa334246e801c131862bf318ba29cc..ba85f273e4874f3db7e69d390a590b833c894a31 100644 (file)
@@ -51,9 +51,7 @@ static void musb_do_idle(unsigned long _musb)
 {
        struct musb     *musb = (void *)_musb;
        unsigned long   flags;
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        u8      power;
-#endif
        u8      devctl;
 
        spin_lock_irqsave(&musb->lock, flags);
@@ -70,7 +68,6 @@ static void musb_do_idle(unsigned long _musb)
                        MUSB_HST_MODE(musb);
                }
                break;
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        case OTG_STATE_A_SUSPEND:
                /* finish RESUME signaling? */
                if (musb->port1_status & MUSB_PORT_STAT_RESUME) {
@@ -87,15 +84,12 @@ static void musb_do_idle(unsigned long _musb)
                        musb->xceiv->state = OTG_STATE_A_HOST;
                }
                break;
-#endif
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        case OTG_STATE_A_HOST:
                devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
                if (devctl &  MUSB_DEVCTL_BDEVICE)
                        musb->xceiv->state = OTG_STATE_B_IDLE;
                else
                        musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
-#endif
        default:
                break;
        }
@@ -243,13 +237,11 @@ static int musb_otg_notifications(struct notifier_block *nb,
                dev_dbg(musb->controller, "ID GND\n");
 
                if (is_otg_enabled(musb)) {
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
                        if (musb->gadget_driver) {
                                pm_runtime_get_sync(musb->controller);
                                otg_init(musb->xceiv);
                                omap2430_musb_set_vbus(musb, 1);
                        }
-#endif
                } else {
                        pm_runtime_get_sync(musb->controller);
                        otg_init(musb->xceiv);
@@ -260,21 +252,16 @@ static int musb_otg_notifications(struct notifier_block *nb,
        case USB_EVENT_VBUS:
                dev_dbg(musb->controller, "VBUS Connect\n");
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
                if (musb->gadget_driver)
                        pm_runtime_get_sync(musb->controller);
-#endif
                otg_init(musb->xceiv);
                break;
 
        case USB_EVENT_NONE:
                dev_dbg(musb->controller, "VBUS Disconnect\n");
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
                if (is_otg_enabled(musb) || is_peripheral_enabled(musb))
-                       if (musb->gadget_driver)
-#endif
-                       {
+                       if (musb->gadget_driver) {
                                pm_runtime_mark_last_busy(musb->controller);
                                pm_runtime_put_autosuspend(musb->controller);
                        }
index b410357cf0165b0f4e835caaa50add9724065d95..9eec41fbf3a433e0ac250035a997df4440bef1ef 100644 (file)
@@ -269,8 +269,6 @@ void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *buf)
 
 static struct musb *the_musb;
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-
 /* This is used by gadget drivers, and OTG transceiver logic, allowing
  * at most mA current to be drawn from VBUS during a Default-B session
  * (that is, while VBUS exceeds 4.4V).  In Default-A (including pure host
@@ -310,10 +308,6 @@ static int tusb_draw_power(struct otg_transceiver *x, unsigned mA)
        return 0;
 }
 
-#else
-#define tusb_draw_power        NULL
-#endif
-
 /* workaround for issue 13:  change clock during chip idle
  * (to be fixed in rev3 silicon) ... symptoms include disconnect
  * or looping suspend/resume cycles
@@ -440,19 +434,15 @@ static void musb_do_idle(unsigned long _musb)
                if (is_host_active(musb) && (musb->port1_status >> 16))
                        goto done;
 
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-               if (is_peripheral_enabled(musb) && !musb->gadget_driver)
+               if (is_peripheral_enabled(musb) && !musb->gadget_driver) {
                        wakeups = 0;
-               else {
+               else {
                        wakeups = TUSB_PRCM_WHOSTDISCON
-                                       | TUSB_PRCM_WBUS
+                               | TUSB_PRCM_WBUS
                                        | TUSB_PRCM_WVBUS;
                        if (is_otg_enabled(musb))
                                wakeups |= TUSB_PRCM_WID;
                }
-#else
-               wakeups = TUSB_PRCM_WHOSTDISCON | TUSB_PRCM_WBUS;
-#endif
                tusb_allow_idle(musb, wakeups);
        }
 done:
@@ -610,30 +600,22 @@ static int tusb_musb_set_mode(struct musb *musb, u8 musb_mode)
 
        switch (musb_mode) {
 
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
        case MUSB_HOST:         /* Disable PHY ID detect, ground ID */
                phy_otg_ctrl &= ~TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                phy_otg_ena |= TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                dev_conf |= TUSB_DEV_CONF_ID_SEL;
                dev_conf &= ~TUSB_DEV_CONF_SOFT_ID;
                break;
-#endif
-
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
        case MUSB_PERIPHERAL:   /* Disable PHY ID detect, keep ID pull-up on */
                phy_otg_ctrl |= TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                phy_otg_ena |= TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                dev_conf |= (TUSB_DEV_CONF_ID_SEL | TUSB_DEV_CONF_SOFT_ID);
                break;
-#endif
-
-#ifdef CONFIG_USB_MUSB_OTG
        case MUSB_OTG:          /* Use PHY ID detection */
                phy_otg_ctrl |= TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                phy_otg_ena |= TUSB_PHY_OTG_CTRL_OTG_ID_PULLUP;
                dev_conf &= ~(TUSB_DEV_CONF_ID_SEL | TUSB_DEV_CONF_SOFT_ID);
                break;
-#endif
 
        default:
                dev_dbg(musb->controller, "Trying to set mode %i\n", musb_mode);
@@ -684,7 +666,6 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                /* B-dev state machine:  no vbus ~= disconnect */
                if ((is_otg_enabled(musb) && !musb->xceiv->default_a)
                                || !is_host_enabled(musb)) {
-#ifdef CONFIG_USB_MUSB_HDRC_HCD
                        /* ? musb_root_disconnect(musb); */
                        musb->port1_status &=
                                ~(USB_PORT_STAT_CONNECTION
@@ -693,7 +674,6 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                                | USB_PORT_STAT_HIGH_SPEED
                                | USB_PORT_STAT_TEST
                                );
-#endif
 
                        if (otg_stat & TUSB_DEV_OTG_STAT_SESS_END) {
                                dev_dbg(musb->controller, "Forcing disconnect (no interrupt)\n");