LCOV - code coverage report
Current view: top level - include/linux/usb - otg.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 1 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : /* USB OTG (On The Go) defines */
       2             : /*
       3             :  *
       4             :  * These APIs may be used between USB controllers.  USB device drivers
       5             :  * (for either host or peripheral roles) don't use these calls; they
       6             :  * continue to use just usb_device and usb_gadget.
       7             :  */
       8             : 
       9             : #ifndef __LINUX_USB_OTG_H
      10             : #define __LINUX_USB_OTG_H
      11             : 
      12             : /* OTG defines lots of enumeration states before device reset */
      13             : enum usb_otg_state {
      14             :         OTG_STATE_UNDEFINED = 0,
      15             : 
      16             :         /* single-role peripheral, and dual-role default-b */
      17             :         OTG_STATE_B_IDLE,
      18             :         OTG_STATE_B_SRP_INIT,
      19             :         OTG_STATE_B_PERIPHERAL,
      20             : 
      21             :         /* extra dual-role default-b states */
      22             :         OTG_STATE_B_WAIT_ACON,
      23             :         OTG_STATE_B_HOST,
      24             : 
      25             :         /* dual-role default-a */
      26             :         OTG_STATE_A_IDLE,
      27             :         OTG_STATE_A_WAIT_VRISE,
      28             :         OTG_STATE_A_WAIT_BCON,
      29             :         OTG_STATE_A_HOST,
      30             :         OTG_STATE_A_SUSPEND,
      31             :         OTG_STATE_A_PERIPHERAL,
      32             :         OTG_STATE_A_WAIT_VFALL,
      33             :         OTG_STATE_A_VBUS_ERR,
      34             : };
      35             : 
      36             : #define USB_OTG_PULLUP_ID               (1 << 0)
      37             : #define USB_OTG_PULLDOWN_DP             (1 << 1)
      38             : #define USB_OTG_PULLDOWN_DM             (1 << 2)
      39             : #define USB_OTG_EXT_VBUS_INDICATOR      (1 << 3)
      40             : #define USB_OTG_DRV_VBUS                (1 << 4)
      41             : #define USB_OTG_DRV_VBUS_EXT            (1 << 5)
      42             : 
      43             : struct otg_transceiver;
      44             : 
      45             : /* for transceivers connected thru an ULPI interface, the user must
      46             :  * provide access ops
      47             :  */
      48             : struct otg_io_access_ops {
      49             :         int (*read)(struct otg_transceiver *otg, u32 reg);
      50             :         int (*write)(struct otg_transceiver *otg, u32 val, u32 reg);
      51             : };
      52           2 : 
      53             : /*
      54             :  * the otg driver needs to interact with both device side and host side
      55             :  * usb controllers.  it decides which controller is active at a given
      56             :  * moment, using the transceiver, ID signal, HNP and sometimes static
      57             :  * configuration information (including "board isn't wired for otg").
      58             :  */
      59             : struct otg_transceiver {
      60             :         struct device           *dev;
      61             :         const char              *label;
      62             :         unsigned int             flags;
      63             : 
      64             :         u8                      default_a;
      65             :         enum usb_otg_state      state;
      66             : 
      67             :         struct usb_bus          *host;
      68             :         struct usb_gadget       *gadget;
      69             : 
      70             :         struct otg_io_access_ops        *io_ops;
      71             :         void __iomem                    *io_priv;
      72             : 
      73             :         /* to pass extra port status to the root hub */
      74             :         u16                     port_status;
      75             :         u16                     port_change;
      76             : 
      77             :         /* initialize/shutdown the OTG controller */
      78             :         int     (*init)(struct otg_transceiver *otg);
      79             :         void    (*shutdown)(struct otg_transceiver *otg);
      80             : 
      81             :         /* bind/unbind the host controller */
      82             :         int     (*set_host)(struct otg_transceiver *otg,
      83             :                                 struct usb_bus *host);
      84             : 
      85             :         /* bind/unbind the peripheral controller */
      86             :         int     (*set_peripheral)(struct otg_transceiver *otg,
      87             :                                 struct usb_gadget *gadget);
      88             : 
      89             :         /* effective for B devices, ignored for A-peripheral */
      90             :         int     (*set_power)(struct otg_transceiver *otg,
      91             :                                 unsigned mA);
      92             : 
      93             :         /* effective for A-peripheral, ignored for B devices */
      94             :         int     (*set_vbus)(struct otg_transceiver *otg,
      95             :                                 bool enabled);
      96             : 
      97             :         /* for non-OTG B devices: set transceiver into suspend mode */
      98             :         int     (*set_suspend)(struct otg_transceiver *otg,
      99             :                                 int suspend);
     100             : 
     101             :         /* for B devices only:  start session with A-Host */
     102             :         int     (*start_srp)(struct otg_transceiver *otg);
     103             : 
     104             :         /* start or continue HNP role switch */
     105             :         int     (*start_hnp)(struct otg_transceiver *otg);
     106             : 
     107             : };
     108             : 
     109             : 
     110             : /* for board-specific init logic */
     111             : extern int otg_set_transceiver(struct otg_transceiver *);
     112             : 
     113             : /* sometimes transceivers are accessed only through e.g. ULPI */
     114             : extern void usb_nop_xceiv_register(void);
     115             : extern void usb_nop_xceiv_unregister(void);
     116             : 
     117             : /* helpers for direct access thru low-level io interface */
     118             : static inline int otg_io_read(struct otg_transceiver *otg, u32 reg)
     119             : {
     120             :         if (otg->io_ops && otg->io_ops->read)
     121             :                 return otg->io_ops->read(otg, reg);
     122             : 
     123             :         return -EINVAL;
     124             : }
     125             : 
     126             : static inline int otg_io_write(struct otg_transceiver *otg, u32 reg, u32 val)
     127             : {
     128             :         if (otg->io_ops && otg->io_ops->write)
     129             :                 return otg->io_ops->write(otg, reg, val);
     130             : 
     131             :         return -EINVAL;
     132             : }
     133             : 
     134             : static inline int
     135             : otg_init(struct otg_transceiver *otg)
     136             : {
     137             :         if (otg->init)
     138             :                 return otg->init(otg);
     139             : 
     140             :         return 0;
     141             : }
     142             : 
     143             : static inline void
     144             : otg_shutdown(struct otg_transceiver *otg)
     145             : {
     146             :         if (otg->shutdown)
     147             :                 otg->shutdown(otg);
     148             : }
     149             : 
     150             : /* for usb host and peripheral controller drivers */
     151             : extern struct otg_transceiver *otg_get_transceiver(void);
     152             : extern void otg_put_transceiver(struct otg_transceiver *);
     153             : 
     154             : /* Context: can sleep */
     155             : static inline int
     156             : otg_start_hnp(struct otg_transceiver *otg)
     157             : {
     158             :         return otg->start_hnp(otg);
     159             : }
     160             : 
     161             : /* Context: can sleep */
     162             : static inline int
     163             : otg_set_vbus(struct otg_transceiver *otg, bool enabled)
     164             : {
     165             :         return otg->set_vbus(otg, enabled);
     166             : }
     167             : 
     168             : /* for HCDs */
     169             : static inline int
     170             : otg_set_host(struct otg_transceiver *otg, struct usb_bus *host)
     171             : {
     172             :         return otg->set_host(otg, host);
     173             : }
     174             : 
     175             : /* for usb peripheral controller drivers */
     176             : 
     177             : /* Context: can sleep */
     178             : static inline int
     179             : otg_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *periph)
     180             : {
     181             :         return otg->set_peripheral(otg, periph);
     182             : }
     183             : 
     184             : static inline int
     185             : otg_set_power(struct otg_transceiver *otg, unsigned mA)
     186             : {
     187             :         return otg->set_power(otg, mA);
     188             : }
     189             : 
     190             : /* Context: can sleep */
     191             : static inline int
     192             : otg_set_suspend(struct otg_transceiver *otg, int suspend)
     193             : {
     194             :         if (otg->set_suspend != NULL)
     195             :                 return otg->set_suspend(otg, suspend);
     196             :         else
     197             :                 return 0;
     198             : }
     199             : 
     200             : static inline int
     201             : otg_start_srp(struct otg_transceiver *otg)
     202             : {
     203             :         return otg->start_srp(otg);
     204             : }
     205             : 
     206             : 
     207             : /* for OTG controller drivers (and maybe other stuff) */
     208             : extern int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num);
     209             : 
     210             : #endif /* __LINUX_USB_OTG_H */

Generated by: LCOV version 1.10