xref: /openbmc/linux/drivers/net/ethernet/ibm/ibmveth.c (revision 45fe9262)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * IBM Power Virtual Ethernet Device Driver
4  *
5  * Copyright (C) IBM Corporation, 2003, 2010
6  *
7  * Authors: Dave Larson <larson1@us.ibm.com>
8  *	    Santiago Leon <santil@linux.vnet.ibm.com>
9  *	    Brian King <brking@linux.vnet.ibm.com>
10  *	    Robert Jennings <rcj@linux.vnet.ibm.com>
11  *	    Anton Blanchard <anton@au.ibm.com>
12  */
13 
14 #include <linux/module.h>
15 #include <linux/types.h>
16 #include <linux/errno.h>
17 #include <linux/dma-mapping.h>
18 #include <linux/kernel.h>
19 #include <linux/netdevice.h>
20 #include <linux/etherdevice.h>
21 #include <linux/skbuff.h>
22 #include <linux/init.h>
23 #include <linux/interrupt.h>
24 #include <linux/mm.h>
25 #include <linux/pm.h>
26 #include <linux/ethtool.h>
27 #include <linux/in.h>
28 #include <linux/ip.h>
29 #include <linux/ipv6.h>
30 #include <linux/slab.h>
31 #include <asm/hvcall.h>
32 #include <linux/atomic.h>
33 #include <asm/vio.h>
34 #include <asm/iommu.h>
35 #include <asm/firmware.h>
36 #include <net/tcp.h>
37 #include <net/ip6_checksum.h>
38 
39 #include "ibmveth.h"
40 
41 static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance);
42 static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter);
43 static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev);
44 
45 static struct kobj_type ktype_veth_pool;
46 
47 
48 static const char ibmveth_driver_name[] = "ibmveth";
49 static const char ibmveth_driver_string[] = "IBM Power Virtual Ethernet Driver";
50 #define ibmveth_driver_version "1.06"
51 
52 MODULE_AUTHOR("Santiago Leon <santil@linux.vnet.ibm.com>");
53 MODULE_DESCRIPTION("IBM Power Virtual Ethernet Driver");
54 MODULE_LICENSE("GPL");
55 MODULE_VERSION(ibmveth_driver_version);
56 
57 static unsigned int tx_copybreak __read_mostly = 128;
58 module_param(tx_copybreak, uint, 0644);
59 MODULE_PARM_DESC(tx_copybreak,
60 	"Maximum size of packet that is copied to a new buffer on transmit");
61 
62 static unsigned int rx_copybreak __read_mostly = 128;
63 module_param(rx_copybreak, uint, 0644);
64 MODULE_PARM_DESC(rx_copybreak,
65 	"Maximum size of packet that is copied to a new buffer on receive");
66 
67 static unsigned int rx_flush __read_mostly = 0;
68 module_param(rx_flush, uint, 0644);
69 MODULE_PARM_DESC(rx_flush, "Flush receive buffers before use");
70 
71 static bool old_large_send __read_mostly;
72 module_param(old_large_send, bool, 0444);
73 MODULE_PARM_DESC(old_large_send,
74 	"Use old large send method on firmware that supports the new method");
75 
76 struct ibmveth_stat {
77 	char name[ETH_GSTRING_LEN];
78 	int offset;
79 };
80 
81 #define IBMVETH_STAT_OFF(stat) offsetof(struct ibmveth_adapter, stat)
82 #define IBMVETH_GET_STAT(a, off) *((u64 *)(((unsigned long)(a)) + off))
83 
84 static struct ibmveth_stat ibmveth_stats[] = {
85 	{ "replenish_task_cycles", IBMVETH_STAT_OFF(replenish_task_cycles) },
86 	{ "replenish_no_mem", IBMVETH_STAT_OFF(replenish_no_mem) },
87 	{ "replenish_add_buff_failure",
88 			IBMVETH_STAT_OFF(replenish_add_buff_failure) },
89 	{ "replenish_add_buff_success",
90 			IBMVETH_STAT_OFF(replenish_add_buff_success) },
91 	{ "rx_invalid_buffer", IBMVETH_STAT_OFF(rx_invalid_buffer) },
92 	{ "rx_no_buffer", IBMVETH_STAT_OFF(rx_no_buffer) },
93 	{ "tx_map_failed", IBMVETH_STAT_OFF(tx_map_failed) },
94 	{ "tx_send_failed", IBMVETH_STAT_OFF(tx_send_failed) },
95 	{ "fw_enabled_ipv4_csum", IBMVETH_STAT_OFF(fw_ipv4_csum_support) },
96 	{ "fw_enabled_ipv6_csum", IBMVETH_STAT_OFF(fw_ipv6_csum_support) },
97 	{ "tx_large_packets", IBMVETH_STAT_OFF(tx_large_packets) },
98 	{ "rx_large_packets", IBMVETH_STAT_OFF(rx_large_packets) },
99 	{ "fw_enabled_large_send", IBMVETH_STAT_OFF(fw_large_send_support) }
100 };
101 
102 /* simple methods of getting data from the current rxq entry */
103 static inline u32 ibmveth_rxq_flags(struct ibmveth_adapter *adapter)
104 {
105 	return be32_to_cpu(adapter->rx_queue.queue_addr[adapter->rx_queue.index].flags_off);
106 }
107 
108 static inline int ibmveth_rxq_toggle(struct ibmveth_adapter *adapter)
109 {
110 	return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_TOGGLE) >>
111 			IBMVETH_RXQ_TOGGLE_SHIFT;
112 }
113 
114 static inline int ibmveth_rxq_pending_buffer(struct ibmveth_adapter *adapter)
115 {
116 	return ibmveth_rxq_toggle(adapter) == adapter->rx_queue.toggle;
117 }
118 
119 static inline int ibmveth_rxq_buffer_valid(struct ibmveth_adapter *adapter)
120 {
121 	return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_VALID;
122 }
123 
124 static inline int ibmveth_rxq_frame_offset(struct ibmveth_adapter *adapter)
125 {
126 	return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_OFF_MASK;
127 }
128 
129 static inline int ibmveth_rxq_large_packet(struct ibmveth_adapter *adapter)
130 {
131 	return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_LRG_PKT;
132 }
133 
134 static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter *adapter)
135 {
136 	return be32_to_cpu(adapter->rx_queue.queue_addr[adapter->rx_queue.index].length);
137 }
138 
139 static inline int ibmveth_rxq_csum_good(struct ibmveth_adapter *adapter)
140 {
141 	return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_CSUM_GOOD;
142 }
143 
144 /* setup the initial settings for a buffer pool */
145 static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool *pool,
146 				     u32 pool_index, u32 pool_size,
147 				     u32 buff_size, u32 pool_active)
148 {
149 	pool->size = pool_size;
150 	pool->index = pool_index;
151 	pool->buff_size = buff_size;
152 	pool->threshold = pool_size * 7 / 8;
153 	pool->active = pool_active;
154 }
155 
156 /* allocate and setup an buffer pool - called during open */
157 static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool)
158 {
159 	int i;
160 
161 	pool->free_map = kmalloc_array(pool->size, sizeof(u16), GFP_KERNEL);
162 
163 	if (!pool->free_map)
164 		return -1;
165 
166 	pool->dma_addr = kcalloc(pool->size, sizeof(dma_addr_t), GFP_KERNEL);
167 	if (!pool->dma_addr) {
168 		kfree(pool->free_map);
169 		pool->free_map = NULL;
170 		return -1;
171 	}
172 
173 	pool->skbuff = kcalloc(pool->size, sizeof(void *), GFP_KERNEL);
174 
175 	if (!pool->skbuff) {
176 		kfree(pool->dma_addr);
177 		pool->dma_addr = NULL;
178 
179 		kfree(pool->free_map);
180 		pool->free_map = NULL;
181 		return -1;
182 	}
183 
184 	for (i = 0; i < pool->size; ++i)
185 		pool->free_map[i] = i;
186 
187 	atomic_set(&pool->available, 0);
188 	pool->producer_index = 0;
189 	pool->consumer_index = 0;
190 
191 	return 0;
192 }
193 
194 static inline void ibmveth_flush_buffer(void *addr, unsigned long length)
195 {
196 	unsigned long offset;
197 
198 	for (offset = 0; offset < length; offset += SMP_CACHE_BYTES)
199 		asm("dcbfl %0,%1" :: "b" (addr), "r" (offset));
200 }
201 
202 /* replenish the buffers for a pool.  note that we don't need to
203  * skb_reserve these since they are used for incoming...
204  */
205 static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter,
206 					  struct ibmveth_buff_pool *pool)
207 {
208 	u32 i;
209 	u32 count = pool->size - atomic_read(&pool->available);
210 	u32 buffers_added = 0;
211 	struct sk_buff *skb;
212 	unsigned int free_index, index;
213 	u64 correlator;
214 	unsigned long lpar_rc;
215 	dma_addr_t dma_addr;
216 
217 	mb();
218 
219 	for (i = 0; i < count; ++i) {
220 		union ibmveth_buf_desc desc;
221 
222 		skb = netdev_alloc_skb(adapter->netdev, pool->buff_size);
223 
224 		if (!skb) {
225 			netdev_dbg(adapter->netdev,
226 				   "replenish: unable to allocate skb\n");
227 			adapter->replenish_no_mem++;
228 			break;
229 		}
230 
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];
236 
237 		BUG_ON(index == IBM_VETH_INVALID_MAP);
238 		BUG_ON(pool->skbuff[index] != NULL);
239 
240 		dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
241 				pool->buff_size, DMA_FROM_DEVICE);
242 
243 		if (dma_mapping_error(&adapter->vdev->dev, dma_addr))
244 			goto failure;
245 
246 		pool->free_map[free_index] = IBM_VETH_INVALID_MAP;
247 		pool->dma_addr[index] = dma_addr;
248 		pool->skbuff[index] = skb;
249 
250 		correlator = ((u64)pool->index << 32) | index;
251 		*(u64 *)skb->data = correlator;
252 
253 		desc.fields.flags_len = IBMVETH_BUF_VALID | pool->buff_size;
254 		desc.fields.address = dma_addr;
255 
256 		if (rx_flush) {
257 			unsigned int len = min(pool->buff_size,
258 						adapter->netdev->mtu +
259 						IBMVETH_BUFF_OH);
260 			ibmveth_flush_buffer(skb->data, len);
261 		}
262 		lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address,
263 						   desc.desc);
264 
265 		if (lpar_rc != H_SUCCESS) {
266 			goto failure;
267 		} else {
268 			buffers_added++;
269 			adapter->replenish_add_buff_success++;
270 		}
271 	}
272 
273 	mb();
274 	atomic_add(buffers_added, &(pool->available));
275 	return;
276 
277 failure:
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;
282 	else
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,
287 		                 DMA_FROM_DEVICE);
288 	dev_kfree_skb_any(skb);
289 	adapter->replenish_add_buff_failure++;
290 
291 	mb();
292 	atomic_add(buffers_added, &(pool->available));
293 }
294 
295 /*
296  * The final 8 bytes of the buffer list is a counter of frames dropped
297  * because there was not a buffer in the buffer list capable of holding
298  * the frame.
299  */
300 static void ibmveth_update_rx_no_buffer(struct ibmveth_adapter *adapter)
301 {
302 	__be64 *p = adapter->buffer_list_addr + 4096 - 8;
303 
304 	adapter->rx_no_buffer = be64_to_cpup(p);
305 }
306 
307 /* replenish routine */
308 static void ibmveth_replenish_task(struct ibmveth_adapter *adapter)
309 {
310 	int i;
311 
312 	adapter->replenish_task_cycles++;
313 
314 	for (i = (IBMVETH_NUM_BUFF_POOLS - 1); i >= 0; i--) {
315 		struct ibmveth_buff_pool *pool = &adapter->rx_buff_pool[i];
316 
317 		if (pool->active &&
318 		    (atomic_read(&pool->available) < pool->threshold))
319 			ibmveth_replenish_buffer_pool(adapter, pool);
320 	}
321 
322 	ibmveth_update_rx_no_buffer(adapter);
323 }
324 
325 /* empty and free ana buffer pool - also used to do cleanup in error paths */
326 static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter,
327 				     struct ibmveth_buff_pool *pool)
328 {
329 	int i;
330 
331 	kfree(pool->free_map);
332 	pool->free_map = NULL;
333 
334 	if (pool->skbuff && pool->dma_addr) {
335 		for (i = 0; i < pool->size; ++i) {
336 			struct sk_buff *skb = pool->skbuff[i];
337 			if (skb) {
338 				dma_unmap_single(&adapter->vdev->dev,
339 						 pool->dma_addr[i],
340 						 pool->buff_size,
341 						 DMA_FROM_DEVICE);
342 				dev_kfree_skb_any(skb);
343 				pool->skbuff[i] = NULL;
344 			}
345 		}
346 	}
347 
348 	if (pool->dma_addr) {
349 		kfree(pool->dma_addr);
350 		pool->dma_addr = NULL;
351 	}
352 
353 	if (pool->skbuff) {
354 		kfree(pool->skbuff);
355 		pool->skbuff = NULL;
356 	}
357 }
358 
359 /* remove a buffer from a pool */
360 static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter *adapter,
361 					    u64 correlator)
362 {
363 	unsigned int pool  = correlator >> 32;
364 	unsigned int index = correlator & 0xffffffffUL;
365 	unsigned int free_index;
366 	struct sk_buff *skb;
367 
368 	BUG_ON(pool >= IBMVETH_NUM_BUFF_POOLS);
369 	BUG_ON(index >= adapter->rx_buff_pool[pool].size);
370 
371 	skb = adapter->rx_buff_pool[pool].skbuff[index];
372 
373 	BUG_ON(skb == NULL);
374 
375 	adapter->rx_buff_pool[pool].skbuff[index] = NULL;
376 
377 	dma_unmap_single(&adapter->vdev->dev,
378 			 adapter->rx_buff_pool[pool].dma_addr[index],
379 			 adapter->rx_buff_pool[pool].buff_size,
380 			 DMA_FROM_DEVICE);
381 
382 	free_index = adapter->rx_buff_pool[pool].producer_index;
383 	adapter->rx_buff_pool[pool].producer_index++;
384 	if (adapter->rx_buff_pool[pool].producer_index >=
385 	    adapter->rx_buff_pool[pool].size)
386 		adapter->rx_buff_pool[pool].producer_index = 0;
387 	adapter->rx_buff_pool[pool].free_map[free_index] = index;
388 
389 	mb();
390 
391 	atomic_dec(&(adapter->rx_buff_pool[pool].available));
392 }
393 
394 /* get the current buffer on the rx queue */
395 static inline struct sk_buff *ibmveth_rxq_get_buffer(struct ibmveth_adapter *adapter)
396 {
397 	u64 correlator = adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator;
398 	unsigned int pool = correlator >> 32;
399 	unsigned int index = correlator & 0xffffffffUL;
400 
401 	BUG_ON(pool >= IBMVETH_NUM_BUFF_POOLS);
402 	BUG_ON(index >= adapter->rx_buff_pool[pool].size);
403 
404 	return adapter->rx_buff_pool[pool].skbuff[index];
405 }
406 
407 /* recycle the current buffer on the rx queue */
408 static int ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
409 {
410 	u32 q_index = adapter->rx_queue.index;
411 	u64 correlator = adapter->rx_queue.queue_addr[q_index].correlator;
412 	unsigned int pool = correlator >> 32;
413 	unsigned int index = correlator & 0xffffffffUL;
414 	union ibmveth_buf_desc desc;
415 	unsigned long lpar_rc;
416 	int ret = 1;
417 
418 	BUG_ON(pool >= IBMVETH_NUM_BUFF_POOLS);
419 	BUG_ON(index >= adapter->rx_buff_pool[pool].size);
420 
421 	if (!adapter->rx_buff_pool[pool].active) {
422 		ibmveth_rxq_harvest_buffer(adapter);
423 		ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[pool]);
424 		goto out;
425 	}
426 
427 	desc.fields.flags_len = IBMVETH_BUF_VALID |
428 		adapter->rx_buff_pool[pool].buff_size;
429 	desc.fields.address = adapter->rx_buff_pool[pool].dma_addr[index];
430 
431 	lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc);
432 
433 	if (lpar_rc != H_SUCCESS) {
434 		netdev_dbg(adapter->netdev, "h_add_logical_lan_buffer failed "
435 			   "during recycle rc=%ld", lpar_rc);
436 		ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator);
437 		ret = 0;
438 	}
439 
440 	if (++adapter->rx_queue.index == adapter->rx_queue.num_slots) {
441 		adapter->rx_queue.index = 0;
442 		adapter->rx_queue.toggle = !adapter->rx_queue.toggle;
443 	}
444 
445 out:
446 	return ret;
447 }
448 
449 static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter)
450 {
451 	ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator);
452 
453 	if (++adapter->rx_queue.index == adapter->rx_queue.num_slots) {
454 		adapter->rx_queue.index = 0;
455 		adapter->rx_queue.toggle = !adapter->rx_queue.toggle;
456 	}
457 }
458 
459 static int ibmveth_register_logical_lan(struct ibmveth_adapter *adapter,
460         union ibmveth_buf_desc rxq_desc, u64 mac_address)
461 {
462 	int rc, try_again = 1;
463 
464 	/*
465 	 * After a kexec the adapter will still be open, so our attempt to
466 	 * open it will fail. So if we get a failure we free the adapter and
467 	 * try again, but only once.
468 	 */
469 retry:
470 	rc = h_register_logical_lan(adapter->vdev->unit_address,
471 				    adapter->buffer_list_dma, rxq_desc.desc,
472 				    adapter->filter_list_dma, mac_address);
473 
474 	if (rc != H_SUCCESS && try_again) {
475 		do {
476 			rc = h_free_logical_lan(adapter->vdev->unit_address);
477 		} while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY));
478 
479 		try_again = 0;
480 		goto retry;
481 	}
482 
483 	return rc;
484 }
485 
486 static u64 ibmveth_encode_mac_addr(u8 *mac)
487 {
488 	int i;
489 	u64 encoded = 0;
490 
491 	for (i = 0; i < ETH_ALEN; i++)
492 		encoded = (encoded << 8) | mac[i];
493 
494 	return encoded;
495 }
496 
497 static int ibmveth_open(struct net_device *netdev)
498 {
499 	struct ibmveth_adapter *adapter = netdev_priv(netdev);
500 	u64 mac_address;
501 	int rxq_entries = 1;
502 	unsigned long lpar_rc;
503 	int rc;
504 	union ibmveth_buf_desc rxq_desc;
505 	int i;
506 	struct device *dev;
507 
508 	netdev_dbg(netdev, "open starting\n");
509 
510 	napi_enable(&adapter->napi);
511 
512 	for(i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++)
513 		rxq_entries += adapter->rx_buff_pool[i].size;
514 
515 	rc = -ENOMEM;
516 	adapter->buffer_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
517 	if (!adapter->buffer_list_addr) {
518 		netdev_err(netdev, "unable to allocate list pages\n");
519 		goto out;
520 	}
521 
522 	adapter->filter_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
523 	if (!adapter->filter_list_addr) {
524 		netdev_err(netdev, "unable to allocate filter pages\n");
525 		goto out_free_buffer_list;
526 	}
527 
528 	dev = &adapter->vdev->dev;
529 
530 	adapter->rx_queue.queue_len = sizeof(struct ibmveth_rx_q_entry) *
531 						rxq_entries;
532 	adapter->rx_queue.queue_addr =
533 		dma_alloc_coherent(dev, adapter->rx_queue.queue_len,
534 				   &adapter->rx_queue.queue_dma, GFP_KERNEL);
535 	if (!adapter->rx_queue.queue_addr)
536 		goto out_free_filter_list;
537 
538 	adapter->buffer_list_dma = dma_map_single(dev,
539 			adapter->buffer_list_addr, 4096, DMA_BIDIRECTIONAL);
540 	if (dma_mapping_error(dev, adapter->buffer_list_dma)) {
541 		netdev_err(netdev, "unable to map buffer list pages\n");
542 		goto out_free_queue_mem;
543 	}
544 
545 	adapter->filter_list_dma = dma_map_single(dev,
546 			adapter->filter_list_addr, 4096, DMA_BIDIRECTIONAL);
547 	if (dma_mapping_error(dev, adapter->filter_list_dma)) {
548 		netdev_err(netdev, "unable to map filter list pages\n");
549 		goto out_unmap_buffer_list;
550 	}
551 
552 	adapter->rx_queue.index = 0;
553 	adapter->rx_queue.num_slots = rxq_entries;
554 	adapter->rx_queue.toggle = 1;
555 
556 	mac_address = ibmveth_encode_mac_addr(netdev->dev_addr);
557 
558 	rxq_desc.fields.flags_len = IBMVETH_BUF_VALID |
559 					adapter->rx_queue.queue_len;
560 	rxq_desc.fields.address = adapter->rx_queue.queue_dma;
561 
562 	netdev_dbg(netdev, "buffer list @ 0x%p\n", adapter->buffer_list_addr);
563 	netdev_dbg(netdev, "filter list @ 0x%p\n", adapter->filter_list_addr);
564 	netdev_dbg(netdev, "receive q   @ 0x%p\n", adapter->rx_queue.queue_addr);
565 
566 	h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
567 
568 	lpar_rc = ibmveth_register_logical_lan(adapter, rxq_desc, mac_address);
569 
570 	if (lpar_rc != H_SUCCESS) {
571 		netdev_err(netdev, "h_register_logical_lan failed with %ld\n",
572 			   lpar_rc);
573 		netdev_err(netdev, "buffer TCE:0x%llx filter TCE:0x%llx rxq "
574 			   "desc:0x%llx MAC:0x%llx\n",
575 				     adapter->buffer_list_dma,
576 				     adapter->filter_list_dma,
577 				     rxq_desc.desc,
578 				     mac_address);
579 		rc = -ENONET;
580 		goto out_unmap_filter_list;
581 	}
582 
583 	for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) {
584 		if (!adapter->rx_buff_pool[i].active)
585 			continue;
586 		if (ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[i])) {
587 			netdev_err(netdev, "unable to alloc pool\n");
588 			adapter->rx_buff_pool[i].active = 0;
589 			rc = -ENOMEM;
590 			goto out_free_buffer_pools;
591 		}
592 	}
593 
594 	netdev_dbg(netdev, "registering irq 0x%x\n", netdev->irq);
595 	rc = request_irq(netdev->irq, ibmveth_interrupt, 0, netdev->name,
596 			 netdev);
597 	if (rc != 0) {
598 		netdev_err(netdev, "unable to request irq 0x%x, rc %d\n",
599 			   netdev->irq, rc);
600 		do {
601 			lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);
602 		} while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY));
603 
604 		goto out_free_buffer_pools;
605 	}
606 
607 	rc = -ENOMEM;
608 	adapter->bounce_buffer =
609 	    kmalloc(netdev->mtu + IBMVETH_BUFF_OH, GFP_KERNEL);
610 	if (!adapter->bounce_buffer)
611 		goto out_free_irq;
612 
613 	adapter->bounce_buffer_dma =
614 	    dma_map_single(&adapter->vdev->dev, adapter->bounce_buffer,
615 			   netdev->mtu + IBMVETH_BUFF_OH, DMA_BIDIRECTIONAL);
616 	if (dma_mapping_error(dev, adapter->bounce_buffer_dma)) {
617 		netdev_err(netdev, "unable to map bounce buffer\n");
618 		goto out_free_bounce_buffer;
619 	}
620 
621 	netdev_dbg(netdev, "initial replenish cycle\n");
622 	ibmveth_interrupt(netdev->irq, netdev);
623 
624 	netif_start_queue(netdev);
625 
626 	netdev_dbg(netdev, "open complete\n");
627 
628 	return 0;
629 
630 out_free_bounce_buffer:
631 	kfree(adapter->bounce_buffer);
632 out_free_irq:
633 	free_irq(netdev->irq, netdev);
634 out_free_buffer_pools:
635 	while (--i >= 0) {
636 		if (adapter->rx_buff_pool[i].active)
637 			ibmveth_free_buffer_pool(adapter,
638 						 &adapter->rx_buff_pool[i]);
639 	}
640 out_unmap_filter_list:
641 	dma_unmap_single(dev, adapter->filter_list_dma, 4096,
642 			 DMA_BIDIRECTIONAL);
643 out_unmap_buffer_list:
644 	dma_unmap_single(dev, adapter->buffer_list_dma, 4096,
645 			 DMA_BIDIRECTIONAL);
646 out_free_queue_mem:
647 	dma_free_coherent(dev, adapter->rx_queue.queue_len,
648 			  adapter->rx_queue.queue_addr,
649 			  adapter->rx_queue.queue_dma);
650 out_free_filter_list:
651 	free_page((unsigned long)adapter->filter_list_addr);
652 out_free_buffer_list:
653 	free_page((unsigned long)adapter->buffer_list_addr);
654 out:
655 	napi_disable(&adapter->napi);
656 	return rc;
657 }
658 
659 static int ibmveth_close(struct net_device *netdev)
660 {
661 	struct ibmveth_adapter *adapter = netdev_priv(netdev);
662 	struct device *dev = &adapter->vdev->dev;
663 	long lpar_rc;
664 	int i;
665 
666 	netdev_dbg(netdev, "close starting\n");
667 
668 	napi_disable(&adapter->napi);
669 
670 	if (!adapter->pool_config)
671 		netif_stop_queue(netdev);
672 
673 	h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
674 
675 	do {
676 		lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);
677 	} while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY));
678 
679 	if (lpar_rc != H_SUCCESS) {
680 		netdev_err(netdev, "h_free_logical_lan failed with %lx, "
681 			   "continuing with close\n", lpar_rc);
682 	}
683 
684 	free_irq(netdev->irq, netdev);
685 
686 	ibmveth_update_rx_no_buffer(adapter);
687 
688 	dma_unmap_single(dev, adapter->buffer_list_dma, 4096,
689 			 DMA_BIDIRECTIONAL);
690 	free_page((unsigned long)adapter->buffer_list_addr);
691 
692 	dma_unmap_single(dev, adapter->filter_list_dma, 4096,
693 			 DMA_BIDIRECTIONAL);
694 	free_page((unsigned long)adapter->filter_list_addr);
695 
696 	dma_free_coherent(dev, adapter->rx_queue.queue_len,
697 			  adapter->rx_queue.queue_addr,
698 			  adapter->rx_queue.queue_dma);
699 
700 	for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++)
701 		if (adapter->rx_buff_pool[i].active)
702 			ibmveth_free_buffer_pool(adapter,
703 						 &adapter->rx_buff_pool[i]);
704 
705 	dma_unmap_single(&adapter->vdev->dev, adapter->bounce_buffer_dma,
706 			 adapter->netdev->mtu + IBMVETH_BUFF_OH,
707 			 DMA_BIDIRECTIONAL);
708 	kfree(adapter->bounce_buffer);
709 
710 	netdev_dbg(netdev, "close complete\n");
711 
712 	return 0;
713 }
714 
715 static int ibmveth_set_link_ksettings(struct net_device *dev,
716 				      const struct ethtool_link_ksettings *cmd)
717 {
718 	struct ibmveth_adapter *adapter = netdev_priv(dev);
719 
720 	return ethtool_virtdev_set_link_ksettings(dev, cmd,
721 						  &adapter->speed,
722 						  &adapter->duplex);
723 }
724 
725 static int ibmveth_get_link_ksettings(struct net_device *dev,
726 				      struct ethtool_link_ksettings *cmd)
727 {
728 	struct ibmveth_adapter *adapter = netdev_priv(dev);
729 
730 	cmd->base.speed = adapter->speed;
731 	cmd->base.duplex = adapter->duplex;
732 	cmd->base.port = PORT_OTHER;
733 
734 	return 0;
735 }
736 
737 static void ibmveth_init_link_settings(struct net_device *dev)
738 {
739 	struct ibmveth_adapter *adapter = netdev_priv(dev);
740 
741 	adapter->speed = SPEED_1000;
742 	adapter->duplex = DUPLEX_FULL;
743 }
744 
745 static void netdev_get_drvinfo(struct net_device *dev,
746 			       struct ethtool_drvinfo *info)
747 {
748 	strlcpy(info->driver, ibmveth_driver_name, sizeof(info->driver));
749 	strlcpy(info->version, ibmveth_driver_version, sizeof(info->version));
750 }
751 
752 static netdev_features_t ibmveth_fix_features(struct net_device *dev,
753 	netdev_features_t features)
754 {
755 	/*
756 	 * Since the ibmveth firmware interface does not have the
757 	 * concept of separate tx/rx checksum offload enable, if rx
758 	 * checksum is disabled we also have to disable tx checksum
759 	 * offload. Once we disable rx checksum offload, we are no
760 	 * longer allowed to send tx buffers that are not properly
761 	 * checksummed.
762 	 */
763 
764 	if (!(features & NETIF_F_RXCSUM))
765 		features &= ~NETIF_F_CSUM_MASK;
766 
767 	return features;
768 }
769 
770 static int ibmveth_set_csum_offload(struct net_device *dev, u32 data)
771 {
772 	struct ibmveth_adapter *adapter = netdev_priv(dev);
773 	unsigned long set_attr, clr_attr, ret_attr;
774 	unsigned long set_attr6, clr_attr6;
775 	long ret, ret4, ret6;
776 	int rc1 = 0, rc2 = 0;
777 	int restart = 0;
778 
779 	if (netif_running(dev)) {
780 		restart = 1;
781 		adapter->pool_config = 1;
782 		ibmveth_close(dev);
783 		adapter->pool_config = 0;
784 	}
785 
786 	set_attr = 0;
787 	clr_attr = 0;
788 	set_attr6 = 0;
789 	clr_attr6 = 0;
790 
791 	if (data) {
792 		set_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM;
793 		set_attr6 = IBMVETH_ILLAN_IPV6_TCP_CSUM;
794 	} else {
795 		clr_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM;
796 		clr_attr6 = IBMVETH_ILLAN_IPV6_TCP_CSUM;
797 	}
798 
799 	ret = h_illan_attributes(adapter->vdev->unit_address, 0, 0, &ret_attr);
800 
801 	if (ret == H_SUCCESS &&
802 	    (ret_attr & IBMVETH_ILLAN_PADDED_PKT_CSUM)) {
803 		ret4 = h_illan_attributes(adapter->vdev->unit_address, clr_attr,
804 					 set_attr, &ret_attr);
805 
806 		if (ret4 != H_SUCCESS) {
807 			netdev_err(dev, "unable to change IPv4 checksum "
808 					"offload settings. %d rc=%ld\n",
809 					data, ret4);
810 
811 			h_illan_attributes(adapter->vdev->unit_address,
812 					   set_attr, clr_attr, &ret_attr);
813 
814 			if (data == 1)
815 				dev->features &= ~NETIF_F_IP_CSUM;
816 
817 		} else {
818 			adapter->fw_ipv4_csum_support = data;
819 		}
820 
821 		ret6 = h_illan_attributes(adapter->vdev->unit_address,
822 					 clr_attr6, set_attr6, &ret_attr);
823 
824 		if (ret6 != H_SUCCESS) {
825 			netdev_err(dev, "unable to change IPv6 checksum "
826 					"offload settings. %d rc=%ld\n",
827 					data, ret6);
828 
829 			h_illan_attributes(adapter->vdev->unit_address,
830 					   set_attr6, clr_attr6, &ret_attr);
831 
832 			if (data == 1)
833 				dev->features &= ~NETIF_F_IPV6_CSUM;
834 
835 		} else
836 			adapter->fw_ipv6_csum_support = data;
837 
838 		if (ret4 == H_SUCCESS || ret6 == H_SUCCESS)
839 			adapter->rx_csum = data;
840 		else
841 			rc1 = -EIO;
842 	} else {
843 		rc1 = -EIO;
844 		netdev_err(dev, "unable to change checksum offload settings."
845 				     " %d rc=%ld ret_attr=%lx\n", data, ret,
846 				     ret_attr);
847 	}
848 
849 	if (restart)
850 		rc2 = ibmveth_open(dev);
851 
852 	return rc1 ? rc1 : rc2;
853 }
854 
855 static int ibmveth_set_tso(struct net_device *dev, u32 data)
856 {
857 	struct ibmveth_adapter *adapter = netdev_priv(dev);
858 	unsigned long set_attr, clr_attr, ret_attr;
859 	long ret1, ret2;
860 	int rc1 = 0, rc2 = 0;
861 	int restart = 0;
862 
863 	if (netif_running(dev)) {
864 		restart = 1;
865 		adapter->pool_config = 1;
866 		ibmveth_close(dev);
867 		adapter->pool_config = 0;
868 	}
869 
870 	set_attr = 0;
871 	clr_attr = 0;
872 
873 	if (data)
874 		set_attr = IBMVETH_ILLAN_LRG_SR_ENABLED;
875 	else
876 		clr_attr = IBMVETH_ILLAN_LRG_SR_ENABLED;
877 
878 	ret1 = h_illan_attributes(adapter->vdev->unit_address, 0, 0, &ret_attr);
879 
880 	if (ret1 == H_SUCCESS && (ret_attr & IBMVETH_ILLAN_LRG_SND_SUPPORT) &&
881 	    !old_large_send) {
882 		ret2 = h_illan_attributes(adapter->vdev->unit_address, clr_attr,
883 					  set_attr, &ret_attr);
884 
885 		if (ret2 != H_SUCCESS) {
886 			netdev_err(dev, "unable to change tso settings. %d rc=%ld\n",
887 				   data, ret2);
888 
889 			h_illan_attributes(adapter->vdev->unit_address,
890 					   set_attr, clr_attr, &ret_attr);
891 
892 			if (data == 1)
893 				dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
894 			rc1 = -EIO;
895 
896 		} else {
897 			adapter->fw_large_send_support = data;
898 			adapter->large_send = data;
899 		}
900 	} else {
901 		/* Older firmware version of large send offload does not
902 		 * support tcp6/ipv6
903 		 */
904 		if (data == 1) {
905 			dev->features &= ~NETIF_F_TSO6;
906 			netdev_info(dev, "TSO feature requires all partitions to have updated driver");
907 		}
908 		adapter->large_send = data;
909 	}
910 
911 	if (restart)
912 		rc2 = ibmveth_open(dev);
913 
914 	return rc1 ? rc1 : rc2;
915 }
916 
917 static int ibmveth_set_features(struct net_device *dev,
918 	netdev_features_t features)
919 {
920 	struct ibmveth_adapter *adapter = netdev_priv(dev);
921 	int rx_csum = !!(features & NETIF_F_RXCSUM);
922 	int large_send = !!(features & (NETIF_F_TSO | NETIF_F_TSO6));
923 	int rc1 = 0, rc2 = 0;
924 
925 	if (rx_csum != adapter->rx_csum) {
926 		rc1 = ibmveth_set_csum_offload(dev, rx_csum);
927 		if (rc1 && !adapter->rx_csum)
928 			dev->features =
929 				features & ~(NETIF_F_CSUM_MASK |
930 					     NETIF_F_RXCSUM);
931 	}
932 
933 	if (large_send != adapter->large_send) {
934 		rc2 = ibmveth_set_tso(dev, large_send);
935 		if (rc2 && !adapter->large_send)
936 			dev->features =
937 				features & ~(NETIF_F_TSO | NETIF_F_TSO6);
938 	}
939 
940 	return rc1 ? rc1 : rc2;
941 }
942 
943 static void ibmveth_get_strings(struct net_device *dev, u32 stringset, u8 *data)
944 {
945 	int i;
946 
947 	if (stringset != ETH_SS_STATS)
948 		return;
949 
950 	for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++, data += ETH_GSTRING_LEN)
951 		memcpy(data, ibmveth_stats[i].name, ETH_GSTRING_LEN);
952 }
953 
954 static int ibmveth_get_sset_count(struct net_device *dev, int sset)
955 {
956 	switch (sset) {
957 	case ETH_SS_STATS:
958 		return ARRAY_SIZE(ibmveth_stats);
959 	default:
960 		return -EOPNOTSUPP;
961 	}
962 }
963 
964 static void ibmveth_get_ethtool_stats(struct net_device *dev,
965 				      struct ethtool_stats *stats, u64 *data)
966 {
967 	int i;
968 	struct ibmveth_adapter *adapter = netdev_priv(dev);
969 
970 	for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++)
971 		data[i] = IBMVETH_GET_STAT(adapter, ibmveth_stats[i].offset);
972 }
973 
974 static const struct ethtool_ops netdev_ethtool_ops = {
975 	.get_drvinfo		         = netdev_get_drvinfo,
976 	.get_link		         = ethtool_op_get_link,
977 	.get_strings		         = ibmveth_get_strings,
978 	.get_sset_count		         = ibmveth_get_sset_count,
979 	.get_ethtool_stats	         = ibmveth_get_ethtool_stats,
980 	.get_link_ksettings	         = ibmveth_get_link_ksettings,
981 	.set_link_ksettings              = ibmveth_set_link_ksettings,
982 };
983 
984 static int ibmveth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
985 {
986 	return -EOPNOTSUPP;
987 }
988 
989 static int ibmveth_send(struct ibmveth_adapter *adapter,
990 			union ibmveth_buf_desc *descs, unsigned long mss)
991 {
992 	unsigned long correlator;
993 	unsigned int retry_count;
994 	unsigned long ret;
995 
996 	/*
997 	 * The retry count sets a maximum for the number of broadcast and
998 	 * multicast destinations within the system.
999 	 */
1000 	retry_count = 1024;
1001 	correlator = 0;
1002 	do {
1003 		ret = h_send_logical_lan(adapter->vdev->unit_address,
1004 					     descs[0].desc, descs[1].desc,
1005 					     descs[2].desc, descs[3].desc,
1006 					     descs[4].desc, descs[5].desc,
1007 					     correlator, &correlator, mss,
1008 					     adapter->fw_large_send_support);
1009 	} while ((ret == H_BUSY) && (retry_count--));
1010 
1011 	if (ret != H_SUCCESS && ret != H_DROPPED) {
1012 		netdev_err(adapter->netdev, "tx: h_send_logical_lan failed "
1013 			   "with rc=%ld\n", ret);
1014 		return 1;
1015 	}
1016 
1017 	return 0;
1018 }
1019 
1020 static int ibmveth_is_packet_unsupported(struct sk_buff *skb,
1021 					 struct net_device *netdev)
1022 {
1023 	struct ethhdr *ether_header;
1024 	int ret = 0;
1025 
1026 	ether_header = eth_hdr(skb);
1027 
1028 	if (ether_addr_equal(ether_header->h_dest, netdev->dev_addr)) {
1029 		netdev_dbg(netdev, "veth doesn't support loopback packets, dropping packet.\n");
1030 		netdev->stats.tx_dropped++;
1031 		ret = -EOPNOTSUPP;
1032 	}
1033 
1034 	return ret;
1035 }
1036 
1037 static netdev_tx_t ibmveth_start_xmit(struct sk_buff *skb,
1038 				      struct net_device *netdev)
1039 {
1040 	struct ibmveth_adapter *adapter = netdev_priv(netdev);
1041 	unsigned int desc_flags;
1042 	union ibmveth_buf_desc descs[6];
1043 	int last, i;
1044 	int force_bounce = 0;
1045 	dma_addr_t dma_addr;
1046 	unsigned long mss = 0;
1047 
1048 	if (ibmveth_is_packet_unsupported(skb, netdev))
1049 		goto out;
1050 
1051 	/* veth doesn't handle frag_list, so linearize the skb.
1052 	 * When GRO is enabled SKB's can have frag_list.
1053 	 */
1054 	if (adapter->is_active_trunk &&
1055 	    skb_has_frag_list(skb) && __skb_linearize(skb)) {
1056 		netdev->stats.tx_dropped++;
1057 		goto out;
1058 	}
1059 
1060 	/*
1061 	 * veth handles a maximum of 6 segments including the header, so
1062 	 * we have to linearize the skb if there are more than this.
1063 	 */
1064 	if (skb_shinfo(skb)->nr_frags > 5 && __skb_linearize(skb)) {
1065 		netdev->stats.tx_dropped++;
1066 		goto out;
1067 	}
1068 
1069 	/* veth can't checksum offload UDP */
1070 	if (skb->ip_summed == CHECKSUM_PARTIAL &&
1071 	    ((skb->protocol == htons(ETH_P_IP) &&
1072 	      ip_hdr(skb)->protocol != IPPROTO_TCP) ||
1073 	     (skb->protocol == htons(ETH_P_IPV6) &&
1074 	      ipv6_hdr(skb)->nexthdr != IPPROTO_TCP)) &&
1075 	    skb_checksum_help(skb)) {
1076 
1077 		netdev_err(netdev, "tx: failed to checksum packet\n");
1078 		netdev->stats.tx_dropped++;
1079 		goto out;
1080 	}
1081 
1082 	desc_flags = IBMVETH_BUF_VALID;
1083 
1084 	if (skb->ip_summed == CHECKSUM_PARTIAL) {
1085 		unsigned char *buf = skb_transport_header(skb) +
1086 						skb->csum_offset;
1087 
1088 		desc_flags |= (IBMVETH_BUF_NO_CSUM | IBMVETH_BUF_CSUM_GOOD);
1089 
1090 		/* Need to zero out the checksum */
1091 		buf[0] = 0;
1092 		buf[1] = 0;
1093 
1094 		if (skb_is_gso(skb) && adapter->fw_large_send_support)
1095 			desc_flags |= IBMVETH_BUF_LRG_SND;
1096 	}
1097 
1098 retry_bounce:
1099 	memset(descs, 0, sizeof(descs));
1100 
1101 	/*
1102 	 * If a linear packet is below the rx threshold then
1103 	 * copy it into the static bounce buffer. This avoids the
1104 	 * cost of a TCE insert and remove.
1105 	 */
1106 	if (force_bounce || (!skb_is_nonlinear(skb) &&
1107 				(skb->len < tx_copybreak))) {
1108 		skb_copy_from_linear_data(skb, adapter->bounce_buffer,
1109 					  skb->len);
1110 
1111 		descs[0].fields.flags_len = desc_flags | skb->len;
1112 		descs[0].fields.address = adapter->bounce_buffer_dma;
1113 
1114 		if (ibmveth_send(adapter, descs, 0)) {
1115 			adapter->tx_send_failed++;
1116 			netdev->stats.tx_dropped++;
1117 		} else {
1118 			netdev->stats.tx_packets++;
1119 			netdev->stats.tx_bytes += skb->len;
1120 		}
1121 
1122 		goto out;
1123 	}
1124 
1125 	/* Map the header */
1126 	dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
1127 				  skb_headlen(skb), DMA_TO_DEVICE);
1128 	if (dma_mapping_error(&adapter->vdev->dev, dma_addr))
1129 		goto map_failed;
1130 
1131 	descs[0].fields.flags_len = desc_flags | skb_headlen(skb);
1132 	descs[0].fields.address = dma_addr;
1133 
1134 	/* Map the frags */
1135 	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1136 		const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1137 
1138 		dma_addr = skb_frag_dma_map(&adapter->vdev->dev, frag, 0,
1139 					    skb_frag_size(frag), DMA_TO_DEVICE);
1140 
1141 		if (dma_mapping_error(&adapter->vdev->dev, dma_addr))
1142 			goto map_failed_frags;
1143 
1144 		descs[i+1].fields.flags_len = desc_flags | skb_frag_size(frag);
1145 		descs[i+1].fields.address = dma_addr;
1146 	}
1147 
1148 	if (skb->ip_summed == CHECKSUM_PARTIAL && skb_is_gso(skb)) {
1149 		if (adapter->fw_large_send_support) {
1150 			mss = (unsigned long)skb_shinfo(skb)->gso_size;
1151 			adapter->tx_large_packets++;
1152 		} else if (!skb_is_gso_v6(skb)) {
1153 			/* Put -1 in the IP checksum to tell phyp it
1154 			 * is a largesend packet. Put the mss in
1155 			 * the TCP checksum.
1156 			 */
1157 			ip_hdr(skb)->check = 0xffff;
1158 			tcp_hdr(skb)->check =
1159 				cpu_to_be16(skb_shinfo(skb)->gso_size);
1160 			adapter->tx_large_packets++;
1161 		}
1162 	}
1163 
1164 	if (ibmveth_send(adapter, descs, mss)) {
1165 		adapter->tx_send_failed++;
1166 		netdev->stats.tx_dropped++;
1167 	} else {
1168 		netdev->stats.tx_packets++;
1169 		netdev->stats.tx_bytes += skb->len;
1170 	}
1171 
1172 	dma_unmap_single(&adapter->vdev->dev,
1173 			 descs[0].fields.address,
1174 			 descs[0].fields.flags_len & IBMVETH_BUF_LEN_MASK,
1175 			 DMA_TO_DEVICE);
1176 
1177 	for (i = 1; i < skb_shinfo(skb)->nr_frags + 1; i++)
1178 		dma_unmap_page(&adapter->vdev->dev, descs[i].fields.address,
1179 			       descs[i].fields.flags_len & IBMVETH_BUF_LEN_MASK,
1180 			       DMA_TO_DEVICE);
1181 
1182 out:
1183 	dev_consume_skb_any(skb);
1184 	return NETDEV_TX_OK;
1185 
1186 map_failed_frags:
1187 	last = i+1;
1188 	for (i = 1; i < last; i++)
1189 		dma_unmap_page(&adapter->vdev->dev, descs[i].fields.address,
1190 			       descs[i].fields.flags_len & IBMVETH_BUF_LEN_MASK,
1191 			       DMA_TO_DEVICE);
1192 
1193 	dma_unmap_single(&adapter->vdev->dev,
1194 			 descs[0].fields.address,
1195 			 descs[0].fields.flags_len & IBMVETH_BUF_LEN_MASK,
1196 			 DMA_TO_DEVICE);
1197 map_failed:
1198 	if (!firmware_has_feature(FW_FEATURE_CMO))
1199 		netdev_err(netdev, "tx: unable to map xmit buffer\n");
1200 	adapter->tx_map_failed++;
1201 	if (skb_linearize(skb)) {
1202 		netdev->stats.tx_dropped++;
1203 		goto out;
1204 	}
1205 	force_bounce = 1;
1206 	goto retry_bounce;
1207 }
1208 
1209 static void ibmveth_rx_mss_helper(struct sk_buff *skb, u16 mss, int lrg_pkt)
1210 {
1211 	struct tcphdr *tcph;
1212 	int offset = 0;
1213 	int hdr_len;
1214 
1215 	/* only TCP packets will be aggregated */
1216 	if (skb->protocol == htons(ETH_P_IP)) {
1217 		struct iphdr *iph = (struct iphdr *)skb->data;
1218 
1219 		if (iph->protocol == IPPROTO_TCP) {
1220 			offset = iph->ihl * 4;
1221 			skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
1222 		} else {
1223 			return;
1224 		}
1225 	} else if (skb->protocol == htons(ETH_P_IPV6)) {
1226 		struct ipv6hdr *iph6 = (struct ipv6hdr *)skb->data;
1227 
1228 		if (iph6->nexthdr == IPPROTO_TCP) {
1229 			offset = sizeof(struct ipv6hdr);
1230 			skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
1231 		} else {
1232 			return;
1233 		}
1234 	} else {
1235 		return;
1236 	}
1237 	/* if mss is not set through Large Packet bit/mss in rx buffer,
1238 	 * expect that the mss will be written to the tcp header checksum.
1239 	 */
1240 	tcph = (struct tcphdr *)(skb->data + offset);
1241 	if (lrg_pkt) {
1242 		skb_shinfo(skb)->gso_size = mss;
1243 	} else if (offset) {
1244 		skb_shinfo(skb)->gso_size = ntohs(tcph->check);
1245 		tcph->check = 0;
1246 	}
1247 
1248 	if (skb_shinfo(skb)->gso_size) {
1249 		hdr_len = offset + tcph->doff * 4;
1250 		skb_shinfo(skb)->gso_segs =
1251 				DIV_ROUND_UP(skb->len - hdr_len,
1252 					     skb_shinfo(skb)->gso_size);
1253 	}
1254 }
1255 
1256 static void ibmveth_rx_csum_helper(struct sk_buff *skb,
1257 				   struct ibmveth_adapter *adapter)
1258 {
1259 	struct iphdr *iph = NULL;
1260 	struct ipv6hdr *iph6 = NULL;
1261 	__be16 skb_proto = 0;
1262 	u16 iphlen = 0;
1263 	u16 iph_proto = 0;
1264 	u16 tcphdrlen = 0;
1265 
1266 	skb_proto = be16_to_cpu(skb->protocol);
1267 
1268 	if (skb_proto == ETH_P_IP) {
1269 		iph = (struct iphdr *)skb->data;
1270 
1271 		/* If the IP checksum is not offloaded and if the packet
1272 		 *  is large send, the checksum must be rebuilt.
1273 		 */
1274 		if (iph->check == 0xffff) {
1275 			iph->check = 0;
1276 			iph->check = ip_fast_csum((unsigned char *)iph,
1277 						  iph->ihl);
1278 		}
1279 
1280 		iphlen = iph->ihl * 4;
1281 		iph_proto = iph->protocol;
1282 	} else if (skb_proto == ETH_P_IPV6) {
1283 		iph6 = (struct ipv6hdr *)skb->data;
1284 		iphlen = sizeof(struct ipv6hdr);
1285 		iph_proto = iph6->nexthdr;
1286 	}
1287 
1288 	/* In OVS environment, when a flow is not cached, specifically for a
1289 	 * new TCP connection, the first packet information is passed up
1290 	 * the user space for finding a flow. During this process, OVS computes
1291 	 * checksum on the first packet when CHECKSUM_PARTIAL flag is set.
1292 	 *
1293 	 * Given that we zeroed out TCP checksum field in transmit path
1294 	 * (refer ibmveth_start_xmit routine) as we set "no checksum bit",
1295 	 * OVS computed checksum will be incorrect w/o TCP pseudo checksum
1296 	 * in the packet. This leads to OVS dropping the packet and hence
1297 	 * TCP retransmissions are seen.
1298 	 *
1299 	 * So, re-compute TCP pseudo header checksum.
1300 	 */
1301 	if (iph_proto == IPPROTO_TCP && adapter->is_active_trunk) {
1302 		struct tcphdr *tcph = (struct tcphdr *)(skb->data + iphlen);
1303 
1304 		tcphdrlen = skb->len - iphlen;
1305 
1306 		/* Recompute TCP pseudo header checksum */
1307 		if (skb_proto == ETH_P_IP)
1308 			tcph->check = ~csum_tcpudp_magic(iph->saddr,
1309 					iph->daddr, tcphdrlen, iph_proto, 0);
1310 		else if (skb_proto == ETH_P_IPV6)
1311 			tcph->check = ~csum_ipv6_magic(&iph6->saddr,
1312 					&iph6->daddr, tcphdrlen, iph_proto, 0);
1313 
1314 		/* Setup SKB fields for checksum offload */
1315 		skb_partial_csum_set(skb, iphlen,
1316 				     offsetof(struct tcphdr, check));
1317 		skb_reset_network_header(skb);
1318 	}
1319 }
1320 
1321 static int ibmveth_poll(struct napi_struct *napi, int budget)
1322 {
1323 	struct ibmveth_adapter *adapter =
1324 			container_of(napi, struct ibmveth_adapter, napi);
1325 	struct net_device *netdev = adapter->netdev;
1326 	int frames_processed = 0;
1327 	unsigned long lpar_rc;
1328 	u16 mss = 0;
1329 
1330 	while (frames_processed < budget) {
1331 		if (!ibmveth_rxq_pending_buffer(adapter))
1332 			break;
1333 
1334 		smp_rmb();
1335 		if (!ibmveth_rxq_buffer_valid(adapter)) {
1336 			wmb(); /* suggested by larson1 */
1337 			adapter->rx_invalid_buffer++;
1338 			netdev_dbg(netdev, "recycling invalid buffer\n");
1339 			ibmveth_rxq_recycle_buffer(adapter);
1340 		} else {
1341 			struct sk_buff *skb, *new_skb;
1342 			int length = ibmveth_rxq_frame_length(adapter);
1343 			int offset = ibmveth_rxq_frame_offset(adapter);
1344 			int csum_good = ibmveth_rxq_csum_good(adapter);
1345 			int lrg_pkt = ibmveth_rxq_large_packet(adapter);
1346 			__sum16 iph_check = 0;
1347 
1348 			skb = ibmveth_rxq_get_buffer(adapter);
1349 
1350 			/* if the large packet bit is set in the rx queue
1351 			 * descriptor, the mss will be written by PHYP eight
1352 			 * bytes from the start of the rx buffer, which is
1353 			 * skb->data at this stage
1354 			 */
1355 			if (lrg_pkt) {
1356 				__be64 *rxmss = (__be64 *)(skb->data + 8);
1357 
1358 				mss = (u16)be64_to_cpu(*rxmss);
1359 			}
1360 
1361 			new_skb = NULL;
1362 			if (length < rx_copybreak)
1363 				new_skb = netdev_alloc_skb(netdev, length);
1364 
1365 			if (new_skb) {
1366 				skb_copy_to_linear_data(new_skb,
1367 							skb->data + offset,
1368 							length);
1369 				if (rx_flush)
1370 					ibmveth_flush_buffer(skb->data,
1371 						length + offset);
1372 				if (!ibmveth_rxq_recycle_buffer(adapter))
1373 					kfree_skb(skb);
1374 				skb = new_skb;
1375 			} else {
1376 				ibmveth_rxq_harvest_buffer(adapter);
1377 				skb_reserve(skb, offset);
1378 			}
1379 
1380 			skb_put(skb, length);
1381 			skb->protocol = eth_type_trans(skb, netdev);
1382 
1383 			/* PHYP without PLSO support places a -1 in the ip
1384 			 * checksum for large send frames.
1385 			 */
1386 			if (skb->protocol == cpu_to_be16(ETH_P_IP)) {
1387 				struct iphdr *iph = (struct iphdr *)skb->data;
1388 
1389 				iph_check = iph->check;
1390 			}
1391 
1392 			if ((length > netdev->mtu + ETH_HLEN) ||
1393 			    lrg_pkt || iph_check == 0xffff) {
1394 				ibmveth_rx_mss_helper(skb, mss, lrg_pkt);
1395 				adapter->rx_large_packets++;
1396 			}
1397 
1398 			if (csum_good) {
1399 				skb->ip_summed = CHECKSUM_UNNECESSARY;
1400 				ibmveth_rx_csum_helper(skb, adapter);
1401 			}
1402 
1403 			napi_gro_receive(napi, skb);	/* send it up */
1404 
1405 			netdev->stats.rx_packets++;
1406 			netdev->stats.rx_bytes += length;
1407 			frames_processed++;
1408 		}
1409 	}
1410 
1411 	ibmveth_replenish_task(adapter);
1412 
1413 	if (frames_processed < budget) {
1414 		napi_complete_done(napi, frames_processed);
1415 
1416 		/* We think we are done - reenable interrupts,
1417 		 * then check once more to make sure we are done.
1418 		 */
1419 		lpar_rc = h_vio_signal(adapter->vdev->unit_address,
1420 				       VIO_IRQ_ENABLE);
1421 
1422 		BUG_ON(lpar_rc != H_SUCCESS);
1423 
1424 		if (ibmveth_rxq_pending_buffer(adapter) &&
1425 		    napi_reschedule(napi)) {
1426 			lpar_rc = h_vio_signal(adapter->vdev->unit_address,
1427 					       VIO_IRQ_DISABLE);
1428 		}
1429 	}
1430 
1431 	return frames_processed;
1432 }
1433 
1434 static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance)
1435 {
1436 	struct net_device *netdev = dev_instance;
1437 	struct ibmveth_adapter *adapter = netdev_priv(netdev);
1438 	unsigned long lpar_rc;
1439 
1440 	if (napi_schedule_prep(&adapter->napi)) {
1441 		lpar_rc = h_vio_signal(adapter->vdev->unit_address,
1442 				       VIO_IRQ_DISABLE);
1443 		BUG_ON(lpar_rc != H_SUCCESS);
1444 		__napi_schedule(&adapter->napi);
1445 	}
1446 	return IRQ_HANDLED;
1447 }
1448 
1449 static void ibmveth_set_multicast_list(struct net_device *netdev)
1450 {
1451 	struct ibmveth_adapter *adapter = netdev_priv(netdev);
1452 	unsigned long lpar_rc;
1453 
1454 	if ((netdev->flags & IFF_PROMISC) ||
1455 	    (netdev_mc_count(netdev) > adapter->mcastFilterSize)) {
1456 		lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
1457 					   IbmVethMcastEnableRecv |
1458 					   IbmVethMcastDisableFiltering,
1459 					   0);
1460 		if (lpar_rc != H_SUCCESS) {
1461 			netdev_err(netdev, "h_multicast_ctrl rc=%ld when "
1462 				   "entering promisc mode\n", lpar_rc);
1463 		}
1464 	} else {
1465 		struct netdev_hw_addr *ha;
1466 		/* clear the filter table & disable filtering */
1467 		lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
1468 					   IbmVethMcastEnableRecv |
1469 					   IbmVethMcastDisableFiltering |
1470 					   IbmVethMcastClearFilterTable,
1471 					   0);
1472 		if (lpar_rc != H_SUCCESS) {
1473 			netdev_err(netdev, "h_multicast_ctrl rc=%ld when "
1474 				   "attempting to clear filter table\n",
1475 				   lpar_rc);
1476 		}
1477 		/* add the addresses to the filter table */
1478 		netdev_for_each_mc_addr(ha, netdev) {
1479 			/* add the multicast address to the filter table */
1480 			u64 mcast_addr;
1481 			mcast_addr = ibmveth_encode_mac_addr(ha->addr);
1482 			lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
1483 						   IbmVethMcastAddFilter,
1484 						   mcast_addr);
1485 			if (lpar_rc != H_SUCCESS) {
1486 				netdev_err(netdev, "h_multicast_ctrl rc=%ld "
1487 					   "when adding an entry to the filter "
1488 					   "table\n", lpar_rc);
1489 			}
1490 		}
1491 
1492 		/* re-enable filtering */
1493 		lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
1494 					   IbmVethMcastEnableFiltering,
1495 					   0);
1496 		if (lpar_rc != H_SUCCESS) {
1497 			netdev_err(netdev, "h_multicast_ctrl rc=%ld when "
1498 				   "enabling filtering\n", lpar_rc);
1499 		}
1500 	}
1501 }
1502 
1503 static int ibmveth_change_mtu(struct net_device *dev, int new_mtu)
1504 {
1505 	struct ibmveth_adapter *adapter = netdev_priv(dev);
1506 	struct vio_dev *viodev = adapter->vdev;
1507 	int new_mtu_oh = new_mtu + IBMVETH_BUFF_OH;
1508 	int i, rc;
1509 	int need_restart = 0;
1510 
1511 	for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++)
1512 		if (new_mtu_oh <= adapter->rx_buff_pool[i].buff_size)
1513 			break;
1514 
1515 	if (i == IBMVETH_NUM_BUFF_POOLS)
1516 		return -EINVAL;
1517 
1518 	/* Deactivate all the buffer pools so that the next loop can activate
1519 	   only the buffer pools necessary to hold the new MTU */
1520 	if (netif_running(adapter->netdev)) {
1521 		need_restart = 1;
1522 		adapter->pool_config = 1;
1523 		ibmveth_close(adapter->netdev);
1524 		adapter->pool_config = 0;
1525 	}
1526 
1527 	/* Look for an active buffer pool that can hold the new MTU */
1528 	for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) {
1529 		adapter->rx_buff_pool[i].active = 1;
1530 
1531 		if (new_mtu_oh <= adapter->rx_buff_pool[i].buff_size) {
1532 			dev->mtu = new_mtu;
1533 			vio_cmo_set_dev_desired(viodev,
1534 						ibmveth_get_desired_dma
1535 						(viodev));
1536 			if (need_restart) {
1537 				return ibmveth_open(adapter->netdev);
1538 			}
1539 			return 0;
1540 		}
1541 	}
1542 
1543 	if (need_restart && (rc = ibmveth_open(adapter->netdev)))
1544 		return rc;
1545 
1546 	return -EINVAL;
1547 }
1548 
1549 #ifdef CONFIG_NET_POLL_CONTROLLER
1550 static void ibmveth_poll_controller(struct net_device *dev)
1551 {
1552 	ibmveth_replenish_task(netdev_priv(dev));
1553 	ibmveth_interrupt(dev->irq, dev);
1554 }
1555 #endif
1556 
1557 /**
1558  * ibmveth_get_desired_dma - Calculate IO memory desired by the driver
1559  *
1560  * @vdev: struct vio_dev for the device whose desired IO mem is to be returned
1561  *
1562  * Return value:
1563  *	Number of bytes of IO data the driver will need to perform well.
1564  */
1565 static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev)
1566 {
1567 	struct net_device *netdev = dev_get_drvdata(&vdev->dev);
1568 	struct ibmveth_adapter *adapter;
1569 	struct iommu_table *tbl;
1570 	unsigned long ret;
1571 	int i;
1572 	int rxqentries = 1;
1573 
1574 	tbl = get_iommu_table_base(&vdev->dev);
1575 
1576 	/* netdev inits at probe time along with the structures we need below*/
1577 	if (netdev == NULL)
1578 		return IOMMU_PAGE_ALIGN(IBMVETH_IO_ENTITLEMENT_DEFAULT, tbl);
1579 
1580 	adapter = netdev_priv(netdev);
1581 
1582 	ret = IBMVETH_BUFF_LIST_SIZE + IBMVETH_FILT_LIST_SIZE;
1583 	ret += IOMMU_PAGE_ALIGN(netdev->mtu, tbl);
1584 
1585 	for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) {
1586 		/* add the size of the active receive buffers */
1587 		if (adapter->rx_buff_pool[i].active)
1588 			ret +=
1589 			    adapter->rx_buff_pool[i].size *
1590 			    IOMMU_PAGE_ALIGN(adapter->rx_buff_pool[i].
1591 					     buff_size, tbl);
1592 		rxqentries += adapter->rx_buff_pool[i].size;
1593 	}
1594 	/* add the size of the receive queue entries */
1595 	ret += IOMMU_PAGE_ALIGN(
1596 		rxqentries * sizeof(struct ibmveth_rx_q_entry), tbl);
1597 
1598 	return ret;
1599 }
1600 
1601 static int ibmveth_set_mac_addr(struct net_device *dev, void *p)
1602 {
1603 	struct ibmveth_adapter *adapter = netdev_priv(dev);
1604 	struct sockaddr *addr = p;
1605 	u64 mac_address;
1606 	int rc;
1607 
1608 	if (!is_valid_ether_addr(addr->sa_data))
1609 		return -EADDRNOTAVAIL;
1610 
1611 	mac_address = ibmveth_encode_mac_addr(addr->sa_data);
1612 	rc = h_change_logical_lan_mac(adapter->vdev->unit_address, mac_address);
1613 	if (rc) {
1614 		netdev_err(adapter->netdev, "h_change_logical_lan_mac failed with rc=%d\n", rc);
1615 		return rc;
1616 	}
1617 
1618 	ether_addr_copy(dev->dev_addr, addr->sa_data);
1619 
1620 	return 0;
1621 }
1622 
1623 static const struct net_device_ops ibmveth_netdev_ops = {
1624 	.ndo_open		= ibmveth_open,
1625 	.ndo_stop		= ibmveth_close,
1626 	.ndo_start_xmit		= ibmveth_start_xmit,
1627 	.ndo_set_rx_mode	= ibmveth_set_multicast_list,
1628 	.ndo_do_ioctl		= ibmveth_ioctl,
1629 	.ndo_change_mtu		= ibmveth_change_mtu,
1630 	.ndo_fix_features	= ibmveth_fix_features,
1631 	.ndo_set_features	= ibmveth_set_features,
1632 	.ndo_validate_addr	= eth_validate_addr,
1633 	.ndo_set_mac_address    = ibmveth_set_mac_addr,
1634 #ifdef CONFIG_NET_POLL_CONTROLLER
1635 	.ndo_poll_controller	= ibmveth_poll_controller,
1636 #endif
1637 };
1638 
1639 static int ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)
1640 {
1641 	int rc, i, mac_len;
1642 	struct net_device *netdev;
1643 	struct ibmveth_adapter *adapter;
1644 	unsigned char *mac_addr_p;
1645 	__be32 *mcastFilterSize_p;
1646 	long ret;
1647 	unsigned long ret_attr;
1648 
1649 	dev_dbg(&dev->dev, "entering ibmveth_probe for UA 0x%x\n",
1650 		dev->unit_address);
1651 
1652 	mac_addr_p = (unsigned char *)vio_get_attribute(dev, VETH_MAC_ADDR,
1653 							&mac_len);
1654 	if (!mac_addr_p) {
1655 		dev_err(&dev->dev, "Can't find VETH_MAC_ADDR attribute\n");
1656 		return -EINVAL;
1657 	}
1658 	/* Workaround for old/broken pHyp */
1659 	if (mac_len == 8)
1660 		mac_addr_p += 2;
1661 	else if (mac_len != 6) {
1662 		dev_err(&dev->dev, "VETH_MAC_ADDR attribute wrong len %d\n",
1663 			mac_len);
1664 		return -EINVAL;
1665 	}
1666 
1667 	mcastFilterSize_p = (__be32 *)vio_get_attribute(dev,
1668 							VETH_MCAST_FILTER_SIZE,
1669 							NULL);
1670 	if (!mcastFilterSize_p) {
1671 		dev_err(&dev->dev, "Can't find VETH_MCAST_FILTER_SIZE "
1672 			"attribute\n");
1673 		return -EINVAL;
1674 	}
1675 
1676 	netdev = alloc_etherdev(sizeof(struct ibmveth_adapter));
1677 
1678 	if (!netdev)
1679 		return -ENOMEM;
1680 
1681 	adapter = netdev_priv(netdev);
1682 	dev_set_drvdata(&dev->dev, netdev);
1683 
1684 	adapter->vdev = dev;
1685 	adapter->netdev = netdev;
1686 	adapter->mcastFilterSize = be32_to_cpu(*mcastFilterSize_p);
1687 	adapter->pool_config = 0;
1688 	ibmveth_init_link_settings(netdev);
1689 
1690 	netif_napi_add(netdev, &adapter->napi, ibmveth_poll, 16);
1691 
1692 	netdev->irq = dev->irq;
1693 	netdev->netdev_ops = &ibmveth_netdev_ops;
1694 	netdev->ethtool_ops = &netdev_ethtool_ops;
1695 	SET_NETDEV_DEV(netdev, &dev->dev);
1696 	netdev->hw_features = NETIF_F_SG;
1697 	if (vio_get_attribute(dev, "ibm,illan-options", NULL) != NULL) {
1698 		netdev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
1699 				       NETIF_F_RXCSUM;
1700 	}
1701 
1702 	netdev->features |= netdev->hw_features;
1703 
1704 	ret = h_illan_attributes(adapter->vdev->unit_address, 0, 0, &ret_attr);
1705 
1706 	/* If running older firmware, TSO should not be enabled by default */
1707 	if (ret == H_SUCCESS && (ret_attr & IBMVETH_ILLAN_LRG_SND_SUPPORT) &&
1708 	    !old_large_send) {
1709 		netdev->hw_features |= NETIF_F_TSO | NETIF_F_TSO6;
1710 		netdev->features |= netdev->hw_features;
1711 	} else {
1712 		netdev->hw_features |= NETIF_F_TSO;
1713 	}
1714 
1715 	adapter->is_active_trunk = false;
1716 	if (ret == H_SUCCESS && (ret_attr & IBMVETH_ILLAN_ACTIVE_TRUNK)) {
1717 		adapter->is_active_trunk = true;
1718 		netdev->hw_features |= NETIF_F_FRAGLIST;
1719 		netdev->features |= NETIF_F_FRAGLIST;
1720 	}
1721 
1722 	netdev->min_mtu = IBMVETH_MIN_MTU;
1723 	netdev->max_mtu = ETH_MAX_MTU - IBMVETH_BUFF_OH;
1724 
1725 	memcpy(netdev->dev_addr, mac_addr_p, ETH_ALEN);
1726 
1727 	if (firmware_has_feature(FW_FEATURE_CMO))
1728 		memcpy(pool_count, pool_count_cmo, sizeof(pool_count));
1729 
1730 	for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) {
1731 		struct kobject *kobj = &adapter->rx_buff_pool[i].kobj;
1732 		int error;
1733 
1734 		ibmveth_init_buffer_pool(&adapter->rx_buff_pool[i], i,
1735 					 pool_count[i], pool_size[i],
1736 					 pool_active[i]);
1737 		error = kobject_init_and_add(kobj, &ktype_veth_pool,
1738 					     &dev->dev.kobj, "pool%d", i);
1739 		if (!error)
1740 			kobject_uevent(kobj, KOBJ_ADD);
1741 	}
1742 
1743 	netdev_dbg(netdev, "adapter @ 0x%p\n", adapter);
1744 	netdev_dbg(netdev, "registering netdev...\n");
1745 
1746 	ibmveth_set_features(netdev, netdev->features);
1747 
1748 	rc = register_netdev(netdev);
1749 
1750 	if (rc) {
1751 		netdev_dbg(netdev, "failed to register netdev rc=%d\n", rc);
1752 		free_netdev(netdev);
1753 		return rc;
1754 	}
1755 
1756 	netdev_dbg(netdev, "registered\n");
1757 
1758 	return 0;
1759 }
1760 
1761 static int ibmveth_remove(struct vio_dev *dev)
1762 {
1763 	struct net_device *netdev = dev_get_drvdata(&dev->dev);
1764 	struct ibmveth_adapter *adapter = netdev_priv(netdev);
1765 	int i;
1766 
1767 	for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++)
1768 		kobject_put(&adapter->rx_buff_pool[i].kobj);
1769 
1770 	unregister_netdev(netdev);
1771 
1772 	free_netdev(netdev);
1773 	dev_set_drvdata(&dev->dev, NULL);
1774 
1775 	return 0;
1776 }
1777 
1778 static struct attribute veth_active_attr;
1779 static struct attribute veth_num_attr;
1780 static struct attribute veth_size_attr;
1781 
1782 static ssize_t veth_pool_show(struct kobject *kobj,
1783 			      struct attribute *attr, char *buf)
1784 {
1785 	struct ibmveth_buff_pool *pool = container_of(kobj,
1786 						      struct ibmveth_buff_pool,
1787 						      kobj);
1788 
1789 	if (attr == &veth_active_attr)
1790 		return sprintf(buf, "%d\n", pool->active);
1791 	else if (attr == &veth_num_attr)
1792 		return sprintf(buf, "%d\n", pool->size);
1793 	else if (attr == &veth_size_attr)
1794 		return sprintf(buf, "%d\n", pool->buff_size);
1795 	return 0;
1796 }
1797 
1798 static ssize_t veth_pool_store(struct kobject *kobj, struct attribute *attr,
1799 			       const char *buf, size_t count)
1800 {
1801 	struct ibmveth_buff_pool *pool = container_of(kobj,
1802 						      struct ibmveth_buff_pool,
1803 						      kobj);
1804 	struct net_device *netdev = dev_get_drvdata(
1805 	    container_of(kobj->parent, struct device, kobj));
1806 	struct ibmveth_adapter *adapter = netdev_priv(netdev);
1807 	long value = simple_strtol(buf, NULL, 10);
1808 	long rc;
1809 
1810 	if (attr == &veth_active_attr) {
1811 		if (value && !pool->active) {
1812 			if (netif_running(netdev)) {
1813 				if (ibmveth_alloc_buffer_pool(pool)) {
1814 					netdev_err(netdev,
1815 						   "unable to alloc pool\n");
1816 					return -ENOMEM;
1817 				}
1818 				pool->active = 1;
1819 				adapter->pool_config = 1;
1820 				ibmveth_close(netdev);
1821 				adapter->pool_config = 0;
1822 				if ((rc = ibmveth_open(netdev)))
1823 					return rc;
1824 			} else {
1825 				pool->active = 1;
1826 			}
1827 		} else if (!value && pool->active) {
1828 			int mtu = netdev->mtu + IBMVETH_BUFF_OH;
1829 			int i;
1830 			/* Make sure there is a buffer pool with buffers that
1831 			   can hold a packet of the size of the MTU */
1832 			for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) {
1833 				if (pool == &adapter->rx_buff_pool[i])
1834 					continue;
1835 				if (!adapter->rx_buff_pool[i].active)
1836 					continue;
1837 				if (mtu <= adapter->rx_buff_pool[i].buff_size)
1838 					break;
1839 			}
1840 
1841 			if (i == IBMVETH_NUM_BUFF_POOLS) {
1842 				netdev_err(netdev, "no active pool >= MTU\n");
1843 				return -EPERM;
1844 			}
1845 
1846 			if (netif_running(netdev)) {
1847 				adapter->pool_config = 1;
1848 				ibmveth_close(netdev);
1849 				pool->active = 0;
1850 				adapter->pool_config = 0;
1851 				if ((rc = ibmveth_open(netdev)))
1852 					return rc;
1853 			}
1854 			pool->active = 0;
1855 		}
1856 	} else if (attr == &veth_num_attr) {
1857 		if (value <= 0 || value > IBMVETH_MAX_POOL_COUNT) {
1858 			return -EINVAL;
1859 		} else {
1860 			if (netif_running(netdev)) {
1861 				adapter->pool_config = 1;
1862 				ibmveth_close(netdev);
1863 				adapter->pool_config = 0;
1864 				pool->size = value;
1865 				if ((rc = ibmveth_open(netdev)))
1866 					return rc;
1867 			} else {
1868 				pool->size = value;
1869 			}
1870 		}
1871 	} else if (attr == &veth_size_attr) {
1872 		if (value <= IBMVETH_BUFF_OH || value > IBMVETH_MAX_BUF_SIZE) {
1873 			return -EINVAL;
1874 		} else {
1875 			if (netif_running(netdev)) {
1876 				adapter->pool_config = 1;
1877 				ibmveth_close(netdev);
1878 				adapter->pool_config = 0;
1879 				pool->buff_size = value;
1880 				if ((rc = ibmveth_open(netdev)))
1881 					return rc;
1882 			} else {
1883 				pool->buff_size = value;
1884 			}
1885 		}
1886 	}
1887 
1888 	/* kick the interrupt handler to allocate/deallocate pools */
1889 	ibmveth_interrupt(netdev->irq, netdev);
1890 	return count;
1891 }
1892 
1893 
1894 #define ATTR(_name, _mode)				\
1895 	struct attribute veth_##_name##_attr = {	\
1896 	.name = __stringify(_name), .mode = _mode,	\
1897 	};
1898 
1899 static ATTR(active, 0644);
1900 static ATTR(num, 0644);
1901 static ATTR(size, 0644);
1902 
1903 static struct attribute *veth_pool_attrs[] = {
1904 	&veth_active_attr,
1905 	&veth_num_attr,
1906 	&veth_size_attr,
1907 	NULL,
1908 };
1909 
1910 static const struct sysfs_ops veth_pool_ops = {
1911 	.show   = veth_pool_show,
1912 	.store  = veth_pool_store,
1913 };
1914 
1915 static struct kobj_type ktype_veth_pool = {
1916 	.release        = NULL,
1917 	.sysfs_ops      = &veth_pool_ops,
1918 	.default_attrs  = veth_pool_attrs,
1919 };
1920 
1921 static int ibmveth_resume(struct device *dev)
1922 {
1923 	struct net_device *netdev = dev_get_drvdata(dev);
1924 	ibmveth_interrupt(netdev->irq, netdev);
1925 	return 0;
1926 }
1927 
1928 static const struct vio_device_id ibmveth_device_table[] = {
1929 	{ "network", "IBM,l-lan"},
1930 	{ "", "" }
1931 };
1932 MODULE_DEVICE_TABLE(vio, ibmveth_device_table);
1933 
1934 static const struct dev_pm_ops ibmveth_pm_ops = {
1935 	.resume = ibmveth_resume
1936 };
1937 
1938 static struct vio_driver ibmveth_driver = {
1939 	.id_table	= ibmveth_device_table,
1940 	.probe		= ibmveth_probe,
1941 	.remove		= ibmveth_remove,
1942 	.get_desired_dma = ibmveth_get_desired_dma,
1943 	.name		= ibmveth_driver_name,
1944 	.pm		= &ibmveth_pm_ops,
1945 };
1946 
1947 static int __init ibmveth_module_init(void)
1948 {
1949 	printk(KERN_DEBUG "%s: %s %s\n", ibmveth_driver_name,
1950 	       ibmveth_driver_string, ibmveth_driver_version);
1951 
1952 	return vio_register_driver(&ibmveth_driver);
1953 }
1954 
1955 static void __exit ibmveth_module_exit(void)
1956 {
1957 	vio_unregister_driver(&ibmveth_driver);
1958 }
1959 
1960 module_init(ibmveth_module_init);
1961 module_exit(ibmveth_module_exit);
1962