dhd_linux.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056
  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/kernel.h>
  17. #include <linux/etherdevice.h>
  18. #include <linux/module.h>
  19. #include <net/cfg80211.h>
  20. #include <net/rtnetlink.h>
  21. #include <brcmu_utils.h>
  22. #include <brcmu_wifi.h>
  23. #include "dhd.h"
  24. #include "dhd_bus.h"
  25. #include "dhd_proto.h"
  26. #include "dhd_dbg.h"
  27. #include "fwil_types.h"
  28. #include "p2p.h"
  29. #include "wl_cfg80211.h"
  30. #include "fwil.h"
  31. #include "fwsignal.h"
  32. MODULE_AUTHOR("Broadcom Corporation");
  33. MODULE_DESCRIPTION("Broadcom 802.11 wireless LAN fullmac driver.");
  34. MODULE_LICENSE("Dual BSD/GPL");
  35. #define MAX_WAIT_FOR_8021X_TX 50 /* msecs */
  36. /* Error bits */
  37. int brcmf_msg_level;
  38. module_param_named(debug, brcmf_msg_level, int, S_IRUSR | S_IWUSR);
  39. MODULE_PARM_DESC(debug, "level of debug output");
  40. /* P2P0 enable */
  41. static int brcmf_p2p_enable;
  42. #ifdef CONFIG_BRCMDBG
  43. module_param_named(p2pon, brcmf_p2p_enable, int, 0);
  44. MODULE_PARM_DESC(p2pon, "enable p2p management functionality");
  45. #endif
  46. char *brcmf_ifname(struct brcmf_pub *drvr, int ifidx)
  47. {
  48. if (ifidx < 0 || ifidx >= BRCMF_MAX_IFS) {
  49. brcmf_err("ifidx %d out of range\n", ifidx);
  50. return "<if_bad>";
  51. }
  52. if (drvr->iflist[ifidx] == NULL) {
  53. brcmf_err("null i/f %d\n", ifidx);
  54. return "<if_null>";
  55. }
  56. if (drvr->iflist[ifidx]->ndev)
  57. return drvr->iflist[ifidx]->ndev->name;
  58. return "<if_none>";
  59. }
  60. static void _brcmf_set_multicast_list(struct work_struct *work)
  61. {
  62. struct brcmf_if *ifp;
  63. struct net_device *ndev;
  64. struct netdev_hw_addr *ha;
  65. u32 cmd_value, cnt;
  66. __le32 cnt_le;
  67. char *buf, *bufp;
  68. u32 buflen;
  69. s32 err;
  70. ifp = container_of(work, struct brcmf_if, multicast_work);
  71. brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
  72. ndev = ifp->ndev;
  73. /* Determine initial value of allmulti flag */
  74. cmd_value = (ndev->flags & IFF_ALLMULTI) ? true : false;
  75. /* Send down the multicast list first. */
  76. cnt = netdev_mc_count(ndev);
  77. buflen = sizeof(cnt) + (cnt * ETH_ALEN);
  78. buf = kmalloc(buflen, GFP_ATOMIC);
  79. if (!buf)
  80. return;
  81. bufp = buf;
  82. cnt_le = cpu_to_le32(cnt);
  83. memcpy(bufp, &cnt_le, sizeof(cnt_le));
  84. bufp += sizeof(cnt_le);
  85. netdev_for_each_mc_addr(ha, ndev) {
  86. if (!cnt)
  87. break;
  88. memcpy(bufp, ha->addr, ETH_ALEN);
  89. bufp += ETH_ALEN;
  90. cnt--;
  91. }
  92. err = brcmf_fil_iovar_data_set(ifp, "mcast_list", buf, buflen);
  93. if (err < 0) {
  94. brcmf_err("Setting mcast_list failed, %d\n", err);
  95. cmd_value = cnt ? true : cmd_value;
  96. }
  97. kfree(buf);
  98. /*
  99. * Now send the allmulti setting. This is based on the setting in the
  100. * net_device flags, but might be modified above to be turned on if we
  101. * were trying to set some addresses and dongle rejected it...
  102. */
  103. err = brcmf_fil_iovar_int_set(ifp, "allmulti", cmd_value);
  104. if (err < 0)
  105. brcmf_err("Setting allmulti failed, %d\n", err);
  106. /*Finally, pick up the PROMISC flag */
  107. cmd_value = (ndev->flags & IFF_PROMISC) ? true : false;
  108. err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PROMISC, cmd_value);
  109. if (err < 0)
  110. brcmf_err("Setting BRCMF_C_SET_PROMISC failed, %d\n",
  111. err);
  112. }
  113. static void
  114. _brcmf_set_mac_address(struct work_struct *work)
  115. {
  116. struct brcmf_if *ifp;
  117. s32 err;
  118. ifp = container_of(work, struct brcmf_if, setmacaddr_work);
  119. brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
  120. err = brcmf_fil_iovar_data_set(ifp, "cur_etheraddr", ifp->mac_addr,
  121. ETH_ALEN);
  122. if (err < 0) {
  123. brcmf_err("Setting cur_etheraddr failed, %d\n", err);
  124. } else {
  125. brcmf_dbg(TRACE, "MAC address updated to %pM\n",
  126. ifp->mac_addr);
  127. memcpy(ifp->ndev->dev_addr, ifp->mac_addr, ETH_ALEN);
  128. }
  129. }
  130. static int brcmf_netdev_set_mac_address(struct net_device *ndev, void *addr)
  131. {
  132. struct brcmf_if *ifp = netdev_priv(ndev);
  133. struct sockaddr *sa = (struct sockaddr *)addr;
  134. memcpy(&ifp->mac_addr, sa->sa_data, ETH_ALEN);
  135. schedule_work(&ifp->setmacaddr_work);
  136. return 0;
  137. }
  138. static void brcmf_netdev_set_multicast_list(struct net_device *ndev)
  139. {
  140. struct brcmf_if *ifp = netdev_priv(ndev);
  141. schedule_work(&ifp->multicast_work);
  142. }
  143. static netdev_tx_t brcmf_netdev_start_xmit(struct sk_buff *skb,
  144. struct net_device *ndev)
  145. {
  146. int ret;
  147. struct brcmf_if *ifp = netdev_priv(ndev);
  148. struct brcmf_pub *drvr = ifp->drvr;
  149. struct ethhdr *eh;
  150. brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
  151. /* Can the device send data? */
  152. if (drvr->bus_if->state != BRCMF_BUS_DATA) {
  153. brcmf_err("xmit rejected state=%d\n", drvr->bus_if->state);
  154. netif_stop_queue(ndev);
  155. dev_kfree_skb(skb);
  156. ret = -ENODEV;
  157. goto done;
  158. }
  159. if (!drvr->iflist[ifp->bssidx]) {
  160. brcmf_err("bad ifidx %d\n", ifp->bssidx);
  161. netif_stop_queue(ndev);
  162. dev_kfree_skb(skb);
  163. ret = -ENODEV;
  164. goto done;
  165. }
  166. /* Make sure there's enough room for any header */
  167. if (skb_headroom(skb) < drvr->hdrlen) {
  168. struct sk_buff *skb2;
  169. brcmf_dbg(INFO, "%s: insufficient headroom\n",
  170. brcmf_ifname(drvr, ifp->bssidx));
  171. drvr->bus_if->tx_realloc++;
  172. skb2 = skb_realloc_headroom(skb, drvr->hdrlen);
  173. dev_kfree_skb(skb);
  174. skb = skb2;
  175. if (skb == NULL) {
  176. brcmf_err("%s: skb_realloc_headroom failed\n",
  177. brcmf_ifname(drvr, ifp->bssidx));
  178. ret = -ENOMEM;
  179. goto done;
  180. }
  181. }
  182. /* validate length for ether packet */
  183. if (skb->len < sizeof(*eh)) {
  184. ret = -EINVAL;
  185. dev_kfree_skb(skb);
  186. goto done;
  187. }
  188. /* handle ethernet header */
  189. eh = (struct ethhdr *)(skb->data);
  190. if (is_multicast_ether_addr(eh->h_dest))
  191. drvr->tx_multicast++;
  192. if (ntohs(eh->h_proto) == ETH_P_PAE)
  193. atomic_inc(&ifp->pend_8021x_cnt);
  194. /* If the protocol uses a data header, apply it */
  195. brcmf_proto_hdrpush(drvr, ifp->ifidx, 0, skb);
  196. /* Use bus module to send data frame */
  197. ret = brcmf_bus_txdata(drvr->bus_if, skb);
  198. done:
  199. if (ret) {
  200. ifp->stats.tx_dropped++;
  201. } else {
  202. ifp->stats.tx_packets++;
  203. ifp->stats.tx_bytes += skb->len;
  204. }
  205. /* Return ok: we always eat the packet */
  206. return NETDEV_TX_OK;
  207. }
  208. void brcmf_txflowblock_if(struct brcmf_if *ifp,
  209. enum brcmf_netif_stop_reason reason, bool state)
  210. {
  211. if (!ifp)
  212. return;
  213. brcmf_dbg(TRACE, "enter: idx=%d stop=0x%X reason=%d state=%d\n",
  214. ifp->bssidx, ifp->netif_stop, reason, state);
  215. if (state) {
  216. if (!ifp->netif_stop)
  217. netif_stop_queue(ifp->ndev);
  218. ifp->netif_stop |= reason;
  219. } else {
  220. ifp->netif_stop &= ~reason;
  221. if (!ifp->netif_stop)
  222. netif_wake_queue(ifp->ndev);
  223. }
  224. }
  225. void brcmf_txflowblock(struct device *dev, bool state)
  226. {
  227. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  228. struct brcmf_pub *drvr = bus_if->drvr;
  229. int i;
  230. brcmf_dbg(TRACE, "Enter\n");
  231. for (i = 0; i < BRCMF_MAX_IFS; i++)
  232. brcmf_txflowblock_if(drvr->iflist[i],
  233. BRCMF_NETIF_STOP_REASON_BLOCK_BUS, state);
  234. }
  235. void brcmf_rx_frames(struct device *dev, struct sk_buff_head *skb_list)
  236. {
  237. unsigned char *eth;
  238. uint len;
  239. struct sk_buff *skb, *pnext;
  240. struct brcmf_if *ifp;
  241. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  242. struct brcmf_pub *drvr = bus_if->drvr;
  243. u8 ifidx;
  244. int ret;
  245. brcmf_dbg(TRACE, "Enter\n");
  246. skb_queue_walk_safe(skb_list, skb, pnext) {
  247. skb_unlink(skb, skb_list);
  248. /* process and remove protocol-specific header */
  249. ret = brcmf_proto_hdrpull(drvr, drvr->fw_signals, &ifidx, skb);
  250. ifp = drvr->iflist[ifidx];
  251. if (ret || !ifp || !ifp->ndev) {
  252. if ((ret != -ENODATA) && ifp)
  253. ifp->stats.rx_errors++;
  254. brcmu_pkt_buf_free_skb(skb);
  255. continue;
  256. }
  257. /* Get the protocol, maintain skb around eth_type_trans()
  258. * The main reason for this hack is for the limitation of
  259. * Linux 2.4 where 'eth_type_trans' uses the
  260. * 'net->hard_header_len'
  261. * to perform skb_pull inside vs ETH_HLEN. Since to avoid
  262. * coping of the packet coming from the network stack to add
  263. * BDC, Hardware header etc, during network interface
  264. * registration
  265. * we set the 'net->hard_header_len' to ETH_HLEN + extra space
  266. * required
  267. * for BDC, Hardware header etc. and not just the ETH_HLEN
  268. */
  269. eth = skb->data;
  270. len = skb->len;
  271. skb->dev = ifp->ndev;
  272. skb->protocol = eth_type_trans(skb, skb->dev);
  273. if (skb->pkt_type == PACKET_MULTICAST)
  274. ifp->stats.multicast++;
  275. skb->data = eth;
  276. skb->len = len;
  277. /* Strip header, count, deliver upward */
  278. skb_pull(skb, ETH_HLEN);
  279. /* Process special event packets and then discard them */
  280. brcmf_fweh_process_skb(drvr, skb, &ifidx);
  281. if (drvr->iflist[ifidx]) {
  282. ifp = drvr->iflist[ifidx];
  283. ifp->ndev->last_rx = jiffies;
  284. }
  285. if (!(ifp->ndev->flags & IFF_UP)) {
  286. brcmu_pkt_buf_free_skb(skb);
  287. continue;
  288. }
  289. ifp->stats.rx_bytes += skb->len;
  290. ifp->stats.rx_packets++;
  291. if (in_interrupt())
  292. netif_rx(skb);
  293. else
  294. /* If the receive is not processed inside an ISR,
  295. * the softirqd must be woken explicitly to service
  296. * the NET_RX_SOFTIRQ. In 2.6 kernels, this is handled
  297. * by netif_rx_ni(), but in earlier kernels, we need
  298. * to do it manually.
  299. */
  300. netif_rx_ni(skb);
  301. }
  302. }
  303. void brcmf_txcomplete(struct device *dev, struct sk_buff *txp, bool success)
  304. {
  305. u8 ifidx;
  306. struct ethhdr *eh;
  307. u16 type;
  308. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  309. struct brcmf_pub *drvr = bus_if->drvr;
  310. struct brcmf_if *ifp;
  311. int res;
  312. res = brcmf_proto_hdrpull(drvr, false, &ifidx, txp);
  313. ifp = drvr->iflist[ifidx];
  314. if (!ifp)
  315. goto done;
  316. if (res == 0) {
  317. eh = (struct ethhdr *)(txp->data);
  318. type = ntohs(eh->h_proto);
  319. if (type == ETH_P_PAE) {
  320. atomic_dec(&ifp->pend_8021x_cnt);
  321. if (waitqueue_active(&ifp->pend_8021x_wait))
  322. wake_up(&ifp->pend_8021x_wait);
  323. }
  324. }
  325. if (!success)
  326. ifp->stats.tx_errors++;
  327. done:
  328. brcmu_pkt_buf_free_skb(txp);
  329. }
  330. static struct net_device_stats *brcmf_netdev_get_stats(struct net_device *ndev)
  331. {
  332. struct brcmf_if *ifp = netdev_priv(ndev);
  333. brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
  334. return &ifp->stats;
  335. }
  336. /*
  337. * Set current toe component enables in toe_ol iovar,
  338. * and set toe global enable iovar
  339. */
  340. static int brcmf_toe_set(struct brcmf_if *ifp, u32 toe_ol)
  341. {
  342. s32 err;
  343. err = brcmf_fil_iovar_int_set(ifp, "toe_ol", toe_ol);
  344. if (err < 0) {
  345. brcmf_err("Setting toe_ol failed, %d\n", err);
  346. return err;
  347. }
  348. err = brcmf_fil_iovar_int_set(ifp, "toe", (toe_ol != 0));
  349. if (err < 0)
  350. brcmf_err("Setting toe failed, %d\n", err);
  351. return err;
  352. }
  353. static void brcmf_ethtool_get_drvinfo(struct net_device *ndev,
  354. struct ethtool_drvinfo *info)
  355. {
  356. struct brcmf_if *ifp = netdev_priv(ndev);
  357. struct brcmf_pub *drvr = ifp->drvr;
  358. strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
  359. snprintf(info->version, sizeof(info->version), "%lu",
  360. drvr->drv_version);
  361. strlcpy(info->bus_info, dev_name(drvr->bus_if->dev),
  362. sizeof(info->bus_info));
  363. }
  364. static const struct ethtool_ops brcmf_ethtool_ops = {
  365. .get_drvinfo = brcmf_ethtool_get_drvinfo,
  366. };
  367. static int brcmf_ethtool(struct brcmf_if *ifp, void __user *uaddr)
  368. {
  369. struct brcmf_pub *drvr = ifp->drvr;
  370. struct ethtool_drvinfo info;
  371. char drvname[sizeof(info.driver)];
  372. u32 cmd;
  373. struct ethtool_value edata;
  374. u32 toe_cmpnt, csum_dir;
  375. int ret;
  376. brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
  377. /* all ethtool calls start with a cmd word */
  378. if (copy_from_user(&cmd, uaddr, sizeof(u32)))
  379. return -EFAULT;
  380. switch (cmd) {
  381. case ETHTOOL_GDRVINFO:
  382. /* Copy out any request driver name */
  383. if (copy_from_user(&info, uaddr, sizeof(info)))
  384. return -EFAULT;
  385. strncpy(drvname, info.driver, sizeof(info.driver));
  386. drvname[sizeof(info.driver) - 1] = '\0';
  387. /* clear struct for return */
  388. memset(&info, 0, sizeof(info));
  389. info.cmd = cmd;
  390. /* if requested, identify ourselves */
  391. if (strcmp(drvname, "?dhd") == 0) {
  392. sprintf(info.driver, "dhd");
  393. strcpy(info.version, BRCMF_VERSION_STR);
  394. }
  395. /* report dongle driver type */
  396. else
  397. sprintf(info.driver, "wl");
  398. sprintf(info.version, "%lu", drvr->drv_version);
  399. if (copy_to_user(uaddr, &info, sizeof(info)))
  400. return -EFAULT;
  401. brcmf_dbg(TRACE, "given %*s, returning %s\n",
  402. (int)sizeof(drvname), drvname, info.driver);
  403. break;
  404. /* Get toe offload components from dongle */
  405. case ETHTOOL_GRXCSUM:
  406. case ETHTOOL_GTXCSUM:
  407. ret = brcmf_fil_iovar_int_get(ifp, "toe_ol", &toe_cmpnt);
  408. if (ret < 0)
  409. return ret;
  410. csum_dir =
  411. (cmd == ETHTOOL_GTXCSUM) ? TOE_TX_CSUM_OL : TOE_RX_CSUM_OL;
  412. edata.cmd = cmd;
  413. edata.data = (toe_cmpnt & csum_dir) ? 1 : 0;
  414. if (copy_to_user(uaddr, &edata, sizeof(edata)))
  415. return -EFAULT;
  416. break;
  417. /* Set toe offload components in dongle */
  418. case ETHTOOL_SRXCSUM:
  419. case ETHTOOL_STXCSUM:
  420. if (copy_from_user(&edata, uaddr, sizeof(edata)))
  421. return -EFAULT;
  422. /* Read the current settings, update and write back */
  423. ret = brcmf_fil_iovar_int_get(ifp, "toe_ol", &toe_cmpnt);
  424. if (ret < 0)
  425. return ret;
  426. csum_dir =
  427. (cmd == ETHTOOL_STXCSUM) ? TOE_TX_CSUM_OL : TOE_RX_CSUM_OL;
  428. if (edata.data != 0)
  429. toe_cmpnt |= csum_dir;
  430. else
  431. toe_cmpnt &= ~csum_dir;
  432. ret = brcmf_toe_set(ifp, toe_cmpnt);
  433. if (ret < 0)
  434. return ret;
  435. /* If setting TX checksum mode, tell Linux the new mode */
  436. if (cmd == ETHTOOL_STXCSUM) {
  437. if (edata.data)
  438. ifp->ndev->features |= NETIF_F_IP_CSUM;
  439. else
  440. ifp->ndev->features &= ~NETIF_F_IP_CSUM;
  441. }
  442. break;
  443. default:
  444. return -EOPNOTSUPP;
  445. }
  446. return 0;
  447. }
  448. static int brcmf_netdev_ioctl_entry(struct net_device *ndev, struct ifreq *ifr,
  449. int cmd)
  450. {
  451. struct brcmf_if *ifp = netdev_priv(ndev);
  452. struct brcmf_pub *drvr = ifp->drvr;
  453. brcmf_dbg(TRACE, "Enter, idx=%d, cmd=0x%04x\n", ifp->bssidx, cmd);
  454. if (!drvr->iflist[ifp->bssidx])
  455. return -1;
  456. if (cmd == SIOCETHTOOL)
  457. return brcmf_ethtool(ifp, ifr->ifr_data);
  458. return -EOPNOTSUPP;
  459. }
  460. static int brcmf_netdev_stop(struct net_device *ndev)
  461. {
  462. struct brcmf_if *ifp = netdev_priv(ndev);
  463. brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
  464. brcmf_cfg80211_down(ndev);
  465. /* Set state and stop OS transmissions */
  466. netif_stop_queue(ndev);
  467. return 0;
  468. }
  469. static int brcmf_netdev_open(struct net_device *ndev)
  470. {
  471. struct brcmf_if *ifp = netdev_priv(ndev);
  472. struct brcmf_pub *drvr = ifp->drvr;
  473. struct brcmf_bus *bus_if = drvr->bus_if;
  474. u32 toe_ol;
  475. s32 ret = 0;
  476. brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
  477. /* If bus is not ready, can't continue */
  478. if (bus_if->state != BRCMF_BUS_DATA) {
  479. brcmf_err("failed bus is not ready\n");
  480. return -EAGAIN;
  481. }
  482. atomic_set(&ifp->pend_8021x_cnt, 0);
  483. /* Get current TOE mode from dongle */
  484. if (brcmf_fil_iovar_int_get(ifp, "toe_ol", &toe_ol) >= 0
  485. && (toe_ol & TOE_TX_CSUM_OL) != 0)
  486. ndev->features |= NETIF_F_IP_CSUM;
  487. else
  488. ndev->features &= ~NETIF_F_IP_CSUM;
  489. /* Allow transmit calls */
  490. netif_start_queue(ndev);
  491. if (brcmf_cfg80211_up(ndev)) {
  492. brcmf_err("failed to bring up cfg80211\n");
  493. return -1;
  494. }
  495. return ret;
  496. }
  497. static const struct net_device_ops brcmf_netdev_ops_pri = {
  498. .ndo_open = brcmf_netdev_open,
  499. .ndo_stop = brcmf_netdev_stop,
  500. .ndo_get_stats = brcmf_netdev_get_stats,
  501. .ndo_do_ioctl = brcmf_netdev_ioctl_entry,
  502. .ndo_start_xmit = brcmf_netdev_start_xmit,
  503. .ndo_set_mac_address = brcmf_netdev_set_mac_address,
  504. .ndo_set_rx_mode = brcmf_netdev_set_multicast_list
  505. };
  506. int brcmf_net_attach(struct brcmf_if *ifp, bool rtnl_locked)
  507. {
  508. struct brcmf_pub *drvr = ifp->drvr;
  509. struct net_device *ndev;
  510. s32 err;
  511. brcmf_dbg(TRACE, "Enter, idx=%d mac=%pM\n", ifp->bssidx,
  512. ifp->mac_addr);
  513. ndev = ifp->ndev;
  514. /* set appropriate operations */
  515. ndev->netdev_ops = &brcmf_netdev_ops_pri;
  516. ndev->hard_header_len = ETH_HLEN + drvr->hdrlen;
  517. ndev->ethtool_ops = &brcmf_ethtool_ops;
  518. drvr->rxsz = ndev->mtu + ndev->hard_header_len +
  519. drvr->hdrlen;
  520. /* set the mac address */
  521. memcpy(ndev->dev_addr, ifp->mac_addr, ETH_ALEN);
  522. INIT_WORK(&ifp->setmacaddr_work, _brcmf_set_mac_address);
  523. INIT_WORK(&ifp->multicast_work, _brcmf_set_multicast_list);
  524. if (rtnl_locked)
  525. err = register_netdevice(ndev);
  526. else
  527. err = register_netdev(ndev);
  528. if (err != 0) {
  529. brcmf_err("couldn't register the net device\n");
  530. goto fail;
  531. }
  532. brcmf_dbg(INFO, "%s: Broadcom Dongle Host Driver\n", ndev->name);
  533. return 0;
  534. fail:
  535. ndev->netdev_ops = NULL;
  536. return -EBADE;
  537. }
  538. static int brcmf_net_p2p_open(struct net_device *ndev)
  539. {
  540. brcmf_dbg(TRACE, "Enter\n");
  541. return brcmf_cfg80211_up(ndev);
  542. }
  543. static int brcmf_net_p2p_stop(struct net_device *ndev)
  544. {
  545. brcmf_dbg(TRACE, "Enter\n");
  546. return brcmf_cfg80211_down(ndev);
  547. }
  548. static int brcmf_net_p2p_do_ioctl(struct net_device *ndev,
  549. struct ifreq *ifr, int cmd)
  550. {
  551. brcmf_dbg(TRACE, "Enter\n");
  552. return 0;
  553. }
  554. static netdev_tx_t brcmf_net_p2p_start_xmit(struct sk_buff *skb,
  555. struct net_device *ndev)
  556. {
  557. if (skb)
  558. dev_kfree_skb_any(skb);
  559. return NETDEV_TX_OK;
  560. }
  561. static const struct net_device_ops brcmf_netdev_ops_p2p = {
  562. .ndo_open = brcmf_net_p2p_open,
  563. .ndo_stop = brcmf_net_p2p_stop,
  564. .ndo_do_ioctl = brcmf_net_p2p_do_ioctl,
  565. .ndo_start_xmit = brcmf_net_p2p_start_xmit
  566. };
  567. static int brcmf_net_p2p_attach(struct brcmf_if *ifp)
  568. {
  569. struct net_device *ndev;
  570. brcmf_dbg(TRACE, "Enter, idx=%d mac=%pM\n", ifp->bssidx,
  571. ifp->mac_addr);
  572. ndev = ifp->ndev;
  573. ndev->netdev_ops = &brcmf_netdev_ops_p2p;
  574. /* set the mac address */
  575. memcpy(ndev->dev_addr, ifp->mac_addr, ETH_ALEN);
  576. if (register_netdev(ndev) != 0) {
  577. brcmf_err("couldn't register the p2p net device\n");
  578. goto fail;
  579. }
  580. brcmf_dbg(INFO, "%s: Broadcom Dongle Host Driver\n", ndev->name);
  581. return 0;
  582. fail:
  583. return -EBADE;
  584. }
  585. struct brcmf_if *brcmf_add_if(struct brcmf_pub *drvr, s32 bssidx, s32 ifidx,
  586. char *name, u8 *mac_addr)
  587. {
  588. struct brcmf_if *ifp;
  589. struct net_device *ndev;
  590. brcmf_dbg(TRACE, "Enter, idx=%d, ifidx=%d\n", bssidx, ifidx);
  591. ifp = drvr->iflist[bssidx];
  592. /*
  593. * Delete the existing interface before overwriting it
  594. * in case we missed the BRCMF_E_IF_DEL event.
  595. */
  596. if (ifp) {
  597. brcmf_err("ERROR: netdev:%s already exists\n",
  598. ifp->ndev->name);
  599. if (ifidx) {
  600. netif_stop_queue(ifp->ndev);
  601. unregister_netdev(ifp->ndev);
  602. free_netdev(ifp->ndev);
  603. drvr->iflist[bssidx] = NULL;
  604. } else {
  605. brcmf_err("ignore IF event\n");
  606. return ERR_PTR(-EINVAL);
  607. }
  608. }
  609. /* Allocate netdev, including space for private structure */
  610. ndev = alloc_netdev(sizeof(struct brcmf_if), name, ether_setup);
  611. if (!ndev) {
  612. brcmf_err("OOM - alloc_netdev\n");
  613. return ERR_PTR(-ENOMEM);
  614. }
  615. ifp = netdev_priv(ndev);
  616. ifp->ndev = ndev;
  617. ifp->drvr = drvr;
  618. drvr->iflist[bssidx] = ifp;
  619. ifp->ifidx = ifidx;
  620. ifp->bssidx = bssidx;
  621. init_waitqueue_head(&ifp->pend_8021x_wait);
  622. if (mac_addr != NULL)
  623. memcpy(ifp->mac_addr, mac_addr, ETH_ALEN);
  624. brcmf_dbg(TRACE, " ==== pid:%x, if:%s (%pM) created ===\n",
  625. current->pid, ifp->ndev->name, ifp->mac_addr);
  626. return ifp;
  627. }
  628. void brcmf_del_if(struct brcmf_pub *drvr, s32 bssidx)
  629. {
  630. struct brcmf_if *ifp;
  631. ifp = drvr->iflist[bssidx];
  632. if (!ifp) {
  633. brcmf_err("Null interface, idx=%d\n", bssidx);
  634. return;
  635. }
  636. brcmf_dbg(TRACE, "Enter, idx=%d, ifidx=%d\n", bssidx, ifp->ifidx);
  637. if (ifp->ndev) {
  638. if (bssidx == 0) {
  639. if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) {
  640. rtnl_lock();
  641. brcmf_netdev_stop(ifp->ndev);
  642. rtnl_unlock();
  643. }
  644. } else {
  645. netif_stop_queue(ifp->ndev);
  646. }
  647. if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) {
  648. cancel_work_sync(&ifp->setmacaddr_work);
  649. cancel_work_sync(&ifp->multicast_work);
  650. }
  651. unregister_netdev(ifp->ndev);
  652. drvr->iflist[bssidx] = NULL;
  653. if (bssidx == 0)
  654. brcmf_cfg80211_detach(drvr->config);
  655. free_netdev(ifp->ndev);
  656. }
  657. }
  658. int brcmf_attach(uint bus_hdrlen, struct device *dev)
  659. {
  660. struct brcmf_pub *drvr = NULL;
  661. int ret = 0;
  662. brcmf_dbg(TRACE, "Enter\n");
  663. /* Allocate primary brcmf_info */
  664. drvr = kzalloc(sizeof(struct brcmf_pub), GFP_ATOMIC);
  665. if (!drvr)
  666. return -ENOMEM;
  667. mutex_init(&drvr->proto_block);
  668. /* Link to bus module */
  669. drvr->hdrlen = bus_hdrlen;
  670. drvr->bus_if = dev_get_drvdata(dev);
  671. drvr->bus_if->drvr = drvr;
  672. /* create device debugfs folder */
  673. brcmf_debugfs_attach(drvr);
  674. /* Attach and link in the protocol */
  675. ret = brcmf_proto_attach(drvr);
  676. if (ret != 0) {
  677. brcmf_err("brcmf_prot_attach failed\n");
  678. goto fail;
  679. }
  680. /* attach firmware event handler */
  681. brcmf_fweh_attach(drvr);
  682. INIT_LIST_HEAD(&drvr->bus_if->dcmd_list);
  683. return ret;
  684. fail:
  685. brcmf_detach(dev);
  686. return ret;
  687. }
  688. int brcmf_bus_start(struct device *dev)
  689. {
  690. int ret = -1;
  691. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  692. struct brcmf_pub *drvr = bus_if->drvr;
  693. struct brcmf_if *ifp;
  694. struct brcmf_if *p2p_ifp;
  695. brcmf_dbg(TRACE, "\n");
  696. /* Bring up the bus */
  697. ret = brcmf_bus_init(bus_if);
  698. if (ret != 0) {
  699. brcmf_err("brcmf_sdbrcm_bus_init failed %d\n", ret);
  700. return ret;
  701. }
  702. /* add primary networking interface */
  703. ifp = brcmf_add_if(drvr, 0, 0, "wlan%d", NULL);
  704. if (IS_ERR(ifp))
  705. return PTR_ERR(ifp);
  706. if (brcmf_p2p_enable)
  707. p2p_ifp = brcmf_add_if(drvr, 1, 0, "p2p%d", NULL);
  708. else
  709. p2p_ifp = NULL;
  710. if (IS_ERR(p2p_ifp))
  711. p2p_ifp = NULL;
  712. /* signal bus ready */
  713. bus_if->state = BRCMF_BUS_DATA;
  714. /* Bus is ready, do any initialization */
  715. ret = brcmf_c_preinit_dcmds(ifp);
  716. if (ret < 0)
  717. goto fail;
  718. drvr->fw_signals = true;
  719. (void)brcmf_fws_init(drvr);
  720. brcmf_fws_add_interface(ifp);
  721. drvr->config = brcmf_cfg80211_attach(drvr, bus_if->dev);
  722. if (drvr->config == NULL) {
  723. ret = -ENOMEM;
  724. goto fail;
  725. }
  726. ret = brcmf_fweh_activate_events(ifp);
  727. if (ret < 0)
  728. goto fail;
  729. ret = brcmf_net_attach(ifp, false);
  730. fail:
  731. if (ret < 0) {
  732. brcmf_err("failed: %d\n", ret);
  733. if (drvr->config)
  734. brcmf_cfg80211_detach(drvr->config);
  735. if (drvr->fws) {
  736. brcmf_fws_del_interface(ifp);
  737. brcmf_fws_deinit(drvr);
  738. }
  739. free_netdev(ifp->ndev);
  740. drvr->iflist[0] = NULL;
  741. if (p2p_ifp) {
  742. free_netdev(p2p_ifp->ndev);
  743. drvr->iflist[1] = NULL;
  744. }
  745. return ret;
  746. }
  747. if ((brcmf_p2p_enable) && (p2p_ifp))
  748. brcmf_net_p2p_attach(p2p_ifp);
  749. return 0;
  750. }
  751. static void brcmf_bus_detach(struct brcmf_pub *drvr)
  752. {
  753. brcmf_dbg(TRACE, "Enter\n");
  754. if (drvr) {
  755. /* Stop the protocol module */
  756. brcmf_proto_stop(drvr);
  757. /* Stop the bus module */
  758. brcmf_bus_stop(drvr->bus_if);
  759. }
  760. }
  761. void brcmf_dev_reset(struct device *dev)
  762. {
  763. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  764. struct brcmf_pub *drvr = bus_if->drvr;
  765. if (drvr == NULL)
  766. return;
  767. if (drvr->iflist[0])
  768. brcmf_fil_cmd_int_set(drvr->iflist[0], BRCMF_C_TERMINATED, 1);
  769. }
  770. void brcmf_detach(struct device *dev)
  771. {
  772. s32 i;
  773. struct brcmf_bus *bus_if = dev_get_drvdata(dev);
  774. struct brcmf_pub *drvr = bus_if->drvr;
  775. brcmf_dbg(TRACE, "Enter\n");
  776. if (drvr == NULL)
  777. return;
  778. /* stop firmware event handling */
  779. brcmf_fweh_detach(drvr);
  780. /* make sure primary interface removed last */
  781. for (i = BRCMF_MAX_IFS-1; i > -1; i--)
  782. if (drvr->iflist[i]) {
  783. brcmf_fws_del_interface(drvr->iflist[i]);
  784. brcmf_del_if(drvr, i);
  785. }
  786. brcmf_bus_detach(drvr);
  787. if (drvr->prot)
  788. brcmf_proto_detach(drvr);
  789. if (drvr->fws)
  790. brcmf_fws_deinit(drvr);
  791. brcmf_debugfs_detach(drvr);
  792. bus_if->drvr = NULL;
  793. kfree(drvr);
  794. }
  795. static int brcmf_get_pend_8021x_cnt(struct brcmf_if *ifp)
  796. {
  797. return atomic_read(&ifp->pend_8021x_cnt);
  798. }
  799. int brcmf_netdev_wait_pend8021x(struct net_device *ndev)
  800. {
  801. struct brcmf_if *ifp = netdev_priv(ndev);
  802. int err;
  803. err = wait_event_timeout(ifp->pend_8021x_wait,
  804. !brcmf_get_pend_8021x_cnt(ifp),
  805. msecs_to_jiffies(MAX_WAIT_FOR_8021X_TX));
  806. WARN_ON(!err);
  807. return !err;
  808. }
  809. /*
  810. * return chip id and rev of the device encoded in u32.
  811. */
  812. u32 brcmf_get_chip_info(struct brcmf_if *ifp)
  813. {
  814. struct brcmf_bus *bus = ifp->drvr->bus_if;
  815. return bus->chip << 4 | bus->chiprev;
  816. }
  817. static void brcmf_driver_init(struct work_struct *work)
  818. {
  819. brcmf_debugfs_init();
  820. #ifdef CONFIG_BRCMFMAC_SDIO
  821. brcmf_sdio_init();
  822. #endif
  823. #ifdef CONFIG_BRCMFMAC_USB
  824. brcmf_usb_init();
  825. #endif
  826. }
  827. static DECLARE_WORK(brcmf_driver_work, brcmf_driver_init);
  828. static int __init brcmfmac_module_init(void)
  829. {
  830. if (!schedule_work(&brcmf_driver_work))
  831. return -EBUSY;
  832. return 0;
  833. }
  834. static void __exit brcmfmac_module_exit(void)
  835. {
  836. cancel_work_sync(&brcmf_driver_work);
  837. #ifdef CONFIG_BRCMFMAC_SDIO
  838. brcmf_sdio_exit();
  839. #endif
  840. #ifdef CONFIG_BRCMFMAC_USB
  841. brcmf_usb_exit();
  842. #endif
  843. brcmf_debugfs_exit();
  844. }
  845. module_init(brcmfmac_module_init);
  846. module_exit(brcmfmac_module_exit);