vcs.maemo.org Git - h-e-n/blob - drivers/usb/musb/musb_core.h

   1 /*
   2  * MUSB OTG driver defines
   3  *
   4  * Copyright 2005 Mentor Graphics Corporation
   5  * Copyright (C) 2005-2006 by Texas Instruments
   6  * Copyright (C) 2006-2007 Nokia Corporation
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  *
  22  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
  23  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  24  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  25  * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  28  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  29  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  */
  34
  35 #ifndef __MUSB_CORE_H__
  36 #define __MUSB_CORE_H__
  37
  38 #include <linux/slab.h>
  39 #include <linux/list.h>
  40 #include <linux/interrupt.h>
  41 #include <linux/smp_lock.h>
  42 #include <linux/errno.h>
  43 #include <linux/clk.h>
  44 #include <linux/device.h>
  45 #include <linux/usb/ch9.h>
  46 #include <linux/usb/gadget.h>
  47 #include <linux/usb.h>
  48 #include <linux/usb/otg.h>
  49 #include <linux/usb/musb.h>
  50
  51 struct musb;
  52 struct musb_hw_ep;
  53 struct musb_ep;
  54
  55
  56 #include "musb_debug.h"
  57 #include "musb_dma.h"
  58
  59 #include "musb_io.h"
  60 #include "musb_regs.h"
  61
  62 #include "musb_gadget.h"
  63 #include "../core/hcd.h"
  64 #include "musb_host.h"
  65
  66 /* This is the version of forced hostmode userspace<->kernelspace API.
  67  * Do not update to the build date, bump only on API changes */
  68 #define MUSB_VERSION_HOSTMODE   "20101110"
  69
  70 #ifdef CONFIG_USB_MUSB_OTG
  71
  72 #define is_peripheral_enabled(musb)     ((musb)->board_mode != MUSB_HOST)
  73 #define is_host_enabled(musb)           ((musb)->board_mode != MUSB_PERIPHERAL)
  74 #define is_otg_enabled(musb)            ((musb)->board_mode == MUSB_OTG)
  75
  76 /* NOTE:  otg and peripheral-only state machines start at B_IDLE.
  77  * OTG or host-only go to A_IDLE when ID is sensed.
  78  */
  79 #define is_peripheral_active(m)         (!(m)->is_host)
  80 #define is_host_active(m)               ((m)->is_host)
  81
  82 #else
  83 #define is_peripheral_enabled(musb)     is_peripheral_capable()
  84 #define is_host_enabled(musb)           is_host_capable()
  85 #define is_otg_enabled(musb)            0
  86
  87 #define is_peripheral_active(musb)      is_peripheral_capable()
  88 #define is_host_active(musb)            is_host_capable()
  89 #endif
  90
  91 #if defined(CONFIG_USB_MUSB_OTG) || defined(CONFIG_USB_MUSB_PERIPHERAL)
  92 /* for some reason, the "select USB_GADGET_MUSB_HDRC" doesn't always
  93  * override that choice selection (often USB_GADGET_DUMMY_HCD).
  94  */
  95 #ifndef CONFIG_USB_GADGET_MUSB_HDRC
  96 #error bogus Kconfig output ... select CONFIG_USB_GADGET_MUSB_HDRC
  97 #endif
  98 #endif  /* need MUSB gadget selection */
  99
 100
 101 #ifdef CONFIG_PROC_FS
 102 #include <linux/fs.h>
 103 #define MUSB_CONFIG_PROC_FS
 104 #endif
 105
 106 /****************************** PERIPHERAL ROLE *****************************/
 107
 108 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
 109
 110 #define is_peripheral_capable() (1)
 111
 112 extern irqreturn_t musb_g_ep0_irq(struct musb *);
 113 extern void musb_g_tx(struct musb *, u8);
 114 extern void musb_g_rx(struct musb *, u8, bool);
 115 extern void musb_g_reset(struct musb *);
 116 extern void musb_g_suspend(struct musb *);
 117 extern void musb_g_resume(struct musb *);
 118 extern void musb_g_wakeup(struct musb *);
 119 extern void musb_g_disconnect(struct musb *);
 120
 121 #else
 122
 123 #define is_peripheral_capable() (0)
 124
 125 static inline irqreturn_t musb_g_ep0_irq(struct musb *m) { return IRQ_NONE; }
 126 static inline void musb_g_reset(struct musb *m) {}
 127 static inline void musb_g_suspend(struct musb *m) {}
 128 static inline void musb_g_resume(struct musb *m) {}
 129 static inline void musb_g_wakeup(struct musb *m) {}
 130 static inline void musb_g_disconnect(struct musb *m) {}
 131
 132 #endif
 133
 134 /****************************** HOST ROLE ***********************************/
 135
 136 #ifdef CONFIG_USB_MUSB_HDRC_HCD
 137
 138 #define is_host_capable()       (1)
 139
 140 extern irqreturn_t musb_h_ep0_irq(struct musb *);
 141 extern void musb_host_tx(struct musb *, u8);
 142 extern void musb_host_rx(struct musb *, u8);
 143
 144 #else
 145
 146 #define is_host_capable()       (0)
 147
 148 static inline irqreturn_t musb_h_ep0_irq(struct musb *m) { return IRQ_NONE; }
 149 static inline void musb_host_tx(struct musb *m, u8 e) {}
 150 static inline void musb_host_rx(struct musb *m, u8 e) {}
 151
 152 #endif
 153
 154
 155 /****************************** CONSTANTS ********************************/
 156
 157 #ifndef MUSB_C_NUM_EPS
 158 #define MUSB_C_NUM_EPS ((u8)16)
 159 #endif
 160
 161 #ifndef MUSB_MAX_END0_PACKET
 162 #define MUSB_MAX_END0_PACKET ((u16)MUSB_EP0_FIFOSIZE)
 163 #endif
 164
 165 /* host side ep0 states */
 166 enum musb_h_ep0_state {
 167         MUSB_EP0_IDLE,
 168         MUSB_EP0_START,                 /* expect ack of setup */
 169         MUSB_EP0_IN,                    /* expect IN DATA */
 170         MUSB_EP0_OUT,                   /* expect ack of OUT DATA */
 171         MUSB_EP0_STATUS,                /* expect ack of STATUS */
 172 } __attribute__ ((packed));
 173
 174 /* peripheral side ep0 states */
 175 enum musb_g_ep0_state {
 176         MUSB_EP0_STAGE_SETUP,           /* idle, waiting for setup */
 177         MUSB_EP0_STAGE_TX,              /* IN data */
 178         MUSB_EP0_STAGE_RX,              /* OUT data */
 179         MUSB_EP0_STAGE_STATUSIN,        /* (after OUT data) */
 180         MUSB_EP0_STAGE_STATUSOUT,       /* (after IN data) */
 181         MUSB_EP0_STAGE_ACKWAIT,         /* after zlp, before statusin */
 182 } __attribute__ ((packed));
 183
 184 /* OTG protocol constants */
 185 #define OTG_TIME_A_WAIT_VRISE   100             /* msec (max) */
 186 #define OTG_TIME_A_WAIT_BCON    0               /* 0=infinite; min 1000 msec */
 187 #define OTG_TIME_A_IDLE_BDIS    200             /* msec (min) */
 188
 189 /*************************** REGISTER ACCESS ********************************/
 190
 191 /* Endpoint registers (other than dynfifo setup) can be accessed either
 192  * directly with the "flat" model, or after setting up an index register.
 193  */
 194
 195 #if defined(CONFIG_ARCH_DAVINCI) || defined(CONFIG_ARCH_OMAP2430) \
 196                 || defined(CONFIG_ARCH_OMAP3430) || defined(CONFIG_BLACKFIN)
 197 /* REVISIT indexed access seemed to
 198  * misbehave (on DaVinci) for at least peripheral IN ...
 199  */
 200 #define MUSB_FLAT_REG
 201 #endif
 202
 203 /* TUSB mapping: "flat" plus ep0 special cases */
 204 #if     defined(CONFIG_USB_TUSB6010)
 205 #define musb_ep_select(_mbase, _epnum) \
 206         musb_writeb((_mbase), MUSB_INDEX, (_epnum))
 207 #define MUSB_EP_OFFSET                  MUSB_TUSB_OFFSET
 208
 209 /* "flat" mapping: each endpoint has its own i/o address */
 210 #elif   defined(MUSB_FLAT_REG)
 211 #define musb_ep_select(_mbase, _epnum)  (((void)(_mbase)), ((void)(_epnum)))
 212 #define MUSB_EP_OFFSET                  MUSB_FLAT_OFFSET
 213
 214 /* "indexed" mapping: INDEX register controls register bank select */
 215 #else
 216 #define musb_ep_select(_mbase, _epnum) \
 217         musb_writeb((_mbase), MUSB_INDEX, (_epnum))
 218 #define MUSB_EP_OFFSET                  MUSB_INDEXED_OFFSET
 219 #endif
 220
 221 /****************************** FUNCTIONS ********************************/
 222
 223 #define MUSB_HST_MODE(_musb)\
 224         { (_musb)->is_host = true; }
 225 #define MUSB_DEV_MODE(_musb) \
 226         { (_musb)->is_host = false; }
 227
 228 #define test_devctl_hst_mode(_x) \
 229         (musb_readb((_x)->mregs, MUSB_DEVCTL)&MUSB_DEVCTL_HM)
 230
 231 #define MUSB_MODE(musb) ((musb)->is_host ? "Host" : "Peripheral")
 232
 233 /******************************** TYPES *************************************/
 234
 235 /*
 236  * struct musb_hw_ep - endpoint hardware (bidirectional)
 237  *
 238  * Ordered slightly for better cacheline locality.
 239  */
 240 struct musb_hw_ep {
 241         struct musb             *musb;
 242         void __iomem            *fifo;
 243         void __iomem            *regs;
 244
 245 #ifdef CONFIG_USB_TUSB6010
 246         void __iomem            *conf;
 247 #endif
 248
 249         /* index in musb->endpoints[]  */
 250         u8                      epnum;
 251
 252         /* hardware configuration, possibly dynamic */
 253         bool                    is_shared_fifo;
 254         bool                    tx_double_buffered;
 255         bool                    rx_double_buffered;
 256         u16                     max_packet_sz_tx;
 257         u16                     max_packet_sz_rx;
 258
 259         struct dma_channel      *tx_channel;
 260         struct dma_channel      *rx_channel;
 261
 262 #ifdef CONFIG_USB_TUSB6010
 263         /* TUSB has "asynchronous" and "synchronous" dma modes */
 264         dma_addr_t              fifo_async;
 265         dma_addr_t              fifo_sync;
 266         void __iomem            *fifo_sync_va;
 267 #endif
 268
 269 #ifdef CONFIG_USB_MUSB_HDRC_HCD
 270         void __iomem            *target_regs;
 271
 272         /* currently scheduled peripheral endpoint */
 273         struct musb_qh          *in_qh;
 274         struct musb_qh          *out_qh;
 275
 276         /* list of rx and tx qhs, control transfer needs only
 277          * one list thus only in_list is used for control.
 278          */
 279         struct list_head        in_list;
 280         struct list_head        out_list;
 281
 282         u8                      rx_reinit;
 283         u8                      tx_reinit;
 284 #endif
 285
 286 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
 287         /* peripheral side */
 288         struct musb_ep          ep_in;                  /* TX */
 289         struct musb_ep          ep_out;                 /* RX */
 290 #endif
 291 };
 292
 293 static inline struct usb_request *next_in_request(struct musb_hw_ep *hw_ep)
 294 {
 295 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
 296         return next_request(&hw_ep->ep_in);
 297 #else
 298         return NULL;
 299 #endif
 300 }
 301
 302 static inline struct usb_request *next_out_request(struct musb_hw_ep *hw_ep)
 303 {
 304 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
 305         return next_request(&hw_ep->ep_out);
 306 #else
 307         return NULL;
 308 #endif
 309 }
 310
 311 #define MUSB_MAX_EPS    16
 312
 313 struct musb_ctx {
 314         /* common register */
 315         u16     intrtxe;
 316         u16     intrrxe;
 317
 318         u8      intrusbe;
 319
 320         u8      faddr;
 321         u8      power;
 322
 323         u8      frame;
 324         u8      index;
 325         u8      testmode;
 326         u8      devctl;
 327         u8      misc;
 328
 329         /* indexed registers */
 330         u16     txmaxp[MUSB_MAX_EPS];
 331         u16     txcsr[MUSB_MAX_EPS];
 332
 333         u16     rxmaxp[MUSB_MAX_EPS];
 334         u16     rxcsr[MUSB_MAX_EPS];
 335
 336         u16     csr0;           /* select ep0 to read/write this register */
 337
 338         u8      txtype[MUSB_MAX_EPS];
 339         u8      txinterval[MUSB_MAX_EPS];
 340
 341         u8      rxtype[MUSB_MAX_EPS];
 342         u8      rxinterval[MUSB_MAX_EPS];
 343
 344         u8      fifosize[MUSB_MAX_EPS];
 345
 346         u8      rxfifosz[MUSB_MAX_EPS];
 347         u8      txfifosz[MUSB_MAX_EPS];
 348         u16     txfifoadd[MUSB_MAX_EPS];
 349         u16     rxfifoadd[MUSB_MAX_EPS];
 350
 351         u8      count0;
 352         u8      type0;
 353         u8      naklimit0;
 354 };
 355
 356 /*
 357  * struct musb - Driver instance data.
 358  */
 359 struct musb {
 360         /* device lock */
 361         spinlock_t              lock;
 362         struct mutex            mutex;
 363         struct clk              *clock;
 364         irqreturn_t             (*isr)(int, void *);
 365         struct work_struct      irq_work;
 366         struct work_struct      vbus_work;
 367
 368 /* this hub status bit is reserved by USB 2.0 and not seen by usbcore */
 369 #define MUSB_PORT_STAT_RESUME   (1 << 31)
 370
 371         u32                     port1_status;
 372
 373 #ifdef CONFIG_USB_MUSB_HDRC_HCD
 374         unsigned long           rh_timer;
 375
 376         enum musb_h_ep0_state   ep0_stage;
 377
 378         /* bulk traffic normally dedicates endpoint hardware, and each
 379          * direction has its own ring of host side endpoints.
 380          * we try to progress the transfer at the head of each endpoint's
 381          * queue until it completes or NAKs too much; then we try the next
 382          * endpoint.
 383          */
 384         struct musb_hw_ep       *bulk_ep;
 385
 386         struct musb_qh          *periodic[32];  /* tree of interrupt+iso */
 387 #endif
 388
 389         /* called with IRQs blocked; ON/nonzero implies starting a session,
 390          * and waiting at least a_wait_vrise_tmout.
 391          */
 392         void                    (*board_set_vbus)(struct musb *, int is_on);
 393
 394         struct dma_controller   *dma_controller;
 395
 396         struct device           *controller;
 397         void __iomem            *ctrl_base;
 398         void __iomem            *mregs;
 399
 400 #ifdef CONFIG_USB_TUSB6010
 401         dma_addr_t              async;
 402         dma_addr_t              sync;
 403         void __iomem            *sync_va;
 404 #endif
 405
 406         /* passed down from chip/board specific irq handlers */
 407         u8                      int_usb;
 408         u16                     int_rx;
 409         u16                     int_tx;
 410
 411         struct otg_transceiver  *xceiv;
 412
 413         int nIrq;
 414         unsigned                irq_wake:1;
 415
 416         struct musb_hw_ep        endpoints[MUSB_C_NUM_EPS];
 417 #define control_ep              endpoints
 418
 419 #define VBUSERR_RETRY_COUNT     3
 420         u16                     vbuserr_retry;
 421         u16 epmask;
 422         u8 nr_endpoints;
 423
 424         struct musb_board_data  *board;
 425         u8 board_mode;          /* enum musb_mode */
 426         int                     (*board_set_power)(int state);
 427
 428         int                     (*set_clock)(struct clk *clk, int is_active);
 429
 430         u8                      min_power;      /* vbus for periph, in mA/2 */
 431
 432         unsigned                power_draw;     /* current power draw, gadget only */
 433
 434         bool                    is_host;
 435
 436         int                     a_wait_bcon;    /* VBUS timeout in msecs */
 437         unsigned long           idle_timeout;   /* Next timeout in jiffies */
 438
 439         /* active means connected and not suspended */
 440         unsigned                is_active:1;
 441
 442         unsigned is_multipoint:1;
 443         unsigned ignore_disconnect:1;   /* during bus resets */
 444
 445 #ifdef C_MP_TX
 446         unsigned bulk_split:1;
 447 #define can_bulk_split(musb,type) \
 448                 (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_split)
 449 #else
 450 #define can_bulk_split(musb, type)      0
 451 #endif
 452
 453 #ifdef C_MP_RX
 454         unsigned bulk_combine:1;
 455 #define can_bulk_combine(musb,type) \
 456                 (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_combine)
 457 #else
 458 #define can_bulk_combine(musb, type)    0
 459 #endif
 460
 461 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
 462         /* is_suspended means USB B_PERIPHERAL suspend */
 463         unsigned                is_suspended:1;
 464
 465         /* may_wakeup means remote wakeup is enabled */
 466         unsigned                may_wakeup:1;
 467
 468         /* is_self_powered is reported in device status and the
 469          * config descriptor.  is_bus_powered means B_PERIPHERAL
 470          * draws some VBUS current; both can be true.
 471          */
 472         unsigned                is_self_powered:1;
 473         unsigned                is_bus_powered:1;
 474
 475         unsigned                set_address:1;
 476         unsigned                test_mode:1;
 477         unsigned                softconnect:1;
 478
 479         u8                      address;
 480         u8                      test_mode_nr;
 481         u16                     ackpend;                /* ep0 */
 482         enum musb_g_ep0_state   ep0_state;
 483         struct usb_gadget       g;                      /* the gadget */
 484         struct usb_gadget_driver *gadget_driver;        /* its driver */
 485 #endif
 486
 487         /* true if this chip can enable SUSPENDM */
 488         unsigned                suspendm:1;
 489
 490         /* true if we're using dma */
 491         unsigned                use_dma:1;
 492
 493         struct musb_hdrc_config *config;
 494
 495 #ifdef MUSB_CONFIG_PROC_FS
 496         struct proc_dir_entry *proc_entry;
 497 #endif
 498         unsigned                is_charger:1;
 499 };
 500
 501 static inline void musb_set_vbus(struct musb *musb, int is_on)
 502 {
 503         musb->board_set_vbus(musb, is_on);
 504 }
 505
 506 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
 507 static inline struct musb *gadget_to_musb(struct usb_gadget *g)
 508 {
 509         return container_of(g, struct musb, g);
 510 }
 511 #endif
 512
 513 #ifdef CONFIG_BLACKFIN
 514 static inline int musb_read_fifosize(struct musb *musb,
 515                 struct musb_hw_ep *hw_ep, u8 epnum)
 516 {
 517         musb->nr_endpoints++;
 518         musb->epmask |= (1 << epnum);
 519
 520         if (epnum < 5) {
 521                 hw_ep->max_packet_sz_tx = 128;
 522                 hw_ep->max_packet_sz_rx = 128;
 523         } else {
 524                 hw_ep->max_packet_sz_tx = 1024;
 525                 hw_ep->max_packet_sz_rx = 1024;
 526         }
 527         hw_ep->is_shared_fifo = false;
 528
 529         return 0;
 530 }
 531
 532 static inline void musb_configure_ep0(struct musb *musb)
 533 {
 534         musb->endpoints[0].max_packet_sz_tx = MUSB_EP0_FIFOSIZE;
 535         musb->endpoints[0].max_packet_sz_rx = MUSB_EP0_FIFOSIZE;
 536         musb->endpoints[0].is_shared_fifo = true;
 537 }
 538
 539 #else
 540
 541 static inline int musb_read_fifosize(struct musb *musb,
 542                 struct musb_hw_ep *hw_ep, u8 epnum)
 543 {
 544         u8 reg = 0;
 545
 546         /* read from core using indexed model */
 547         reg = musb_readb(hw_ep->regs, 0x10 + MUSB_FIFOSIZE);
 548         /* 0's returned when no more endpoints */
 549         if (!reg)
 550                 return -ENODEV;
 551
 552         musb->nr_endpoints++;
 553         musb->epmask |= (1 << epnum);
 554
 555         hw_ep->max_packet_sz_tx = 1 << (reg & 0x0f);
 556
 557         /* shared TX/RX FIFO? */
 558         if ((reg & 0xf0) == 0xf0) {
 559                 hw_ep->max_packet_sz_rx = hw_ep->max_packet_sz_tx;
 560                 hw_ep->is_shared_fifo = true;
 561                 return 0;
 562         } else {
 563                 hw_ep->max_packet_sz_rx = 1 << ((reg & 0xf0) >> 4);
 564                 hw_ep->is_shared_fifo = false;
 565         }
 566
 567         return 0;
 568 }
 569
 570 static inline void musb_configure_ep0(struct musb *musb)
 571 {
 572         musb->endpoints[0].max_packet_sz_tx = MUSB_EP0_FIFOSIZE;
 573         musb->endpoints[0].max_packet_sz_rx = MUSB_EP0_FIFOSIZE;
 574 }
 575 #endif /* CONFIG_BLACKFIN */
 576
 577
 578 /***************************** Glue it together *****************************/
 579
 580 extern const char musb_driver_name[];
 581
 582 extern void musb_start(struct musb *musb);
 583 extern void musb_stop(struct musb *musb);
 584
 585 extern void musb_write_fifo(struct musb_hw_ep *ep, u16 len, const u8 *src);
 586 extern void musb_read_fifo(struct musb_hw_ep *ep, u16 len, u8 *dst);
 587
 588 extern void musb_load_testpacket(struct musb *);
 589
 590 extern irqreturn_t musb_interrupt(struct musb *);
 591
 592 extern void musb_platform_enable(struct musb *musb);
 593 extern void musb_platform_disable(struct musb *musb);
 594
 595 extern void musb_hnp_stop(struct musb *musb);
 596
 597 extern int musb_platform_set_mode(struct musb *musb, u8 musb_mode, u8 hostspeed);
 598
 599 #if defined(CONFIG_USB_TUSB6010) || defined(CONFIG_BLACKFIN) || \
 600         defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP34XX)
 601 extern void musb_platform_try_idle(struct musb *musb, unsigned long timeout);
 602 #else
 603 #define musb_platform_try_idle(x, y)            do {} while (0)
 604 #endif
 605
 606 #if defined(CONFIG_USB_TUSB6010) || defined(CONFIG_BLACKFIN)
 607 extern int musb_platform_get_vbus_status(struct musb *musb);
 608 #else
 609 #define musb_platform_get_vbus_status(x)        0
 610 #endif
 611
 612 #ifdef CONFIG_PM
 613 extern void musb_save_ctx(struct musb *musb);
 614 extern void musb_restore_ctx(struct musb *musb);
 615 extern void musb_save_ctx_and_suspend(struct usb_gadget *, int);
 616 extern void musb_restore_ctx_and_resume(struct usb_gadget *);
 617 #else
 618 static inline void musb_save_ctx(struct musb *musb) {}
 619 static inline void musb_restore_ctx(struct musb *musb) {}
 620 static inline void musb_save_ctx_and_suspend(struct usb_gadget *, int) {}
 621 static inline void musb_restore_ctx_and_resume(struct usb_gadget *) {}
 622 #endif
 623
 624 extern int __init musb_platform_init(struct musb *musb);
 625 extern int musb_platform_exit(struct musb *musb);
 626
 627 /*-------------------------- ProcFS definitions ---------------------*/
 628
 629 struct proc_dir_entry;
 630
 631 #ifdef CONFIG_MUSB_PROC_FS
 632 extern struct proc_dir_entry *musb_debug_create(char *name, struct musb *data);
 633 extern void musb_debug_delete(char *name, struct musb *data);
 634 #else
 635 static inline struct proc_dir_entry *
 636 musb_debug_create(char *name, struct musb *data)
 637 {
 638         return NULL;
 639 }
 640 static inline void musb_debug_delete(char *name, struct musb *data)
 641 {
 642 }
 643 #endif
 644
 645 #endif  /* __MUSB_CORE_H__ */