islpci_eth.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510
  1. /*
  2. *
  3. * Copyright (C) 2002 Intersil Americas Inc.
  4. * Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; either version 2 of the License
  8. *
  9. * This program is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write to the Free Software
  16. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  17. *
  18. */
  19. #include <linux/module.h>
  20. #include <linux/pci.h>
  21. #include <linux/delay.h>
  22. #include <linux/netdevice.h>
  23. #include <linux/etherdevice.h>
  24. #include <linux/if_arp.h>
  25. #include "prismcompat.h"
  26. #include "isl_38xx.h"
  27. #include "islpci_eth.h"
  28. #include "islpci_mgt.h"
  29. #include "oid_mgt.h"
  30. /******************************************************************************
  31. Network Interface functions
  32. ******************************************************************************/
  33. void
  34. islpci_eth_cleanup_transmit(islpci_private *priv,
  35. isl38xx_control_block *control_block)
  36. {
  37. struct sk_buff *skb;
  38. u32 index;
  39. /* compare the control block read pointer with the free pointer */
  40. while (priv->free_data_tx !=
  41. le32_to_cpu(control_block->
  42. device_curr_frag[ISL38XX_CB_TX_DATA_LQ])) {
  43. /* read the index of the first fragment to be freed */
  44. index = priv->free_data_tx % ISL38XX_CB_TX_QSIZE;
  45. /* check for holes in the arrays caused by multi fragment frames
  46. * searching for the last fragment of a frame */
  47. if (priv->pci_map_tx_address[index] != (dma_addr_t) NULL) {
  48. /* entry is the last fragment of a frame
  49. * free the skb structure and unmap pci memory */
  50. skb = priv->data_low_tx[index];
  51. #if VERBOSE > SHOW_ERROR_MESSAGES
  52. DEBUG(SHOW_TRACING,
  53. "cleanup skb %p skb->data %p skb->len %u truesize %u\n ",
  54. skb, skb->data, skb->len, skb->truesize);
  55. #endif
  56. pci_unmap_single(priv->pdev,
  57. priv->pci_map_tx_address[index],
  58. skb->len, PCI_DMA_TODEVICE);
  59. dev_kfree_skb_irq(skb);
  60. skb = NULL;
  61. }
  62. /* increment the free data low queue pointer */
  63. priv->free_data_tx++;
  64. }
  65. }
  66. int
  67. islpci_eth_transmit(struct sk_buff *skb, struct net_device *ndev)
  68. {
  69. islpci_private *priv = netdev_priv(ndev);
  70. isl38xx_control_block *cb = priv->control_block;
  71. u32 index;
  72. dma_addr_t pci_map_address;
  73. int frame_size;
  74. isl38xx_fragment *fragment;
  75. int offset;
  76. struct sk_buff *newskb;
  77. int newskb_offset;
  78. unsigned long flags;
  79. unsigned char wds_mac[6];
  80. u32 curr_frag;
  81. int err = 0;
  82. #if VERBOSE > SHOW_ERROR_MESSAGES
  83. DEBUG(SHOW_FUNCTION_CALLS, "islpci_eth_transmit \n");
  84. #endif
  85. /* lock the driver code */
  86. spin_lock_irqsave(&priv->slock, flags);
  87. /* check whether the destination queue has enough fragments for the frame */
  88. curr_frag = le32_to_cpu(cb->driver_curr_frag[ISL38XX_CB_TX_DATA_LQ]);
  89. if (unlikely(curr_frag - priv->free_data_tx >= ISL38XX_CB_TX_QSIZE)) {
  90. printk(KERN_ERR "%s: transmit device queue full when awake\n",
  91. ndev->name);
  92. netif_stop_queue(ndev);
  93. /* trigger the device */
  94. isl38xx_w32_flush(priv->device_base, ISL38XX_DEV_INT_UPDATE,
  95. ISL38XX_DEV_INT_REG);
  96. udelay(ISL38XX_WRITEIO_DELAY);
  97. err = -EBUSY;
  98. goto drop_free;
  99. }
  100. /* Check alignment and WDS frame formatting. The start of the packet should
  101. * be aligned on a 4-byte boundary. If WDS is enabled add another 6 bytes
  102. * and add WDS address information */
  103. if (likely(((long) skb->data & 0x03) | init_wds)) {
  104. /* get the number of bytes to add and re-allign */
  105. offset = (4 - (long) skb->data) & 0x03;
  106. offset += init_wds ? 6 : 0;
  107. /* check whether the current skb can be used */
  108. if (!skb_cloned(skb) && (skb_tailroom(skb) >= offset)) {
  109. unsigned char *src = skb->data;
  110. #if VERBOSE > SHOW_ERROR_MESSAGES
  111. DEBUG(SHOW_TRACING, "skb offset %i wds %i\n", offset,
  112. init_wds);
  113. #endif
  114. /* align the buffer on 4-byte boundary */
  115. skb_reserve(skb, (4 - (long) skb->data) & 0x03);
  116. if (init_wds) {
  117. /* wds requires an additional address field of 6 bytes */
  118. skb_put(skb, 6);
  119. #ifdef ISLPCI_ETH_DEBUG
  120. printk("islpci_eth_transmit:wds_mac\n");
  121. #endif
  122. memmove(skb->data + 6, src, skb->len);
  123. memcpy(skb->data, wds_mac, 6);
  124. } else {
  125. memmove(skb->data, src, skb->len);
  126. }
  127. #if VERBOSE > SHOW_ERROR_MESSAGES
  128. DEBUG(SHOW_TRACING, "memmove %p %p %i \n", skb->data,
  129. src, skb->len);
  130. #endif
  131. } else {
  132. newskb =
  133. dev_alloc_skb(init_wds ? skb->len + 6 : skb->len);
  134. if (unlikely(newskb == NULL)) {
  135. printk(KERN_ERR "%s: Cannot allocate skb\n",
  136. ndev->name);
  137. err = -ENOMEM;
  138. goto drop_free;
  139. }
  140. newskb_offset = (4 - (long) newskb->data) & 0x03;
  141. /* Check if newskb->data is aligned */
  142. if (newskb_offset)
  143. skb_reserve(newskb, newskb_offset);
  144. skb_put(newskb, init_wds ? skb->len + 6 : skb->len);
  145. if (init_wds) {
  146. memcpy(newskb->data + 6, skb->data, skb->len);
  147. memcpy(newskb->data, wds_mac, 6);
  148. #ifdef ISLPCI_ETH_DEBUG
  149. printk("islpci_eth_transmit:wds_mac\n");
  150. #endif
  151. } else
  152. memcpy(newskb->data, skb->data, skb->len);
  153. #if VERBOSE > SHOW_ERROR_MESSAGES
  154. DEBUG(SHOW_TRACING, "memcpy %p %p %i wds %i\n",
  155. newskb->data, skb->data, skb->len, init_wds);
  156. #endif
  157. newskb->dev = skb->dev;
  158. dev_kfree_skb_irq(skb);
  159. skb = newskb;
  160. }
  161. }
  162. /* display the buffer contents for debugging */
  163. #if VERBOSE > SHOW_ERROR_MESSAGES
  164. DEBUG(SHOW_BUFFER_CONTENTS, "\ntx %p ", skb->data);
  165. display_buffer((char *) skb->data, skb->len);
  166. #endif
  167. /* map the skb buffer to pci memory for DMA operation */
  168. pci_map_address = pci_map_single(priv->pdev,
  169. (void *) skb->data, skb->len,
  170. PCI_DMA_TODEVICE);
  171. if (unlikely(pci_map_address == 0)) {
  172. printk(KERN_WARNING "%s: cannot map buffer to PCI\n",
  173. ndev->name);
  174. err = -EIO;
  175. goto drop_free;
  176. }
  177. /* Place the fragment in the control block structure. */
  178. index = curr_frag % ISL38XX_CB_TX_QSIZE;
  179. fragment = &cb->tx_data_low[index];
  180. priv->pci_map_tx_address[index] = pci_map_address;
  181. /* store the skb address for future freeing */
  182. priv->data_low_tx[index] = skb;
  183. /* set the proper fragment start address and size information */
  184. frame_size = skb->len;
  185. fragment->size = cpu_to_le16(frame_size);
  186. fragment->flags = cpu_to_le16(0); /* set to 1 if more fragments */
  187. fragment->address = cpu_to_le32(pci_map_address);
  188. curr_frag++;
  189. /* The fragment address in the control block must have been
  190. * written before announcing the frame buffer to device. */
  191. wmb();
  192. cb->driver_curr_frag[ISL38XX_CB_TX_DATA_LQ] = cpu_to_le32(curr_frag);
  193. if (curr_frag - priv->free_data_tx + ISL38XX_MIN_QTHRESHOLD
  194. > ISL38XX_CB_TX_QSIZE) {
  195. /* stop sends from upper layers */
  196. netif_stop_queue(ndev);
  197. /* set the full flag for the transmission queue */
  198. priv->data_low_tx_full = 1;
  199. }
  200. /* set the transmission time */
  201. ndev->trans_start = jiffies;
  202. priv->statistics.tx_packets++;
  203. priv->statistics.tx_bytes += skb->len;
  204. /* trigger the device */
  205. islpci_trigger(priv);
  206. /* unlock the driver code */
  207. spin_unlock_irqrestore(&priv->slock, flags);
  208. return 0;
  209. drop_free:
  210. priv->statistics.tx_dropped++;
  211. spin_unlock_irqrestore(&priv->slock, flags);
  212. dev_kfree_skb(skb);
  213. return err;
  214. }
  215. static inline int
  216. islpci_monitor_rx(islpci_private *priv, struct sk_buff **skb)
  217. {
  218. /* The card reports full 802.11 packets but with a 20 bytes
  219. * header and without the FCS. But there a is a bit that
  220. * indicates if the packet is corrupted :-) */
  221. struct rfmon_header *hdr = (struct rfmon_header *) (*skb)->data;
  222. if (hdr->flags & 0x01)
  223. /* This one is bad. Drop it ! */
  224. return -1;
  225. if (priv->ndev->type == ARPHRD_IEEE80211_PRISM) {
  226. struct avs_80211_1_header *avs;
  227. /* extract the relevant data from the header */
  228. u32 clock = le32_to_cpu(hdr->clock);
  229. u8 rate = hdr->rate;
  230. u16 freq = le16_to_cpu(hdr->freq);
  231. u8 rssi = hdr->rssi;
  232. skb_pull(*skb, sizeof (struct rfmon_header));
  233. if (skb_headroom(*skb) < sizeof (struct avs_80211_1_header)) {
  234. struct sk_buff *newskb = skb_copy_expand(*skb,
  235. sizeof (struct
  236. avs_80211_1_header),
  237. 0, GFP_ATOMIC);
  238. if (newskb) {
  239. dev_kfree_skb_irq(*skb);
  240. *skb = newskb;
  241. } else
  242. return -1;
  243. /* This behavior is not very subtile... */
  244. }
  245. /* make room for the new header and fill it. */
  246. avs =
  247. (struct avs_80211_1_header *) skb_push(*skb,
  248. sizeof (struct
  249. avs_80211_1_header));
  250. avs->version = cpu_to_be32(P80211CAPTURE_VERSION);
  251. avs->length = cpu_to_be32(sizeof (struct avs_80211_1_header));
  252. avs->mactime = cpu_to_be64(le64_to_cpu(clock));
  253. avs->hosttime = cpu_to_be64(jiffies);
  254. avs->phytype = cpu_to_be32(6); /*OFDM: 6 for (g), 8 for (a) */
  255. avs->channel = cpu_to_be32(channel_of_freq(freq));
  256. avs->datarate = cpu_to_be32(rate * 5);
  257. avs->antenna = cpu_to_be32(0); /*unknown */
  258. avs->priority = cpu_to_be32(0); /*unknown */
  259. avs->ssi_type = cpu_to_be32(3); /*2: dBm, 3: raw RSSI */
  260. avs->ssi_signal = cpu_to_be32(rssi & 0x7f);
  261. avs->ssi_noise = cpu_to_be32(priv->local_iwstatistics.qual.noise); /*better than 'undefined', I assume */
  262. avs->preamble = cpu_to_be32(0); /*unknown */
  263. avs->encoding = cpu_to_be32(0); /*unknown */
  264. } else
  265. skb_pull(*skb, sizeof (struct rfmon_header));
  266. (*skb)->protocol = htons(ETH_P_802_2);
  267. (*skb)->mac.raw = (*skb)->data;
  268. (*skb)->pkt_type = PACKET_OTHERHOST;
  269. return 0;
  270. }
  271. int
  272. islpci_eth_receive(islpci_private *priv)
  273. {
  274. struct net_device *ndev = priv->ndev;
  275. isl38xx_control_block *control_block = priv->control_block;
  276. struct sk_buff *skb;
  277. u16 size;
  278. u32 index, offset;
  279. unsigned char *src;
  280. int discard = 0;
  281. #if VERBOSE > SHOW_ERROR_MESSAGES
  282. DEBUG(SHOW_FUNCTION_CALLS, "islpci_eth_receive \n");
  283. #endif
  284. /* the device has written an Ethernet frame in the data area
  285. * of the sk_buff without updating the structure, do it now */
  286. index = priv->free_data_rx % ISL38XX_CB_RX_QSIZE;
  287. size = le16_to_cpu(control_block->rx_data_low[index].size);
  288. skb = priv->data_low_rx[index];
  289. offset = ((unsigned long)
  290. le32_to_cpu(control_block->rx_data_low[index].address) -
  291. (unsigned long) skb->data) & 3;
  292. #if VERBOSE > SHOW_ERROR_MESSAGES
  293. DEBUG(SHOW_TRACING,
  294. "frq->addr %x skb->data %p skb->len %u offset %u truesize %u\n ",
  295. control_block->rx_data_low[priv->free_data_rx].address, skb->data,
  296. skb->len, offset, skb->truesize);
  297. #endif
  298. /* delete the streaming DMA mapping before processing the skb */
  299. pci_unmap_single(priv->pdev,
  300. priv->pci_map_rx_address[index],
  301. MAX_FRAGMENT_SIZE_RX + 2, PCI_DMA_FROMDEVICE);
  302. /* update the skb structure and allign the buffer */
  303. skb_put(skb, size);
  304. if (offset) {
  305. /* shift the buffer allocation offset bytes to get the right frame */
  306. skb_pull(skb, 2);
  307. skb_put(skb, 2);
  308. }
  309. #if VERBOSE > SHOW_ERROR_MESSAGES
  310. /* display the buffer contents for debugging */
  311. DEBUG(SHOW_BUFFER_CONTENTS, "\nrx %p ", skb->data);
  312. display_buffer((char *) skb->data, skb->len);
  313. #endif
  314. /* check whether WDS is enabled and whether the data frame is a WDS frame */
  315. if (init_wds) {
  316. /* WDS enabled, check for the wds address on the first 6 bytes of the buffer */
  317. src = skb->data + 6;
  318. memmove(skb->data, src, skb->len - 6);
  319. skb_trim(skb, skb->len - 6);
  320. }
  321. #if VERBOSE > SHOW_ERROR_MESSAGES
  322. DEBUG(SHOW_TRACING, "Fragment size %i in skb at %p\n", size, skb);
  323. DEBUG(SHOW_TRACING, "Skb data at %p, length %i\n", skb->data, skb->len);
  324. /* display the buffer contents for debugging */
  325. DEBUG(SHOW_BUFFER_CONTENTS, "\nrx %p ", skb->data);
  326. display_buffer((char *) skb->data, skb->len);
  327. #endif
  328. /* do some additional sk_buff and network layer parameters */
  329. skb->dev = ndev;
  330. /* take care of monitor mode and spy monitoring. */
  331. if (unlikely(priv->iw_mode == IW_MODE_MONITOR))
  332. discard = islpci_monitor_rx(priv, &skb);
  333. else {
  334. if (unlikely(skb->data[2 * ETH_ALEN] == 0)) {
  335. /* The packet has a rx_annex. Read it for spy monitoring, Then
  336. * remove it, while keeping the 2 leading MAC addr.
  337. */
  338. struct iw_quality wstats;
  339. struct rx_annex_header *annex =
  340. (struct rx_annex_header *) skb->data;
  341. wstats.level = annex->rfmon.rssi;
  342. /* The noise value can be a bit outdated if nobody's
  343. * reading wireless stats... */
  344. wstats.noise = priv->local_iwstatistics.qual.noise;
  345. wstats.qual = wstats.level - wstats.noise;
  346. wstats.updated = 0x07;
  347. /* Update spy records */
  348. wireless_spy_update(ndev, annex->addr2, &wstats);
  349. memcpy(skb->data + sizeof (struct rfmon_header),
  350. skb->data, 2 * ETH_ALEN);
  351. skb_pull(skb, sizeof (struct rfmon_header));
  352. }
  353. skb->protocol = eth_type_trans(skb, ndev);
  354. }
  355. skb->ip_summed = CHECKSUM_NONE;
  356. priv->statistics.rx_packets++;
  357. priv->statistics.rx_bytes += size;
  358. /* deliver the skb to the network layer */
  359. #ifdef ISLPCI_ETH_DEBUG
  360. printk
  361. ("islpci_eth_receive:netif_rx %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
  362. skb->data[0], skb->data[1], skb->data[2], skb->data[3],
  363. skb->data[4], skb->data[5]);
  364. #endif
  365. if (unlikely(discard)) {
  366. dev_kfree_skb_irq(skb);
  367. skb = NULL;
  368. } else
  369. netif_rx(skb);
  370. /* increment the read index for the rx data low queue */
  371. priv->free_data_rx++;
  372. /* add one or more sk_buff structures */
  373. while (index =
  374. le32_to_cpu(control_block->
  375. driver_curr_frag[ISL38XX_CB_RX_DATA_LQ]),
  376. index - priv->free_data_rx < ISL38XX_CB_RX_QSIZE) {
  377. /* allocate an sk_buff for received data frames storage
  378. * include any required allignment operations */
  379. skb = dev_alloc_skb(MAX_FRAGMENT_SIZE_RX + 2);
  380. if (unlikely(skb == NULL)) {
  381. /* error allocating an sk_buff structure elements */
  382. DEBUG(SHOW_ERROR_MESSAGES, "Error allocating skb \n");
  383. break;
  384. }
  385. skb_reserve(skb, (4 - (long) skb->data) & 0x03);
  386. /* store the new skb structure pointer */
  387. index = index % ISL38XX_CB_RX_QSIZE;
  388. priv->data_low_rx[index] = skb;
  389. #if VERBOSE > SHOW_ERROR_MESSAGES
  390. DEBUG(SHOW_TRACING,
  391. "new alloc skb %p skb->data %p skb->len %u index %u truesize %u\n ",
  392. skb, skb->data, skb->len, index, skb->truesize);
  393. #endif
  394. /* set the streaming DMA mapping for proper PCI bus operation */
  395. priv->pci_map_rx_address[index] =
  396. pci_map_single(priv->pdev, (void *) skb->data,
  397. MAX_FRAGMENT_SIZE_RX + 2,
  398. PCI_DMA_FROMDEVICE);
  399. if (unlikely(priv->pci_map_rx_address[index] == (dma_addr_t) NULL)) {
  400. /* error mapping the buffer to device accessable memory address */
  401. DEBUG(SHOW_ERROR_MESSAGES,
  402. "Error mapping DMA address\n");
  403. /* free the skbuf structure before aborting */
  404. dev_kfree_skb_irq((struct sk_buff *) skb);
  405. skb = NULL;
  406. break;
  407. }
  408. /* update the fragment address */
  409. control_block->rx_data_low[index].address = cpu_to_le32((u32)
  410. priv->
  411. pci_map_rx_address
  412. [index]);
  413. wmb();
  414. /* increment the driver read pointer */
  415. add_le32p((u32 *) &control_block->
  416. driver_curr_frag[ISL38XX_CB_RX_DATA_LQ], 1);
  417. }
  418. /* trigger the device */
  419. islpci_trigger(priv);
  420. return 0;
  421. }
  422. void
  423. islpci_do_reset_and_wake(void *data)
  424. {
  425. islpci_private *priv = (islpci_private *) data;
  426. islpci_reset(priv, 1);
  427. netif_wake_queue(priv->ndev);
  428. priv->reset_task_pending = 0;
  429. }
  430. void
  431. islpci_eth_tx_timeout(struct net_device *ndev)
  432. {
  433. islpci_private *priv = netdev_priv(ndev);
  434. struct net_device_stats *statistics = &priv->statistics;
  435. /* increment the transmit error counter */
  436. statistics->tx_errors++;
  437. printk(KERN_WARNING "%s: tx_timeout", ndev->name);
  438. if (!priv->reset_task_pending) {
  439. priv->reset_task_pending = 1;
  440. printk(", scheduling a reset");
  441. netif_stop_queue(ndev);
  442. schedule_work(&priv->reset_task);
  443. }
  444. printk("\n");
  445. }