Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0+
       2                 :            : /*
       3                 :            :  * USB Networking Link Interface
       4                 :            :  *
       5                 :            :  * Copyright (C) 2000-2005 by David Brownell <dbrownell@users.sourceforge.net>
       6                 :            :  * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
       7                 :            :  *
       8                 :            :  * This program is free software; you can redistribute it and/or modify
       9                 :            :  * it under the terms of the GNU General Public License as published by
      10                 :            :  * the Free Software Foundation; either version 2 of the License, or
      11                 :            :  * (at your option) any later version.
      12                 :            :  *
      13                 :            :  * This program is distributed in the hope that it will be useful,
      14                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 :            :  * GNU General Public License for more details.
      17                 :            :  *
      18                 :            :  * You should have received a copy of the GNU General Public License
      19                 :            :  * along with this program; if not, write to the Free Software
      20                 :            :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      21                 :            :  */
      22                 :            : 
      23                 :            : #ifndef __LINUX_USB_USBNET_H
      24                 :            : #define __LINUX_USB_USBNET_H
      25                 :            : 
      26                 :            : /* interface from usbnet core to each USB networking link we handle */
      27                 :            : struct usbnet {
      28                 :            :         /* housekeeping */
      29                 :            :         struct usb_device       *udev;
      30                 :            :         struct usb_interface    *intf;
      31                 :            :         const struct driver_info *driver_info;
      32                 :            :         const char              *driver_name;
      33                 :            :         void                    *driver_priv;
      34                 :            :         wait_queue_head_t       wait;
      35                 :            :         struct mutex            phy_mutex;
      36                 :            :         unsigned char           suspend_count;
      37                 :            :         unsigned char           pkt_cnt, pkt_err;
      38                 :            :         unsigned short          rx_qlen, tx_qlen;
      39                 :            :         unsigned                can_dma_sg:1;
      40                 :            : 
      41                 :            :         /* i/o info: pipes etc */
      42                 :            :         unsigned                in, out;
      43                 :            :         struct usb_host_endpoint *status;
      44                 :            :         unsigned                maxpacket;
      45                 :            :         struct timer_list       delay;
      46                 :            :         const char              *padding_pkt;
      47                 :            : 
      48                 :            :         /* protocol/interface state */
      49                 :            :         struct net_device       *net;
      50                 :            :         int                     msg_enable;
      51                 :            :         unsigned long           data[5];
      52                 :            :         u32                     xid;
      53                 :            :         u32                     hard_mtu;       /* count any extra framing */
      54                 :            :         size_t                  rx_urb_size;    /* size for rx urbs */
      55                 :            :         struct mii_if_info      mii;
      56                 :            : 
      57                 :            :         /* various kinds of pending driver work */
      58                 :            :         struct sk_buff_head     rxq;
      59                 :            :         struct sk_buff_head     txq;
      60                 :            :         struct sk_buff_head     done;
      61                 :            :         struct sk_buff_head     rxq_pause;
      62                 :            :         struct urb              *interrupt;
      63                 :            :         unsigned                interrupt_count;
      64                 :            :         struct mutex            interrupt_mutex;
      65                 :            :         struct usb_anchor       deferred;
      66                 :            :         struct tasklet_struct   bh;
      67                 :            : 
      68                 :            :         struct pcpu_sw_netstats __percpu *stats64;
      69                 :            : 
      70                 :            :         struct work_struct      kevent;
      71                 :            :         unsigned long           flags;
      72                 :            : #               define EVENT_TX_HALT    0
      73                 :            : #               define EVENT_RX_HALT    1
      74                 :            : #               define EVENT_RX_MEMORY  2
      75                 :            : #               define EVENT_STS_SPLIT  3
      76                 :            : #               define EVENT_LINK_RESET 4
      77                 :            : #               define EVENT_RX_PAUSED  5
      78                 :            : #               define EVENT_DEV_ASLEEP 6
      79                 :            : #               define EVENT_DEV_OPEN   7
      80                 :            : #               define EVENT_DEVICE_REPORT_IDLE 8
      81                 :            : #               define EVENT_NO_RUNTIME_PM      9
      82                 :            : #               define EVENT_RX_KILL    10
      83                 :            : #               define EVENT_LINK_CHANGE        11
      84                 :            : #               define EVENT_SET_RX_MODE        12
      85                 :            : #               define EVENT_NO_IP_ALIGN        13
      86                 :            : };
      87                 :            : 
      88                 :            : static inline struct usb_driver *driver_of(struct usb_interface *intf)
      89                 :            : {
      90                 :          1 :         return to_usb_driver(intf->dev.driver);
      91                 :            : }
      92                 :            : 
      93                 :            : /* interface from the device/framing level "minidriver" to core */
      94                 :            : struct driver_info {
      95                 :            :         char            *description;
      96                 :            : 
      97                 :            :         int             flags;
      98                 :            : /* framing is CDC Ethernet, not writing ZLPs (hw issues), or optionally: */
      99                 :            : #define FLAG_FRAMING_NC 0x0001          /* guard against device dropouts */
     100                 :            : #define FLAG_FRAMING_GL 0x0002          /* genelink batches packets */
     101                 :            : #define FLAG_FRAMING_Z  0x0004          /* zaurus adds a trailer */
     102                 :            : #define FLAG_FRAMING_RN 0x0008          /* RNDIS batches, plus huge header */
     103                 :            : 
     104                 :            : #define FLAG_NO_SETINT  0x0010          /* device can't set_interface() */
     105                 :            : #define FLAG_ETHER      0x0020          /* maybe use "eth%d" names */
     106                 :            : 
     107                 :            : #define FLAG_FRAMING_AX 0x0040          /* AX88772/178 packets */
     108                 :            : #define FLAG_WLAN       0x0080          /* use "wlan%d" names */
     109                 :            : #define FLAG_AVOID_UNLINK_URBS 0x0100   /* don't unlink urbs at usbnet_stop() */
     110                 :            : #define FLAG_SEND_ZLP   0x0200          /* hw requires ZLPs are sent */
     111                 :            : #define FLAG_WWAN       0x0400          /* use "wwan%d" names */
     112                 :            : 
     113                 :            : #define FLAG_LINK_INTR  0x0800          /* updates link (carrier) status */
     114                 :            : 
     115                 :            : #define FLAG_POINTTOPOINT 0x1000        /* possibly use "usb%d" names */
     116                 :            : 
     117                 :            : /*
     118                 :            :  * Indicates to usbnet, that USB driver accumulates multiple IP packets.
     119                 :            :  * Affects statistic (counters) and short packet handling.
     120                 :            :  */
     121                 :            : #define FLAG_MULTI_PACKET       0x2000
     122                 :            : #define FLAG_RX_ASSEMBLE        0x4000  /* rx packets may span >1 frames */
     123                 :            : #define FLAG_NOARP              0x8000  /* device can't do ARP */
     124                 :            : 
     125                 :            :         /* init device ... can sleep, or cause probe() failure */
     126                 :            :         int     (*bind)(struct usbnet *, struct usb_interface *);
     127                 :            : 
     128                 :            :         /* cleanup device ... can sleep, but can't fail */
     129                 :            :         void    (*unbind)(struct usbnet *, struct usb_interface *);
     130                 :            : 
     131                 :            :         /* reset device ... can sleep */
     132                 :            :         int     (*reset)(struct usbnet *);
     133                 :            : 
     134                 :            :         /* stop device ... can sleep */
     135                 :            :         int     (*stop)(struct usbnet *);
     136                 :            : 
     137                 :            :         /* see if peer is connected ... can sleep */
     138                 :            :         int     (*check_connect)(struct usbnet *);
     139                 :            : 
     140                 :            :         /* (dis)activate runtime power management */
     141                 :            :         int     (*manage_power)(struct usbnet *, int);
     142                 :            : 
     143                 :            :         /* for status polling */
     144                 :            :         void    (*status)(struct usbnet *, struct urb *);
     145                 :            : 
     146                 :            :         /* link reset handling, called from defer_kevent */
     147                 :            :         int     (*link_reset)(struct usbnet *);
     148                 :            : 
     149                 :            :         /* fixup rx packet (strip framing) */
     150                 :            :         int     (*rx_fixup)(struct usbnet *dev, struct sk_buff *skb);
     151                 :            : 
     152                 :            :         /* fixup tx packet (add framing) */
     153                 :            :         struct sk_buff  *(*tx_fixup)(struct usbnet *dev,
     154                 :            :                                 struct sk_buff *skb, gfp_t flags);
     155                 :            : 
     156                 :            :         /* recover from timeout */
     157                 :            :         void    (*recover)(struct usbnet *dev);
     158                 :            : 
     159                 :            :         /* early initialization code, can sleep. This is for minidrivers
     160                 :            :          * having 'subminidrivers' that need to do extra initialization
     161                 :            :          * right after minidriver have initialized hardware. */
     162                 :            :         int     (*early_init)(struct usbnet *dev);
     163                 :            : 
     164                 :            :         /* called by minidriver when receiving indication */
     165                 :            :         void    (*indication)(struct usbnet *dev, void *ind, int indlen);
     166                 :            : 
     167                 :            :         /* rx mode change (device changes address list filtering) */
     168                 :            :         void    (*set_rx_mode)(struct usbnet *dev);
     169                 :            : 
     170                 :            :         /* for new devices, use the descriptor-reading code instead */
     171                 :            :         int             in;             /* rx endpoint */
     172                 :            :         int             out;            /* tx endpoint */
     173                 :            : 
     174                 :            :         unsigned long   data;           /* Misc driver specific data */
     175                 :            : };
     176                 :            : 
     177                 :            : /* Minidrivers are just drivers using the "usbnet" core as a powerful
     178                 :            :  * network-specific subroutine library ... that happens to do pretty
     179                 :            :  * much everything except custom framing and chip-specific stuff.
     180                 :            :  */
     181                 :            : extern int usbnet_probe(struct usb_interface *, const struct usb_device_id *);
     182                 :            : extern int usbnet_suspend(struct usb_interface *, pm_message_t);
     183                 :            : extern int usbnet_resume(struct usb_interface *);
     184                 :            : extern void usbnet_disconnect(struct usb_interface *);
     185                 :            : extern void usbnet_device_suggests_idle(struct usbnet *dev);
     186                 :            : 
     187                 :            : extern int usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
     188                 :            :                     u16 value, u16 index, void *data, u16 size);
     189                 :            : extern int usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
     190                 :            :                     u16 value, u16 index, const void *data, u16 size);
     191                 :            : extern int usbnet_read_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
     192                 :            :                     u16 value, u16 index, void *data, u16 size);
     193                 :            : extern int usbnet_write_cmd_nopm(struct usbnet *dev, u8 cmd, u8 reqtype,
     194                 :            :                     u16 value, u16 index, const void *data, u16 size);
     195                 :            : extern int usbnet_write_cmd_async(struct usbnet *dev, u8 cmd, u8 reqtype,
     196                 :            :                     u16 value, u16 index, const void *data, u16 size);
     197                 :            : 
     198                 :            : /* Drivers that reuse some of the standard USB CDC infrastructure
     199                 :            :  * (notably, using multiple interfaces according to the CDC
     200                 :            :  * union descriptor) get some helper code.
     201                 :            :  */
     202                 :            : struct cdc_state {
     203                 :            :         struct usb_cdc_header_desc      *header;
     204                 :            :         struct usb_cdc_union_desc       *u;
     205                 :            :         struct usb_cdc_ether_desc       *ether;
     206                 :            :         struct usb_interface            *control;
     207                 :            :         struct usb_interface            *data;
     208                 :            : };
     209                 :            : 
     210                 :            : extern int usbnet_generic_cdc_bind(struct usbnet *, struct usb_interface *);
     211                 :            : extern int usbnet_ether_cdc_bind(struct usbnet *dev, struct usb_interface *intf);
     212                 :            : extern int usbnet_cdc_bind(struct usbnet *, struct usb_interface *);
     213                 :            : extern void usbnet_cdc_unbind(struct usbnet *, struct usb_interface *);
     214                 :            : extern void usbnet_cdc_status(struct usbnet *, struct urb *);
     215                 :            : 
     216                 :            : /* CDC and RNDIS support the same host-chosen packet filters for IN transfers */
     217                 :            : #define DEFAULT_FILTER  (USB_CDC_PACKET_TYPE_BROADCAST \
     218                 :            :                         |USB_CDC_PACKET_TYPE_ALL_MULTICAST \
     219                 :            :                         |USB_CDC_PACKET_TYPE_PROMISCUOUS \
     220                 :            :                         |USB_CDC_PACKET_TYPE_DIRECTED)
     221                 :            : 
     222                 :            : 
     223                 :            : /* we record the state for each of our queued skbs */
     224                 :            : enum skb_state {
     225                 :            :         illegal = 0,
     226                 :            :         tx_start, tx_done,
     227                 :            :         rx_start, rx_done, rx_cleanup,
     228                 :            :         unlink_start
     229                 :            : };
     230                 :            : 
     231                 :            : struct skb_data {       /* skb->cb is one of these */
     232                 :            :         struct urb              *urb;
     233                 :            :         struct usbnet           *dev;
     234                 :            :         enum skb_state          state;
     235                 :            :         long                    length;
     236                 :            :         unsigned long           packets;
     237                 :            : };
     238                 :            : 
     239                 :            : /* Drivers that set FLAG_MULTI_PACKET must call this in their
     240                 :            :  * tx_fixup method before returning an skb.
     241                 :            :  */
     242                 :            : static inline void
     243                 :            : usbnet_set_skb_tx_stats(struct sk_buff *skb,
     244                 :            :                         unsigned long packets, long bytes_delta)
     245                 :            : {
     246                 :            :         struct skb_data *entry = (struct skb_data *) skb->cb;
     247                 :            : 
     248                 :          3 :         entry->packets = packets;
     249                 :          3 :         entry->length = bytes_delta;
     250                 :            : }
     251                 :            : 
     252                 :            : extern int usbnet_open(struct net_device *net);
     253                 :            : extern int usbnet_stop(struct net_device *net);
     254                 :            : extern netdev_tx_t usbnet_start_xmit(struct sk_buff *skb,
     255                 :            :                                      struct net_device *net);
     256                 :            : extern void usbnet_tx_timeout(struct net_device *net);
     257                 :            : extern int usbnet_change_mtu(struct net_device *net, int new_mtu);
     258                 :            : 
     259                 :            : extern int usbnet_get_endpoints(struct usbnet *, struct usb_interface *);
     260                 :            : extern int usbnet_get_ethernet_addr(struct usbnet *, int);
     261                 :            : extern void usbnet_defer_kevent(struct usbnet *, int);
     262                 :            : extern void usbnet_skb_return(struct usbnet *, struct sk_buff *);
     263                 :            : extern void usbnet_unlink_rx_urbs(struct usbnet *);
     264                 :            : 
     265                 :            : extern void usbnet_pause_rx(struct usbnet *);
     266                 :            : extern void usbnet_resume_rx(struct usbnet *);
     267                 :            : extern void usbnet_purge_paused_rxq(struct usbnet *);
     268                 :            : 
     269                 :            : extern int usbnet_get_link_ksettings(struct net_device *net,
     270                 :            :                                      struct ethtool_link_ksettings *cmd);
     271                 :            : extern int usbnet_set_link_ksettings(struct net_device *net,
     272                 :            :                                      const struct ethtool_link_ksettings *cmd);
     273                 :            : extern u32 usbnet_get_link(struct net_device *net);
     274                 :            : extern u32 usbnet_get_msglevel(struct net_device *);
     275                 :            : extern void usbnet_set_msglevel(struct net_device *, u32);
     276                 :            : extern void usbnet_get_drvinfo(struct net_device *, struct ethtool_drvinfo *);
     277                 :            : extern int usbnet_nway_reset(struct net_device *net);
     278                 :            : 
     279                 :            : extern int usbnet_manage_power(struct usbnet *, int);
     280                 :            : extern void usbnet_link_change(struct usbnet *, bool, bool);
     281                 :            : 
     282                 :            : extern int usbnet_status_start(struct usbnet *dev, gfp_t mem_flags);
     283                 :            : extern void usbnet_status_stop(struct usbnet *dev);
     284                 :            : 
     285                 :            : extern void usbnet_update_max_qlen(struct usbnet *dev);
     286                 :            : extern void usbnet_get_stats64(struct net_device *dev,
     287                 :            :                                struct rtnl_link_stats64 *stats);
     288                 :            : 
     289                 :            : #endif /* __LINUX_USB_USBNET_H */