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>
39 #include <linux/ethtool.h>
42 #include <linux/ipv6.h>
43 #include <linux/slab.h>
44 #include <asm/hvcall.h>
45 #include <asm/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 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 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 void 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
;
406 BUG_ON(pool
>= IBMVETH_NUM_BUFF_POOLS
);
407 BUG_ON(index
>= adapter
->rx_buff_pool
[pool
].size
);
409 if (!adapter
->rx_buff_pool
[pool
].active
) {
410 ibmveth_rxq_harvest_buffer(adapter
);
411 ibmveth_free_buffer_pool(adapter
, &adapter
->rx_buff_pool
[pool
]);
415 desc
.fields
.flags_len
= IBMVETH_BUF_VALID
|
416 adapter
->rx_buff_pool
[pool
].buff_size
;
417 desc
.fields
.address
= adapter
->rx_buff_pool
[pool
].dma_addr
[index
];
419 lpar_rc
= h_add_logical_lan_buffer(adapter
->vdev
->unit_address
, desc
.desc
);
421 if (lpar_rc
!= H_SUCCESS
) {
422 netdev_dbg(adapter
->netdev
, "h_add_logical_lan_buffer failed "
423 "during recycle rc=%ld", lpar_rc
);
424 ibmveth_remove_buffer_from_pool(adapter
, adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].correlator
);
427 if (++adapter
->rx_queue
.index
== adapter
->rx_queue
.num_slots
) {
428 adapter
->rx_queue
.index
= 0;
429 adapter
->rx_queue
.toggle
= !adapter
->rx_queue
.toggle
;
433 static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter
*adapter
)
435 ibmveth_remove_buffer_from_pool(adapter
, adapter
->rx_queue
.queue_addr
[adapter
->rx_queue
.index
].correlator
);
437 if (++adapter
->rx_queue
.index
== adapter
->rx_queue
.num_slots
) {
438 adapter
->rx_queue
.index
= 0;
439 adapter
->rx_queue
.toggle
= !adapter
->rx_queue
.toggle
;
443 static void ibmveth_cleanup(struct ibmveth_adapter
*adapter
)
446 struct device
*dev
= &adapter
->vdev
->dev
;
448 if (adapter
->buffer_list_addr
!= NULL
) {
449 if (!dma_mapping_error(dev
, adapter
->buffer_list_dma
)) {
450 dma_unmap_single(dev
, adapter
->buffer_list_dma
, 4096,
452 adapter
->buffer_list_dma
= DMA_ERROR_CODE
;
454 free_page((unsigned long)adapter
->buffer_list_addr
);
455 adapter
->buffer_list_addr
= NULL
;
458 if (adapter
->filter_list_addr
!= NULL
) {
459 if (!dma_mapping_error(dev
, adapter
->filter_list_dma
)) {
460 dma_unmap_single(dev
, adapter
->filter_list_dma
, 4096,
462 adapter
->filter_list_dma
= DMA_ERROR_CODE
;
464 free_page((unsigned long)adapter
->filter_list_addr
);
465 adapter
->filter_list_addr
= NULL
;
468 if (adapter
->rx_queue
.queue_addr
!= NULL
) {
469 if (!dma_mapping_error(dev
, adapter
->rx_queue
.queue_dma
)) {
470 dma_unmap_single(dev
,
471 adapter
->rx_queue
.queue_dma
,
472 adapter
->rx_queue
.queue_len
,
474 adapter
->rx_queue
.queue_dma
= DMA_ERROR_CODE
;
476 kfree(adapter
->rx_queue
.queue_addr
);
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 int ibmveth_open(struct net_device
*netdev
)
527 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
530 unsigned long lpar_rc
;
532 union ibmveth_buf_desc rxq_desc
;
536 netdev_dbg(netdev
, "open starting\n");
538 napi_enable(&adapter
->napi
);
540 for(i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++)
541 rxq_entries
+= adapter
->rx_buff_pool
[i
].size
;
543 adapter
->buffer_list_addr
= (void*) get_zeroed_page(GFP_KERNEL
);
544 adapter
->filter_list_addr
= (void*) get_zeroed_page(GFP_KERNEL
);
546 if (!adapter
->buffer_list_addr
|| !adapter
->filter_list_addr
) {
547 netdev_err(netdev
, "unable to allocate filter or buffer list "
553 adapter
->rx_queue
.queue_len
= sizeof(struct ibmveth_rx_q_entry
) *
555 adapter
->rx_queue
.queue_addr
= kmalloc(adapter
->rx_queue
.queue_len
,
558 if (!adapter
->rx_queue
.queue_addr
) {
559 netdev_err(netdev
, "unable to allocate rx queue pages\n");
564 dev
= &adapter
->vdev
->dev
;
566 adapter
->buffer_list_dma
= dma_map_single(dev
,
567 adapter
->buffer_list_addr
, 4096, DMA_BIDIRECTIONAL
);
568 adapter
->filter_list_dma
= dma_map_single(dev
,
569 adapter
->filter_list_addr
, 4096, DMA_BIDIRECTIONAL
);
570 adapter
->rx_queue
.queue_dma
= dma_map_single(dev
,
571 adapter
->rx_queue
.queue_addr
,
572 adapter
->rx_queue
.queue_len
, DMA_BIDIRECTIONAL
);
574 if ((dma_mapping_error(dev
, adapter
->buffer_list_dma
)) ||
575 (dma_mapping_error(dev
, adapter
->filter_list_dma
)) ||
576 (dma_mapping_error(dev
, adapter
->rx_queue
.queue_dma
))) {
577 netdev_err(netdev
, "unable to map filter or buffer list "
583 adapter
->rx_queue
.index
= 0;
584 adapter
->rx_queue
.num_slots
= rxq_entries
;
585 adapter
->rx_queue
.toggle
= 1;
587 memcpy(&mac_address
, netdev
->dev_addr
, netdev
->addr_len
);
588 mac_address
= mac_address
>> 16;
590 rxq_desc
.fields
.flags_len
= IBMVETH_BUF_VALID
|
591 adapter
->rx_queue
.queue_len
;
592 rxq_desc
.fields
.address
= adapter
->rx_queue
.queue_dma
;
594 netdev_dbg(netdev
, "buffer list @ 0x%p\n", adapter
->buffer_list_addr
);
595 netdev_dbg(netdev
, "filter list @ 0x%p\n", adapter
->filter_list_addr
);
596 netdev_dbg(netdev
, "receive q @ 0x%p\n", adapter
->rx_queue
.queue_addr
);
598 h_vio_signal(adapter
->vdev
->unit_address
, VIO_IRQ_DISABLE
);
600 lpar_rc
= ibmveth_register_logical_lan(adapter
, rxq_desc
, mac_address
);
602 if (lpar_rc
!= H_SUCCESS
) {
603 netdev_err(netdev
, "h_register_logical_lan failed with %ld\n",
605 netdev_err(netdev
, "buffer TCE:0x%llx filter TCE:0x%llx rxq "
606 "desc:0x%llx MAC:0x%llx\n",
607 adapter
->buffer_list_dma
,
608 adapter
->filter_list_dma
,
615 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
616 if (!adapter
->rx_buff_pool
[i
].active
)
618 if (ibmveth_alloc_buffer_pool(&adapter
->rx_buff_pool
[i
])) {
619 netdev_err(netdev
, "unable to alloc pool\n");
620 adapter
->rx_buff_pool
[i
].active
= 0;
626 netdev_dbg(netdev
, "registering irq 0x%x\n", netdev
->irq
);
627 rc
= request_irq(netdev
->irq
, ibmveth_interrupt
, 0, netdev
->name
,
630 netdev_err(netdev
, "unable to request irq 0x%x, rc %d\n",
633 rc
= h_free_logical_lan(adapter
->vdev
->unit_address
);
634 } while (H_IS_LONG_BUSY(rc
) || (rc
== H_BUSY
));
639 adapter
->bounce_buffer
=
640 kmalloc(netdev
->mtu
+ IBMVETH_BUFF_OH
, GFP_KERNEL
);
641 if (!adapter
->bounce_buffer
) {
642 netdev_err(netdev
, "unable to allocate bounce buffer\n");
644 goto err_out_free_irq
;
646 adapter
->bounce_buffer_dma
=
647 dma_map_single(&adapter
->vdev
->dev
, adapter
->bounce_buffer
,
648 netdev
->mtu
+ IBMVETH_BUFF_OH
, DMA_BIDIRECTIONAL
);
649 if (dma_mapping_error(dev
, adapter
->bounce_buffer_dma
)) {
650 netdev_err(netdev
, "unable to map bounce buffer\n");
652 goto err_out_free_irq
;
655 netdev_dbg(netdev
, "initial replenish cycle\n");
656 ibmveth_interrupt(netdev
->irq
, netdev
);
658 netif_start_queue(netdev
);
660 netdev_dbg(netdev
, "open complete\n");
665 free_irq(netdev
->irq
, netdev
);
667 ibmveth_cleanup(adapter
);
668 napi_disable(&adapter
->napi
);
672 static int ibmveth_close(struct net_device
*netdev
)
674 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
677 netdev_dbg(netdev
, "close starting\n");
679 napi_disable(&adapter
->napi
);
681 if (!adapter
->pool_config
)
682 netif_stop_queue(netdev
);
684 h_vio_signal(adapter
->vdev
->unit_address
, VIO_IRQ_DISABLE
);
687 lpar_rc
= h_free_logical_lan(adapter
->vdev
->unit_address
);
688 } while (H_IS_LONG_BUSY(lpar_rc
) || (lpar_rc
== H_BUSY
));
690 if (lpar_rc
!= H_SUCCESS
) {
691 netdev_err(netdev
, "h_free_logical_lan failed with %lx, "
692 "continuing with close\n", lpar_rc
);
695 free_irq(netdev
->irq
, netdev
);
697 adapter
->rx_no_buffer
= *(u64
*)(((char *)adapter
->buffer_list_addr
) +
700 ibmveth_cleanup(adapter
);
702 netdev_dbg(netdev
, "close complete\n");
707 static int netdev_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
709 cmd
->supported
= (SUPPORTED_1000baseT_Full
| SUPPORTED_Autoneg
|
711 cmd
->advertising
= (ADVERTISED_1000baseT_Full
| ADVERTISED_Autoneg
|
713 cmd
->speed
= SPEED_1000
;
714 cmd
->duplex
= DUPLEX_FULL
;
715 cmd
->port
= PORT_FIBRE
;
716 cmd
->phy_address
= 0;
717 cmd
->transceiver
= XCVR_INTERNAL
;
718 cmd
->autoneg
= AUTONEG_ENABLE
;
724 static void netdev_get_drvinfo(struct net_device
*dev
,
725 struct ethtool_drvinfo
*info
)
727 strncpy(info
->driver
, ibmveth_driver_name
, sizeof(info
->driver
) - 1);
728 strncpy(info
->version
, ibmveth_driver_version
,
729 sizeof(info
->version
) - 1);
732 static u32
netdev_get_link(struct net_device
*dev
)
737 static void ibmveth_set_rx_csum_flags(struct net_device
*dev
, u32 data
)
739 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
742 adapter
->rx_csum
= 1;
745 * Since the ibmveth firmware interface does not have the
746 * concept of separate tx/rx checksum offload enable, if rx
747 * checksum is disabled we also have to disable tx checksum
748 * offload. Once we disable rx checksum offload, we are no
749 * longer allowed to send tx buffers that are not properly
752 adapter
->rx_csum
= 0;
753 dev
->features
&= ~NETIF_F_IP_CSUM
;
754 dev
->features
&= ~NETIF_F_IPV6_CSUM
;
758 static void ibmveth_set_tx_csum_flags(struct net_device
*dev
, u32 data
)
760 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
763 if (adapter
->fw_ipv4_csum_support
)
764 dev
->features
|= NETIF_F_IP_CSUM
;
765 if (adapter
->fw_ipv6_csum_support
)
766 dev
->features
|= NETIF_F_IPV6_CSUM
;
767 adapter
->rx_csum
= 1;
769 dev
->features
&= ~NETIF_F_IP_CSUM
;
770 dev
->features
&= ~NETIF_F_IPV6_CSUM
;
774 static int ibmveth_set_csum_offload(struct net_device
*dev
, u32 data
,
775 void (*done
) (struct net_device
*, u32
))
777 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
778 unsigned long set_attr
, clr_attr
, ret_attr
;
779 unsigned long set_attr6
, clr_attr6
;
781 int rc1
= 0, rc2
= 0;
784 if (netif_running(dev
)) {
786 adapter
->pool_config
= 1;
788 adapter
->pool_config
= 0;
795 set_attr
= IBMVETH_ILLAN_IPV4_TCP_CSUM
;
796 set_attr6
= IBMVETH_ILLAN_IPV6_TCP_CSUM
;
798 clr_attr
= IBMVETH_ILLAN_IPV4_TCP_CSUM
;
799 clr_attr6
= IBMVETH_ILLAN_IPV6_TCP_CSUM
;
802 ret
= h_illan_attributes(adapter
->vdev
->unit_address
, 0, 0, &ret_attr
);
804 if (ret
== H_SUCCESS
&& !(ret_attr
& IBMVETH_ILLAN_ACTIVE_TRUNK
) &&
805 !(ret_attr
& IBMVETH_ILLAN_TRUNK_PRI_MASK
) &&
806 (ret_attr
& IBMVETH_ILLAN_PADDED_PKT_CSUM
)) {
807 ret
= h_illan_attributes(adapter
->vdev
->unit_address
, clr_attr
,
808 set_attr
, &ret_attr
);
810 if (ret
!= H_SUCCESS
) {
811 netdev_err(dev
, "unable to change IPv4 checksum "
812 "offload settings. %d rc=%ld\n",
815 ret
= h_illan_attributes(adapter
->vdev
->unit_address
,
816 set_attr
, clr_attr
, &ret_attr
);
818 adapter
->fw_ipv4_csum_support
= data
;
821 ret6
= h_illan_attributes(adapter
->vdev
->unit_address
,
822 clr_attr6
, set_attr6
, &ret_attr
);
824 if (ret6
!= H_SUCCESS
) {
825 netdev_err(dev
, "unable to change IPv6 checksum "
826 "offload settings. %d rc=%ld\n",
829 ret
= h_illan_attributes(adapter
->vdev
->unit_address
,
830 set_attr6
, clr_attr6
,
833 adapter
->fw_ipv6_csum_support
= data
;
835 if (ret
== H_SUCCESS
|| ret6
== H_SUCCESS
)
841 netdev_err(dev
, "unable to change checksum offload settings."
842 " %d rc=%ld ret_attr=%lx\n", data
, ret
,
847 rc2
= ibmveth_open(dev
);
849 return rc1
? rc1
: rc2
;
852 static int ibmveth_set_rx_csum(struct net_device
*dev
, u32 data
)
854 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
856 if ((data
&& adapter
->rx_csum
) || (!data
&& !adapter
->rx_csum
))
859 return ibmveth_set_csum_offload(dev
, data
, ibmveth_set_rx_csum_flags
);
862 static int ibmveth_set_tx_csum(struct net_device
*dev
, u32 data
)
864 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
867 if (data
&& (dev
->features
& (NETIF_F_IP_CSUM
| NETIF_F_IPV6_CSUM
)))
869 if (!data
&& !(dev
->features
& (NETIF_F_IP_CSUM
| NETIF_F_IPV6_CSUM
)))
872 if (data
&& !adapter
->rx_csum
)
873 rc
= ibmveth_set_csum_offload(dev
, data
,
874 ibmveth_set_tx_csum_flags
);
876 ibmveth_set_tx_csum_flags(dev
, data
);
881 static u32
ibmveth_get_rx_csum(struct net_device
*dev
)
883 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
884 return adapter
->rx_csum
;
887 static void ibmveth_get_strings(struct net_device
*dev
, u32 stringset
, u8
*data
)
891 if (stringset
!= ETH_SS_STATS
)
894 for (i
= 0; i
< ARRAY_SIZE(ibmveth_stats
); i
++, data
+= ETH_GSTRING_LEN
)
895 memcpy(data
, ibmveth_stats
[i
].name
, ETH_GSTRING_LEN
);
898 static int ibmveth_get_sset_count(struct net_device
*dev
, int sset
)
902 return ARRAY_SIZE(ibmveth_stats
);
908 static void ibmveth_get_ethtool_stats(struct net_device
*dev
,
909 struct ethtool_stats
*stats
, u64
*data
)
912 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
914 for (i
= 0; i
< ARRAY_SIZE(ibmveth_stats
); i
++)
915 data
[i
] = IBMVETH_GET_STAT(adapter
, ibmveth_stats
[i
].offset
);
918 static const struct ethtool_ops netdev_ethtool_ops
= {
919 .get_drvinfo
= netdev_get_drvinfo
,
920 .get_settings
= netdev_get_settings
,
921 .get_link
= netdev_get_link
,
922 .set_tx_csum
= ibmveth_set_tx_csum
,
923 .get_rx_csum
= ibmveth_get_rx_csum
,
924 .set_rx_csum
= ibmveth_set_rx_csum
,
925 .get_strings
= ibmveth_get_strings
,
926 .get_sset_count
= ibmveth_get_sset_count
,
927 .get_ethtool_stats
= ibmveth_get_ethtool_stats
,
928 .set_sg
= ethtool_op_set_sg
,
931 static int ibmveth_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
936 #define page_offset(v) ((unsigned long)(v) & ((1 << 12) - 1))
938 static int ibmveth_send(struct ibmveth_adapter
*adapter
,
939 union ibmveth_buf_desc
*descs
)
941 unsigned long correlator
;
942 unsigned int retry_count
;
946 * The retry count sets a maximum for the number of broadcast and
947 * multicast destinations within the system.
952 ret
= h_send_logical_lan(adapter
->vdev
->unit_address
,
953 descs
[0].desc
, descs
[1].desc
,
954 descs
[2].desc
, descs
[3].desc
,
955 descs
[4].desc
, descs
[5].desc
,
956 correlator
, &correlator
);
957 } while ((ret
== H_BUSY
) && (retry_count
--));
959 if (ret
!= H_SUCCESS
&& ret
!= H_DROPPED
) {
960 netdev_err(adapter
->netdev
, "tx: h_send_logical_lan failed "
961 "with rc=%ld\n", ret
);
968 static netdev_tx_t
ibmveth_start_xmit(struct sk_buff
*skb
,
969 struct net_device
*netdev
)
971 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
972 unsigned int desc_flags
;
973 union ibmveth_buf_desc descs
[6];
975 int force_bounce
= 0;
978 * veth handles a maximum of 6 segments including the header, so
979 * we have to linearize the skb if there are more than this.
981 if (skb_shinfo(skb
)->nr_frags
> 5 && __skb_linearize(skb
)) {
982 netdev
->stats
.tx_dropped
++;
986 /* veth can't checksum offload UDP */
987 if (skb
->ip_summed
== CHECKSUM_PARTIAL
&&
988 ((skb
->protocol
== htons(ETH_P_IP
) &&
989 ip_hdr(skb
)->protocol
!= IPPROTO_TCP
) ||
990 (skb
->protocol
== htons(ETH_P_IPV6
) &&
991 ipv6_hdr(skb
)->nexthdr
!= IPPROTO_TCP
)) &&
992 skb_checksum_help(skb
)) {
994 netdev_err(netdev
, "tx: failed to checksum packet\n");
995 netdev
->stats
.tx_dropped
++;
999 desc_flags
= IBMVETH_BUF_VALID
;
1001 if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
1002 unsigned char *buf
= skb_transport_header(skb
) +
1005 desc_flags
|= (IBMVETH_BUF_NO_CSUM
| IBMVETH_BUF_CSUM_GOOD
);
1007 /* Need to zero out the checksum */
1013 memset(descs
, 0, sizeof(descs
));
1016 * If a linear packet is below the rx threshold then
1017 * copy it into the static bounce buffer. This avoids the
1018 * cost of a TCE insert and remove.
1020 if (force_bounce
|| (!skb_is_nonlinear(skb
) &&
1021 (skb
->len
< tx_copybreak
))) {
1022 skb_copy_from_linear_data(skb
, adapter
->bounce_buffer
,
1025 descs
[0].fields
.flags_len
= desc_flags
| skb
->len
;
1026 descs
[0].fields
.address
= adapter
->bounce_buffer_dma
;
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
;
1039 /* Map the header */
1040 descs
[0].fields
.address
= dma_map_single(&adapter
->vdev
->dev
, skb
->data
,
1043 if (dma_mapping_error(&adapter
->vdev
->dev
, descs
[0].fields
.address
))
1046 descs
[0].fields
.flags_len
= desc_flags
| skb_headlen(skb
);
1049 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
1050 unsigned long dma_addr
;
1051 skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
];
1053 dma_addr
= dma_map_page(&adapter
->vdev
->dev
, frag
->page
,
1054 frag
->page_offset
, frag
->size
,
1057 if (dma_mapping_error(&adapter
->vdev
->dev
, dma_addr
))
1058 goto map_failed_frags
;
1060 descs
[i
+1].fields
.flags_len
= desc_flags
| frag
->size
;
1061 descs
[i
+1].fields
.address
= dma_addr
;
1064 if (ibmveth_send(adapter
, descs
)) {
1065 adapter
->tx_send_failed
++;
1066 netdev
->stats
.tx_dropped
++;
1068 netdev
->stats
.tx_packets
++;
1069 netdev
->stats
.tx_bytes
+= skb
->len
;
1072 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
+ 1; i
++)
1073 dma_unmap_page(&adapter
->vdev
->dev
, descs
[i
].fields
.address
,
1074 descs
[i
].fields
.flags_len
& IBMVETH_BUF_LEN_MASK
,
1079 return NETDEV_TX_OK
;
1083 for (i
= 0; i
< last
; i
++)
1084 dma_unmap_page(&adapter
->vdev
->dev
, descs
[i
].fields
.address
,
1085 descs
[i
].fields
.flags_len
& IBMVETH_BUF_LEN_MASK
,
1089 if (!firmware_has_feature(FW_FEATURE_CMO
))
1090 netdev_err(netdev
, "tx: unable to map xmit buffer\n");
1091 adapter
->tx_map_failed
++;
1097 static int ibmveth_poll(struct napi_struct
*napi
, int budget
)
1099 struct ibmveth_adapter
*adapter
=
1100 container_of(napi
, struct ibmveth_adapter
, napi
);
1101 struct net_device
*netdev
= adapter
->netdev
;
1102 int frames_processed
= 0;
1103 unsigned long lpar_rc
;
1107 if (!ibmveth_rxq_pending_buffer(adapter
))
1111 if (!ibmveth_rxq_buffer_valid(adapter
)) {
1112 wmb(); /* suggested by larson1 */
1113 adapter
->rx_invalid_buffer
++;
1114 netdev_dbg(netdev
, "recycling invalid buffer\n");
1115 ibmveth_rxq_recycle_buffer(adapter
);
1117 struct sk_buff
*skb
, *new_skb
;
1118 int length
= ibmveth_rxq_frame_length(adapter
);
1119 int offset
= ibmveth_rxq_frame_offset(adapter
);
1120 int csum_good
= ibmveth_rxq_csum_good(adapter
);
1122 skb
= ibmveth_rxq_get_buffer(adapter
);
1125 if (length
< rx_copybreak
)
1126 new_skb
= netdev_alloc_skb(netdev
, length
);
1129 skb_copy_to_linear_data(new_skb
,
1133 ibmveth_flush_buffer(skb
->data
,
1136 ibmveth_rxq_recycle_buffer(adapter
);
1138 ibmveth_rxq_harvest_buffer(adapter
);
1139 skb_reserve(skb
, offset
);
1142 skb_put(skb
, length
);
1143 skb
->protocol
= eth_type_trans(skb
, netdev
);
1146 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1148 netif_receive_skb(skb
); /* send it up */
1150 netdev
->stats
.rx_packets
++;
1151 netdev
->stats
.rx_bytes
+= length
;
1154 } while (frames_processed
< budget
);
1156 ibmveth_replenish_task(adapter
);
1158 if (frames_processed
< budget
) {
1159 /* We think we are done - reenable interrupts,
1160 * then check once more to make sure we are done.
1162 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
,
1165 BUG_ON(lpar_rc
!= H_SUCCESS
);
1167 napi_complete(napi
);
1169 if (ibmveth_rxq_pending_buffer(adapter
) &&
1170 napi_reschedule(napi
)) {
1171 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
,
1177 return frames_processed
;
1180 static irqreturn_t
ibmveth_interrupt(int irq
, void *dev_instance
)
1182 struct net_device
*netdev
= dev_instance
;
1183 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
1184 unsigned long lpar_rc
;
1186 if (napi_schedule_prep(&adapter
->napi
)) {
1187 lpar_rc
= h_vio_signal(adapter
->vdev
->unit_address
,
1189 BUG_ON(lpar_rc
!= H_SUCCESS
);
1190 __napi_schedule(&adapter
->napi
);
1195 static void ibmveth_set_multicast_list(struct net_device
*netdev
)
1197 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
1198 unsigned long lpar_rc
;
1200 if ((netdev
->flags
& IFF_PROMISC
) ||
1201 (netdev_mc_count(netdev
) > adapter
->mcastFilterSize
)) {
1202 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1203 IbmVethMcastEnableRecv
|
1204 IbmVethMcastDisableFiltering
,
1206 if (lpar_rc
!= H_SUCCESS
) {
1207 netdev_err(netdev
, "h_multicast_ctrl rc=%ld when "
1208 "entering promisc mode\n", lpar_rc
);
1211 struct netdev_hw_addr
*ha
;
1212 /* clear the filter table & disable filtering */
1213 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1214 IbmVethMcastEnableRecv
|
1215 IbmVethMcastDisableFiltering
|
1216 IbmVethMcastClearFilterTable
,
1218 if (lpar_rc
!= H_SUCCESS
) {
1219 netdev_err(netdev
, "h_multicast_ctrl rc=%ld when "
1220 "attempting to clear filter table\n",
1223 /* add the addresses to the filter table */
1224 netdev_for_each_mc_addr(ha
, netdev
) {
1225 /* add the multicast address to the filter table */
1226 unsigned long mcast_addr
= 0;
1227 memcpy(((char *)&mcast_addr
)+2, ha
->addr
, 6);
1228 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1229 IbmVethMcastAddFilter
,
1231 if (lpar_rc
!= H_SUCCESS
) {
1232 netdev_err(netdev
, "h_multicast_ctrl rc=%ld "
1233 "when adding an entry to the filter "
1234 "table\n", lpar_rc
);
1238 /* re-enable filtering */
1239 lpar_rc
= h_multicast_ctrl(adapter
->vdev
->unit_address
,
1240 IbmVethMcastEnableFiltering
,
1242 if (lpar_rc
!= H_SUCCESS
) {
1243 netdev_err(netdev
, "h_multicast_ctrl rc=%ld when "
1244 "enabling filtering\n", lpar_rc
);
1249 static int ibmveth_change_mtu(struct net_device
*dev
, int new_mtu
)
1251 struct ibmveth_adapter
*adapter
= netdev_priv(dev
);
1252 struct vio_dev
*viodev
= adapter
->vdev
;
1253 int new_mtu_oh
= new_mtu
+ IBMVETH_BUFF_OH
;
1255 int need_restart
= 0;
1257 if (new_mtu
< IBMVETH_MIN_MTU
)
1260 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++)
1261 if (new_mtu_oh
< adapter
->rx_buff_pool
[i
].buff_size
)
1264 if (i
== IBMVETH_NUM_BUFF_POOLS
)
1267 /* Deactivate all the buffer pools so that the next loop can activate
1268 only the buffer pools necessary to hold the new MTU */
1269 if (netif_running(adapter
->netdev
)) {
1271 adapter
->pool_config
= 1;
1272 ibmveth_close(adapter
->netdev
);
1273 adapter
->pool_config
= 0;
1276 /* Look for an active buffer pool that can hold the new MTU */
1277 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
1278 adapter
->rx_buff_pool
[i
].active
= 1;
1280 if (new_mtu_oh
< adapter
->rx_buff_pool
[i
].buff_size
) {
1282 vio_cmo_set_dev_desired(viodev
,
1283 ibmveth_get_desired_dma
1286 return ibmveth_open(adapter
->netdev
);
1292 if (need_restart
&& (rc
= ibmveth_open(adapter
->netdev
)))
1298 #ifdef CONFIG_NET_POLL_CONTROLLER
1299 static void ibmveth_poll_controller(struct net_device
*dev
)
1301 ibmveth_replenish_task(netdev_priv(dev
));
1302 ibmveth_interrupt(dev
->irq
, dev
);
1307 * ibmveth_get_desired_dma - Calculate IO memory desired by the driver
1309 * @vdev: struct vio_dev for the device whose desired IO mem is to be returned
1312 * Number of bytes of IO data the driver will need to perform well.
1314 static unsigned long ibmveth_get_desired_dma(struct vio_dev
*vdev
)
1316 struct net_device
*netdev
= dev_get_drvdata(&vdev
->dev
);
1317 struct ibmveth_adapter
*adapter
;
1322 /* netdev inits at probe time along with the structures we need below*/
1324 return IOMMU_PAGE_ALIGN(IBMVETH_IO_ENTITLEMENT_DEFAULT
);
1326 adapter
= netdev_priv(netdev
);
1328 ret
= IBMVETH_BUFF_LIST_SIZE
+ IBMVETH_FILT_LIST_SIZE
;
1329 ret
+= IOMMU_PAGE_ALIGN(netdev
->mtu
);
1331 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
1332 /* add the size of the active receive buffers */
1333 if (adapter
->rx_buff_pool
[i
].active
)
1335 adapter
->rx_buff_pool
[i
].size
*
1336 IOMMU_PAGE_ALIGN(adapter
->rx_buff_pool
[i
].
1338 rxqentries
+= adapter
->rx_buff_pool
[i
].size
;
1340 /* add the size of the receive queue entries */
1341 ret
+= IOMMU_PAGE_ALIGN(rxqentries
* sizeof(struct ibmveth_rx_q_entry
));
1346 static const struct net_device_ops ibmveth_netdev_ops
= {
1347 .ndo_open
= ibmveth_open
,
1348 .ndo_stop
= ibmveth_close
,
1349 .ndo_start_xmit
= ibmveth_start_xmit
,
1350 .ndo_set_multicast_list
= ibmveth_set_multicast_list
,
1351 .ndo_do_ioctl
= ibmveth_ioctl
,
1352 .ndo_change_mtu
= ibmveth_change_mtu
,
1353 .ndo_validate_addr
= eth_validate_addr
,
1354 .ndo_set_mac_address
= eth_mac_addr
,
1355 #ifdef CONFIG_NET_POLL_CONTROLLER
1356 .ndo_poll_controller
= ibmveth_poll_controller
,
1360 static int __devinit
ibmveth_probe(struct vio_dev
*dev
,
1361 const struct vio_device_id
*id
)
1364 struct net_device
*netdev
;
1365 struct ibmveth_adapter
*adapter
;
1366 unsigned char *mac_addr_p
;
1367 unsigned int *mcastFilterSize_p
;
1369 dev_dbg(&dev
->dev
, "entering ibmveth_probe for UA 0x%x\n",
1372 mac_addr_p
= (unsigned char *)vio_get_attribute(dev
, VETH_MAC_ADDR
,
1375 dev_err(&dev
->dev
, "Can't find VETH_MAC_ADDR attribute\n");
1379 mcastFilterSize_p
= (unsigned int *)vio_get_attribute(dev
,
1380 VETH_MCAST_FILTER_SIZE
, NULL
);
1381 if (!mcastFilterSize_p
) {
1382 dev_err(&dev
->dev
, "Can't find VETH_MCAST_FILTER_SIZE "
1387 netdev
= alloc_etherdev(sizeof(struct ibmveth_adapter
));
1392 adapter
= netdev_priv(netdev
);
1393 dev_set_drvdata(&dev
->dev
, netdev
);
1395 adapter
->vdev
= dev
;
1396 adapter
->netdev
= netdev
;
1397 adapter
->mcastFilterSize
= *mcastFilterSize_p
;
1398 adapter
->pool_config
= 0;
1400 netif_napi_add(netdev
, &adapter
->napi
, ibmveth_poll
, 16);
1403 * Some older boxes running PHYP non-natively have an OF that returns
1404 * a 8-byte local-mac-address field (and the first 2 bytes have to be
1405 * ignored) while newer boxes' OF return a 6-byte field. Note that
1406 * IEEE 1275 specifies that local-mac-address must be a 6-byte field.
1407 * The RPA doc specifies that the first byte must be 10b, so we'll
1408 * just look for it to solve this 8 vs. 6 byte field issue
1410 if ((*mac_addr_p
& 0x3) != 0x02)
1413 adapter
->mac_addr
= 0;
1414 memcpy(&adapter
->mac_addr
, mac_addr_p
, 6);
1416 netdev
->irq
= dev
->irq
;
1417 netdev
->netdev_ops
= &ibmveth_netdev_ops
;
1418 netdev
->ethtool_ops
= &netdev_ethtool_ops
;
1419 SET_NETDEV_DEV(netdev
, &dev
->dev
);
1420 netdev
->features
|= NETIF_F_SG
;
1422 memcpy(netdev
->dev_addr
, &adapter
->mac_addr
, netdev
->addr_len
);
1424 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
1425 struct kobject
*kobj
= &adapter
->rx_buff_pool
[i
].kobj
;
1428 ibmveth_init_buffer_pool(&adapter
->rx_buff_pool
[i
], i
,
1429 pool_count
[i
], pool_size
[i
],
1431 error
= kobject_init_and_add(kobj
, &ktype_veth_pool
,
1432 &dev
->dev
.kobj
, "pool%d", i
);
1434 kobject_uevent(kobj
, KOBJ_ADD
);
1437 netdev_dbg(netdev
, "adapter @ 0x%p\n", adapter
);
1439 adapter
->buffer_list_dma
= DMA_ERROR_CODE
;
1440 adapter
->filter_list_dma
= DMA_ERROR_CODE
;
1441 adapter
->rx_queue
.queue_dma
= DMA_ERROR_CODE
;
1443 netdev_dbg(netdev
, "registering netdev...\n");
1445 ibmveth_set_csum_offload(netdev
, 1, ibmveth_set_tx_csum_flags
);
1447 rc
= register_netdev(netdev
);
1450 netdev_dbg(netdev
, "failed to register netdev rc=%d\n", rc
);
1451 free_netdev(netdev
);
1455 netdev_dbg(netdev
, "registered\n");
1460 static int __devexit
ibmveth_remove(struct vio_dev
*dev
)
1462 struct net_device
*netdev
= dev_get_drvdata(&dev
->dev
);
1463 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
1466 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++)
1467 kobject_put(&adapter
->rx_buff_pool
[i
].kobj
);
1469 unregister_netdev(netdev
);
1471 free_netdev(netdev
);
1472 dev_set_drvdata(&dev
->dev
, NULL
);
1477 static struct attribute veth_active_attr
;
1478 static struct attribute veth_num_attr
;
1479 static struct attribute veth_size_attr
;
1481 static ssize_t
veth_pool_show(struct kobject
*kobj
,
1482 struct attribute
*attr
, char *buf
)
1484 struct ibmveth_buff_pool
*pool
= container_of(kobj
,
1485 struct ibmveth_buff_pool
,
1488 if (attr
== &veth_active_attr
)
1489 return sprintf(buf
, "%d\n", pool
->active
);
1490 else if (attr
== &veth_num_attr
)
1491 return sprintf(buf
, "%d\n", pool
->size
);
1492 else if (attr
== &veth_size_attr
)
1493 return sprintf(buf
, "%d\n", pool
->buff_size
);
1497 static ssize_t
veth_pool_store(struct kobject
*kobj
, struct attribute
*attr
,
1498 const char *buf
, size_t count
)
1500 struct ibmveth_buff_pool
*pool
= container_of(kobj
,
1501 struct ibmveth_buff_pool
,
1503 struct net_device
*netdev
= dev_get_drvdata(
1504 container_of(kobj
->parent
, struct device
, kobj
));
1505 struct ibmveth_adapter
*adapter
= netdev_priv(netdev
);
1506 long value
= simple_strtol(buf
, NULL
, 10);
1509 if (attr
== &veth_active_attr
) {
1510 if (value
&& !pool
->active
) {
1511 if (netif_running(netdev
)) {
1512 if (ibmveth_alloc_buffer_pool(pool
)) {
1514 "unable to alloc pool\n");
1518 adapter
->pool_config
= 1;
1519 ibmveth_close(netdev
);
1520 adapter
->pool_config
= 0;
1521 if ((rc
= ibmveth_open(netdev
)))
1526 } else if (!value
&& pool
->active
) {
1527 int mtu
= netdev
->mtu
+ IBMVETH_BUFF_OH
;
1529 /* Make sure there is a buffer pool with buffers that
1530 can hold a packet of the size of the MTU */
1531 for (i
= 0; i
< IBMVETH_NUM_BUFF_POOLS
; i
++) {
1532 if (pool
== &adapter
->rx_buff_pool
[i
])
1534 if (!adapter
->rx_buff_pool
[i
].active
)
1536 if (mtu
<= adapter
->rx_buff_pool
[i
].buff_size
)
1540 if (i
== IBMVETH_NUM_BUFF_POOLS
) {
1541 netdev_err(netdev
, "no active pool >= MTU\n");
1545 if (netif_running(netdev
)) {
1546 adapter
->pool_config
= 1;
1547 ibmveth_close(netdev
);
1549 adapter
->pool_config
= 0;
1550 if ((rc
= ibmveth_open(netdev
)))
1555 } else if (attr
== &veth_num_attr
) {
1556 if (value
<= 0 || value
> IBMVETH_MAX_POOL_COUNT
) {
1559 if (netif_running(netdev
)) {
1560 adapter
->pool_config
= 1;
1561 ibmveth_close(netdev
);
1562 adapter
->pool_config
= 0;
1564 if ((rc
= ibmveth_open(netdev
)))
1570 } else if (attr
== &veth_size_attr
) {
1571 if (value
<= IBMVETH_BUFF_OH
|| value
> IBMVETH_MAX_BUF_SIZE
) {
1574 if (netif_running(netdev
)) {
1575 adapter
->pool_config
= 1;
1576 ibmveth_close(netdev
);
1577 adapter
->pool_config
= 0;
1578 pool
->buff_size
= value
;
1579 if ((rc
= ibmveth_open(netdev
)))
1582 pool
->buff_size
= value
;
1587 /* kick the interrupt handler to allocate/deallocate pools */
1588 ibmveth_interrupt(netdev
->irq
, netdev
);
1593 #define ATTR(_name, _mode) \
1594 struct attribute veth_##_name##_attr = { \
1595 .name = __stringify(_name), .mode = _mode, \
1598 static ATTR(active
, 0644);
1599 static ATTR(num
, 0644);
1600 static ATTR(size
, 0644);
1602 static struct attribute
*veth_pool_attrs
[] = {
1609 static const struct sysfs_ops veth_pool_ops
= {
1610 .show
= veth_pool_show
,
1611 .store
= veth_pool_store
,
1614 static struct kobj_type ktype_veth_pool
= {
1616 .sysfs_ops
= &veth_pool_ops
,
1617 .default_attrs
= veth_pool_attrs
,
1620 static int ibmveth_resume(struct device
*dev
)
1622 struct net_device
*netdev
= dev_get_drvdata(dev
);
1623 ibmveth_interrupt(netdev
->irq
, netdev
);
1627 static struct vio_device_id ibmveth_device_table
[] __devinitdata
= {
1628 { "network", "IBM,l-lan"},
1631 MODULE_DEVICE_TABLE(vio
, ibmveth_device_table
);
1633 static struct dev_pm_ops ibmveth_pm_ops
= {
1634 .resume
= ibmveth_resume
1637 static struct vio_driver ibmveth_driver
= {
1638 .id_table
= ibmveth_device_table
,
1639 .probe
= ibmveth_probe
,
1640 .remove
= ibmveth_remove
,
1641 .get_desired_dma
= ibmveth_get_desired_dma
,
1643 .name
= ibmveth_driver_name
,
1644 .owner
= THIS_MODULE
,
1645 .pm
= &ibmveth_pm_ops
,
1649 static int __init
ibmveth_module_init(void)
1651 printk(KERN_DEBUG
"%s: %s %s\n", ibmveth_driver_name
,
1652 ibmveth_driver_string
, ibmveth_driver_version
);
1654 return vio_register_driver(&ibmveth_driver
);
1657 static void __exit
ibmveth_module_exit(void)
1659 vio_unregister_driver(&ibmveth_driver
);
1662 module_init(ibmveth_module_init
);
1663 module_exit(ibmveth_module_exit
);