]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/net/ethernet/ibm/ibmvnic.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ibmvnic: Use common counter for capabilities checks
[mirror_ubuntu-artful-kernel.git] / drivers / net / ethernet / ibm / ibmvnic.c
CommitLineData
032c5e82
TF		 1/**************************************************************************/
2/* */
3/* IBM System i and System p Virtual NIC Device Driver */
4/* Copyright (C) 2014 IBM Corp. */
5/* Santiago Leon (santi_leon@yahoo.com) */
6/* Thomas Falcon (tlfalcon@linux.vnet.ibm.com) */
7/* John Allen (jallen@linux.vnet.ibm.com) */
8/* */
9/* This program is free software; you can redistribute it and/or modify */
10/* it under the terms of the GNU General Public License as published by */
11/* the Free Software Foundation; either version 2 of the License, or */
12/* (at your option) any later version. */
13/* */
14/* This program is distributed in the hope that it will be useful, */
15/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
16/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
17/* GNU General Public License for more details. */
18/* */
19/* You should have received a copy of the GNU General Public License */
20/* along with this program. */
21/* */
22/* This module contains the implementation of a virtual ethernet device */
23/* for use with IBM i/p Series LPAR Linux. It utilizes the logical LAN */
24/* option of the RS/6000 Platform Architecture to interface with virtual */
25/* ethernet NICs that are presented to the partition by the hypervisor. */
26/* */
27/* Messages are passed between the VNIC driver and the VNIC server using */
28/* Command/Response Queues (CRQs) and sub CRQs (sCRQs). CRQs are used to */
29/* issue and receive commands that initiate communication with the server */
30/* on driver initialization. Sub CRQs (sCRQs) are similar to CRQs, but */
31/* are used by the driver to notify the server that a packet is */
32/* ready for transmission or that a buffer has been added to receive a */
33/* packet. Subsequently, sCRQs are used by the server to notify the */
34/* driver that a packet transmission has been completed or that a packet */
35/* has been received and placed in a waiting buffer. */
36/* */
37/* In lieu of a more conventional "on-the-fly" DMA mapping strategy in */
38/* which skbs are DMA mapped and immediately unmapped when the transmit */
39/* or receive has been completed, the VNIC driver is required to use */
40/* "long term mapping". This entails that large, continuous DMA mapped */
41/* buffers are allocated on driver initialization and these buffers are */
42/* then continuously reused to pass skbs to and from the VNIC server. */
43/* */
44/**************************************************************************/
45
46#include <linux/module.h>
47#include <linux/moduleparam.h>
48#include <linux/types.h>
49#include <linux/errno.h>
50#include <linux/completion.h>
51#include <linux/ioport.h>
52#include <linux/dma-mapping.h>
53#include <linux/kernel.h>
54#include <linux/netdevice.h>
55#include <linux/etherdevice.h>
56#include <linux/skbuff.h>
57#include <linux/init.h>
58#include <linux/delay.h>
59#include <linux/mm.h>
60#include <linux/ethtool.h>
61#include <linux/proc_fs.h>
62#include <linux/in.h>
63#include <linux/ip.h>
ad7775dc 64#include <linux/ipv6.h>
032c5e82
TF		 65#include <linux/irq.h>
66#include <linux/kthread.h>
67#include <linux/seq_file.h>
68#include <linux/debugfs.h>
69#include <linux/interrupt.h>
70#include <net/net_namespace.h>
71#include <asm/hvcall.h>
72#include <linux/atomic.h>
73#include <asm/vio.h>
74#include <asm/iommu.h>
75#include <linux/uaccess.h>
76#include <asm/firmware.h>
65dc6891 77#include <linux/workqueue.h>
032c5e82
TF		 78
79#include "ibmvnic.h"
80
81static const char ibmvnic_driver_name[] = "ibmvnic";
82static const char ibmvnic_driver_string[] = "IBM System i/p Virtual NIC Driver";
83
84MODULE_AUTHOR("Santiago Leon <santi_leon@yahoo.com>");
85MODULE_DESCRIPTION("IBM System i/p Virtual NIC Driver");
86MODULE_LICENSE("GPL");
87MODULE_VERSION(IBMVNIC_DRIVER_VERSION);
88
89static int ibmvnic_version = IBMVNIC_INITIAL_VERSION;
90static int ibmvnic_remove(struct vio_dev *);
91static void release_sub_crqs(struct ibmvnic_adapter *);
ea22d51a 92static void release_sub_crqs_no_irqs(struct ibmvnic_adapter *);
032c5e82
TF		 93static int ibmvnic_reset_crq(struct ibmvnic_adapter *);
94static int ibmvnic_send_crq_init(struct ibmvnic_adapter *);
95static int ibmvnic_reenable_crq_queue(struct ibmvnic_adapter *);
96static int ibmvnic_send_crq(struct ibmvnic_adapter *, union ibmvnic_crq *);
97static int send_subcrq(struct ibmvnic_adapter *adapter, u64 remote_handle,
98 union sub_crq *sub_crq);
ad7775dc 99static int send_subcrq_indirect(struct ibmvnic_adapter *, u64, u64, u64);
032c5e82
TF		 100static irqreturn_t ibmvnic_interrupt_rx(int irq, void *instance);
101static int enable_scrq_irq(struct ibmvnic_adapter *,
102 struct ibmvnic_sub_crq_queue *);
103static int disable_scrq_irq(struct ibmvnic_adapter *,
104 struct ibmvnic_sub_crq_queue *);
105static int pending_scrq(struct ibmvnic_adapter *,
106 struct ibmvnic_sub_crq_queue *);
107static union sub_crq *ibmvnic_next_scrq(struct ibmvnic_adapter *,
108 struct ibmvnic_sub_crq_queue *);
109static int ibmvnic_poll(struct napi_struct *napi, int data);
110static void send_map_query(struct ibmvnic_adapter *adapter);
111static void send_request_map(struct ibmvnic_adapter *, dma_addr_t, __be32, u8);
112static void send_request_unmap(struct ibmvnic_adapter *, u8);
113
114struct ibmvnic_stat {
115 char name[ETH_GSTRING_LEN];
116 int offset;
117};
118
119#define IBMVNIC_STAT_OFF(stat) (offsetof(struct ibmvnic_adapter, stats) + \
120 offsetof(struct ibmvnic_statistics, stat))
121#define IBMVNIC_GET_STAT(a, off) (*((u64 *)(((unsigned long)(a)) + off)))
122
123static const struct ibmvnic_stat ibmvnic_stats[] = {
124 {"rx_packets", IBMVNIC_STAT_OFF(rx_packets)},
125 {"rx_bytes", IBMVNIC_STAT_OFF(rx_bytes)},
126 {"tx_packets", IBMVNIC_STAT_OFF(tx_packets)},
127 {"tx_bytes", IBMVNIC_STAT_OFF(tx_bytes)},
128 {"ucast_tx_packets", IBMVNIC_STAT_OFF(ucast_tx_packets)},
129 {"ucast_rx_packets", IBMVNIC_STAT_OFF(ucast_rx_packets)},
130 {"mcast_tx_packets", IBMVNIC_STAT_OFF(mcast_tx_packets)},
131 {"mcast_rx_packets", IBMVNIC_STAT_OFF(mcast_rx_packets)},
132 {"bcast_tx_packets", IBMVNIC_STAT_OFF(bcast_tx_packets)},
133 {"bcast_rx_packets", IBMVNIC_STAT_OFF(bcast_rx_packets)},
134 {"align_errors", IBMVNIC_STAT_OFF(align_errors)},
135 {"fcs_errors", IBMVNIC_STAT_OFF(fcs_errors)},
136 {"single_collision_frames", IBMVNIC_STAT_OFF(single_collision_frames)},
137 {"multi_collision_frames", IBMVNIC_STAT_OFF(multi_collision_frames)},
138 {"sqe_test_errors", IBMVNIC_STAT_OFF(sqe_test_errors)},
139 {"deferred_tx", IBMVNIC_STAT_OFF(deferred_tx)},
140 {"late_collisions", IBMVNIC_STAT_OFF(late_collisions)},
141 {"excess_collisions", IBMVNIC_STAT_OFF(excess_collisions)},
142 {"internal_mac_tx_errors", IBMVNIC_STAT_OFF(internal_mac_tx_errors)},
143 {"carrier_sense", IBMVNIC_STAT_OFF(carrier_sense)},
144 {"too_long_frames", IBMVNIC_STAT_OFF(too_long_frames)},
145 {"internal_mac_rx_errors", IBMVNIC_STAT_OFF(internal_mac_rx_errors)},
146};
147
148static long h_reg_sub_crq(unsigned long unit_address, unsigned long token,
149 unsigned long length, unsigned long *number,
150 unsigned long *irq)
151{
152 unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
153 long rc;
154
155 rc = plpar_hcall(H_REG_SUB_CRQ, retbuf, unit_address, token, length);
156 *number = retbuf[0];
157 *irq = retbuf[1];
158
159 return rc;
160}
161
162/* net_device_ops functions */
163
164static void init_rx_pool(struct ibmvnic_adapter *adapter,
165 struct ibmvnic_rx_pool *rx_pool, int num, int index,
166 int buff_size, int active)
167{
168 netdev_dbg(adapter->netdev,
169 "Initializing rx_pool %d, %d buffs, %d bytes each\n",
170 index, num, buff_size);
171 rx_pool->size = num;
172 rx_pool->index = index;
173 rx_pool->buff_size = buff_size;
174 rx_pool->active = active;
175}
176
177static int alloc_long_term_buff(struct ibmvnic_adapter *adapter,
178 struct ibmvnic_long_term_buff *ltb, int size)
179{
180 struct device *dev = &adapter->vdev->dev;
181
182 ltb->size = size;
183 ltb->buff = dma_alloc_coherent(dev, ltb->size, &ltb->addr,
184 GFP_KERNEL);
185
186 if (!ltb->buff) {
187 dev_err(dev, "Couldn't alloc long term buffer\n");
188 return -ENOMEM;
189 }
190 ltb->map_id = adapter->map_id;
191 adapter->map_id++;
db5d0b59
NF		 192
193 init_completion(&adapter->fw_done);
032c5e82
TF		 194 send_request_map(adapter, ltb->addr,
195 ltb->size, ltb->map_id);
032c5e82
TF		 196 wait_for_completion(&adapter->fw_done);
197 return 0;
198}
199
200static void free_long_term_buff(struct ibmvnic_adapter *adapter,
201 struct ibmvnic_long_term_buff *ltb)
202{
203 struct device *dev = &adapter->vdev->dev;
204
205 dma_free_coherent(dev, ltb->size, ltb->buff, ltb->addr);
dfad09a6
TF		 206 if (!adapter->failover)
207 send_request_unmap(adapter, ltb->map_id);
032c5e82
TF		 208}
209
210static int alloc_rx_pool(struct ibmvnic_adapter *adapter,
211 struct ibmvnic_rx_pool *pool)
212{
213 struct device *dev = &adapter->vdev->dev;
214 int i;
215
216 pool->free_map = kcalloc(pool->size, sizeof(int), GFP_KERNEL);
217 if (!pool->free_map)
218 return -ENOMEM;
219
220 pool->rx_buff = kcalloc(pool->size, sizeof(struct ibmvnic_rx_buff),
221 GFP_KERNEL);
222
223 if (!pool->rx_buff) {
224 dev_err(dev, "Couldn't alloc rx buffers\n");
225 kfree(pool->free_map);
226 return -ENOMEM;
227 }
228
229 if (alloc_long_term_buff(adapter, &pool->long_term_buff,
230 pool->size * pool->buff_size)) {
231 kfree(pool->free_map);
232 kfree(pool->rx_buff);
233 return -ENOMEM;
234 }
235
236 for (i = 0; i < pool->size; ++i)
237 pool->free_map[i] = i;
238
239 atomic_set(&pool->available, 0);
240 pool->next_alloc = 0;
241 pool->next_free = 0;
242
243 return 0;
244}
245
246static void replenish_rx_pool(struct ibmvnic_adapter *adapter,
247 struct ibmvnic_rx_pool *pool)
248{
249 int count = pool->size - atomic_read(&pool->available);
250 struct device *dev = &adapter->vdev->dev;
251 int buffers_added = 0;
252 unsigned long lpar_rc;
253 union sub_crq sub_crq;
254 struct sk_buff *skb;
255 unsigned int offset;
256 dma_addr_t dma_addr;
257 unsigned char *dst;
258 u64 *handle_array;
259 int shift = 0;
260 int index;
261 int i;
262
263 handle_array = (u64 *)((u8 *)(adapter->login_rsp_buf) +
264 be32_to_cpu(adapter->login_rsp_buf->
265 off_rxadd_subcrqs));
266
267 for (i = 0; i < count; ++i) {
268 skb = alloc_skb(pool->buff_size, GFP_ATOMIC);
269 if (!skb) {
270 dev_err(dev, "Couldn't replenish rx buff\n");
271 adapter->replenish_no_mem++;
272 break;
273 }
274
275 index = pool->free_map[pool->next_free];
276
277 if (pool->rx_buff[index].skb)
278 dev_err(dev, "Inconsistent free_map!\n");
279
280 /* Copy the skb to the long term mapped DMA buffer */
281 offset = index * pool->buff_size;
282 dst = pool->long_term_buff.buff + offset;
283 memset(dst, 0, pool->buff_size);
284 dma_addr = pool->long_term_buff.addr + offset;
285 pool->rx_buff[index].data = dst;
286
287 pool->free_map[pool->next_free] = IBMVNIC_INVALID_MAP;
288 pool->rx_buff[index].dma = dma_addr;
289 pool->rx_buff[index].skb = skb;
290 pool->rx_buff[index].pool_index = pool->index;
291 pool->rx_buff[index].size = pool->buff_size;
292
293 memset(&sub_crq, 0, sizeof(sub_crq));
294 sub_crq.rx_add.first = IBMVNIC_CRQ_CMD;
295 sub_crq.rx_add.correlator =
296 cpu_to_be64((u64)&pool->rx_buff[index]);
297 sub_crq.rx_add.ioba = cpu_to_be32(dma_addr);
298 sub_crq.rx_add.map_id = pool->long_term_buff.map_id;
299
300 /* The length field of the sCRQ is defined to be 24 bits so the
301 * buffer size needs to be left shifted by a byte before it is
302 * converted to big endian to prevent the last byte from being
303 * truncated.
304 */
305#ifdef __LITTLE_ENDIAN__
306 shift = 8;
307#endif
308 sub_crq.rx_add.len = cpu_to_be32(pool->buff_size << shift);
309
310 lpar_rc = send_subcrq(adapter, handle_array[pool->index],
311 &sub_crq);
312 if (lpar_rc != H_SUCCESS)
313 goto failure;
314
315 buffers_added++;
316 adapter->replenish_add_buff_success++;
317 pool->next_free = (pool->next_free + 1) % pool->size;
318 }
319 atomic_add(buffers_added, &pool->available);
320 return;
321
322failure:
323 dev_info(dev, "replenish pools failure\n");
324 pool->free_map[pool->next_free] = index;
325 pool->rx_buff[index].skb = NULL;
326 if (!dma_mapping_error(dev, dma_addr))
327 dma_unmap_single(dev, dma_addr, pool->buff_size,
328 DMA_FROM_DEVICE);
329
330 dev_kfree_skb_any(skb);
331 adapter->replenish_add_buff_failure++;
332 atomic_add(buffers_added, &pool->available);
333}
334
335static void replenish_pools(struct ibmvnic_adapter *adapter)
336{
337 int i;
338
339 if (adapter->migrated)
340 return;
341
342 adapter->replenish_task_cycles++;
343 for (i = 0; i < be32_to_cpu(adapter->login_rsp_buf->num_rxadd_subcrqs);
344 i++) {
345 if (adapter->rx_pool[i].active)
346 replenish_rx_pool(adapter, &adapter->rx_pool[i]);
347 }
348}
349
350static void free_rx_pool(struct ibmvnic_adapter *adapter,
351 struct ibmvnic_rx_pool *pool)
352{
353 int i;
354
355 kfree(pool->free_map);
356 pool->free_map = NULL;
357
358 if (!pool->rx_buff)
359 return;
360
361 for (i = 0; i < pool->size; i++) {
362 if (pool->rx_buff[i].skb) {
363 dev_kfree_skb_any(pool->rx_buff[i].skb);
364 pool->rx_buff[i].skb = NULL;
365 }
366 }
367 kfree(pool->rx_buff);
368 pool->rx_buff = NULL;
369}
370
371static int ibmvnic_open(struct net_device *netdev)
372{
373 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
374 struct device *dev = &adapter->vdev->dev;
375 struct ibmvnic_tx_pool *tx_pool;
376 union ibmvnic_crq crq;
377 int rxadd_subcrqs;
378 u64 *size_array;
379 int tx_subcrqs;
380 int i, j;
381
382 rxadd_subcrqs =
383 be32_to_cpu(adapter->login_rsp_buf->num_rxadd_subcrqs);
384 tx_subcrqs =
385 be32_to_cpu(adapter->login_rsp_buf->num_txsubm_subcrqs);
386 size_array = (u64 *)((u8 *)(adapter->login_rsp_buf) +
387 be32_to_cpu(adapter->login_rsp_buf->
388 off_rxadd_buff_size));
389 adapter->map_id = 1;
390 adapter->napi = kcalloc(adapter->req_rx_queues,
391 sizeof(struct napi_struct), GFP_KERNEL);
392 if (!adapter->napi)
393 goto alloc_napi_failed;
394 for (i = 0; i < adapter->req_rx_queues; i++) {
395 netif_napi_add(netdev, &adapter->napi[i], ibmvnic_poll,
396 NAPI_POLL_WEIGHT);
397 napi_enable(&adapter->napi[i]);
398 }
399 adapter->rx_pool =
400 kcalloc(rxadd_subcrqs, sizeof(struct ibmvnic_rx_pool), GFP_KERNEL);
401
402 if (!adapter->rx_pool)
403 goto rx_pool_arr_alloc_failed;
404 send_map_query(adapter);
405 for (i = 0; i < rxadd_subcrqs; i++) {
406 init_rx_pool(adapter, &adapter->rx_pool[i],
407 IBMVNIC_BUFFS_PER_POOL, i,
408 be64_to_cpu(size_array[i]), 1);
409 if (alloc_rx_pool(adapter, &adapter->rx_pool[i])) {
410 dev_err(dev, "Couldn't alloc rx pool\n");
411 goto rx_pool_alloc_failed;
412 }
413 }
414 adapter->tx_pool =
415 kcalloc(tx_subcrqs, sizeof(struct ibmvnic_tx_pool), GFP_KERNEL);
416
417 if (!adapter->tx_pool)
418 goto tx_pool_arr_alloc_failed;
419 for (i = 0; i < tx_subcrqs; i++) {
420 tx_pool = &adapter->tx_pool[i];
421 tx_pool->tx_buff =
422 kcalloc(adapter->max_tx_entries_per_subcrq,
423 sizeof(struct ibmvnic_tx_buff), GFP_KERNEL);
424 if (!tx_pool->tx_buff)
425 goto tx_pool_alloc_failed;
426
427 if (alloc_long_term_buff(adapter, &tx_pool->long_term_buff,
428 adapter->max_tx_entries_per_subcrq *
429 adapter->req_mtu))
430 goto tx_ltb_alloc_failed;
431
432 tx_pool->free_map =
433 kcalloc(adapter->max_tx_entries_per_subcrq,
434 sizeof(int), GFP_KERNEL);
435 if (!tx_pool->free_map)
436 goto tx_fm_alloc_failed;
437
438 for (j = 0; j < adapter->max_tx_entries_per_subcrq; j++)
439 tx_pool->free_map[j] = j;
440
441 tx_pool->consumer_index = 0;
442 tx_pool->producer_index = 0;
443 }
444 adapter->bounce_buffer_size =
445 (netdev->mtu + ETH_HLEN - 1) / PAGE_SIZE + 1;
446 adapter->bounce_buffer = kmalloc(adapter->bounce_buffer_size,
447 GFP_KERNEL);
448 if (!adapter->bounce_buffer)
449 goto bounce_alloc_failed;
450
451 adapter->bounce_buffer_dma = dma_map_single(dev, adapter->bounce_buffer,
452 adapter->bounce_buffer_size,
453 DMA_TO_DEVICE);
454 if (dma_mapping_error(dev, adapter->bounce_buffer_dma)) {
455 dev_err(dev, "Couldn't map tx bounce buffer\n");
456 goto bounce_map_failed;
457 }
458 replenish_pools(adapter);
459
460 /* We're ready to receive frames, enable the sub-crq interrupts and
461 * set the logical link state to up
462 */
463 for (i = 0; i < adapter->req_rx_queues; i++)
464 enable_scrq_irq(adapter, adapter->rx_scrq[i]);
465
466 for (i = 0; i < adapter->req_tx_queues; i++)
467 enable_scrq_irq(adapter, adapter->tx_scrq[i]);
468
469 memset(&crq, 0, sizeof(crq));
470 crq.logical_link_state.first = IBMVNIC_CRQ_CMD;
471 crq.logical_link_state.cmd = LOGICAL_LINK_STATE;
472 crq.logical_link_state.link_state = IBMVNIC_LOGICAL_LNK_UP;
473 ibmvnic_send_crq(adapter, &crq);
474
b8efb894
TF		 475 netif_tx_start_all_queues(netdev);
476
032c5e82
TF		 477 return 0;
478
479bounce_map_failed:
480 kfree(adapter->bounce_buffer);
481bounce_alloc_failed:
482 i = tx_subcrqs - 1;
483 kfree(adapter->tx_pool[i].free_map);
484tx_fm_alloc_failed:
485 free_long_term_buff(adapter, &adapter->tx_pool[i].long_term_buff);
486tx_ltb_alloc_failed:
487 kfree(adapter->tx_pool[i].tx_buff);
488tx_pool_alloc_failed:
489 for (j = 0; j < i; j++) {
490 kfree(adapter->tx_pool[j].tx_buff);
491 free_long_term_buff(adapter,
492 &adapter->tx_pool[j].long_term_buff);
493 kfree(adapter->tx_pool[j].free_map);
494 }
495 kfree(adapter->tx_pool);
496 adapter->tx_pool = NULL;
497tx_pool_arr_alloc_failed:
498 i = rxadd_subcrqs;
499rx_pool_alloc_failed:
500 for (j = 0; j < i; j++) {
501 free_rx_pool(adapter, &adapter->rx_pool[j]);
502 free_long_term_buff(adapter,
503 &adapter->rx_pool[j].long_term_buff);
504 }
505 kfree(adapter->rx_pool);
506 adapter->rx_pool = NULL;
507rx_pool_arr_alloc_failed:
508 for (i = 0; i < adapter->req_rx_queues; i++)
e722af63 509 napi_disable(&adapter->napi[i]);
032c5e82
TF		 510alloc_napi_failed:
511 return -ENOMEM;
512}
513
514static int ibmvnic_close(struct net_device *netdev)
515{
516 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
517 struct device *dev = &adapter->vdev->dev;
518 union ibmvnic_crq crq;
519 int i;
520
521 adapter->closing = true;
522
523 for (i = 0; i < adapter->req_rx_queues; i++)
524 napi_disable(&adapter->napi[i]);
525
dfad09a6
TF		 526 if (!adapter->failover)
527 netif_tx_stop_all_queues(netdev);
032c5e82
TF		 528
529 if (adapter->bounce_buffer) {
530 if (!dma_mapping_error(dev, adapter->bounce_buffer_dma)) {
531 dma_unmap_single(&adapter->vdev->dev,
532 adapter->bounce_buffer_dma,
533 adapter->bounce_buffer_size,
534 DMA_BIDIRECTIONAL);
535 adapter->bounce_buffer_dma = DMA_ERROR_CODE;
536 }
537 kfree(adapter->bounce_buffer);
538 adapter->bounce_buffer = NULL;
539 }
540
541 memset(&crq, 0, sizeof(crq));
542 crq.logical_link_state.first = IBMVNIC_CRQ_CMD;
543 crq.logical_link_state.cmd = LOGICAL_LINK_STATE;
544 crq.logical_link_state.link_state = IBMVNIC_LOGICAL_LNK_DN;
545 ibmvnic_send_crq(adapter, &crq);
546
547 for (i = 0; i < be32_to_cpu(adapter->login_rsp_buf->num_txsubm_subcrqs);
548 i++) {
549 kfree(adapter->tx_pool[i].tx_buff);
550 free_long_term_buff(adapter,
551 &adapter->tx_pool[i].long_term_buff);
552 kfree(adapter->tx_pool[i].free_map);
553 }
554 kfree(adapter->tx_pool);
555 adapter->tx_pool = NULL;
556
557 for (i = 0; i < be32_to_cpu(adapter->login_rsp_buf->num_rxadd_subcrqs);
558 i++) {
559 free_rx_pool(adapter, &adapter->rx_pool[i]);
560 free_long_term_buff(adapter,
561 &adapter->rx_pool[i].long_term_buff);
562 }
563 kfree(adapter->rx_pool);
564 adapter->rx_pool = NULL;
565
566 adapter->closing = false;
567
568 return 0;
569}
570
ad7775dc
TF		 571/**
572 * build_hdr_data - creates L2/L3/L4 header data buffer
573 * @hdr_field - bitfield determining needed headers
574 * @skb - socket buffer
575 * @hdr_len - array of header lengths
576 * @tot_len - total length of data
577 *
578 * Reads hdr_field to determine which headers are needed by firmware.
579 * Builds a buffer containing these headers. Saves individual header
580 * lengths and total buffer length to be used to build descriptors.
581 */
582static int build_hdr_data(u8 hdr_field, struct sk_buff *skb,
583 int *hdr_len, u8 *hdr_data)
584{
585 int len = 0;
586 u8 *hdr;
587
588 hdr_len[0] = sizeof(struct ethhdr);
589
590 if (skb->protocol == htons(ETH_P_IP)) {
591 hdr_len[1] = ip_hdr(skb)->ihl * 4;
592 if (ip_hdr(skb)->protocol == IPPROTO_TCP)
593 hdr_len[2] = tcp_hdrlen(skb);
594 else if (ip_hdr(skb)->protocol == IPPROTO_UDP)
595 hdr_len[2] = sizeof(struct udphdr);
596 } else if (skb->protocol == htons(ETH_P_IPV6)) {
597 hdr_len[1] = sizeof(struct ipv6hdr);
598 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
599 hdr_len[2] = tcp_hdrlen(skb);
600 else if (ipv6_hdr(skb)->nexthdr == IPPROTO_UDP)
601 hdr_len[2] = sizeof(struct udphdr);
602 }
603
604 memset(hdr_data, 0, 120);
605 if ((hdr_field >> 6) & 1) {
606 hdr = skb_mac_header(skb);
607 memcpy(hdr_data, hdr, hdr_len[0]);
608 len += hdr_len[0];
609 }
610
611 if ((hdr_field >> 5) & 1) {
612 hdr = skb_network_header(skb);
613 memcpy(hdr_data + len, hdr, hdr_len[1]);
614 len += hdr_len[1];
615 }
616
617 if ((hdr_field >> 4) & 1) {
618 hdr = skb_transport_header(skb);
619 memcpy(hdr_data + len, hdr, hdr_len[2]);
620 len += hdr_len[2];
621 }
622 return len;
623}
624
625/**
626 * create_hdr_descs - create header and header extension descriptors
627 * @hdr_field - bitfield determining needed headers
628 * @data - buffer containing header data
629 * @len - length of data buffer
630 * @hdr_len - array of individual header lengths
631 * @scrq_arr - descriptor array
632 *
633 * Creates header and, if needed, header extension descriptors and
634 * places them in a descriptor array, scrq_arr
635 */
636
637static void create_hdr_descs(u8 hdr_field, u8 *hdr_data, int len, int *hdr_len,
638 union sub_crq *scrq_arr)
639{
640 union sub_crq hdr_desc;
641 int tmp_len = len;
642 u8 *data, *cur;
643 int tmp;
644
645 while (tmp_len > 0) {
646 cur = hdr_data + len - tmp_len;
647
648 memset(&hdr_desc, 0, sizeof(hdr_desc));
649 if (cur != hdr_data) {
650 data = hdr_desc.hdr_ext.data;
651 tmp = tmp_len > 29 ? 29 : tmp_len;
652 hdr_desc.hdr_ext.first = IBMVNIC_CRQ_CMD;
653 hdr_desc.hdr_ext.type = IBMVNIC_HDR_EXT_DESC;
654 hdr_desc.hdr_ext.len = tmp;
655 } else {
656 data = hdr_desc.hdr.data;
657 tmp = tmp_len > 24 ? 24 : tmp_len;
658 hdr_desc.hdr.first = IBMVNIC_CRQ_CMD;
659 hdr_desc.hdr.type = IBMVNIC_HDR_DESC;
660 hdr_desc.hdr.len = tmp;
661 hdr_desc.hdr.l2_len = (u8)hdr_len[0];
662 hdr_desc.hdr.l3_len = cpu_to_be16((u16)hdr_len[1]);
663 hdr_desc.hdr.l4_len = (u8)hdr_len[2];
664 hdr_desc.hdr.flag = hdr_field << 1;
665 }
666 memcpy(data, cur, tmp);
667 tmp_len -= tmp;
668 *scrq_arr = hdr_desc;
669 scrq_arr++;
670 }
671}
672
673/**
674 * build_hdr_descs_arr - build a header descriptor array
675 * @skb - socket buffer
676 * @num_entries - number of descriptors to be sent
677 * @subcrq - first TX descriptor
678 * @hdr_field - bit field determining which headers will be sent
679 *
680 * This function will build a TX descriptor array with applicable
681 * L2/L3/L4 packet header descriptors to be sent by send_subcrq_indirect.
682 */
683
684static void build_hdr_descs_arr(struct ibmvnic_tx_buff *txbuff,
685 int *num_entries, u8 hdr_field)
686{
687 int hdr_len[3] = {0, 0, 0};
688 int tot_len, len;
689 u8 *hdr_data = txbuff->hdr_data;
690
691 tot_len = build_hdr_data(hdr_field, txbuff->skb, hdr_len,
692 txbuff->hdr_data);
693 len = tot_len;
694 len -= 24;
695 if (len > 0)
696 num_entries += len % 29 ? len / 29 + 1 : len / 29;
697 create_hdr_descs(hdr_field, hdr_data, tot_len, hdr_len,
698 txbuff->indir_arr + 1);
699}
700
032c5e82
TF		 701static int ibmvnic_xmit(struct sk_buff *skb, struct net_device *netdev)
702{
703 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
704 int queue_num = skb_get_queue_mapping(skb);
ad7775dc 705 u8 *hdrs = (u8 *)&adapter->tx_rx_desc_req;
032c5e82
TF		 706 struct device *dev = &adapter->vdev->dev;
707 struct ibmvnic_tx_buff *tx_buff = NULL;
708 struct ibmvnic_tx_pool *tx_pool;
709 unsigned int tx_send_failed = 0;
710 unsigned int tx_map_failed = 0;
711 unsigned int tx_dropped = 0;
712 unsigned int tx_packets = 0;
713 unsigned int tx_bytes = 0;
714 dma_addr_t data_dma_addr;
715 struct netdev_queue *txq;
716 bool used_bounce = false;
717 unsigned long lpar_rc;
718 union sub_crq tx_crq;
719 unsigned int offset;
ad7775dc 720 int num_entries = 1;
032c5e82
TF		 721 unsigned char *dst;
722 u64 *handle_array;
723 int index = 0;
724 int ret = 0;
725
726 tx_pool = &adapter->tx_pool[queue_num];
727 txq = netdev_get_tx_queue(netdev, skb_get_queue_mapping(skb));
728 handle_array = (u64 *)((u8 *)(adapter->login_rsp_buf) +
729 be32_to_cpu(adapter->login_rsp_buf->
730 off_txsubm_subcrqs));
731 if (adapter->migrated) {
732 tx_send_failed++;
733 tx_dropped++;
734 ret = NETDEV_TX_BUSY;
735 goto out;
736 }
737
738 index = tx_pool->free_map[tx_pool->consumer_index];
739 offset = index * adapter->req_mtu;
740 dst = tx_pool->long_term_buff.buff + offset;
741 memset(dst, 0, adapter->req_mtu);
742 skb_copy_from_linear_data(skb, dst, skb->len);
743 data_dma_addr = tx_pool->long_term_buff.addr + offset;
744
745 tx_pool->consumer_index =
746 (tx_pool->consumer_index + 1) %
747 adapter->max_tx_entries_per_subcrq;
748
749 tx_buff = &tx_pool->tx_buff[index];
750 tx_buff->skb = skb;
751 tx_buff->data_dma[0] = data_dma_addr;
752 tx_buff->data_len[0] = skb->len;
753 tx_buff->index = index;
754 tx_buff->pool_index = queue_num;
755 tx_buff->last_frag = true;
756 tx_buff->used_bounce = used_bounce;
757
758 memset(&tx_crq, 0, sizeof(tx_crq));
759 tx_crq.v1.first = IBMVNIC_CRQ_CMD;
760 tx_crq.v1.type = IBMVNIC_TX_DESC;
761 tx_crq.v1.n_crq_elem = 1;
762 tx_crq.v1.n_sge = 1;
763 tx_crq.v1.flags1 = IBMVNIC_TX_COMP_NEEDED;
764 tx_crq.v1.correlator = cpu_to_be32(index);
765 tx_crq.v1.dma_reg = cpu_to_be16(tx_pool->long_term_buff.map_id);
766 tx_crq.v1.sge_len = cpu_to_be32(skb->len);
767 tx_crq.v1.ioba = cpu_to_be64(data_dma_addr);
768
769 if (adapter->vlan_header_insertion) {
770 tx_crq.v1.flags2 |= IBMVNIC_TX_VLAN_INSERT;
771 tx_crq.v1.vlan_id = cpu_to_be16(skb->vlan_tci);
772 }
773
774 if (skb->protocol == htons(ETH_P_IP)) {
775 if (ip_hdr(skb)->version == 4)
776 tx_crq.v1.flags1 |= IBMVNIC_TX_PROT_IPV4;
777 else if (ip_hdr(skb)->version == 6)
778 tx_crq.v1.flags1 |= IBMVNIC_TX_PROT_IPV6;
779
780 if (ip_hdr(skb)->protocol == IPPROTO_TCP)
781 tx_crq.v1.flags1 |= IBMVNIC_TX_PROT_TCP;
782 else if (ip_hdr(skb)->protocol != IPPROTO_TCP)
783 tx_crq.v1.flags1 |= IBMVNIC_TX_PROT_UDP;
784 }
785
ad7775dc 786 if (skb->ip_summed == CHECKSUM_PARTIAL) {
032c5e82 787 tx_crq.v1.flags1 |= IBMVNIC_TX_CHKSUM_OFFLOAD;
ad7775dc
TF		 788 hdrs += 2;
789 }
790 /* determine if l2/3/4 headers are sent to firmware */
791 if ((*hdrs >> 7) & 1 &&
792 (skb->protocol == htons(ETH_P_IP) ||
793 skb->protocol == htons(ETH_P_IPV6))) {
794 build_hdr_descs_arr(tx_buff, &num_entries, *hdrs);
795 tx_crq.v1.n_crq_elem = num_entries;
796 tx_buff->indir_arr[0] = tx_crq;
797 tx_buff->indir_dma = dma_map_single(dev, tx_buff->indir_arr,
798 sizeof(tx_buff->indir_arr),
799 DMA_TO_DEVICE);
800 if (dma_mapping_error(dev, tx_buff->indir_dma)) {
801 if (!firmware_has_feature(FW_FEATURE_CMO))
802 dev_err(dev, "tx: unable to map descriptor array\n");
803 tx_map_failed++;
804 tx_dropped++;
805 ret = NETDEV_TX_BUSY;
806 goto out;
807 }
498cd8e4 808 lpar_rc = send_subcrq_indirect(adapter, handle_array[queue_num],
ad7775dc
TF		 809 (u64)tx_buff->indir_dma,
810 (u64)num_entries);
811 } else {
498cd8e4
JA		 812 lpar_rc = send_subcrq(adapter, handle_array[queue_num],
813 &tx_crq);
ad7775dc 814 }
032c5e82
TF		 815 if (lpar_rc != H_SUCCESS) {
816 dev_err(dev, "tx failed with code %ld\n", lpar_rc);
817
818 if (tx_pool->consumer_index == 0)
819 tx_pool->consumer_index =
820 adapter->max_tx_entries_per_subcrq - 1;
821 else
822 tx_pool->consumer_index--;
823
824 tx_send_failed++;
825 tx_dropped++;
826 ret = NETDEV_TX_BUSY;
827 goto out;
828 }
829 tx_packets++;
830 tx_bytes += skb->len;
831 txq->trans_start = jiffies;
832 ret = NETDEV_TX_OK;
833
834out:
835 netdev->stats.tx_dropped += tx_dropped;
836 netdev->stats.tx_bytes += tx_bytes;
837 netdev->stats.tx_packets += tx_packets;
838 adapter->tx_send_failed += tx_send_failed;
839 adapter->tx_map_failed += tx_map_failed;
840
841 return ret;
842}
843
844static void ibmvnic_set_multi(struct net_device *netdev)
845{
846 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
847 struct netdev_hw_addr *ha;
848 union ibmvnic_crq crq;
849
850 memset(&crq, 0, sizeof(crq));
851 crq.request_capability.first = IBMVNIC_CRQ_CMD;
852 crq.request_capability.cmd = REQUEST_CAPABILITY;
853
854 if (netdev->flags & IFF_PROMISC) {
855 if (!adapter->promisc_supported)
856 return;
857 } else {
858 if (netdev->flags & IFF_ALLMULTI) {
859 /* Accept all multicast */
860 memset(&crq, 0, sizeof(crq));
861 crq.multicast_ctrl.first = IBMVNIC_CRQ_CMD;
862 crq.multicast_ctrl.cmd = MULTICAST_CTRL;
863 crq.multicast_ctrl.flags = IBMVNIC_ENABLE_ALL;
864 ibmvnic_send_crq(adapter, &crq);
865 } else if (netdev_mc_empty(netdev)) {
866 /* Reject all multicast */
867 memset(&crq, 0, sizeof(crq));
868 crq.multicast_ctrl.first = IBMVNIC_CRQ_CMD;
869 crq.multicast_ctrl.cmd = MULTICAST_CTRL;
870 crq.multicast_ctrl.flags = IBMVNIC_DISABLE_ALL;
871 ibmvnic_send_crq(adapter, &crq);
872 } else {
873 /* Accept one or more multicast(s) */
874 netdev_for_each_mc_addr(ha, netdev) {
875 memset(&crq, 0, sizeof(crq));
876 crq.multicast_ctrl.first = IBMVNIC_CRQ_CMD;
877 crq.multicast_ctrl.cmd = MULTICAST_CTRL;
878 crq.multicast_ctrl.flags = IBMVNIC_ENABLE_MC;
879 ether_addr_copy(&crq.multicast_ctrl.mac_addr[0],
880 ha->addr);
881 ibmvnic_send_crq(adapter, &crq);
882 }
883 }
884 }
885}
886
887static int ibmvnic_set_mac(struct net_device *netdev, void *p)
888{
889 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
890 struct sockaddr *addr = p;
891 union ibmvnic_crq crq;
892
893 if (!is_valid_ether_addr(addr->sa_data))
894 return -EADDRNOTAVAIL;
895
896 memset(&crq, 0, sizeof(crq));
897 crq.change_mac_addr.first = IBMVNIC_CRQ_CMD;
898 crq.change_mac_addr.cmd = CHANGE_MAC_ADDR;
899 ether_addr_copy(&crq.change_mac_addr.mac_addr[0], addr->sa_data);
900 ibmvnic_send_crq(adapter, &crq);
901 /* netdev->dev_addr is changed in handle_change_mac_rsp function */
902 return 0;
903}
904
032c5e82
TF		 905static void ibmvnic_tx_timeout(struct net_device *dev)
906{
907 struct ibmvnic_adapter *adapter = netdev_priv(dev);
908 int rc;
909
910 /* Adapter timed out, resetting it */
911 release_sub_crqs(adapter);
912 rc = ibmvnic_reset_crq(adapter);
913 if (rc)
914 dev_err(&adapter->vdev->dev, "Adapter timeout, reset failed\n");
915 else
916 ibmvnic_send_crq_init(adapter);
917}
918
919static void remove_buff_from_pool(struct ibmvnic_adapter *adapter,
920 struct ibmvnic_rx_buff *rx_buff)
921{
922 struct ibmvnic_rx_pool *pool = &adapter->rx_pool[rx_buff->pool_index];
923
924 rx_buff->skb = NULL;
925
926 pool->free_map[pool->next_alloc] = (int)(rx_buff - pool->rx_buff);
927 pool->next_alloc = (pool->next_alloc + 1) % pool->size;
928
929 atomic_dec(&pool->available);
930}
931
932static int ibmvnic_poll(struct napi_struct *napi, int budget)
933{
934 struct net_device *netdev = napi->dev;
935 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
936 int scrq_num = (int)(napi - adapter->napi);
937 int frames_processed = 0;
938restart_poll:
939 while (frames_processed < budget) {
940 struct sk_buff *skb;
941 struct ibmvnic_rx_buff *rx_buff;
942 union sub_crq *next;
943 u32 length;
944 u16 offset;
945 u8 flags = 0;
946
947 if (!pending_scrq(adapter, adapter->rx_scrq[scrq_num]))
948 break;
949 next = ibmvnic_next_scrq(adapter, adapter->rx_scrq[scrq_num]);
950 rx_buff =
951 (struct ibmvnic_rx_buff *)be64_to_cpu(next->
952 rx_comp.correlator);
953 /* do error checking */
954 if (next->rx_comp.rc) {
955 netdev_err(netdev, "rx error %x\n", next->rx_comp.rc);
956 /* free the entry */
957 next->rx_comp.first = 0;
958 remove_buff_from_pool(adapter, rx_buff);
959 break;
960 }
961
962 length = be32_to_cpu(next->rx_comp.len);
963 offset = be16_to_cpu(next->rx_comp.off_frame_data);
964 flags = next->rx_comp.flags;
965 skb = rx_buff->skb;
966 skb_copy_to_linear_data(skb, rx_buff->data + offset,
967 length);
968 skb->vlan_tci = be16_to_cpu(next->rx_comp.vlan_tci);
969 /* free the entry */
970 next->rx_comp.first = 0;
971 remove_buff_from_pool(adapter, rx_buff);
972
973 skb_put(skb, length);
974 skb->protocol = eth_type_trans(skb, netdev);
975
976 if (flags & IBMVNIC_IP_CHKSUM_GOOD &&
977 flags & IBMVNIC_TCP_UDP_CHKSUM_GOOD) {
978 skb->ip_summed = CHECKSUM_UNNECESSARY;
979 }
980
981 length = skb->len;
982 napi_gro_receive(napi, skb); /* send it up */
983 netdev->stats.rx_packets++;
984 netdev->stats.rx_bytes += length;
985 frames_processed++;
986 }
498cd8e4 987 replenish_rx_pool(adapter, &adapter->rx_pool[scrq_num]);
032c5e82
TF		 988
989 if (frames_processed < budget) {
990 enable_scrq_irq(adapter, adapter->rx_scrq[scrq_num]);
6ad20165 991 napi_complete_done(napi, frames_processed);
032c5e82
TF		 992 if (pending_scrq(adapter, adapter->rx_scrq[scrq_num]) &&
993 napi_reschedule(napi)) {
994 disable_scrq_irq(adapter, adapter->rx_scrq[scrq_num]);
995 goto restart_poll;
996 }
997 }
998 return frames_processed;
999}
1000
1001#ifdef CONFIG_NET_POLL_CONTROLLER
1002static void ibmvnic_netpoll_controller(struct net_device *dev)
1003{
1004 struct ibmvnic_adapter *adapter = netdev_priv(dev);
1005 int i;
1006
1007 replenish_pools(netdev_priv(dev));
1008 for (i = 0; i < adapter->req_rx_queues; i++)
1009 ibmvnic_interrupt_rx(adapter->rx_scrq[i]->irq,
1010 adapter->rx_scrq[i]);
1011}
1012#endif
1013
1014static const struct net_device_ops ibmvnic_netdev_ops = {
1015 .ndo_open = ibmvnic_open,
1016 .ndo_stop = ibmvnic_close,
1017 .ndo_start_xmit = ibmvnic_xmit,
1018 .ndo_set_rx_mode = ibmvnic_set_multi,
1019 .ndo_set_mac_address = ibmvnic_set_mac,
1020 .ndo_validate_addr = eth_validate_addr,
032c5e82
TF		 1021 .ndo_tx_timeout = ibmvnic_tx_timeout,
1022#ifdef CONFIG_NET_POLL_CONTROLLER
1023 .ndo_poll_controller = ibmvnic_netpoll_controller,
1024#endif
1025};
1026
1027/* ethtool functions */
1028
8a43379f
PR		 1029static int ibmvnic_get_link_ksettings(struct net_device *netdev,
1030 struct ethtool_link_ksettings *cmd)
032c5e82 1031{
8a43379f
PR		 1032 u32 supported, advertising;
1033
1034 supported = (SUPPORTED_1000baseT_Full | SUPPORTED_Autoneg |
032c5e82 1035 SUPPORTED_FIBRE);
8a43379f 1036 advertising = (ADVERTISED_1000baseT_Full | ADVERTISED_Autoneg |
032c5e82 1037 ADVERTISED_FIBRE);
8a43379f
PR		 1038 cmd->base.speed = SPEED_1000;
1039 cmd->base.duplex = DUPLEX_FULL;
1040 cmd->base.port = PORT_FIBRE;
1041 cmd->base.phy_address = 0;
1042 cmd->base.autoneg = AUTONEG_ENABLE;
1043
1044 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
1045 supported);
1046 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
1047 advertising);
1048
032c5e82
TF		 1049 return 0;
1050}
1051
1052static void ibmvnic_get_drvinfo(struct net_device *dev,
1053 struct ethtool_drvinfo *info)
1054{
1055 strlcpy(info->driver, ibmvnic_driver_name, sizeof(info->driver));
1056 strlcpy(info->version, IBMVNIC_DRIVER_VERSION, sizeof(info->version));
1057}
1058
1059static u32 ibmvnic_get_msglevel(struct net_device *netdev)
1060{
1061 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
1062
1063 return adapter->msg_enable;
1064}
1065
1066static void ibmvnic_set_msglevel(struct net_device *netdev, u32 data)
1067{
1068 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
1069
1070 adapter->msg_enable = data;
1071}
1072
1073static u32 ibmvnic_get_link(struct net_device *netdev)
1074{
1075 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
1076
1077 /* Don't need to send a query because we request a logical link up at
1078 * init and then we wait for link state indications
1079 */
1080 return adapter->logical_link_state;
1081}
1082
1083static void ibmvnic_get_ringparam(struct net_device *netdev,
1084 struct ethtool_ringparam *ring)
1085{
1086 ring->rx_max_pending = 0;
1087 ring->tx_max_pending = 0;
1088 ring->rx_mini_max_pending = 0;
1089 ring->rx_jumbo_max_pending = 0;
1090 ring->rx_pending = 0;
1091 ring->tx_pending = 0;
1092 ring->rx_mini_pending = 0;
1093 ring->rx_jumbo_pending = 0;
1094}
1095
1096static void ibmvnic_get_strings(struct net_device *dev, u32 stringset, u8 *data)
1097{
1098 int i;
1099
1100 if (stringset != ETH_SS_STATS)
1101 return;
1102
1103 for (i = 0; i < ARRAY_SIZE(ibmvnic_stats); i++, data += ETH_GSTRING_LEN)
1104 memcpy(data, ibmvnic_stats[i].name, ETH_GSTRING_LEN);
1105}
1106
1107static int ibmvnic_get_sset_count(struct net_device *dev, int sset)
1108{
1109 switch (sset) {
1110 case ETH_SS_STATS:
1111 return ARRAY_SIZE(ibmvnic_stats);
1112 default:
1113 return -EOPNOTSUPP;
1114 }
1115}
1116
1117static void ibmvnic_get_ethtool_stats(struct net_device *dev,
1118 struct ethtool_stats *stats, u64 *data)
1119{
1120 struct ibmvnic_adapter *adapter = netdev_priv(dev);
1121 union ibmvnic_crq crq;
1122 int i;
1123
1124 memset(&crq, 0, sizeof(crq));
1125 crq.request_statistics.first = IBMVNIC_CRQ_CMD;
1126 crq.request_statistics.cmd = REQUEST_STATISTICS;
1127 crq.request_statistics.ioba = cpu_to_be32(adapter->stats_token);
1128 crq.request_statistics.len =
1129 cpu_to_be32(sizeof(struct ibmvnic_statistics));
032c5e82
TF		 1130
1131 /* Wait for data to be written */
1132 init_completion(&adapter->stats_done);
db5d0b59 1133 ibmvnic_send_crq(adapter, &crq);
032c5e82
TF		 1134 wait_for_completion(&adapter->stats_done);
1135
1136 for (i = 0; i < ARRAY_SIZE(ibmvnic_stats); i++)
1137 data[i] = IBMVNIC_GET_STAT(adapter, ibmvnic_stats[i].offset);
1138}
1139
1140static const struct ethtool_ops ibmvnic_ethtool_ops = {
032c5e82
TF		 1141 .get_drvinfo = ibmvnic_get_drvinfo,
1142 .get_msglevel = ibmvnic_get_msglevel,
1143 .set_msglevel = ibmvnic_set_msglevel,
1144 .get_link = ibmvnic_get_link,
1145 .get_ringparam = ibmvnic_get_ringparam,
1146 .get_strings = ibmvnic_get_strings,
1147 .get_sset_count = ibmvnic_get_sset_count,
1148 .get_ethtool_stats = ibmvnic_get_ethtool_stats,
8a43379f 1149 .get_link_ksettings = ibmvnic_get_link_ksettings,
032c5e82
TF		 1150};
1151
1152/* Routines for managing CRQs/sCRQs */
1153
1154static void release_sub_crq_queue(struct ibmvnic_adapter *adapter,
1155 struct ibmvnic_sub_crq_queue *scrq)
1156{
1157 struct device *dev = &adapter->vdev->dev;
1158 long rc;
1159
1160 netdev_dbg(adapter->netdev, "Releasing sub-CRQ\n");
1161
1162 /* Close the sub-crqs */
1163 do {
1164 rc = plpar_hcall_norets(H_FREE_SUB_CRQ,
1165 adapter->vdev->unit_address,
1166 scrq->crq_num);
1167 } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
1168
1169 dma_unmap_single(dev, scrq->msg_token, 4 * PAGE_SIZE,
1170 DMA_BIDIRECTIONAL);
1171 free_pages((unsigned long)scrq->msgs, 2);
1172 kfree(scrq);
1173}
1174
1175static struct ibmvnic_sub_crq_queue *init_sub_crq_queue(struct ibmvnic_adapter
1176 *adapter)
1177{
1178 struct device *dev = &adapter->vdev->dev;
1179 struct ibmvnic_sub_crq_queue *scrq;
1180 int rc;
1181
1182 scrq = kmalloc(sizeof(*scrq), GFP_ATOMIC);
1183 if (!scrq)
1184 return NULL;
1185
12608c26 1186 scrq->msgs = (union sub_crq *)__get_free_pages(GFP_ATOMIC, 2);
032c5e82
TF		 1187 memset(scrq->msgs, 0, 4 * PAGE_SIZE);
1188 if (!scrq->msgs) {
1189 dev_warn(dev, "Couldn't allocate crq queue messages page\n");
1190 goto zero_page_failed;
1191 }
1192
1193 scrq->msg_token = dma_map_single(dev, scrq->msgs, 4 * PAGE_SIZE,
1194 DMA_BIDIRECTIONAL);
1195 if (dma_mapping_error(dev, scrq->msg_token)) {
1196 dev_warn(dev, "Couldn't map crq queue messages page\n");
1197 goto map_failed;
1198 }
1199
1200 rc = h_reg_sub_crq(adapter->vdev->unit_address, scrq->msg_token,
1201 4 * PAGE_SIZE, &scrq->crq_num, &scrq->hw_irq);
1202
1203 if (rc == H_RESOURCE)
1204 rc = ibmvnic_reset_crq(adapter);
1205
1206 if (rc == H_CLOSED) {
1207 dev_warn(dev, "Partner adapter not ready, waiting.\n");
1208 } else if (rc) {
1209 dev_warn(dev, "Error %d registering sub-crq\n", rc);
1210 goto reg_failed;
1211 }
1212
032c5e82
TF		 1213 scrq->adapter = adapter;
1214 scrq->size = 4 * PAGE_SIZE / sizeof(*scrq->msgs);
1215 scrq->cur = 0;
1216 scrq->rx_skb_top = NULL;
1217 spin_lock_init(&scrq->lock);
1218
1219 netdev_dbg(adapter->netdev,
1220 "sub-crq initialized, num %lx, hw_irq=%lx, irq=%x\n",
1221 scrq->crq_num, scrq->hw_irq, scrq->irq);
1222
1223 return scrq;
1224
032c5e82
TF		 1225reg_failed:
1226 dma_unmap_single(dev, scrq->msg_token, 4 * PAGE_SIZE,
1227 DMA_BIDIRECTIONAL);
1228map_failed:
1229 free_pages((unsigned long)scrq->msgs, 2);
1230zero_page_failed:
1231 kfree(scrq);
1232
1233 return NULL;
1234}
1235
1236static void release_sub_crqs(struct ibmvnic_adapter *adapter)
1237{
1238 int i;
1239
1240 if (adapter->tx_scrq) {
1241 for (i = 0; i < adapter->req_tx_queues; i++)
1242 if (adapter->tx_scrq[i]) {
1243 free_irq(adapter->tx_scrq[i]->irq,
1244 adapter->tx_scrq[i]);
88eb98a0 1245 irq_dispose_mapping(adapter->tx_scrq[i]->irq);
032c5e82
TF		 1246 release_sub_crq_queue(adapter,
1247 adapter->tx_scrq[i]);
1248 }
1249 adapter->tx_scrq = NULL;
1250 }
1251
1252 if (adapter->rx_scrq) {
1253 for (i = 0; i < adapter->req_rx_queues; i++)
1254 if (adapter->rx_scrq[i]) {
1255 free_irq(adapter->rx_scrq[i]->irq,
1256 adapter->rx_scrq[i]);
88eb98a0 1257 irq_dispose_mapping(adapter->rx_scrq[i]->irq);
032c5e82
TF		 1258 release_sub_crq_queue(adapter,
1259 adapter->rx_scrq[i]);
1260 }
1261 adapter->rx_scrq = NULL;
1262 }
032c5e82
TF		 1263}
1264
ea22d51a
TF		 1265static void release_sub_crqs_no_irqs(struct ibmvnic_adapter *adapter)
1266{
1267 int i;
1268
1269 if (adapter->tx_scrq) {
1270 for (i = 0; i < adapter->req_tx_queues; i++)
1271 if (adapter->tx_scrq[i])
1272 release_sub_crq_queue(adapter,
1273 adapter->tx_scrq[i]);
1274 adapter->tx_scrq = NULL;
1275 }
1276
1277 if (adapter->rx_scrq) {
1278 for (i = 0; i < adapter->req_rx_queues; i++)
1279 if (adapter->rx_scrq[i])
1280 release_sub_crq_queue(adapter,
1281 adapter->rx_scrq[i]);
1282 adapter->rx_scrq = NULL;
1283 }
ea22d51a
TF		 1284}
1285
032c5e82
TF		 1286static int disable_scrq_irq(struct ibmvnic_adapter *adapter,
1287 struct ibmvnic_sub_crq_queue *scrq)
1288{
1289 struct device *dev = &adapter->vdev->dev;
1290 unsigned long rc;
1291
1292 rc = plpar_hcall_norets(H_VIOCTL, adapter->vdev->unit_address,
1293 H_DISABLE_VIO_INTERRUPT, scrq->hw_irq, 0, 0);
1294 if (rc)
1295 dev_err(dev, "Couldn't disable scrq irq 0x%lx. rc=%ld\n",
1296 scrq->hw_irq, rc);
1297 return rc;
1298}
1299
1300static int enable_scrq_irq(struct ibmvnic_adapter *adapter,
1301 struct ibmvnic_sub_crq_queue *scrq)
1302{
1303 struct device *dev = &adapter->vdev->dev;
1304 unsigned long rc;
1305
1306 if (scrq->hw_irq > 0x100000000ULL) {
1307 dev_err(dev, "bad hw_irq = %lx\n", scrq->hw_irq);
1308 return 1;
1309 }
1310
1311 rc = plpar_hcall_norets(H_VIOCTL, adapter->vdev->unit_address,
1312 H_ENABLE_VIO_INTERRUPT, scrq->hw_irq, 0, 0);
1313 if (rc)
1314 dev_err(dev, "Couldn't enable scrq irq 0x%lx. rc=%ld\n",
1315 scrq->hw_irq, rc);
1316 return rc;
1317}
1318
1319static int ibmvnic_complete_tx(struct ibmvnic_adapter *adapter,
1320 struct ibmvnic_sub_crq_queue *scrq)
1321{
1322 struct device *dev = &adapter->vdev->dev;
1323 struct ibmvnic_tx_buff *txbuff;
1324 union sub_crq *next;
1325 int index;
1326 int i, j;
ad7775dc 1327 u8 first;
032c5e82
TF		 1328
1329restart_loop:
1330 while (pending_scrq(adapter, scrq)) {
1331 unsigned int pool = scrq->pool_index;
1332
1333 next = ibmvnic_next_scrq(adapter, scrq);
1334 for (i = 0; i < next->tx_comp.num_comps; i++) {
1335 if (next->tx_comp.rcs[i]) {
1336 dev_err(dev, "tx error %x\n",
1337 next->tx_comp.rcs[i]);
1338 continue;
1339 }
1340 index = be32_to_cpu(next->tx_comp.correlators[i]);
1341 txbuff = &adapter->tx_pool[pool].tx_buff[index];
1342
1343 for (j = 0; j < IBMVNIC_MAX_FRAGS_PER_CRQ; j++) {
1344 if (!txbuff->data_dma[j])
1345 continue;
1346
1347 txbuff->data_dma[j] = 0;
1348 txbuff->used_bounce = false;
1349 }
ad7775dc
TF		 1350 /* if sub_crq was sent indirectly */
1351 first = txbuff->indir_arr[0].generic.first;
1352 if (first == IBMVNIC_CRQ_CMD) {
1353 dma_unmap_single(dev, txbuff->indir_dma,
1354 sizeof(txbuff->indir_arr),
1355 DMA_TO_DEVICE);
1356 }
032c5e82
TF		 1357
1358 if (txbuff->last_frag)
1359 dev_kfree_skb_any(txbuff->skb);
1360
1361 adapter->tx_pool[pool].free_map[adapter->tx_pool[pool].
1362 producer_index] = index;
1363 adapter->tx_pool[pool].producer_index =
1364 (adapter->tx_pool[pool].producer_index + 1) %
1365 adapter->max_tx_entries_per_subcrq;
1366 }
1367 /* remove tx_comp scrq*/
1368 next->tx_comp.first = 0;
1369 }
1370
1371 enable_scrq_irq(adapter, scrq);
1372
1373 if (pending_scrq(adapter, scrq)) {
1374 disable_scrq_irq(adapter, scrq);
1375 goto restart_loop;
1376 }
1377
1378 return 0;
1379}
1380
1381static irqreturn_t ibmvnic_interrupt_tx(int irq, void *instance)
1382{
1383 struct ibmvnic_sub_crq_queue *scrq = instance;
1384 struct ibmvnic_adapter *adapter = scrq->adapter;
1385
1386 disable_scrq_irq(adapter, scrq);
1387 ibmvnic_complete_tx(adapter, scrq);
1388
1389 return IRQ_HANDLED;
1390}
1391
1392static irqreturn_t ibmvnic_interrupt_rx(int irq, void *instance)
1393{
1394 struct ibmvnic_sub_crq_queue *scrq = instance;
1395 struct ibmvnic_adapter *adapter = scrq->adapter;
1396
1397 if (napi_schedule_prep(&adapter->napi[scrq->scrq_num])) {
1398 disable_scrq_irq(adapter, scrq);
1399 __napi_schedule(&adapter->napi[scrq->scrq_num]);
1400 }
1401
1402 return IRQ_HANDLED;
1403}
1404
ea22d51a
TF		 1405static int init_sub_crq_irqs(struct ibmvnic_adapter *adapter)
1406{
1407 struct device *dev = &adapter->vdev->dev;
1408 struct ibmvnic_sub_crq_queue *scrq;
1409 int i = 0, j = 0;
1410 int rc = 0;
1411
1412 for (i = 0; i < adapter->req_tx_queues; i++) {
1413 scrq = adapter->tx_scrq[i];
1414 scrq->irq = irq_create_mapping(NULL, scrq->hw_irq);
1415
99c1790e 1416 if (!scrq->irq) {
ea22d51a
TF		 1417 rc = -EINVAL;
1418 dev_err(dev, "Error mapping irq\n");
1419 goto req_tx_irq_failed;
1420 }
1421
1422 rc = request_irq(scrq->irq, ibmvnic_interrupt_tx,
1423 0, "ibmvnic_tx", scrq);
1424
1425 if (rc) {
1426 dev_err(dev, "Couldn't register tx irq 0x%x. rc=%d\n",
1427 scrq->irq, rc);
1428 irq_dispose_mapping(scrq->irq);
1429 goto req_rx_irq_failed;
1430 }
1431 }
1432
1433 for (i = 0; i < adapter->req_rx_queues; i++) {
1434 scrq = adapter->rx_scrq[i];
1435 scrq->irq = irq_create_mapping(NULL, scrq->hw_irq);
99c1790e 1436 if (!scrq->irq) {
ea22d51a
TF		 1437 rc = -EINVAL;
1438 dev_err(dev, "Error mapping irq\n");
1439 goto req_rx_irq_failed;
1440 }
1441 rc = request_irq(scrq->irq, ibmvnic_interrupt_rx,
1442 0, "ibmvnic_rx", scrq);
1443 if (rc) {
1444 dev_err(dev, "Couldn't register rx irq 0x%x. rc=%d\n",
1445 scrq->irq, rc);
1446 irq_dispose_mapping(scrq->irq);
1447 goto req_rx_irq_failed;
1448 }
1449 }
1450 return rc;
1451
1452req_rx_irq_failed:
8bf371e6 1453 for (j = 0; j < i; j++) {
ea22d51a
TF		 1454 free_irq(adapter->rx_scrq[j]->irq, adapter->rx_scrq[j]);
1455 irq_dispose_mapping(adapter->rx_scrq[j]->irq);
8bf371e6 1456 }
ea22d51a
TF		 1457 i = adapter->req_tx_queues;
1458req_tx_irq_failed:
8bf371e6 1459 for (j = 0; j < i; j++) {
ea22d51a
TF		 1460 free_irq(adapter->tx_scrq[j]->irq, adapter->tx_scrq[j]);
1461 irq_dispose_mapping(adapter->rx_scrq[j]->irq);
8bf371e6 1462 }
ea22d51a
TF		 1463 release_sub_crqs_no_irqs(adapter);
1464 return rc;
1465}
1466
032c5e82
TF		 1467static void init_sub_crqs(struct ibmvnic_adapter *adapter, int retry)
1468{
1469 struct device *dev = &adapter->vdev->dev;
1470 struct ibmvnic_sub_crq_queue **allqueues;
1471 int registered_queues = 0;
1472 union ibmvnic_crq crq;
1473 int total_queues;
1474 int more = 0;
ea22d51a 1475 int i;
032c5e82
TF		 1476
1477 if (!retry) {
1478 /* Sub-CRQ entries are 32 byte long */
1479 int entries_page = 4 * PAGE_SIZE / (sizeof(u64) * 4);
1480
1481 if (adapter->min_tx_entries_per_subcrq > entries_page ||
1482 adapter->min_rx_add_entries_per_subcrq > entries_page) {
1483 dev_err(dev, "Fatal, invalid entries per sub-crq\n");
1484 goto allqueues_failed;
1485 }
1486
1487 /* Get the minimum between the queried max and the entries
1488 * that fit in our PAGE_SIZE
1489 */
1490 adapter->req_tx_entries_per_subcrq =
1491 adapter->max_tx_entries_per_subcrq > entries_page ?
1492 entries_page : adapter->max_tx_entries_per_subcrq;
1493 adapter->req_rx_add_entries_per_subcrq =
1494 adapter->max_rx_add_entries_per_subcrq > entries_page ?
1495 entries_page : adapter->max_rx_add_entries_per_subcrq;
1496
6dbcd8fb
JA		 1497 adapter->req_tx_queues = adapter->opt_tx_comp_sub_queues;
1498 adapter->req_rx_queues = adapter->opt_rx_comp_queues;
498cd8e4 1499 adapter->req_rx_add_queues = adapter->max_rx_add_queues;
032c5e82 1500
f39f0d1e 1501 adapter->req_mtu = adapter->netdev->mtu + ETH_HLEN;
032c5e82
TF		 1502 }
1503
1504 total_queues = adapter->req_tx_queues + adapter->req_rx_queues;
1505
1506 allqueues = kcalloc(total_queues, sizeof(*allqueues), GFP_ATOMIC);
1507 if (!allqueues)
1508 goto allqueues_failed;
1509
1510 for (i = 0; i < total_queues; i++) {
1511 allqueues[i] = init_sub_crq_queue(adapter);
1512 if (!allqueues[i]) {
1513 dev_warn(dev, "Couldn't allocate all sub-crqs\n");
1514 break;
1515 }
1516 registered_queues++;
1517 }
1518
1519 /* Make sure we were able to register the minimum number of queues */
1520 if (registered_queues <
1521 adapter->min_tx_queues + adapter->min_rx_queues) {
1522 dev_err(dev, "Fatal: Couldn't init min number of sub-crqs\n");
1523 goto tx_failed;
1524 }
1525
1526 /* Distribute the failed allocated queues*/
1527 for (i = 0; i < total_queues - registered_queues + more ; i++) {
1528 netdev_dbg(adapter->netdev, "Reducing number of queues\n");
1529 switch (i % 3) {
1530 case 0:
1531 if (adapter->req_rx_queues > adapter->min_rx_queues)
1532 adapter->req_rx_queues--;
1533 else
1534 more++;
1535 break;
1536 case 1:
1537 if (adapter->req_tx_queues > adapter->min_tx_queues)
1538 adapter->req_tx_queues--;
1539 else
1540 more++;
1541 break;
1542 }
1543 }
1544
1545 adapter->tx_scrq = kcalloc(adapter->req_tx_queues,
1546 sizeof(*adapter->tx_scrq), GFP_ATOMIC);
1547 if (!adapter->tx_scrq)
1548 goto tx_failed;
1549
1550 for (i = 0; i < adapter->req_tx_queues; i++) {
1551 adapter->tx_scrq[i] = allqueues[i];
1552 adapter->tx_scrq[i]->pool_index = i;
032c5e82
TF		 1553 }
1554
1555 adapter->rx_scrq = kcalloc(adapter->req_rx_queues,
1556 sizeof(*adapter->rx_scrq), GFP_ATOMIC);
1557 if (!adapter->rx_scrq)
1558 goto rx_failed;
1559
1560 for (i = 0; i < adapter->req_rx_queues; i++) {
1561 adapter->rx_scrq[i] = allqueues[i + adapter->req_tx_queues];
1562 adapter->rx_scrq[i]->scrq_num = i;
032c5e82
TF		 1563 }
1564
1565 memset(&crq, 0, sizeof(crq));
1566 crq.request_capability.first = IBMVNIC_CRQ_CMD;
1567 crq.request_capability.cmd = REQUEST_CAPABILITY;
1568
1569 crq.request_capability.capability = cpu_to_be16(REQ_TX_QUEUES);
de89e854 1570 crq.request_capability.number = cpu_to_be64(adapter->req_tx_queues);
901e040a 1571 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1572 ibmvnic_send_crq(adapter, &crq);
1573
1574 crq.request_capability.capability = cpu_to_be16(REQ_RX_QUEUES);
de89e854 1575 crq.request_capability.number = cpu_to_be64(adapter->req_rx_queues);
901e040a 1576 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1577 ibmvnic_send_crq(adapter, &crq);
1578
1579 crq.request_capability.capability = cpu_to_be16(REQ_RX_ADD_QUEUES);
de89e854 1580 crq.request_capability.number = cpu_to_be64(adapter->req_rx_add_queues);
901e040a 1581 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1582 ibmvnic_send_crq(adapter, &crq);
1583
1584 crq.request_capability.capability =
1585 cpu_to_be16(REQ_TX_ENTRIES_PER_SUBCRQ);
1586 crq.request_capability.number =
de89e854 1587 cpu_to_be64(adapter->req_tx_entries_per_subcrq);
901e040a 1588 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1589 ibmvnic_send_crq(adapter, &crq);
1590
1591 crq.request_capability.capability =
1592 cpu_to_be16(REQ_RX_ADD_ENTRIES_PER_SUBCRQ);
1593 crq.request_capability.number =
de89e854 1594 cpu_to_be64(adapter->req_rx_add_entries_per_subcrq);
901e040a 1595 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1596 ibmvnic_send_crq(adapter, &crq);
1597
1598 crq.request_capability.capability = cpu_to_be16(REQ_MTU);
de89e854 1599 crq.request_capability.number = cpu_to_be64(adapter->req_mtu);
901e040a 1600 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1601 ibmvnic_send_crq(adapter, &crq);
1602
1603 if (adapter->netdev->flags & IFF_PROMISC) {
1604 if (adapter->promisc_supported) {
1605 crq.request_capability.capability =
1606 cpu_to_be16(PROMISC_REQUESTED);
de89e854 1607 crq.request_capability.number = cpu_to_be64(1);
901e040a 1608 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1609 ibmvnic_send_crq(adapter, &crq);
1610 }
1611 } else {
1612 crq.request_capability.capability =
1613 cpu_to_be16(PROMISC_REQUESTED);
de89e854 1614 crq.request_capability.number = cpu_to_be64(0);
901e040a 1615 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1616 ibmvnic_send_crq(adapter, &crq);
1617 }
1618
1619 kfree(allqueues);
1620
1621 return;
1622
032c5e82
TF		 1623rx_failed:
1624 kfree(adapter->tx_scrq);
1625 adapter->tx_scrq = NULL;
1626tx_failed:
1627 for (i = 0; i < registered_queues; i++)
1628 release_sub_crq_queue(adapter, allqueues[i]);
1629 kfree(allqueues);
1630allqueues_failed:
1631 ibmvnic_remove(adapter->vdev);
1632}
1633
1634static int pending_scrq(struct ibmvnic_adapter *adapter,
1635 struct ibmvnic_sub_crq_queue *scrq)
1636{
1637 union sub_crq *entry = &scrq->msgs[scrq->cur];
1638
1639 if (entry->generic.first & IBMVNIC_CRQ_CMD_RSP || adapter->closing)
1640 return 1;
1641 else
1642 return 0;
1643}
1644
1645static union sub_crq *ibmvnic_next_scrq(struct ibmvnic_adapter *adapter,
1646 struct ibmvnic_sub_crq_queue *scrq)
1647{
1648 union sub_crq *entry;
1649 unsigned long flags;
1650
1651 spin_lock_irqsave(&scrq->lock, flags);
1652 entry = &scrq->msgs[scrq->cur];
1653 if (entry->generic.first & IBMVNIC_CRQ_CMD_RSP) {
1654 if (++scrq->cur == scrq->size)
1655 scrq->cur = 0;
1656 } else {
1657 entry = NULL;
1658 }
1659 spin_unlock_irqrestore(&scrq->lock, flags);
1660
1661 return entry;
1662}
1663
1664static union ibmvnic_crq *ibmvnic_next_crq(struct ibmvnic_adapter *adapter)
1665{
1666 struct ibmvnic_crq_queue *queue = &adapter->crq;
1667 union ibmvnic_crq *crq;
1668
1669 crq = &queue->msgs[queue->cur];
1670 if (crq->generic.first & IBMVNIC_CRQ_CMD_RSP) {
1671 if (++queue->cur == queue->size)
1672 queue->cur = 0;
1673 } else {
1674 crq = NULL;
1675 }
1676
1677 return crq;
1678}
1679
1680static int send_subcrq(struct ibmvnic_adapter *adapter, u64 remote_handle,
1681 union sub_crq *sub_crq)
1682{
1683 unsigned int ua = adapter->vdev->unit_address;
1684 struct device *dev = &adapter->vdev->dev;
1685 u64 *u64_crq = (u64 *)sub_crq;
1686 int rc;
1687
1688 netdev_dbg(adapter->netdev,
1689 "Sending sCRQ %016lx: %016lx %016lx %016lx %016lx\n",
1690 (unsigned long int)cpu_to_be64(remote_handle),
1691 (unsigned long int)cpu_to_be64(u64_crq[0]),
1692 (unsigned long int)cpu_to_be64(u64_crq[1]),
1693 (unsigned long int)cpu_to_be64(u64_crq[2]),
1694 (unsigned long int)cpu_to_be64(u64_crq[3]));
1695
1696 /* Make sure the hypervisor sees the complete request */
1697 mb();
1698
1699 rc = plpar_hcall_norets(H_SEND_SUB_CRQ, ua,
1700 cpu_to_be64(remote_handle),
1701 cpu_to_be64(u64_crq[0]),
1702 cpu_to_be64(u64_crq[1]),
1703 cpu_to_be64(u64_crq[2]),
1704 cpu_to_be64(u64_crq[3]));
1705
1706 if (rc) {
1707 if (rc == H_CLOSED)
1708 dev_warn(dev, "CRQ Queue closed\n");
1709 dev_err(dev, "Send error (rc=%d)\n", rc);
1710 }
1711
1712 return rc;
1713}
1714
ad7775dc
TF		 1715static int send_subcrq_indirect(struct ibmvnic_adapter *adapter,
1716 u64 remote_handle, u64 ioba, u64 num_entries)
1717{
1718 unsigned int ua = adapter->vdev->unit_address;
1719 struct device *dev = &adapter->vdev->dev;
1720 int rc;
1721
1722 /* Make sure the hypervisor sees the complete request */
1723 mb();
1724 rc = plpar_hcall_norets(H_SEND_SUB_CRQ_INDIRECT, ua,
1725 cpu_to_be64(remote_handle),
1726 ioba, num_entries);
1727
1728 if (rc) {
1729 if (rc == H_CLOSED)
1730 dev_warn(dev, "CRQ Queue closed\n");
1731 dev_err(dev, "Send (indirect) error (rc=%d)\n", rc);
1732 }
1733
1734 return rc;
1735}
1736
032c5e82
TF		 1737static int ibmvnic_send_crq(struct ibmvnic_adapter *adapter,
1738 union ibmvnic_crq *crq)
1739{
1740 unsigned int ua = adapter->vdev->unit_address;
1741 struct device *dev = &adapter->vdev->dev;
1742 u64 *u64_crq = (u64 *)crq;
1743 int rc;
1744
1745 netdev_dbg(adapter->netdev, "Sending CRQ: %016lx %016lx\n",
1746 (unsigned long int)cpu_to_be64(u64_crq[0]),
1747 (unsigned long int)cpu_to_be64(u64_crq[1]));
1748
1749 /* Make sure the hypervisor sees the complete request */
1750 mb();
1751
1752 rc = plpar_hcall_norets(H_SEND_CRQ, ua,
1753 cpu_to_be64(u64_crq[0]),
1754 cpu_to_be64(u64_crq[1]));
1755
1756 if (rc) {
1757 if (rc == H_CLOSED)
1758 dev_warn(dev, "CRQ Queue closed\n");
1759 dev_warn(dev, "Send error (rc=%d)\n", rc);
1760 }
1761
1762 return rc;
1763}
1764
1765static int ibmvnic_send_crq_init(struct ibmvnic_adapter *adapter)
1766{
1767 union ibmvnic_crq crq;
1768
1769 memset(&crq, 0, sizeof(crq));
1770 crq.generic.first = IBMVNIC_CRQ_INIT_CMD;
1771 crq.generic.cmd = IBMVNIC_CRQ_INIT;
1772 netdev_dbg(adapter->netdev, "Sending CRQ init\n");
1773
1774 return ibmvnic_send_crq(adapter, &crq);
1775}
1776
1777static int ibmvnic_send_crq_init_complete(struct ibmvnic_adapter *adapter)
1778{
1779 union ibmvnic_crq crq;
1780
1781 memset(&crq, 0, sizeof(crq));
1782 crq.generic.first = IBMVNIC_CRQ_INIT_CMD;
1783 crq.generic.cmd = IBMVNIC_CRQ_INIT_COMPLETE;
1784 netdev_dbg(adapter->netdev, "Sending CRQ init complete\n");
1785
1786 return ibmvnic_send_crq(adapter, &crq);
1787}
1788
1789static int send_version_xchg(struct ibmvnic_adapter *adapter)
1790{
1791 union ibmvnic_crq crq;
1792
1793 memset(&crq, 0, sizeof(crq));
1794 crq.version_exchange.first = IBMVNIC_CRQ_CMD;
1795 crq.version_exchange.cmd = VERSION_EXCHANGE;
1796 crq.version_exchange.version = cpu_to_be16(ibmvnic_version);
1797
1798 return ibmvnic_send_crq(adapter, &crq);
1799}
1800
1801static void send_login(struct ibmvnic_adapter *adapter)
1802{
1803 struct ibmvnic_login_rsp_buffer *login_rsp_buffer;
1804 struct ibmvnic_login_buffer *login_buffer;
1805 struct ibmvnic_inflight_cmd *inflight_cmd;
1806 struct device *dev = &adapter->vdev->dev;
1807 dma_addr_t rsp_buffer_token;
1808 dma_addr_t buffer_token;
1809 size_t rsp_buffer_size;
1810 union ibmvnic_crq crq;
1811 unsigned long flags;
1812 size_t buffer_size;
1813 __be64 *tx_list_p;
1814 __be64 *rx_list_p;
1815 int i;
1816
1817 buffer_size =
1818 sizeof(struct ibmvnic_login_buffer) +
1819 sizeof(u64) * (adapter->req_tx_queues + adapter->req_rx_queues);
1820
1821 login_buffer = kmalloc(buffer_size, GFP_ATOMIC);
1822 if (!login_buffer)
1823 goto buf_alloc_failed;
1824
1825 buffer_token = dma_map_single(dev, login_buffer, buffer_size,
1826 DMA_TO_DEVICE);
1827 if (dma_mapping_error(dev, buffer_token)) {
1828 dev_err(dev, "Couldn't map login buffer\n");
1829 goto buf_map_failed;
1830 }
1831
498cd8e4
JA		 1832 rsp_buffer_size = sizeof(struct ibmvnic_login_rsp_buffer) +
1833 sizeof(u64) * adapter->req_tx_queues +
1834 sizeof(u64) * adapter->req_rx_queues +
1835 sizeof(u64) * adapter->req_rx_queues +
1836 sizeof(u8) * IBMVNIC_TX_DESC_VERSIONS;
032c5e82
TF		 1837
1838 login_rsp_buffer = kmalloc(rsp_buffer_size, GFP_ATOMIC);
1839 if (!login_rsp_buffer)
1840 goto buf_rsp_alloc_failed;
1841
1842 rsp_buffer_token = dma_map_single(dev, login_rsp_buffer,
1843 rsp_buffer_size, DMA_FROM_DEVICE);
1844 if (dma_mapping_error(dev, rsp_buffer_token)) {
1845 dev_err(dev, "Couldn't map login rsp buffer\n");
1846 goto buf_rsp_map_failed;
1847 }
1848 inflight_cmd = kmalloc(sizeof(*inflight_cmd), GFP_ATOMIC);
1849 if (!inflight_cmd) {
1850 dev_err(dev, "Couldn't allocate inflight_cmd\n");
1851 goto inflight_alloc_failed;
1852 }
1853 adapter->login_buf = login_buffer;
1854 adapter->login_buf_token = buffer_token;
1855 adapter->login_buf_sz = buffer_size;
1856 adapter->login_rsp_buf = login_rsp_buffer;
1857 adapter->login_rsp_buf_token = rsp_buffer_token;
1858 adapter->login_rsp_buf_sz = rsp_buffer_size;
1859
1860 login_buffer->len = cpu_to_be32(buffer_size);
1861 login_buffer->version = cpu_to_be32(INITIAL_VERSION_LB);
1862 login_buffer->num_txcomp_subcrqs = cpu_to_be32(adapter->req_tx_queues);
1863 login_buffer->off_txcomp_subcrqs =
1864 cpu_to_be32(sizeof(struct ibmvnic_login_buffer));
1865 login_buffer->num_rxcomp_subcrqs = cpu_to_be32(adapter->req_rx_queues);
1866 login_buffer->off_rxcomp_subcrqs =
1867 cpu_to_be32(sizeof(struct ibmvnic_login_buffer) +
1868 sizeof(u64) * adapter->req_tx_queues);
1869 login_buffer->login_rsp_ioba = cpu_to_be32(rsp_buffer_token);
1870 login_buffer->login_rsp_len = cpu_to_be32(rsp_buffer_size);
1871
1872 tx_list_p = (__be64 *)((char *)login_buffer +
1873 sizeof(struct ibmvnic_login_buffer));
1874 rx_list_p = (__be64 *)((char *)login_buffer +
1875 sizeof(struct ibmvnic_login_buffer) +
1876 sizeof(u64) * adapter->req_tx_queues);
1877
1878 for (i = 0; i < adapter->req_tx_queues; i++) {
1879 if (adapter->tx_scrq[i]) {
1880 tx_list_p[i] = cpu_to_be64(adapter->tx_scrq[i]->
1881 crq_num);
1882 }
1883 }
1884
1885 for (i = 0; i < adapter->req_rx_queues; i++) {
1886 if (adapter->rx_scrq[i]) {
1887 rx_list_p[i] = cpu_to_be64(adapter->rx_scrq[i]->
1888 crq_num);
1889 }
1890 }
1891
1892 netdev_dbg(adapter->netdev, "Login Buffer:\n");
1893 for (i = 0; i < (adapter->login_buf_sz - 1) / 8 + 1; i++) {
1894 netdev_dbg(adapter->netdev, "%016lx\n",
1895 ((unsigned long int *)(adapter->login_buf))[i]);
1896 }
1897
1898 memset(&crq, 0, sizeof(crq));
1899 crq.login.first = IBMVNIC_CRQ_CMD;
1900 crq.login.cmd = LOGIN;
1901 crq.login.ioba = cpu_to_be32(buffer_token);
1902 crq.login.len = cpu_to_be32(buffer_size);
1903
1904 memcpy(&inflight_cmd->crq, &crq, sizeof(crq));
1905
1906 spin_lock_irqsave(&adapter->inflight_lock, flags);
1907 list_add_tail(&inflight_cmd->list, &adapter->inflight);
1908 spin_unlock_irqrestore(&adapter->inflight_lock, flags);
1909
1910 ibmvnic_send_crq(adapter, &crq);
1911
1912 return;
1913
1914inflight_alloc_failed:
1915 dma_unmap_single(dev, rsp_buffer_token, rsp_buffer_size,
1916 DMA_FROM_DEVICE);
1917buf_rsp_map_failed:
1918 kfree(login_rsp_buffer);
1919buf_rsp_alloc_failed:
1920 dma_unmap_single(dev, buffer_token, buffer_size, DMA_TO_DEVICE);
1921buf_map_failed:
1922 kfree(login_buffer);
1923buf_alloc_failed:
1924 return;
1925}
1926
1927static void send_request_map(struct ibmvnic_adapter *adapter, dma_addr_t addr,
1928 u32 len, u8 map_id)
1929{
1930 union ibmvnic_crq crq;
1931
1932 memset(&crq, 0, sizeof(crq));
1933 crq.request_map.first = IBMVNIC_CRQ_CMD;
1934 crq.request_map.cmd = REQUEST_MAP;
1935 crq.request_map.map_id = map_id;
1936 crq.request_map.ioba = cpu_to_be32(addr);
1937 crq.request_map.len = cpu_to_be32(len);
1938 ibmvnic_send_crq(adapter, &crq);
1939}
1940
1941static void send_request_unmap(struct ibmvnic_adapter *adapter, u8 map_id)
1942{
1943 union ibmvnic_crq crq;
1944
1945 memset(&crq, 0, sizeof(crq));
1946 crq.request_unmap.first = IBMVNIC_CRQ_CMD;
1947 crq.request_unmap.cmd = REQUEST_UNMAP;
1948 crq.request_unmap.map_id = map_id;
1949 ibmvnic_send_crq(adapter, &crq);
1950}
1951
1952static void send_map_query(struct ibmvnic_adapter *adapter)
1953{
1954 union ibmvnic_crq crq;
1955
1956 memset(&crq, 0, sizeof(crq));
1957 crq.query_map.first = IBMVNIC_CRQ_CMD;
1958 crq.query_map.cmd = QUERY_MAP;
1959 ibmvnic_send_crq(adapter, &crq);
1960}
1961
1962/* Send a series of CRQs requesting various capabilities of the VNIC server */
1963static void send_cap_queries(struct ibmvnic_adapter *adapter)
1964{
1965 union ibmvnic_crq crq;
1966
901e040a 1967 atomic_set(&adapter->running_cap_crqs, 0);
032c5e82
TF		 1968 memset(&crq, 0, sizeof(crq));
1969 crq.query_capability.first = IBMVNIC_CRQ_CMD;
1970 crq.query_capability.cmd = QUERY_CAPABILITY;
1971
1972 crq.query_capability.capability = cpu_to_be16(MIN_TX_QUEUES);
901e040a 1973 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1974 ibmvnic_send_crq(adapter, &crq);
1975
1976 crq.query_capability.capability = cpu_to_be16(MIN_RX_QUEUES);
901e040a 1977 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1978 ibmvnic_send_crq(adapter, &crq);
1979
1980 crq.query_capability.capability = cpu_to_be16(MIN_RX_ADD_QUEUES);
901e040a 1981 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1982 ibmvnic_send_crq(adapter, &crq);
1983
1984 crq.query_capability.capability = cpu_to_be16(MAX_TX_QUEUES);
901e040a 1985 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1986 ibmvnic_send_crq(adapter, &crq);
1987
1988 crq.query_capability.capability = cpu_to_be16(MAX_RX_QUEUES);
901e040a 1989 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1990 ibmvnic_send_crq(adapter, &crq);
1991
1992 crq.query_capability.capability = cpu_to_be16(MAX_RX_ADD_QUEUES);
901e040a 1993 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1994 ibmvnic_send_crq(adapter, &crq);
1995
1996 crq.query_capability.capability =
1997 cpu_to_be16(MIN_TX_ENTRIES_PER_SUBCRQ);
901e040a 1998 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 1999 ibmvnic_send_crq(adapter, &crq);
2000
2001 crq.query_capability.capability =
2002 cpu_to_be16(MIN_RX_ADD_ENTRIES_PER_SUBCRQ);
901e040a 2003 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2004 ibmvnic_send_crq(adapter, &crq);
2005
2006 crq.query_capability.capability =
2007 cpu_to_be16(MAX_TX_ENTRIES_PER_SUBCRQ);
901e040a 2008 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2009 ibmvnic_send_crq(adapter, &crq);
2010
2011 crq.query_capability.capability =
2012 cpu_to_be16(MAX_RX_ADD_ENTRIES_PER_SUBCRQ);
901e040a 2013 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2014 ibmvnic_send_crq(adapter, &crq);
2015
2016 crq.query_capability.capability = cpu_to_be16(TCP_IP_OFFLOAD);
901e040a 2017 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2018 ibmvnic_send_crq(adapter, &crq);
2019
2020 crq.query_capability.capability = cpu_to_be16(PROMISC_SUPPORTED);
901e040a 2021 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2022 ibmvnic_send_crq(adapter, &crq);
2023
2024 crq.query_capability.capability = cpu_to_be16(MIN_MTU);
901e040a 2025 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2026 ibmvnic_send_crq(adapter, &crq);
2027
2028 crq.query_capability.capability = cpu_to_be16(MAX_MTU);
901e040a 2029 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2030 ibmvnic_send_crq(adapter, &crq);
2031
2032 crq.query_capability.capability = cpu_to_be16(MAX_MULTICAST_FILTERS);
901e040a 2033 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2034 ibmvnic_send_crq(adapter, &crq);
2035
2036 crq.query_capability.capability = cpu_to_be16(VLAN_HEADER_INSERTION);
901e040a 2037 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2038 ibmvnic_send_crq(adapter, &crq);
2039
2040 crq.query_capability.capability = cpu_to_be16(MAX_TX_SG_ENTRIES);
901e040a 2041 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2042 ibmvnic_send_crq(adapter, &crq);
2043
2044 crq.query_capability.capability = cpu_to_be16(RX_SG_SUPPORTED);
901e040a 2045 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2046 ibmvnic_send_crq(adapter, &crq);
2047
2048 crq.query_capability.capability = cpu_to_be16(OPT_TX_COMP_SUB_QUEUES);
901e040a 2049 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2050 ibmvnic_send_crq(adapter, &crq);
2051
2052 crq.query_capability.capability = cpu_to_be16(OPT_RX_COMP_QUEUES);
901e040a 2053 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2054 ibmvnic_send_crq(adapter, &crq);
2055
2056 crq.query_capability.capability =
2057 cpu_to_be16(OPT_RX_BUFADD_Q_PER_RX_COMP_Q);
901e040a 2058 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2059 ibmvnic_send_crq(adapter, &crq);
2060
2061 crq.query_capability.capability =
2062 cpu_to_be16(OPT_TX_ENTRIES_PER_SUBCRQ);
901e040a 2063 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2064 ibmvnic_send_crq(adapter, &crq);
2065
2066 crq.query_capability.capability =
2067 cpu_to_be16(OPT_RXBA_ENTRIES_PER_SUBCRQ);
901e040a 2068 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2069 ibmvnic_send_crq(adapter, &crq);
2070
2071 crq.query_capability.capability = cpu_to_be16(TX_RX_DESC_REQ);
901e040a 2072 atomic_inc(&adapter->running_cap_crqs);
032c5e82
TF		 2073 ibmvnic_send_crq(adapter, &crq);
2074}
2075
2076static void handle_query_ip_offload_rsp(struct ibmvnic_adapter *adapter)
2077{
2078 struct device *dev = &adapter->vdev->dev;
2079 struct ibmvnic_query_ip_offload_buffer *buf = &adapter->ip_offload_buf;
2080 union ibmvnic_crq crq;
2081 int i;
2082
2083 dma_unmap_single(dev, adapter->ip_offload_tok,
2084 sizeof(adapter->ip_offload_buf), DMA_FROM_DEVICE);
2085
2086 netdev_dbg(adapter->netdev, "Query IP Offload Buffer:\n");
2087 for (i = 0; i < (sizeof(adapter->ip_offload_buf) - 1) / 8 + 1; i++)
2088 netdev_dbg(adapter->netdev, "%016lx\n",
2089 ((unsigned long int *)(buf))[i]);
2090
2091 netdev_dbg(adapter->netdev, "ipv4_chksum = %d\n", buf->ipv4_chksum);
2092 netdev_dbg(adapter->netdev, "ipv6_chksum = %d\n", buf->ipv6_chksum);
2093 netdev_dbg(adapter->netdev, "tcp_ipv4_chksum = %d\n",
2094 buf->tcp_ipv4_chksum);
2095 netdev_dbg(adapter->netdev, "tcp_ipv6_chksum = %d\n",
2096 buf->tcp_ipv6_chksum);
2097 netdev_dbg(adapter->netdev, "udp_ipv4_chksum = %d\n",
2098 buf->udp_ipv4_chksum);
2099 netdev_dbg(adapter->netdev, "udp_ipv6_chksum = %d\n",
2100 buf->udp_ipv6_chksum);
2101 netdev_dbg(adapter->netdev, "large_tx_ipv4 = %d\n",
2102 buf->large_tx_ipv4);
2103 netdev_dbg(adapter->netdev, "large_tx_ipv6 = %d\n",
2104 buf->large_tx_ipv6);
2105 netdev_dbg(adapter->netdev, "large_rx_ipv4 = %d\n",
2106 buf->large_rx_ipv4);
2107 netdev_dbg(adapter->netdev, "large_rx_ipv6 = %d\n",
2108 buf->large_rx_ipv6);
2109 netdev_dbg(adapter->netdev, "max_ipv4_hdr_sz = %d\n",
2110 buf->max_ipv4_header_size);
2111 netdev_dbg(adapter->netdev, "max_ipv6_hdr_sz = %d\n",
2112 buf->max_ipv6_header_size);
2113 netdev_dbg(adapter->netdev, "max_tcp_hdr_size = %d\n",
2114 buf->max_tcp_header_size);
2115 netdev_dbg(adapter->netdev, "max_udp_hdr_size = %d\n",
2116 buf->max_udp_header_size);
2117 netdev_dbg(adapter->netdev, "max_large_tx_size = %d\n",
2118 buf->max_large_tx_size);
2119 netdev_dbg(adapter->netdev, "max_large_rx_size = %d\n",
2120 buf->max_large_rx_size);
2121 netdev_dbg(adapter->netdev, "ipv6_ext_hdr = %d\n",
2122 buf->ipv6_extension_header);
2123 netdev_dbg(adapter->netdev, "tcp_pseudosum_req = %d\n",
2124 buf->tcp_pseudosum_req);
2125 netdev_dbg(adapter->netdev, "num_ipv6_ext_hd = %d\n",
2126 buf->num_ipv6_ext_headers);
2127 netdev_dbg(adapter->netdev, "off_ipv6_ext_hd = %d\n",
2128 buf->off_ipv6_ext_headers);
2129
2130 adapter->ip_offload_ctrl_tok =
2131 dma_map_single(dev, &adapter->ip_offload_ctrl,
2132 sizeof(adapter->ip_offload_ctrl), DMA_TO_DEVICE);
2133
2134 if (dma_mapping_error(dev, adapter->ip_offload_ctrl_tok)) {
2135 dev_err(dev, "Couldn't map ip offload control buffer\n");
2136 return;
2137 }
2138
2139 adapter->ip_offload_ctrl.version = cpu_to_be32(INITIAL_VERSION_IOB);
2140 adapter->ip_offload_ctrl.tcp_ipv4_chksum = buf->tcp_ipv4_chksum;
2141 adapter->ip_offload_ctrl.udp_ipv4_chksum = buf->udp_ipv4_chksum;
2142 adapter->ip_offload_ctrl.tcp_ipv6_chksum = buf->tcp_ipv6_chksum;
2143 adapter->ip_offload_ctrl.udp_ipv6_chksum = buf->udp_ipv6_chksum;
2144
2145 /* large_tx/rx disabled for now, additional features needed */
2146 adapter->ip_offload_ctrl.large_tx_ipv4 = 0;
2147 adapter->ip_offload_ctrl.large_tx_ipv6 = 0;
2148 adapter->ip_offload_ctrl.large_rx_ipv4 = 0;
2149 adapter->ip_offload_ctrl.large_rx_ipv6 = 0;
2150
2151 adapter->netdev->features = NETIF_F_GSO;
2152
2153 if (buf->tcp_ipv4_chksum || buf->udp_ipv4_chksum)
2154 adapter->netdev->features |= NETIF_F_IP_CSUM;
2155
2156 if (buf->tcp_ipv6_chksum || buf->udp_ipv6_chksum)
2157 adapter->netdev->features |= NETIF_F_IPV6_CSUM;
2158
9be02cdf
TF		 2159 if ((adapter->netdev->features &
2160 (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM)))
2161 adapter->netdev->features |= NETIF_F_RXCSUM;
2162
032c5e82
TF		 2163 memset(&crq, 0, sizeof(crq));
2164 crq.control_ip_offload.first = IBMVNIC_CRQ_CMD;
2165 crq.control_ip_offload.cmd = CONTROL_IP_OFFLOAD;
2166 crq.control_ip_offload.len =
2167 cpu_to_be32(sizeof(adapter->ip_offload_ctrl));
2168 crq.control_ip_offload.ioba = cpu_to_be32(adapter->ip_offload_ctrl_tok);
2169 ibmvnic_send_crq(adapter, &crq);
2170}
2171
2172static void handle_error_info_rsp(union ibmvnic_crq *crq,
2173 struct ibmvnic_adapter *adapter)
2174{
2175 struct device *dev = &adapter->vdev->dev;
96183182 2176 struct ibmvnic_error_buff *error_buff, *tmp;
032c5e82
TF		 2177 unsigned long flags;
2178 bool found = false;
2179 int i;
2180
2181 if (!crq->request_error_rsp.rc.code) {
2182 dev_info(dev, "Request Error Rsp returned with rc=%x\n",
2183 crq->request_error_rsp.rc.code);
2184 return;
2185 }
2186
2187 spin_lock_irqsave(&adapter->error_list_lock, flags);
96183182 2188 list_for_each_entry_safe(error_buff, tmp, &adapter->errors, list)
032c5e82
TF		 2189 if (error_buff->error_id == crq->request_error_rsp.error_id) {
2190 found = true;
2191 list_del(&error_buff->list);
2192 break;
2193 }
2194 spin_unlock_irqrestore(&adapter->error_list_lock, flags);
2195
2196 if (!found) {
2197 dev_err(dev, "Couldn't find error id %x\n",
75224c93 2198 be32_to_cpu(crq->request_error_rsp.error_id));
032c5e82
TF		 2199 return;
2200 }
2201
2202 dev_err(dev, "Detailed info for error id %x:",
75224c93 2203 be32_to_cpu(crq->request_error_rsp.error_id));
032c5e82
TF		 2204
2205 for (i = 0; i < error_buff->len; i++) {
2206 pr_cont("%02x", (int)error_buff->buff[i]);
2207 if (i % 8 == 7)
2208 pr_cont(" ");
2209 }
2210 pr_cont("\n");
2211
2212 dma_unmap_single(dev, error_buff->dma, error_buff->len,
2213 DMA_FROM_DEVICE);
2214 kfree(error_buff->buff);
2215 kfree(error_buff);
2216}
2217
2218static void handle_dump_size_rsp(union ibmvnic_crq *crq,
2219 struct ibmvnic_adapter *adapter)
2220{
2221 int len = be32_to_cpu(crq->request_dump_size_rsp.len);
2222 struct ibmvnic_inflight_cmd *inflight_cmd;
2223 struct device *dev = &adapter->vdev->dev;
2224 union ibmvnic_crq newcrq;
2225 unsigned long flags;
2226
2227 /* allocate and map buffer */
2228 adapter->dump_data = kmalloc(len, GFP_KERNEL);
2229 if (!adapter->dump_data) {
2230 complete(&adapter->fw_done);
2231 return;
2232 }
2233
2234 adapter->dump_data_token = dma_map_single(dev, adapter->dump_data, len,
2235 DMA_FROM_DEVICE);
2236
2237 if (dma_mapping_error(dev, adapter->dump_data_token)) {
2238 if (!firmware_has_feature(FW_FEATURE_CMO))
2239 dev_err(dev, "Couldn't map dump data\n");
2240 kfree(adapter->dump_data);
2241 complete(&adapter->fw_done);
2242 return;
2243 }
2244
2245 inflight_cmd = kmalloc(sizeof(*inflight_cmd), GFP_ATOMIC);
2246 if (!inflight_cmd) {
2247 dma_unmap_single(dev, adapter->dump_data_token, len,
2248 DMA_FROM_DEVICE);
2249 kfree(adapter->dump_data);
2250 complete(&adapter->fw_done);
2251 return;
2252 }
2253
2254 memset(&newcrq, 0, sizeof(newcrq));
2255 newcrq.request_dump.first = IBMVNIC_CRQ_CMD;
2256 newcrq.request_dump.cmd = REQUEST_DUMP;
2257 newcrq.request_dump.ioba = cpu_to_be32(adapter->dump_data_token);
2258 newcrq.request_dump.len = cpu_to_be32(adapter->dump_data_size);
2259
2260 memcpy(&inflight_cmd->crq, &newcrq, sizeof(newcrq));
2261
2262 spin_lock_irqsave(&adapter->inflight_lock, flags);
2263 list_add_tail(&inflight_cmd->list, &adapter->inflight);
2264 spin_unlock_irqrestore(&adapter->inflight_lock, flags);
2265
2266 ibmvnic_send_crq(adapter, &newcrq);
2267}
2268
2269static void handle_error_indication(union ibmvnic_crq *crq,
2270 struct ibmvnic_adapter *adapter)
2271{
2272 int detail_len = be32_to_cpu(crq->error_indication.detail_error_sz);
2273 struct ibmvnic_inflight_cmd *inflight_cmd;
2274 struct device *dev = &adapter->vdev->dev;
2275 struct ibmvnic_error_buff *error_buff;
2276 union ibmvnic_crq new_crq;
2277 unsigned long flags;
2278
2279 dev_err(dev, "Firmware reports %serror id %x, cause %d\n",
2280 crq->error_indication.
2281 flags & IBMVNIC_FATAL_ERROR ? "FATAL " : "",
75224c93
TF		 2282 be32_to_cpu(crq->error_indication.error_id),
2283 be16_to_cpu(crq->error_indication.error_cause));
032c5e82
TF		 2284
2285 error_buff = kmalloc(sizeof(*error_buff), GFP_ATOMIC);
2286 if (!error_buff)
2287 return;
2288
2289 error_buff->buff = kmalloc(detail_len, GFP_ATOMIC);
2290 if (!error_buff->buff) {
2291 kfree(error_buff);
2292 return;
2293 }
2294
2295 error_buff->dma = dma_map_single(dev, error_buff->buff, detail_len,
2296 DMA_FROM_DEVICE);
2297 if (dma_mapping_error(dev, error_buff->dma)) {
2298 if (!firmware_has_feature(FW_FEATURE_CMO))
2299 dev_err(dev, "Couldn't map error buffer\n");
2300 kfree(error_buff->buff);
2301 kfree(error_buff);
2302 return;
2303 }
2304
2305 inflight_cmd = kmalloc(sizeof(*inflight_cmd), GFP_ATOMIC);
2306 if (!inflight_cmd) {
2307 dma_unmap_single(dev, error_buff->dma, detail_len,
2308 DMA_FROM_DEVICE);
2309 kfree(error_buff->buff);
2310 kfree(error_buff);
2311 return;
2312 }
2313
2314 error_buff->len = detail_len;
2315 error_buff->error_id = crq->error_indication.error_id;
2316
2317 spin_lock_irqsave(&adapter->error_list_lock, flags);
2318 list_add_tail(&error_buff->list, &adapter->errors);
2319 spin_unlock_irqrestore(&adapter->error_list_lock, flags);
2320
2321 memset(&new_crq, 0, sizeof(new_crq));
2322 new_crq.request_error_info.first = IBMVNIC_CRQ_CMD;
2323 new_crq.request_error_info.cmd = REQUEST_ERROR_INFO;
2324 new_crq.request_error_info.ioba = cpu_to_be32(error_buff->dma);
2325 new_crq.request_error_info.len = cpu_to_be32(detail_len);
2326 new_crq.request_error_info.error_id = crq->error_indication.error_id;
2327
2328 memcpy(&inflight_cmd->crq, &crq, sizeof(crq));
2329
2330 spin_lock_irqsave(&adapter->inflight_lock, flags);
2331 list_add_tail(&inflight_cmd->list, &adapter->inflight);
2332 spin_unlock_irqrestore(&adapter->inflight_lock, flags);
2333
2334 ibmvnic_send_crq(adapter, &new_crq);
2335}
2336
2337static void handle_change_mac_rsp(union ibmvnic_crq *crq,
2338 struct ibmvnic_adapter *adapter)
2339{
2340 struct net_device *netdev = adapter->netdev;
2341 struct device *dev = &adapter->vdev->dev;
2342 long rc;
2343
2344 rc = crq->change_mac_addr_rsp.rc.code;
2345 if (rc) {
2346 dev_err(dev, "Error %ld in CHANGE_MAC_ADDR_RSP\n", rc);
2347 return;
2348 }
2349 memcpy(netdev->dev_addr, &crq->change_mac_addr_rsp.mac_addr[0],
2350 ETH_ALEN);
2351}
2352
2353static void handle_request_cap_rsp(union ibmvnic_crq *crq,
2354 struct ibmvnic_adapter *adapter)
2355{
2356 struct device *dev = &adapter->vdev->dev;
2357 u64 *req_value;
2358 char *name;
2359
901e040a 2360 atomic_dec(&adapter->running_cap_crqs);
032c5e82
TF		 2361 switch (be16_to_cpu(crq->request_capability_rsp.capability)) {
2362 case REQ_TX_QUEUES:
2363 req_value = &adapter->req_tx_queues;
2364 name = "tx";
2365 break;
2366 case REQ_RX_QUEUES:
2367 req_value = &adapter->req_rx_queues;
2368 name = "rx";
2369 break;
2370 case REQ_RX_ADD_QUEUES:
2371 req_value = &adapter->req_rx_add_queues;
2372 name = "rx_add";
2373 break;
2374 case REQ_TX_ENTRIES_PER_SUBCRQ:
2375 req_value = &adapter->req_tx_entries_per_subcrq;
2376 name = "tx_entries_per_subcrq";
2377 break;
2378 case REQ_RX_ADD_ENTRIES_PER_SUBCRQ:
2379 req_value = &adapter->req_rx_add_entries_per_subcrq;
2380 name = "rx_add_entries_per_subcrq";
2381 break;
2382 case REQ_MTU:
2383 req_value = &adapter->req_mtu;
2384 name = "mtu";
2385 break;
2386 case PROMISC_REQUESTED:
2387 req_value = &adapter->promisc;
2388 name = "promisc";
2389 break;
2390 default:
2391 dev_err(dev, "Got invalid cap request rsp %d\n",
2392 crq->request_capability.capability);
2393 return;
2394 }
2395
2396 switch (crq->request_capability_rsp.rc.code) {
2397 case SUCCESS:
2398 break;
2399 case PARTIALSUCCESS:
2400 dev_info(dev, "req=%lld, rsp=%ld in %s queue, retrying.\n",
2401 *req_value,
28f4d165 2402 (long int)be64_to_cpu(crq->request_capability_rsp.
032c5e82 2403 number), name);
ea22d51a 2404 release_sub_crqs_no_irqs(adapter);
28f4d165 2405 *req_value = be64_to_cpu(crq->request_capability_rsp.number);
ea22d51a 2406 init_sub_crqs(adapter, 1);
032c5e82
TF		 2407 return;
2408 default:
2409 dev_err(dev, "Error %d in request cap rsp\n",
2410 crq->request_capability_rsp.rc.code);
2411 return;
2412 }
2413
2414 /* Done receiving requested capabilities, query IP offload support */
901e040a 2415 if (atomic_read(&adapter->running_cap_crqs) == 0) {
032c5e82
TF		 2416 union ibmvnic_crq newcrq;
2417 int buf_sz = sizeof(struct ibmvnic_query_ip_offload_buffer);
2418 struct ibmvnic_query_ip_offload_buffer *ip_offload_buf =
2419 &adapter->ip_offload_buf;
2420
2421 adapter->ip_offload_tok = dma_map_single(dev, ip_offload_buf,
2422 buf_sz,
2423 DMA_FROM_DEVICE);
2424
2425 if (dma_mapping_error(dev, adapter->ip_offload_tok)) {
2426 if (!firmware_has_feature(FW_FEATURE_CMO))
2427 dev_err(dev, "Couldn't map offload buffer\n");
2428 return;
2429 }
2430
2431 memset(&newcrq, 0, sizeof(newcrq));
2432 newcrq.query_ip_offload.first = IBMVNIC_CRQ_CMD;
2433 newcrq.query_ip_offload.cmd = QUERY_IP_OFFLOAD;
2434 newcrq.query_ip_offload.len = cpu_to_be32(buf_sz);
2435 newcrq.query_ip_offload.ioba =
2436 cpu_to_be32(adapter->ip_offload_tok);
2437
2438 ibmvnic_send_crq(adapter, &newcrq);
2439 }
2440}
2441
2442static int handle_login_rsp(union ibmvnic_crq *login_rsp_crq,
2443 struct ibmvnic_adapter *adapter)
2444{
2445 struct device *dev = &adapter->vdev->dev;
2446 struct ibmvnic_login_rsp_buffer *login_rsp = adapter->login_rsp_buf;
2447 struct ibmvnic_login_buffer *login = adapter->login_buf;
2448 union ibmvnic_crq crq;
2449 int i;
2450
2451 dma_unmap_single(dev, adapter->login_buf_token, adapter->login_buf_sz,
2452 DMA_BIDIRECTIONAL);
2453 dma_unmap_single(dev, adapter->login_rsp_buf_token,
2454 adapter->login_rsp_buf_sz, DMA_BIDIRECTIONAL);
2455
498cd8e4
JA		 2456 /* If the number of queues requested can't be allocated by the
2457 * server, the login response will return with code 1. We will need
2458 * to resend the login buffer with fewer queues requested.
2459 */
2460 if (login_rsp_crq->generic.rc.code) {
2461 adapter->renegotiate = true;
2462 complete(&adapter->init_done);
2463 return 0;
2464 }
2465
032c5e82
TF		 2466 netdev_dbg(adapter->netdev, "Login Response Buffer:\n");
2467 for (i = 0; i < (adapter->login_rsp_buf_sz - 1) / 8 + 1; i++) {
2468 netdev_dbg(adapter->netdev, "%016lx\n",
2469 ((unsigned long int *)(adapter->login_rsp_buf))[i]);
2470 }
2471
2472 /* Sanity checks */
2473 if (login->num_txcomp_subcrqs != login_rsp->num_txsubm_subcrqs ||
2474 (be32_to_cpu(login->num_rxcomp_subcrqs) *
2475 adapter->req_rx_add_queues !=
2476 be32_to_cpu(login_rsp->num_rxadd_subcrqs))) {
2477 dev_err(dev, "FATAL: Inconsistent login and login rsp\n");
2478 ibmvnic_remove(adapter->vdev);
2479 return -EIO;
2480 }
2481 complete(&adapter->init_done);
2482
2483 memset(&crq, 0, sizeof(crq));
2484 crq.request_ras_comp_num.first = IBMVNIC_CRQ_CMD;
2485 crq.request_ras_comp_num.cmd = REQUEST_RAS_COMP_NUM;
2486 ibmvnic_send_crq(adapter, &crq);
2487
2488 return 0;
2489}
2490
2491static void handle_request_map_rsp(union ibmvnic_crq *crq,
2492 struct ibmvnic_adapter *adapter)
2493{
2494 struct device *dev = &adapter->vdev->dev;
2495 u8 map_id = crq->request_map_rsp.map_id;
2496 int tx_subcrqs;
2497 int rx_subcrqs;
2498 long rc;
2499 int i;
2500
2501 tx_subcrqs = be32_to_cpu(adapter->login_rsp_buf->num_txsubm_subcrqs);
2502 rx_subcrqs = be32_to_cpu(adapter->login_rsp_buf->num_rxadd_subcrqs);
2503
2504 rc = crq->request_map_rsp.rc.code;
2505 if (rc) {
2506 dev_err(dev, "Error %ld in REQUEST_MAP_RSP\n", rc);
2507 adapter->map_id--;
2508 /* need to find and zero tx/rx_pool map_id */
2509 for (i = 0; i < tx_subcrqs; i++) {
2510 if (adapter->tx_pool[i].long_term_buff.map_id == map_id)
2511 adapter->tx_pool[i].long_term_buff.map_id = 0;
2512 }
2513 for (i = 0; i < rx_subcrqs; i++) {
2514 if (adapter->rx_pool[i].long_term_buff.map_id == map_id)
2515 adapter->rx_pool[i].long_term_buff.map_id = 0;
2516 }
2517 }
2518 complete(&adapter->fw_done);
2519}
2520
2521static void handle_request_unmap_rsp(union ibmvnic_crq *crq,
2522 struct ibmvnic_adapter *adapter)
2523{
2524 struct device *dev = &adapter->vdev->dev;
2525 long rc;
2526
2527 rc = crq->request_unmap_rsp.rc.code;
2528 if (rc)
2529 dev_err(dev, "Error %ld in REQUEST_UNMAP_RSP\n", rc);
2530}
2531
2532static void handle_query_map_rsp(union ibmvnic_crq *crq,
2533 struct ibmvnic_adapter *adapter)
2534{
2535 struct net_device *netdev = adapter->netdev;
2536 struct device *dev = &adapter->vdev->dev;
2537 long rc;
2538
2539 rc = crq->query_map_rsp.rc.code;
2540 if (rc) {
2541 dev_err(dev, "Error %ld in QUERY_MAP_RSP\n", rc);
2542 return;
2543 }
2544 netdev_dbg(netdev, "page_size = %d\ntot_pages = %d\nfree_pages = %d\n",
2545 crq->query_map_rsp.page_size, crq->query_map_rsp.tot_pages,
2546 crq->query_map_rsp.free_pages);
2547}
2548
2549static void handle_query_cap_rsp(union ibmvnic_crq *crq,
2550 struct ibmvnic_adapter *adapter)
2551{
2552 struct net_device *netdev = adapter->netdev;
2553 struct device *dev = &adapter->vdev->dev;
2554 long rc;
2555
901e040a 2556 atomic_dec(&adapter->running_cap_crqs);
032c5e82 2557 netdev_dbg(netdev, "Outstanding queries: %d\n",
901e040a 2558 atomic_read(&adapter->running_cap_crqs));
032c5e82
TF		 2559 rc = crq->query_capability.rc.code;
2560 if (rc) {
2561 dev_err(dev, "Error %ld in QUERY_CAP_RSP\n", rc);
2562 goto out;
2563 }
2564
2565 switch (be16_to_cpu(crq->query_capability.capability)) {
2566 case MIN_TX_QUEUES:
2567 adapter->min_tx_queues =
de89e854 2568 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2569 netdev_dbg(netdev, "min_tx_queues = %lld\n",
2570 adapter->min_tx_queues);
2571 break;
2572 case MIN_RX_QUEUES:
2573 adapter->min_rx_queues =
de89e854 2574 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2575 netdev_dbg(netdev, "min_rx_queues = %lld\n",
2576 adapter->min_rx_queues);
2577 break;
2578 case MIN_RX_ADD_QUEUES:
2579 adapter->min_rx_add_queues =
de89e854 2580 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2581 netdev_dbg(netdev, "min_rx_add_queues = %lld\n",
2582 adapter->min_rx_add_queues);
2583 break;
2584 case MAX_TX_QUEUES:
2585 adapter->max_tx_queues =
de89e854 2586 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2587 netdev_dbg(netdev, "max_tx_queues = %lld\n",
2588 adapter->max_tx_queues);
2589 break;
2590 case MAX_RX_QUEUES:
2591 adapter->max_rx_queues =
de89e854 2592 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2593 netdev_dbg(netdev, "max_rx_queues = %lld\n",
2594 adapter->max_rx_queues);
2595 break;
2596 case MAX_RX_ADD_QUEUES:
2597 adapter->max_rx_add_queues =
de89e854 2598 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2599 netdev_dbg(netdev, "max_rx_add_queues = %lld\n",
2600 adapter->max_rx_add_queues);
2601 break;
2602 case MIN_TX_ENTRIES_PER_SUBCRQ:
2603 adapter->min_tx_entries_per_subcrq =
de89e854 2604 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2605 netdev_dbg(netdev, "min_tx_entries_per_subcrq = %lld\n",
2606 adapter->min_tx_entries_per_subcrq);
2607 break;
2608 case MIN_RX_ADD_ENTRIES_PER_SUBCRQ:
2609 adapter->min_rx_add_entries_per_subcrq =
de89e854 2610 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2611 netdev_dbg(netdev, "min_rx_add_entrs_per_subcrq = %lld\n",
2612 adapter->min_rx_add_entries_per_subcrq);
2613 break;
2614 case MAX_TX_ENTRIES_PER_SUBCRQ:
2615 adapter->max_tx_entries_per_subcrq =
de89e854 2616 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2617 netdev_dbg(netdev, "max_tx_entries_per_subcrq = %lld\n",
2618 adapter->max_tx_entries_per_subcrq);
2619 break;
2620 case MAX_RX_ADD_ENTRIES_PER_SUBCRQ:
2621 adapter->max_rx_add_entries_per_subcrq =
de89e854 2622 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2623 netdev_dbg(netdev, "max_rx_add_entrs_per_subcrq = %lld\n",
2624 adapter->max_rx_add_entries_per_subcrq);
2625 break;
2626 case TCP_IP_OFFLOAD:
2627 adapter->tcp_ip_offload =
de89e854 2628 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2629 netdev_dbg(netdev, "tcp_ip_offload = %lld\n",
2630 adapter->tcp_ip_offload);
2631 break;
2632 case PROMISC_SUPPORTED:
2633 adapter->promisc_supported =
de89e854 2634 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2635 netdev_dbg(netdev, "promisc_supported = %lld\n",
2636 adapter->promisc_supported);
2637 break;
2638 case MIN_MTU:
de89e854 2639 adapter->min_mtu = be64_to_cpu(crq->query_capability.number);
f39f0d1e 2640 netdev->min_mtu = adapter->min_mtu - ETH_HLEN;
032c5e82
TF		 2641 netdev_dbg(netdev, "min_mtu = %lld\n", adapter->min_mtu);
2642 break;
2643 case MAX_MTU:
de89e854 2644 adapter->max_mtu = be64_to_cpu(crq->query_capability.number);
f39f0d1e 2645 netdev->max_mtu = adapter->max_mtu - ETH_HLEN;
032c5e82
TF		 2646 netdev_dbg(netdev, "max_mtu = %lld\n", adapter->max_mtu);
2647 break;
2648 case MAX_MULTICAST_FILTERS:
2649 adapter->max_multicast_filters =
de89e854 2650 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2651 netdev_dbg(netdev, "max_multicast_filters = %lld\n",
2652 adapter->max_multicast_filters);
2653 break;
2654 case VLAN_HEADER_INSERTION:
2655 adapter->vlan_header_insertion =
de89e854 2656 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2657 if (adapter->vlan_header_insertion)
2658 netdev->features |= NETIF_F_HW_VLAN_STAG_TX;
2659 netdev_dbg(netdev, "vlan_header_insertion = %lld\n",
2660 adapter->vlan_header_insertion);
2661 break;
2662 case MAX_TX_SG_ENTRIES:
2663 adapter->max_tx_sg_entries =
de89e854 2664 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2665 netdev_dbg(netdev, "max_tx_sg_entries = %lld\n",
2666 adapter->max_tx_sg_entries);
2667 break;
2668 case RX_SG_SUPPORTED:
2669 adapter->rx_sg_supported =
de89e854 2670 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2671 netdev_dbg(netdev, "rx_sg_supported = %lld\n",
2672 adapter->rx_sg_supported);
2673 break;
2674 case OPT_TX_COMP_SUB_QUEUES:
2675 adapter->opt_tx_comp_sub_queues =
de89e854 2676 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2677 netdev_dbg(netdev, "opt_tx_comp_sub_queues = %lld\n",
2678 adapter->opt_tx_comp_sub_queues);
2679 break;
2680 case OPT_RX_COMP_QUEUES:
2681 adapter->opt_rx_comp_queues =
de89e854 2682 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2683 netdev_dbg(netdev, "opt_rx_comp_queues = %lld\n",
2684 adapter->opt_rx_comp_queues);
2685 break;
2686 case OPT_RX_BUFADD_Q_PER_RX_COMP_Q:
2687 adapter->opt_rx_bufadd_q_per_rx_comp_q =
de89e854 2688 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2689 netdev_dbg(netdev, "opt_rx_bufadd_q_per_rx_comp_q = %lld\n",
2690 adapter->opt_rx_bufadd_q_per_rx_comp_q);
2691 break;
2692 case OPT_TX_ENTRIES_PER_SUBCRQ:
2693 adapter->opt_tx_entries_per_subcrq =
de89e854 2694 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2695 netdev_dbg(netdev, "opt_tx_entries_per_subcrq = %lld\n",
2696 adapter->opt_tx_entries_per_subcrq);
2697 break;
2698 case OPT_RXBA_ENTRIES_PER_SUBCRQ:
2699 adapter->opt_rxba_entries_per_subcrq =
de89e854 2700 be64_to_cpu(crq->query_capability.number);
032c5e82
TF		 2701 netdev_dbg(netdev, "opt_rxba_entries_per_subcrq = %lld\n",
2702 adapter->opt_rxba_entries_per_subcrq);
2703 break;
2704 case TX_RX_DESC_REQ:
2705 adapter->tx_rx_desc_req = crq->query_capability.number;
2706 netdev_dbg(netdev, "tx_rx_desc_req = %llx\n",
2707 adapter->tx_rx_desc_req);
2708 break;
2709
2710 default:
2711 netdev_err(netdev, "Got invalid cap rsp %d\n",
2712 crq->query_capability.capability);
2713 }
2714
2715out:
901e040a 2716 if (atomic_read(&adapter->running_cap_crqs) == 0)
ea22d51a 2717 init_sub_crqs(adapter, 0);
032c5e82
TF		 2718 /* We're done querying the capabilities, initialize sub-crqs */
2719}
2720
2721static void handle_control_ras_rsp(union ibmvnic_crq *crq,
2722 struct ibmvnic_adapter *adapter)
2723{
2724 u8 correlator = crq->control_ras_rsp.correlator;
2725 struct device *dev = &adapter->vdev->dev;
2726 bool found = false;
2727 int i;
2728
2729 if (crq->control_ras_rsp.rc.code) {
2730 dev_warn(dev, "Control ras failed rc=%d\n",
2731 crq->control_ras_rsp.rc.code);
2732 return;
2733 }
2734
2735 for (i = 0; i < adapter->ras_comp_num; i++) {
2736 if (adapter->ras_comps[i].correlator == correlator) {
2737 found = true;
2738 break;
2739 }
2740 }
2741
2742 if (!found) {
2743 dev_warn(dev, "Correlator not found on control_ras_rsp\n");
2744 return;
2745 }
2746
2747 switch (crq->control_ras_rsp.op) {
2748 case IBMVNIC_TRACE_LEVEL:
2749 adapter->ras_comps[i].trace_level = crq->control_ras.level;
2750 break;
2751 case IBMVNIC_ERROR_LEVEL:
2752 adapter->ras_comps[i].error_check_level =
2753 crq->control_ras.level;
2754 break;
2755 case IBMVNIC_TRACE_PAUSE:
2756 adapter->ras_comp_int[i].paused = 1;
2757 break;
2758 case IBMVNIC_TRACE_RESUME:
2759 adapter->ras_comp_int[i].paused = 0;
2760 break;
2761 case IBMVNIC_TRACE_ON:
2762 adapter->ras_comps[i].trace_on = 1;
2763 break;
2764 case IBMVNIC_TRACE_OFF:
2765 adapter->ras_comps[i].trace_on = 0;
2766 break;
2767 case IBMVNIC_CHG_TRACE_BUFF_SZ:
2768 /* trace_buff_sz is 3 bytes, stuff it into an int */
2769 ((u8 *)(&adapter->ras_comps[i].trace_buff_size))[0] = 0;
2770 ((u8 *)(&adapter->ras_comps[i].trace_buff_size))[1] =
2771 crq->control_ras_rsp.trace_buff_sz[0];
2772 ((u8 *)(&adapter->ras_comps[i].trace_buff_size))[2] =
2773 crq->control_ras_rsp.trace_buff_sz[1];
2774 ((u8 *)(&adapter->ras_comps[i].trace_buff_size))[3] =
2775 crq->control_ras_rsp.trace_buff_sz[2];
2776 break;
2777 default:
2778 dev_err(dev, "invalid op %d on control_ras_rsp",
2779 crq->control_ras_rsp.op);
2780 }
2781}
2782
032c5e82
TF		 2783static ssize_t trace_read(struct file *file, char __user *user_buf, size_t len,
2784 loff_t *ppos)
2785{
2786 struct ibmvnic_fw_comp_internal *ras_comp_int = file->private_data;
2787 struct ibmvnic_adapter *adapter = ras_comp_int->adapter;
2788 struct device *dev = &adapter->vdev->dev;
2789 struct ibmvnic_fw_trace_entry *trace;
2790 int num = ras_comp_int->num;
2791 union ibmvnic_crq crq;
2792 dma_addr_t trace_tok;
2793
2794 if (*ppos >= be32_to_cpu(adapter->ras_comps[num].trace_buff_size))
2795 return 0;
2796
2797 trace =
2798 dma_alloc_coherent(dev,
2799 be32_to_cpu(adapter->ras_comps[num].
2800 trace_buff_size), &trace_tok,
2801 GFP_KERNEL);
2802 if (!trace) {
2803 dev_err(dev, "Couldn't alloc trace buffer\n");
2804 return 0;
2805 }
2806
2807 memset(&crq, 0, sizeof(crq));
2808 crq.collect_fw_trace.first = IBMVNIC_CRQ_CMD;
2809 crq.collect_fw_trace.cmd = COLLECT_FW_TRACE;
2810 crq.collect_fw_trace.correlator = adapter->ras_comps[num].correlator;
2811 crq.collect_fw_trace.ioba = cpu_to_be32(trace_tok);
2812 crq.collect_fw_trace.len = adapter->ras_comps[num].trace_buff_size;
032c5e82
TF		 2813
2814 init_completion(&adapter->fw_done);
db5d0b59 2815 ibmvnic_send_crq(adapter, &crq);
032c5e82
TF		 2816 wait_for_completion(&adapter->fw_done);
2817
2818 if (*ppos + len > be32_to_cpu(adapter->ras_comps[num].trace_buff_size))
2819 len =
2820 be32_to_cpu(adapter->ras_comps[num].trace_buff_size) -
2821 *ppos;
2822
2823 copy_to_user(user_buf, &((u8 *)trace)[*ppos], len);
2824
2825 dma_free_coherent(dev,
2826 be32_to_cpu(adapter->ras_comps[num].trace_buff_size),
2827 trace, trace_tok);
2828 *ppos += len;
2829 return len;
2830}
2831
2832static const struct file_operations trace_ops = {
2833 .owner = THIS_MODULE,
7a95e94c 2834 .open = simple_open,
032c5e82
TF		 2835 .read = trace_read,
2836};
2837
2838static ssize_t paused_read(struct file *file, char __user *user_buf, size_t len,
2839 loff_t *ppos)
2840{
2841 struct ibmvnic_fw_comp_internal *ras_comp_int = file->private_data;
2842 struct ibmvnic_adapter *adapter = ras_comp_int->adapter;
2843 int num = ras_comp_int->num;
2844 char buff[5]; /* 1 or 0 plus \n and \0 */
2845 int size;
2846
2847 size = sprintf(buff, "%d\n", adapter->ras_comp_int[num].paused);
2848
2849 if (*ppos >= size)
2850 return 0;
2851
2852 copy_to_user(user_buf, buff, size);
2853 *ppos += size;
2854 return size;
2855}
2856
2857static ssize_t paused_write(struct file *file, const char __user *user_buf,
2858 size_t len, loff_t *ppos)
2859{
2860 struct ibmvnic_fw_comp_internal *ras_comp_int = file->private_data;
2861 struct ibmvnic_adapter *adapter = ras_comp_int->adapter;
2862 int num = ras_comp_int->num;
2863 union ibmvnic_crq crq;
2864 unsigned long val;
2865 char buff[9]; /* decimal max int plus \n and \0 */
2866
2867 copy_from_user(buff, user_buf, sizeof(buff));
2868 val = kstrtoul(buff, 10, NULL);
2869
2870 adapter->ras_comp_int[num].paused = val ? 1 : 0;
2871
2872 memset(&crq, 0, sizeof(crq));
2873 crq.control_ras.first = IBMVNIC_CRQ_CMD;
2874 crq.control_ras.cmd = CONTROL_RAS;
2875 crq.control_ras.correlator = adapter->ras_comps[num].correlator;
2876 crq.control_ras.op = val ? IBMVNIC_TRACE_PAUSE : IBMVNIC_TRACE_RESUME;
2877 ibmvnic_send_crq(adapter, &crq);
2878
2879 return len;
2880}
2881
2882static const struct file_operations paused_ops = {
2883 .owner = THIS_MODULE,
7a95e94c 2884 .open = simple_open,
032c5e82
TF		 2885 .read = paused_read,
2886 .write = paused_write,
2887};
2888
2889static ssize_t tracing_read(struct file *file, char __user *user_buf,
2890 size_t len, loff_t *ppos)
2891{
2892 struct ibmvnic_fw_comp_internal *ras_comp_int = file->private_data;
2893 struct ibmvnic_adapter *adapter = ras_comp_int->adapter;
2894 int num = ras_comp_int->num;
2895 char buff[5]; /* 1 or 0 plus \n and \0 */
2896 int size;
2897
2898 size = sprintf(buff, "%d\n", adapter->ras_comps[num].trace_on);
2899
2900 if (*ppos >= size)
2901 return 0;
2902
2903 copy_to_user(user_buf, buff, size);
2904 *ppos += size;
2905 return size;
2906}
2907
2908static ssize_t tracing_write(struct file *file, const char __user *user_buf,
2909 size_t len, loff_t *ppos)
2910{
2911 struct ibmvnic_fw_comp_internal *ras_comp_int = file->private_data;
2912 struct ibmvnic_adapter *adapter = ras_comp_int->adapter;
2913 int num = ras_comp_int->num;
2914 union ibmvnic_crq crq;
2915 unsigned long val;
2916 char buff[9]; /* decimal max int plus \n and \0 */
2917
2918 copy_from_user(buff, user_buf, sizeof(buff));
2919 val = kstrtoul(buff, 10, NULL);
2920
2921 memset(&crq, 0, sizeof(crq));
2922 crq.control_ras.first = IBMVNIC_CRQ_CMD;
2923 crq.control_ras.cmd = CONTROL_RAS;
2924 crq.control_ras.correlator = adapter->ras_comps[num].correlator;
2925 crq.control_ras.op = val ? IBMVNIC_TRACE_ON : IBMVNIC_TRACE_OFF;
2926
2927 return len;
2928}
2929
2930static const struct file_operations tracing_ops = {
2931 .owner = THIS_MODULE,
7a95e94c 2932 .open = simple_open,
032c5e82
TF		 2933 .read = tracing_read,
2934 .write = tracing_write,
2935};
2936
2937static ssize_t error_level_read(struct file *file, char __user *user_buf,
2938 size_t len, loff_t *ppos)
2939{
2940 struct ibmvnic_fw_comp_internal *ras_comp_int = file->private_data;
2941 struct ibmvnic_adapter *adapter = ras_comp_int->adapter;
2942 int num = ras_comp_int->num;
2943 char buff[5]; /* decimal max char plus \n and \0 */
2944 int size;
2945
2946 size = sprintf(buff, "%d\n", adapter->ras_comps[num].error_check_level);
2947
2948 if (*ppos >= size)
2949 return 0;
2950
2951 copy_to_user(user_buf, buff, size);
2952 *ppos += size;
2953 return size;
2954}
2955
2956static ssize_t error_level_write(struct file *file, const char __user *user_buf,
2957 size_t len, loff_t *ppos)
2958{
2959 struct ibmvnic_fw_comp_internal *ras_comp_int = file->private_data;
2960 struct ibmvnic_adapter *adapter = ras_comp_int->adapter;
2961 int num = ras_comp_int->num;
2962 union ibmvnic_crq crq;
2963 unsigned long val;
2964 char buff[9]; /* decimal max int plus \n and \0 */
2965
2966 copy_from_user(buff, user_buf, sizeof(buff));
2967 val = kstrtoul(buff, 10, NULL);
2968
2969 if (val > 9)
2970 val = 9;
2971
2972 memset(&crq, 0, sizeof(crq));
2973 crq.control_ras.first = IBMVNIC_CRQ_CMD;
2974 crq.control_ras.cmd = CONTROL_RAS;
2975 crq.control_ras.correlator = adapter->ras_comps[num].correlator;
2976 crq.control_ras.op = IBMVNIC_ERROR_LEVEL;
2977 crq.control_ras.level = val;
2978 ibmvnic_send_crq(adapter, &crq);
2979
2980 return len;
2981}
2982
2983static const struct file_operations error_level_ops = {
2984 .owner = THIS_MODULE,
7a95e94c 2985 .open = simple_open,
032c5e82
TF		 2986 .read = error_level_read,
2987 .write = error_level_write,
2988};
2989
2990static ssize_t trace_level_read(struct file *file, char __user *user_buf,
2991 size_t len, loff_t *ppos)
2992{
2993 struct ibmvnic_fw_comp_internal *ras_comp_int = file->private_data;
2994 struct ibmvnic_adapter *adapter = ras_comp_int->adapter;
2995 int num = ras_comp_int->num;
2996 char buff[5]; /* decimal max char plus \n and \0 */
2997 int size;
2998
2999 size = sprintf(buff, "%d\n", adapter->ras_comps[num].trace_level);
3000 if (*ppos >= size)
3001 return 0;
3002
3003 copy_to_user(user_buf, buff, size);
3004 *ppos += size;
3005 return size;
3006}
3007
3008static ssize_t trace_level_write(struct file *file, const char __user *user_buf,
3009 size_t len, loff_t *ppos)
3010{
3011 struct ibmvnic_fw_comp_internal *ras_comp_int = file->private_data;
3012 struct ibmvnic_adapter *adapter = ras_comp_int->adapter;
3013 union ibmvnic_crq crq;
3014 unsigned long val;
3015 char buff[9]; /* decimal max int plus \n and \0 */
3016
3017 copy_from_user(buff, user_buf, sizeof(buff));
3018 val = kstrtoul(buff, 10, NULL);
3019 if (val > 9)
3020 val = 9;
3021
3022 memset(&crq, 0, sizeof(crq));
3023 crq.control_ras.first = IBMVNIC_CRQ_CMD;
3024 crq.control_ras.cmd = CONTROL_RAS;
3025 crq.control_ras.correlator =
3026 adapter->ras_comps[ras_comp_int->num].correlator;
3027 crq.control_ras.op = IBMVNIC_TRACE_LEVEL;
3028 crq.control_ras.level = val;
3029 ibmvnic_send_crq(adapter, &crq);
3030
3031 return len;
3032}
3033
3034static const struct file_operations trace_level_ops = {
3035 .owner = THIS_MODULE,
7a95e94c 3036 .open = simple_open,
032c5e82
TF		 3037 .read = trace_level_read,
3038 .write = trace_level_write,
3039};
3040
3041static ssize_t trace_buff_size_read(struct file *file, char __user *user_buf,
3042 size_t len, loff_t *ppos)
3043{
3044 struct ibmvnic_fw_comp_internal *ras_comp_int = file->private_data;
3045 struct ibmvnic_adapter *adapter = ras_comp_int->adapter;
3046 int num = ras_comp_int->num;
3047 char buff[9]; /* decimal max int plus \n and \0 */
3048 int size;
3049
3050 size = sprintf(buff, "%d\n", adapter->ras_comps[num].trace_buff_size);
3051 if (*ppos >= size)
3052 return 0;
3053
3054 copy_to_user(user_buf, buff, size);
3055 *ppos += size;
3056 return size;
3057}
3058
3059static ssize_t trace_buff_size_write(struct file *file,
3060 const char __user *user_buf, size_t len,
3061 loff_t *ppos)
3062{
3063 struct ibmvnic_fw_comp_internal *ras_comp_int = file->private_data;
3064 struct ibmvnic_adapter *adapter = ras_comp_int->adapter;
3065 union ibmvnic_crq crq;
3066 unsigned long val;
3067 char buff[9]; /* decimal max int plus \n and \0 */
3068
3069 copy_from_user(buff, user_buf, sizeof(buff));
3070 val = kstrtoul(buff, 10, NULL);
3071
3072 memset(&crq, 0, sizeof(crq));
3073 crq.control_ras.first = IBMVNIC_CRQ_CMD;
3074 crq.control_ras.cmd = CONTROL_RAS;
3075 crq.control_ras.correlator =
3076 adapter->ras_comps[ras_comp_int->num].correlator;
3077 crq.control_ras.op = IBMVNIC_CHG_TRACE_BUFF_SZ;
3078 /* trace_buff_sz is 3 bytes, stuff an int into it */
3079 crq.control_ras.trace_buff_sz[0] = ((u8 *)(&val))[5];
3080 crq.control_ras.trace_buff_sz[1] = ((u8 *)(&val))[6];
3081 crq.control_ras.trace_buff_sz[2] = ((u8 *)(&val))[7];
3082 ibmvnic_send_crq(adapter, &crq);
3083
3084 return len;
3085}
3086
3087static const struct file_operations trace_size_ops = {
3088 .owner = THIS_MODULE,
7a95e94c 3089 .open = simple_open,
032c5e82
TF		 3090 .read = trace_buff_size_read,
3091 .write = trace_buff_size_write,
3092};
3093
3094static void handle_request_ras_comps_rsp(union ibmvnic_crq *crq,
3095 struct ibmvnic_adapter *adapter)
3096{
3097 struct device *dev = &adapter->vdev->dev;
3098 struct dentry *dir_ent;
3099 struct dentry *ent;
3100 int i;
3101
3102 debugfs_remove_recursive(adapter->ras_comps_ent);
3103
3104 adapter->ras_comps_ent = debugfs_create_dir("ras_comps",
3105 adapter->debugfs_dir);
3106 if (!adapter->ras_comps_ent || IS_ERR(adapter->ras_comps_ent)) {
3107 dev_info(dev, "debugfs create ras_comps dir failed\n");
3108 return;
3109 }
3110
3111 for (i = 0; i < adapter->ras_comp_num; i++) {
3112 dir_ent = debugfs_create_dir(adapter->ras_comps[i].name,
3113 adapter->ras_comps_ent);
3114 if (!dir_ent || IS_ERR(dir_ent)) {
3115 dev_info(dev, "debugfs create %s dir failed\n",
3116 adapter->ras_comps[i].name);
3117 continue;
3118 }
3119
3120 adapter->ras_comp_int[i].adapter = adapter;
3121 adapter->ras_comp_int[i].num = i;
3122 adapter->ras_comp_int[i].desc_blob.data =
3123 &adapter->ras_comps[i].description;
3124 adapter->ras_comp_int[i].desc_blob.size =
3125 sizeof(adapter->ras_comps[i].description);
3126
3127 /* Don't need to remember the dentry's because the debugfs dir
3128 * gets removed recursively
3129 */
3130 ent = debugfs_create_blob("description", S_IRUGO, dir_ent,
3131 &adapter->ras_comp_int[i].desc_blob);
3132 ent = debugfs_create_file("trace_buf_size", S_IRUGO | S_IWUSR,
3133 dir_ent, &adapter->ras_comp_int[i],
3134 &trace_size_ops);
3135 ent = debugfs_create_file("trace_level",
3136 S_IRUGO |
3137 (adapter->ras_comps[i].trace_level !=
3138 0xFF ? S_IWUSR : 0),
3139 dir_ent, &adapter->ras_comp_int[i],
3140 &trace_level_ops);
3141 ent = debugfs_create_file("error_level",
3142 S_IRUGO |
3143 (adapter->
3144 ras_comps[i].error_check_level !=
3145 0xFF ? S_IWUSR : 0),
3146 dir_ent, &adapter->ras_comp_int[i],
3147 &trace_level_ops);
3148 ent = debugfs_create_file("tracing", S_IRUGO | S_IWUSR,
3149 dir_ent, &adapter->ras_comp_int[i],
3150 &tracing_ops);
3151 ent = debugfs_create_file("paused", S_IRUGO | S_IWUSR,
3152 dir_ent, &adapter->ras_comp_int[i],
3153 &paused_ops);
3154 ent = debugfs_create_file("trace", S_IRUGO, dir_ent,
3155 &adapter->ras_comp_int[i],
3156 &trace_ops);
3157 }
3158}
3159
3160static void handle_request_ras_comp_num_rsp(union ibmvnic_crq *crq,
3161 struct ibmvnic_adapter *adapter)
3162{
3163 int len = adapter->ras_comp_num * sizeof(struct ibmvnic_fw_component);
3164 struct device *dev = &adapter->vdev->dev;
3165 union ibmvnic_crq newcrq;
3166
3167 adapter->ras_comps = dma_alloc_coherent(dev, len,
3168 &adapter->ras_comps_tok,
3169 GFP_KERNEL);
3170 if (!adapter->ras_comps) {
3171 if (!firmware_has_feature(FW_FEATURE_CMO))
3172 dev_err(dev, "Couldn't alloc fw comps buffer\n");
3173 return;
3174 }
3175
3176 adapter->ras_comp_int = kmalloc(adapter->ras_comp_num *
3177 sizeof(struct ibmvnic_fw_comp_internal),
3178 GFP_KERNEL);
3179 if (!adapter->ras_comp_int)
3180 dma_free_coherent(dev, len, adapter->ras_comps,
3181 adapter->ras_comps_tok);
3182
3183 memset(&newcrq, 0, sizeof(newcrq));
3184 newcrq.request_ras_comps.first = IBMVNIC_CRQ_CMD;
3185 newcrq.request_ras_comps.cmd = REQUEST_RAS_COMPS;
3186 newcrq.request_ras_comps.ioba = cpu_to_be32(adapter->ras_comps_tok);
3187 newcrq.request_ras_comps.len = cpu_to_be32(len);
3188 ibmvnic_send_crq(adapter, &newcrq);
3189}
3190
3191static void ibmvnic_free_inflight(struct ibmvnic_adapter *adapter)
3192{
96183182 3193 struct ibmvnic_inflight_cmd *inflight_cmd, *tmp1;
032c5e82 3194 struct device *dev = &adapter->vdev->dev;
96183182 3195 struct ibmvnic_error_buff *error_buff, *tmp2;
032c5e82
TF		 3196 unsigned long flags;
3197 unsigned long flags2;
3198
3199 spin_lock_irqsave(&adapter->inflight_lock, flags);
96183182 3200 list_for_each_entry_safe(inflight_cmd, tmp1, &adapter->inflight, list) {
032c5e82
TF		 3201 switch (inflight_cmd->crq.generic.cmd) {
3202 case LOGIN:
3203 dma_unmap_single(dev, adapter->login_buf_token,
3204 adapter->login_buf_sz,
3205 DMA_BIDIRECTIONAL);
3206 dma_unmap_single(dev, adapter->login_rsp_buf_token,
3207 adapter->login_rsp_buf_sz,
3208 DMA_BIDIRECTIONAL);
3209 kfree(adapter->login_rsp_buf);
3210 kfree(adapter->login_buf);
3211 break;
3212 case REQUEST_DUMP:
3213 complete(&adapter->fw_done);
3214 break;
3215 case REQUEST_ERROR_INFO:
3216 spin_lock_irqsave(&adapter->error_list_lock, flags2);
96183182
WY		 3217 list_for_each_entry_safe(error_buff, tmp2,
3218 &adapter->errors, list) {
032c5e82
TF		 3219 dma_unmap_single(dev, error_buff->dma,
3220 error_buff->len,
3221 DMA_FROM_DEVICE);
3222 kfree(error_buff->buff);
3223 list_del(&error_buff->list);
3224 kfree(error_buff);
3225 }
3226 spin_unlock_irqrestore(&adapter->error_list_lock,
3227 flags2);
3228 break;
3229 }
3230 list_del(&inflight_cmd->list);
3231 kfree(inflight_cmd);
3232 }
3233 spin_unlock_irqrestore(&adapter->inflight_lock, flags);
3234}
3235
9888d7b0
TF		 3236static void ibmvnic_xport_event(struct work_struct *work)
3237{
3238 struct ibmvnic_adapter *adapter = container_of(work,
3239 struct ibmvnic_adapter,
3240 ibmvnic_xport);
3241 struct device *dev = &adapter->vdev->dev;
3242 long rc;
3243
3244 ibmvnic_free_inflight(adapter);
3245 release_sub_crqs(adapter);
3246 if (adapter->migrated) {
3247 rc = ibmvnic_reenable_crq_queue(adapter);
3248 if (rc)
3249 dev_err(dev, "Error after enable rc=%ld\n", rc);
3250 adapter->migrated = false;
3251 rc = ibmvnic_send_crq_init(adapter);
3252 if (rc)
3253 dev_err(dev, "Error sending init rc=%ld\n", rc);
3254 }
3255}
3256
032c5e82
TF		 3257static void ibmvnic_handle_crq(union ibmvnic_crq *crq,
3258 struct ibmvnic_adapter *adapter)
3259{
3260 struct ibmvnic_generic_crq *gen_crq = &crq->generic;
3261 struct net_device *netdev = adapter->netdev;
3262 struct device *dev = &adapter->vdev->dev;
3263 long rc;
3264
3265 netdev_dbg(netdev, "Handling CRQ: %016lx %016lx\n",
3266 ((unsigned long int *)crq)[0],
3267 ((unsigned long int *)crq)[1]);
3268 switch (gen_crq->first) {
3269 case IBMVNIC_CRQ_INIT_RSP:
3270 switch (gen_crq->cmd) {
3271 case IBMVNIC_CRQ_INIT:
3272 dev_info(dev, "Partner initialized\n");
3273 /* Send back a response */
3274 rc = ibmvnic_send_crq_init_complete(adapter);
65dc6891
TF		 3275 if (!rc)
3276 schedule_work(&adapter->vnic_crq_init);
032c5e82
TF		 3277 else
3278 dev_err(dev, "Can't send initrsp rc=%ld\n", rc);
3279 break;
3280 case IBMVNIC_CRQ_INIT_COMPLETE:
3281 dev_info(dev, "Partner initialization complete\n");
3282 send_version_xchg(adapter);
3283 break;
3284 default:
3285 dev_err(dev, "Unknown crq cmd: %d\n", gen_crq->cmd);
3286 }
3287 return;
3288 case IBMVNIC_CRQ_XPORT_EVENT:
3289 if (gen_crq->cmd == IBMVNIC_PARTITION_MIGRATED) {
3290 dev_info(dev, "Re-enabling adapter\n");
3291 adapter->migrated = true;
9888d7b0 3292 schedule_work(&adapter->ibmvnic_xport);
dfad09a6
TF		 3293 } else if (gen_crq->cmd == IBMVNIC_DEVICE_FAILOVER) {
3294 dev_info(dev, "Backing device failover detected\n");
3295 netif_carrier_off(netdev);
3296 adapter->failover = true;
032c5e82
TF		 3297 } else {
3298 /* The adapter lost the connection */
3299 dev_err(dev, "Virtual Adapter failed (rc=%d)\n",
3300 gen_crq->cmd);
9888d7b0 3301 schedule_work(&adapter->ibmvnic_xport);
032c5e82
TF		 3302 }
3303 return;
3304 case IBMVNIC_CRQ_CMD_RSP:
3305 break;
3306 default:
3307 dev_err(dev, "Got an invalid msg type 0x%02x\n",
3308 gen_crq->first);
3309 return;
3310 }
3311
3312 switch (gen_crq->cmd) {
3313 case VERSION_EXCHANGE_RSP:
3314 rc = crq->version_exchange_rsp.rc.code;
3315 if (rc) {
3316 dev_err(dev, "Error %ld in VERSION_EXCHG_RSP\n", rc);
3317 break;
3318 }
3319 dev_info(dev, "Partner protocol version is %d\n",
3320 crq->version_exchange_rsp.version);
3321 if (be16_to_cpu(crq->version_exchange_rsp.version) <
3322 ibmvnic_version)
3323 ibmvnic_version =
3324 be16_to_cpu(crq->version_exchange_rsp.version);
3325 send_cap_queries(adapter);
3326 break;
3327 case QUERY_CAPABILITY_RSP:
3328 handle_query_cap_rsp(crq, adapter);
3329 break;
3330 case QUERY_MAP_RSP:
3331 handle_query_map_rsp(crq, adapter);
3332 break;
3333 case REQUEST_MAP_RSP:
3334 handle_request_map_rsp(crq, adapter);
3335 break;
3336 case REQUEST_UNMAP_RSP:
3337 handle_request_unmap_rsp(crq, adapter);
3338 break;
3339 case REQUEST_CAPABILITY_RSP:
3340 handle_request_cap_rsp(crq, adapter);
3341 break;
3342 case LOGIN_RSP:
3343 netdev_dbg(netdev, "Got Login Response\n");
3344 handle_login_rsp(crq, adapter);
3345 break;
3346 case LOGICAL_LINK_STATE_RSP:
3347 netdev_dbg(netdev, "Got Logical Link State Response\n");
3348 adapter->logical_link_state =
3349 crq->logical_link_state_rsp.link_state;
3350 break;
3351 case LINK_STATE_INDICATION:
3352 netdev_dbg(netdev, "Got Logical Link State Indication\n");
3353 adapter->phys_link_state =
3354 crq->link_state_indication.phys_link_state;
3355 adapter->logical_link_state =
3356 crq->link_state_indication.logical_link_state;
3357 break;
3358 case CHANGE_MAC_ADDR_RSP:
3359 netdev_dbg(netdev, "Got MAC address change Response\n");
3360 handle_change_mac_rsp(crq, adapter);
3361 break;
3362 case ERROR_INDICATION:
3363 netdev_dbg(netdev, "Got Error Indication\n");
3364 handle_error_indication(crq, adapter);
3365 break;
3366 case REQUEST_ERROR_RSP:
3367 netdev_dbg(netdev, "Got Error Detail Response\n");
3368 handle_error_info_rsp(crq, adapter);
3369 break;
3370 case REQUEST_STATISTICS_RSP:
3371 netdev_dbg(netdev, "Got Statistics Response\n");
3372 complete(&adapter->stats_done);
3373 break;
3374 case REQUEST_DUMP_SIZE_RSP:
3375 netdev_dbg(netdev, "Got Request Dump Size Response\n");
3376 handle_dump_size_rsp(crq, adapter);
3377 break;
3378 case REQUEST_DUMP_RSP:
3379 netdev_dbg(netdev, "Got Request Dump Response\n");
3380 complete(&adapter->fw_done);
3381 break;
3382 case QUERY_IP_OFFLOAD_RSP:
3383 netdev_dbg(netdev, "Got Query IP offload Response\n");
3384 handle_query_ip_offload_rsp(adapter);
3385 break;
3386 case MULTICAST_CTRL_RSP:
3387 netdev_dbg(netdev, "Got multicast control Response\n");
3388 break;
3389 case CONTROL_IP_OFFLOAD_RSP:
3390 netdev_dbg(netdev, "Got Control IP offload Response\n");
3391 dma_unmap_single(dev, adapter->ip_offload_ctrl_tok,
3392 sizeof(adapter->ip_offload_ctrl),
3393 DMA_TO_DEVICE);
3394 /* We're done with the queries, perform the login */
3395 send_login(adapter);
3396 break;
3397 case REQUEST_RAS_COMP_NUM_RSP:
3398 netdev_dbg(netdev, "Got Request RAS Comp Num Response\n");
3399 if (crq->request_ras_comp_num_rsp.rc.code == 10) {
3400 netdev_dbg(netdev, "Request RAS Comp Num not supported\n");
3401 break;
3402 }
3403 adapter->ras_comp_num =
3404 be32_to_cpu(crq->request_ras_comp_num_rsp.num_components);
3405 handle_request_ras_comp_num_rsp(crq, adapter);
3406 break;
3407 case REQUEST_RAS_COMPS_RSP:
3408 netdev_dbg(netdev, "Got Request RAS Comps Response\n");
3409 handle_request_ras_comps_rsp(crq, adapter);
3410 break;
3411 case CONTROL_RAS_RSP:
3412 netdev_dbg(netdev, "Got Control RAS Response\n");
3413 handle_control_ras_rsp(crq, adapter);
3414 break;
3415 case COLLECT_FW_TRACE_RSP:
3416 netdev_dbg(netdev, "Got Collect firmware trace Response\n");
3417 complete(&adapter->fw_done);
3418 break;
3419 default:
3420 netdev_err(netdev, "Got an invalid cmd type 0x%02x\n",
3421 gen_crq->cmd);
3422 }
3423}
3424
3425static irqreturn_t ibmvnic_interrupt(int irq, void *instance)
3426{
3427 struct ibmvnic_adapter *adapter = instance;
6c267b3d
TF		 3428 unsigned long flags;
3429
3430 spin_lock_irqsave(&adapter->crq.lock, flags);
3431 vio_disable_interrupts(adapter->vdev);
3432 tasklet_schedule(&adapter->tasklet);
3433 spin_unlock_irqrestore(&adapter->crq.lock, flags);
3434 return IRQ_HANDLED;
3435}
3436
3437static void ibmvnic_tasklet(void *data)
3438{
3439 struct ibmvnic_adapter *adapter = data;
032c5e82
TF		 3440 struct ibmvnic_crq_queue *queue = &adapter->crq;
3441 struct vio_dev *vdev = adapter->vdev;
3442 union ibmvnic_crq *crq;
3443 unsigned long flags;
3444 bool done = false;
3445
3446 spin_lock_irqsave(&queue->lock, flags);
3447 vio_disable_interrupts(vdev);
3448 while (!done) {
3449 /* Pull all the valid messages off the CRQ */
3450 while ((crq = ibmvnic_next_crq(adapter)) != NULL) {
3451 ibmvnic_handle_crq(crq, adapter);
3452 crq->generic.first = 0;
3453 }
3454 vio_enable_interrupts(vdev);
3455 crq = ibmvnic_next_crq(adapter);
3456 if (crq) {
3457 vio_disable_interrupts(vdev);
3458 ibmvnic_handle_crq(crq, adapter);
3459 crq->generic.first = 0;
3460 } else {
3461 done = true;
3462 }
3463 }
3464 spin_unlock_irqrestore(&queue->lock, flags);
032c5e82
TF		 3465}
3466
3467static int ibmvnic_reenable_crq_queue(struct ibmvnic_adapter *adapter)
3468{
3469 struct vio_dev *vdev = adapter->vdev;
3470 int rc;
3471
3472 do {
3473 rc = plpar_hcall_norets(H_ENABLE_CRQ, vdev->unit_address);
3474 } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc));
3475
3476 if (rc)
3477 dev_err(&vdev->dev, "Error enabling adapter (rc=%d)\n", rc);
3478
3479 return rc;
3480}
3481
3482static int ibmvnic_reset_crq(struct ibmvnic_adapter *adapter)
3483{
3484 struct ibmvnic_crq_queue *crq = &adapter->crq;
3485 struct device *dev = &adapter->vdev->dev;
3486 struct vio_dev *vdev = adapter->vdev;
3487 int rc;
3488
3489 /* Close the CRQ */
3490 do {
3491 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
3492 } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
3493
3494 /* Clean out the queue */
3495 memset(crq->msgs, 0, PAGE_SIZE);
3496 crq->cur = 0;
3497
3498 /* And re-open it again */
3499 rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
3500 crq->msg_token, PAGE_SIZE);
3501
3502 if (rc == H_CLOSED)
3503 /* Adapter is good, but other end is not ready */
3504 dev_warn(dev, "Partner adapter not ready\n");
3505 else if (rc != 0)
3506 dev_warn(dev, "Couldn't register crq (rc=%d)\n", rc);
3507
3508 return rc;
3509}
3510
3511static void ibmvnic_release_crq_queue(struct ibmvnic_adapter *adapter)
3512{
3513 struct ibmvnic_crq_queue *crq = &adapter->crq;
3514 struct vio_dev *vdev = adapter->vdev;
3515 long rc;
3516
3517 netdev_dbg(adapter->netdev, "Releasing CRQ\n");
3518 free_irq(vdev->irq, adapter);
6c267b3d 3519 tasklet_kill(&adapter->tasklet);
032c5e82
TF		 3520 do {
3521 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
3522 } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
3523
3524 dma_unmap_single(&vdev->dev, crq->msg_token, PAGE_SIZE,
3525 DMA_BIDIRECTIONAL);
3526 free_page((unsigned long)crq->msgs);
3527}
3528
3529static int ibmvnic_init_crq_queue(struct ibmvnic_adapter *adapter)
3530{
3531 struct ibmvnic_crq_queue *crq = &adapter->crq;
3532 struct device *dev = &adapter->vdev->dev;
3533 struct vio_dev *vdev = adapter->vdev;
3534 int rc, retrc = -ENOMEM;
3535
3536 crq->msgs = (union ibmvnic_crq *)get_zeroed_page(GFP_KERNEL);
3537 /* Should we allocate more than one page? */
3538
3539 if (!crq->msgs)
3540 return -ENOMEM;
3541
3542 crq->size = PAGE_SIZE / sizeof(*crq->msgs);
3543 crq->msg_token = dma_map_single(dev, crq->msgs, PAGE_SIZE,
3544 DMA_BIDIRECTIONAL);
3545 if (dma_mapping_error(dev, crq->msg_token))
3546 goto map_failed;
3547
3548 rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
3549 crq->msg_token, PAGE_SIZE);
3550
3551 if (rc == H_RESOURCE)
3552 /* maybe kexecing and resource is busy. try a reset */
3553 rc = ibmvnic_reset_crq(adapter);
3554 retrc = rc;
3555
3556 if (rc == H_CLOSED) {
3557 dev_warn(dev, "Partner adapter not ready\n");
3558 } else if (rc) {
3559 dev_warn(dev, "Error %d opening adapter\n", rc);
3560 goto reg_crq_failed;
3561 }
3562
3563 retrc = 0;
3564
6c267b3d
TF		 3565 tasklet_init(&adapter->tasklet, (void *)ibmvnic_tasklet,
3566 (unsigned long)adapter);
3567
032c5e82
TF		 3568 netdev_dbg(adapter->netdev, "registering irq 0x%x\n", vdev->irq);
3569 rc = request_irq(vdev->irq, ibmvnic_interrupt, 0, IBMVNIC_NAME,
3570 adapter);
3571 if (rc) {
3572 dev_err(dev, "Couldn't register irq 0x%x. rc=%d\n",
3573 vdev->irq, rc);
3574 goto req_irq_failed;
3575 }
3576
3577 rc = vio_enable_interrupts(vdev);
3578 if (rc) {
3579 dev_err(dev, "Error %d enabling interrupts\n", rc);
3580 goto req_irq_failed;
3581 }
3582
3583 crq->cur = 0;
3584 spin_lock_init(&crq->lock);
3585
3586 return retrc;
3587
3588req_irq_failed:
6c267b3d 3589 tasklet_kill(&adapter->tasklet);
032c5e82
TF		 3590 do {
3591 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
3592 } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
3593reg_crq_failed:
3594 dma_unmap_single(dev, crq->msg_token, PAGE_SIZE, DMA_BIDIRECTIONAL);
3595map_failed:
3596 free_page((unsigned long)crq->msgs);
3597 return retrc;
3598}
3599
3600/* debugfs for dump */
3601static int ibmvnic_dump_show(struct seq_file *seq, void *v)
3602{
3603 struct net_device *netdev = seq->private;
3604 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
3605 struct device *dev = &adapter->vdev->dev;
3606 union ibmvnic_crq crq;
3607
3608 memset(&crq, 0, sizeof(crq));
3609 crq.request_dump_size.first = IBMVNIC_CRQ_CMD;
3610 crq.request_dump_size.cmd = REQUEST_DUMP_SIZE;
032c5e82
TF		 3611
3612 init_completion(&adapter->fw_done);
db5d0b59 3613 ibmvnic_send_crq(adapter, &crq);
032c5e82
TF		 3614 wait_for_completion(&adapter->fw_done);
3615
3616 seq_write(seq, adapter->dump_data, adapter->dump_data_size);
3617
3618 dma_unmap_single(dev, adapter->dump_data_token, adapter->dump_data_size,
3619 DMA_BIDIRECTIONAL);
3620
3621 kfree(adapter->dump_data);
3622
3623 return 0;
3624}
3625
3626static int ibmvnic_dump_open(struct inode *inode, struct file *file)
3627{
3628 return single_open(file, ibmvnic_dump_show, inode->i_private);
3629}
3630
3631static const struct file_operations ibmvnic_dump_ops = {
3632 .owner = THIS_MODULE,
3633 .open = ibmvnic_dump_open,
3634 .read = seq_read,
3635 .llseek = seq_lseek,
3636 .release = single_release,
3637};
3638
65dc6891
TF		 3639static void handle_crq_init_rsp(struct work_struct *work)
3640{
3641 struct ibmvnic_adapter *adapter = container_of(work,
3642 struct ibmvnic_adapter,
3643 vnic_crq_init);
3644 struct device *dev = &adapter->vdev->dev;
3645 struct net_device *netdev = adapter->netdev;
3646 unsigned long timeout = msecs_to_jiffies(30000);
dfad09a6 3647 bool restart = false;
65dc6891
TF		 3648 int rc;
3649
dfad09a6
TF		 3650 if (adapter->failover) {
3651 release_sub_crqs(adapter);
3652 if (netif_running(netdev)) {
3653 netif_tx_disable(netdev);
3654 ibmvnic_close(netdev);
3655 restart = true;
3656 }
3657 }
3658
65dc6891 3659 reinit_completion(&adapter->init_done);
db5d0b59 3660 send_version_xchg(adapter);
65dc6891
TF		 3661 if (!wait_for_completion_timeout(&adapter->init_done, timeout)) {
3662 dev_err(dev, "Passive init timeout\n");
3663 goto task_failed;
3664 }
3665
3666 do {
3667 if (adapter->renegotiate) {
3668 adapter->renegotiate = false;
3669 release_sub_crqs_no_irqs(adapter);
65dc6891
TF		 3670
3671 reinit_completion(&adapter->init_done);
db5d0b59 3672 send_cap_queries(adapter);
65dc6891
TF		 3673 if (!wait_for_completion_timeout(&adapter->init_done,
3674 timeout)) {
3675 dev_err(dev, "Passive init timeout\n");
3676 goto task_failed;
3677 }
3678 }
3679 } while (adapter->renegotiate);
3680 rc = init_sub_crq_irqs(adapter);
3681
3682 if (rc)
3683 goto task_failed;
3684
3685 netdev->real_num_tx_queues = adapter->req_tx_queues;
f39f0d1e 3686 netdev->mtu = adapter->req_mtu - ETH_HLEN;
65dc6891 3687
dfad09a6
TF		 3688 if (adapter->failover) {
3689 adapter->failover = false;
3690 if (restart) {
3691 rc = ibmvnic_open(netdev);
3692 if (rc)
3693 goto restart_failed;
3694 }
3695 netif_carrier_on(netdev);
3696 return;
3697 }
3698
65dc6891
TF		 3699 rc = register_netdev(netdev);
3700 if (rc) {
3701 dev_err(dev,
3702 "failed to register netdev rc=%d\n", rc);
3703 goto register_failed;
3704 }
3705 dev_info(dev, "ibmvnic registered\n");
3706
3707 return;
3708
dfad09a6
TF		 3709restart_failed:
3710 dev_err(dev, "Failed to restart ibmvnic, rc=%d\n", rc);
65dc6891
TF		 3711register_failed:
3712 release_sub_crqs(adapter);
3713task_failed:
3714 dev_err(dev, "Passive initialization was not successful\n");
3715}
3716
032c5e82
TF		 3717static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id)
3718{
ea22d51a 3719 unsigned long timeout = msecs_to_jiffies(30000);
032c5e82
TF		 3720 struct ibmvnic_adapter *adapter;
3721 struct net_device *netdev;
3722 unsigned char *mac_addr_p;
3723 struct dentry *ent;
e1fac0ad 3724 char buf[17]; /* debugfs name buf */
032c5e82
TF		 3725 int rc;
3726
3727 dev_dbg(&dev->dev, "entering ibmvnic_probe for UA 0x%x\n",
3728 dev->unit_address);
3729
3730 mac_addr_p = (unsigned char *)vio_get_attribute(dev,
3731 VETH_MAC_ADDR, NULL);
3732 if (!mac_addr_p) {
3733 dev_err(&dev->dev,
3734 "(%s:%3.3d) ERROR: Can't find MAC_ADDR attribute\n",
3735 __FILE__, __LINE__);
3736 return 0;
3737 }
3738
3739 netdev = alloc_etherdev_mq(sizeof(struct ibmvnic_adapter),
3740 IBMVNIC_MAX_TX_QUEUES);
3741 if (!netdev)
3742 return -ENOMEM;
3743
3744 adapter = netdev_priv(netdev);
3745 dev_set_drvdata(&dev->dev, netdev);
3746 adapter->vdev = dev;
3747 adapter->netdev = netdev;
dfad09a6 3748 adapter->failover = false;
032c5e82
TF		 3749
3750 ether_addr_copy(adapter->mac_addr, mac_addr_p);
3751 ether_addr_copy(netdev->dev_addr, adapter->mac_addr);
3752 netdev->irq = dev->irq;
3753 netdev->netdev_ops = &ibmvnic_netdev_ops;
3754 netdev->ethtool_ops = &ibmvnic_ethtool_ops;
3755 SET_NETDEV_DEV(netdev, &dev->dev);
3756
65dc6891 3757 INIT_WORK(&adapter->vnic_crq_init, handle_crq_init_rsp);
9888d7b0 3758 INIT_WORK(&adapter->ibmvnic_xport, ibmvnic_xport_event);
65dc6891 3759
032c5e82
TF		 3760 spin_lock_init(&adapter->stats_lock);
3761
3762 rc = ibmvnic_init_crq_queue(adapter);
3763 if (rc) {
3764 dev_err(&dev->dev, "Couldn't initialize crq. rc=%d\n", rc);
3765 goto free_netdev;
3766 }
3767
3768 INIT_LIST_HEAD(&adapter->errors);
3769 INIT_LIST_HEAD(&adapter->inflight);
3770 spin_lock_init(&adapter->error_list_lock);
3771 spin_lock_init(&adapter->inflight_lock);
3772
3773 adapter->stats_token = dma_map_single(&dev->dev, &adapter->stats,
3774 sizeof(struct ibmvnic_statistics),
3775 DMA_FROM_DEVICE);
3776 if (dma_mapping_error(&dev->dev, adapter->stats_token)) {
3777 if (!firmware_has_feature(FW_FEATURE_CMO))
3778 dev_err(&dev->dev, "Couldn't map stats buffer\n");
0e87203a 3779 rc = -ENOMEM;
032c5e82
TF		 3780 goto free_crq;
3781 }
3782
3783 snprintf(buf, sizeof(buf), "ibmvnic_%x", dev->unit_address);
3784 ent = debugfs_create_dir(buf, NULL);
3785 if (!ent || IS_ERR(ent)) {
3786 dev_info(&dev->dev, "debugfs create directory failed\n");
3787 adapter->debugfs_dir = NULL;
3788 } else {
3789 adapter->debugfs_dir = ent;
3790 ent = debugfs_create_file("dump", S_IRUGO, adapter->debugfs_dir,
3791 netdev, &ibmvnic_dump_ops);
3792 if (!ent || IS_ERR(ent)) {
3793 dev_info(&dev->dev,
3794 "debugfs create dump file failed\n");
3795 adapter->debugfs_dump = NULL;
3796 } else {
3797 adapter->debugfs_dump = ent;
3798 }
3799 }
032c5e82
TF		 3800
3801 init_completion(&adapter->init_done);
db5d0b59 3802 ibmvnic_send_crq_init(adapter);
ea22d51a
TF		 3803 if (!wait_for_completion_timeout(&adapter->init_done, timeout))
3804 return 0;
032c5e82 3805
498cd8e4 3806 do {
498cd8e4 3807 if (adapter->renegotiate) {
ea22d51a
TF		 3808 adapter->renegotiate = false;
3809 release_sub_crqs_no_irqs(adapter);
498cd8e4
JA		 3810
3811 reinit_completion(&adapter->init_done);
db5d0b59 3812 send_cap_queries(adapter);
ea22d51a
TF		 3813 if (!wait_for_completion_timeout(&adapter->init_done,
3814 timeout))
3815 return 0;
498cd8e4
JA		 3816 }
3817 } while (adapter->renegotiate);
032c5e82 3818
ea22d51a
TF		 3819 rc = init_sub_crq_irqs(adapter);
3820 if (rc) {
3821 dev_err(&dev->dev, "failed to initialize sub crq irqs\n");
3822 goto free_debugfs;
032c5e82
TF		 3823 }
3824
3825 netdev->real_num_tx_queues = adapter->req_tx_queues;
f39f0d1e 3826 netdev->mtu = adapter->req_mtu - ETH_HLEN;
032c5e82
TF		 3827
3828 rc = register_netdev(netdev);
3829 if (rc) {
3830 dev_err(&dev->dev, "failed to register netdev rc=%d\n", rc);
ea22d51a 3831 goto free_sub_crqs;
032c5e82
TF		 3832 }
3833 dev_info(&dev->dev, "ibmvnic registered\n");
3834
3835 return 0;
3836
ea22d51a
TF		 3837free_sub_crqs:
3838 release_sub_crqs(adapter);
032c5e82
TF		 3839free_debugfs:
3840 if (adapter->debugfs_dir && !IS_ERR(adapter->debugfs_dir))
3841 debugfs_remove_recursive(adapter->debugfs_dir);
3842free_crq:
3843 ibmvnic_release_crq_queue(adapter);
3844free_netdev:
3845 free_netdev(netdev);
3846 return rc;
3847}
3848
3849static int ibmvnic_remove(struct vio_dev *dev)
3850{
3851 struct net_device *netdev = dev_get_drvdata(&dev->dev);
3852 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
3853
3854 unregister_netdev(netdev);
3855
3856 release_sub_crqs(adapter);
3857
3858 ibmvnic_release_crq_queue(adapter);
3859
3860 if (adapter->debugfs_dir && !IS_ERR(adapter->debugfs_dir))
3861 debugfs_remove_recursive(adapter->debugfs_dir);
3862
b7f193da
TF		 3863 dma_unmap_single(&dev->dev, adapter->stats_token,
3864 sizeof(struct ibmvnic_statistics), DMA_FROM_DEVICE);
3865
032c5e82
TF		 3866 if (adapter->ras_comps)
3867 dma_free_coherent(&dev->dev,
3868 adapter->ras_comp_num *
3869 sizeof(struct ibmvnic_fw_component),
3870 adapter->ras_comps, adapter->ras_comps_tok);
3871
3872 kfree(adapter->ras_comp_int);
3873
3874 free_netdev(netdev);
3875 dev_set_drvdata(&dev->dev, NULL);
3876
3877 return 0;
3878}
3879
3880static unsigned long ibmvnic_get_desired_dma(struct vio_dev *vdev)
3881{
3882 struct net_device *netdev = dev_get_drvdata(&vdev->dev);
3883 struct ibmvnic_adapter *adapter;
3884 struct iommu_table *tbl;
3885 unsigned long ret = 0;
3886 int i;
3887
3888 tbl = get_iommu_table_base(&vdev->dev);
3889
3890 /* netdev inits at probe time along with the structures we need below*/
3891 if (!netdev)
3892 return IOMMU_PAGE_ALIGN(IBMVNIC_IO_ENTITLEMENT_DEFAULT, tbl);
3893
3894 adapter = netdev_priv(netdev);
3895
3896 ret += PAGE_SIZE; /* the crq message queue */
3897 ret += adapter->bounce_buffer_size;
3898 ret += IOMMU_PAGE_ALIGN(sizeof(struct ibmvnic_statistics), tbl);
3899
3900 for (i = 0; i < adapter->req_tx_queues + adapter->req_rx_queues; i++)
3901 ret += 4 * PAGE_SIZE; /* the scrq message queue */
3902
3903 for (i = 0; i < be32_to_cpu(adapter->login_rsp_buf->num_rxadd_subcrqs);
3904 i++)
3905 ret += adapter->rx_pool[i].size *
3906 IOMMU_PAGE_ALIGN(adapter->rx_pool[i].buff_size, tbl);
3907
3908 return ret;
3909}
3910
3911static int ibmvnic_resume(struct device *dev)
3912{
3913 struct net_device *netdev = dev_get_drvdata(dev);
3914 struct ibmvnic_adapter *adapter = netdev_priv(netdev);
3915 int i;
3916
3917 /* kick the interrupt handlers just in case we lost an interrupt */
3918 for (i = 0; i < adapter->req_rx_queues; i++)
3919 ibmvnic_interrupt_rx(adapter->rx_scrq[i]->irq,
3920 adapter->rx_scrq[i]);
3921
3922 return 0;
3923}
3924
3925static struct vio_device_id ibmvnic_device_table[] = {
3926 {"network", "IBM,vnic"},
3927 {"", "" }
3928};
3929MODULE_DEVICE_TABLE(vio, ibmvnic_device_table);
3930
3931static const struct dev_pm_ops ibmvnic_pm_ops = {
3932 .resume = ibmvnic_resume
3933};
3934
3935static struct vio_driver ibmvnic_driver = {
3936 .id_table = ibmvnic_device_table,
3937 .probe = ibmvnic_probe,
3938 .remove = ibmvnic_remove,
3939 .get_desired_dma = ibmvnic_get_desired_dma,
3940 .name = ibmvnic_driver_name,
3941 .pm = &ibmvnic_pm_ops,
3942};
3943
3944/* module functions */
3945static int __init ibmvnic_module_init(void)
3946{
3947 pr_info("%s: %s %s\n", ibmvnic_driver_name, ibmvnic_driver_string,
3948 IBMVNIC_DRIVER_VERSION);
3949
3950 return vio_register_driver(&ibmvnic_driver);
3951}
3952
3953static void __exit ibmvnic_module_exit(void)
3954{
3955 vio_unregister_driver(&ibmvnic_driver);
3956}
3957
3958module_init(ibmvnic_module_init);
3959module_exit(ibmvnic_module_exit);
Ubuntu Artful kernel mirror