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