wimax/i2400m: fix i2400m->wake_tx_skb handling
[~shefty/rdma-dev.git] / drivers / net / wimax / i2400m / netdev.c
1 /*
2  * Intel Wireless WiMAX Connection 2400m
3  * Glue with the networking stack
4  *
5  *
6  * Copyright (C) 2007 Intel Corporation <linux-wimax@intel.com>
7  * Yanir Lubetkin <yanirx.lubetkin@intel.com>
8  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License version
12  * 2 as published by the Free Software Foundation.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22  * 02110-1301, USA.
23  *
24  *
25  * This implements an ethernet device for the i2400m.
26  *
27  * We fake being an ethernet device to simplify the support from user
28  * space and from the other side. The world is (sadly) configured to
29  * take in only Ethernet devices...
30  *
31  * Because of this, when using firmwares <= v1.3, there is an
32  * copy-each-rxed-packet overhead on the RX path. Each IP packet has
33  * to be reallocated to add an ethernet header (as there is no space
34  * in what we get from the device). This is a known drawback and
35  * firmwares >= 1.4 add header space that can be used to insert the
36  * ethernet header without having to reallocate and copy.
37  *
38  * TX error handling is tricky; because we have to FIFO/queue the
39  * buffers for transmission (as the hardware likes it aggregated), we
40  * just give the skb to the TX subsystem and by the time it is
41  * transmitted, we have long forgotten about it. So we just don't care
42  * too much about it.
43  *
44  * Note that when the device is in idle mode with the basestation, we
45  * need to negotiate coming back up online. That involves negotiation
46  * and possible user space interaction. Thus, we defer to a workqueue
47  * to do all that. By default, we only queue a single packet and drop
48  * the rest, as potentially the time to go back from idle to normal is
49  * long.
50  *
51  * ROADMAP
52  *
53  * i2400m_open         Called on ifconfig up
54  * i2400m_stop         Called on ifconfig down
55  *
56  * i2400m_hard_start_xmit Called by the network stack to send a packet
57  *   i2400m_net_wake_tx   Wake up device from basestation-IDLE & TX
58  *     i2400m_wake_tx_work
59  *       i2400m_cmd_exit_idle
60  *       i2400m_tx
61  *   i2400m_net_tx        TX a data frame
62  *     i2400m_tx
63  *
64  * i2400m_change_mtu      Called on ifconfig mtu XXX
65  *
66  * i2400m_tx_timeout      Called when the device times out
67  *
68  * i2400m_net_rx          Called by the RX code when a data frame is
69  *                        available (firmware <= 1.3)
70  * i2400m_net_erx         Called by the RX code when a data frame is
71  *                        available (firmware >= 1.4).
72  * i2400m_netdev_setup    Called to setup all the netdev stuff from
73  *                        alloc_netdev.
74  */
75 #include <linux/if_arp.h>
76 #include <linux/slab.h>
77 #include <linux/netdevice.h>
78 #include <linux/ethtool.h>
79 #include <linux/export.h>
80 #include "i2400m.h"
81
82
83 #define D_SUBMODULE netdev
84 #include "debug-levels.h"
85
86 enum {
87 /* netdev interface */
88         /* 20 secs? yep, this is the maximum timeout that the device
89          * might take to get out of IDLE / negotiate it with the base
90          * station. We add 1sec for good measure. */
91         I2400M_TX_TIMEOUT = 21 * HZ,
92         /*
93          * Experimentation has determined that, 20 to be a good value
94          * for minimizing the jitter in the throughput.
95          */
96         I2400M_TX_QLEN = 20,
97 };
98
99
100 static
101 int i2400m_open(struct net_device *net_dev)
102 {
103         int result;
104         struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
105         struct device *dev = i2400m_dev(i2400m);
106
107         d_fnstart(3, dev, "(net_dev %p [i2400m %p])\n", net_dev, i2400m);
108         /* Make sure we wait until init is complete... */
109         mutex_lock(&i2400m->init_mutex);
110         if (i2400m->updown)
111                 result = 0;
112         else
113                 result = -EBUSY;
114         mutex_unlock(&i2400m->init_mutex);
115         d_fnend(3, dev, "(net_dev %p [i2400m %p]) = %d\n",
116                 net_dev, i2400m, result);
117         return result;
118 }
119
120
121 static
122 int i2400m_stop(struct net_device *net_dev)
123 {
124         struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
125         struct device *dev = i2400m_dev(i2400m);
126
127         d_fnstart(3, dev, "(net_dev %p [i2400m %p])\n", net_dev, i2400m);
128         i2400m_net_wake_stop(i2400m);
129         d_fnend(3, dev, "(net_dev %p [i2400m %p]) = 0\n", net_dev, i2400m);
130         return 0;
131 }
132
133
134 /*
135  * Wake up the device and transmit a held SKB, then restart the net queue
136  *
137  * When the device goes into basestation-idle mode, we need to tell it
138  * to exit that mode; it will negotiate with the base station, user
139  * space may have to intervene to rehandshake crypto and then tell us
140  * when it is ready to transmit the packet we have "queued". Still we
141  * need to give it sometime after it reports being ok.
142  *
143  * On error, there is not much we can do. If the error was on TX, we
144  * still wake the queue up to see if the next packet will be luckier.
145  *
146  * If _cmd_exit_idle() fails...well, it could be many things; most
147  * commonly it is that something else took the device out of IDLE mode
148  * (for example, the base station). In that case we get an -EILSEQ and
149  * we are just going to ignore that one. If the device is back to
150  * connected, then fine -- if it is someother state, the packet will
151  * be dropped anyway.
152  */
153 void i2400m_wake_tx_work(struct work_struct *ws)
154 {
155         int result;
156         struct i2400m *i2400m = container_of(ws, struct i2400m, wake_tx_ws);
157         struct net_device *net_dev = i2400m->wimax_dev.net_dev;
158         struct device *dev = i2400m_dev(i2400m);
159         struct sk_buff *skb;
160         unsigned long flags;
161
162         spin_lock_irqsave(&i2400m->tx_lock, flags);
163         skb = i2400m->wake_tx_skb;
164         i2400m->wake_tx_skb = NULL;
165         spin_unlock_irqrestore(&i2400m->tx_lock, flags);
166
167         d_fnstart(3, dev, "(ws %p i2400m %p skb %p)\n", ws, i2400m, skb);
168         result = -EINVAL;
169         if (skb == NULL) {
170                 dev_err(dev, "WAKE&TX: skb disappeared!\n");
171                 goto out_put;
172         }
173         /* If we have, somehow, lost the connection after this was
174          * queued, don't do anything; this might be the device got
175          * reset or just disconnected. */
176         if (unlikely(!netif_carrier_ok(net_dev)))
177                 goto out_kfree;
178         result = i2400m_cmd_exit_idle(i2400m);
179         if (result == -EILSEQ)
180                 result = 0;
181         if (result < 0) {
182                 dev_err(dev, "WAKE&TX: device didn't get out of idle: "
183                         "%d - resetting\n", result);
184                 i2400m_reset(i2400m, I2400M_RT_BUS);
185                 goto error;
186         }
187         result = wait_event_timeout(i2400m->state_wq,
188                                     i2400m->state != I2400M_SS_IDLE,
189                                     net_dev->watchdog_timeo - HZ/2);
190         if (result == 0)
191                 result = -ETIMEDOUT;
192         if (result < 0) {
193                 dev_err(dev, "WAKE&TX: error waiting for device to exit IDLE: "
194                         "%d - resetting\n", result);
195                 i2400m_reset(i2400m, I2400M_RT_BUS);
196                 goto error;
197         }
198         msleep(20);     /* device still needs some time or it drops it */
199         result = i2400m_tx(i2400m, skb->data, skb->len, I2400M_PT_DATA);
200 error:
201         netif_wake_queue(net_dev);
202 out_kfree:
203         kfree_skb(skb); /* refcount transferred by _hard_start_xmit() */
204 out_put:
205         i2400m_put(i2400m);
206         d_fnend(3, dev, "(ws %p i2400m %p skb %p) = void [%d]\n",
207                 ws, i2400m, skb, result);
208 }
209
210
211 /*
212  * Prepare the data payload TX header
213  *
214  * The i2400m expects a 4 byte header in front of a data packet.
215  *
216  * Because we pretend to be an ethernet device, this packet comes with
217  * an ethernet header. Pull it and push our header.
218  */
219 static
220 void i2400m_tx_prep_header(struct sk_buff *skb)
221 {
222         struct i2400m_pl_data_hdr *pl_hdr;
223         skb_pull(skb, ETH_HLEN);
224         pl_hdr = (struct i2400m_pl_data_hdr *) skb_push(skb, sizeof(*pl_hdr));
225         pl_hdr->reserved = 0;
226 }
227
228
229
230 /*
231  * Cleanup resources acquired during i2400m_net_wake_tx()
232  *
233  * This is called by __i2400m_dev_stop and means we have to make sure
234  * the workqueue is flushed from any pending work.
235  */
236 void i2400m_net_wake_stop(struct i2400m *i2400m)
237 {
238         struct device *dev = i2400m_dev(i2400m);
239         struct sk_buff *wake_tx_skb;
240         unsigned long flags;
241
242         d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
243         /*
244          * See i2400m_hard_start_xmit(), references are taken there and
245          * here we release them if the packet was still pending.
246          */
247         cancel_work_sync(&i2400m->wake_tx_ws);
248
249         spin_lock_irqsave(&i2400m->tx_lock, flags);
250         wake_tx_skb = i2400m->wake_tx_skb;
251         i2400m->wake_tx_skb = NULL;
252         spin_unlock_irqrestore(&i2400m->tx_lock, flags);
253
254         if (wake_tx_skb) {
255                 i2400m_put(i2400m);
256                 kfree_skb(wake_tx_skb);
257         }
258
259         d_fnend(3, dev, "(i2400m %p) = void\n", i2400m);
260 }
261
262
263 /*
264  * TX an skb to an idle device
265  *
266  * When the device is in basestation-idle mode, we need to wake it up
267  * and then TX. So we queue a work_struct for doing so.
268  *
269  * We need to get an extra ref for the skb (so it is not dropped), as
270  * well as be careful not to queue more than one request (won't help
271  * at all). If more than one request comes or there are errors, we
272  * just drop the packets (see i2400m_hard_start_xmit()).
273  */
274 static
275 int i2400m_net_wake_tx(struct i2400m *i2400m, struct net_device *net_dev,
276                        struct sk_buff *skb)
277 {
278         int result;
279         struct device *dev = i2400m_dev(i2400m);
280         unsigned long flags;
281
282         d_fnstart(3, dev, "(skb %p net_dev %p)\n", skb, net_dev);
283         if (net_ratelimit()) {
284                 d_printf(3, dev, "WAKE&NETTX: "
285                          "skb %p sending %d bytes to radio\n",
286                          skb, skb->len);
287                 d_dump(4, dev, skb->data, skb->len);
288         }
289         /* We hold a ref count for i2400m and skb, so when
290          * stopping() the device, we need to cancel that work
291          * and if pending, release those resources. */
292         result = 0;
293         spin_lock_irqsave(&i2400m->tx_lock, flags);
294         if (!i2400m->wake_tx_skb) {
295                 netif_stop_queue(net_dev);
296                 i2400m_get(i2400m);
297                 i2400m->wake_tx_skb = skb_get(skb);     /* transfer ref count */
298                 i2400m_tx_prep_header(skb);
299                 result = schedule_work(&i2400m->wake_tx_ws);
300                 WARN_ON(result == 0);
301         }
302         spin_unlock_irqrestore(&i2400m->tx_lock, flags);
303         if (result == 0) {
304                 /* Yes, this happens even if we stopped the
305                  * queue -- blame the queue disciplines that
306                  * queue without looking -- I guess there is a reason
307                  * for that. */
308                 if (net_ratelimit())
309                         d_printf(1, dev, "NETTX: device exiting idle, "
310                                  "dropping skb %p, queue running %d\n",
311                                  skb, netif_queue_stopped(net_dev));
312                 result = -EBUSY;
313         }
314         d_fnend(3, dev, "(skb %p net_dev %p) = %d\n", skb, net_dev, result);
315         return result;
316 }
317
318
319 /*
320  * Transmit a packet to the base station on behalf of the network stack.
321  *
322  * Returns: 0 if ok, < 0 errno code on error.
323  *
324  * We need to pull the ethernet header and add the hardware header,
325  * which is currently set to all zeroes and reserved.
326  */
327 static
328 int i2400m_net_tx(struct i2400m *i2400m, struct net_device *net_dev,
329                   struct sk_buff *skb)
330 {
331         int result;
332         struct device *dev = i2400m_dev(i2400m);
333
334         d_fnstart(3, dev, "(i2400m %p net_dev %p skb %p)\n",
335                   i2400m, net_dev, skb);
336         /* FIXME: check eth hdr, only IPv4 is routed by the device as of now */
337         net_dev->trans_start = jiffies;
338         i2400m_tx_prep_header(skb);
339         d_printf(3, dev, "NETTX: skb %p sending %d bytes to radio\n",
340                  skb, skb->len);
341         d_dump(4, dev, skb->data, skb->len);
342         result = i2400m_tx(i2400m, skb->data, skb->len, I2400M_PT_DATA);
343         d_fnend(3, dev, "(i2400m %p net_dev %p skb %p) = %d\n",
344                 i2400m, net_dev, skb, result);
345         return result;
346 }
347
348
349 /*
350  * Transmit a packet to the base station on behalf of the network stack
351  *
352  *
353  * Returns: NETDEV_TX_OK (always, even in case of error)
354  *
355  * In case of error, we just drop it. Reasons:
356  *
357  *  - we add a hw header to each skb, and if the network stack
358  *    retries, we have no way to know if that skb has it or not.
359  *
360  *  - network protocols have their own drop-recovery mechanisms
361  *
362  *  - there is not much else we can do
363  *
364  * If the device is idle, we need to wake it up; that is an operation
365  * that will sleep. See i2400m_net_wake_tx() for details.
366  */
367 static
368 netdev_tx_t i2400m_hard_start_xmit(struct sk_buff *skb,
369                                          struct net_device *net_dev)
370 {
371         struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
372         struct device *dev = i2400m_dev(i2400m);
373         int result = -1;
374
375         d_fnstart(3, dev, "(skb %p net_dev %p)\n", skb, net_dev);
376
377         if (skb_header_cloned(skb) && 
378             pskb_expand_head(skb, 0, 0, GFP_ATOMIC))
379                 goto drop;
380
381         if (i2400m->state == I2400M_SS_IDLE)
382                 result = i2400m_net_wake_tx(i2400m, net_dev, skb);
383         else
384                 result = i2400m_net_tx(i2400m, net_dev, skb);
385         if (result <  0) {
386 drop:
387                 net_dev->stats.tx_dropped++;
388         } else {
389                 net_dev->stats.tx_packets++;
390                 net_dev->stats.tx_bytes += skb->len;
391         }
392         dev_kfree_skb(skb);
393         d_fnend(3, dev, "(skb %p net_dev %p) = %d\n", skb, net_dev, result);
394         return NETDEV_TX_OK;
395 }
396
397
398 static
399 int i2400m_change_mtu(struct net_device *net_dev, int new_mtu)
400 {
401         int result;
402         struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
403         struct device *dev = i2400m_dev(i2400m);
404
405         if (new_mtu >= I2400M_MAX_MTU) {
406                 dev_err(dev, "Cannot change MTU to %d (max is %d)\n",
407                         new_mtu, I2400M_MAX_MTU);
408                 result = -EINVAL;
409         } else {
410                 net_dev->mtu = new_mtu;
411                 result = 0;
412         }
413         return result;
414 }
415
416
417 static
418 void i2400m_tx_timeout(struct net_device *net_dev)
419 {
420         /*
421          * We might want to kick the device
422          *
423          * There is not much we can do though, as the device requires
424          * that we send the data aggregated. By the time we receive
425          * this, there might be data pending to be sent or not...
426          */
427         net_dev->stats.tx_errors++;
428 }
429
430
431 /*
432  * Create a fake ethernet header
433  *
434  * For emulating an ethernet device, every received IP header has to
435  * be prefixed with an ethernet header. Fake it with the given
436  * protocol.
437  */
438 static
439 void i2400m_rx_fake_eth_header(struct net_device *net_dev,
440                                void *_eth_hdr, __be16 protocol)
441 {
442         struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
443         struct ethhdr *eth_hdr = _eth_hdr;
444
445         memcpy(eth_hdr->h_dest, net_dev->dev_addr, sizeof(eth_hdr->h_dest));
446         memcpy(eth_hdr->h_source, i2400m->src_mac_addr,
447                sizeof(eth_hdr->h_source));
448         eth_hdr->h_proto = protocol;
449 }
450
451
452 /*
453  * i2400m_net_rx - pass a network packet to the stack
454  *
455  * @i2400m: device instance
456  * @skb_rx: the skb where the buffer pointed to by @buf is
457  * @i: 1 if payload is the only one
458  * @buf: pointer to the buffer containing the data
459  * @len: buffer's length
460  *
461  * This is only used now for the v1.3 firmware. It will be deprecated
462  * in >= 2.6.31.
463  *
464  * Note that due to firmware limitations, we don't have space to add
465  * an ethernet header, so we need to copy each packet. Firmware
466  * versions >= v1.4 fix this [see i2400m_net_erx()].
467  *
468  * We just clone the skb and set it up so that it's skb->data pointer
469  * points to "buf" and it's length.
470  *
471  * Note that if the payload is the last (or the only one) in a
472  * multi-payload message, we don't clone the SKB but just reuse it.
473  *
474  * This function is normally run from a thread context. However, we
475  * still use netif_rx() instead of netif_receive_skb() as was
476  * recommended in the mailing list. Reason is in some stress tests
477  * when sending/receiving a lot of data we seem to hit a softlock in
478  * the kernel's TCP implementation [aroudn tcp_delay_timer()]. Using
479  * netif_rx() took care of the issue.
480  *
481  * This is, of course, still open to do more research on why running
482  * with netif_receive_skb() hits this softlock. FIXME.
483  *
484  * FIXME: currently we don't do any efforts at distinguishing if what
485  * we got was an IPv4 or IPv6 header, to setup the protocol field
486  * correctly.
487  */
488 void i2400m_net_rx(struct i2400m *i2400m, struct sk_buff *skb_rx,
489                    unsigned i, const void *buf, int buf_len)
490 {
491         struct net_device *net_dev = i2400m->wimax_dev.net_dev;
492         struct device *dev = i2400m_dev(i2400m);
493         struct sk_buff *skb;
494
495         d_fnstart(2, dev, "(i2400m %p buf %p buf_len %d)\n",
496                   i2400m, buf, buf_len);
497         if (i) {
498                 skb = skb_get(skb_rx);
499                 d_printf(2, dev, "RX: reusing first payload skb %p\n", skb);
500                 skb_pull(skb, buf - (void *) skb->data);
501                 skb_trim(skb, (void *) skb_end_pointer(skb) - buf);
502         } else {
503                 /* Yes, this is bad -- a lot of overhead -- see
504                  * comments at the top of the file */
505                 skb = __netdev_alloc_skb(net_dev, buf_len, GFP_KERNEL);
506                 if (skb == NULL) {
507                         dev_err(dev, "NETRX: no memory to realloc skb\n");
508                         net_dev->stats.rx_dropped++;
509                         goto error_skb_realloc;
510                 }
511                 memcpy(skb_put(skb, buf_len), buf, buf_len);
512         }
513         i2400m_rx_fake_eth_header(i2400m->wimax_dev.net_dev,
514                                   skb->data - ETH_HLEN,
515                                   cpu_to_be16(ETH_P_IP));
516         skb_set_mac_header(skb, -ETH_HLEN);
517         skb->dev = i2400m->wimax_dev.net_dev;
518         skb->protocol = htons(ETH_P_IP);
519         net_dev->stats.rx_packets++;
520         net_dev->stats.rx_bytes += buf_len;
521         d_printf(3, dev, "NETRX: receiving %d bytes to network stack\n",
522                 buf_len);
523         d_dump(4, dev, buf, buf_len);
524         netif_rx_ni(skb);       /* see notes in function header */
525 error_skb_realloc:
526         d_fnend(2, dev, "(i2400m %p buf %p buf_len %d) = void\n",
527                 i2400m, buf, buf_len);
528 }
529
530
531 /*
532  * i2400m_net_erx - pass a network packet to the stack (extended version)
533  *
534  * @i2400m: device descriptor
535  * @skb: the skb where the packet is - the skb should be set to point
536  *     at the IP packet; this function will add ethernet headers if
537  *     needed.
538  * @cs: packet type
539  *
540  * This is only used now for firmware >= v1.4. Note it is quite
541  * similar to i2400m_net_rx() (used only for v1.3 firmware).
542  *
543  * This function is normally run from a thread context. However, we
544  * still use netif_rx() instead of netif_receive_skb() as was
545  * recommended in the mailing list. Reason is in some stress tests
546  * when sending/receiving a lot of data we seem to hit a softlock in
547  * the kernel's TCP implementation [aroudn tcp_delay_timer()]. Using
548  * netif_rx() took care of the issue.
549  *
550  * This is, of course, still open to do more research on why running
551  * with netif_receive_skb() hits this softlock. FIXME.
552  */
553 void i2400m_net_erx(struct i2400m *i2400m, struct sk_buff *skb,
554                     enum i2400m_cs cs)
555 {
556         struct net_device *net_dev = i2400m->wimax_dev.net_dev;
557         struct device *dev = i2400m_dev(i2400m);
558         int protocol;
559
560         d_fnstart(2, dev, "(i2400m %p skb %p [%u] cs %d)\n",
561                   i2400m, skb, skb->len, cs);
562         switch(cs) {
563         case I2400M_CS_IPV4_0:
564         case I2400M_CS_IPV4:
565                 protocol = ETH_P_IP;
566                 i2400m_rx_fake_eth_header(i2400m->wimax_dev.net_dev,
567                                           skb->data - ETH_HLEN,
568                                           cpu_to_be16(ETH_P_IP));
569                 skb_set_mac_header(skb, -ETH_HLEN);
570                 skb->dev = i2400m->wimax_dev.net_dev;
571                 skb->protocol = htons(ETH_P_IP);
572                 net_dev->stats.rx_packets++;
573                 net_dev->stats.rx_bytes += skb->len;
574                 break;
575         default:
576                 dev_err(dev, "ERX: BUG? CS type %u unsupported\n", cs);
577                 goto error;
578
579         }
580         d_printf(3, dev, "ERX: receiving %d bytes to the network stack\n",
581                  skb->len);
582         d_dump(4, dev, skb->data, skb->len);
583         netif_rx_ni(skb);       /* see notes in function header */
584 error:
585         d_fnend(2, dev, "(i2400m %p skb %p [%u] cs %d) = void\n",
586                 i2400m, skb, skb->len, cs);
587 }
588
589 static const struct net_device_ops i2400m_netdev_ops = {
590         .ndo_open = i2400m_open,
591         .ndo_stop = i2400m_stop,
592         .ndo_start_xmit = i2400m_hard_start_xmit,
593         .ndo_tx_timeout = i2400m_tx_timeout,
594         .ndo_change_mtu = i2400m_change_mtu,
595 };
596
597 static void i2400m_get_drvinfo(struct net_device *net_dev,
598                                struct ethtool_drvinfo *info)
599 {
600         struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
601
602         strncpy(info->driver, KBUILD_MODNAME, sizeof(info->driver) - 1);
603         strncpy(info->fw_version,
604                 i2400m->fw_name ? : "", sizeof(info->fw_version) - 1);
605         if (net_dev->dev.parent)
606                 strncpy(info->bus_info, dev_name(net_dev->dev.parent),
607                         sizeof(info->bus_info) - 1);
608 }
609
610 static const struct ethtool_ops i2400m_ethtool_ops = {
611         .get_drvinfo = i2400m_get_drvinfo,
612         .get_link = ethtool_op_get_link,
613 };
614
615 /**
616  * i2400m_netdev_setup - Setup setup @net_dev's i2400m private data
617  *
618  * Called by alloc_netdev()
619  */
620 void i2400m_netdev_setup(struct net_device *net_dev)
621 {
622         d_fnstart(3, NULL, "(net_dev %p)\n", net_dev);
623         ether_setup(net_dev);
624         net_dev->mtu = I2400M_MAX_MTU;
625         net_dev->tx_queue_len = I2400M_TX_QLEN;
626         net_dev->features =
627                   NETIF_F_VLAN_CHALLENGED
628                 | NETIF_F_HIGHDMA;
629         net_dev->flags =
630                 IFF_NOARP               /* i2400m is apure IP device */
631                 & (~IFF_BROADCAST       /* i2400m is P2P */
632                    & ~IFF_MULTICAST);
633         net_dev->watchdog_timeo = I2400M_TX_TIMEOUT;
634         net_dev->netdev_ops = &i2400m_netdev_ops;
635         net_dev->ethtool_ops = &i2400m_ethtool_ops;
636         d_fnend(3, NULL, "(net_dev %p) = void\n", net_dev);
637 }
638 EXPORT_SYMBOL_GPL(i2400m_netdev_setup);
639