drivers/staging/r8188eu/os_dep/usb_intf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 2007 - 2011 Realtek Corporation. */
   3
   4 #include <linux/usb.h>
   5 #include "../include/osdep_service.h"
   6 #include "../include/drv_types.h"
   7 #include "../include/recv_osdep.h"
   8 #include "../include/xmit_osdep.h"
   9 #include "../include/hal_intf.h"
  10 #include "../include/osdep_intf.h"
  11 #include "../include/usb_ops.h"
  12 #include "../include/usb_osintf.h"
  13 #include "../include/rtw_ioctl.h"
  14 #include "../include/rtl8188e_hal.h"
  15
  16 int ui_pid[3] = {0, 0, 0};
  17
  18 static int rtw_suspend(struct usb_interface *intf, pm_message_t message);
  19 static int rtw_resume(struct usb_interface *intf);
  20
  21 static int rtw_drv_init(struct usb_interface *pusb_intf, const struct usb_device_id *pdid);
  22 static void rtw_dev_remove(struct usb_interface *pusb_intf);
  23
  24 #define USB_VENDER_ID_REALTEK           0x0bda
  25
  26 /* DID_USB_v916_20130116 */
  27 static struct usb_device_id rtw_usb_id_tbl[] = {
  28         /*=== Realtek demoboard ===*/
  29         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8179)}, /* 8188EUS */
  30         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x0179)}, /* 8188ETV */
  31         /*=== Customer ID ===*/
  32         /****** 8188EUS ********/
  33         {USB_DEVICE(0x07B8, 0x8179)}, /* Abocom - Abocom */
  34         {USB_DEVICE(0x0DF6, 0x0076)}, /* Sitecom N150 v2 */
  35         {USB_DEVICE(0x2001, 0x330F)}, /* DLink DWA-125 REV D1 */
  36         {USB_DEVICE(0x2001, 0x3310)}, /* Dlink DWA-123 REV D1 */
  37         {USB_DEVICE(0x2001, 0x3311)}, /* DLink GO-USB-N150 REV B1 */
  38         {USB_DEVICE(0x2001, 0x331B)}, /* D-Link DWA-121 rev B1 */
  39         {USB_DEVICE(0x056E, 0x4008)}, /* Elecom WDC-150SU2M */
  40         {USB_DEVICE(0x2357, 0x010c)}, /* TP-Link TL-WN722N v2 */
  41         {USB_DEVICE(0x2357, 0x0111)}, /* TP-Link TL-WN727N v5.21 */
  42         {USB_DEVICE(0x2C4E, 0x0102)}, /* MERCUSYS MW150US v2 */
  43         {USB_DEVICE(0x0B05, 0x18F0)}, /* ASUS USB-N10 Nano B1 */
  44         {USB_DEVICE(0x7392, 0xb811)}, /* Edimax EW-7811Un V2 */
  45         {}      /* Terminating entry */
  46 };
  47
  48 MODULE_DEVICE_TABLE(usb, rtw_usb_id_tbl);
  49
  50 struct rtw_usb_drv {
  51         struct usb_driver usbdrv;
  52         int drv_registered;
  53         struct mutex hw_init_mutex;
  54 };
  55
  56 static struct rtw_usb_drv rtl8188e_usb_drv = {
  57         .usbdrv.name = "r8188eu",
  58         .usbdrv.probe = rtw_drv_init,
  59         .usbdrv.disconnect = rtw_dev_remove,
  60         .usbdrv.id_table = rtw_usb_id_tbl,
  61         .usbdrv.suspend =  rtw_suspend,
  62         .usbdrv.resume = rtw_resume,
  63         .usbdrv.reset_resume   = rtw_resume,
  64 };
  65
  66 static struct rtw_usb_drv *usb_drv = &rtl8188e_usb_drv;
  67
  68 static struct dvobj_priv *usb_dvobj_init(struct usb_interface *usb_intf)
  69 {
  70         int     i;
  71         u8      rt_num_in_pipes = 0;
  72         struct dvobj_priv *pdvobjpriv;
  73         struct usb_host_config          *phost_conf;
  74         struct usb_config_descriptor    *pconf_desc;
  75         struct usb_host_interface       *phost_iface;
  76         struct usb_interface_descriptor *piface_desc;
  77         struct usb_endpoint_descriptor  *pendp_desc;
  78         struct usb_device       *pusbd;
  79
  80         pdvobjpriv = kzalloc(sizeof(*pdvobjpriv), GFP_KERNEL);
  81         if (!pdvobjpriv)
  82                 goto err;
  83
  84         pdvobjpriv->pusbintf = usb_intf;
  85         pusbd = interface_to_usbdev(usb_intf);
  86         pdvobjpriv->pusbdev = pusbd;
  87         usb_set_intfdata(usb_intf, pdvobjpriv);
  88
  89         pdvobjpriv->RtNumOutPipes = 0;
  90
  91         phost_conf = pusbd->actconfig;
  92         pconf_desc = &phost_conf->desc;
  93
  94         phost_iface = &usb_intf->altsetting[0];
  95         piface_desc = &phost_iface->desc;
  96
  97         pdvobjpriv->NumInterfaces = pconf_desc->bNumInterfaces;
  98         pdvobjpriv->InterfaceNumber = piface_desc->bInterfaceNumber;
  99
 100         for (i = 0; i < piface_desc->bNumEndpoints; i++) {
 101                 int ep_num;
 102                 pendp_desc = &phost_iface->endpoint[i].desc;
 103
 104                 ep_num = usb_endpoint_num(pendp_desc);
 105
 106                 if (usb_endpoint_is_bulk_in(pendp_desc)) {
 107                         pdvobjpriv->RtInPipe = ep_num;
 108                         rt_num_in_pipes++;
 109                 } else if (usb_endpoint_is_bulk_out(pendp_desc)) {
 110                         pdvobjpriv->RtOutPipe[pdvobjpriv->RtNumOutPipes] =
 111                                 ep_num;
 112                         pdvobjpriv->RtNumOutPipes++;
 113                 }
 114         }
 115
 116         if (rt_num_in_pipes != 1)
 117                 goto err;
 118
 119         /* 3 misc */
 120         rtw_reset_continual_urb_error(pdvobjpriv);
 121
 122         usb_get_dev(pusbd);
 123         return pdvobjpriv;
 124
 125 err:
 126         kfree(pdvobjpriv);
 127         return NULL;
 128 }
 129
 130 static void usb_dvobj_deinit(struct usb_interface *usb_intf)
 131 {
 132         struct dvobj_priv *dvobj = usb_get_intfdata(usb_intf);
 133
 134         usb_set_intfdata(usb_intf, NULL);
 135         if (dvobj) {
 136                 /* Modify condition for 92DU DMDP 2010.11.18, by Thomas */
 137                 if ((dvobj->NumInterfaces != 2 &&
 138                     dvobj->NumInterfaces != 3) ||
 139             (dvobj->InterfaceNumber == 1)) {
 140                         if (interface_to_usbdev(usb_intf)->state !=
 141                             USB_STATE_NOTATTACHED)
 142                                 /* If we didn't unplug usb dongle and
 143                                  * remove/insert module, driver fails
 144                                  * on sitesurvey for the first time when
 145                                  * device is up . Reset usb port for sitesurvey
 146                                  * fail issue. */
 147                                 usb_reset_device(interface_to_usbdev(usb_intf));
 148                 }
 149                 kfree(dvobj);
 150         }
 151
 152         usb_put_dev(interface_to_usbdev(usb_intf));
 153
 154 }
 155
 156 static void usb_intf_start(struct adapter *padapter)
 157 {
 158         rtl8188eu_inirp_init(padapter);
 159 }
 160
 161 static void usb_intf_stop(struct adapter *padapter)
 162 {
 163         /* cancel in irp */
 164         rtw_read_port_cancel(padapter);
 165
 166         /* cancel out irp */
 167         rtw_write_port_cancel(padapter);
 168
 169         /* todo:cancel other irps */
 170 }
 171
 172 static void rtw_dev_unload(struct adapter *padapter)
 173 {
 174         if (padapter->bup) {
 175                 padapter->bDriverStopped = true;
 176                 if (padapter->xmitpriv.ack_tx)
 177                         rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
 178                 /* s3. */
 179                 if (padapter->intf_stop)
 180                         padapter->intf_stop(padapter);
 181                 /* s4. */
 182                 rtw_stop_drv_threads(padapter);
 183
 184                 /* s5. */
 185                 if (!padapter->bSurpriseRemoved) {
 186                         rtw_hal_deinit(padapter);
 187                         padapter->bSurpriseRemoved = true;
 188                 }
 189
 190                 padapter->bup = false;
 191         }
 192 }
 193
 194 static int rtw_suspend(struct usb_interface *pusb_intf, pm_message_t message)
 195 {
 196         struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
 197         struct adapter *padapter = dvobj->if1;
 198         struct net_device *pnetdev = padapter->pnetdev;
 199         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 200         struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
 201
 202         if ((!padapter->bup) || (padapter->bDriverStopped) ||
 203             (padapter->bSurpriseRemoved))
 204                 goto exit;
 205
 206         pwrpriv->bInSuspend = true;
 207         rtw_cancel_all_timer(padapter);
 208         LeaveAllPowerSaveMode(padapter);
 209
 210         mutex_lock(&pwrpriv->lock);
 211         /* s1. */
 212         if (pnetdev) {
 213                 netif_carrier_off(pnetdev);
 214                 netif_tx_stop_all_queues(pnetdev);
 215         }
 216
 217         /* s2. */
 218         rtw_disassoc_cmd(padapter, 0, false);
 219
 220         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) &&
 221             check_fwstate(pmlmepriv, _FW_LINKED))
 222                 pmlmepriv->to_roaming = 1;
 223         /* s2-2.  indicate disconnect to os */
 224         rtw_indicate_disconnect(padapter);
 225         /* s2-3. */
 226         rtw_free_assoc_resources(padapter, 1);
 227         /* s2-4. */
 228         rtw_free_network_queue(padapter, true);
 229
 230         rtw_dev_unload(padapter);
 231         mutex_unlock(&pwrpriv->lock);
 232
 233         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
 234                 rtw_indicate_scan_done(padapter, 1);
 235
 236         if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
 237                 rtw_indicate_disconnect(padapter);
 238
 239 exit:
 240                 return 0;
 241 }
 242
 243 static int rtw_resume(struct usb_interface *pusb_intf)
 244 {
 245         struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
 246         struct adapter *padapter = dvobj->if1;
 247         struct net_device *pnetdev;
 248         struct pwrctrl_priv *pwrpriv = NULL;
 249         int ret = -1;
 250
 251         pnetdev = padapter->pnetdev;
 252         pwrpriv = &padapter->pwrctrlpriv;
 253
 254         mutex_lock(&pwrpriv->lock);
 255         rtw_reset_drv_sw(padapter);
 256         if (pwrpriv)
 257                 pwrpriv->bkeepfwalive = false;
 258
 259         if (netdev_open(pnetdev) != 0) {
 260                 mutex_unlock(&pwrpriv->lock);
 261                 goto exit;
 262         }
 263
 264         netif_device_attach(pnetdev);
 265         netif_carrier_on(pnetdev);
 266
 267         mutex_unlock(&pwrpriv->lock);
 268
 269         if (padapter->pid[1] != 0)
 270                 rtw_signal_process(padapter->pid[1], SIGUSR2);
 271
 272         rtw_roaming(padapter, NULL);
 273
 274         ret = 0;
 275 exit:
 276         if (pwrpriv)
 277                 pwrpriv->bInSuspend = false;
 278
 279         return ret;
 280 }
 281
 282 /*
 283  * drv_init() - a device potentially for us
 284  *
 285  * notes: drv_init() is called when the bus driver has located
 286  * a card for us to support.
 287  *        We accept the new device by returning 0.
 288  */
 289
 290 static struct adapter *rtw_usb_if1_init(struct dvobj_priv *dvobj,
 291         struct usb_interface *pusb_intf)
 292 {
 293         struct adapter *padapter = NULL;
 294         struct net_device *pnetdev = NULL;
 295         struct io_priv *piopriv;
 296         struct intf_hdl *pintf;
 297
 298         padapter = vzalloc(sizeof(*padapter));
 299         if (!padapter)
 300                 return NULL;
 301
 302         padapter->dvobj = dvobj;
 303         dvobj->if1 = padapter;
 304
 305         padapter->bDriverStopped = true;
 306
 307         padapter->hw_init_mutex = &usb_drv->hw_init_mutex;
 308
 309         if (rtw_handle_dualmac(padapter, 1) != _SUCCESS)
 310                 goto free_adapter;
 311
 312         pnetdev = rtw_init_netdev(padapter);
 313         if (!pnetdev)
 314                 goto handle_dualmac;
 315         SET_NETDEV_DEV(pnetdev, dvobj_to_dev(dvobj));
 316         padapter = rtw_netdev_priv(pnetdev);
 317
 318         padapter->intf_start = &usb_intf_start;
 319         padapter->intf_stop = &usb_intf_stop;
 320
 321         /* step init_io_priv */
 322         piopriv = &padapter->iopriv;
 323         pintf = &piopriv->intf;
 324         piopriv->padapter = padapter;
 325         pintf->padapter = padapter;
 326         pintf->pintf_dev = adapter_to_dvobj(padapter);
 327
 328         /* step read_chip_version */
 329         rtl8188e_read_chip_version(padapter);
 330
 331         /* step usb endpoint mapping */
 332         rtl8188eu_interface_configure(padapter);
 333
 334         /* step read efuse/eeprom data and get mac_addr */
 335         ReadAdapterInfo8188EU(padapter);
 336
 337         /* step 5. */
 338         if (rtw_init_drv_sw(padapter) == _FAIL)
 339                 goto handle_dualmac;
 340
 341 #ifdef CONFIG_PM
 342         if (padapter->pwrctrlpriv.bSupportRemoteWakeup) {
 343                 dvobj->pusbdev->do_remote_wakeup = 1;
 344                 pusb_intf->needs_remote_wakeup = 1;
 345                 device_init_wakeup(&pusb_intf->dev, 1);
 346         }
 347 #endif
 348
 349         /* 2012-07-11 Move here to prevent the 8723AS-VAU BT auto
 350          * suspend influence */
 351         usb_autopm_get_interface(pusb_intf);
 352
 353         /*  alloc dev name after read efuse. */
 354         if (rtw_init_netdev_name(pnetdev, padapter->registrypriv.ifname) < 0)
 355                 goto free_drv_sw;
 356         rtw_macaddr_cfg(padapter->eeprompriv.mac_addr);
 357         rtw_init_wifidirect_addrs(padapter, padapter->eeprompriv.mac_addr,
 358                                   padapter->eeprompriv.mac_addr);
 359         eth_hw_addr_set(pnetdev, padapter->eeprompriv.mac_addr);
 360
 361         /* step 6. Tell the network stack we exist */
 362         if (register_netdev(pnetdev) != 0)
 363                 goto free_drv_sw;
 364
 365         return padapter;
 366
 367 free_drv_sw:
 368         rtw_cancel_all_timer(padapter);
 369         rtw_free_drv_sw(padapter);
 370 handle_dualmac:
 371         rtw_handle_dualmac(padapter, 0);
 372 free_adapter:
 373         if (pnetdev)
 374                 rtw_free_netdev(pnetdev);
 375         else if (padapter)
 376                 vfree(padapter);
 377
 378         return NULL;
 379 }
 380
 381 static void rtw_usb_if1_deinit(struct adapter *if1)
 382 {
 383         struct net_device *pnetdev = if1->pnetdev;
 384         struct mlme_priv *pmlmepriv = &if1->mlmepriv;
 385
 386         if (check_fwstate(pmlmepriv, _FW_LINKED))
 387                 rtw_disassoc_cmd(if1, 0, false);
 388
 389         free_mlme_ap_info(if1);
 390
 391         if (pnetdev) {
 392                 /* will call netdev_close() */
 393                 unregister_netdev(pnetdev);
 394         }
 395         rtw_cancel_all_timer(if1);
 396
 397         rtw_dev_unload(if1);
 398         rtw_handle_dualmac(if1, 0);
 399         rtw_free_drv_sw(if1);
 400         if (pnetdev)
 401                 rtw_free_netdev(pnetdev);
 402 }
 403
 404 static int rtw_drv_init(struct usb_interface *pusb_intf, const struct usb_device_id *pdid)
 405 {
 406         struct adapter *if1 = NULL;
 407         struct dvobj_priv *dvobj;
 408
 409         /* Initialize dvobj_priv */
 410         dvobj = usb_dvobj_init(pusb_intf);
 411         if (!dvobj)
 412                 goto err;
 413
 414         if1 = rtw_usb_if1_init(dvobj, pusb_intf);
 415         if (!if1)
 416                 goto free_dvobj;
 417
 418         if (ui_pid[1] != 0)
 419                 rtw_signal_process(ui_pid[1], SIGUSR2);
 420
 421         return 0;
 422
 423 free_dvobj:
 424         usb_dvobj_deinit(pusb_intf);
 425 err:
 426         return -ENODEV;
 427 }
 428
 429 /*
 430  * dev_remove() - our device is being removed
 431 */
 432 /* rmmod module & unplug(SurpriseRemoved) will call r871xu_dev_remove() => how to recognize both */
 433 static void rtw_dev_remove(struct usb_interface *pusb_intf)
 434 {
 435         struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
 436         struct adapter *padapter = dvobj->if1;
 437
 438         if (usb_drv->drv_registered)
 439                 padapter->bSurpriseRemoved = true;
 440
 441         rtw_pm_set_ips(padapter, IPS_NONE);
 442         rtw_pm_set_lps(padapter, PS_MODE_ACTIVE);
 443
 444         LeaveAllPowerSaveMode(padapter);
 445
 446         rtw_usb_if1_deinit(padapter);
 447
 448         usb_dvobj_deinit(pusb_intf);
 449 }
 450
 451 static int __init rtw_drv_entry(void)
 452 {
 453         mutex_init(&usb_drv->hw_init_mutex);
 454
 455         usb_drv->drv_registered = true;
 456         return usb_register(&usb_drv->usbdrv);
 457 }
 458
 459 static void __exit rtw_drv_halt(void)
 460 {
 461         usb_drv->drv_registered = false;
 462         usb_deregister(&usb_drv->usbdrv);
 463
 464         mutex_destroy(&usb_drv->hw_init_mutex);
 465 }
 466
 467 module_init(rtw_drv_entry);
 468 module_exit(rtw_drv_halt);