dhd_linux.c 28 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189
  1. /*
  2. * Copyright (c) 2010 Broadcom Corporation
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for any
  5. * purpose with or without fee is hereby granted, provided that the above
  6. * copyright notice and this permission notice appear in all copies.
  7. *
  8. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  9. * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10. * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11. * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12. * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13. * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14. * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15. */
  16. #include <linux/init.h>
  17. #include <linux/kernel.h>
  18. #include <linux/kthread.h>
  19. #include <linux/slab.h>
  20. #include <linux/skbuff.h>
  21. #include <linux/netdevice.h>
  22. #include <linux/etherdevice.h>
  23. #include <linux/mmc/sdio_func.h>
  24. #include <linux/random.h>
  25. #include <linux/spinlock.h>
  26. #include <linux/ethtool.h>
  27. #include <linux/fcntl.h>
  28. #include <linux/fs.h>
  29. #include <linux/uaccess.h>
  30. #include <linux/hardirq.h>
  31. #include <linux/mutex.h>
  32. #include <linux/wait.h>
  33. #include <linux/module.h>
  34. #include <net/cfg80211.h>
  35. #include <net/rtnetlink.h>
  36. #include <defs.h>
  37. #include <brcmu_utils.h>
  38. #include <brcmu_wifi.h>
  39. #include "dhd.h"
  40. #include "dhd_bus.h"
  41. #include "dhd_proto.h"
  42. #include "dhd_dbg.h"
  43. #include "wl_cfg80211.h"
  44. MODULE_AUTHOR("Broadcom Corporation");
  45. MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN fullmac driver.");
  46. MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN fullmac cards");
  47. MODULE_LICENSE("Dual BSD/GPL");
  48. /* Interface control information */
  49. struct brcmf_if {
  50. struct brcmf_pub *drvr; /* back pointer to brcmf_pub */
  51. /* OS/stack specifics */
  52. struct net_device *ndev;
  53. struct net_device_stats stats;
  54. int idx; /* iface idx in dongle */
  55. u8 mac_addr[ETH_ALEN]; /* assigned MAC address */
  56. };
  57. /* Error bits */
  58. int brcmf_msg_level = BRCMF_ERROR_VAL;
  59. module_param(brcmf_msg_level, int, 0);
  60. int brcmf_ifname2idx(struct brcmf_pub *drvr, char *name)
  61. {
  62. int i = BRCMF_MAX_IFS;
  63. struct brcmf_if *ifp;
  64. if (name == NULL || *name == '\0')
  65. return 0;
  66. while (--i > 0) {
  67. ifp = drvr->iflist[i];
  68. if (ifp && !strncmp(ifp->ndev->name, name, IFNAMSIZ))
  69. break;
  70. }
  71. brcmf_dbg(TRACE, "return idx %d for \"%s\"\n", i, name);
  72. return i; /* default - the primary interface */
  73. }
  74. char *brcmf_ifname(struct brcmf_pub *drvr, int ifidx)
  75. {
  76. if (ifidx < 0 || ifidx >= BRCMF_MAX_IFS) {
  77. brcmf_dbg(ERROR, "ifidx %d out of range\n", ifidx);
  78. return "<if_bad>";
  79. }
  80. if (drvr->iflist[ifidx] == NULL) {
  81. brcmf_dbg(ERROR, "null i/f %d\n", ifidx);
  82. return "<if_null>";
  83. }
  84. if (drvr->iflist[ifidx]->ndev)
  85. return drvr->iflist[ifidx]->ndev->name;
  86. return "<if_none>";
  87. }
  88. static void _brcmf_set_multicast_list(struct work_struct *work)
  89. {
  90. struct net_device *ndev;
  91. struct netdev_hw_addr *ha;
  92. u32 dcmd_value, cnt;
  93. __le32 cnt_le;
  94. __le32 dcmd_le_value;
  95. struct brcmf_dcmd dcmd;
  96. char *buf, *bufp;
  97. uint buflen;
  98. int ret;
  99. struct brcmf_pub *drvr = container_of(work, struct brcmf_pub,
  100. multicast_work);
  101. ndev = drvr->iflist[0]->ndev;
  102. cnt = netdev_mc_count(ndev);
  103. /* Determine initial value of allmulti flag */
  104. dcmd_value = (ndev->flags & IFF_ALLMULTI) ? true : false;
  105. /* Send down the multicast list first. */
  106. buflen = sizeof("mcast_list") + sizeof(cnt) + (cnt * ETH_ALEN);
  107. bufp = buf = kmalloc(buflen, GFP_ATOMIC);
  108. if (!bufp)
  109. return;
  110. strcpy(bufp, "mcast_list");
  111. bufp += strlen("mcast_list") + 1;
  112. cnt_le = cpu_to_le32(cnt);
  113. memcpy(bufp, &cnt_le, sizeof(cnt));
  114. bufp += sizeof(cnt_le);
  115. netdev_for_each_mc_addr(ha, ndev) {
  116. if (!cnt)
  117. break;
  118. memcpy(bufp, ha->addr, ETH_ALEN);
  119. bufp += ETH_ALEN;
  120. cnt--;
  121. }
  122. memset(&dcmd, 0, sizeof(dcmd));
  123. dcmd.cmd = BRCMF_C_SET_VAR;
  124. dcmd.buf = buf;
  125. dcmd.len = buflen;
  126. dcmd.set = true;
  127. ret = brcmf_proto_dcmd(drvr, 0, &dcmd, dcmd.len);
  128. if (ret < 0) {
  129. brcmf_dbg(ERROR, "%s: set mcast_list failed, cnt %d\n",
  130. brcmf_ifname(drvr, 0), cnt);
  131. dcmd_value = cnt ? true : dcmd_value;
  132. }
  133. kfree(buf);
  134. /* Now send the allmulti setting. This is based on the setting in the
  135. * net_device flags, but might be modified above to be turned on if we
  136. * were trying to set some addresses and dongle rejected it...
  137. */
  138. buflen = sizeof("allmulti") + sizeof(dcmd_value);
  139. buf = kmalloc(buflen, GFP_ATOMIC);
  140. if (!buf)
  141. return;
  142. dcmd_le_value = cpu_to_le32(dcmd_value);
  143. if (!brcmf_c_mkiovar
  144. ("allmulti", (void *)&dcmd_le_value,
  145. sizeof(dcmd_le_value), buf, buflen)) {
  146. brcmf_dbg(ERROR, "%s: mkiovar failed for allmulti, datalen %d buflen %u\n",
  147. brcmf_ifname(drvr, 0),
  148. (int)sizeof(dcmd_value), buflen);
  149. kfree(buf);
  150. return;
  151. }
  152. memset(&dcmd, 0, sizeof(dcmd));
  153. dcmd.cmd = BRCMF_C_SET_VAR;
  154. dcmd.buf = buf;
  155. dcmd.len = buflen;
  156. dcmd.set = true;
  157. ret = brcmf_proto_dcmd(drvr, 0, &dcmd, dcmd.len);
  158. if (ret < 0) {
  159. brcmf_dbg(ERROR, "%s: set allmulti %d failed\n",
  160. brcmf_ifname(drvr, 0),
  161. le32_to_cpu(dcmd_le_value));
  162. }
  163. kfree(buf);
  164. /* Finally, pick up the PROMISC flag as well, like the NIC
  165. driver does */
  166. dcmd_value = (ndev->flags & IFF_PROMISC) ? true : false;
  167. dcmd_le_value = cpu_to_le32(dcmd_value);
  168. memset(&dcmd, 0, sizeof(dcmd));
  169. dcmd.cmd = BRCMF_C_SET_PROMISC;
  170. dcmd.buf = &dcmd_le_value;
  171. dcmd.len = sizeof(dcmd_le_value);
  172. dcmd.set = true;
  173. ret = brcmf_proto_dcmd(drvr, 0, &dcmd, dcmd.len);
  174. if (ret < 0) {
  175. brcmf_dbg(ERROR, "%s: set promisc %d failed\n",
  176. brcmf_ifname(drvr, 0),
  177. le32_to_cpu(dcmd_le_value));
  178. }
  179. }
  180. static void
  181. _brcmf_set_mac_address(struct work_struct *work)
  182. {
  183. char buf[32];
  184. struct brcmf_dcmd dcmd;
  185. int ret;
  186. struct brcmf_pub *drvr = container_of(work, struct brcmf_pub,
  187. setmacaddr_work);
  188. brcmf_dbg(TRACE, "enter\n");
  189. if (!brcmf_c_mkiovar("cur_etheraddr", (char *)drvr->macvalue,
  190. ETH_ALEN, buf, 32)) {
  191. brcmf_dbg(ERROR, "%s: mkiovar failed for cur_etheraddr\n",
  192. brcmf_ifname(drvr, 0));
  193. return;
  194. }
  195. memset(&dcmd, 0, sizeof(dcmd));
  196. dcmd.cmd = BRCMF_C_SET_VAR;
  197. dcmd.buf = buf;
  198. dcmd.len = 32;
  199. dcmd.set = true;
  200. ret = brcmf_proto_dcmd(drvr, 0, &dcmd, dcmd.len);
  201. if (ret < 0)
  202. brcmf_dbg(ERROR, "%s: set cur_etheraddr failed\n",
  203. brcmf_ifname(drvr, 0));
  204. else
  205. memcpy(drvr->iflist[0]->ndev->dev_addr,
  206. drvr->macvalue, ETH_ALEN);
  207. return;
  208. }
  209. static int brcmf_netdev_set_mac_address(struct net_device *ndev, void *addr)
  210. {
  211. struct brcmf_if *ifp = netdev_priv(ndev);
  212. struct brcmf_pub *drvr = ifp->drvr;
  213. struct sockaddr *sa = (struct sockaddr *)addr;
  214. memcpy(&drvr->macvalue, sa->sa_data, ETH_ALEN);
  215. schedule_work(&drvr->setmacaddr_work);
  216. return 0;
  217. }
  218. static void brcmf_netdev_set_multicast_list(struct net_device *ndev)
  219. {
  220. struct brcmf_if *ifp = netdev_priv(ndev);
  221. struct brcmf_pub *drvr = ifp->drvr;
  222. schedule_work(&drvr->multicast_work);
  223. }
  224. int brcmf_sendpkt(struct brcmf_pub *drvr, int ifidx, struct sk_buff *pktbuf)
  225. {
  226. /* Reject if down */
  227. if (!drvr->up || (drvr->bus_if->state == BRCMF_BUS_DOWN))
  228. return -ENODEV;
  229. /* Update multicast statistic */
  230. if (pktbuf->len >= ETH_ALEN) {
  231. u8 *pktdata = (u8 *) (pktbuf->data);
  232. struct ethhdr *eh = (struct ethhdr *)pktdata;
  233. if (is_multicast_ether_addr(eh->h_dest))
  234. drvr->tx_multicast++;
  235. if (ntohs(eh->h_proto) == ETH_P_PAE)
  236. atomic_inc(&drvr->pend_8021x_cnt);
  237. }
  238. /* If the protocol uses a data header, apply it */
  239. brcmf_proto_hdrpush(drvr, ifidx, pktbuf);
  240. /* Use bus module to send data frame */
  241. return brcmf_sdbrcm_bus_txdata(drvr->dev, pktbuf);
  242. }
  243. static int brcmf_netdev_start_xmit(struct sk_buff *skb, struct net_device *ndev)
  244. {
  245. int ret;
  246. struct brcmf_if *ifp = netdev_priv(ndev);
  247. struct brcmf_pub *drvr = ifp->drvr;
  248. brcmf_dbg(TRACE, "Enter\n");
  249. /* Reject if down */
  250. if (!drvr->up ||
  251. (drvr->bus_if->state == BRCMF_BUS_DOWN)) {
  252. brcmf_dbg(ERROR, "xmit rejected pub.up=%d state=%d\n",
  253. drvr->up,
  254. drvr->bus_if->state);
  255. netif_stop_queue(ndev);
  256. return -ENODEV;
  257. }
  258. if (!drvr->iflist[ifp->idx]) {
  259. brcmf_dbg(ERROR, "bad ifidx %d\n", ifp->idx);
  260. netif_stop_queue(ndev);
  261. return -ENODEV;
  262. }
  263. /* Make sure there's enough room for any header */
  264. if (skb_headroom(skb) < drvr->hdrlen) {
  265. struct sk_buff *skb2;
  266. brcmf_dbg(INFO, "%s: insufficient headroom\n",
  267. brcmf_ifname(drvr, ifp->idx));
  268. drvr->tx_realloc++;
  269. skb2 = skb_realloc_headroom(skb, drvr->hdrlen);
  270. dev_kfree_skb(skb);
  271. skb = skb2;
  272. if (skb == NULL) {
  273. brcmf_dbg(ERROR, "%s: skb_realloc_headroom failed\n",
  274. brcmf_ifname(drvr, ifp->idx));
  275. ret = -ENOMEM;
  276. goto done;
  277. }
  278. }
  279. ret = brcmf_sendpkt(drvr, ifp->idx, skb);
  280. done:
  281. if (ret)
  282. drvr->dstats.tx_dropped++;
  283. else
  284. drvr->tx_packets++;
  285. /* Return ok: we always eat the packet */
  286. return 0;
  287. }
  288. void brcmf_txflowcontrol(struct device *dev, int ifidx, bool state)
  289. {
  290. struct net_device *ndev;
  291. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  292. struct brcmf_pub *drvr = bus_if->drvr;
  293. brcmf_dbg(TRACE, "Enter\n");
  294. drvr->txoff = state;
  295. ndev = drvr->iflist[ifidx]->ndev;
  296. if (state == ON)
  297. netif_stop_queue(ndev);
  298. else
  299. netif_wake_queue(ndev);
  300. }
  301. static int brcmf_host_event(struct brcmf_pub *drvr, int *ifidx,
  302. void *pktdata, struct brcmf_event_msg *event,
  303. void **data)
  304. {
  305. int bcmerror = 0;
  306. bcmerror = brcmf_c_host_event(drvr, ifidx, pktdata, event, data);
  307. if (bcmerror != 0)
  308. return bcmerror;
  309. if (drvr->iflist[*ifidx]->ndev)
  310. brcmf_cfg80211_event(drvr->iflist[*ifidx]->ndev,
  311. event, *data);
  312. return bcmerror;
  313. }
  314. void brcmf_rx_frame(struct device *dev, int ifidx,
  315. struct sk_buff_head *skb_list)
  316. {
  317. unsigned char *eth;
  318. uint len;
  319. void *data;
  320. struct sk_buff *skb, *pnext;
  321. struct brcmf_if *ifp;
  322. struct brcmf_event_msg event;
  323. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  324. struct brcmf_pub *drvr = bus_if->drvr;
  325. brcmf_dbg(TRACE, "Enter\n");
  326. skb_queue_walk_safe(skb_list, skb, pnext) {
  327. skb_unlink(skb, skb_list);
  328. /* Get the protocol, maintain skb around eth_type_trans()
  329. * The main reason for this hack is for the limitation of
  330. * Linux 2.4 where 'eth_type_trans' uses the
  331. * 'net->hard_header_len'
  332. * to perform skb_pull inside vs ETH_HLEN. Since to avoid
  333. * coping of the packet coming from the network stack to add
  334. * BDC, Hardware header etc, during network interface
  335. * registration
  336. * we set the 'net->hard_header_len' to ETH_HLEN + extra space
  337. * required
  338. * for BDC, Hardware header etc. and not just the ETH_HLEN
  339. */
  340. eth = skb->data;
  341. len = skb->len;
  342. ifp = drvr->iflist[ifidx];
  343. if (ifp == NULL)
  344. ifp = drvr->iflist[0];
  345. if (!ifp || !ifp->ndev ||
  346. ifp->ndev->reg_state != NETREG_REGISTERED) {
  347. brcmu_pkt_buf_free_skb(skb);
  348. continue;
  349. }
  350. skb->dev = ifp->ndev;
  351. skb->protocol = eth_type_trans(skb, skb->dev);
  352. if (skb->pkt_type == PACKET_MULTICAST)
  353. drvr->rx_multicast++;
  354. skb->data = eth;
  355. skb->len = len;
  356. /* Strip header, count, deliver upward */
  357. skb_pull(skb, ETH_HLEN);
  358. /* Process special event packets and then discard them */
  359. if (ntohs(skb->protocol) == ETH_P_LINK_CTL)
  360. brcmf_host_event(drvr, &ifidx,
  361. skb_mac_header(skb),
  362. &event, &data);
  363. if (drvr->iflist[ifidx]) {
  364. ifp = drvr->iflist[ifidx];
  365. ifp->ndev->last_rx = jiffies;
  366. }
  367. drvr->dstats.rx_bytes += skb->len;
  368. drvr->rx_packets++; /* Local count */
  369. if (in_interrupt())
  370. netif_rx(skb);
  371. else
  372. /* If the receive is not processed inside an ISR,
  373. * the softirqd must be woken explicitly to service
  374. * the NET_RX_SOFTIRQ. In 2.6 kernels, this is handled
  375. * by netif_rx_ni(), but in earlier kernels, we need
  376. * to do it manually.
  377. */
  378. netif_rx_ni(skb);
  379. }
  380. }
  381. void brcmf_txcomplete(struct device *dev, struct sk_buff *txp, bool success)
  382. {
  383. uint ifidx;
  384. struct ethhdr *eh;
  385. u16 type;
  386. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  387. struct brcmf_pub *drvr = bus_if->drvr;
  388. brcmf_proto_hdrpull(drvr, &ifidx, txp);
  389. eh = (struct ethhdr *)(txp->data);
  390. type = ntohs(eh->h_proto);
  391. if (type == ETH_P_PAE)
  392. atomic_dec(&drvr->pend_8021x_cnt);
  393. }
  394. static struct net_device_stats *brcmf_netdev_get_stats(struct net_device *ndev)
  395. {
  396. struct brcmf_if *ifp = netdev_priv(ndev);
  397. struct brcmf_pub *drvr = ifp->drvr;
  398. brcmf_dbg(TRACE, "Enter\n");
  399. if (drvr->up)
  400. /* Use the protocol to get dongle stats */
  401. brcmf_proto_dstats(drvr);
  402. /* Copy dongle stats to net device stats */
  403. ifp->stats.rx_packets = drvr->dstats.rx_packets;
  404. ifp->stats.tx_packets = drvr->dstats.tx_packets;
  405. ifp->stats.rx_bytes = drvr->dstats.rx_bytes;
  406. ifp->stats.tx_bytes = drvr->dstats.tx_bytes;
  407. ifp->stats.rx_errors = drvr->dstats.rx_errors;
  408. ifp->stats.tx_errors = drvr->dstats.tx_errors;
  409. ifp->stats.rx_dropped = drvr->dstats.rx_dropped;
  410. ifp->stats.tx_dropped = drvr->dstats.tx_dropped;
  411. ifp->stats.multicast = drvr->dstats.multicast;
  412. return &ifp->stats;
  413. }
  414. /* Retrieve current toe component enables, which are kept
  415. as a bitmap in toe_ol iovar */
  416. static int brcmf_toe_get(struct brcmf_pub *drvr, int ifidx, u32 *toe_ol)
  417. {
  418. struct brcmf_dcmd dcmd;
  419. __le32 toe_le;
  420. char buf[32];
  421. int ret;
  422. memset(&dcmd, 0, sizeof(dcmd));
  423. dcmd.cmd = BRCMF_C_GET_VAR;
  424. dcmd.buf = buf;
  425. dcmd.len = (uint) sizeof(buf);
  426. dcmd.set = false;
  427. strcpy(buf, "toe_ol");
  428. ret = brcmf_proto_dcmd(drvr, ifidx, &dcmd, dcmd.len);
  429. if (ret < 0) {
  430. /* Check for older dongle image that doesn't support toe_ol */
  431. if (ret == -EIO) {
  432. brcmf_dbg(ERROR, "%s: toe not supported by device\n",
  433. brcmf_ifname(drvr, ifidx));
  434. return -EOPNOTSUPP;
  435. }
  436. brcmf_dbg(INFO, "%s: could not get toe_ol: ret=%d\n",
  437. brcmf_ifname(drvr, ifidx), ret);
  438. return ret;
  439. }
  440. memcpy(&toe_le, buf, sizeof(u32));
  441. *toe_ol = le32_to_cpu(toe_le);
  442. return 0;
  443. }
  444. /* Set current toe component enables in toe_ol iovar,
  445. and set toe global enable iovar */
  446. static int brcmf_toe_set(struct brcmf_pub *drvr, int ifidx, u32 toe_ol)
  447. {
  448. struct brcmf_dcmd dcmd;
  449. char buf[32];
  450. int ret;
  451. __le32 toe_le = cpu_to_le32(toe_ol);
  452. memset(&dcmd, 0, sizeof(dcmd));
  453. dcmd.cmd = BRCMF_C_SET_VAR;
  454. dcmd.buf = buf;
  455. dcmd.len = (uint) sizeof(buf);
  456. dcmd.set = true;
  457. /* Set toe_ol as requested */
  458. strcpy(buf, "toe_ol");
  459. memcpy(&buf[sizeof("toe_ol")], &toe_le, sizeof(u32));
  460. ret = brcmf_proto_dcmd(drvr, ifidx, &dcmd, dcmd.len);
  461. if (ret < 0) {
  462. brcmf_dbg(ERROR, "%s: could not set toe_ol: ret=%d\n",
  463. brcmf_ifname(drvr, ifidx), ret);
  464. return ret;
  465. }
  466. /* Enable toe globally only if any components are enabled. */
  467. toe_le = cpu_to_le32(toe_ol != 0);
  468. strcpy(buf, "toe");
  469. memcpy(&buf[sizeof("toe")], &toe_le, sizeof(u32));
  470. ret = brcmf_proto_dcmd(drvr, ifidx, &dcmd, dcmd.len);
  471. if (ret < 0) {
  472. brcmf_dbg(ERROR, "%s: could not set toe: ret=%d\n",
  473. brcmf_ifname(drvr, ifidx), ret);
  474. return ret;
  475. }
  476. return 0;
  477. }
  478. static void brcmf_ethtool_get_drvinfo(struct net_device *ndev,
  479. struct ethtool_drvinfo *info)
  480. {
  481. struct brcmf_if *ifp = netdev_priv(ndev);
  482. struct brcmf_pub *drvr = ifp->drvr;
  483. sprintf(info->driver, KBUILD_MODNAME);
  484. sprintf(info->version, "%lu", drvr->drv_version);
  485. sprintf(info->bus_info, "%s", dev_name(drvr->dev));
  486. }
  487. static struct ethtool_ops brcmf_ethtool_ops = {
  488. .get_drvinfo = brcmf_ethtool_get_drvinfo
  489. };
  490. static int brcmf_ethtool(struct brcmf_pub *drvr, void __user *uaddr)
  491. {
  492. struct ethtool_drvinfo info;
  493. char drvname[sizeof(info.driver)];
  494. u32 cmd;
  495. struct ethtool_value edata;
  496. u32 toe_cmpnt, csum_dir;
  497. int ret;
  498. brcmf_dbg(TRACE, "Enter\n");
  499. /* all ethtool calls start with a cmd word */
  500. if (copy_from_user(&cmd, uaddr, sizeof(u32)))
  501. return -EFAULT;
  502. switch (cmd) {
  503. case ETHTOOL_GDRVINFO:
  504. /* Copy out any request driver name */
  505. if (copy_from_user(&info, uaddr, sizeof(info)))
  506. return -EFAULT;
  507. strncpy(drvname, info.driver, sizeof(info.driver));
  508. drvname[sizeof(info.driver) - 1] = '\0';
  509. /* clear struct for return */
  510. memset(&info, 0, sizeof(info));
  511. info.cmd = cmd;
  512. /* if requested, identify ourselves */
  513. if (strcmp(drvname, "?dhd") == 0) {
  514. sprintf(info.driver, "dhd");
  515. strcpy(info.version, BRCMF_VERSION_STR);
  516. }
  517. /* otherwise, require dongle to be up */
  518. else if (!drvr->up) {
  519. brcmf_dbg(ERROR, "dongle is not up\n");
  520. return -ENODEV;
  521. }
  522. /* finally, report dongle driver type */
  523. else if (drvr->iswl)
  524. sprintf(info.driver, "wl");
  525. else
  526. sprintf(info.driver, "xx");
  527. sprintf(info.version, "%lu", drvr->drv_version);
  528. if (copy_to_user(uaddr, &info, sizeof(info)))
  529. return -EFAULT;
  530. brcmf_dbg(CTL, "given %*s, returning %s\n",
  531. (int)sizeof(drvname), drvname, info.driver);
  532. break;
  533. /* Get toe offload components from dongle */
  534. case ETHTOOL_GRXCSUM:
  535. case ETHTOOL_GTXCSUM:
  536. ret = brcmf_toe_get(drvr, 0, &toe_cmpnt);
  537. if (ret < 0)
  538. return ret;
  539. csum_dir =
  540. (cmd == ETHTOOL_GTXCSUM) ? TOE_TX_CSUM_OL : TOE_RX_CSUM_OL;
  541. edata.cmd = cmd;
  542. edata.data = (toe_cmpnt & csum_dir) ? 1 : 0;
  543. if (copy_to_user(uaddr, &edata, sizeof(edata)))
  544. return -EFAULT;
  545. break;
  546. /* Set toe offload components in dongle */
  547. case ETHTOOL_SRXCSUM:
  548. case ETHTOOL_STXCSUM:
  549. if (copy_from_user(&edata, uaddr, sizeof(edata)))
  550. return -EFAULT;
  551. /* Read the current settings, update and write back */
  552. ret = brcmf_toe_get(drvr, 0, &toe_cmpnt);
  553. if (ret < 0)
  554. return ret;
  555. csum_dir =
  556. (cmd == ETHTOOL_STXCSUM) ? TOE_TX_CSUM_OL : TOE_RX_CSUM_OL;
  557. if (edata.data != 0)
  558. toe_cmpnt |= csum_dir;
  559. else
  560. toe_cmpnt &= ~csum_dir;
  561. ret = brcmf_toe_set(drvr, 0, toe_cmpnt);
  562. if (ret < 0)
  563. return ret;
  564. /* If setting TX checksum mode, tell Linux the new mode */
  565. if (cmd == ETHTOOL_STXCSUM) {
  566. if (edata.data)
  567. drvr->iflist[0]->ndev->features |=
  568. NETIF_F_IP_CSUM;
  569. else
  570. drvr->iflist[0]->ndev->features &=
  571. ~NETIF_F_IP_CSUM;
  572. }
  573. break;
  574. default:
  575. return -EOPNOTSUPP;
  576. }
  577. return 0;
  578. }
  579. static int brcmf_netdev_ioctl_entry(struct net_device *ndev, struct ifreq *ifr,
  580. int cmd)
  581. {
  582. struct brcmf_if *ifp = netdev_priv(ndev);
  583. struct brcmf_pub *drvr = ifp->drvr;
  584. brcmf_dbg(TRACE, "ifidx %d, cmd 0x%04x\n", ifp->idx, cmd);
  585. if (!drvr->iflist[ifp->idx])
  586. return -1;
  587. if (cmd == SIOCETHTOOL)
  588. return brcmf_ethtool(drvr, ifr->ifr_data);
  589. return -EOPNOTSUPP;
  590. }
  591. /* called only from within this driver. Sends a command to the dongle. */
  592. s32 brcmf_exec_dcmd(struct net_device *ndev, u32 cmd, void *arg, u32 len)
  593. {
  594. struct brcmf_dcmd dcmd;
  595. s32 err = 0;
  596. int buflen = 0;
  597. bool is_set_key_cmd;
  598. struct brcmf_if *ifp = netdev_priv(ndev);
  599. struct brcmf_pub *drvr = ifp->drvr;
  600. memset(&dcmd, 0, sizeof(dcmd));
  601. dcmd.cmd = cmd;
  602. dcmd.buf = arg;
  603. dcmd.len = len;
  604. if (dcmd.buf != NULL)
  605. buflen = min_t(uint, dcmd.len, BRCMF_DCMD_MAXLEN);
  606. /* send to dongle (must be up, and wl) */
  607. if ((drvr->bus_if->state != BRCMF_BUS_DATA)) {
  608. brcmf_dbg(ERROR, "DONGLE_DOWN\n");
  609. err = -EIO;
  610. goto done;
  611. }
  612. if (!drvr->iswl) {
  613. err = -EIO;
  614. goto done;
  615. }
  616. /*
  617. * Intercept BRCMF_C_SET_KEY CMD - serialize M4 send and
  618. * set key CMD to prevent M4 encryption.
  619. */
  620. is_set_key_cmd = ((dcmd.cmd == BRCMF_C_SET_KEY) ||
  621. ((dcmd.cmd == BRCMF_C_SET_VAR) &&
  622. !(strncmp("wsec_key", dcmd.buf, 9))) ||
  623. ((dcmd.cmd == BRCMF_C_SET_VAR) &&
  624. !(strncmp("bsscfg:wsec_key", dcmd.buf, 15))));
  625. if (is_set_key_cmd)
  626. brcmf_netdev_wait_pend8021x(ndev);
  627. err = brcmf_proto_dcmd(drvr, ifp->idx, &dcmd, buflen);
  628. done:
  629. if (err > 0)
  630. err = 0;
  631. return err;
  632. }
  633. static int brcmf_netdev_stop(struct net_device *ndev)
  634. {
  635. struct brcmf_if *ifp = netdev_priv(ndev);
  636. struct brcmf_pub *drvr = ifp->drvr;
  637. brcmf_dbg(TRACE, "Enter\n");
  638. brcmf_cfg80211_down(drvr->config);
  639. if (drvr->up == 0)
  640. return 0;
  641. /* Set state and stop OS transmissions */
  642. drvr->up = 0;
  643. netif_stop_queue(ndev);
  644. return 0;
  645. }
  646. static int brcmf_netdev_open(struct net_device *ndev)
  647. {
  648. struct brcmf_if *ifp = netdev_priv(ndev);
  649. struct brcmf_pub *drvr = ifp->drvr;
  650. u32 toe_ol;
  651. s32 ret = 0;
  652. brcmf_dbg(TRACE, "ifidx %d\n", ifp->idx);
  653. if (ifp->idx == 0) { /* do it only for primary eth0 */
  654. /* try to bring up bus */
  655. ret = brcmf_bus_start(drvr->dev);
  656. if (ret != 0) {
  657. brcmf_dbg(ERROR, "failed with code %d\n", ret);
  658. return -1;
  659. }
  660. atomic_set(&drvr->pend_8021x_cnt, 0);
  661. memcpy(ndev->dev_addr, drvr->mac, ETH_ALEN);
  662. /* Get current TOE mode from dongle */
  663. if (brcmf_toe_get(drvr, ifp->idx, &toe_ol) >= 0
  664. && (toe_ol & TOE_TX_CSUM_OL) != 0)
  665. drvr->iflist[ifp->idx]->ndev->features |=
  666. NETIF_F_IP_CSUM;
  667. else
  668. drvr->iflist[ifp->idx]->ndev->features &=
  669. ~NETIF_F_IP_CSUM;
  670. }
  671. /* Allow transmit calls */
  672. netif_start_queue(ndev);
  673. drvr->up = 1;
  674. if (brcmf_cfg80211_up(drvr->config)) {
  675. brcmf_dbg(ERROR, "failed to bring up cfg80211\n");
  676. return -1;
  677. }
  678. return ret;
  679. }
  680. static const struct net_device_ops brcmf_netdev_ops_pri = {
  681. .ndo_open = brcmf_netdev_open,
  682. .ndo_stop = brcmf_netdev_stop,
  683. .ndo_get_stats = brcmf_netdev_get_stats,
  684. .ndo_do_ioctl = brcmf_netdev_ioctl_entry,
  685. .ndo_start_xmit = brcmf_netdev_start_xmit,
  686. .ndo_set_mac_address = brcmf_netdev_set_mac_address,
  687. .ndo_set_rx_mode = brcmf_netdev_set_multicast_list
  688. };
  689. int
  690. brcmf_add_if(struct device *dev, int ifidx, char *name, u8 *mac_addr)
  691. {
  692. struct brcmf_if *ifp;
  693. struct net_device *ndev;
  694. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  695. struct brcmf_pub *drvr = bus_if->drvr;
  696. brcmf_dbg(TRACE, "idx %d\n", ifidx);
  697. ifp = drvr->iflist[ifidx];
  698. /*
  699. * Delete the existing interface before overwriting it
  700. * in case we missed the BRCMF_E_IF_DEL event.
  701. */
  702. if (ifp) {
  703. brcmf_dbg(ERROR, "ERROR: netdev:%s already exists, try free & unregister\n",
  704. ifp->ndev->name);
  705. netif_stop_queue(ifp->ndev);
  706. unregister_netdev(ifp->ndev);
  707. free_netdev(ifp->ndev);
  708. drvr->iflist[ifidx] = NULL;
  709. }
  710. /* Allocate netdev, including space for private structure */
  711. ndev = alloc_netdev(sizeof(struct brcmf_if), name, ether_setup);
  712. if (!ndev) {
  713. brcmf_dbg(ERROR, "OOM - alloc_netdev\n");
  714. return -ENOMEM;
  715. }
  716. ifp = netdev_priv(ndev);
  717. ifp->ndev = ndev;
  718. ifp->drvr = drvr;
  719. drvr->iflist[ifidx] = ifp;
  720. ifp->idx = ifidx;
  721. if (mac_addr != NULL)
  722. memcpy(&ifp->mac_addr, mac_addr, ETH_ALEN);
  723. if (brcmf_net_attach(drvr, ifp->idx)) {
  724. brcmf_dbg(ERROR, "brcmf_net_attach failed");
  725. free_netdev(ifp->ndev);
  726. drvr->iflist[ifidx] = NULL;
  727. return -EOPNOTSUPP;
  728. }
  729. brcmf_dbg(TRACE, " ==== pid:%x, net_device for if:%s created ===\n",
  730. current->pid, ifp->ndev->name);
  731. return 0;
  732. }
  733. void brcmf_del_if(struct brcmf_pub *drvr, int ifidx)
  734. {
  735. struct brcmf_if *ifp;
  736. brcmf_dbg(TRACE, "idx %d\n", ifidx);
  737. ifp = drvr->iflist[ifidx];
  738. if (!ifp) {
  739. brcmf_dbg(ERROR, "Null interface\n");
  740. return;
  741. }
  742. if (ifp->ndev) {
  743. if (ifidx == 0) {
  744. if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) {
  745. rtnl_lock();
  746. brcmf_netdev_stop(ifp->ndev);
  747. rtnl_unlock();
  748. }
  749. } else {
  750. netif_stop_queue(ifp->ndev);
  751. }
  752. unregister_netdev(ifp->ndev);
  753. drvr->iflist[ifidx] = NULL;
  754. if (ifidx == 0)
  755. brcmf_cfg80211_detach(drvr->config);
  756. free_netdev(ifp->ndev);
  757. }
  758. }
  759. struct brcmf_pub *brcmf_attach(struct brcmf_sdio *bus, uint bus_hdrlen,
  760. struct device *dev)
  761. {
  762. struct brcmf_pub *drvr = NULL;
  763. brcmf_dbg(TRACE, "Enter\n");
  764. /* Allocate primary brcmf_info */
  765. drvr = kzalloc(sizeof(struct brcmf_pub), GFP_ATOMIC);
  766. if (!drvr)
  767. goto fail;
  768. mutex_init(&drvr->proto_block);
  769. /* Link to bus module */
  770. drvr->bus = bus;
  771. drvr->hdrlen = bus_hdrlen;
  772. drvr->bus_if = dev_get_drvdata(dev);
  773. drvr->bus_if->drvr = drvr;
  774. drvr->dev = dev;
  775. /* Attach and link in the protocol */
  776. if (brcmf_proto_attach(drvr) != 0) {
  777. brcmf_dbg(ERROR, "brcmf_prot_attach failed\n");
  778. goto fail;
  779. }
  780. INIT_WORK(&drvr->setmacaddr_work, _brcmf_set_mac_address);
  781. INIT_WORK(&drvr->multicast_work, _brcmf_set_multicast_list);
  782. return drvr;
  783. fail:
  784. if (drvr)
  785. brcmf_detach(dev);
  786. return NULL;
  787. }
  788. int brcmf_bus_start(struct device *dev)
  789. {
  790. int ret = -1;
  791. /* Room for "event_msgs" + '\0' + bitvec */
  792. char iovbuf[BRCMF_EVENTING_MASK_LEN + 12];
  793. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  794. struct brcmf_pub *drvr = bus_if->drvr;
  795. brcmf_dbg(TRACE, "\n");
  796. /* Bring up the bus */
  797. ret = brcmf_sdbrcm_bus_init(dev);
  798. if (ret != 0) {
  799. brcmf_dbg(ERROR, "brcmf_sdbrcm_bus_init failed %d\n", ret);
  800. return ret;
  801. }
  802. /* If bus is not ready, can't come up */
  803. if (bus_if->state != BRCMF_BUS_DATA) {
  804. brcmf_dbg(ERROR, "failed bus is not ready\n");
  805. return -ENODEV;
  806. }
  807. brcmf_c_mkiovar("event_msgs", drvr->eventmask, BRCMF_EVENTING_MASK_LEN,
  808. iovbuf, sizeof(iovbuf));
  809. brcmf_proto_cdc_query_dcmd(drvr, 0, BRCMF_C_GET_VAR, iovbuf,
  810. sizeof(iovbuf));
  811. memcpy(drvr->eventmask, iovbuf, BRCMF_EVENTING_MASK_LEN);
  812. setbit(drvr->eventmask, BRCMF_E_SET_SSID);
  813. setbit(drvr->eventmask, BRCMF_E_PRUNE);
  814. setbit(drvr->eventmask, BRCMF_E_AUTH);
  815. setbit(drvr->eventmask, BRCMF_E_REASSOC);
  816. setbit(drvr->eventmask, BRCMF_E_REASSOC_IND);
  817. setbit(drvr->eventmask, BRCMF_E_DEAUTH_IND);
  818. setbit(drvr->eventmask, BRCMF_E_DISASSOC_IND);
  819. setbit(drvr->eventmask, BRCMF_E_DISASSOC);
  820. setbit(drvr->eventmask, BRCMF_E_JOIN);
  821. setbit(drvr->eventmask, BRCMF_E_ASSOC_IND);
  822. setbit(drvr->eventmask, BRCMF_E_PSK_SUP);
  823. setbit(drvr->eventmask, BRCMF_E_LINK);
  824. setbit(drvr->eventmask, BRCMF_E_NDIS_LINK);
  825. setbit(drvr->eventmask, BRCMF_E_MIC_ERROR);
  826. setbit(drvr->eventmask, BRCMF_E_PMKID_CACHE);
  827. setbit(drvr->eventmask, BRCMF_E_TXFAIL);
  828. setbit(drvr->eventmask, BRCMF_E_JOIN_START);
  829. setbit(drvr->eventmask, BRCMF_E_SCAN_COMPLETE);
  830. /* enable dongle roaming event */
  831. drvr->pktfilter_count = 1;
  832. /* Setup filter to allow only unicast */
  833. drvr->pktfilter[0] = "100 0 0 0 0x01 0x00";
  834. /* Bus is ready, do any protocol initialization */
  835. ret = brcmf_proto_init(drvr);
  836. if (ret < 0)
  837. return ret;
  838. return 0;
  839. }
  840. int brcmf_net_attach(struct brcmf_pub *drvr, int ifidx)
  841. {
  842. struct net_device *ndev;
  843. u8 temp_addr[ETH_ALEN] = {
  844. 0x00, 0x90, 0x4c, 0x11, 0x22, 0x33};
  845. brcmf_dbg(TRACE, "ifidx %d\n", ifidx);
  846. ndev = drvr->iflist[ifidx]->ndev;
  847. ndev->netdev_ops = &brcmf_netdev_ops_pri;
  848. /*
  849. * We have to use the primary MAC for virtual interfaces
  850. */
  851. if (ifidx != 0) {
  852. /* for virtual interfaces use the primary MAC */
  853. memcpy(temp_addr, drvr->mac, ETH_ALEN);
  854. }
  855. if (ifidx == 1) {
  856. brcmf_dbg(TRACE, "ACCESS POINT MAC:\n");
  857. /* ACCESSPOINT INTERFACE CASE */
  858. temp_addr[0] |= 0X02; /* set bit 2 ,
  859. - Locally Administered address */
  860. }
  861. ndev->hard_header_len = ETH_HLEN + drvr->hdrlen;
  862. ndev->ethtool_ops = &brcmf_ethtool_ops;
  863. drvr->rxsz = ndev->mtu + ndev->hard_header_len +
  864. drvr->hdrlen;
  865. memcpy(ndev->dev_addr, temp_addr, ETH_ALEN);
  866. /* attach to cfg80211 for primary interface */
  867. if (!ifidx) {
  868. drvr->config = brcmf_cfg80211_attach(ndev, drvr->dev, drvr);
  869. if (drvr->config == NULL) {
  870. brcmf_dbg(ERROR, "wl_cfg80211_attach failed\n");
  871. goto fail;
  872. }
  873. }
  874. if (register_netdev(ndev) != 0) {
  875. brcmf_dbg(ERROR, "couldn't register the net device\n");
  876. goto fail;
  877. }
  878. brcmf_dbg(INFO, "%s: Broadcom Dongle Host Driver\n", ndev->name);
  879. return 0;
  880. fail:
  881. ndev->netdev_ops = NULL;
  882. return -EBADE;
  883. }
  884. static void brcmf_bus_detach(struct brcmf_pub *drvr)
  885. {
  886. brcmf_dbg(TRACE, "Enter\n");
  887. if (drvr) {
  888. /* Stop the protocol module */
  889. brcmf_proto_stop(drvr);
  890. /* Stop the bus module */
  891. brcmf_sdbrcm_bus_stop(drvr->dev);
  892. }
  893. }
  894. void brcmf_detach(struct device *dev)
  895. {
  896. int i;
  897. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  898. struct brcmf_pub *drvr = bus_if->drvr;
  899. brcmf_dbg(TRACE, "Enter\n");
  900. /* make sure primary interface removed last */
  901. for (i = BRCMF_MAX_IFS-1; i > -1; i--)
  902. if (drvr->iflist[i])
  903. brcmf_del_if(drvr, i);
  904. cancel_work_sync(&drvr->setmacaddr_work);
  905. cancel_work_sync(&drvr->multicast_work);
  906. brcmf_bus_detach(drvr);
  907. if (drvr->prot)
  908. brcmf_proto_detach(drvr);
  909. bus_if->drvr = NULL;
  910. kfree(drvr);
  911. }
  912. static int brcmf_get_pend_8021x_cnt(struct brcmf_pub *drvr)
  913. {
  914. return atomic_read(&drvr->pend_8021x_cnt);
  915. }
  916. #define MAX_WAIT_FOR_8021X_TX 10
  917. int brcmf_netdev_wait_pend8021x(struct net_device *ndev)
  918. {
  919. struct brcmf_if *ifp = netdev_priv(ndev);
  920. struct brcmf_pub *drvr = ifp->drvr;
  921. int timeout = 10 * HZ / 1000;
  922. int ntimes = MAX_WAIT_FOR_8021X_TX;
  923. int pend = brcmf_get_pend_8021x_cnt(drvr);
  924. while (ntimes && pend) {
  925. if (pend) {
  926. set_current_state(TASK_INTERRUPTIBLE);
  927. schedule_timeout(timeout);
  928. set_current_state(TASK_RUNNING);
  929. ntimes--;
  930. }
  931. pend = brcmf_get_pend_8021x_cnt(drvr);
  932. }
  933. return pend;
  934. }
  935. #ifdef BCMDBG
  936. int brcmf_write_to_file(struct brcmf_pub *drvr, const u8 *buf, int size)
  937. {
  938. int ret = 0;
  939. struct file *fp;
  940. mm_segment_t old_fs;
  941. loff_t pos = 0;
  942. /* change to KERNEL_DS address limit */
  943. old_fs = get_fs();
  944. set_fs(KERNEL_DS);
  945. /* open file to write */
  946. fp = filp_open("/tmp/mem_dump", O_WRONLY | O_CREAT, 0640);
  947. if (!fp) {
  948. brcmf_dbg(ERROR, "open file error\n");
  949. ret = -1;
  950. goto exit;
  951. }
  952. /* Write buf to file */
  953. fp->f_op->write(fp, (char __user *)buf, size, &pos);
  954. exit:
  955. /* free buf before return */
  956. kfree(buf);
  957. /* close file before return */
  958. if (fp)
  959. filp_close(fp, current->files);
  960. /* restore previous address limit */
  961. set_fs(old_fs);
  962. return ret;
  963. }
  964. #endif /* BCMDBG */