?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
init from v2.6.32.60
[mach-moxart.git] / drivers / net / virtio_net.c
blobbf6d850a658656479134aa3cf4abd402d40df4e1
1 /* A network driver using virtio.
2 *
3 * Copyright 2007 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
4 *
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, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19 //#define DEBUG
20 #include <linux/netdevice.h>
21 #include <linux/etherdevice.h>
22 #include <linux/ethtool.h>
23 #include <linux/module.h>
24 #include <linux/virtio.h>
25 #include <linux/virtio_net.h>
26 #include <linux/scatterlist.h>
27 #include <linux/if_vlan.h>
28
29 static int napi_weight = 128;
30 module_param(napi_weight, int, 0444);
31
32 static int csum = 1, gso = 1;
33 module_param(csum, bool, 0444);
34 module_param(gso, bool, 0444);
35
36 /* FIXME: MTU in config. */
37 #define MAX_PACKET_LEN (ETH_HLEN + VLAN_HLEN + ETH_DATA_LEN)
38 #define GOOD_COPY_LEN 128
39
40 #define VIRTNET_SEND_COMMAND_SG_MAX 2
41
42 struct virtnet_info
43 {
44 struct virtio_device *vdev;
45 struct virtqueue *rvq, *svq, *cvq;
46 struct net_device *dev;
47 struct napi_struct napi;
48 unsigned int status;
49
50 /* Number of input buffers, and max we've ever had. */
51 unsigned int num, max;
52
53 /* I like... big packets and I cannot lie! */
54 bool big_packets;
55
56 /* Host will merge rx buffers for big packets (shake it! shake it!) */
57 bool mergeable_rx_bufs;
58
59 /* Receive & send queues. */
60 struct sk_buff_head recv;
61 struct sk_buff_head send;
62
63 /* Work struct for refilling if we run low on memory. */
64 struct delayed_work refill;
65
66 /* Chain pages by the private ptr. */
67 struct page *pages;
68 };
69
70 struct skb_vnet_hdr {
71 union {
72 struct virtio_net_hdr hdr;
73 struct virtio_net_hdr_mrg_rxbuf mhdr;
74 };
75 unsigned int num_sg;
76 };
77
78 static inline struct skb_vnet_hdr *skb_vnet_hdr(struct sk_buff *skb)
79 {
80 return (struct skb_vnet_hdr *)skb->cb;
81 }
82
83 static void give_a_page(struct virtnet_info *vi, struct page *page)
84 {
85 page->private = (unsigned long)vi->pages;
86 vi->pages = page;
87 }
88
89 static void trim_pages(struct virtnet_info *vi, struct sk_buff *skb)
90 {
91 unsigned int i;
92
93 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
94 give_a_page(vi, skb_shinfo(skb)->frags[i].page);
95 skb_shinfo(skb)->nr_frags = 0;
96 skb->data_len = 0;
97 }
98
99 static struct page *get_a_page(struct virtnet_info *vi, gfp_t gfp_mask)
100 {
101 struct page *p = vi->pages;
102
103 if (p)
104 vi->pages = (struct page *)p->private;
105 else
106 p = alloc_page(gfp_mask);
107 return p;
108 }
109
110 static void skb_xmit_done(struct virtqueue *svq)
111 {
112 struct virtnet_info *vi = svq->vdev->priv;
113
114 /* Suppress further interrupts. */
115 svq->vq_ops->disable_cb(svq);
116
117 /* We were probably waiting for more output buffers. */
118 netif_wake_queue(vi->dev);
119 }
120
121 static void receive_skb(struct net_device *dev, struct sk_buff *skb,
122 unsigned len)
123 {
124 struct virtnet_info *vi = netdev_priv(dev);
125 struct skb_vnet_hdr *hdr = skb_vnet_hdr(skb);
126 int err;
127 int i;
128
129 if (unlikely(len < sizeof(struct virtio_net_hdr) + ETH_HLEN)) {
130 pr_debug("%s: short packet %i\n", dev->name, len);
131 dev->stats.rx_length_errors++;
132 goto drop;
133 }
134
135 if (vi->mergeable_rx_bufs) {
136 unsigned int copy;
137 char *p = page_address(skb_shinfo(skb)->frags[0].page);
138
139 if (len > PAGE_SIZE)
140 len = PAGE_SIZE;
141 len -= sizeof(struct virtio_net_hdr_mrg_rxbuf);
142
143 memcpy(&hdr->mhdr, p, sizeof(hdr->mhdr));
144 p += sizeof(hdr->mhdr);
145
146 copy = len;
147 if (copy > skb_tailroom(skb))
148 copy = skb_tailroom(skb);
149
150 memcpy(skb_put(skb, copy), p, copy);
151
152 len -= copy;
153
154 if (!len) {
155 give_a_page(vi, skb_shinfo(skb)->frags[0].page);
156 skb_shinfo(skb)->nr_frags--;
157 } else {
158 skb_shinfo(skb)->frags[0].page_offset +=
159 sizeof(hdr->mhdr) + copy;
160 skb_shinfo(skb)->frags[0].size = len;
161 skb->data_len += len;
162 skb->len += len;
163 }
164
165 while (--hdr->mhdr.num_buffers) {
166 struct sk_buff *nskb;
167
168 i = skb_shinfo(skb)->nr_frags;
169 if (i >= MAX_SKB_FRAGS) {
170 pr_debug("%s: packet too long %d\n", dev->name,
171 len);
172 dev->stats.rx_length_errors++;
173 goto drop;
174 }
175
176 nskb = vi->rvq->vq_ops->get_buf(vi->rvq, &len);
177 if (!nskb) {
178 pr_debug("%s: rx error: %d buffers missing\n",
179 dev->name, hdr->mhdr.num_buffers);
180 dev->stats.rx_length_errors++;
181 goto drop;
182 }
183
184 __skb_unlink(nskb, &vi->recv);
185 vi->num--;
186
187 skb_shinfo(skb)->frags[i] = skb_shinfo(nskb)->frags[0];
188 skb_shinfo(nskb)->nr_frags = 0;
189 kfree_skb(nskb);
190
191 if (len > PAGE_SIZE)
192 len = PAGE_SIZE;
193
194 skb_shinfo(skb)->frags[i].size = len;
195 skb_shinfo(skb)->nr_frags++;
196 skb->data_len += len;
197 skb->len += len;
198 }
199 } else {
200 len -= sizeof(hdr->hdr);
201
202 if (len <= MAX_PACKET_LEN)
203 trim_pages(vi, skb);
204
205 err = pskb_trim(skb, len);
206 if (err) {
207 pr_debug("%s: pskb_trim failed %i %d\n", dev->name,
208 len, err);
209 dev->stats.rx_dropped++;
210 goto drop;
211 }
212 }
213
214 skb->truesize += skb->data_len;
215 dev->stats.rx_bytes += skb->len;
216 dev->stats.rx_packets++;
217
218 if (hdr->hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
219 pr_debug("Needs csum!\n");
220 if (!skb_partial_csum_set(skb,
221 hdr->hdr.csum_start,
222 hdr->hdr.csum_offset))
223 goto frame_err;
224 }
225
226 skb->protocol = eth_type_trans(skb, dev);
227 pr_debug("Receiving skb proto 0x%04x len %i type %i\n",
228 ntohs(skb->protocol), skb->len, skb->pkt_type);
229
230 if (hdr->hdr.gso_type != VIRTIO_NET_HDR_GSO_NONE) {
231 pr_debug("GSO!\n");
232 switch (hdr->hdr.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
233 case VIRTIO_NET_HDR_GSO_TCPV4:
234 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
235 break;
236 case VIRTIO_NET_HDR_GSO_UDP:
237 skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
238 break;
239 case VIRTIO_NET_HDR_GSO_TCPV6:
240 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
241 break;
242 default:
243 if (net_ratelimit())
244 printk(KERN_WARNING "%s: bad gso type %u.\n",
245 dev->name, hdr->hdr.gso_type);
246 goto frame_err;
247 }
248
249 if (hdr->hdr.gso_type & VIRTIO_NET_HDR_GSO_ECN)
250 skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
251
252 skb_shinfo(skb)->gso_size = hdr->hdr.gso_size;
253 if (skb_shinfo(skb)->gso_size == 0) {
254 if (net_ratelimit())
255 printk(KERN_WARNING "%s: zero gso size.\n",
256 dev->name);
257 goto frame_err;
258 }
259
260 /* Header must be checked, and gso_segs computed. */
261 skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
262 skb_shinfo(skb)->gso_segs = 0;
263 }
264
265 netif_receive_skb(skb);
266 return;
267
268 frame_err:
269 dev->stats.rx_frame_errors++;
270 drop:
271 dev_kfree_skb(skb);
272 }
273
274 static bool try_fill_recv_maxbufs(struct virtnet_info *vi, gfp_t gfp)
275 {
276 struct sk_buff *skb;
277 struct scatterlist sg[2+MAX_SKB_FRAGS];
278 int num, err, i;
279 bool oom = false;
280
281 sg_init_table(sg, 2+MAX_SKB_FRAGS);
282 do {
283 struct skb_vnet_hdr *hdr;
284
285 skb = netdev_alloc_skb(vi->dev, MAX_PACKET_LEN + NET_IP_ALIGN);
286 if (unlikely(!skb)) {
287 oom = true;
288 break;
289 }
290
291 skb_reserve(skb, NET_IP_ALIGN);
292 skb_put(skb, MAX_PACKET_LEN);
293
294 hdr = skb_vnet_hdr(skb);
295 sg_set_buf(sg, &hdr->hdr, sizeof(hdr->hdr));
296
297 if (vi->big_packets) {
298 for (i = 0; i < MAX_SKB_FRAGS; i++) {
299 skb_frag_t *f = &skb_shinfo(skb)->frags[i];
300 f->page = get_a_page(vi, gfp);
301 if (!f->page)
302 break;
303
304 f->page_offset = 0;
305 f->size = PAGE_SIZE;
306
307 skb->data_len += PAGE_SIZE;
308 skb->len += PAGE_SIZE;
309
310 skb_shinfo(skb)->nr_frags++;
311 }
312 }
313
314 num = skb_to_sgvec(skb, sg+1, 0, skb->len) + 1;
315 skb_queue_head(&vi->recv, skb);
316
317 err = vi->rvq->vq_ops->add_buf(vi->rvq, sg, 0, num, skb);
318 if (err < 0) {
319 skb_unlink(skb, &vi->recv);
320 trim_pages(vi, skb);
321 kfree_skb(skb);
322 break;
323 }
324 vi->num++;
325 } while (err >= num);
326 if (unlikely(vi->num > vi->max))
327 vi->max = vi->num;
328 vi->rvq->vq_ops->kick(vi->rvq);
329 return !oom;
330 }
331
332 /* Returns false if we couldn't fill entirely (OOM). */
333 static bool try_fill_recv(struct virtnet_info *vi, gfp_t gfp)
334 {
335 struct sk_buff *skb;
336 struct scatterlist sg[1];
337 int err;
338 bool oom = false;
339
340 if (!vi->mergeable_rx_bufs)
341 return try_fill_recv_maxbufs(vi, gfp);
342
343 do {
344 skb_frag_t *f;
345
346 skb = netdev_alloc_skb(vi->dev, GOOD_COPY_LEN + NET_IP_ALIGN);
347 if (unlikely(!skb)) {
348 oom = true;
349 break;
350 }
351
352 skb_reserve(skb, NET_IP_ALIGN);
353
354 f = &skb_shinfo(skb)->frags[0];
355 f->page = get_a_page(vi, gfp);
356 if (!f->page) {
357 oom = true;
358 kfree_skb(skb);
359 break;
360 }
361
362 f->page_offset = 0;
363 f->size = PAGE_SIZE;
364
365 skb_shinfo(skb)->nr_frags++;
366
367 sg_init_one(sg, page_address(f->page), PAGE_SIZE);
368 skb_queue_head(&vi->recv, skb);
369
370 err = vi->rvq->vq_ops->add_buf(vi->rvq, sg, 0, 1, skb);
371 if (err < 0) {
372 skb_unlink(skb, &vi->recv);
373 kfree_skb(skb);
374 break;
375 }
376 vi->num++;
377 } while (err > 0);
378 if (unlikely(vi->num > vi->max))
379 vi->max = vi->num;
380 vi->rvq->vq_ops->kick(vi->rvq);
381 return !oom;
382 }
383
384 static void skb_recv_done(struct virtqueue *rvq)
385 {
386 struct virtnet_info *vi = rvq->vdev->priv;
387 /* Schedule NAPI, Suppress further interrupts if successful. */
388 if (napi_schedule_prep(&vi->napi)) {
389 rvq->vq_ops->disable_cb(rvq);
390 __napi_schedule(&vi->napi);
391 }
392 }
393
394 static void virtnet_napi_enable(struct virtnet_info *vi)
395 {
396 napi_enable(&vi->napi);
397
398 /* If all buffers were filled by other side before we napi_enabled, we
399 * won't get another interrupt, so process any outstanding packets
400 * now. virtnet_poll wants re-enable the queue, so we disable here.
401 * We synchronize against interrupts via NAPI_STATE_SCHED */
402 if (napi_schedule_prep(&vi->napi)) {
403 vi->rvq->vq_ops->disable_cb(vi->rvq);
404 __napi_schedule(&vi->napi);
405 }
406 }
407
408 static void refill_work(struct work_struct *work)
409 {
410 struct virtnet_info *vi;
411 bool still_empty;
412
413 vi = container_of(work, struct virtnet_info, refill.work);
414 napi_disable(&vi->napi);
415 still_empty = !try_fill_recv(vi, GFP_KERNEL);
416 virtnet_napi_enable(vi);
417
418 /* In theory, this can happen: if we don't get any buffers in
419 * we will *never* try to fill again. */
420 if (still_empty)
421 schedule_delayed_work(&vi->refill, HZ/2);
422 }
423
424 static int virtnet_poll(struct napi_struct *napi, int budget)
425 {
426 struct virtnet_info *vi = container_of(napi, struct virtnet_info, napi);
427 struct sk_buff *skb = NULL;
428 unsigned int len, received = 0;
429
430 again:
431 while (received < budget &&
432 (skb = vi->rvq->vq_ops->get_buf(vi->rvq, &len)) != NULL) {
433 __skb_unlink(skb, &vi->recv);
434 receive_skb(vi->dev, skb, len);
435 vi->num--;
436 received++;
437 }
438
439 if (vi->num < vi->max / 2) {
440 if (!try_fill_recv(vi, GFP_ATOMIC))
441 schedule_delayed_work(&vi->refill, 0);
442 }
443
444 /* Out of packets? */
445 if (received < budget) {
446 napi_complete(napi);
447 if (unlikely(!vi->rvq->vq_ops->enable_cb(vi->rvq))
448 && napi_schedule_prep(napi)) {
449 vi->rvq->vq_ops->disable_cb(vi->rvq);
450 __napi_schedule(napi);
451 goto again;
452 }
453 }
454
455 return received;
456 }
457
458 static unsigned int free_old_xmit_skbs(struct virtnet_info *vi)
459 {
460 struct sk_buff *skb;
461 unsigned int len, tot_sgs = 0;
462
463 while ((skb = vi->svq->vq_ops->get_buf(vi->svq, &len)) != NULL) {
464 pr_debug("Sent skb %p\n", skb);
465 __skb_unlink(skb, &vi->send);
466 vi->dev->stats.tx_bytes += skb->len;
467 vi->dev->stats.tx_packets++;
468 tot_sgs += skb_vnet_hdr(skb)->num_sg;
469 dev_kfree_skb_any(skb);
470 }
471 return tot_sgs;
472 }
473
474 static int xmit_skb(struct virtnet_info *vi, struct sk_buff *skb)
475 {
476 struct scatterlist sg[2+MAX_SKB_FRAGS];
477 struct skb_vnet_hdr *hdr = skb_vnet_hdr(skb);
478 const unsigned char *dest = ((struct ethhdr *)skb->data)->h_dest;
479
480 sg_init_table(sg, 2+MAX_SKB_FRAGS);
481
482 pr_debug("%s: xmit %p %pM\n", vi->dev->name, skb, dest);
483
484 if (skb->ip_summed == CHECKSUM_PARTIAL) {
485 hdr->hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
486 hdr->hdr.csum_start = skb->csum_start - skb_headroom(skb);
487 hdr->hdr.csum_offset = skb->csum_offset;
488 } else {
489 hdr->hdr.flags = 0;
490 hdr->hdr.csum_offset = hdr->hdr.csum_start = 0;
491 }
492
493 if (skb_is_gso(skb)) {
494 hdr->hdr.hdr_len = skb_headlen(skb);
495 hdr->hdr.gso_size = skb_shinfo(skb)->gso_size;
496 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4)
497 hdr->hdr.gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
498 else if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
499 hdr->hdr.gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
500 else if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
501 hdr->hdr.gso_type = VIRTIO_NET_HDR_GSO_UDP;
502 else
503 BUG();
504 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCP_ECN)
505 hdr->hdr.gso_type |= VIRTIO_NET_HDR_GSO_ECN;
506 } else {
507 hdr->hdr.gso_type = VIRTIO_NET_HDR_GSO_NONE;
508 hdr->hdr.gso_size = hdr->hdr.hdr_len = 0;
509 }
510
511 hdr->mhdr.num_buffers = 0;
512
513 /* Encode metadata header at front. */
514 if (vi->mergeable_rx_bufs)
515 sg_set_buf(sg, &hdr->mhdr, sizeof(hdr->mhdr));
516 else
517 sg_set_buf(sg, &hdr->hdr, sizeof(hdr->hdr));
518
519 hdr->num_sg = skb_to_sgvec(skb, sg+1, 0, skb->len) + 1;
520 return vi->svq->vq_ops->add_buf(vi->svq, sg, hdr->num_sg, 0, skb);
521 }
522
523 static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
524 {
525 struct virtnet_info *vi = netdev_priv(dev);
526 int capacity;
527
528 /* Free up any pending old buffers before queueing new ones. */
529 free_old_xmit_skbs(vi);
530
531 /* Try to transmit */
532 capacity = xmit_skb(vi, skb);
533
534 /* This can happen with OOM and indirect buffers. */
535 if (unlikely(capacity < 0)) {
536 if (net_ratelimit()) {
537 if (likely(capacity == -ENOMEM)) {
538 dev_warn(&dev->dev,
539 "TX queue failure: out of memory\n");
540 } else {
541 dev->stats.tx_fifo_errors++;
542 dev_warn(&dev->dev,
543 "Unexpected TX queue failure: %d\n",
544 capacity);
545 }
546 }
547 dev->stats.tx_dropped++;
548 kfree_skb(skb);
549 return NETDEV_TX_OK;
550 }
551 vi->svq->vq_ops->kick(vi->svq);
552
553 /*
554 * Put new one in send queue. You'd expect we'd need this before
555 * xmit_skb calls add_buf(), since the callback can be triggered
556 * immediately after that. But since the callback just triggers
557 * another call back here, normal network xmit locking prevents the
558 * race.
559 */
560 __skb_queue_head(&vi->send, skb);
561
562 /* Don't wait up for transmitted skbs to be freed. */
563 skb_orphan(skb);
564 nf_reset(skb);
565
566 /* Apparently nice girls don't return TX_BUSY; stop the queue
567 * before it gets out of hand. Naturally, this wastes entries. */
568 if (capacity < 2+MAX_SKB_FRAGS) {
569 netif_stop_queue(dev);
570 if (unlikely(!vi->svq->vq_ops->enable_cb(vi->svq))) {
571 /* More just got used, free them then recheck. */
572 capacity += free_old_xmit_skbs(vi);
573 if (capacity >= 2+MAX_SKB_FRAGS) {
574 netif_start_queue(dev);
575 vi->svq->vq_ops->disable_cb(vi->svq);
576 }
577 }
578 }
579
580 return NETDEV_TX_OK;
581 }
582
583 static int virtnet_set_mac_address(struct net_device *dev, void *p)
584 {
585 struct virtnet_info *vi = netdev_priv(dev);
586 struct virtio_device *vdev = vi->vdev;
587 int ret;
588
589 ret = eth_mac_addr(dev, p);
590 if (ret)
591 return ret;
592
593 if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC))
594 vdev->config->set(vdev, offsetof(struct virtio_net_config, mac),
595 dev->dev_addr, dev->addr_len);
596
597 return 0;
598 }
599
600 #ifdef CONFIG_NET_POLL_CONTROLLER
601 static void virtnet_netpoll(struct net_device *dev)
602 {
603 struct virtnet_info *vi = netdev_priv(dev);
604
605 napi_schedule(&vi->napi);
606 }
607 #endif
608
609 static int virtnet_open(struct net_device *dev)
610 {
611 struct virtnet_info *vi = netdev_priv(dev);
612
613 virtnet_napi_enable(vi);
614 return 0;
615 }
616
617 /*
618 * Send command via the control virtqueue and check status. Commands
619 * supported by the hypervisor, as indicated by feature bits, should
620 * never fail unless improperly formated.
621 */
622 static bool virtnet_send_command(struct virtnet_info *vi, u8 class, u8 cmd,
623 struct scatterlist *data, int out, int in)
624 {
625 struct scatterlist *s, sg[VIRTNET_SEND_COMMAND_SG_MAX + 2];
626 struct virtio_net_ctrl_hdr ctrl;
627 virtio_net_ctrl_ack status = ~0;
628 unsigned int tmp;
629 int i;
630
631 /* Caller should know better */
632 BUG_ON(!virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ) ||
633 (out + in > VIRTNET_SEND_COMMAND_SG_MAX));
634
635 out++; /* Add header */
636 in++; /* Add return status */
637
638 ctrl.class = class;
639 ctrl.cmd = cmd;
640
641 sg_init_table(sg, out + in);
642
643 sg_set_buf(&sg[0], &ctrl, sizeof(ctrl));
644 for_each_sg(data, s, out + in - 2, i)
645 sg_set_buf(&sg[i + 1], sg_virt(s), s->length);
646 sg_set_buf(&sg[out + in - 1], &status, sizeof(status));
647
648 BUG_ON(vi->cvq->vq_ops->add_buf(vi->cvq, sg, out, in, vi) < 0);
649
650 vi->cvq->vq_ops->kick(vi->cvq);
651
652 /*
653 * Spin for a response, the kick causes an ioport write, trapping
654 * into the hypervisor, so the request should be handled immediately.
655 */
656 while (!vi->cvq->vq_ops->get_buf(vi->cvq, &tmp))
657 cpu_relax();
658
659 return status == VIRTIO_NET_OK;
660 }
661
662 static int virtnet_close(struct net_device *dev)
663 {
664 struct virtnet_info *vi = netdev_priv(dev);
665
666 napi_disable(&vi->napi);
667
668 return 0;
669 }
670
671 static int virtnet_set_tx_csum(struct net_device *dev, u32 data)
672 {
673 struct virtnet_info *vi = netdev_priv(dev);
674 struct virtio_device *vdev = vi->vdev;
675
676 if (data && !virtio_has_feature(vdev, VIRTIO_NET_F_CSUM))
677 return -ENOSYS;
678
679 return ethtool_op_set_tx_hw_csum(dev, data);
680 }
681
682 static void virtnet_set_rx_mode(struct net_device *dev)
683 {
684 struct virtnet_info *vi = netdev_priv(dev);
685 struct scatterlist sg[2];
686 u8 promisc, allmulti;
687 struct virtio_net_ctrl_mac *mac_data;
688 struct dev_addr_list *addr;
689 struct netdev_hw_addr *ha;
690 void *buf;
691 int i;
692
693 /* We can't dynamicaly set ndo_set_rx_mode, so return gracefully */
694 if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_RX))
695 return;
696
697 promisc = ((dev->flags & IFF_PROMISC) != 0);
698 allmulti = ((dev->flags & IFF_ALLMULTI) != 0);
699
700 sg_init_one(sg, &promisc, sizeof(promisc));
701
702 if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_RX,
703 VIRTIO_NET_CTRL_RX_PROMISC,
704 sg, 1, 0))
705 dev_warn(&dev->dev, "Failed to %sable promisc mode.\n",
706 promisc ? "en" : "dis");
707
708 sg_init_one(sg, &allmulti, sizeof(allmulti));
709
710 if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_RX,
711 VIRTIO_NET_CTRL_RX_ALLMULTI,
712 sg, 1, 0))
713 dev_warn(&dev->dev, "Failed to %sable allmulti mode.\n",
714 allmulti ? "en" : "dis");
715
716 /* MAC filter - use one buffer for both lists */
717 mac_data = buf = kzalloc(((dev->uc.count + dev->mc_count) * ETH_ALEN) +
718 (2 * sizeof(mac_data->entries)), GFP_ATOMIC);
719 if (!buf) {
720 dev_warn(&dev->dev, "No memory for MAC address buffer\n");
721 return;
722 }
723
724 sg_init_table(sg, 2);
725
726 /* Store the unicast list and count in the front of the buffer */
727 mac_data->entries = dev->uc.count;
728 i = 0;
729 list_for_each_entry(ha, &dev->uc.list, list)
730 memcpy(&mac_data->macs[i++][0], ha->addr, ETH_ALEN);
731
732 sg_set_buf(&sg[0], mac_data,
733 sizeof(mac_data->entries) + (dev->uc.count * ETH_ALEN));
734
735 /* multicast list and count fill the end */
736 mac_data = (void *)&mac_data->macs[dev->uc.count][0];
737
738 mac_data->entries = dev->mc_count;
739 addr = dev->mc_list;
740 for (i = 0; i < dev->mc_count; i++, addr = addr->next)
741 memcpy(&mac_data->macs[i][0], addr->da_addr, ETH_ALEN);
742
743 sg_set_buf(&sg[1], mac_data,
744 sizeof(mac_data->entries) + (dev->mc_count * ETH_ALEN));
745
746 if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_MAC,
747 VIRTIO_NET_CTRL_MAC_TABLE_SET,
748 sg, 2, 0))
749 dev_warn(&dev->dev, "Failed to set MAC fitler table.\n");
750
751 kfree(buf);
752 }
753
754 static void virtnet_vlan_rx_add_vid(struct net_device *dev, u16 vid)
755 {
756 struct virtnet_info *vi = netdev_priv(dev);
757 struct scatterlist sg;
758
759 sg_init_one(&sg, &vid, sizeof(vid));
760
761 if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_VLAN,
762 VIRTIO_NET_CTRL_VLAN_ADD, &sg, 1, 0))
763 dev_warn(&dev->dev, "Failed to add VLAN ID %d.\n", vid);
764 }
765
766 static void virtnet_vlan_rx_kill_vid(struct net_device *dev, u16 vid)
767 {
768 struct virtnet_info *vi = netdev_priv(dev);
769 struct scatterlist sg;
770
771 sg_init_one(&sg, &vid, sizeof(vid));
772
773 if (!virtnet_send_command(vi, VIRTIO_NET_CTRL_VLAN,
774 VIRTIO_NET_CTRL_VLAN_DEL, &sg, 1, 0))
775 dev_warn(&dev->dev, "Failed to kill VLAN ID %d.\n", vid);
776 }
777
778 static const struct ethtool_ops virtnet_ethtool_ops = {
779 .set_tx_csum = virtnet_set_tx_csum,
780 .set_sg = ethtool_op_set_sg,
781 .set_tso = ethtool_op_set_tso,
782 .set_ufo = ethtool_op_set_ufo,
783 .get_link = ethtool_op_get_link,
784 };
785
786 #define MIN_MTU 68
787 #define MAX_MTU 65535
788
789 static int virtnet_change_mtu(struct net_device *dev, int new_mtu)
790 {
791 if (new_mtu < MIN_MTU || new_mtu > MAX_MTU)
792 return -EINVAL;
793 dev->mtu = new_mtu;
794 return 0;
795 }
796
797 static const struct net_device_ops virtnet_netdev = {
798 .ndo_open = virtnet_open,
799 .ndo_stop = virtnet_close,
800 .ndo_start_xmit = start_xmit,
801 .ndo_validate_addr = eth_validate_addr,
802 .ndo_set_mac_address = virtnet_set_mac_address,
803 .ndo_set_rx_mode = virtnet_set_rx_mode,
804 .ndo_change_mtu = virtnet_change_mtu,
805 .ndo_vlan_rx_add_vid = virtnet_vlan_rx_add_vid,
806 .ndo_vlan_rx_kill_vid = virtnet_vlan_rx_kill_vid,
807 #ifdef CONFIG_NET_POLL_CONTROLLER
808 .ndo_poll_controller = virtnet_netpoll,
809 #endif
810 };
811
812 static void virtnet_update_status(struct virtnet_info *vi)
813 {
814 u16 v;
815
816 if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_STATUS))
817 return;
818
819 vi->vdev->config->get(vi->vdev,
820 offsetof(struct virtio_net_config, status),
821 &v, sizeof(v));
822
823 /* Ignore unknown (future) status bits */
824 v &= VIRTIO_NET_S_LINK_UP;
825
826 if (vi->status == v)
827 return;
828
829 vi->status = v;
830
831 if (vi->status & VIRTIO_NET_S_LINK_UP) {
832 netif_carrier_on(vi->dev);
833 netif_wake_queue(vi->dev);
834 } else {
835 netif_carrier_off(vi->dev);
836 netif_stop_queue(vi->dev);
837 }
838 }
839
840 static void virtnet_config_changed(struct virtio_device *vdev)
841 {
842 struct virtnet_info *vi = vdev->priv;
843
844 virtnet_update_status(vi);
845 }
846
847 static int virtnet_probe(struct virtio_device *vdev)
848 {
849 int err;
850 struct net_device *dev;
851 struct virtnet_info *vi;
852 struct virtqueue *vqs[3];
853 vq_callback_t *callbacks[] = { skb_recv_done, skb_xmit_done, NULL};
854 const char *names[] = { "input", "output", "control" };
855 int nvqs;
856
857 /* Allocate ourselves a network device with room for our info */
858 dev = alloc_etherdev(sizeof(struct virtnet_info));
859 if (!dev)
860 return -ENOMEM;
861
862 /* Set up network device as normal. */
863 dev->netdev_ops = &virtnet_netdev;
864 dev->features = NETIF_F_HIGHDMA;
865 SET_ETHTOOL_OPS(dev, &virtnet_ethtool_ops);
866 SET_NETDEV_DEV(dev, &vdev->dev);
867
868 /* Do we support "hardware" checksums? */
869 if (csum && virtio_has_feature(vdev, VIRTIO_NET_F_CSUM)) {
870 /* This opens up the world of extra features. */
871 dev->features |= NETIF_F_HW_CSUM|NETIF_F_SG|NETIF_F_FRAGLIST;
872 if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_GSO)) {
873 dev->features |= NETIF_F_TSO | NETIF_F_UFO
874 | NETIF_F_TSO_ECN | NETIF_F_TSO6;
875 }
876 /* Individual feature bits: what can host handle? */
877 if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO4))
878 dev->features |= NETIF_F_TSO;
879 if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO6))
880 dev->features |= NETIF_F_TSO6;
881 if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_ECN))
882 dev->features |= NETIF_F_TSO_ECN;
883 if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_UFO))
884 dev->features |= NETIF_F_UFO;
885 }
886
887 /* Configuration may specify what MAC to use. Otherwise random. */
888 if (virtio_has_feature(vdev, VIRTIO_NET_F_MAC)) {
889 vdev->config->get(vdev,
890 offsetof(struct virtio_net_config, mac),
891 dev->dev_addr, dev->addr_len);
892 } else
893 random_ether_addr(dev->dev_addr);
894
895 /* Set up our device-specific information */
896 vi = netdev_priv(dev);
897 netif_napi_add(dev, &vi->napi, virtnet_poll, napi_weight);
898 vi->dev = dev;
899 vi->vdev = vdev;
900 vdev->priv = vi;
901 vi->pages = NULL;
902 INIT_DELAYED_WORK(&vi->refill, refill_work);
903
904 /* If we can receive ANY GSO packets, we must allocate large ones. */
905 if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO4)
906 || virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_TSO6)
907 || virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_ECN))
908 vi->big_packets = true;
909
910 if (virtio_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF))
911 vi->mergeable_rx_bufs = true;
912
913 /* We expect two virtqueues, receive then send,
914 * and optionally control. */
915 nvqs = virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ) ? 3 : 2;
916
917 err = vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names);
918 if (err)
919 goto free;
920
921 vi->rvq = vqs[0];
922 vi->svq = vqs[1];
923
924 if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VQ)) {
925 vi->cvq = vqs[2];
926
927 if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_CTRL_VLAN))
928 dev->features |= NETIF_F_HW_VLAN_FILTER;
929 }
930
931 /* Initialize our empty receive and send queues. */
932 skb_queue_head_init(&vi->recv);
933 skb_queue_head_init(&vi->send);
934
935 err = register_netdev(dev);
936 if (err) {
937 pr_debug("virtio_net: registering device failed\n");
938 goto free_vqs;
939 }
940
941 /* Last of all, set up some receive buffers. */
942 try_fill_recv(vi, GFP_KERNEL);
943
944 /* If we didn't even get one input buffer, we're useless. */
945 if (vi->num == 0) {
946 err = -ENOMEM;
947 goto unregister;
948 }
949
950 vi->status = VIRTIO_NET_S_LINK_UP;
951 virtnet_update_status(vi);
952 netif_carrier_on(dev);
953
954 pr_debug("virtnet: registered device %s\n", dev->name);
955 return 0;
956
957 unregister:
958 unregister_netdev(dev);
959 cancel_delayed_work_sync(&vi->refill);
960 free_vqs:
961 vdev->config->del_vqs(vdev);
962 free:
963 free_netdev(dev);
964 return err;
965 }
966
967 static void __devexit virtnet_remove(struct virtio_device *vdev)
968 {
969 struct virtnet_info *vi = vdev->priv;
970 struct sk_buff *skb;
971
972 /* Stop all the virtqueues. */
973 vdev->config->reset(vdev);
974
975 /* Free our skbs in send and recv queues, if any. */
976 while ((skb = __skb_dequeue(&vi->recv)) != NULL) {
977 kfree_skb(skb);
978 vi->num--;
979 }
980 __skb_queue_purge(&vi->send);
981
982 BUG_ON(vi->num != 0);
983
984 unregister_netdev(vi->dev);
985 cancel_delayed_work_sync(&vi->refill);
986
987 vdev->config->del_vqs(vi->vdev);
988
989 while (vi->pages)
990 __free_pages(get_a_page(vi, GFP_KERNEL), 0);
991
992 free_netdev(vi->dev);
993 }
994
995 static struct virtio_device_id id_table[] = {
996 { VIRTIO_ID_NET, VIRTIO_DEV_ANY_ID },
997 { 0 },
998 };
999
1000 static unsigned int features[] = {
1001 VIRTIO_NET_F_CSUM, VIRTIO_NET_F_GUEST_CSUM,
1002 VIRTIO_NET_F_GSO, VIRTIO_NET_F_MAC,
1003 VIRTIO_NET_F_HOST_TSO4, VIRTIO_NET_F_HOST_UFO, VIRTIO_NET_F_HOST_TSO6,
1004 VIRTIO_NET_F_HOST_ECN, VIRTIO_NET_F_GUEST_TSO4, VIRTIO_NET_F_GUEST_TSO6,
1005 VIRTIO_NET_F_GUEST_ECN, VIRTIO_NET_F_GUEST_UFO,
1006 VIRTIO_NET_F_MRG_RXBUF, VIRTIO_NET_F_STATUS, VIRTIO_NET_F_CTRL_VQ,
1007 VIRTIO_NET_F_CTRL_RX, VIRTIO_NET_F_CTRL_VLAN,
1008 };
1009
1010 static struct virtio_driver virtio_net_driver = {
1011 .feature_table = features,
1012 .feature_table_size = ARRAY_SIZE(features),
1013 .driver.name = KBUILD_MODNAME,
1014 .driver.owner = THIS_MODULE,
1015 .id_table = id_table,
1016 .probe = virtnet_probe,
1017 .remove = __devexit_p(virtnet_remove),
1018 .config_changed = virtnet_config_changed,
1019 };
1020
1021 static int __init init(void)
1022 {
1023 return register_virtio_driver(&virtio_net_driver);
1024 }
1025
1026 static void __exit fini(void)
1027 {
1028 unregister_virtio_driver(&virtio_net_driver);
1029 }
1030 module_init(init);
1031 module_exit(fini);
1032
1033 MODULE_DEVICE_TABLE(virtio, id_table);
1034 MODULE_DESCRIPTION("Virtio network driver");
1035 MODULE_LICENSE("GPL");
Linux MOXA ART SoC ARM port