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, see <http://www.gnu.org/licenses/>.
17 * Copyright (C) IBM Corporation, 2003, 2010
19 * Authors: Dave Larson <larson1@us.ibm.com>
20 * Santiago Leon <santil@linux.vnet.ibm.com>
21 * Brian King <brking@linux.vnet.ibm.com>
22 * Robert Jennings <rcj@linux.vnet.ibm.com>
23 * Anton Blanchard <anton@au.ibm.com>
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/types.h>
29 #include <linux/errno.h>
30 #include <linux/dma-mapping.h>
31 #include <linux/kernel.h>
32 #include <linux/netdevice.h>
33 #include <linux/etherdevice.h>
34 #include <linux/skbuff.h>
35 #include <linux/init.h>
36 #include <linux/interrupt.h>
39 #include <linux/ethtool.h>
42 #include <linux/ipv6.h>
43 #include <linux/slab.h>
44 #include <asm/hvcall.h>
45 #include <linux/atomic.h>
47 #include <asm/iommu.h>
48 #include <asm/firmware.h>
52 static irqreturn_t
ibmveth_interrupt(int irq
, void *dev_instance
);
53 static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter
*adapter
);
54 static unsigned long ibmveth_get_desired_dma(struct vio_dev
*vdev
);
56 static struct kobj_type ktype_veth_pool
;
59 static const char ibmveth_driver_name
[] = "ibmveth";
60 static const char ibmveth_driver_string
[] = "IBM Power Virtual Ethernet Driver";
61 #define ibmveth_driver_version "1.04"
63 MODULE_AUTHOR("Santiago Leon <santil@linux.vnet.ibm.com>");
64 MODULE_DESCRIPTION("IBM Power Virtual Ethernet Driver");
65 MODULE_LICENSE("GPL");
66 MODULE_VERSION(ibmveth_driver_version
);
68 static unsigned int tx_copybreak __read_mostly
= 128;
69 module_param(tx_copybreak
, uint
, 0644);
70 MODULE_PARM_DESC(tx_copybreak
,
71 "Maximum size of packet that is copied to a new buffer on transmit");
73 static unsigned int rx_copybreak __read_mostly
= 128;
74 module_param(rx_copybreak
, uint
, 0644);
75 MODULE_PARM_DESC(rx_copybreak
,
76 "Maximum size of packet that is copied to a new buffer on receive");
78 static unsigned int rx_flush __read_mostly
= 0;
79 module_param(rx_flush
, uint
, 0644);
80 MODULE_PARM_DESC(rx_flush
, "Flush receive buffers before use");
83 char name
[ETH_GSTRING_LEN
];
87 #define IBMVETH_STAT_OFF(stat) offsetof(struct ibmveth_adapter, stat)
88 #define IBMVETH_GET_STAT(a, off) *((u64 *)(((unsigned long)(a)) + off))
90 struct ibmveth_stat ibmveth_stats
[] = {
91 { "replenish_task_cycles", IBMVETH_STAT_OFF(replenish_task_cycles
) },
92 { "replenish_no_mem", IBMVETH_STAT_OFF(replenish_no_mem
) },
93 { "replenish_add_buff_failure",
94 IBMVETH_STAT_OFF(replenish_add_buff_failure
) },
95 { "replenish_add_buff_success",
96 IBMVETH_STAT_OFF(replenish_add_buff_success
) },
97 { "rx_invalid_buffer", IBMVETH_STAT_OFF(rx_invalid_buffer
) },
98 { "rx_no_buffer", IBMVETH_STAT_OFF(rx_no_buffer
) },
99 { "tx_map_failed", IBMVETH_STAT_OFF(tx_map_failed
) },
100 { "tx_send_failed", IBMVETH_STAT_OFF(tx_send_failed
) },
101 { "fw_enabled_ipv4_csum", IBMVETH_STAT_OFF(fw_ipv4_csum_support
) },
102 { "fw_enabled_ipv6_csum", IBMVETH_STAT_OFF(fw_ipv6_csum_support
) },
105 /* simple methods of getting data from the current rxq entry */
106 static inline u32
ibmveth_rxq_flags(struct ibmveth_adapter
*adapter
)
108 return be32_to_cpu(adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].flags_off
);
111 static inline int ibmveth_rxq_toggle(struct ibmveth_adapter
*adapter
)
113 return (ibmveth_rxq_flags(adapter
) & IBMVETH_RXQ_TOGGLE
) >>
114 IBMVETH_RXQ_TOGGLE_SHIFT
;
117 static inline int ibmveth_rxq_pending_buffer(struct ibmveth_adapter
*adapter
)
119 return ibmveth_rxq_toggle(adapter
) == adapter
->rx_queue
.toggle
;
122 static inline int ibmveth_rxq_buffer_valid(struct ibmveth_adapter
*adapter
)
124 return ibmveth_rxq_flags(adapter
) & IBMVETH_RXQ_VALID
;
127 static inline int ibmveth_rxq_frame_offset(struct ibmveth_adapter
*adapter
)
129 return ibmveth_rxq_flags(adapter
) & IBMVETH_RXQ_OFF_MASK
;
132 static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter
*adapter
)
134 return be32_to_cpu(adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].length
);
137 static inline int ibmveth_rxq_csum_good(struct ibmveth_adapter
*adapter
)
139 return ibmveth_rxq_flags(adapter
) & IBMVETH_RXQ_CSUM_GOOD
;
142 /* setup the initial settings for a buffer pool */
143 static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool
*pool
,
144 u32 pool_index
, u32 pool_size
,
145 u32 buff_size
, u32 pool_active
)
147 pool
->size
= pool_size
;
148 pool
->index
= pool_index
;
149 pool
->buff_size
= buff_size
;
150 pool
->threshold
= pool_size
* 7 / 8;
151 pool
->active
= pool_active
;
154 /* allocate and setup an buffer pool - called during open */
155 static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool
*pool
)
159 pool
->free_map
= kmalloc(sizeof(u16
) * pool
->size
, GFP_KERNEL
);
164 pool
->dma_addr
= kmalloc(sizeof(dma_addr_t
) * pool
->size
, GFP_KERNEL
);
165 if (!pool
->dma_addr
) {
166 kfree(pool
->free_map
);
167 pool
->free_map
= NULL
;
171 pool
->skbuff
= kcalloc(pool
->size
, sizeof(void *), GFP_KERNEL
);
174 kfree(pool
->dma_addr
);
175 pool
->dma_addr
= NULL
;
177 kfree(pool
->free_map
);
178 pool
->free_map
= NULL
;
182 memset(pool
->dma_addr
, 0, sizeof(dma_addr_t
) * pool
->size
);
184 for (i
= 0; i
< pool
->size
; ++i
)
185 pool
->free_map
[i
] = i
;
187 atomic_set(&pool
->available
, 0);
188 pool
->producer_index
= 0;
189 pool
->consumer_index
= 0;
194 static inline void ibmveth_flush_buffer(void *addr
, unsigned long length
)
196 unsigned long offset
;
198 for (offset
= 0; offset
< length
; offset
+= SMP_CACHE_BYTES
)
199 asm("dcbfl %0,%1" :: "b" (addr
), "r" (offset
));
202 /* replenish the buffers for a pool. note that we don't need to
203 * skb_reserve these since they are used for incoming...
205 static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter
*adapter
,
206 struct ibmveth_buff_pool
*pool
)
209 u32 count
= pool
->size
- atomic_read(&pool
->available
);
210 u32 buffers_added
= 0;
212 unsigned int free_index
, index
;
214 unsigned long lpar_rc
;
219 for (i
= 0; i
< count
; ++i
) {
220 union ibmveth_buf_desc desc
;
222 skb
= netdev_alloc_skb(adapter
->netdev
, pool
->buff_size
);
225 netdev_dbg(adapter
->netdev
,
226 "replenish: unable to allocate skb\n");
227 adapter
->replenish_no_mem
++;
231 free_index
= pool
->consumer_index
;
232 pool
->consumer_index
++;
233 if (pool
->consumer_index
>= pool
->size
)
234 pool
->consumer_index
= 0;
235 index
= pool
->free_map
[free_index
];
237 BUG_ON(index
== IBM_VETH_INVALID_MAP
);
238 BUG_ON(pool
->skbuff
[index
] != NULL
);
240 dma_addr
= dma_map_single(&adapter
->vdev
->dev
, skb
->data
,
241 pool
->buff_size
, DMA_FROM_DEVICE
);
243 if (dma_mapping_error(&adapter
->vdev
->dev
, dma_addr
))
246 pool
->free_map
[free_index
] = IBM_VETH_INVALID_MAP
;
247 pool
->dma_addr
[index
] = dma_addr
;
248 pool
->skbuff
[index
] = skb
;
250 correlator
= ((u64
)pool
->index
<< 32) | index
;
251 *(u64
*)skb
->data
= correlator
;
253 desc
.fields
.flags_len
= IBMVETH_BUF_VALID
| pool
->buff_size
;
254 desc
.fields
.address
= dma_addr
;
257 unsigned int len
= min(pool
->buff_size
,
258 adapter
->netdev
->mtu
+
260 ibmveth_flush_buffer(skb
->data
, len
);
262 lpar_rc
= h_add_logical_lan_buffer(adapter
->vdev
->unit_address
,
265 if (lpar_rc
!= H_SUCCESS
) {
269 adapter
->replenish_add_buff_success
++;
274 atomic_add(buffers_added
, &(pool
->available
));
278 pool
->free_map
[free_index
] = index
;
279 pool
->skbuff
[index
] = NULL
;
280 if (pool
->consumer_index
== 0)
281 pool
->consumer_index
= pool
->size
- 1;
283 pool
->consumer_index
--;
284 if (!dma_mapping_error(&adapter
->vdev
->dev
, dma_addr
))
285 dma_unmap_single(&adapter
->vdev
->dev
,
286 pool
->dma_addr
[index
], pool
->buff_size
,
288 dev_kfree_skb_any(skb
);
289 adapter
->replenish_add_buff_failure
++;
292 atomic_add(buffers_added
, &(pool
->available
));
295 /* replenish routine */
296 static void ibmveth_replenish_task(struct ibmveth_adapter
*adapter
)
300 adapter
->replenish_task_cycles
++;
302 for (i
= (IBMVETH_NUM_BUFF_POOLS
- 1); i
>= 0; i
--) {
303 struct ibmveth_buff_pool
*pool
= &adapter
->rx_buff_pool
[i
];
306 (atomic_read(&pool
->available
) < pool
->threshold
))
307 ibmveth_replenish_buffer_pool(adapter
, pool
);
310 adapter
->rx_no_buffer
= *(u64
*)(((char*)adapter
->buffer_list_addr
) +
314 /* empty and free ana buffer pool - also used to do cleanup in error paths */
315 static void ibmveth_free_buffer_pool(struct ibmveth_adapter
*adapter
,
316 struct ibmveth_buff_pool
*pool
)
320 kfree(pool
->free_map
);
321 pool
->free_map
= NULL
;
323 if (pool
->skbuff
&& pool
->dma_addr
) {
324 for (i
= 0; i
< pool
->size
; ++i
) {
325 struct sk_buff
*skb
= pool
->skbuff
[i
];
327 dma_unmap_single(&adapter
->vdev
->dev
,
331 dev_kfree_skb_any(skb
);
332 pool
->skbuff
[i
] = NULL
;
337 if (pool
->dma_addr
) {
338 kfree(pool
->dma_addr
);
339 pool
->dma_addr
= NULL
;
348 /* remove a buffer from a pool */
349 static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter
*adapter
,
352 unsigned int pool
= correlator
>> 32;
353 unsigned int index
= correlator
& 0xffffffffUL
;
354 unsigned int free_index
;
357 BUG_ON(pool
>= IBMVETH_NUM_BUFF_POOLS
);
358 BUG_ON(index
>= adapter
->rx_buff_pool
[pool
].size
);
360 skb
= adapter
->rx_buff_pool
[pool
].skbuff
[index
];
364 adapter
->rx_buff_pool
[pool
].skbuff
[index
] = NULL
;
366 dma_unmap_single(&adapter
->vdev
->dev
,
367 adapter
->rx_buff_pool
[pool
].dma_addr
[index
],
368 adapter
->rx_buff_pool
[pool
].buff_size
,
371 free_index
= adapter
->rx_buff_pool
[pool
].producer_index
;
372 adapter
->rx_buff_pool
[pool
].producer_index
++;
373 if (adapter
->rx_buff_pool
[pool
].producer_index
>=
374 adapter
->rx_buff_pool
[pool
].size
)
375 adapter
->rx_buff_pool
[pool
].producer_index
= 0;
376 adapter
->rx_buff_pool
[pool
].free_map
[free_index
] = index
;
380 atomic_dec(&(adapter
->rx_buff_pool
[pool
].available
));
383 /* get the current buffer on the rx queue */
384 static inline struct sk_buff
*ibmveth_rxq_get_buffer(struct ibmveth_adapter
*adapter
)
386 u64 correlator
= adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].correlator
;
387 unsigned int pool
= correlator
>> 32;
388 unsigned int index
= correlator
& 0xffffffffUL
;
390 BUG_ON(pool
>= IBMVETH_NUM_BUFF_POOLS
);
391 BUG_ON(index
>= adapter
->rx_buff_pool
[pool
].size
);
393 return adapter
->rx_buff_pool
[pool
].skbuff
[index
];
396 /* recycle the current buffer on the rx queue */
397 static int ibmveth_rxq_recycle_buffer(struct ibmveth_adapter
*adapter
)
399 u32 q_index
= adapter
->rx_queue
.index
;
400 u64 correlator
= adapter
->rx_queue
.queue_addr
[q_index
].correlator
;
401 unsigned int pool
= correlator
>> 32;
402 unsigned int index
= correlator
& 0xffffffffUL
;
403 union ibmveth_buf_desc desc
;
404 unsigned long lpar_rc
;
407 BUG_ON(pool
>= IBMVETH_NUM_BUFF_POOLS
);
408 BUG_ON(index
>= adapter
->rx_buff_pool
[pool
].size
);
410 if (!adapter
->rx_buff_pool
[pool
].active
) {
411 ibmveth_rxq_harvest_buffer(adapter
);
412 ibmveth_free_buffer_pool(adapter
, &adapter
->rx_buff_pool
[pool
]);
416 desc
.fields
.flags_len
= IBMVETH_BUF_VALID
|
417 adapter
->rx_buff_pool
[pool
].buff_size
;
418 desc
.fields
.address
= adapter
->rx_buff_pool
[pool
].dma_addr
[index
];
420 lpar_rc
= h_add_logical_lan_buffer(adapter
->vdev
->unit_address
, desc
.desc
);
422 if (lpar_rc
!= H_SUCCESS
) {
423 netdev_dbg(adapter
->netdev
, "h_add_logical_lan_buffer failed "
424 "during recycle rc=%ld", lpar_rc
);
425 ibmveth_remove_buffer_from_pool(adapter
, adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].correlator
);
429 if (++adapter
->rx_queue
.index
== adapter
->rx_queue
.num_slots
) {
430 adapter
->rx_queue
.index
= 0;
431 adapter
->rx_queue
.toggle
= !adapter
->rx_queue
.toggle
;
438 static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter
*adapter
)
440 ibmveth_remove_buffer_from_pool(adapter
, adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].correlator
);
442 if (++adapter
->rx_queue
.index
== adapter
->rx_queue
.num_slots
) {
443 adapter
->rx_queue
.index
= 0;
444 adapter
->rx_queue
.toggle
= !adapter
->rx_queue
.toggle
;
448 static void ibmveth_cleanup(struct ibmveth_adapter
*adapter
)
451 struct device
*dev
= &adapter
->vdev
->dev
;
453 if (adapter
->buffer_list_addr
!= NULL
) {
454 if (!dma_mapping_error(dev
, adapter
->buffer_list_dma
)) {
455 dma_unmap_single(dev
, adapter
->buffer_list_dma
, 4096,
457 adapter
->buffer_list_dma
= DMA_ERROR_CODE
;
459 free_page((unsigned long)adapter
->buffer_list_addr
);
460 adapter
->buffer_list_addr
= NULL
;
463 if (adapter
->filter_list_addr
!= NULL
) {
464 if (!dma_mapping_error(dev
, adapter
->filter_list_dma
)) {
465 dma_unmap_single(dev
, adapter
->filter_list_dma
, 4096,
467 adapter
->filter_list_dma
= DMA_ERROR_CODE
;
469 free_page((unsigned long)adapter
->filter_list_addr
);
470 adapter
->filter_list_addr
= NULL
;
473 if (adapter
->rx_queue
.queue_addr
!= NULL
) {
474 dma_free_coherent(dev
, adapter
->rx_queue
.queue_len
,
475 adapter
->rx_queue
.queue_addr
,
476 adapter
->rx_queue
.queue_dma
);
477 adapter
->rx_queue
.queue_addr
= NULL
;
480 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++)
481 if (adapter
->rx_buff_pool
[i
].active
)
482 ibmveth_free_buffer_pool(adapter
,
483 &adapter
->rx_buff_pool
[i
]);
485 if (adapter
->bounce_buffer
!= NULL
) {
486 if (!dma_mapping_error(dev
, adapter
->bounce_buffer_dma
)) {
487 dma_unmap_single(&adapter
->vdev
->dev
,
488 adapter
->bounce_buffer_dma
,
489 adapter
->netdev
->mtu
+ IBMVETH_BUFF_OH
,
491 adapter
->bounce_buffer_dma
= DMA_ERROR_CODE
;
493 kfree(adapter
->bounce_buffer
);
494 adapter
->bounce_buffer
= NULL
;
498 static int ibmveth_register_logical_lan(struct ibmveth_adapter
*adapter
,
499 union ibmveth_buf_desc rxq_desc
, u64 mac_address
)
501 int rc
, try_again
= 1;
504 * After a kexec the adapter will still be open, so our attempt to
505 * open it will fail. So if we get a failure we free the adapter and
506 * try again, but only once.
509 rc
= h_register_logical_lan(adapter
->vdev
->unit_address
,
510 adapter
->buffer_list_dma
, rxq_desc
.desc
,
511 adapter
->filter_list_dma
, mac_address
);
513 if (rc
!= H_SUCCESS
&& try_again
) {
515 rc
= h_free_logical_lan(adapter
->vdev
->unit_address
);
516 } while (H_IS_LONG_BUSY(rc
) || (rc
== H_BUSY
));
525 static u64
ibmveth_encode_mac_addr(u8
*mac
)
530 for (i
= 0; i
< ETH_ALEN
; i
++)
531 encoded
= (encoded
<< 8) | mac
[i
];
536 static int ibmveth_open(struct net_device
*netdev
)
538 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
541 unsigned long lpar_rc
;
543 union ibmveth_buf_desc rxq_desc
;
547 netdev_dbg(netdev
, "open starting\n");
549 napi_enable(&adapter
->napi
);
551 for(i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++)
552 rxq_entries
+= adapter
->rx_buff_pool
[i
].size
;
554 adapter
->buffer_list_addr
= (void*) get_zeroed_page(GFP_KERNEL
);
555 adapter
->filter_list_addr
= (void*) get_zeroed_page(GFP_KERNEL
);
557 if (!adapter
->buffer_list_addr
|| !adapter
->filter_list_addr
) {
558 netdev_err(netdev
, "unable to allocate filter or buffer list "
564 dev
= &adapter
->vdev
->dev
;
566 adapter
->rx_queue
.queue_len
= sizeof(struct ibmveth_rx_q_entry
) *
568 adapter
->rx_queue
.queue_addr
=
569 dma_alloc_coherent(dev
, adapter
->rx_queue
.queue_len
,
570 &adapter
->rx_queue
.queue_dma
, GFP_KERNEL
);
571 if (!adapter
->rx_queue
.queue_addr
) {
576 adapter
->buffer_list_dma
= dma_map_single(dev
,
577 adapter
->buffer_list_addr
, 4096, DMA_BIDIRECTIONAL
);
578 adapter
->filter_list_dma
= dma_map_single(dev
,
579 adapter
->filter_list_addr
, 4096, DMA_BIDIRECTIONAL
);
581 if ((dma_mapping_error(dev
, adapter
->buffer_list_dma
)) ||
582 (dma_mapping_error(dev
, adapter
->filter_list_dma
))) {
583 netdev_err(netdev
, "unable to map filter or buffer list "
589 adapter
->rx_queue
.index
= 0;
590 adapter
->rx_queue
.num_slots
= rxq_entries
;
591 adapter
->rx_queue
.toggle
= 1;
593 mac_address
= ibmveth_encode_mac_addr(netdev
->dev_addr
);
595 rxq_desc
.fields
.flags_len
= IBMVETH_BUF_VALID
|
596 adapter
->rx_queue
.queue_len
;
597 rxq_desc
.fields
.address
= adapter
->rx_queue
.queue_dma
;
599 netdev_dbg(netdev
, "buffer list @ 0x%p\n", adapter
->buffer_list_addr
);
600 netdev_dbg(netdev
, "filter list @ 0x%p\n", adapter
->filter_list_addr
);
601 netdev_dbg(netdev
, "receive q @ 0x%p\n", adapter
->rx_queue
.queue_addr
);
603 h_vio_signal(adapter
->vdev
->unit_address
, VIO_IRQ_DISABLE
);
605 lpar_rc
= ibmveth_register_logical_lan(adapter
, rxq_desc
, mac_address
);
607 if (lpar_rc
!= H_SUCCESS
) {
608 netdev_err(netdev
, "h_register_logical_lan failed with %ld\n",
610 netdev_err(netdev
, "buffer TCE:0x%llx filter TCE:0x%llx rxq "
611 "desc:0x%llx MAC:0x%llx\n",
612 adapter
->buffer_list_dma
,
613 adapter
->filter_list_dma
,
620 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
621 if (!adapter
->rx_buff_pool
[i
].active
)
623 if (ibmveth_alloc_buffer_pool(&adapter
->rx_buff_pool
[i
])) {
624 netdev_err(netdev
, "unable to alloc pool\n");
625 adapter
->rx_buff_pool
[i
].active
= 0;
631 netdev_dbg(netdev
, "registering irq 0x%x\n", netdev
->irq
);
632 rc
= request_irq(netdev
->irq
, ibmveth_interrupt
, 0, netdev
->name
,
635 netdev_err(netdev
, "unable to request irq 0x%x, rc %d\n",
638 lpar_rc
= h_free_logical_lan(adapter
->vdev
->unit_address
);
639 } while (H_IS_LONG_BUSY(lpar_rc
) || (lpar_rc
== H_BUSY
));
644 adapter
->bounce_buffer
=
645 kmalloc(netdev
->mtu
+ IBMVETH_BUFF_OH
, GFP_KERNEL
);
646 if (!adapter
->bounce_buffer
) {
648 goto err_out_free_irq
;
650 adapter
->bounce_buffer_dma
=
651 dma_map_single(&adapter
->vdev
->dev
, adapter
->bounce_buffer
,
652 netdev
->mtu
+ IBMVETH_BUFF_OH
, DMA_BIDIRECTIONAL
);
653 if (dma_mapping_error(dev
, adapter
->bounce_buffer_dma
)) {
654 netdev_err(netdev
, "unable to map bounce buffer\n");
656 goto err_out_free_irq
;
659 netdev_dbg(netdev
, "initial replenish cycle\n");
660 ibmveth_interrupt(netdev
->irq
, netdev
);
662 netif_start_queue(netdev
);
664 netdev_dbg(netdev
, "open complete\n");
669 free_irq(netdev
->irq
, netdev
);
671 ibmveth_cleanup(adapter
);
672 napi_disable(&adapter
->napi
);
676 static int ibmveth_close(struct net_device
*netdev
)
678 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
681 netdev_dbg(netdev
, "close starting\n");
683 napi_disable(&adapter
->napi
);
685 if (!adapter
->pool_config
)
686 netif_stop_queue(netdev
);
688 h_vio_signal(adapter
->vdev
->unit_address
, VIO_IRQ_DISABLE
);
691 lpar_rc
= h_free_logical_lan(adapter
->vdev
->unit_address
);
692 } while (H_IS_LONG_BUSY(lpar_rc
) || (lpar_rc
== H_BUSY
));
694 if (lpar_rc
!= H_SUCCESS
) {
695 netdev_err(netdev
, "h_free_logical_lan failed with %lx, "
696 "continuing with close\n", lpar_rc
);
699 free_irq(netdev
->irq
, netdev
);
701 adapter
->rx_no_buffer
= *(u64
*)(((char *)adapter
->buffer_list_addr
) +
704 ibmveth_cleanup(adapter
);
706 netdev_dbg(netdev
, "close complete\n");
711 static int netdev_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
713 cmd
->supported
= (SUPPORTED_1000baseT_Full
| SUPPORTED_Autoneg
|
715 cmd
->advertising
= (ADVERTISED_1000baseT_Full
| ADVERTISED_Autoneg
|
717 ethtool_cmd_speed_set(cmd
, SPEED_1000
);
718 cmd
->duplex
= DUPLEX_FULL
;
719 cmd
->port
= PORT_FIBRE
;
720 cmd
->phy_address
= 0;
721 cmd
->transceiver
= XCVR_INTERNAL
;
722 cmd
->autoneg
= AUTONEG_ENABLE
;
728 static void netdev_get_drvinfo(struct net_device
*dev
,
729 struct ethtool_drvinfo
*info
)
731 strlcpy(info
->driver
, ibmveth_driver_name
, sizeof(info
->driver
));
732 strlcpy(info
->version
, ibmveth_driver_version
, sizeof(info
->version
));
735 static netdev_features_t
ibmveth_fix_features(struct net_device
*dev
,
736 netdev_features_t features
)
739 * Since the ibmveth firmware interface does not have the
740 * concept of separate tx/rx checksum offload enable, if rx
741 * checksum is disabled we also have to disable tx checksum
742 * offload. Once we disable rx checksum offload, we are no
743 * longer allowed to send tx buffers that are not properly
747 if (!(features
& NETIF_F_RXCSUM
))
748 features
&= ~NETIF_F_ALL_CSUM
;
753 static int ibmveth_set_csum_offload(struct net_device
*dev
, u32 data
)
755 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
756 unsigned long set_attr
, clr_attr
, ret_attr
;
757 unsigned long set_attr6
, clr_attr6
;
758 long ret
, ret4
, ret6
;
759 int rc1
= 0, rc2
= 0;
762 if (netif_running(dev
)) {
764 adapter
->pool_config
= 1;
766 adapter
->pool_config
= 0;
775 set_attr
= IBMVETH_ILLAN_IPV4_TCP_CSUM
;
776 set_attr6
= IBMVETH_ILLAN_IPV6_TCP_CSUM
;
778 clr_attr
= IBMVETH_ILLAN_IPV4_TCP_CSUM
;
779 clr_attr6
= IBMVETH_ILLAN_IPV6_TCP_CSUM
;
782 ret
= h_illan_attributes(adapter
->vdev
->unit_address
, 0, 0, &ret_attr
);
784 if (ret
== H_SUCCESS
&& !(ret_attr
& IBMVETH_ILLAN_ACTIVE_TRUNK
) &&
785 !(ret_attr
& IBMVETH_ILLAN_TRUNK_PRI_MASK
) &&
786 (ret_attr
& IBMVETH_ILLAN_PADDED_PKT_CSUM
)) {
787 ret4
= h_illan_attributes(adapter
->vdev
->unit_address
, clr_attr
,
788 set_attr
, &ret_attr
);
790 if (ret4
!= H_SUCCESS
) {
791 netdev_err(dev
, "unable to change IPv4 checksum "
792 "offload settings. %d rc=%ld\n",
795 h_illan_attributes(adapter
->vdev
->unit_address
,
796 set_attr
, clr_attr
, &ret_attr
);
799 dev
->features
&= ~NETIF_F_IP_CSUM
;
802 adapter
->fw_ipv4_csum_support
= data
;
805 ret6
= h_illan_attributes(adapter
->vdev
->unit_address
,
806 clr_attr6
, set_attr6
, &ret_attr
);
808 if (ret6
!= H_SUCCESS
) {
809 netdev_err(dev
, "unable to change IPv6 checksum "
810 "offload settings. %d rc=%ld\n",
813 h_illan_attributes(adapter
->vdev
->unit_address
,
814 set_attr6
, clr_attr6
, &ret_attr
);
817 dev
->features
&= ~NETIF_F_IPV6_CSUM
;
820 adapter
->fw_ipv6_csum_support
= data
;
822 if (ret4
== H_SUCCESS
|| ret6
== H_SUCCESS
)
823 adapter
->rx_csum
= data
;
828 netdev_err(dev
, "unable to change checksum offload settings."
829 " %d rc=%ld ret_attr=%lx\n", data
, ret
,
834 rc2
= ibmveth_open(dev
);
836 return rc1
? rc1
: rc2
;
839 static int ibmveth_set_features(struct net_device
*dev
,
840 netdev_features_t features
)
842 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
843 int rx_csum
= !!(features
& NETIF_F_RXCSUM
);
846 if (rx_csum
== adapter
->rx_csum
)
849 rc
= ibmveth_set_csum_offload(dev
, rx_csum
);
850 if (rc
&& !adapter
->rx_csum
)
851 dev
->features
= features
& ~(NETIF_F_ALL_CSUM
| NETIF_F_RXCSUM
);
856 static void ibmveth_get_strings(struct net_device
*dev
, u32 stringset
, u8
*data
)
860 if (stringset
!= ETH_SS_STATS
)
863 for (i
= 0; i
< ARRAY_SIZE(ibmveth_stats
); i
++, data
+= ETH_GSTRING_LEN
)
864 memcpy(data
, ibmveth_stats
[i
].name
, ETH_GSTRING_LEN
);
867 static int ibmveth_get_sset_count(struct net_device
*dev
, int sset
)
871 return ARRAY_SIZE(ibmveth_stats
);
877 static void ibmveth_get_ethtool_stats(struct net_device
*dev
,
878 struct ethtool_stats
*stats
, u64
*data
)
881 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
883 for (i
= 0; i
< ARRAY_SIZE(ibmveth_stats
); i
++)
884 data
[i
] = IBMVETH_GET_STAT(adapter
, ibmveth_stats
[i
].offset
);
887 static const struct ethtool_ops netdev_ethtool_ops
= {
888 .get_drvinfo
= netdev_get_drvinfo
,
889 .get_settings
= netdev_get_settings
,
890 .get_link
= ethtool_op_get_link
,
891 .get_strings
= ibmveth_get_strings
,
892 .get_sset_count
= ibmveth_get_sset_count
,
893 .get_ethtool_stats
= ibmveth_get_ethtool_stats
,
896 static int ibmveth_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
901 #define page_offset(v) ((unsigned long)(v) & ((1 << 12) - 1))
903 static int ibmveth_send(struct ibmveth_adapter
*adapter
,
904 union ibmveth_buf_desc
*descs
)
906 unsigned long correlator
;
907 unsigned int retry_count
;
911 * The retry count sets a maximum for the number of broadcast and
912 * multicast destinations within the system.
917 ret
= h_send_logical_lan(adapter
->vdev
->unit_address
,
918 descs
[0].desc
, descs
[1].desc
,
919 descs
[2].desc
, descs
[3].desc
,
920 descs
[4].desc
, descs
[5].desc
,
921 correlator
, &correlator
);
922 } while ((ret
== H_BUSY
) && (retry_count
--));
924 if (ret
!= H_SUCCESS
&& ret
!= H_DROPPED
) {
925 netdev_err(adapter
->netdev
, "tx: h_send_logical_lan failed "
926 "with rc=%ld\n", ret
);
933 static netdev_tx_t
ibmveth_start_xmit(struct sk_buff
*skb
,
934 struct net_device
*netdev
)
936 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
937 unsigned int desc_flags
;
938 union ibmveth_buf_desc descs
[6];
940 int force_bounce
= 0;
944 * veth handles a maximum of 6 segments including the header, so
945 * we have to linearize the skb if there are more than this.
947 if (skb_shinfo(skb
)->nr_frags
> 5 && __skb_linearize(skb
)) {
948 netdev
->stats
.tx_dropped
++;
952 /* veth can't checksum offload UDP */
953 if (skb
->ip_summed
== CHECKSUM_PARTIAL
&&
954 ((skb
->protocol
== htons(ETH_P_IP
) &&
955 ip_hdr(skb
)->protocol
!= IPPROTO_TCP
) ||
956 (skb
->protocol
== htons(ETH_P_IPV6
) &&
957 ipv6_hdr(skb
)->nexthdr
!= IPPROTO_TCP
)) &&
958 skb_checksum_help(skb
)) {
960 netdev_err(netdev
, "tx: failed to checksum packet\n");
961 netdev
->stats
.tx_dropped
++;
965 desc_flags
= IBMVETH_BUF_VALID
;
967 if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
968 unsigned char *buf
= skb_transport_header(skb
) +
971 desc_flags
|= (IBMVETH_BUF_NO_CSUM
| IBMVETH_BUF_CSUM_GOOD
);
973 /* Need to zero out the checksum */
979 memset(descs
, 0, sizeof(descs
));
982 * If a linear packet is below the rx threshold then
983 * copy it into the static bounce buffer. This avoids the
984 * cost of a TCE insert and remove.
986 if (force_bounce
|| (!skb_is_nonlinear(skb
) &&
987 (skb
->len
< tx_copybreak
))) {
988 skb_copy_from_linear_data(skb
, adapter
->bounce_buffer
,
991 descs
[0].fields
.flags_len
= desc_flags
| skb
->len
;
992 descs
[0].fields
.address
= adapter
->bounce_buffer_dma
;
994 if (ibmveth_send(adapter
, descs
)) {
995 adapter
->tx_send_failed
++;
996 netdev
->stats
.tx_dropped
++;
998 netdev
->stats
.tx_packets
++;
999 netdev
->stats
.tx_bytes
+= skb
->len
;
1005 /* Map the header */
1006 dma_addr
= dma_map_single(&adapter
->vdev
->dev
, skb
->data
,
1007 skb_headlen(skb
), DMA_TO_DEVICE
);
1008 if (dma_mapping_error(&adapter
->vdev
->dev
, dma_addr
))
1011 descs
[0].fields
.flags_len
= desc_flags
| skb_headlen(skb
);
1012 descs
[0].fields
.address
= dma_addr
;
1015 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
1016 const skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
];
1018 dma_addr
= skb_frag_dma_map(&adapter
->vdev
->dev
, frag
, 0,
1019 skb_frag_size(frag
), DMA_TO_DEVICE
);
1021 if (dma_mapping_error(&adapter
->vdev
->dev
, dma_addr
))
1022 goto map_failed_frags
;
1024 descs
[i
+1].fields
.flags_len
= desc_flags
| skb_frag_size(frag
);
1025 descs
[i
+1].fields
.address
= dma_addr
;
1028 if (ibmveth_send(adapter
, descs
)) {
1029 adapter
->tx_send_failed
++;
1030 netdev
->stats
.tx_dropped
++;
1032 netdev
->stats
.tx_packets
++;
1033 netdev
->stats
.tx_bytes
+= skb
->len
;
1036 dma_unmap_single(&adapter
->vdev
->dev
,
1037 descs
[0].fields
.address
,
1038 descs
[0].fields
.flags_len
& IBMVETH_BUF_LEN_MASK
,
1041 for (i
= 1; i
< skb_shinfo(skb
)->nr_frags
+ 1; i
++)
1042 dma_unmap_page(&adapter
->vdev
->dev
, descs
[i
].fields
.address
,
1043 descs
[i
].fields
.flags_len
& IBMVETH_BUF_LEN_MASK
,
1048 return NETDEV_TX_OK
;
1052 for (i
= 0; i
< last
; i
++)
1053 dma_unmap_page(&adapter
->vdev
->dev
, descs
[i
].fields
.address
,
1054 descs
[i
].fields
.flags_len
& IBMVETH_BUF_LEN_MASK
,
1058 if (!firmware_has_feature(FW_FEATURE_CMO
))
1059 netdev_err(netdev
, "tx: unable to map xmit buffer\n");
1060 adapter
->tx_map_failed
++;
1066 static int ibmveth_poll(struct napi_struct
*napi
, int budget
)
1068 struct ibmveth_adapter
*adapter
=
1069 container_of(napi
, struct ibmveth_adapter
, napi
);
1070 struct net_device
*netdev
= adapter
->netdev
;
1071 int frames_processed
= 0;
1072 unsigned long lpar_rc
;
1076 if (!ibmveth_rxq_pending_buffer(adapter
))
1080 if (!ibmveth_rxq_buffer_valid(adapter
)) {
1081 wmb(); /* suggested by larson1 */
1082 adapter
->rx_invalid_buffer
++;
1083 netdev_dbg(netdev
, "recycling invalid buffer\n");
1084 ibmveth_rxq_recycle_buffer(adapter
);
1086 struct sk_buff
*skb
, *new_skb
;
1087 int length
= ibmveth_rxq_frame_length(adapter
);
1088 int offset
= ibmveth_rxq_frame_offset(adapter
);
1089 int csum_good
= ibmveth_rxq_csum_good(adapter
);
1091 skb
= ibmveth_rxq_get_buffer(adapter
);
1094 if (length
< rx_copybreak
)
1095 new_skb
= netdev_alloc_skb(netdev
, length
);
1098 skb_copy_to_linear_data(new_skb
,
1102 ibmveth_flush_buffer(skb
->data
,
1104 if (!ibmveth_rxq_recycle_buffer(adapter
))
1108 ibmveth_rxq_harvest_buffer(adapter
);
1109 skb_reserve(skb
, offset
);
1112 skb_put(skb
, length
);
1113 skb
->protocol
= eth_type_trans(skb
, netdev
);
1116 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1118 netif_receive_skb(skb
); /* send it up */
1120 netdev
->stats
.rx_packets
++;
1121 netdev
->stats
.rx_bytes
+= length
;
1124 } while (frames_processed
< budget
);
1126 ibmveth_replenish_task(adapter
);
1128 if (frames_processed
< budget
) {
1129 /* We think we are done - reenable interrupts,
1130 * then check once more to make sure we are done.
1132 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
,
1135 BUG_ON(lpar_rc
!= H_SUCCESS
);
1137 napi_complete(napi
);
1139 if (ibmveth_rxq_pending_buffer(adapter
) &&
1140 napi_reschedule(napi
)) {
1141 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
,
1147 return frames_processed
;
1150 static irqreturn_t
ibmveth_interrupt(int irq
, void *dev_instance
)
1152 struct net_device
*netdev
= dev_instance
;
1153 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
1154 unsigned long lpar_rc
;
1156 if (napi_schedule_prep(&adapter
->napi
)) {
1157 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
,
1159 BUG_ON(lpar_rc
!= H_SUCCESS
);
1160 __napi_schedule(&adapter
->napi
);
1165 static void ibmveth_set_multicast_list(struct net_device
*netdev
)
1167 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
1168 unsigned long lpar_rc
;
1170 if ((netdev
->flags
& IFF_PROMISC
) ||
1171 (netdev_mc_count(netdev
) > adapter
->mcastFilterSize
)) {
1172 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1173 IbmVethMcastEnableRecv
|
1174 IbmVethMcastDisableFiltering
,
1176 if (lpar_rc
!= H_SUCCESS
) {
1177 netdev_err(netdev
, "h_multicast_ctrl rc=%ld when "
1178 "entering promisc mode\n", lpar_rc
);
1181 struct netdev_hw_addr
*ha
;
1182 /* clear the filter table & disable filtering */
1183 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1184 IbmVethMcastEnableRecv
|
1185 IbmVethMcastDisableFiltering
|
1186 IbmVethMcastClearFilterTable
,
1188 if (lpar_rc
!= H_SUCCESS
) {
1189 netdev_err(netdev
, "h_multicast_ctrl rc=%ld when "
1190 "attempting to clear filter table\n",
1193 /* add the addresses to the filter table */
1194 netdev_for_each_mc_addr(ha
, netdev
) {
1195 /* add the multicast address to the filter table */
1197 mcast_addr
= ibmveth_encode_mac_addr(ha
->addr
);
1198 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1199 IbmVethMcastAddFilter
,
1201 if (lpar_rc
!= H_SUCCESS
) {
1202 netdev_err(netdev
, "h_multicast_ctrl rc=%ld "
1203 "when adding an entry to the filter "
1204 "table\n", lpar_rc
);
1208 /* re-enable filtering */
1209 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1210 IbmVethMcastEnableFiltering
,
1212 if (lpar_rc
!= H_SUCCESS
) {
1213 netdev_err(netdev
, "h_multicast_ctrl rc=%ld when "
1214 "enabling filtering\n", lpar_rc
);
1219 static int ibmveth_change_mtu(struct net_device
*dev
, int new_mtu
)
1221 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
1222 struct vio_dev
*viodev
= adapter
->vdev
;
1223 int new_mtu_oh
= new_mtu
+ IBMVETH_BUFF_OH
;
1225 int need_restart
= 0;
1227 if (new_mtu
< IBMVETH_MIN_MTU
)
1230 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++)
1231 if (new_mtu_oh
< adapter
->rx_buff_pool
[i
].buff_size
)
1234 if (i
== IBMVETH_NUM_BUFF_POOLS
)
1237 /* Deactivate all the buffer pools so that the next loop can activate
1238 only the buffer pools necessary to hold the new MTU */
1239 if (netif_running(adapter
->netdev
)) {
1241 adapter
->pool_config
= 1;
1242 ibmveth_close(adapter
->netdev
);
1243 adapter
->pool_config
= 0;
1246 /* Look for an active buffer pool that can hold the new MTU */
1247 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
1248 adapter
->rx_buff_pool
[i
].active
= 1;
1250 if (new_mtu_oh
< adapter
->rx_buff_pool
[i
].buff_size
) {
1252 vio_cmo_set_dev_desired(viodev
,
1253 ibmveth_get_desired_dma
1256 return ibmveth_open(adapter
->netdev
);
1262 if (need_restart
&& (rc
= ibmveth_open(adapter
->netdev
)))
1268 #ifdef CONFIG_NET_POLL_CONTROLLER
1269 static void ibmveth_poll_controller(struct net_device
*dev
)
1271 ibmveth_replenish_task(netdev_priv(dev
));
1272 ibmveth_interrupt(dev
->irq
, dev
);
1277 * ibmveth_get_desired_dma - Calculate IO memory desired by the driver
1279 * @vdev: struct vio_dev for the device whose desired IO mem is to be returned
1282 * Number of bytes of IO data the driver will need to perform well.
1284 static unsigned long ibmveth_get_desired_dma(struct vio_dev
*vdev
)
1286 struct net_device
*netdev
= dev_get_drvdata(&vdev
->dev
);
1287 struct ibmveth_adapter
*adapter
;
1288 struct iommu_table
*tbl
;
1293 tbl
= get_iommu_table_base(&vdev
->dev
);
1295 /* netdev inits at probe time along with the structures we need below*/
1297 return IOMMU_PAGE_ALIGN(IBMVETH_IO_ENTITLEMENT_DEFAULT
, tbl
);
1299 adapter
= netdev_priv(netdev
);
1301 ret
= IBMVETH_BUFF_LIST_SIZE
+ IBMVETH_FILT_LIST_SIZE
;
1302 ret
+= IOMMU_PAGE_ALIGN(netdev
->mtu
, tbl
);
1304 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
1305 /* add the size of the active receive buffers */
1306 if (adapter
->rx_buff_pool
[i
].active
)
1308 adapter
->rx_buff_pool
[i
].size
*
1309 IOMMU_PAGE_ALIGN(adapter
->rx_buff_pool
[i
].
1311 rxqentries
+= adapter
->rx_buff_pool
[i
].size
;
1313 /* add the size of the receive queue entries */
1314 ret
+= IOMMU_PAGE_ALIGN(
1315 rxqentries
* sizeof(struct ibmveth_rx_q_entry
), tbl
);
1320 static const struct net_device_ops ibmveth_netdev_ops
= {
1321 .ndo_open
= ibmveth_open
,
1322 .ndo_stop
= ibmveth_close
,
1323 .ndo_start_xmit
= ibmveth_start_xmit
,
1324 .ndo_set_rx_mode
= ibmveth_set_multicast_list
,
1325 .ndo_do_ioctl
= ibmveth_ioctl
,
1326 .ndo_change_mtu
= ibmveth_change_mtu
,
1327 .ndo_fix_features
= ibmveth_fix_features
,
1328 .ndo_set_features
= ibmveth_set_features
,
1329 .ndo_validate_addr
= eth_validate_addr
,
1330 .ndo_set_mac_address
= eth_mac_addr
,
1331 #ifdef CONFIG_NET_POLL_CONTROLLER
1332 .ndo_poll_controller
= ibmveth_poll_controller
,
1336 static int ibmveth_probe(struct vio_dev
*dev
, const struct vio_device_id
*id
)
1339 struct net_device
*netdev
;
1340 struct ibmveth_adapter
*adapter
;
1341 unsigned char *mac_addr_p
;
1342 unsigned int *mcastFilterSize_p
;
1344 dev_dbg(&dev
->dev
, "entering ibmveth_probe for UA 0x%x\n",
1347 mac_addr_p
= (unsigned char *)vio_get_attribute(dev
, VETH_MAC_ADDR
,
1350 dev_err(&dev
->dev
, "Can't find VETH_MAC_ADDR attribute\n");
1353 /* Workaround for old/broken pHyp */
1356 else if (mac_len
!= 6) {
1357 dev_err(&dev
->dev
, "VETH_MAC_ADDR attribute wrong len %d\n",
1362 mcastFilterSize_p
= (unsigned int *)vio_get_attribute(dev
,
1363 VETH_MCAST_FILTER_SIZE
, NULL
);
1364 if (!mcastFilterSize_p
) {
1365 dev_err(&dev
->dev
, "Can't find VETH_MCAST_FILTER_SIZE "
1370 netdev
= alloc_etherdev(sizeof(struct ibmveth_adapter
));
1375 adapter
= netdev_priv(netdev
);
1376 dev_set_drvdata(&dev
->dev
, netdev
);
1378 adapter
->vdev
= dev
;
1379 adapter
->netdev
= netdev
;
1380 adapter
->mcastFilterSize
= *mcastFilterSize_p
;
1381 adapter
->pool_config
= 0;
1383 netif_napi_add(netdev
, &adapter
->napi
, ibmveth_poll
, 16);
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
, mac_addr_p
, ETH_ALEN
);
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
);