]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/staging/rtl8712/usb_intf.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drivers/staging: Remove unnecessary casts of pci_get_drvdata
[mirror_ubuntu-bionic-kernel.git] / drivers / staging / rtl8712 / usb_intf.c
CommitLineData
2865d42c
LF		 1/******************************************************************************
2 * usb_intf.c
3 *
4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
5 * Linux device driver for RTL8192SU
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 *
20 * Modifications for inclusion into the Linux staging tree are
21 * Copyright(c) 2010 Larry Finger. All rights reserved.
22 *
23 * Contact information:
24 * WLAN FAE <wlanfae@realtek.com>
25 * Larry Finger <Larry.Finger@lwfinger.net>
26 *
27 ******************************************************************************/
28
29#define _HCI_INTF_C_
30
31#include "osdep_service.h"
32#include "drv_types.h"
33#include "recv_osdep.h"
34#include "xmit_osdep.h"
35#include "rtl8712_efuse.h"
36#include "usb_vendor_req.h"
37#include "usb_ops.h"
38#include "usb_osintf.h"
39
5a3acb04 40#define DRVER "v7_0.20100831"
2865d42c
LF		 41
42static struct usb_interface *pintf;
43
44static int r871xu_drv_init(struct usb_interface *pusb_intf,
45 const struct usb_device_id *pdid);
46
47static void r871xu_dev_remove(struct usb_interface *pusb_intf);
48
49static struct usb_device_id rtl871x_usb_id_tbl[] = {
50 /*92SU
51 * Realtek */
52 {USB_DEVICE(0x0bda, 0x8171)},
53 {USB_DEVICE(0x0bda, 0x8172)},
54 {USB_DEVICE(0x0bda, 0x8173)},
55 {USB_DEVICE(0x0bda, 0x8174)},
56 {USB_DEVICE(0x0bda, 0x8712)},
57 {USB_DEVICE(0x0bda, 0x8713)},
58 {USB_DEVICE(0x0bda, 0xC512)},
59 /* Abocom */
60 {USB_DEVICE(0x07B8, 0x8188)},
61 /* Corega */
62 {USB_DEVICE(0x07aa, 0x0047)},
63 /* Dlink */
64 {USB_DEVICE(0x07d1, 0x3303)},
65 {USB_DEVICE(0x07d1, 0x3302)},
66 {USB_DEVICE(0x07d1, 0x3300)},
67 /* Dlink for Skyworth */
68 {USB_DEVICE(0x14b2, 0x3300)},
69 {USB_DEVICE(0x14b2, 0x3301)},
70 {USB_DEVICE(0x14b2, 0x3302)},
71 /* EnGenius */
72 {USB_DEVICE(0x1740, 0x9603)},
73 {USB_DEVICE(0x1740, 0x9605)},
74 /* Belkin */
75 {USB_DEVICE(0x050d, 0x815F)},
76 {USB_DEVICE(0x050d, 0x945A)},
77 {USB_DEVICE(0x050d, 0x845A)},
78 /* Guillemot */
79 {USB_DEVICE(0x06f8, 0xe031)},
80 /* Edimax */
81 {USB_DEVICE(0x7392, 0x7611)},
82 {USB_DEVICE(0x7392, 0x7612)},
83 {USB_DEVICE(0x7392, 0x7622)},
84 /* Sitecom */
85 {USB_DEVICE(0x0DF6, 0x0045)},
86 /* Hawking */
87 {USB_DEVICE(0x0E66, 0x0015)},
88 {USB_DEVICE(0x0E66, 0x0016)},
89 {USB_DEVICE(0x0b05, 0x1786)},
90 {USB_DEVICE(0x0b05, 0x1791)}, /* 11n mode disable */
91
92 {USB_DEVICE(0x13D3, 0x3306)},
93 {USB_DEVICE(0x13D3, 0x3309)},
94 {USB_DEVICE(0x13D3, 0x3310)},
95 {USB_DEVICE(0x13D3, 0x3311)}, /* 11n mode disable */
96 {USB_DEVICE(0x13D3, 0x3325)},
97 {USB_DEVICE(0x083A, 0xC512)},
98 {}
99};
100
101MODULE_DEVICE_TABLE(usb, rtl871x_usb_id_tbl);
102
103static struct specific_device_id specific_device_id_tbl[] = {
104 {.idVendor = 0x0b05, .idProduct = 0x1791,
105 .flags = SPEC_DEV_ID_DISABLE_HT},
106 {.idVendor = 0x13D3, .idProduct = 0x3311,
107 .flags = SPEC_DEV_ID_DISABLE_HT},
108 {}
109};
110
111struct drv_priv {
112 struct usb_driver r871xu_drv;
113 int drv_registered;
114};
115
116#ifdef CONFIG_PM
117static int r871x_suspend(struct usb_interface *pusb_intf, pm_message_t state)
118{
119 struct net_device *pnetdev = usb_get_intfdata(pusb_intf);
120
121 printk(KERN_INFO "r8712: suspending...\n");
122 if (!pnetdev || !netif_running(pnetdev)) {
123 printk(KERN_INFO "r8712: unable to suspend\n");
124 return 0;
125 }
126 if (pnetdev->netdev_ops->ndo_stop)
127 pnetdev->netdev_ops->ndo_stop(pnetdev);
128 mdelay(10);
129 netif_device_detach(pnetdev);
130 return 0;
131}
132
133static int r871x_resume(struct usb_interface *pusb_intf)
134{
135 struct net_device *pnetdev = usb_get_intfdata(pusb_intf);
136
137 printk(KERN_INFO "r8712: resuming...\n");
138 if (!pnetdev || !netif_running(pnetdev)) {
139 printk(KERN_INFO "r8712: unable to resume\n");
140 return 0;
141 }
142 netif_device_attach(pnetdev);
143 if (pnetdev->netdev_ops->ndo_open)
144 pnetdev->netdev_ops->ndo_open(pnetdev);
145 return 0;
146}
147
148static int r871x_reset_resume(struct usb_interface *pusb_intf)
149{
150 /* dummy routine */
151 return 0;
152}
153
154#endif
155
156static struct drv_priv drvpriv = {
157 .r871xu_drv.name = "r8712u",
158 .r871xu_drv.id_table = rtl871x_usb_id_tbl,
159 .r871xu_drv.probe = r871xu_drv_init,
160 .r871xu_drv.disconnect = r871xu_dev_remove,
161#ifdef CONFIG_PM
162 .r871xu_drv.suspend = r871x_suspend,
163 .r871xu_drv.resume = r871x_resume,
164 .r871xu_drv.reset_resume = r871x_reset_resume,
165#endif
166};
167
168static uint r8712_usb_dvobj_init(struct _adapter *padapter)
169{
170 uint status = _SUCCESS;
171 struct usb_device_descriptor *pdev_desc;
172 struct usb_host_config *phost_conf;
173 struct usb_config_descriptor *pconf_desc;
174 struct usb_host_interface *phost_iface;
175 struct usb_interface_descriptor *piface_desc;
176 struct dvobj_priv *pdvobjpriv = &padapter->dvobjpriv;
177 struct usb_device *pusbd = pdvobjpriv->pusbdev;
178
179 pdvobjpriv->padapter = padapter;
180 padapter->EepromAddressSize = 6;
181 pdev_desc = &pusbd->descriptor;
182 phost_conf = pusbd->actconfig;
183 pconf_desc = &phost_conf->desc;
184 phost_iface = &pintf->altsetting[0];
185 piface_desc = &phost_iface->desc;
186 pdvobjpriv->nr_endpoint = piface_desc->bNumEndpoints;
187 if (pusbd->speed == USB_SPEED_HIGH) {
188 pdvobjpriv->ishighspeed = true;
189 printk(KERN_INFO "r8712u: USB_SPEED_HIGH with %d endpoints\n",
190 pdvobjpriv->nr_endpoint);
191 } else {
192 pdvobjpriv->ishighspeed = false;
193 printk(KERN_INFO "r8712u: USB_SPEED_LOW with %d endpoints\n",
194 pdvobjpriv->nr_endpoint);
195 }
196 if ((r8712_alloc_io_queue(padapter)) == _FAIL)
197 status = _FAIL;
198 sema_init(&(padapter->dvobjpriv.usb_suspend_sema), 0);
199 return status;
200}
201
202static void r8712_usb_dvobj_deinit(struct _adapter *padapter)
203{
204}
205
206void rtl871x_intf_stop(struct _adapter *padapter)
207{
208 /*disable_hw_interrupt*/
209 if (padapter->bSurpriseRemoved == false) {
210 /*device still exists, so driver can do i/o operation
211 * TODO: */
212 }
213
214 /* cancel in irp */
215 if (padapter->dvobjpriv.inirp_deinit != NULL)
216 padapter->dvobjpriv.inirp_deinit(padapter);
217 /* cancel out irp */
218 r8712_usb_write_port_cancel(padapter);
219 /* TODO:cancel other irps */
220}
221
222void r871x_dev_unload(struct _adapter *padapter)
223{
224 if (padapter->bup == true) {
225 /*s1.*/
226 padapter->bDriverStopped = true;
227
228 /*s3.*/
229 rtl871x_intf_stop(padapter);
230
231 /*s4.*/
232 r8712_stop_drv_threads(padapter);
233
234 /*s5.*/
235 if (padapter->bSurpriseRemoved == false) {
236 padapter->hw_init_completed = false;
237 rtl8712_hal_deinit(padapter);
238 }
239
240 /*s6.*/
241 if (padapter->dvobj_deinit)
242 padapter->dvobj_deinit(padapter);
243 padapter->bup = false;
244 }
245}
246
247static void disable_ht_for_spec_devid(const struct usb_device_id *pdid,
248 struct _adapter *padapter)
249{
250 u16 vid, pid;
251 u32 flags;
252 int i;
253 int num = sizeof(specific_device_id_tbl) /
254 sizeof(struct specific_device_id);
255
256 for (i = 0; i < num; i++) {
257 vid = specific_device_id_tbl[i].idVendor;
258 pid = specific_device_id_tbl[i].idProduct;
259 flags = specific_device_id_tbl[i].flags;
260
261 if ((pdid->idVendor == vid) && (pdid->idProduct == pid) &&
262 (flags&SPEC_DEV_ID_DISABLE_HT)) {
263 padapter->registrypriv.ht_enable = 0;
264 padapter->registrypriv.cbw40_enable = 0;
265 padapter->registrypriv.ampdu_enable = 0;
266 }
267 }
268}
269
270static u8 key_2char2num(u8 hch, u8 lch)
271{
272 return (hex_to_bin(hch) << 4) | hex_to_bin(lch);
273}
274
275/*
276 * drv_init() - a device potentially for us
277 *
278 * notes: drv_init() is called when the bus driver has located a card for us
279 * to support. We accept the new device by returning 0.
280*/
281static int r871xu_drv_init(struct usb_interface *pusb_intf,
282 const struct usb_device_id *pdid)
283{
284 uint status;
285 struct _adapter *padapter = NULL;
286 struct dvobj_priv *pdvobjpriv;
287 struct net_device *pnetdev;
288
289 printk(KERN_INFO "r8712u: DriverVersion: %s\n", DRVER);
290 /* In this probe function, O.S. will provide the usb interface pointer
291 * to driver. We have to increase the reference count of the usb device
292 * structure by using the usb_get_dev function.
293 */
294 usb_get_dev(interface_to_usbdev(pusb_intf));
295 pintf = pusb_intf;
296 /* step 1. */
297 pnetdev = r8712_init_netdev();
298 if (!pnetdev)
299 goto error;
300 padapter = (struct _adapter *)_netdev_priv(pnetdev);
301 disable_ht_for_spec_devid(pdid, padapter);
302 pdvobjpriv = &padapter->dvobjpriv;
303 pdvobjpriv->padapter = padapter;
304 padapter->dvobjpriv.pusbdev = interface_to_usbdev(pusb_intf);
305 usb_set_intfdata(pusb_intf, pnetdev);
306 SET_NETDEV_DEV(pnetdev, &pusb_intf->dev);
307 /* step 2. */
308 padapter->dvobj_init = &r8712_usb_dvobj_init;
309 padapter->dvobj_deinit = &r8712_usb_dvobj_deinit;
310 padapter->halpriv.hal_bus_init = &r8712_usb_hal_bus_init;
311 padapter->dvobjpriv.inirp_init = &r8712_usb_inirp_init;
312 padapter->dvobjpriv.inirp_deinit = &r8712_usb_inirp_deinit;
313 /* step 3.
314 * initialize the dvobj_priv
315 */
316 if (padapter->dvobj_init == NULL)
317 goto error;
318 else {
319 status = padapter->dvobj_init(padapter);
320 if (status != _SUCCESS)
321 goto error;
322 }
323 /* step 4. */
324 status = r8712_init_drv_sw(padapter);
325 if (status == _FAIL)
326 goto error;
327 /* step 5. read efuse/eeprom data and get mac_addr */
328 {
329 int i, offset;
330 u8 mac[6];
331 u8 tmpU1b, AutoloadFail, eeprom_CustomerID;
332 u8 *pdata = padapter->eeprompriv.efuse_eeprom_data;
333
334 tmpU1b = r8712_read8(padapter, EE_9346CR);/*CR9346*/
335
336 /* To check system boot selection.*/
337 printk(KERN_INFO "r8712u: Boot from %s: Autoload %s\n",
338 (tmpU1b & _9356SEL) ? "EEPROM" : "EFUSE",
339 (tmpU1b & _EEPROM_EN) ? "OK" : "Failed");
340
341 /* To check autoload success or not.*/
342 if (tmpU1b & _EEPROM_EN) {
343 AutoloadFail = true;
344 /* The following operations prevent Efuse leakage by
345 * turning on 2.5V.
346 */
347 tmpU1b = r8712_read8(padapter, EFUSE_TEST+3);
348 r8712_write8(padapter, EFUSE_TEST + 3, tmpU1b | 0x80);
349 msleep(20);
350 r8712_write8(padapter, EFUSE_TEST + 3,
351 (tmpU1b & (~BIT(7))));
352
353 /* Retrieve Chip version.
354 * Recognize IC version by Reg0x4 BIT15.
355 */
356 tmpU1b = (u8)((r8712_read32(padapter, PMC_FSM) >> 15) &
357 0x1F);
358 if (tmpU1b == 0x3)
359 padapter->registrypriv.chip_version =
360 RTL8712_3rdCUT;
361 else
362 padapter->registrypriv.chip_version =
363 (tmpU1b >> 1) + 1;
364 switch (padapter->registrypriv.chip_version) {
365 case RTL8712_1stCUT:
366 case RTL8712_2ndCUT:
367 case RTL8712_3rdCUT:
368 break;
369 default:
370 padapter->registrypriv.chip_version =
371 RTL8712_2ndCUT;
372 break;
373 }
374
375 for (i = 0, offset = 0; i < 128; i += 8, offset++)
376 r8712_efuse_pg_packet_read(padapter, offset,
377 &pdata[i]);
378
379 if (r8712_initmac) {
380 /* Users specify the mac address */
381 int jj, kk;
382
383 for (jj = 0, kk = 0; jj < ETH_ALEN;
384 jj++, kk += 3)
385 mac[jj] =
386 key_2char2num(r8712_initmac[kk],
387 r8712_initmac[kk + 1]);
388 } else {
389 /* Use the mac address stored in the Efuse
390 * offset = 0x12 for usb in efuse
391 */
392 memcpy(mac, &pdata[0x12], ETH_ALEN);
393 }
394 eeprom_CustomerID = pdata[0x52];
395 switch (eeprom_CustomerID) {
396 case EEPROM_CID_ALPHA:
397 padapter->eeprompriv.CustomerID =
398 RT_CID_819x_ALPHA;
399 break;
400 case EEPROM_CID_CAMEO:
401 padapter->eeprompriv.CustomerID =
402 RT_CID_819x_CAMEO;
403 break;
404 case EEPROM_CID_SITECOM:
405 padapter->eeprompriv.CustomerID =
406 RT_CID_819x_Sitecom;
407 break;
408 case EEPROM_CID_COREGA:
409 padapter->eeprompriv.CustomerID =
410 RT_CID_COREGA;
411 break;
412 case EEPROM_CID_Senao:
413 padapter->eeprompriv.CustomerID =
414 RT_CID_819x_Senao;
415 break;
416 case EEPROM_CID_EDIMAX_BELKIN:
417 padapter->eeprompriv.CustomerID =
418 RT_CID_819x_Edimax_Belkin;
419 break;
420 case EEPROM_CID_SERCOMM_BELKIN:
421 padapter->eeprompriv.CustomerID =
422 RT_CID_819x_Sercomm_Belkin;
423 break;
424 case EEPROM_CID_WNC_COREGA:
425 padapter->eeprompriv.CustomerID =
426 RT_CID_819x_WNC_COREGA;
427 break;
428 case EEPROM_CID_WHQL:
429 break;
430 case EEPROM_CID_NetCore:
431 padapter->eeprompriv.CustomerID =
432 RT_CID_819x_Netcore;
433 break;
434 case EEPROM_CID_CAMEO1:
435 padapter->eeprompriv.CustomerID =
436 RT_CID_819x_CAMEO1;
437 break;
438 case EEPROM_CID_CLEVO:
439 padapter->eeprompriv.CustomerID =
440 RT_CID_819x_CLEVO;
441 break;
442 default:
443 padapter->eeprompriv.CustomerID =
444 RT_CID_DEFAULT;
445 break;
446 }
447 printk(KERN_INFO "r8712u: CustomerID = 0x%.4x\n",
448 padapter->eeprompriv.CustomerID);
449 /* Led mode */
450 switch (padapter->eeprompriv.CustomerID) {
451 case RT_CID_DEFAULT:
452 case RT_CID_819x_ALPHA:
453 case RT_CID_819x_CAMEO:
454 padapter->ledpriv.LedStrategy = SW_LED_MODE1;
455 padapter->ledpriv.bRegUseLed = true;
456 break;
457 case RT_CID_819x_Sitecom:
458 padapter->ledpriv.LedStrategy = SW_LED_MODE2;
459 padapter->ledpriv.bRegUseLed = true;
460 break;
461 case RT_CID_COREGA:
462 case RT_CID_819x_Senao:
463 padapter->ledpriv.LedStrategy = SW_LED_MODE3;
464 padapter->ledpriv.bRegUseLed = true;
465 break;
466 case RT_CID_819x_Edimax_Belkin:
467 padapter->ledpriv.LedStrategy = SW_LED_MODE4;
468 padapter->ledpriv.bRegUseLed = true;
469 break;
470 case RT_CID_819x_Sercomm_Belkin:
471 padapter->ledpriv.LedStrategy = SW_LED_MODE5;
472 padapter->ledpriv.bRegUseLed = true;
473 break;
474 case RT_CID_819x_WNC_COREGA:
475 padapter->ledpriv.LedStrategy = SW_LED_MODE6;
476 padapter->ledpriv.bRegUseLed = true;
477 break;
478 default:
479 padapter->ledpriv.LedStrategy = SW_LED_MODE0;
480 padapter->ledpriv.bRegUseLed = false;
481 break;
482 }
483 } else
484 AutoloadFail = false;
485 if (((mac[0] == 0xff) && (mac[1] == 0xff) &&
486 (mac[2] == 0xff) && (mac[3] == 0xff) &&
487 (mac[4] == 0xff) && (mac[5] == 0xff)) ||
488 ((mac[0] == 0x00) && (mac[1] == 0x00) &&
489 (mac[2] == 0x00) && (mac[3] == 0x00) &&
490 (mac[4] == 0x00) && (mac[5] == 0x00)) ||
491 (AutoloadFail == false)) {
492 mac[0] = 0x00;
493 mac[1] = 0xe0;
494 mac[2] = 0x4c;
495 mac[3] = 0x87;
496 mac[4] = 0x00;
497 mac[5] = 0x00;
498 }
499 if (r8712_initmac) {
500 /* Make sure the user did not select a multicast
501 * address by setting bit 1 of first octet.
502 */
503 mac[0] &= 0xFE;
504 printk(KERN_INFO "r8712u: MAC Address from user = "
505 "%pM\n", mac);
506 } else
507 printk(KERN_INFO "r8712u: MAC Address from efuse = "
508 "%pM\n", mac);
509 memcpy(pnetdev->dev_addr, mac, ETH_ALEN);
510 }
511 /* step 6. Tell the network stack we exist */
512 if (register_netdev(pnetdev) != 0)
513 goto error;
514 return 0;
515error:
516 usb_put_dev(interface_to_usbdev(pusb_intf));
517 usb_set_intfdata(pusb_intf, NULL);
518 if (padapter->dvobj_deinit != NULL)
519 padapter->dvobj_deinit(padapter);
520 if (pnetdev)
521 os_free_netdev(pnetdev);
522 return -ENODEV;
523}
524
525/* rmmod module & unplug(SurpriseRemoved) will call r871xu_dev_remove()
526 * => how to recognize both */
527static void r871xu_dev_remove(struct usb_interface *pusb_intf)
528{
529 struct net_device *pnetdev = usb_get_intfdata(pusb_intf);
530 struct _adapter *padapter = (struct _adapter *)netdev_priv(pnetdev);
531 struct usb_device *udev = interface_to_usbdev(pusb_intf);
532
533 if (padapter) {
534 if (drvpriv.drv_registered == true)
535 padapter->bSurpriseRemoved = true;
536 if (pnetdev != NULL) {
537 /* will call netdev_close() */
538 unregister_netdev(pnetdev);
539 }
540 flush_scheduled_work();
541 udelay(1);
542 r871x_dev_unload(padapter);
543 r8712_free_drv_sw(padapter);
544 }
545 usb_set_intfdata(pusb_intf, NULL);
546 /* decrease the reference count of the usb device structure
547 * when disconnect */
548 usb_put_dev(udev);
549 /* If we didn't unplug usb dongle and remove/insert modlue, driver
550 * fails on sitesurvey for the first time when device is up.
551 * Reset usb port for sitesurvey fail issue. */
552 if (udev->state != USB_STATE_NOTATTACHED)
553 usb_reset_device(udev);
554 return;
555}
556
557static int __init r8712u_drv_entry(void)
558{
559 drvpriv.drv_registered = true;
560 return usb_register(&drvpriv.r871xu_drv);
561}
562
563static void __exit r8712u_drv_halt(void)
564{
565 drvpriv.drv_registered = false;
566 usb_deregister(&drvpriv.r871xu_drv);
567 printk(KERN_INFO "r8712u: Driver unloaded\n");
568}
569
570module_init(r8712u_drv_entry);
571module_exit(r8712u_drv_halt);
ubuntu-bionic-kernel mirror