2 * IBM Power Virtual Ethernet Device Driver
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
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.
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.
18 * Copyright (C) IBM Corporation, 2003, 2010
20 * Authors: Dave Larson <larson1@us.ibm.com>
21 * Santiago Leon <santil@linux.vnet.ibm.com>
22 * Brian King <brking@linux.vnet.ibm.com>
23 * Robert Jennings <rcj@linux.vnet.ibm.com>
24 * Anton Blanchard <anton@au.ibm.com>
27 #include <linux/module.h>
28 #include <linux/moduleparam.h>
29 #include <linux/types.h>
30 #include <linux/errno.h>
31 #include <linux/dma-mapping.h>
32 #include <linux/kernel.h>
33 #include <linux/netdevice.h>
34 #include <linux/etherdevice.h>
35 #include <linux/skbuff.h>
36 #include <linux/init.h>
37 #include <linux/interrupt.h>
40 #include <linux/ethtool.h>
43 #include <linux/ipv6.h>
44 #include <linux/slab.h>
45 #include <asm/hvcall.h>
46 #include <linux/atomic.h>
48 #include <asm/iommu.h>
49 #include <asm/firmware.h>
53 static irqreturn_t
ibmveth_interrupt(int irq
, void *dev_instance
);
54 static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter
*adapter
);
55 static unsigned long ibmveth_get_desired_dma(struct vio_dev
*vdev
);
57 static struct kobj_type ktype_veth_pool
;
60 static const char ibmveth_driver_name
[] = "ibmveth";
61 static const char ibmveth_driver_string
[] = "IBM Power Virtual Ethernet Driver";
62 #define ibmveth_driver_version "1.04"
64 MODULE_AUTHOR("Santiago Leon <santil@linux.vnet.ibm.com>");
65 MODULE_DESCRIPTION("IBM Power Virtual Ethernet Driver");
66 MODULE_LICENSE("GPL");
67 MODULE_VERSION(ibmveth_driver_version
);
69 static unsigned int tx_copybreak __read_mostly
= 128;
70 module_param(tx_copybreak
, uint
, 0644);
71 MODULE_PARM_DESC(tx_copybreak
,
72 "Maximum size of packet that is copied to a new buffer on transmit");
74 static unsigned int rx_copybreak __read_mostly
= 128;
75 module_param(rx_copybreak
, uint
, 0644);
76 MODULE_PARM_DESC(rx_copybreak
,
77 "Maximum size of packet that is copied to a new buffer on receive");
79 static unsigned int rx_flush __read_mostly
= 0;
80 module_param(rx_flush
, uint
, 0644);
81 MODULE_PARM_DESC(rx_flush
, "Flush receive buffers before use");
84 char name
[ETH_GSTRING_LEN
];
88 #define IBMVETH_STAT_OFF(stat) offsetof(struct ibmveth_adapter, stat)
89 #define IBMVETH_GET_STAT(a, off) *((u64 *)(((unsigned long)(a)) + off))
91 struct ibmveth_stat ibmveth_stats
[] = {
92 { "replenish_task_cycles", IBMVETH_STAT_OFF(replenish_task_cycles
) },
93 { "replenish_no_mem", IBMVETH_STAT_OFF(replenish_no_mem
) },
94 { "replenish_add_buff_failure",
95 IBMVETH_STAT_OFF(replenish_add_buff_failure
) },
96 { "replenish_add_buff_success",
97 IBMVETH_STAT_OFF(replenish_add_buff_success
) },
98 { "rx_invalid_buffer", IBMVETH_STAT_OFF(rx_invalid_buffer
) },
99 { "rx_no_buffer", IBMVETH_STAT_OFF(rx_no_buffer
) },
100 { "tx_map_failed", IBMVETH_STAT_OFF(tx_map_failed
) },
101 { "tx_send_failed", IBMVETH_STAT_OFF(tx_send_failed
) },
102 { "fw_enabled_ipv4_csum", IBMVETH_STAT_OFF(fw_ipv4_csum_support
) },
103 { "fw_enabled_ipv6_csum", IBMVETH_STAT_OFF(fw_ipv6_csum_support
) },
106 /* simple methods of getting data from the current rxq entry */
107 static inline u32
ibmveth_rxq_flags(struct ibmveth_adapter
*adapter
)
109 return adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].flags_off
;
112 static inline int ibmveth_rxq_toggle(struct ibmveth_adapter
*adapter
)
114 return (ibmveth_rxq_flags(adapter
) & IBMVETH_RXQ_TOGGLE
) >>
115 IBMVETH_RXQ_TOGGLE_SHIFT
;
118 static inline int ibmveth_rxq_pending_buffer(struct ibmveth_adapter
*adapter
)
120 return ibmveth_rxq_toggle(adapter
) == adapter
->rx_queue
.toggle
;
123 static inline int ibmveth_rxq_buffer_valid(struct ibmveth_adapter
*adapter
)
125 return ibmveth_rxq_flags(adapter
) & IBMVETH_RXQ_VALID
;
128 static inline int ibmveth_rxq_frame_offset(struct ibmveth_adapter
*adapter
)
130 return ibmveth_rxq_flags(adapter
) & IBMVETH_RXQ_OFF_MASK
;
133 static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter
*adapter
)
135 return adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].length
;
138 static inline int ibmveth_rxq_csum_good(struct ibmveth_adapter
*adapter
)
140 return ibmveth_rxq_flags(adapter
) & IBMVETH_RXQ_CSUM_GOOD
;
143 /* setup the initial settings for a buffer pool */
144 static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool
*pool
,
145 u32 pool_index
, u32 pool_size
,
146 u32 buff_size
, u32 pool_active
)
148 pool
->size
= pool_size
;
149 pool
->index
= pool_index
;
150 pool
->buff_size
= buff_size
;
151 pool
->threshold
= pool_size
* 7 / 8;
152 pool
->active
= pool_active
;
155 /* allocate and setup an buffer pool - called during open */
156 static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool
*pool
)
160 pool
->free_map
= kmalloc(sizeof(u16
) * pool
->size
, GFP_KERNEL
);
165 pool
->dma_addr
= kmalloc(sizeof(dma_addr_t
) * pool
->size
, GFP_KERNEL
);
166 if (!pool
->dma_addr
) {
167 kfree(pool
->free_map
);
168 pool
->free_map
= NULL
;
172 pool
->skbuff
= kcalloc(pool
->size
, sizeof(void *), GFP_KERNEL
);
175 kfree(pool
->dma_addr
);
176 pool
->dma_addr
= NULL
;
178 kfree(pool
->free_map
);
179 pool
->free_map
= NULL
;
183 memset(pool
->dma_addr
, 0, sizeof(dma_addr_t
) * pool
->size
);
185 for (i
= 0; i
< pool
->size
; ++i
)
186 pool
->free_map
[i
] = i
;
188 atomic_set(&pool
->available
, 0);
189 pool
->producer_index
= 0;
190 pool
->consumer_index
= 0;
195 static inline void ibmveth_flush_buffer(void *addr
, unsigned long length
)
197 unsigned long offset
;
199 for (offset
= 0; offset
< length
; offset
+= SMP_CACHE_BYTES
)
200 asm("dcbfl %0,%1" :: "b" (addr
), "r" (offset
));
203 /* replenish the buffers for a pool. note that we don't need to
204 * skb_reserve these since they are used for incoming...
206 static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter
*adapter
,
207 struct ibmveth_buff_pool
*pool
)
210 u32 count
= pool
->size
- atomic_read(&pool
->available
);
211 u32 buffers_added
= 0;
213 unsigned int free_index
, index
;
215 unsigned long lpar_rc
;
220 for (i
= 0; i
< count
; ++i
) {
221 union ibmveth_buf_desc desc
;
223 skb
= netdev_alloc_skb(adapter
->netdev
, pool
->buff_size
);
226 netdev_dbg(adapter
->netdev
,
227 "replenish: unable to allocate skb\n");
228 adapter
->replenish_no_mem
++;
232 free_index
= pool
->consumer_index
;
233 pool
->consumer_index
++;
234 if (pool
->consumer_index
>= pool
->size
)
235 pool
->consumer_index
= 0;
236 index
= pool
->free_map
[free_index
];
238 BUG_ON(index
== IBM_VETH_INVALID_MAP
);
239 BUG_ON(pool
->skbuff
[index
] != NULL
);
241 dma_addr
= dma_map_single(&adapter
->vdev
->dev
, skb
->data
,
242 pool
->buff_size
, DMA_FROM_DEVICE
);
244 if (dma_mapping_error(&adapter
->vdev
->dev
, dma_addr
))
247 pool
->free_map
[free_index
] = IBM_VETH_INVALID_MAP
;
248 pool
->dma_addr
[index
] = dma_addr
;
249 pool
->skbuff
[index
] = skb
;
251 correlator
= ((u64
)pool
->index
<< 32) | index
;
252 *(u64
*)skb
->data
= correlator
;
254 desc
.fields
.flags_len
= IBMVETH_BUF_VALID
| pool
->buff_size
;
255 desc
.fields
.address
= dma_addr
;
258 unsigned int len
= min(pool
->buff_size
,
259 adapter
->netdev
->mtu
+
261 ibmveth_flush_buffer(skb
->data
, len
);
263 lpar_rc
= h_add_logical_lan_buffer(adapter
->vdev
->unit_address
,
266 if (lpar_rc
!= H_SUCCESS
) {
270 adapter
->replenish_add_buff_success
++;
275 atomic_add(buffers_added
, &(pool
->available
));
279 pool
->free_map
[free_index
] = index
;
280 pool
->skbuff
[index
] = NULL
;
281 if (pool
->consumer_index
== 0)
282 pool
->consumer_index
= pool
->size
- 1;
284 pool
->consumer_index
--;
285 if (!dma_mapping_error(&adapter
->vdev
->dev
, dma_addr
))
286 dma_unmap_single(&adapter
->vdev
->dev
,
287 pool
->dma_addr
[index
], pool
->buff_size
,
289 dev_kfree_skb_any(skb
);
290 adapter
->replenish_add_buff_failure
++;
293 atomic_add(buffers_added
, &(pool
->available
));
297 * The final 8 bytes of the buffer list is a counter of frames dropped
298 * because there was not a buffer in the buffer list capable of holding
301 static void ibmveth_update_rx_no_buffer(struct ibmveth_adapter
*adapter
)
303 __be64
*p
= adapter
->buffer_list_addr
+ 4096 - 8;
305 adapter
->rx_no_buffer
= be64_to_cpup(p
);
308 /* replenish routine */
309 static void ibmveth_replenish_task(struct ibmveth_adapter
*adapter
)
313 adapter
->replenish_task_cycles
++;
315 for (i
= (IBMVETH_NUM_BUFF_POOLS
- 1); i
>= 0; i
--) {
316 struct ibmveth_buff_pool
*pool
= &adapter
->rx_buff_pool
[i
];
319 (atomic_read(&pool
->available
) < pool
->threshold
))
320 ibmveth_replenish_buffer_pool(adapter
, pool
);
323 ibmveth_update_rx_no_buffer(adapter
);
326 /* empty and free ana buffer pool - also used to do cleanup in error paths */
327 static void ibmveth_free_buffer_pool(struct ibmveth_adapter
*adapter
,
328 struct ibmveth_buff_pool
*pool
)
332 kfree(pool
->free_map
);
333 pool
->free_map
= NULL
;
335 if (pool
->skbuff
&& pool
->dma_addr
) {
336 for (i
= 0; i
< pool
->size
; ++i
) {
337 struct sk_buff
*skb
= pool
->skbuff
[i
];
339 dma_unmap_single(&adapter
->vdev
->dev
,
343 dev_kfree_skb_any(skb
);
344 pool
->skbuff
[i
] = NULL
;
349 if (pool
->dma_addr
) {
350 kfree(pool
->dma_addr
);
351 pool
->dma_addr
= NULL
;
360 /* remove a buffer from a pool */
361 static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter
*adapter
,
364 unsigned int pool
= correlator
>> 32;
365 unsigned int index
= correlator
& 0xffffffffUL
;
366 unsigned int free_index
;
369 BUG_ON(pool
>= IBMVETH_NUM_BUFF_POOLS
);
370 BUG_ON(index
>= adapter
->rx_buff_pool
[pool
].size
);
372 skb
= adapter
->rx_buff_pool
[pool
].skbuff
[index
];
376 adapter
->rx_buff_pool
[pool
].skbuff
[index
] = NULL
;
378 dma_unmap_single(&adapter
->vdev
->dev
,
379 adapter
->rx_buff_pool
[pool
].dma_addr
[index
],
380 adapter
->rx_buff_pool
[pool
].buff_size
,
383 free_index
= adapter
->rx_buff_pool
[pool
].producer_index
;
384 adapter
->rx_buff_pool
[pool
].producer_index
++;
385 if (adapter
->rx_buff_pool
[pool
].producer_index
>=
386 adapter
->rx_buff_pool
[pool
].size
)
387 adapter
->rx_buff_pool
[pool
].producer_index
= 0;
388 adapter
->rx_buff_pool
[pool
].free_map
[free_index
] = index
;
392 atomic_dec(&(adapter
->rx_buff_pool
[pool
].available
));
395 /* get the current buffer on the rx queue */
396 static inline struct sk_buff
*ibmveth_rxq_get_buffer(struct ibmveth_adapter
*adapter
)
398 u64 correlator
= adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].correlator
;
399 unsigned int pool
= correlator
>> 32;
400 unsigned int index
= correlator
& 0xffffffffUL
;
402 BUG_ON(pool
>= IBMVETH_NUM_BUFF_POOLS
);
403 BUG_ON(index
>= adapter
->rx_buff_pool
[pool
].size
);
405 return adapter
->rx_buff_pool
[pool
].skbuff
[index
];
408 /* recycle the current buffer on the rx queue */
409 static int ibmveth_rxq_recycle_buffer(struct ibmveth_adapter
*adapter
)
411 u32 q_index
= adapter
->rx_queue
.index
;
412 u64 correlator
= adapter
->rx_queue
.queue_addr
[q_index
].correlator
;
413 unsigned int pool
= correlator
>> 32;
414 unsigned int index
= correlator
& 0xffffffffUL
;
415 union ibmveth_buf_desc desc
;
416 unsigned long lpar_rc
;
419 BUG_ON(pool
>= IBMVETH_NUM_BUFF_POOLS
);
420 BUG_ON(index
>= adapter
->rx_buff_pool
[pool
].size
);
422 if (!adapter
->rx_buff_pool
[pool
].active
) {
423 ibmveth_rxq_harvest_buffer(adapter
);
424 ibmveth_free_buffer_pool(adapter
, &adapter
->rx_buff_pool
[pool
]);
428 desc
.fields
.flags_len
= IBMVETH_BUF_VALID
|
429 adapter
->rx_buff_pool
[pool
].buff_size
;
430 desc
.fields
.address
= adapter
->rx_buff_pool
[pool
].dma_addr
[index
];
432 lpar_rc
= h_add_logical_lan_buffer(adapter
->vdev
->unit_address
, desc
.desc
);
434 if (lpar_rc
!= H_SUCCESS
) {
435 netdev_dbg(adapter
->netdev
, "h_add_logical_lan_buffer failed "
436 "during recycle rc=%ld", lpar_rc
);
437 ibmveth_remove_buffer_from_pool(adapter
, adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].correlator
);
441 if (++adapter
->rx_queue
.index
== adapter
->rx_queue
.num_slots
) {
442 adapter
->rx_queue
.index
= 0;
443 adapter
->rx_queue
.toggle
= !adapter
->rx_queue
.toggle
;
450 static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter
*adapter
)
452 ibmveth_remove_buffer_from_pool(adapter
, adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].correlator
);
454 if (++adapter
->rx_queue
.index
== adapter
->rx_queue
.num_slots
) {
455 adapter
->rx_queue
.index
= 0;
456 adapter
->rx_queue
.toggle
= !adapter
->rx_queue
.toggle
;
460 static void ibmveth_cleanup(struct ibmveth_adapter
*adapter
)
463 struct device
*dev
= &adapter
->vdev
->dev
;
465 if (adapter
->buffer_list_addr
!= NULL
) {
466 if (!dma_mapping_error(dev
, adapter
->buffer_list_dma
)) {
467 dma_unmap_single(dev
, adapter
->buffer_list_dma
, 4096,
469 adapter
->buffer_list_dma
= DMA_ERROR_CODE
;
471 free_page((unsigned long)adapter
->buffer_list_addr
);
472 adapter
->buffer_list_addr
= NULL
;
475 if (adapter
->filter_list_addr
!= NULL
) {
476 if (!dma_mapping_error(dev
, adapter
->filter_list_dma
)) {
477 dma_unmap_single(dev
, adapter
->filter_list_dma
, 4096,
479 adapter
->filter_list_dma
= DMA_ERROR_CODE
;
481 free_page((unsigned long)adapter
->filter_list_addr
);
482 adapter
->filter_list_addr
= NULL
;
485 if (adapter
->rx_queue
.queue_addr
!= NULL
) {
486 dma_free_coherent(dev
, adapter
->rx_queue
.queue_len
,
487 adapter
->rx_queue
.queue_addr
,
488 adapter
->rx_queue
.queue_dma
);
489 adapter
->rx_queue
.queue_addr
= NULL
;
492 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++)
493 if (adapter
->rx_buff_pool
[i
].active
)
494 ibmveth_free_buffer_pool(adapter
,
495 &adapter
->rx_buff_pool
[i
]);
497 if (adapter
->bounce_buffer
!= NULL
) {
498 if (!dma_mapping_error(dev
, adapter
->bounce_buffer_dma
)) {
499 dma_unmap_single(&adapter
->vdev
->dev
,
500 adapter
->bounce_buffer_dma
,
501 adapter
->netdev
->mtu
+ IBMVETH_BUFF_OH
,
503 adapter
->bounce_buffer_dma
= DMA_ERROR_CODE
;
505 kfree(adapter
->bounce_buffer
);
506 adapter
->bounce_buffer
= NULL
;
510 static int ibmveth_register_logical_lan(struct ibmveth_adapter
*adapter
,
511 union ibmveth_buf_desc rxq_desc
, u64 mac_address
)
513 int rc
, try_again
= 1;
516 * After a kexec the adapter will still be open, so our attempt to
517 * open it will fail. So if we get a failure we free the adapter and
518 * try again, but only once.
521 rc
= h_register_logical_lan(adapter
->vdev
->unit_address
,
522 adapter
->buffer_list_dma
, rxq_desc
.desc
,
523 adapter
->filter_list_dma
, mac_address
);
525 if (rc
!= H_SUCCESS
&& try_again
) {
527 rc
= h_free_logical_lan(adapter
->vdev
->unit_address
);
528 } while (H_IS_LONG_BUSY(rc
) || (rc
== H_BUSY
));
537 static int ibmveth_open(struct net_device
*netdev
)
539 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
542 unsigned long lpar_rc
;
544 union ibmveth_buf_desc rxq_desc
;
548 netdev_dbg(netdev
, "open starting\n");
550 napi_enable(&adapter
->napi
);
552 for(i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++)
553 rxq_entries
+= adapter
->rx_buff_pool
[i
].size
;
555 adapter
->buffer_list_addr
= (void*) get_zeroed_page(GFP_KERNEL
);
556 adapter
->filter_list_addr
= (void*) get_zeroed_page(GFP_KERNEL
);
558 if (!adapter
->buffer_list_addr
|| !adapter
->filter_list_addr
) {
559 netdev_err(netdev
, "unable to allocate filter or buffer list "
565 dev
= &adapter
->vdev
->dev
;
567 adapter
->rx_queue
.queue_len
= sizeof(struct ibmveth_rx_q_entry
) *
569 adapter
->rx_queue
.queue_addr
=
570 dma_alloc_coherent(dev
, adapter
->rx_queue
.queue_len
,
571 &adapter
->rx_queue
.queue_dma
, GFP_KERNEL
);
572 if (!adapter
->rx_queue
.queue_addr
) {
577 adapter
->buffer_list_dma
= dma_map_single(dev
,
578 adapter
->buffer_list_addr
, 4096, DMA_BIDIRECTIONAL
);
579 adapter
->filter_list_dma
= dma_map_single(dev
,
580 adapter
->filter_list_addr
, 4096, DMA_BIDIRECTIONAL
);
582 if ((dma_mapping_error(dev
, adapter
->buffer_list_dma
)) ||
583 (dma_mapping_error(dev
, adapter
->filter_list_dma
))) {
584 netdev_err(netdev
, "unable to map filter or buffer list "
590 adapter
->rx_queue
.index
= 0;
591 adapter
->rx_queue
.num_slots
= rxq_entries
;
592 adapter
->rx_queue
.toggle
= 1;
594 memcpy(&mac_address
, netdev
->dev_addr
, netdev
->addr_len
);
595 mac_address
= mac_address
>> 16;
597 rxq_desc
.fields
.flags_len
= IBMVETH_BUF_VALID
|
598 adapter
->rx_queue
.queue_len
;
599 rxq_desc
.fields
.address
= adapter
->rx_queue
.queue_dma
;
601 netdev_dbg(netdev
, "buffer list @ 0x%p\n", adapter
->buffer_list_addr
);
602 netdev_dbg(netdev
, "filter list @ 0x%p\n", adapter
->filter_list_addr
);
603 netdev_dbg(netdev
, "receive q @ 0x%p\n", adapter
->rx_queue
.queue_addr
);
605 h_vio_signal(adapter
->vdev
->unit_address
, VIO_IRQ_DISABLE
);
607 lpar_rc
= ibmveth_register_logical_lan(adapter
, rxq_desc
, mac_address
);
609 if (lpar_rc
!= H_SUCCESS
) {
610 netdev_err(netdev
, "h_register_logical_lan failed with %ld\n",
612 netdev_err(netdev
, "buffer TCE:0x%llx filter TCE:0x%llx rxq "
613 "desc:0x%llx MAC:0x%llx\n",
614 adapter
->buffer_list_dma
,
615 adapter
->filter_list_dma
,
622 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
623 if (!adapter
->rx_buff_pool
[i
].active
)
625 if (ibmveth_alloc_buffer_pool(&adapter
->rx_buff_pool
[i
])) {
626 netdev_err(netdev
, "unable to alloc pool\n");
627 adapter
->rx_buff_pool
[i
].active
= 0;
633 netdev_dbg(netdev
, "registering irq 0x%x\n", netdev
->irq
);
634 rc
= request_irq(netdev
->irq
, ibmveth_interrupt
, 0, netdev
->name
,
637 netdev_err(netdev
, "unable to request irq 0x%x, rc %d\n",
640 lpar_rc
= h_free_logical_lan(adapter
->vdev
->unit_address
);
641 } while (H_IS_LONG_BUSY(lpar_rc
) || (lpar_rc
== H_BUSY
));
646 adapter
->bounce_buffer
=
647 kmalloc(netdev
->mtu
+ IBMVETH_BUFF_OH
, GFP_KERNEL
);
648 if (!adapter
->bounce_buffer
) {
650 goto err_out_free_irq
;
652 adapter
->bounce_buffer_dma
=
653 dma_map_single(&adapter
->vdev
->dev
, adapter
->bounce_buffer
,
654 netdev
->mtu
+ IBMVETH_BUFF_OH
, DMA_BIDIRECTIONAL
);
655 if (dma_mapping_error(dev
, adapter
->bounce_buffer_dma
)) {
656 netdev_err(netdev
, "unable to map bounce buffer\n");
658 goto err_out_free_irq
;
661 netdev_dbg(netdev
, "initial replenish cycle\n");
662 ibmveth_interrupt(netdev
->irq
, netdev
);
664 netif_start_queue(netdev
);
666 netdev_dbg(netdev
, "open complete\n");
671 free_irq(netdev
->irq
, netdev
);
673 ibmveth_cleanup(adapter
);
674 napi_disable(&adapter
->napi
);
678 static int ibmveth_close(struct net_device
*netdev
)
680 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
683 netdev_dbg(netdev
, "close starting\n");
685 napi_disable(&adapter
->napi
);
687 if (!adapter
->pool_config
)
688 netif_stop_queue(netdev
);
690 h_vio_signal(adapter
->vdev
->unit_address
, VIO_IRQ_DISABLE
);
693 lpar_rc
= h_free_logical_lan(adapter
->vdev
->unit_address
);
694 } while (H_IS_LONG_BUSY(lpar_rc
) || (lpar_rc
== H_BUSY
));
696 if (lpar_rc
!= H_SUCCESS
) {
697 netdev_err(netdev
, "h_free_logical_lan failed with %lx, "
698 "continuing with close\n", lpar_rc
);
701 free_irq(netdev
->irq
, netdev
);
703 ibmveth_update_rx_no_buffer(adapter
);
705 ibmveth_cleanup(adapter
);
707 netdev_dbg(netdev
, "close complete\n");
712 static int netdev_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
714 cmd
->supported
= (SUPPORTED_1000baseT_Full
| SUPPORTED_Autoneg
|
716 cmd
->advertising
= (ADVERTISED_1000baseT_Full
| ADVERTISED_Autoneg
|
718 ethtool_cmd_speed_set(cmd
, SPEED_1000
);
719 cmd
->duplex
= DUPLEX_FULL
;
720 cmd
->port
= PORT_FIBRE
;
721 cmd
->phy_address
= 0;
722 cmd
->transceiver
= XCVR_INTERNAL
;
723 cmd
->autoneg
= AUTONEG_ENABLE
;
729 static void netdev_get_drvinfo(struct net_device
*dev
,
730 struct ethtool_drvinfo
*info
)
732 strlcpy(info
->driver
, ibmveth_driver_name
, sizeof(info
->driver
));
733 strlcpy(info
->version
, ibmveth_driver_version
, sizeof(info
->version
));
736 static netdev_features_t
ibmveth_fix_features(struct net_device
*dev
,
737 netdev_features_t features
)
740 * Since the ibmveth firmware interface does not have the
741 * concept of separate tx/rx checksum offload enable, if rx
742 * checksum is disabled we also have to disable tx checksum
743 * offload. Once we disable rx checksum offload, we are no
744 * longer allowed to send tx buffers that are not properly
748 if (!(features
& NETIF_F_RXCSUM
))
749 features
&= ~NETIF_F_ALL_CSUM
;
754 static int ibmveth_set_csum_offload(struct net_device
*dev
, u32 data
)
756 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
757 unsigned long set_attr
, clr_attr
, ret_attr
;
758 unsigned long set_attr6
, clr_attr6
;
759 long ret
, ret4
, ret6
;
760 int rc1
= 0, rc2
= 0;
763 if (netif_running(dev
)) {
765 adapter
->pool_config
= 1;
767 adapter
->pool_config
= 0;
776 set_attr
= IBMVETH_ILLAN_IPV4_TCP_CSUM
;
777 set_attr6
= IBMVETH_ILLAN_IPV6_TCP_CSUM
;
779 clr_attr
= IBMVETH_ILLAN_IPV4_TCP_CSUM
;
780 clr_attr6
= IBMVETH_ILLAN_IPV6_TCP_CSUM
;
783 ret
= h_illan_attributes(adapter
->vdev
->unit_address
, 0, 0, &ret_attr
);
785 if (ret
== H_SUCCESS
&& !(ret_attr
& IBMVETH_ILLAN_ACTIVE_TRUNK
) &&
786 !(ret_attr
& IBMVETH_ILLAN_TRUNK_PRI_MASK
) &&
787 (ret_attr
& IBMVETH_ILLAN_PADDED_PKT_CSUM
)) {
788 ret4
= h_illan_attributes(adapter
->vdev
->unit_address
, clr_attr
,
789 set_attr
, &ret_attr
);
791 if (ret4
!= H_SUCCESS
) {
792 netdev_err(dev
, "unable to change IPv4 checksum "
793 "offload settings. %d rc=%ld\n",
796 h_illan_attributes(adapter
->vdev
->unit_address
,
797 set_attr
, clr_attr
, &ret_attr
);
800 dev
->features
&= ~NETIF_F_IP_CSUM
;
803 adapter
->fw_ipv4_csum_support
= data
;
806 ret6
= h_illan_attributes(adapter
->vdev
->unit_address
,
807 clr_attr6
, set_attr6
, &ret_attr
);
809 if (ret6
!= H_SUCCESS
) {
810 netdev_err(dev
, "unable to change IPv6 checksum "
811 "offload settings. %d rc=%ld\n",
814 h_illan_attributes(adapter
->vdev
->unit_address
,
815 set_attr6
, clr_attr6
, &ret_attr
);
818 dev
->features
&= ~NETIF_F_IPV6_CSUM
;
821 adapter
->fw_ipv6_csum_support
= data
;
823 if (ret4
== H_SUCCESS
|| ret6
== H_SUCCESS
)
824 adapter
->rx_csum
= data
;
829 netdev_err(dev
, "unable to change checksum offload settings."
830 " %d rc=%ld ret_attr=%lx\n", data
, ret
,
835 rc2
= ibmveth_open(dev
);
837 return rc1
? rc1
: rc2
;
840 static int ibmveth_set_features(struct net_device
*dev
,
841 netdev_features_t features
)
843 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
844 int rx_csum
= !!(features
& NETIF_F_RXCSUM
);
847 if (rx_csum
== adapter
->rx_csum
)
850 rc
= ibmveth_set_csum_offload(dev
, rx_csum
);
851 if (rc
&& !adapter
->rx_csum
)
852 dev
->features
= features
& ~(NETIF_F_ALL_CSUM
| NETIF_F_RXCSUM
);
857 static void ibmveth_get_strings(struct net_device
*dev
, u32 stringset
, u8
*data
)
861 if (stringset
!= ETH_SS_STATS
)
864 for (i
= 0; i
< ARRAY_SIZE(ibmveth_stats
); i
++, data
+= ETH_GSTRING_LEN
)
865 memcpy(data
, ibmveth_stats
[i
].name
, ETH_GSTRING_LEN
);
868 static int ibmveth_get_sset_count(struct net_device
*dev
, int sset
)
872 return ARRAY_SIZE(ibmveth_stats
);
878 static void ibmveth_get_ethtool_stats(struct net_device
*dev
,
879 struct ethtool_stats
*stats
, u64
*data
)
882 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
884 for (i
= 0; i
< ARRAY_SIZE(ibmveth_stats
); i
++)
885 data
[i
] = IBMVETH_GET_STAT(adapter
, ibmveth_stats
[i
].offset
);
888 static const struct ethtool_ops netdev_ethtool_ops
= {
889 .get_drvinfo
= netdev_get_drvinfo
,
890 .get_settings
= netdev_get_settings
,
891 .get_link
= ethtool_op_get_link
,
892 .get_strings
= ibmveth_get_strings
,
893 .get_sset_count
= ibmveth_get_sset_count
,
894 .get_ethtool_stats
= ibmveth_get_ethtool_stats
,
897 static int ibmveth_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
902 #define page_offset(v) ((unsigned long)(v) & ((1 << 12) - 1))
904 static int ibmveth_send(struct ibmveth_adapter
*adapter
,
905 union ibmveth_buf_desc
*descs
)
907 unsigned long correlator
;
908 unsigned int retry_count
;
912 * The retry count sets a maximum for the number of broadcast and
913 * multicast destinations within the system.
918 ret
= h_send_logical_lan(adapter
->vdev
->unit_address
,
919 descs
[0].desc
, descs
[1].desc
,
920 descs
[2].desc
, descs
[3].desc
,
921 descs
[4].desc
, descs
[5].desc
,
922 correlator
, &correlator
);
923 } while ((ret
== H_BUSY
) && (retry_count
--));
925 if (ret
!= H_SUCCESS
&& ret
!= H_DROPPED
) {
926 netdev_err(adapter
->netdev
, "tx: h_send_logical_lan failed "
927 "with rc=%ld\n", ret
);
934 static netdev_tx_t
ibmveth_start_xmit(struct sk_buff
*skb
,
935 struct net_device
*netdev
)
937 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
938 unsigned int desc_flags
;
939 union ibmveth_buf_desc descs
[6];
941 int force_bounce
= 0;
945 * veth handles a maximum of 6 segments including the header, so
946 * we have to linearize the skb if there are more than this.
948 if (skb_shinfo(skb
)->nr_frags
> 5 && __skb_linearize(skb
)) {
949 netdev
->stats
.tx_dropped
++;
953 /* veth can't checksum offload UDP */
954 if (skb
->ip_summed
== CHECKSUM_PARTIAL
&&
955 ((skb
->protocol
== htons(ETH_P_IP
) &&
956 ip_hdr(skb
)->protocol
!= IPPROTO_TCP
) ||
957 (skb
->protocol
== htons(ETH_P_IPV6
) &&
958 ipv6_hdr(skb
)->nexthdr
!= IPPROTO_TCP
)) &&
959 skb_checksum_help(skb
)) {
961 netdev_err(netdev
, "tx: failed to checksum packet\n");
962 netdev
->stats
.tx_dropped
++;
966 desc_flags
= IBMVETH_BUF_VALID
;
968 if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
969 unsigned char *buf
= skb_transport_header(skb
) +
972 desc_flags
|= (IBMVETH_BUF_NO_CSUM
| IBMVETH_BUF_CSUM_GOOD
);
974 /* Need to zero out the checksum */
980 memset(descs
, 0, sizeof(descs
));
983 * If a linear packet is below the rx threshold then
984 * copy it into the static bounce buffer. This avoids the
985 * cost of a TCE insert and remove.
987 if (force_bounce
|| (!skb_is_nonlinear(skb
) &&
988 (skb
->len
< tx_copybreak
))) {
989 skb_copy_from_linear_data(skb
, adapter
->bounce_buffer
,
992 descs
[0].fields
.flags_len
= desc_flags
| skb
->len
;
993 descs
[0].fields
.address
= adapter
->bounce_buffer_dma
;
995 if (ibmveth_send(adapter
, descs
)) {
996 adapter
->tx_send_failed
++;
997 netdev
->stats
.tx_dropped
++;
999 netdev
->stats
.tx_packets
++;
1000 netdev
->stats
.tx_bytes
+= skb
->len
;
1006 /* Map the header */
1007 dma_addr
= dma_map_single(&adapter
->vdev
->dev
, skb
->data
,
1008 skb_headlen(skb
), DMA_TO_DEVICE
);
1009 if (dma_mapping_error(&adapter
->vdev
->dev
, dma_addr
))
1012 descs
[0].fields
.flags_len
= desc_flags
| skb_headlen(skb
);
1013 descs
[0].fields
.address
= dma_addr
;
1016 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
1017 const skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
];
1019 dma_addr
= skb_frag_dma_map(&adapter
->vdev
->dev
, frag
, 0,
1020 skb_frag_size(frag
), DMA_TO_DEVICE
);
1022 if (dma_mapping_error(&adapter
->vdev
->dev
, dma_addr
))
1023 goto map_failed_frags
;
1025 descs
[i
+1].fields
.flags_len
= desc_flags
| skb_frag_size(frag
);
1026 descs
[i
+1].fields
.address
= dma_addr
;
1029 if (ibmveth_send(adapter
, descs
)) {
1030 adapter
->tx_send_failed
++;
1031 netdev
->stats
.tx_dropped
++;
1033 netdev
->stats
.tx_packets
++;
1034 netdev
->stats
.tx_bytes
+= skb
->len
;
1037 dma_unmap_single(&adapter
->vdev
->dev
,
1038 descs
[0].fields
.address
,
1039 descs
[0].fields
.flags_len
& IBMVETH_BUF_LEN_MASK
,
1042 for (i
= 1; i
< skb_shinfo(skb
)->nr_frags
+ 1; i
++)
1043 dma_unmap_page(&adapter
->vdev
->dev
, descs
[i
].fields
.address
,
1044 descs
[i
].fields
.flags_len
& IBMVETH_BUF_LEN_MASK
,
1049 return NETDEV_TX_OK
;
1053 for (i
= 0; i
< last
; i
++)
1054 dma_unmap_page(&adapter
->vdev
->dev
, descs
[i
].fields
.address
,
1055 descs
[i
].fields
.flags_len
& IBMVETH_BUF_LEN_MASK
,
1059 if (!firmware_has_feature(FW_FEATURE_CMO
))
1060 netdev_err(netdev
, "tx: unable to map xmit buffer\n");
1061 adapter
->tx_map_failed
++;
1067 static int ibmveth_poll(struct napi_struct
*napi
, int budget
)
1069 struct ibmveth_adapter
*adapter
=
1070 container_of(napi
, struct ibmveth_adapter
, napi
);
1071 struct net_device
*netdev
= adapter
->netdev
;
1072 int frames_processed
= 0;
1073 unsigned long lpar_rc
;
1077 if (!ibmveth_rxq_pending_buffer(adapter
))
1081 if (!ibmveth_rxq_buffer_valid(adapter
)) {
1082 wmb(); /* suggested by larson1 */
1083 adapter
->rx_invalid_buffer
++;
1084 netdev_dbg(netdev
, "recycling invalid buffer\n");
1085 ibmveth_rxq_recycle_buffer(adapter
);
1087 struct sk_buff
*skb
, *new_skb
;
1088 int length
= ibmveth_rxq_frame_length(adapter
);
1089 int offset
= ibmveth_rxq_frame_offset(adapter
);
1090 int csum_good
= ibmveth_rxq_csum_good(adapter
);
1092 skb
= ibmveth_rxq_get_buffer(adapter
);
1095 if (length
< rx_copybreak
)
1096 new_skb
= netdev_alloc_skb(netdev
, length
);
1099 skb_copy_to_linear_data(new_skb
,
1103 ibmveth_flush_buffer(skb
->data
,
1105 if (!ibmveth_rxq_recycle_buffer(adapter
))
1109 ibmveth_rxq_harvest_buffer(adapter
);
1110 skb_reserve(skb
, offset
);
1113 skb_put(skb
, length
);
1114 skb
->protocol
= eth_type_trans(skb
, netdev
);
1117 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1119 netif_receive_skb(skb
); /* send it up */
1121 netdev
->stats
.rx_packets
++;
1122 netdev
->stats
.rx_bytes
+= length
;
1125 } while (frames_processed
< budget
);
1127 ibmveth_replenish_task(adapter
);
1129 if (frames_processed
< budget
) {
1130 /* We think we are done - reenable interrupts,
1131 * then check once more to make sure we are done.
1133 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
,
1136 BUG_ON(lpar_rc
!= H_SUCCESS
);
1138 napi_complete(napi
);
1140 if (ibmveth_rxq_pending_buffer(adapter
) &&
1141 napi_reschedule(napi
)) {
1142 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
,
1148 return frames_processed
;
1151 static irqreturn_t
ibmveth_interrupt(int irq
, void *dev_instance
)
1153 struct net_device
*netdev
= dev_instance
;
1154 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
1155 unsigned long lpar_rc
;
1157 if (napi_schedule_prep(&adapter
->napi
)) {
1158 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
,
1160 BUG_ON(lpar_rc
!= H_SUCCESS
);
1161 __napi_schedule(&adapter
->napi
);
1166 static void ibmveth_set_multicast_list(struct net_device
*netdev
)
1168 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
1169 unsigned long lpar_rc
;
1171 if ((netdev
->flags
& IFF_PROMISC
) ||
1172 (netdev_mc_count(netdev
) > adapter
->mcastFilterSize
)) {
1173 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1174 IbmVethMcastEnableRecv
|
1175 IbmVethMcastDisableFiltering
,
1177 if (lpar_rc
!= H_SUCCESS
) {
1178 netdev_err(netdev
, "h_multicast_ctrl rc=%ld when "
1179 "entering promisc mode\n", lpar_rc
);
1182 struct netdev_hw_addr
*ha
;
1183 /* clear the filter table & disable filtering */
1184 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1185 IbmVethMcastEnableRecv
|
1186 IbmVethMcastDisableFiltering
|
1187 IbmVethMcastClearFilterTable
,
1189 if (lpar_rc
!= H_SUCCESS
) {
1190 netdev_err(netdev
, "h_multicast_ctrl rc=%ld when "
1191 "attempting to clear filter table\n",
1194 /* add the addresses to the filter table */
1195 netdev_for_each_mc_addr(ha
, netdev
) {
1196 /* add the multicast address to the filter table */
1197 unsigned long mcast_addr
= 0;
1198 memcpy(((char *)&mcast_addr
)+2, ha
->addr
, 6);
1199 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1200 IbmVethMcastAddFilter
,
1202 if (lpar_rc
!= H_SUCCESS
) {
1203 netdev_err(netdev
, "h_multicast_ctrl rc=%ld "
1204 "when adding an entry to the filter "
1205 "table\n", lpar_rc
);
1209 /* re-enable filtering */
1210 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1211 IbmVethMcastEnableFiltering
,
1213 if (lpar_rc
!= H_SUCCESS
) {
1214 netdev_err(netdev
, "h_multicast_ctrl rc=%ld when "
1215 "enabling filtering\n", lpar_rc
);
1220 static int ibmveth_change_mtu(struct net_device
*dev
, int new_mtu
)
1222 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
1223 struct vio_dev
*viodev
= adapter
->vdev
;
1224 int new_mtu_oh
= new_mtu
+ IBMVETH_BUFF_OH
;
1226 int need_restart
= 0;
1228 if (new_mtu
< IBMVETH_MIN_MTU
)
1231 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++)
1232 if (new_mtu_oh
< adapter
->rx_buff_pool
[i
].buff_size
)
1235 if (i
== IBMVETH_NUM_BUFF_POOLS
)
1238 /* Deactivate all the buffer pools so that the next loop can activate
1239 only the buffer pools necessary to hold the new MTU */
1240 if (netif_running(adapter
->netdev
)) {
1242 adapter
->pool_config
= 1;
1243 ibmveth_close(adapter
->netdev
);
1244 adapter
->pool_config
= 0;
1247 /* Look for an active buffer pool that can hold the new MTU */
1248 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
1249 adapter
->rx_buff_pool
[i
].active
= 1;
1251 if (new_mtu_oh
< adapter
->rx_buff_pool
[i
].buff_size
) {
1253 vio_cmo_set_dev_desired(viodev
,
1254 ibmveth_get_desired_dma
1257 return ibmveth_open(adapter
->netdev
);
1263 if (need_restart
&& (rc
= ibmveth_open(adapter
->netdev
)))
1269 #ifdef CONFIG_NET_POLL_CONTROLLER
1270 static void ibmveth_poll_controller(struct net_device
*dev
)
1272 ibmveth_replenish_task(netdev_priv(dev
));
1273 ibmveth_interrupt(dev
->irq
, dev
);
1278 * ibmveth_get_desired_dma - Calculate IO memory desired by the driver
1280 * @vdev: struct vio_dev for the device whose desired IO mem is to be returned
1283 * Number of bytes of IO data the driver will need to perform well.
1285 static unsigned long ibmveth_get_desired_dma(struct vio_dev
*vdev
)
1287 struct net_device
*netdev
= dev_get_drvdata(&vdev
->dev
);
1288 struct ibmveth_adapter
*adapter
;
1293 /* netdev inits at probe time along with the structures we need below*/
1295 return IOMMU_PAGE_ALIGN(IBMVETH_IO_ENTITLEMENT_DEFAULT
);
1297 adapter
= netdev_priv(netdev
);
1299 ret
= IBMVETH_BUFF_LIST_SIZE
+ IBMVETH_FILT_LIST_SIZE
;
1300 ret
+= IOMMU_PAGE_ALIGN(netdev
->mtu
);
1302 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
1303 /* add the size of the active receive buffers */
1304 if (adapter
->rx_buff_pool
[i
].active
)
1306 adapter
->rx_buff_pool
[i
].size
*
1307 IOMMU_PAGE_ALIGN(adapter
->rx_buff_pool
[i
].
1309 rxqentries
+= adapter
->rx_buff_pool
[i
].size
;
1311 /* add the size of the receive queue entries */
1312 ret
+= IOMMU_PAGE_ALIGN(rxqentries
* sizeof(struct ibmveth_rx_q_entry
));
1317 static const struct net_device_ops ibmveth_netdev_ops
= {
1318 .ndo_open
= ibmveth_open
,
1319 .ndo_stop
= ibmveth_close
,
1320 .ndo_start_xmit
= ibmveth_start_xmit
,
1321 .ndo_set_rx_mode
= ibmveth_set_multicast_list
,
1322 .ndo_do_ioctl
= ibmveth_ioctl
,
1323 .ndo_change_mtu
= ibmveth_change_mtu
,
1324 .ndo_fix_features
= ibmveth_fix_features
,
1325 .ndo_set_features
= ibmveth_set_features
,
1326 .ndo_validate_addr
= eth_validate_addr
,
1327 .ndo_set_mac_address
= eth_mac_addr
,
1328 #ifdef CONFIG_NET_POLL_CONTROLLER
1329 .ndo_poll_controller
= ibmveth_poll_controller
,
1333 static int ibmveth_probe(struct vio_dev
*dev
, const struct vio_device_id
*id
)
1336 struct net_device
*netdev
;
1337 struct ibmveth_adapter
*adapter
;
1338 unsigned char *mac_addr_p
;
1339 unsigned int *mcastFilterSize_p
;
1341 dev_dbg(&dev
->dev
, "entering ibmveth_probe for UA 0x%x\n",
1344 mac_addr_p
= (unsigned char *)vio_get_attribute(dev
, VETH_MAC_ADDR
,
1347 dev_err(&dev
->dev
, "Can't find VETH_MAC_ADDR attribute\n");
1350 /* Workaround for old/broken pHyp */
1353 else if (mac_len
!= 6) {
1354 dev_err(&dev
->dev
, "VETH_MAC_ADDR attribute wrong len %d\n",
1359 mcastFilterSize_p
= (unsigned int *)vio_get_attribute(dev
,
1360 VETH_MCAST_FILTER_SIZE
, NULL
);
1361 if (!mcastFilterSize_p
) {
1362 dev_err(&dev
->dev
, "Can't find VETH_MCAST_FILTER_SIZE "
1367 netdev
= alloc_etherdev(sizeof(struct ibmveth_adapter
));
1372 adapter
= netdev_priv(netdev
);
1373 dev_set_drvdata(&dev
->dev
, netdev
);
1375 adapter
->vdev
= dev
;
1376 adapter
->netdev
= netdev
;
1377 adapter
->mcastFilterSize
= *mcastFilterSize_p
;
1378 adapter
->pool_config
= 0;
1380 netif_napi_add(netdev
, &adapter
->napi
, ibmveth_poll
, 16);
1382 adapter
->mac_addr
= 0;
1383 memcpy(&adapter
->mac_addr
, mac_addr_p
, 6);
1385 netdev
->irq
= dev
->irq
;
1386 netdev
->netdev_ops
= &ibmveth_netdev_ops
;
1387 netdev
->ethtool_ops
= &netdev_ethtool_ops
;
1388 SET_NETDEV_DEV(netdev
, &dev
->dev
);
1389 netdev
->hw_features
= NETIF_F_SG
| NETIF_F_RXCSUM
|
1390 NETIF_F_IP_CSUM
| NETIF_F_IPV6_CSUM
;
1391 netdev
->features
|= netdev
->hw_features
;
1393 memcpy(netdev
->dev_addr
, &adapter
->mac_addr
, netdev
->addr_len
);
1395 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
1396 struct kobject
*kobj
= &adapter
->rx_buff_pool
[i
].kobj
;
1399 ibmveth_init_buffer_pool(&adapter
->rx_buff_pool
[i
], i
,
1400 pool_count
[i
], pool_size
[i
],
1402 error
= kobject_init_and_add(kobj
, &ktype_veth_pool
,
1403 &dev
->dev
.kobj
, "pool%d", i
);
1405 kobject_uevent(kobj
, KOBJ_ADD
);
1408 netdev_dbg(netdev
, "adapter @ 0x%p\n", adapter
);
1410 adapter
->buffer_list_dma
= DMA_ERROR_CODE
;
1411 adapter
->filter_list_dma
= DMA_ERROR_CODE
;
1412 adapter
->rx_queue
.queue_dma
= DMA_ERROR_CODE
;
1414 netdev_dbg(netdev
, "registering netdev...\n");
1416 ibmveth_set_features(netdev
, netdev
->features
);
1418 rc
= register_netdev(netdev
);
1421 netdev_dbg(netdev
, "failed to register netdev rc=%d\n", rc
);
1422 free_netdev(netdev
);
1426 netdev_dbg(netdev
, "registered\n");
1431 static int ibmveth_remove(struct vio_dev
*dev
)
1433 struct net_device
*netdev
= dev_get_drvdata(&dev
->dev
);
1434 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
1437 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++)
1438 kobject_put(&adapter
->rx_buff_pool
[i
].kobj
);
1440 unregister_netdev(netdev
);
1442 free_netdev(netdev
);
1443 dev_set_drvdata(&dev
->dev
, NULL
);
1448 static struct attribute veth_active_attr
;
1449 static struct attribute veth_num_attr
;
1450 static struct attribute veth_size_attr
;
1452 static ssize_t
veth_pool_show(struct kobject
*kobj
,
1453 struct attribute
*attr
, char *buf
)
1455 struct ibmveth_buff_pool
*pool
= container_of(kobj
,
1456 struct ibmveth_buff_pool
,
1459 if (attr
== &veth_active_attr
)
1460 return sprintf(buf
, "%d\n", pool
->active
);
1461 else if (attr
== &veth_num_attr
)
1462 return sprintf(buf
, "%d\n", pool
->size
);
1463 else if (attr
== &veth_size_attr
)
1464 return sprintf(buf
, "%d\n", pool
->buff_size
);
1468 static ssize_t
veth_pool_store(struct kobject
*kobj
, struct attribute
*attr
,
1469 const char *buf
, size_t count
)
1471 struct ibmveth_buff_pool
*pool
= container_of(kobj
,
1472 struct ibmveth_buff_pool
,
1474 struct net_device
*netdev
= dev_get_drvdata(
1475 container_of(kobj
->parent
, struct device
, kobj
));
1476 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
1477 long value
= simple_strtol(buf
, NULL
, 10);
1480 if (attr
== &veth_active_attr
) {
1481 if (value
&& !pool
->active
) {
1482 if (netif_running(netdev
)) {
1483 if (ibmveth_alloc_buffer_pool(pool
)) {
1485 "unable to alloc pool\n");
1489 adapter
->pool_config
= 1;
1490 ibmveth_close(netdev
);
1491 adapter
->pool_config
= 0;
1492 if ((rc
= ibmveth_open(netdev
)))
1497 } else if (!value
&& pool
->active
) {
1498 int mtu
= netdev
->mtu
+ IBMVETH_BUFF_OH
;
1500 /* Make sure there is a buffer pool with buffers that
1501 can hold a packet of the size of the MTU */
1502 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
1503 if (pool
== &adapter
->rx_buff_pool
[i
])
1505 if (!adapter
->rx_buff_pool
[i
].active
)
1507 if (mtu
<= adapter
->rx_buff_pool
[i
].buff_size
)
1511 if (i
== IBMVETH_NUM_BUFF_POOLS
) {
1512 netdev_err(netdev
, "no active pool >= MTU\n");
1516 if (netif_running(netdev
)) {
1517 adapter
->pool_config
= 1;
1518 ibmveth_close(netdev
);
1520 adapter
->pool_config
= 0;
1521 if ((rc
= ibmveth_open(netdev
)))
1526 } else if (attr
== &veth_num_attr
) {
1527 if (value
<= 0 || value
> IBMVETH_MAX_POOL_COUNT
) {
1530 if (netif_running(netdev
)) {
1531 adapter
->pool_config
= 1;
1532 ibmveth_close(netdev
);
1533 adapter
->pool_config
= 0;
1535 if ((rc
= ibmveth_open(netdev
)))
1541 } else if (attr
== &veth_size_attr
) {
1542 if (value
<= IBMVETH_BUFF_OH
|| value
> IBMVETH_MAX_BUF_SIZE
) {
1545 if (netif_running(netdev
)) {
1546 adapter
->pool_config
= 1;
1547 ibmveth_close(netdev
);
1548 adapter
->pool_config
= 0;
1549 pool
->buff_size
= value
;
1550 if ((rc
= ibmveth_open(netdev
)))
1553 pool
->buff_size
= value
;
1558 /* kick the interrupt handler to allocate/deallocate pools */
1559 ibmveth_interrupt(netdev
->irq
, netdev
);
1564 #define ATTR(_name, _mode) \
1565 struct attribute veth_##_name##_attr = { \
1566 .name = __stringify(_name), .mode = _mode, \
1569 static ATTR(active
, 0644);
1570 static ATTR(num
, 0644);
1571 static ATTR(size
, 0644);
1573 static struct attribute
*veth_pool_attrs
[] = {
1580 static const struct sysfs_ops veth_pool_ops
= {
1581 .show
= veth_pool_show
,
1582 .store
= veth_pool_store
,
1585 static struct kobj_type ktype_veth_pool
= {
1587 .sysfs_ops
= &veth_pool_ops
,
1588 .default_attrs
= veth_pool_attrs
,
1591 static int ibmveth_resume(struct device
*dev
)
1593 struct net_device
*netdev
= dev_get_drvdata(dev
);
1594 ibmveth_interrupt(netdev
->irq
, netdev
);
1598 static struct vio_device_id ibmveth_device_table
[] = {
1599 { "network", "IBM,l-lan"},
1602 MODULE_DEVICE_TABLE(vio
, ibmveth_device_table
);
1604 static struct dev_pm_ops ibmveth_pm_ops
= {
1605 .resume
= ibmveth_resume
1608 static struct vio_driver ibmveth_driver
= {
1609 .id_table
= ibmveth_device_table
,
1610 .probe
= ibmveth_probe
,
1611 .remove
= ibmveth_remove
,
1612 .get_desired_dma
= ibmveth_get_desired_dma
,
1613 .name
= ibmveth_driver_name
,
1614 .pm
= &ibmveth_pm_ops
,
1617 static int __init
ibmveth_module_init(void)
1619 printk(KERN_DEBUG
"%s: %s %s\n", ibmveth_driver_name
,
1620 ibmveth_driver_string
, ibmveth_driver_version
);
1622 return vio_register_driver(&ibmveth_driver
);
1625 static void __exit
ibmveth_module_exit(void)
1627 vio_unregister_driver(&ibmveth_driver
);
1630 module_init(ibmveth_module_init
);
1631 module_exit(ibmveth_module_exit
);