1// SPDX-License-Identifier: GPL-2.0-only
   2/* Copyright (C) 2023 Intel Corporation */
   3
   4#include "idpf.h"
 
   5
   6static const struct net_device_ops idpf_netdev_ops_splitq;
   7static const struct net_device_ops idpf_netdev_ops_singleq;
   8
   9const char * const idpf_vport_vc_state_str[] = {
  10	IDPF_FOREACH_VPORT_VC_STATE(IDPF_GEN_STRING)
  11};
  12
  13/**
  14 * idpf_init_vector_stack - Fill the MSIX vector stack with vector index
  15 * @adapter: private data struct
  16 *
  17 * Return 0 on success, error on failure
  18 */
  19static int idpf_init_vector_stack(struct idpf_adapter *adapter)
  20{
  21	struct idpf_vector_lifo *stack;
  22	u16 min_vec;
  23	u32 i;
  24
  25	mutex_lock(&adapter->vector_lock);
  26	min_vec = adapter->num_msix_entries - adapter->num_avail_msix;
  27	stack = &adapter->vector_stack;
  28	stack->size = adapter->num_msix_entries;
  29	/* set the base and top to point at start of the 'free pool' to
  30	 * distribute the unused vectors on-demand basis
  31	 */
  32	stack->base = min_vec;
  33	stack->top = min_vec;
  34
  35	stack->vec_idx = kcalloc(stack->size, sizeof(u16), GFP_KERNEL);
  36	if (!stack->vec_idx) {
  37		mutex_unlock(&adapter->vector_lock);
  38
  39		return -ENOMEM;
  40	}
  41
  42	for (i = 0; i < stack->size; i++)
  43		stack->vec_idx[i] = i;
  44
  45	mutex_unlock(&adapter->vector_lock);
  46
  47	return 0;
  48}
  49
  50/**
  51 * idpf_deinit_vector_stack - zero out the MSIX vector stack
  52 * @adapter: private data struct
  53 */
  54static void idpf_deinit_vector_stack(struct idpf_adapter *adapter)
  55{
  56	struct idpf_vector_lifo *stack;
  57
  58	mutex_lock(&adapter->vector_lock);
  59	stack = &adapter->vector_stack;
  60	kfree(stack->vec_idx);
  61	stack->vec_idx = NULL;
  62	mutex_unlock(&adapter->vector_lock);
  63}
  64
  65/**
  66 * idpf_mb_intr_rel_irq - Free the IRQ association with the OS
  67 * @adapter: adapter structure
  68 *
  69 * This will also disable interrupt mode and queue up mailbox task. Mailbox
  70 * task will reschedule itself if not in interrupt mode.
  71 */
  72static void idpf_mb_intr_rel_irq(struct idpf_adapter *adapter)
  73{
  74	clear_bit(IDPF_MB_INTR_MODE, adapter->flags);
  75	free_irq(adapter->msix_entries[0].vector, adapter);
  76	queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);
  77}
  78
  79/**
  80 * idpf_intr_rel - Release interrupt capabilities and free memory
  81 * @adapter: adapter to disable interrupts on
  82 */
  83void idpf_intr_rel(struct idpf_adapter *adapter)
  84{
  85	int err;
  86
  87	if (!adapter->msix_entries)
  88		return;
  89
  90	idpf_mb_intr_rel_irq(adapter);
  91	pci_free_irq_vectors(adapter->pdev);
  92
  93	err = idpf_send_dealloc_vectors_msg(adapter);
  94	if (err)
  95		dev_err(&adapter->pdev->dev,
  96			"Failed to deallocate vectors: %d\n", err);
  97
  98	idpf_deinit_vector_stack(adapter);
  99	kfree(adapter->msix_entries);
 100	adapter->msix_entries = NULL;
 101}
 102
 103/**
 104 * idpf_mb_intr_clean - Interrupt handler for the mailbox
 105 * @irq: interrupt number
 106 * @data: pointer to the adapter structure
 107 */
 108static irqreturn_t idpf_mb_intr_clean(int __always_unused irq, void *data)
 109{
 110	struct idpf_adapter *adapter = (struct idpf_adapter *)data;
 111
 112	queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);
 113
 114	return IRQ_HANDLED;
 115}
 116
 117/**
 118 * idpf_mb_irq_enable - Enable MSIX interrupt for the mailbox
 119 * @adapter: adapter to get the hardware address for register write
 120 */
 121static void idpf_mb_irq_enable(struct idpf_adapter *adapter)
 122{
 123	struct idpf_intr_reg *intr = &adapter->mb_vector.intr_reg;
 124	u32 val;
 125
 126	val = intr->dyn_ctl_intena_m | intr->dyn_ctl_itridx_m;
 127	writel(val, intr->dyn_ctl);
 128	writel(intr->icr_ena_ctlq_m, intr->icr_ena);
 129}
 130
 131/**
 132 * idpf_mb_intr_req_irq - Request irq for the mailbox interrupt
 133 * @adapter: adapter structure to pass to the mailbox irq handler
 134 */
 135static int idpf_mb_intr_req_irq(struct idpf_adapter *adapter)
 136{
 137	struct idpf_q_vector *mb_vector = &adapter->mb_vector;
 138	int irq_num, mb_vidx = 0, err;
 139
 140	irq_num = adapter->msix_entries[mb_vidx].vector;
 141	mb_vector->name = kasprintf(GFP_KERNEL, "%s-%s-%d",
 142				    dev_driver_string(&adapter->pdev->dev),
 143				    "Mailbox", mb_vidx);
 144	err = request_irq(irq_num, adapter->irq_mb_handler, 0,
 145			  mb_vector->name, adapter);
 146	if (err) {
 147		dev_err(&adapter->pdev->dev,
 148			"IRQ request for mailbox failed, error: %d\n", err);
 149
 150		return err;
 151	}
 152
 153	set_bit(IDPF_MB_INTR_MODE, adapter->flags);
 154
 155	return 0;
 156}
 157
 158/**
 159 * idpf_set_mb_vec_id - Set vector index for mailbox
 160 * @adapter: adapter structure to access the vector chunks
 161 *
 162 * The first vector id in the requested vector chunks from the CP is for
 163 * the mailbox
 164 */
 165static void idpf_set_mb_vec_id(struct idpf_adapter *adapter)
 166{
 167	if (adapter->req_vec_chunks)
 168		adapter->mb_vector.v_idx =
 169			le16_to_cpu(adapter->caps.mailbox_vector_id);
 170	else
 171		adapter->mb_vector.v_idx = 0;
 172}
 173
 174/**
 175 * idpf_mb_intr_init - Initialize the mailbox interrupt
 176 * @adapter: adapter structure to store the mailbox vector
 177 */
 178static int idpf_mb_intr_init(struct idpf_adapter *adapter)
 179{
 180	adapter->dev_ops.reg_ops.mb_intr_reg_init(adapter);
 181	adapter->irq_mb_handler = idpf_mb_intr_clean;
 182
 183	return idpf_mb_intr_req_irq(adapter);
 184}
 185
 186/**
 187 * idpf_vector_lifo_push - push MSIX vector index onto stack
 188 * @adapter: private data struct
 189 * @vec_idx: vector index to store
 190 */
 191static int idpf_vector_lifo_push(struct idpf_adapter *adapter, u16 vec_idx)
 192{
 193	struct idpf_vector_lifo *stack = &adapter->vector_stack;
 194
 195	lockdep_assert_held(&adapter->vector_lock);
 196
 197	if (stack->top == stack->base) {
 198		dev_err(&adapter->pdev->dev, "Exceeded the vector stack limit: %d\n",
 199			stack->top);
 200		return -EINVAL;
 201	}
 202
 203	stack->vec_idx[--stack->top] = vec_idx;
 204
 205	return 0;
 206}
 207
 208/**
 209 * idpf_vector_lifo_pop - pop MSIX vector index from stack
 210 * @adapter: private data struct
 211 */
 212static int idpf_vector_lifo_pop(struct idpf_adapter *adapter)
 213{
 214	struct idpf_vector_lifo *stack = &adapter->vector_stack;
 215
 216	lockdep_assert_held(&adapter->vector_lock);
 217
 218	if (stack->top == stack->size) {
 219		dev_err(&adapter->pdev->dev, "No interrupt vectors are available to distribute!\n");
 220
 221		return -EINVAL;
 222	}
 223
 224	return stack->vec_idx[stack->top++];
 225}
 226
 227/**
 228 * idpf_vector_stash - Store the vector indexes onto the stack
 229 * @adapter: private data struct
 230 * @q_vector_idxs: vector index array
 231 * @vec_info: info related to the number of vectors
 232 *
 233 * This function is a no-op if there are no vectors indexes to be stashed
 234 */
 235static void idpf_vector_stash(struct idpf_adapter *adapter, u16 *q_vector_idxs,
 236			      struct idpf_vector_info *vec_info)
 237{
 238	int i, base = 0;
 239	u16 vec_idx;
 240
 241	lockdep_assert_held(&adapter->vector_lock);
 242
 243	if (!vec_info->num_curr_vecs)
 244		return;
 245
 246	/* For default vports, no need to stash vector allocated from the
 247	 * default pool onto the stack
 248	 */
 249	if (vec_info->default_vport)
 250		base = IDPF_MIN_Q_VEC;
 251
 252	for (i = vec_info->num_curr_vecs - 1; i >= base ; i--) {
 253		vec_idx = q_vector_idxs[i];
 254		idpf_vector_lifo_push(adapter, vec_idx);
 255		adapter->num_avail_msix++;
 256	}
 257}
 258
 259/**
 260 * idpf_req_rel_vector_indexes - Request or release MSIX vector indexes
 261 * @adapter: driver specific private structure
 262 * @q_vector_idxs: vector index array
 263 * @vec_info: info related to the number of vectors
 264 *
 265 * This is the core function to distribute the MSIX vectors acquired from the
 266 * OS. It expects the caller to pass the number of vectors required and
 267 * also previously allocated. First, it stashes previously allocated vector
 268 * indexes on to the stack and then figures out if it can allocate requested
 269 * vectors. It can wait on acquiring the mutex lock. If the caller passes 0 as
 270 * requested vectors, then this function just stashes the already allocated
 271 * vectors and returns 0.
 272 *
 273 * Returns actual number of vectors allocated on success, error value on failure
 274 * If 0 is returned, implies the stack has no vectors to allocate which is also
 275 * a failure case for the caller
 276 */
 277int idpf_req_rel_vector_indexes(struct idpf_adapter *adapter,
 278				u16 *q_vector_idxs,
 279				struct idpf_vector_info *vec_info)
 280{
 281	u16 num_req_vecs, num_alloc_vecs = 0, max_vecs;
 282	struct idpf_vector_lifo *stack;
 283	int i, j, vecid;
 284
 285	mutex_lock(&adapter->vector_lock);
 286	stack = &adapter->vector_stack;
 287	num_req_vecs = vec_info->num_req_vecs;
 288
 289	/* Stash interrupt vector indexes onto the stack if required */
 290	idpf_vector_stash(adapter, q_vector_idxs, vec_info);
 291
 292	if (!num_req_vecs)
 293		goto rel_lock;
 294
 295	if (vec_info->default_vport) {
 296		/* As IDPF_MIN_Q_VEC per default vport is put aside in the
 297		 * default pool of the stack, use them for default vports
 298		 */
 299		j = vec_info->index * IDPF_MIN_Q_VEC + IDPF_MBX_Q_VEC;
 300		for (i = 0; i < IDPF_MIN_Q_VEC; i++) {
 301			q_vector_idxs[num_alloc_vecs++] = stack->vec_idx[j++];
 302			num_req_vecs--;
 303		}
 304	}
 305
 306	/* Find if stack has enough vector to allocate */
 307	max_vecs = min(adapter->num_avail_msix, num_req_vecs);
 308
 309	for (j = 0; j < max_vecs; j++) {
 310		vecid = idpf_vector_lifo_pop(adapter);
 311		q_vector_idxs[num_alloc_vecs++] = vecid;
 312	}
 313	adapter->num_avail_msix -= max_vecs;
 314
 315rel_lock:
 316	mutex_unlock(&adapter->vector_lock);
 317
 318	return num_alloc_vecs;
 319}
 320
 321/**
 322 * idpf_intr_req - Request interrupt capabilities
 323 * @adapter: adapter to enable interrupts on
 324 *
 325 * Returns 0 on success, negative on failure
 326 */
 327int idpf_intr_req(struct idpf_adapter *adapter)
 328{
 329	u16 default_vports = idpf_get_default_vports(adapter);
 330	int num_q_vecs, total_vecs, num_vec_ids;
 331	int min_vectors, v_actual, err;
 332	unsigned int vector;
 333	u16 *vecids;
 334
 335	total_vecs = idpf_get_reserved_vecs(adapter);
 336	num_q_vecs = total_vecs - IDPF_MBX_Q_VEC;
 337
 338	err = idpf_send_alloc_vectors_msg(adapter, num_q_vecs);
 339	if (err) {
 340		dev_err(&adapter->pdev->dev,
 341			"Failed to allocate %d vectors: %d\n", num_q_vecs, err);
 342
 343		return -EAGAIN;
 344	}
 345
 346	min_vectors = IDPF_MBX_Q_VEC + IDPF_MIN_Q_VEC * default_vports;
 347	v_actual = pci_alloc_irq_vectors(adapter->pdev, min_vectors,
 348					 total_vecs, PCI_IRQ_MSIX);
 349	if (v_actual < min_vectors) {
 350		dev_err(&adapter->pdev->dev, "Failed to allocate MSIX vectors: %d\n",
 351			v_actual);
 352		err = -EAGAIN;
 353		goto send_dealloc_vecs;
 354	}
 355
 356	adapter->msix_entries = kcalloc(v_actual, sizeof(struct msix_entry),
 357					GFP_KERNEL);
 358
 359	if (!adapter->msix_entries) {
 360		err = -ENOMEM;
 361		goto free_irq;
 362	}
 363
 364	idpf_set_mb_vec_id(adapter);
 365
 366	vecids = kcalloc(total_vecs, sizeof(u16), GFP_KERNEL);
 367	if (!vecids) {
 368		err = -ENOMEM;
 369		goto free_msix;
 370	}
 371
 372	if (adapter->req_vec_chunks) {
 373		struct virtchnl2_vector_chunks *vchunks;
 374		struct virtchnl2_alloc_vectors *ac;
 375
 376		ac = adapter->req_vec_chunks;
 377		vchunks = &ac->vchunks;
 378
 379		num_vec_ids = idpf_get_vec_ids(adapter, vecids, total_vecs,
 380					       vchunks);
 381		if (num_vec_ids < v_actual) {
 382			err = -EINVAL;
 383			goto free_vecids;
 384		}
 385	} else {
 386		int i;
 387
 388		for (i = 0; i < v_actual; i++)
 389			vecids[i] = i;
 390	}
 391
 392	for (vector = 0; vector < v_actual; vector++) {
 393		adapter->msix_entries[vector].entry = vecids[vector];
 394		adapter->msix_entries[vector].vector =
 395			pci_irq_vector(adapter->pdev, vector);
 396	}
 397
 398	adapter->num_req_msix = total_vecs;
 399	adapter->num_msix_entries = v_actual;
 400	/* 'num_avail_msix' is used to distribute excess vectors to the vports
 401	 * after considering the minimum vectors required per each default
 402	 * vport
 403	 */
 404	adapter->num_avail_msix = v_actual - min_vectors;
 405
 406	/* Fill MSIX vector lifo stack with vector indexes */
 407	err = idpf_init_vector_stack(adapter);
 408	if (err)
 409		goto free_vecids;
 410
 411	err = idpf_mb_intr_init(adapter);
 412	if (err)
 413		goto deinit_vec_stack;
 414	idpf_mb_irq_enable(adapter);
 415	kfree(vecids);
 416
 417	return 0;
 418
 419deinit_vec_stack:
 420	idpf_deinit_vector_stack(adapter);
 421free_vecids:
 422	kfree(vecids);
 423free_msix:
 424	kfree(adapter->msix_entries);
 425	adapter->msix_entries = NULL;
 426free_irq:
 427	pci_free_irq_vectors(adapter->pdev);
 428send_dealloc_vecs:
 429	idpf_send_dealloc_vectors_msg(adapter);
 430
 431	return err;
 432}
 433
 434/**
 435 * idpf_find_mac_filter - Search filter list for specific mac filter
 436 * @vconfig: Vport config structure
 437 * @macaddr: The MAC address
 438 *
 439 * Returns ptr to the filter object or NULL. Must be called while holding the
 440 * mac_filter_list_lock.
 441 **/
 442static struct idpf_mac_filter *idpf_find_mac_filter(struct idpf_vport_config *vconfig,
 443						    const u8 *macaddr)
 444{
 445	struct idpf_mac_filter *f;
 446
 447	if (!macaddr)
 448		return NULL;
 449
 450	list_for_each_entry(f, &vconfig->user_config.mac_filter_list, list) {
 451		if (ether_addr_equal(macaddr, f->macaddr))
 452			return f;
 453	}
 454
 455	return NULL;
 456}
 457
 458/**
 459 * __idpf_del_mac_filter - Delete a MAC filter from the filter list
 460 * @vport_config: Vport config structure
 461 * @macaddr: The MAC address
 462 *
 463 * Returns 0 on success, error value on failure
 464 **/
 465static int __idpf_del_mac_filter(struct idpf_vport_config *vport_config,
 466				 const u8 *macaddr)
 467{
 468	struct idpf_mac_filter *f;
 469
 470	spin_lock_bh(&vport_config->mac_filter_list_lock);
 471	f = idpf_find_mac_filter(vport_config, macaddr);
 472	if (f) {
 473		list_del(&f->list);
 474		kfree(f);
 475	}
 476	spin_unlock_bh(&vport_config->mac_filter_list_lock);
 477
 478	return 0;
 479}
 480
 481/**
 482 * idpf_del_mac_filter - Delete a MAC filter from the filter list
 483 * @vport: Main vport structure
 484 * @np: Netdev private structure
 485 * @macaddr: The MAC address
 486 * @async: Don't wait for return message
 487 *
 488 * Removes filter from list and if interface is up, tells hardware about the
 489 * removed filter.
 490 **/
 491static int idpf_del_mac_filter(struct idpf_vport *vport,
 492			       struct idpf_netdev_priv *np,
 493			       const u8 *macaddr, bool async)
 494{
 495	struct idpf_vport_config *vport_config;
 496	struct idpf_mac_filter *f;
 497
 498	vport_config = np->adapter->vport_config[np->vport_idx];
 499
 500	spin_lock_bh(&vport_config->mac_filter_list_lock);
 501	f = idpf_find_mac_filter(vport_config, macaddr);
 502	if (f) {
 503		f->remove = true;
 504	} else {
 505		spin_unlock_bh(&vport_config->mac_filter_list_lock);
 506
 507		return -EINVAL;
 508	}
 509	spin_unlock_bh(&vport_config->mac_filter_list_lock);
 510
 511	if (np->state == __IDPF_VPORT_UP) {
 512		int err;
 513
 514		err = idpf_add_del_mac_filters(vport, np, false, async);
 515		if (err)
 516			return err;
 517	}
 518
 519	return  __idpf_del_mac_filter(vport_config, macaddr);
 520}
 521
 522/**
 523 * __idpf_add_mac_filter - Add mac filter helper function
 524 * @vport_config: Vport config structure
 525 * @macaddr: Address to add
 526 *
 527 * Takes mac_filter_list_lock spinlock to add new filter to list.
 528 */
 529static int __idpf_add_mac_filter(struct idpf_vport_config *vport_config,
 530				 const u8 *macaddr)
 531{
 532	struct idpf_mac_filter *f;
 533
 534	spin_lock_bh(&vport_config->mac_filter_list_lock);
 535
 536	f = idpf_find_mac_filter(vport_config, macaddr);
 537	if (f) {
 538		f->remove = false;
 539		spin_unlock_bh(&vport_config->mac_filter_list_lock);
 540
 541		return 0;
 542	}
 543
 544	f = kzalloc(sizeof(*f), GFP_ATOMIC);
 545	if (!f) {
 546		spin_unlock_bh(&vport_config->mac_filter_list_lock);
 547
 548		return -ENOMEM;
 549	}
 550
 551	ether_addr_copy(f->macaddr, macaddr);
 552	list_add_tail(&f->list, &vport_config->user_config.mac_filter_list);
 553	f->add = true;
 554
 555	spin_unlock_bh(&vport_config->mac_filter_list_lock);
 556
 557	return 0;
 558}
 559
 560/**
 561 * idpf_add_mac_filter - Add a mac filter to the filter list
 562 * @vport: Main vport structure
 563 * @np: Netdev private structure
 564 * @macaddr: The MAC address
 565 * @async: Don't wait for return message
 566 *
 567 * Returns 0 on success or error on failure. If interface is up, we'll also
 568 * send the virtchnl message to tell hardware about the filter.
 569 **/
 570static int idpf_add_mac_filter(struct idpf_vport *vport,
 571			       struct idpf_netdev_priv *np,
 572			       const u8 *macaddr, bool async)
 573{
 574	struct idpf_vport_config *vport_config;
 575	int err;
 576
 577	vport_config = np->adapter->vport_config[np->vport_idx];
 578	err = __idpf_add_mac_filter(vport_config, macaddr);
 579	if (err)
 580		return err;
 581
 582	if (np->state == __IDPF_VPORT_UP)
 583		err = idpf_add_del_mac_filters(vport, np, true, async);
 584
 585	return err;
 586}
 587
 588/**
 589 * idpf_del_all_mac_filters - Delete all MAC filters in list
 590 * @vport: main vport struct
 591 *
 592 * Takes mac_filter_list_lock spinlock.  Deletes all filters
 593 */
 594static void idpf_del_all_mac_filters(struct idpf_vport *vport)
 595{
 596	struct idpf_vport_config *vport_config;
 597	struct idpf_mac_filter *f, *ftmp;
 598
 599	vport_config = vport->adapter->vport_config[vport->idx];
 600	spin_lock_bh(&vport_config->mac_filter_list_lock);
 601
 602	list_for_each_entry_safe(f, ftmp, &vport_config->user_config.mac_filter_list,
 603				 list) {
 604		list_del(&f->list);
 605		kfree(f);
 606	}
 607
 608	spin_unlock_bh(&vport_config->mac_filter_list_lock);
 609}
 610
 611/**
 612 * idpf_restore_mac_filters - Re-add all MAC filters in list
 613 * @vport: main vport struct
 614 *
 615 * Takes mac_filter_list_lock spinlock.  Sets add field to true for filters to
 616 * resync filters back to HW.
 617 */
 618static void idpf_restore_mac_filters(struct idpf_vport *vport)
 619{
 620	struct idpf_vport_config *vport_config;
 621	struct idpf_mac_filter *f;
 622
 623	vport_config = vport->adapter->vport_config[vport->idx];
 624	spin_lock_bh(&vport_config->mac_filter_list_lock);
 625
 626	list_for_each_entry(f, &vport_config->user_config.mac_filter_list, list)
 627		f->add = true;
 628
 629	spin_unlock_bh(&vport_config->mac_filter_list_lock);
 630
 631	idpf_add_del_mac_filters(vport, netdev_priv(vport->netdev),
 632				 true, false);
 633}
 634
 635/**
 636 * idpf_remove_mac_filters - Remove all MAC filters in list
 637 * @vport: main vport struct
 638 *
 639 * Takes mac_filter_list_lock spinlock. Sets remove field to true for filters
 640 * to remove filters in HW.
 641 */
 642static void idpf_remove_mac_filters(struct idpf_vport *vport)
 643{
 644	struct idpf_vport_config *vport_config;
 645	struct idpf_mac_filter *f;
 646
 647	vport_config = vport->adapter->vport_config[vport->idx];
 648	spin_lock_bh(&vport_config->mac_filter_list_lock);
 649
 650	list_for_each_entry(f, &vport_config->user_config.mac_filter_list, list)
 651		f->remove = true;
 652
 653	spin_unlock_bh(&vport_config->mac_filter_list_lock);
 654
 655	idpf_add_del_mac_filters(vport, netdev_priv(vport->netdev),
 656				 false, false);
 657}
 658
 659/**
 660 * idpf_deinit_mac_addr - deinitialize mac address for vport
 661 * @vport: main vport structure
 662 */
 663static void idpf_deinit_mac_addr(struct idpf_vport *vport)
 664{
 665	struct idpf_vport_config *vport_config;
 666	struct idpf_mac_filter *f;
 667
 668	vport_config = vport->adapter->vport_config[vport->idx];
 669
 670	spin_lock_bh(&vport_config->mac_filter_list_lock);
 671
 672	f = idpf_find_mac_filter(vport_config, vport->default_mac_addr);
 673	if (f) {
 674		list_del(&f->list);
 675		kfree(f);
 676	}
 677
 678	spin_unlock_bh(&vport_config->mac_filter_list_lock);
 679}
 680
 681/**
 682 * idpf_init_mac_addr - initialize mac address for vport
 683 * @vport: main vport structure
 684 * @netdev: pointer to netdev struct associated with this vport
 685 */
 686static int idpf_init_mac_addr(struct idpf_vport *vport,
 687			      struct net_device *netdev)
 688{
 689	struct idpf_netdev_priv *np = netdev_priv(netdev);
 690	struct idpf_adapter *adapter = vport->adapter;
 691	int err;
 692
 693	if (is_valid_ether_addr(vport->default_mac_addr)) {
 694		eth_hw_addr_set(netdev, vport->default_mac_addr);
 695		ether_addr_copy(netdev->perm_addr, vport->default_mac_addr);
 696
 697		return idpf_add_mac_filter(vport, np, vport->default_mac_addr,
 698					   false);
 699	}
 700
 701	if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS,
 702			     VIRTCHNL2_CAP_MACFILTER)) {
 703		dev_err(&adapter->pdev->dev,
 704			"MAC address is not provided and capability is not set\n");
 705
 706		return -EINVAL;
 707	}
 708
 709	eth_hw_addr_random(netdev);
 710	err = idpf_add_mac_filter(vport, np, netdev->dev_addr, false);
 711	if (err)
 712		return err;
 713
 714	dev_info(&adapter->pdev->dev, "Invalid MAC address %pM, using random %pM\n",
 715		 vport->default_mac_addr, netdev->dev_addr);
 716	ether_addr_copy(vport->default_mac_addr, netdev->dev_addr);
 717
 718	return 0;
 719}
 720
 721/**
 722 * idpf_cfg_netdev - Allocate, configure and register a netdev
 723 * @vport: main vport structure
 724 *
 725 * Returns 0 on success, negative value on failure.
 726 */
 727static int idpf_cfg_netdev(struct idpf_vport *vport)
 728{
 729	struct idpf_adapter *adapter = vport->adapter;
 730	struct idpf_vport_config *vport_config;
 731	netdev_features_t dflt_features;
 732	netdev_features_t offloads = 0;
 733	struct idpf_netdev_priv *np;
 734	struct net_device *netdev;
 735	u16 idx = vport->idx;
 736	int err;
 737
 738	vport_config = adapter->vport_config[idx];
 739
 740	/* It's possible we already have a netdev allocated and registered for
 741	 * this vport
 742	 */
 743	if (test_bit(IDPF_VPORT_REG_NETDEV, vport_config->flags)) {
 744		netdev = adapter->netdevs[idx];
 745		np = netdev_priv(netdev);
 746		np->vport = vport;
 747		np->vport_idx = vport->idx;
 748		np->vport_id = vport->vport_id;
 749		vport->netdev = netdev;
 750
 751		return idpf_init_mac_addr(vport, netdev);
 752	}
 753
 754	netdev = alloc_etherdev_mqs(sizeof(struct idpf_netdev_priv),
 755				    vport_config->max_q.max_txq,
 756				    vport_config->max_q.max_rxq);
 757	if (!netdev)
 758		return -ENOMEM;
 759
 760	vport->netdev = netdev;
 761	np = netdev_priv(netdev);
 762	np->vport = vport;
 763	np->adapter = adapter;
 764	np->vport_idx = vport->idx;
 765	np->vport_id = vport->vport_id;
 766
 767	spin_lock_init(&np->stats_lock);
 768
 769	err = idpf_init_mac_addr(vport, netdev);
 770	if (err) {
 771		free_netdev(vport->netdev);
 772		vport->netdev = NULL;
 773
 774		return err;
 775	}
 776
 777	/* assign netdev_ops */
 778	if (idpf_is_queue_model_split(vport->txq_model))
 779		netdev->netdev_ops = &idpf_netdev_ops_splitq;
 780	else
 781		netdev->netdev_ops = &idpf_netdev_ops_singleq;
 782
 783	/* setup watchdog timeout value to be 5 second */
 784	netdev->watchdog_timeo = 5 * HZ;
 785
 786	netdev->dev_port = idx;
 787
 788	/* configure default MTU size */
 789	netdev->min_mtu = ETH_MIN_MTU;
 790	netdev->max_mtu = vport->max_mtu;
 791
 792	dflt_features = NETIF_F_SG	|
 793			NETIF_F_HIGHDMA;
 794
 795	if (idpf_is_cap_ena_all(adapter, IDPF_RSS_CAPS, IDPF_CAP_RSS))
 796		dflt_features |= NETIF_F_RXHASH;
 797	if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_RX_CSUM_L4V4))
 798		dflt_features |= NETIF_F_IP_CSUM;
 799	if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_RX_CSUM_L4V6))
 800		dflt_features |= NETIF_F_IPV6_CSUM;
 801	if (idpf_is_cap_ena(adapter, IDPF_CSUM_CAPS, IDPF_CAP_RX_CSUM))
 802		dflt_features |= NETIF_F_RXCSUM;
 803	if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_SCTP_CSUM))
 804		dflt_features |= NETIF_F_SCTP_CRC;
 805
 806	if (idpf_is_cap_ena(adapter, IDPF_SEG_CAPS, VIRTCHNL2_CAP_SEG_IPV4_TCP))
 807		dflt_features |= NETIF_F_TSO;
 808	if (idpf_is_cap_ena(adapter, IDPF_SEG_CAPS, VIRTCHNL2_CAP_SEG_IPV6_TCP))
 809		dflt_features |= NETIF_F_TSO6;
 810	if (idpf_is_cap_ena_all(adapter, IDPF_SEG_CAPS,
 811				VIRTCHNL2_CAP_SEG_IPV4_UDP |
 812				VIRTCHNL2_CAP_SEG_IPV6_UDP))
 813		dflt_features |= NETIF_F_GSO_UDP_L4;
 814	if (idpf_is_cap_ena_all(adapter, IDPF_RSC_CAPS, IDPF_CAP_RSC))
 815		offloads |= NETIF_F_GRO_HW;
 816	/* advertise to stack only if offloads for encapsulated packets is
 817	 * supported
 818	 */
 819	if (idpf_is_cap_ena(vport->adapter, IDPF_SEG_CAPS,
 820			    VIRTCHNL2_CAP_SEG_TX_SINGLE_TUNNEL)) {
 821		offloads |= NETIF_F_GSO_UDP_TUNNEL	|
 822			    NETIF_F_GSO_GRE		|
 823			    NETIF_F_GSO_GRE_CSUM	|
 824			    NETIF_F_GSO_PARTIAL		|
 825			    NETIF_F_GSO_UDP_TUNNEL_CSUM	|
 826			    NETIF_F_GSO_IPXIP4		|
 827			    NETIF_F_GSO_IPXIP6		|
 828			    0;
 829
 830		if (!idpf_is_cap_ena_all(vport->adapter, IDPF_CSUM_CAPS,
 831					 IDPF_CAP_TUNNEL_TX_CSUM))
 832			netdev->gso_partial_features |=
 833				NETIF_F_GSO_UDP_TUNNEL_CSUM;
 834
 835		netdev->gso_partial_features |= NETIF_F_GSO_GRE_CSUM;
 836		offloads |= NETIF_F_TSO_MANGLEID;
 837	}
 838	if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_LOOPBACK))
 839		offloads |= NETIF_F_LOOPBACK;
 840
 841	netdev->features |= dflt_features;
 842	netdev->hw_features |= dflt_features | offloads;
 843	netdev->hw_enc_features |= dflt_features | offloads;
 844	idpf_set_ethtool_ops(netdev);
 845	SET_NETDEV_DEV(netdev, &adapter->pdev->dev);
 846
 847	/* carrier off on init to avoid Tx hangs */
 848	netif_carrier_off(netdev);
 849
 850	/* make sure transmit queues start off as stopped */
 851	netif_tx_stop_all_queues(netdev);
 852
 853	/* The vport can be arbitrarily released so we need to also track
 854	 * netdevs in the adapter struct
 855	 */
 856	adapter->netdevs[idx] = netdev;
 857
 858	return 0;
 859}
 860
 861/**
 862 * idpf_get_free_slot - get the next non-NULL location index in array
 863 * @adapter: adapter in which to look for a free vport slot
 864 */
 865static int idpf_get_free_slot(struct idpf_adapter *adapter)
 866{
 867	unsigned int i;
 868
 869	for (i = 0; i < adapter->max_vports; i++) {
 870		if (!adapter->vports[i])
 871			return i;
 872	}
 873
 874	return IDPF_NO_FREE_SLOT;
 875}
 876
 877/**
 878 * idpf_remove_features - Turn off feature configs
 879 * @vport: virtual port structure
 880 */
 881static void idpf_remove_features(struct idpf_vport *vport)
 882{
 883	struct idpf_adapter *adapter = vport->adapter;
 884
 885	if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER))
 886		idpf_remove_mac_filters(vport);
 887}
 888
 889/**
 890 * idpf_vport_stop - Disable a vport
 891 * @vport: vport to disable
 892 */
 893static void idpf_vport_stop(struct idpf_vport *vport)
 894{
 895	struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
 896
 897	if (np->state <= __IDPF_VPORT_DOWN)
 898		return;
 899
 900	netif_carrier_off(vport->netdev);
 901	netif_tx_disable(vport->netdev);
 902
 903	idpf_send_disable_vport_msg(vport);
 904	idpf_send_disable_queues_msg(vport);
 905	idpf_send_map_unmap_queue_vector_msg(vport, false);
 906	/* Normally we ask for queues in create_vport, but if the number of
 907	 * initially requested queues have changed, for example via ethtool
 908	 * set channels, we do delete queues and then add the queues back
 909	 * instead of deleting and reallocating the vport.
 910	 */
 911	if (test_and_clear_bit(IDPF_VPORT_DEL_QUEUES, vport->flags))
 912		idpf_send_delete_queues_msg(vport);
 913
 914	idpf_remove_features(vport);
 915
 916	vport->link_up = false;
 917	idpf_vport_intr_deinit(vport);
 918	idpf_vport_intr_rel(vport);
 919	idpf_vport_queues_rel(vport);
 920	np->state = __IDPF_VPORT_DOWN;
 921}
 922
 923/**
 924 * idpf_stop - Disables a network interface
 925 * @netdev: network interface device structure
 926 *
 927 * The stop entry point is called when an interface is de-activated by the OS,
 928 * and the netdevice enters the DOWN state.  The hardware is still under the
 929 * driver's control, but the netdev interface is disabled.
 930 *
 931 * Returns success only - not allowed to fail
 932 */
 933static int idpf_stop(struct net_device *netdev)
 934{
 935	struct idpf_netdev_priv *np = netdev_priv(netdev);
 936	struct idpf_vport *vport;
 937
 938	if (test_bit(IDPF_REMOVE_IN_PROG, np->adapter->flags))
 939		return 0;
 940
 941	idpf_vport_ctrl_lock(netdev);
 942	vport = idpf_netdev_to_vport(netdev);
 943
 944	idpf_vport_stop(vport);
 945
 946	idpf_vport_ctrl_unlock(netdev);
 947
 948	return 0;
 949}
 950
 951/**
 952 * idpf_decfg_netdev - Unregister the netdev
 953 * @vport: vport for which netdev to be unregistered
 954 */
 955static void idpf_decfg_netdev(struct idpf_vport *vport)
 956{
 957	struct idpf_adapter *adapter = vport->adapter;
 958
 959	unregister_netdev(vport->netdev);
 960	free_netdev(vport->netdev);
 961	vport->netdev = NULL;
 962
 963	adapter->netdevs[vport->idx] = NULL;
 964}
 965
 966/**
 967 * idpf_vport_rel - Delete a vport and free its resources
 968 * @vport: the vport being removed
 969 */
 970static void idpf_vport_rel(struct idpf_vport *vport)
 971{
 972	struct idpf_adapter *adapter = vport->adapter;
 973	struct idpf_vport_config *vport_config;
 974	struct idpf_vector_info vec_info;
 975	struct idpf_rss_data *rss_data;
 976	struct idpf_vport_max_q max_q;
 977	u16 idx = vport->idx;
 978	int i;
 979
 980	vport_config = adapter->vport_config[vport->idx];
 981	idpf_deinit_rss(vport);
 982	rss_data = &vport_config->user_config.rss_data;
 983	kfree(rss_data->rss_key);
 984	rss_data->rss_key = NULL;
 985
 986	idpf_send_destroy_vport_msg(vport);
 987
 988	/* Set all bits as we dont know on which vc_state the vport vhnl_wq
 989	 * is waiting on and wakeup the virtchnl workqueue even if it is
 990	 * waiting for the response as we are going down
 991	 */
 992	for (i = 0; i < IDPF_VC_NBITS; i++)
 993		set_bit(i, vport->vc_state);
 994	wake_up(&vport->vchnl_wq);
 995
 996	mutex_destroy(&vport->vc_buf_lock);
 997
 998	/* Clear all the bits */
 999	for (i = 0; i < IDPF_VC_NBITS; i++)
1000		clear_bit(i, vport->vc_state);
1001
1002	/* Release all max queues allocated to the adapter's pool */
1003	max_q.max_rxq = vport_config->max_q.max_rxq;
1004	max_q.max_txq = vport_config->max_q.max_txq;
1005	max_q.max_bufq = vport_config->max_q.max_bufq;
1006	max_q.max_complq = vport_config->max_q.max_complq;
1007	idpf_vport_dealloc_max_qs(adapter, &max_q);
1008
1009	/* Release all the allocated vectors on the stack */
1010	vec_info.num_req_vecs = 0;
1011	vec_info.num_curr_vecs = vport->num_q_vectors;
1012	vec_info.default_vport = vport->default_vport;
1013
1014	idpf_req_rel_vector_indexes(adapter, vport->q_vector_idxs, &vec_info);
1015
1016	kfree(vport->q_vector_idxs);
1017	vport->q_vector_idxs = NULL;
1018
1019	kfree(adapter->vport_params_recvd[idx]);
1020	adapter->vport_params_recvd[idx] = NULL;
1021	kfree(adapter->vport_params_reqd[idx]);
1022	adapter->vport_params_reqd[idx] = NULL;
1023	if (adapter->vport_config[idx]) {
1024		kfree(adapter->vport_config[idx]->req_qs_chunks);
1025		adapter->vport_config[idx]->req_qs_chunks = NULL;
1026	}
1027	kfree(vport);
1028	adapter->num_alloc_vports--;
1029}
1030
1031/**
1032 * idpf_vport_dealloc - cleanup and release a given vport
1033 * @vport: pointer to idpf vport structure
1034 *
1035 * returns nothing
1036 */
1037static void idpf_vport_dealloc(struct idpf_vport *vport)
1038{
1039	struct idpf_adapter *adapter = vport->adapter;
1040	unsigned int i = vport->idx;
1041
1042	idpf_deinit_mac_addr(vport);
1043	idpf_vport_stop(vport);
1044
1045	if (!test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags))
1046		idpf_decfg_netdev(vport);
1047	if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags))
1048		idpf_del_all_mac_filters(vport);
1049
1050	if (adapter->netdevs[i]) {
1051		struct idpf_netdev_priv *np = netdev_priv(adapter->netdevs[i]);
1052
1053		np->vport = NULL;
1054	}
1055
1056	idpf_vport_rel(vport);
1057
1058	adapter->vports[i] = NULL;
1059	adapter->next_vport = idpf_get_free_slot(adapter);
1060}
1061
1062/**
1063 * idpf_is_hsplit_supported - check whether the header split is supported
1064 * @vport: virtual port to check the capability for
1065 *
1066 * Return: true if it's supported by the HW/FW, false if not.
1067 */
1068static bool idpf_is_hsplit_supported(const struct idpf_vport *vport)
1069{
1070	return idpf_is_queue_model_split(vport->rxq_model) &&
1071	       idpf_is_cap_ena_all(vport->adapter, IDPF_HSPLIT_CAPS,
1072				   IDPF_CAP_HSPLIT);
1073}
1074
1075/**
1076 * idpf_vport_get_hsplit - get the current header split feature state
1077 * @vport: virtual port to query the state for
1078 *
1079 * Return: ``ETHTOOL_TCP_DATA_SPLIT_UNKNOWN`` if not supported,
1080 *         ``ETHTOOL_TCP_DATA_SPLIT_DISABLED`` if disabled,
1081 *         ``ETHTOOL_TCP_DATA_SPLIT_ENABLED`` if active.
1082 */
1083u8 idpf_vport_get_hsplit(const struct idpf_vport *vport)
1084{
1085	const struct idpf_vport_user_config_data *config;
1086
1087	if (!idpf_is_hsplit_supported(vport))
1088		return ETHTOOL_TCP_DATA_SPLIT_UNKNOWN;
1089
1090	config = &vport->adapter->vport_config[vport->idx]->user_config;
1091
1092	return test_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags) ?
1093	       ETHTOOL_TCP_DATA_SPLIT_ENABLED :
1094	       ETHTOOL_TCP_DATA_SPLIT_DISABLED;
1095}
1096
1097/**
1098 * idpf_vport_set_hsplit - enable or disable header split on a given vport
1099 * @vport: virtual port to configure
1100 * @val: Ethtool flag controlling the header split state
1101 *
1102 * Return: true on success, false if not supported by the HW.
1103 */
1104bool idpf_vport_set_hsplit(const struct idpf_vport *vport, u8 val)
1105{
1106	struct idpf_vport_user_config_data *config;
1107
1108	if (!idpf_is_hsplit_supported(vport))
1109		return val == ETHTOOL_TCP_DATA_SPLIT_UNKNOWN;
1110
1111	config = &vport->adapter->vport_config[vport->idx]->user_config;
1112
1113	switch (val) {
1114	case ETHTOOL_TCP_DATA_SPLIT_UNKNOWN:
1115		/* Default is to enable */
1116	case ETHTOOL_TCP_DATA_SPLIT_ENABLED:
1117		__set_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags);
1118		return true;
1119	case ETHTOOL_TCP_DATA_SPLIT_DISABLED:
1120		__clear_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags);
1121		return true;
1122	default:
1123		return false;
1124	}
1125}
1126
1127/**
1128 * idpf_vport_alloc - Allocates the next available struct vport in the adapter
1129 * @adapter: board private structure
1130 * @max_q: vport max queue info
1131 *
1132 * returns a pointer to a vport on success, NULL on failure.
1133 */
1134static struct idpf_vport *idpf_vport_alloc(struct idpf_adapter *adapter,
1135					   struct idpf_vport_max_q *max_q)
1136{
1137	struct idpf_rss_data *rss_data;
1138	u16 idx = adapter->next_vport;
1139	struct idpf_vport *vport;
1140	u16 num_max_q;
1141
1142	if (idx == IDPF_NO_FREE_SLOT)
1143		return NULL;
1144
1145	vport = kzalloc(sizeof(*vport), GFP_KERNEL);
1146	if (!vport)
1147		return vport;
1148
1149	if (!adapter->vport_config[idx]) {
1150		struct idpf_vport_config *vport_config;
1151
1152		vport_config = kzalloc(sizeof(*vport_config), GFP_KERNEL);
1153		if (!vport_config) {
1154			kfree(vport);
1155
1156			return NULL;
1157		}
1158
1159		adapter->vport_config[idx] = vport_config;
1160	}
1161
1162	vport->idx = idx;
1163	vport->adapter = adapter;
1164	vport->compln_clean_budget = IDPF_TX_COMPLQ_CLEAN_BUDGET;
1165	vport->default_vport = adapter->num_alloc_vports <
1166			       idpf_get_default_vports(adapter);
1167
1168	num_max_q = max(max_q->max_txq, max_q->max_rxq);
1169	vport->q_vector_idxs = kcalloc(num_max_q, sizeof(u16), GFP_KERNEL);
1170	if (!vport->q_vector_idxs) {
1171		kfree(vport);
1172
1173		return NULL;
1174	}
1175	idpf_vport_init(vport, max_q);
1176
1177	/* This alloc is done separate from the LUT because it's not strictly
1178	 * dependent on how many queues we have. If we change number of queues
1179	 * and soft reset we'll need a new LUT but the key can remain the same
1180	 * for as long as the vport exists.
1181	 */
1182	rss_data = &adapter->vport_config[idx]->user_config.rss_data;
1183	rss_data->rss_key = kzalloc(rss_data->rss_key_size, GFP_KERNEL);
1184	if (!rss_data->rss_key) {
1185		kfree(vport);
1186
1187		return NULL;
1188	}
1189	/* Initialize default rss key */
1190	netdev_rss_key_fill((void *)rss_data->rss_key, rss_data->rss_key_size);
1191
1192	/* fill vport slot in the adapter struct */
1193	adapter->vports[idx] = vport;
1194	adapter->vport_ids[idx] = idpf_get_vport_id(vport);
1195
1196	adapter->num_alloc_vports++;
1197	/* prepare adapter->next_vport for next use */
1198	adapter->next_vport = idpf_get_free_slot(adapter);
1199
1200	return vport;
1201}
1202
1203/**
1204 * idpf_get_stats64 - get statistics for network device structure
1205 * @netdev: network interface device structure
1206 * @stats: main device statistics structure
1207 */
1208static void idpf_get_stats64(struct net_device *netdev,
1209			     struct rtnl_link_stats64 *stats)
1210{
1211	struct idpf_netdev_priv *np = netdev_priv(netdev);
1212
1213	spin_lock_bh(&np->stats_lock);
1214	*stats = np->netstats;
1215	spin_unlock_bh(&np->stats_lock);
1216}
1217
1218/**
1219 * idpf_statistics_task - Delayed task to get statistics over mailbox
1220 * @work: work_struct handle to our data
1221 */
1222void idpf_statistics_task(struct work_struct *work)
1223{
1224	struct idpf_adapter *adapter;
1225	int i;
1226
1227	adapter = container_of(work, struct idpf_adapter, stats_task.work);
1228
1229	for (i = 0; i < adapter->max_vports; i++) {
1230		struct idpf_vport *vport = adapter->vports[i];
1231
1232		if (vport && !test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags))
1233			idpf_send_get_stats_msg(vport);
1234	}
1235
1236	queue_delayed_work(adapter->stats_wq, &adapter->stats_task,
1237			   msecs_to_jiffies(10000));
1238}
1239
1240/**
1241 * idpf_mbx_task - Delayed task to handle mailbox responses
1242 * @work: work_struct handle
1243 */
1244void idpf_mbx_task(struct work_struct *work)
1245{
1246	struct idpf_adapter *adapter;
1247
1248	adapter = container_of(work, struct idpf_adapter, mbx_task.work);
1249
1250	if (test_bit(IDPF_MB_INTR_MODE, adapter->flags))
1251		idpf_mb_irq_enable(adapter);
1252	else
1253		queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task,
1254				   msecs_to_jiffies(300));
1255
1256	idpf_recv_mb_msg(adapter, VIRTCHNL2_OP_UNKNOWN, NULL, 0);
1257}
1258
1259/**
1260 * idpf_service_task - Delayed task for handling mailbox responses
1261 * @work: work_struct handle to our data
1262 *
1263 */
1264void idpf_service_task(struct work_struct *work)
1265{
1266	struct idpf_adapter *adapter;
1267
1268	adapter = container_of(work, struct idpf_adapter, serv_task.work);
1269
1270	if (idpf_is_reset_detected(adapter) &&
1271	    !idpf_is_reset_in_prog(adapter) &&
1272	    !test_bit(IDPF_REMOVE_IN_PROG, adapter->flags)) {
1273		dev_info(&adapter->pdev->dev, "HW reset detected\n");
1274		set_bit(IDPF_HR_FUNC_RESET, adapter->flags);
1275		queue_delayed_work(adapter->vc_event_wq,
1276				   &adapter->vc_event_task,
1277				   msecs_to_jiffies(10));
1278	}
1279
1280	queue_delayed_work(adapter->serv_wq, &adapter->serv_task,
1281			   msecs_to_jiffies(300));
1282}
1283
1284/**
1285 * idpf_restore_features - Restore feature configs
1286 * @vport: virtual port structure
1287 */
1288static void idpf_restore_features(struct idpf_vport *vport)
1289{
1290	struct idpf_adapter *adapter = vport->adapter;
1291
1292	if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER))
1293		idpf_restore_mac_filters(vport);
1294}
1295
1296/**
1297 * idpf_set_real_num_queues - set number of queues for netdev
1298 * @vport: virtual port structure
1299 *
1300 * Returns 0 on success, negative on failure.
1301 */
1302static int idpf_set_real_num_queues(struct idpf_vport *vport)
1303{
1304	int err;
1305
1306	err = netif_set_real_num_rx_queues(vport->netdev, vport->num_rxq);
1307	if (err)
1308		return err;
1309
1310	return netif_set_real_num_tx_queues(vport->netdev, vport->num_txq);
1311}
1312
1313/**
1314 * idpf_up_complete - Complete interface up sequence
1315 * @vport: virtual port structure
1316 *
1317 * Returns 0 on success, negative on failure.
1318 */
1319static int idpf_up_complete(struct idpf_vport *vport)
1320{
1321	struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
1322
1323	if (vport->link_up && !netif_carrier_ok(vport->netdev)) {
1324		netif_carrier_on(vport->netdev);
1325		netif_tx_start_all_queues(vport->netdev);
1326	}
1327
1328	np->state = __IDPF_VPORT_UP;
1329
1330	return 0;
1331}
1332
1333/**
1334 * idpf_rx_init_buf_tail - Write initial buffer ring tail value
1335 * @vport: virtual port struct
1336 */
1337static void idpf_rx_init_buf_tail(struct idpf_vport *vport)
1338{
1339	int i, j;
1340
1341	for (i = 0; i < vport->num_rxq_grp; i++) {
1342		struct idpf_rxq_group *grp = &vport->rxq_grps[i];
1343
1344		if (idpf_is_queue_model_split(vport->rxq_model)) {
1345			for (j = 0; j < vport->num_bufqs_per_qgrp; j++) {
1346				struct idpf_queue *q =
1347					&grp->splitq.bufq_sets[j].bufq;
1348
1349				writel(q->next_to_alloc, q->tail);
1350			}
1351		} else {
1352			for (j = 0; j < grp->singleq.num_rxq; j++) {
1353				struct idpf_queue *q =
1354					grp->singleq.rxqs[j];
1355
1356				writel(q->next_to_alloc, q->tail);
1357			}
1358		}
1359	}
1360}
1361
1362/**
1363 * idpf_vport_open - Bring up a vport
1364 * @vport: vport to bring up
1365 * @alloc_res: allocate queue resources
1366 */
1367static int idpf_vport_open(struct idpf_vport *vport, bool alloc_res)
1368{
1369	struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
1370	struct idpf_adapter *adapter = vport->adapter;
1371	struct idpf_vport_config *vport_config;
1372	int err;
1373
1374	if (np->state != __IDPF_VPORT_DOWN)
1375		return -EBUSY;
1376
1377	/* we do not allow interface up just yet */
1378	netif_carrier_off(vport->netdev);
1379
1380	if (alloc_res) {
1381		err = idpf_vport_queues_alloc(vport);
1382		if (err)
1383			return err;
1384	}
1385
1386	err = idpf_vport_intr_alloc(vport);
1387	if (err) {
1388		dev_err(&adapter->pdev->dev, "Failed to allocate interrupts for vport %u: %d\n",
1389			vport->vport_id, err);
1390		goto queues_rel;
1391	}
1392
1393	err = idpf_vport_queue_ids_init(vport);
1394	if (err) {
1395		dev_err(&adapter->pdev->dev, "Failed to initialize queue ids for vport %u: %d\n",
1396			vport->vport_id, err);
1397		goto intr_rel;
1398	}
1399
1400	err = idpf_vport_intr_init(vport);
1401	if (err) {
1402		dev_err(&adapter->pdev->dev, "Failed to initialize interrupts for vport %u: %d\n",
1403			vport->vport_id, err);
1404		goto intr_rel;
1405	}
1406
1407	err = idpf_rx_bufs_init_all(vport);
1408	if (err) {
1409		dev_err(&adapter->pdev->dev, "Failed to initialize RX buffers for vport %u: %d\n",
1410			vport->vport_id, err);
1411		goto intr_rel;
1412	}
1413
1414	err = idpf_queue_reg_init(vport);
1415	if (err) {
1416		dev_err(&adapter->pdev->dev, "Failed to initialize queue registers for vport %u: %d\n",
1417			vport->vport_id, err);
1418		goto intr_rel;
1419	}
1420
1421	idpf_rx_init_buf_tail(vport);
 
1422
1423	err = idpf_send_config_queues_msg(vport);
1424	if (err) {
1425		dev_err(&adapter->pdev->dev, "Failed to configure queues for vport %u, %d\n",
1426			vport->vport_id, err);
1427		goto intr_deinit;
1428	}
1429
1430	err = idpf_send_map_unmap_queue_vector_msg(vport, true);
1431	if (err) {
1432		dev_err(&adapter->pdev->dev, "Failed to map queue vectors for vport %u: %d\n",
1433			vport->vport_id, err);
1434		goto intr_deinit;
1435	}
1436
1437	err = idpf_send_enable_queues_msg(vport);
1438	if (err) {
1439		dev_err(&adapter->pdev->dev, "Failed to enable queues for vport %u: %d\n",
1440			vport->vport_id, err);
1441		goto unmap_queue_vectors;
1442	}
1443
1444	err = idpf_send_enable_vport_msg(vport);
1445	if (err) {
1446		dev_err(&adapter->pdev->dev, "Failed to enable vport %u: %d\n",
1447			vport->vport_id, err);
1448		err = -EAGAIN;
1449		goto disable_queues;
1450	}
1451
1452	idpf_restore_features(vport);
1453
1454	vport_config = adapter->vport_config[vport->idx];
1455	if (vport_config->user_config.rss_data.rss_lut)
1456		err = idpf_config_rss(vport);
1457	else
1458		err = idpf_init_rss(vport);
1459	if (err) {
1460		dev_err(&adapter->pdev->dev, "Failed to initialize RSS for vport %u: %d\n",
1461			vport->vport_id, err);
1462		goto disable_vport;
1463	}
1464
1465	err = idpf_up_complete(vport);
1466	if (err) {
1467		dev_err(&adapter->pdev->dev, "Failed to complete interface up for vport %u: %d\n",
1468			vport->vport_id, err);
1469		goto deinit_rss;
1470	}
1471
1472	return 0;
1473
1474deinit_rss:
1475	idpf_deinit_rss(vport);
1476disable_vport:
1477	idpf_send_disable_vport_msg(vport);
1478disable_queues:
1479	idpf_send_disable_queues_msg(vport);
1480unmap_queue_vectors:
1481	idpf_send_map_unmap_queue_vector_msg(vport, false);
1482intr_deinit:
1483	idpf_vport_intr_deinit(vport);
1484intr_rel:
1485	idpf_vport_intr_rel(vport);
1486queues_rel:
1487	idpf_vport_queues_rel(vport);
1488
1489	return err;
1490}
1491
1492/**
1493 * idpf_init_task - Delayed initialization task
1494 * @work: work_struct handle to our data
1495 *
1496 * Init task finishes up pending work started in probe. Due to the asynchronous
1497 * nature in which the device communicates with hardware, we may have to wait
1498 * several milliseconds to get a response.  Instead of busy polling in probe,
1499 * pulling it out into a delayed work task prevents us from bogging down the
1500 * whole system waiting for a response from hardware.
1501 */
1502void idpf_init_task(struct work_struct *work)
1503{
1504	struct idpf_vport_config *vport_config;
1505	struct idpf_vport_max_q max_q;
1506	struct idpf_adapter *adapter;
1507	struct idpf_netdev_priv *np;
1508	struct idpf_vport *vport;
1509	u16 num_default_vports;
1510	struct pci_dev *pdev;
1511	bool default_vport;
1512	int index, err;
1513
1514	adapter = container_of(work, struct idpf_adapter, init_task.work);
1515
1516	num_default_vports = idpf_get_default_vports(adapter);
1517	if (adapter->num_alloc_vports < num_default_vports)
1518		default_vport = true;
1519	else
1520		default_vport = false;
1521
1522	err = idpf_vport_alloc_max_qs(adapter, &max_q);
1523	if (err)
1524		goto unwind_vports;
1525
1526	err = idpf_send_create_vport_msg(adapter, &max_q);
1527	if (err) {
1528		idpf_vport_dealloc_max_qs(adapter, &max_q);
1529		goto unwind_vports;
1530	}
1531
1532	pdev = adapter->pdev;
1533	vport = idpf_vport_alloc(adapter, &max_q);
1534	if (!vport) {
1535		err = -EFAULT;
1536		dev_err(&pdev->dev, "failed to allocate vport: %d\n",
1537			err);
1538		idpf_vport_dealloc_max_qs(adapter, &max_q);
1539		goto unwind_vports;
1540	}
1541
1542	index = vport->idx;
1543	vport_config = adapter->vport_config[index];
1544
1545	init_waitqueue_head(&vport->sw_marker_wq);
1546	init_waitqueue_head(&vport->vchnl_wq);
1547
1548	mutex_init(&vport->vc_buf_lock);
1549	spin_lock_init(&vport_config->mac_filter_list_lock);
1550
1551	INIT_LIST_HEAD(&vport_config->user_config.mac_filter_list);
1552
1553	err = idpf_check_supported_desc_ids(vport);
1554	if (err) {
1555		dev_err(&pdev->dev, "failed to get required descriptor ids\n");
1556		goto cfg_netdev_err;
1557	}
1558
1559	if (idpf_cfg_netdev(vport))
1560		goto cfg_netdev_err;
1561
1562	err = idpf_send_get_rx_ptype_msg(vport);
1563	if (err)
1564		goto handle_err;
1565
1566	/* Once state is put into DOWN, driver is ready for dev_open */
1567	np = netdev_priv(vport->netdev);
1568	np->state = __IDPF_VPORT_DOWN;
1569	if (test_and_clear_bit(IDPF_VPORT_UP_REQUESTED, vport_config->flags))
1570		idpf_vport_open(vport, true);
1571
1572	/* Spawn and return 'idpf_init_task' work queue until all the
1573	 * default vports are created
1574	 */
1575	if (adapter->num_alloc_vports < num_default_vports) {
1576		queue_delayed_work(adapter->init_wq, &adapter->init_task,
1577				   msecs_to_jiffies(5 * (adapter->pdev->devfn & 0x07)));
1578
1579		return;
1580	}
1581
1582	for (index = 0; index < adapter->max_vports; index++) {
1583		if (adapter->netdevs[index] &&
1584		    !test_bit(IDPF_VPORT_REG_NETDEV,
1585			      adapter->vport_config[index]->flags)) {
1586			register_netdev(adapter->netdevs[index]);
1587			set_bit(IDPF_VPORT_REG_NETDEV,
1588				adapter->vport_config[index]->flags);
1589		}
1590	}
1591
1592	/* As all the required vports are created, clear the reset flag
1593	 * unconditionally here in case we were in reset and the link was down.
1594	 */
1595	clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);
1596	/* Start the statistics task now */
1597	queue_delayed_work(adapter->stats_wq, &adapter->stats_task,
1598			   msecs_to_jiffies(10 * (pdev->devfn & 0x07)));
1599
1600	return;
1601
1602handle_err:
1603	idpf_decfg_netdev(vport);
1604cfg_netdev_err:
1605	idpf_vport_rel(vport);
1606	adapter->vports[index] = NULL;
1607unwind_vports:
1608	if (default_vport) {
1609		for (index = 0; index < adapter->max_vports; index++) {
1610			if (adapter->vports[index])
1611				idpf_vport_dealloc(adapter->vports[index]);
1612		}
1613	}
1614	clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);
1615}
1616
1617/**
1618 * idpf_sriov_ena - Enable or change number of VFs
1619 * @adapter: private data struct
1620 * @num_vfs: number of VFs to allocate
1621 */
1622static int idpf_sriov_ena(struct idpf_adapter *adapter, int num_vfs)
1623{
1624	struct device *dev = &adapter->pdev->dev;
1625	int err;
1626
1627	err = idpf_send_set_sriov_vfs_msg(adapter, num_vfs);
1628	if (err) {
1629		dev_err(dev, "Failed to allocate VFs: %d\n", err);
1630
1631		return err;
1632	}
1633
1634	err = pci_enable_sriov(adapter->pdev, num_vfs);
1635	if (err) {
1636		idpf_send_set_sriov_vfs_msg(adapter, 0);
1637		dev_err(dev, "Failed to enable SR-IOV: %d\n", err);
1638
1639		return err;
1640	}
1641
1642	adapter->num_vfs = num_vfs;
1643
1644	return num_vfs;
1645}
1646
1647/**
1648 * idpf_sriov_configure - Configure the requested VFs
1649 * @pdev: pointer to a pci_dev structure
1650 * @num_vfs: number of vfs to allocate
1651 *
1652 * Enable or change the number of VFs. Called when the user updates the number
1653 * of VFs in sysfs.
1654 **/
1655int idpf_sriov_configure(struct pci_dev *pdev, int num_vfs)
1656{
1657	struct idpf_adapter *adapter = pci_get_drvdata(pdev);
1658
1659	if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_SRIOV)) {
1660		dev_info(&pdev->dev, "SR-IOV is not supported on this device\n");
1661
1662		return -EOPNOTSUPP;
1663	}
1664
1665	if (num_vfs)
1666		return idpf_sriov_ena(adapter, num_vfs);
1667
1668	if (pci_vfs_assigned(pdev)) {
1669		dev_warn(&pdev->dev, "Unable to free VFs because some are assigned to VMs\n");
1670
1671		return -EBUSY;
1672	}
1673
1674	pci_disable_sriov(adapter->pdev);
1675	idpf_send_set_sriov_vfs_msg(adapter, 0);
1676	adapter->num_vfs = 0;
1677
1678	return 0;
1679}
1680
1681/**
1682 * idpf_deinit_task - Device deinit routine
1683 * @adapter: Driver specific private structure
1684 *
1685 * Extended remove logic which will be used for
1686 * hard reset as well
1687 */
1688void idpf_deinit_task(struct idpf_adapter *adapter)
1689{
1690	unsigned int i;
1691
1692	/* Wait until the init_task is done else this thread might release
1693	 * the resources first and the other thread might end up in a bad state
1694	 */
1695	cancel_delayed_work_sync(&adapter->init_task);
1696
1697	if (!adapter->vports)
1698		return;
1699
1700	cancel_delayed_work_sync(&adapter->stats_task);
1701
1702	for (i = 0; i < adapter->max_vports; i++) {
1703		if (adapter->vports[i])
1704			idpf_vport_dealloc(adapter->vports[i]);
1705	}
1706}
1707
1708/**
1709 * idpf_check_reset_complete - check that reset is complete
1710 * @hw: pointer to hw struct
1711 * @reset_reg: struct with reset registers
1712 *
1713 * Returns 0 if device is ready to use, or -EBUSY if it's in reset.
1714 **/
1715static int idpf_check_reset_complete(struct idpf_hw *hw,
1716				     struct idpf_reset_reg *reset_reg)
1717{
1718	struct idpf_adapter *adapter = hw->back;
1719	int i;
1720
1721	for (i = 0; i < 2000; i++) {
1722		u32 reg_val = readl(reset_reg->rstat);
1723
1724		/* 0xFFFFFFFF might be read if other side hasn't cleared the
1725		 * register for us yet and 0xFFFFFFFF is not a valid value for
1726		 * the register, so treat that as invalid.
1727		 */
1728		if (reg_val != 0xFFFFFFFF && (reg_val & reset_reg->rstat_m))
1729			return 0;
1730
1731		usleep_range(5000, 10000);
1732	}
1733
1734	dev_warn(&adapter->pdev->dev, "Device reset timeout!\n");
1735	/* Clear the reset flag unconditionally here since the reset
1736	 * technically isn't in progress anymore from the driver's perspective
1737	 */
1738	clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);
1739
1740	return -EBUSY;
1741}
1742
1743/**
1744 * idpf_set_vport_state - Set the vport state to be after the reset
1745 * @adapter: Driver specific private structure
1746 */
1747static void idpf_set_vport_state(struct idpf_adapter *adapter)
1748{
1749	u16 i;
1750
1751	for (i = 0; i < adapter->max_vports; i++) {
1752		struct idpf_netdev_priv *np;
1753
1754		if (!adapter->netdevs[i])
1755			continue;
1756
1757		np = netdev_priv(adapter->netdevs[i]);
1758		if (np->state == __IDPF_VPORT_UP)
1759			set_bit(IDPF_VPORT_UP_REQUESTED,
1760				adapter->vport_config[i]->flags);
1761	}
1762}
1763
1764/**
1765 * idpf_init_hard_reset - Initiate a hardware reset
1766 * @adapter: Driver specific private structure
1767 *
1768 * Deallocate the vports and all the resources associated with them and
1769 * reallocate. Also reinitialize the mailbox. Return 0 on success,
1770 * negative on failure.
1771 */
1772static int idpf_init_hard_reset(struct idpf_adapter *adapter)
1773{
1774	struct idpf_reg_ops *reg_ops = &adapter->dev_ops.reg_ops;
1775	struct device *dev = &adapter->pdev->dev;
1776	struct net_device *netdev;
1777	int err;
1778	u16 i;
1779
1780	mutex_lock(&adapter->vport_ctrl_lock);
1781
1782	dev_info(dev, "Device HW Reset initiated\n");
1783
1784	/* Avoid TX hangs on reset */
1785	for (i = 0; i < adapter->max_vports; i++) {
1786		netdev = adapter->netdevs[i];
1787		if (!netdev)
1788			continue;
1789
1790		netif_carrier_off(netdev);
1791		netif_tx_disable(netdev);
1792	}
1793
1794	/* Prepare for reset */
1795	if (test_and_clear_bit(IDPF_HR_DRV_LOAD, adapter->flags)) {
1796		reg_ops->trigger_reset(adapter, IDPF_HR_DRV_LOAD);
1797	} else if (test_and_clear_bit(IDPF_HR_FUNC_RESET, adapter->flags)) {
1798		bool is_reset = idpf_is_reset_detected(adapter);
1799
1800		idpf_set_vport_state(adapter);
1801		idpf_vc_core_deinit(adapter);
1802		if (!is_reset)
1803			reg_ops->trigger_reset(adapter, IDPF_HR_FUNC_RESET);
1804		idpf_deinit_dflt_mbx(adapter);
1805	} else {
1806		dev_err(dev, "Unhandled hard reset cause\n");
1807		err = -EBADRQC;
1808		goto unlock_mutex;
1809	}
1810
1811	/* Wait for reset to complete */
1812	err = idpf_check_reset_complete(&adapter->hw, &adapter->reset_reg);
1813	if (err) {
1814		dev_err(dev, "The driver was unable to contact the device's firmware. Check that the FW is running. Driver state= 0x%x\n",
1815			adapter->state);
1816		goto unlock_mutex;
1817	}
1818
1819	/* Reset is complete and so start building the driver resources again */
1820	err = idpf_init_dflt_mbx(adapter);
1821	if (err) {
1822		dev_err(dev, "Failed to initialize default mailbox: %d\n", err);
1823		goto unlock_mutex;
1824	}
1825
 
 
1826	/* Initialize the state machine, also allocate memory and request
1827	 * resources
1828	 */
1829	err = idpf_vc_core_init(adapter);
1830	if (err) {
1831		idpf_deinit_dflt_mbx(adapter);
1832		goto unlock_mutex;
1833	}
1834
1835	/* Wait till all the vports are initialized to release the reset lock,
1836	 * else user space callbacks may access uninitialized vports
1837	 */
1838	while (test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags))
1839		msleep(100);
1840
1841unlock_mutex:
1842	mutex_unlock(&adapter->vport_ctrl_lock);
1843
1844	return err;
1845}
1846
1847/**
1848 * idpf_vc_event_task - Handle virtchannel event logic
1849 * @work: work queue struct
1850 */
1851void idpf_vc_event_task(struct work_struct *work)
1852{
1853	struct idpf_adapter *adapter;
1854
1855	adapter = container_of(work, struct idpf_adapter, vc_event_task.work);
1856
1857	if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags))
1858		return;
1859
1860	if (test_bit(IDPF_HR_FUNC_RESET, adapter->flags) ||
1861	    test_bit(IDPF_HR_DRV_LOAD, adapter->flags)) {
1862		set_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);
1863		idpf_init_hard_reset(adapter);
1864	}
1865}
1866
1867/**
1868 * idpf_initiate_soft_reset - Initiate a software reset
1869 * @vport: virtual port data struct
1870 * @reset_cause: reason for the soft reset
1871 *
1872 * Soft reset only reallocs vport queue resources. Returns 0 on success,
1873 * negative on failure.
1874 */
1875int idpf_initiate_soft_reset(struct idpf_vport *vport,
1876			     enum idpf_vport_reset_cause reset_cause)
1877{
1878	struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
1879	enum idpf_vport_state current_state = np->state;
1880	struct idpf_adapter *adapter = vport->adapter;
1881	struct idpf_vport *new_vport;
1882	int err, i;
1883
1884	/* If the system is low on memory, we can end up in bad state if we
1885	 * free all the memory for queue resources and try to allocate them
1886	 * again. Instead, we can pre-allocate the new resources before doing
1887	 * anything and bailing if the alloc fails.
1888	 *
1889	 * Make a clone of the existing vport to mimic its current
1890	 * configuration, then modify the new structure with any requested
1891	 * changes. Once the allocation of the new resources is done, stop the
1892	 * existing vport and copy the configuration to the main vport. If an
1893	 * error occurred, the existing vport will be untouched.
1894	 *
1895	 */
1896	new_vport = kzalloc(sizeof(*vport), GFP_KERNEL);
1897	if (!new_vport)
1898		return -ENOMEM;
1899
1900	/* This purposely avoids copying the end of the struct because it
1901	 * contains wait_queues and mutexes and other stuff we don't want to
1902	 * mess with. Nothing below should use those variables from new_vport
1903	 * and should instead always refer to them in vport if they need to.
1904	 */
1905	memcpy(new_vport, vport, offsetof(struct idpf_vport, vc_state));
1906
1907	/* Adjust resource parameters prior to reallocating resources */
1908	switch (reset_cause) {
1909	case IDPF_SR_Q_CHANGE:
1910		err = idpf_vport_adjust_qs(new_vport);
1911		if (err)
1912			goto free_vport;
1913		break;
1914	case IDPF_SR_Q_DESC_CHANGE:
1915		/* Update queue parameters before allocating resources */
1916		idpf_vport_calc_num_q_desc(new_vport);
1917		break;
1918	case IDPF_SR_MTU_CHANGE:
1919	case IDPF_SR_RSC_CHANGE:
1920		break;
1921	default:
1922		dev_err(&adapter->pdev->dev, "Unhandled soft reset cause\n");
1923		err = -EINVAL;
1924		goto free_vport;
1925	}
1926
1927	err = idpf_vport_queues_alloc(new_vport);
1928	if (err)
1929		goto free_vport;
1930	if (current_state <= __IDPF_VPORT_DOWN) {
1931		idpf_send_delete_queues_msg(vport);
1932	} else {
1933		set_bit(IDPF_VPORT_DEL_QUEUES, vport->flags);
1934		idpf_vport_stop(vport);
1935	}
1936
1937	idpf_deinit_rss(vport);
1938	/* We're passing in vport here because we need its wait_queue
1939	 * to send a message and it should be getting all the vport
1940	 * config data out of the adapter but we need to be careful not
1941	 * to add code to add_queues to change the vport config within
1942	 * vport itself as it will be wiped with a memcpy later.
1943	 */
1944	err = idpf_send_add_queues_msg(vport, new_vport->num_txq,
1945				       new_vport->num_complq,
1946				       new_vport->num_rxq,
1947				       new_vport->num_bufq);
1948	if (err)
1949		goto err_reset;
1950
1951	/* Same comment as above regarding avoiding copying the wait_queues and
1952	 * mutexes applies here. We do not want to mess with those if possible.
1953	 */
1954	memcpy(vport, new_vport, offsetof(struct idpf_vport, vc_state));
1955
1956	/* Since idpf_vport_queues_alloc was called with new_port, the queue
1957	 * back pointers are currently pointing to the local new_vport. Reset
1958	 * the backpointers to the original vport here
1959	 */
1960	for (i = 0; i < vport->num_txq_grp; i++) {
1961		struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
1962		int j;
1963
1964		tx_qgrp->vport = vport;
1965		for (j = 0; j < tx_qgrp->num_txq; j++)
1966			tx_qgrp->txqs[j]->vport = vport;
1967
1968		if (idpf_is_queue_model_split(vport->txq_model))
1969			tx_qgrp->complq->vport = vport;
1970	}
1971
1972	for (i = 0; i < vport->num_rxq_grp; i++) {
1973		struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1974		struct idpf_queue *q;
1975		u16 num_rxq;
1976		int j;
1977
1978		rx_qgrp->vport = vport;
1979		for (j = 0; j < vport->num_bufqs_per_qgrp; j++)
1980			rx_qgrp->splitq.bufq_sets[j].bufq.vport = vport;
1981
1982		if (idpf_is_queue_model_split(vport->rxq_model))
1983			num_rxq = rx_qgrp->splitq.num_rxq_sets;
1984		else
1985			num_rxq = rx_qgrp->singleq.num_rxq;
1986
1987		for (j = 0; j < num_rxq; j++) {
1988			if (idpf_is_queue_model_split(vport->rxq_model))
1989				q = &rx_qgrp->splitq.rxq_sets[j]->rxq;
1990			else
1991				q = rx_qgrp->singleq.rxqs[j];
1992			q->vport = vport;
1993		}
1994	}
1995
1996	if (reset_cause == IDPF_SR_Q_CHANGE)
1997		idpf_vport_alloc_vec_indexes(vport);
1998
1999	err = idpf_set_real_num_queues(vport);
2000	if (err)
2001		goto err_reset;
2002
2003	if (current_state == __IDPF_VPORT_UP)
2004		err = idpf_vport_open(vport, false);
2005
2006	kfree(new_vport);
2007
2008	return err;
2009
2010err_reset:
2011	idpf_vport_queues_rel(new_vport);
2012free_vport:
2013	kfree(new_vport);
2014
2015	return err;
2016}
2017
2018/**
2019 * idpf_addr_sync - Callback for dev_(mc|uc)_sync to add address
2020 * @netdev: the netdevice
2021 * @addr: address to add
2022 *
2023 * Called by __dev_(mc|uc)_sync when an address needs to be added. We call
2024 * __dev_(uc|mc)_sync from .set_rx_mode. Kernel takes addr_list_lock spinlock
2025 * meaning we cannot sleep in this context. Due to this, we have to add the
2026 * filter and send the virtchnl message asynchronously without waiting for the
2027 * response from the other side. We won't know whether or not the operation
2028 * actually succeeded until we get the message back.  Returns 0 on success,
2029 * negative on failure.
2030 */
2031static int idpf_addr_sync(struct net_device *netdev, const u8 *addr)
2032{
2033	struct idpf_netdev_priv *np = netdev_priv(netdev);
2034
2035	return idpf_add_mac_filter(np->vport, np, addr, true);
2036}
2037
2038/**
2039 * idpf_addr_unsync - Callback for dev_(mc|uc)_sync to remove address
2040 * @netdev: the netdevice
2041 * @addr: address to add
2042 *
2043 * Called by __dev_(mc|uc)_sync when an address needs to be added. We call
2044 * __dev_(uc|mc)_sync from .set_rx_mode. Kernel takes addr_list_lock spinlock
2045 * meaning we cannot sleep in this context. Due to this we have to delete the
2046 * filter and send the virtchnl message asynchronously without waiting for the
2047 * return from the other side.  We won't know whether or not the operation
2048 * actually succeeded until we get the message back. Returns 0 on success,
2049 * negative on failure.
2050 */
2051static int idpf_addr_unsync(struct net_device *netdev, const u8 *addr)
2052{
2053	struct idpf_netdev_priv *np = netdev_priv(netdev);
2054
2055	/* Under some circumstances, we might receive a request to delete
2056	 * our own device address from our uc list. Because we store the
2057	 * device address in the VSI's MAC filter list, we need to ignore
2058	 * such requests and not delete our device address from this list.
2059	 */
2060	if (ether_addr_equal(addr, netdev->dev_addr))
2061		return 0;
2062
2063	idpf_del_mac_filter(np->vport, np, addr, true);
2064
2065	return 0;
2066}
2067
2068/**
2069 * idpf_set_rx_mode - NDO callback to set the netdev filters
2070 * @netdev: network interface device structure
2071 *
2072 * Stack takes addr_list_lock spinlock before calling our .set_rx_mode.  We
2073 * cannot sleep in this context.
2074 */
2075static void idpf_set_rx_mode(struct net_device *netdev)
2076{
2077	struct idpf_netdev_priv *np = netdev_priv(netdev);
2078	struct idpf_vport_user_config_data *config_data;
2079	struct idpf_adapter *adapter;
2080	bool changed = false;
2081	struct device *dev;
2082	int err;
2083
2084	adapter = np->adapter;
2085	dev = &adapter->pdev->dev;
2086
2087	if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER)) {
2088		__dev_uc_sync(netdev, idpf_addr_sync, idpf_addr_unsync);
2089		__dev_mc_sync(netdev, idpf_addr_sync, idpf_addr_unsync);
2090	}
2091
2092	if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_PROMISC))
2093		return;
2094
2095	config_data = &adapter->vport_config[np->vport_idx]->user_config;
2096	/* IFF_PROMISC enables both unicast and multicast promiscuous,
2097	 * while IFF_ALLMULTI only enables multicast such that:
2098	 *
2099	 * promisc  + allmulti		= unicast | multicast
2100	 * promisc  + !allmulti		= unicast | multicast
2101	 * !promisc + allmulti		= multicast
2102	 */
2103	if ((netdev->flags & IFF_PROMISC) &&
2104	    !test_and_set_bit(__IDPF_PROMISC_UC, config_data->user_flags)) {
2105		changed = true;
2106		dev_info(&adapter->pdev->dev, "Entering promiscuous mode\n");
2107		if (!test_and_set_bit(__IDPF_PROMISC_MC, adapter->flags))
2108			dev_info(dev, "Entering multicast promiscuous mode\n");
2109	}
2110
2111	if (!(netdev->flags & IFF_PROMISC) &&
2112	    test_and_clear_bit(__IDPF_PROMISC_UC, config_data->user_flags)) {
2113		changed = true;
2114		dev_info(dev, "Leaving promiscuous mode\n");
2115	}
2116
2117	if (netdev->flags & IFF_ALLMULTI &&
2118	    !test_and_set_bit(__IDPF_PROMISC_MC, config_data->user_flags)) {
2119		changed = true;
2120		dev_info(dev, "Entering multicast promiscuous mode\n");
2121	}
2122
2123	if (!(netdev->flags & (IFF_ALLMULTI | IFF_PROMISC)) &&
2124	    test_and_clear_bit(__IDPF_PROMISC_MC, config_data->user_flags)) {
2125		changed = true;
2126		dev_info(dev, "Leaving multicast promiscuous mode\n");
2127	}
2128
2129	if (!changed)
2130		return;
2131
2132	err = idpf_set_promiscuous(adapter, config_data, np->vport_id);
2133	if (err)
2134		dev_err(dev, "Failed to set promiscuous mode: %d\n", err);
2135}
2136
2137/**
2138 * idpf_vport_manage_rss_lut - disable/enable RSS
2139 * @vport: the vport being changed
2140 *
2141 * In the event of disable request for RSS, this function will zero out RSS
2142 * LUT, while in the event of enable request for RSS, it will reconfigure RSS
2143 * LUT with the default LUT configuration.
2144 */
2145static int idpf_vport_manage_rss_lut(struct idpf_vport *vport)
2146{
2147	bool ena = idpf_is_feature_ena(vport, NETIF_F_RXHASH);
2148	struct idpf_rss_data *rss_data;
2149	u16 idx = vport->idx;
2150	int lut_size;
2151
2152	rss_data = &vport->adapter->vport_config[idx]->user_config.rss_data;
2153	lut_size = rss_data->rss_lut_size * sizeof(u32);
2154
2155	if (ena) {
2156		/* This will contain the default or user configured LUT */
2157		memcpy(rss_data->rss_lut, rss_data->cached_lut, lut_size);
2158	} else {
2159		/* Save a copy of the current LUT to be restored later if
2160		 * requested.
2161		 */
2162		memcpy(rss_data->cached_lut, rss_data->rss_lut, lut_size);
2163
2164		/* Zero out the current LUT to disable */
2165		memset(rss_data->rss_lut, 0, lut_size);
2166	}
2167
2168	return idpf_config_rss(vport);
2169}
2170
2171/**
2172 * idpf_set_features - set the netdev feature flags
2173 * @netdev: ptr to the netdev being adjusted
2174 * @features: the feature set that the stack is suggesting
2175 */
2176static int idpf_set_features(struct net_device *netdev,
2177			     netdev_features_t features)
2178{
2179	netdev_features_t changed = netdev->features ^ features;
2180	struct idpf_adapter *adapter;
2181	struct idpf_vport *vport;
2182	int err = 0;
2183
2184	idpf_vport_ctrl_lock(netdev);
2185	vport = idpf_netdev_to_vport(netdev);
2186
2187	adapter = vport->adapter;
2188
2189	if (idpf_is_reset_in_prog(adapter)) {
2190		dev_err(&adapter->pdev->dev, "Device is resetting, changing netdev features temporarily unavailable.\n");
2191		err = -EBUSY;
2192		goto unlock_mutex;
2193	}
2194
2195	if (changed & NETIF_F_RXHASH) {
2196		netdev->features ^= NETIF_F_RXHASH;
2197		err = idpf_vport_manage_rss_lut(vport);
2198		if (err)
2199			goto unlock_mutex;
2200	}
2201
2202	if (changed & NETIF_F_GRO_HW) {
2203		netdev->features ^= NETIF_F_GRO_HW;
2204		err = idpf_initiate_soft_reset(vport, IDPF_SR_RSC_CHANGE);
2205		if (err)
2206			goto unlock_mutex;
2207	}
2208
2209	if (changed & NETIF_F_LOOPBACK) {
2210		netdev->features ^= NETIF_F_LOOPBACK;
2211		err = idpf_send_ena_dis_loopback_msg(vport);
2212	}
2213
2214unlock_mutex:
2215	idpf_vport_ctrl_unlock(netdev);
2216
2217	return err;
2218}
2219
2220/**
2221 * idpf_open - Called when a network interface becomes active
2222 * @netdev: network interface device structure
2223 *
2224 * The open entry point is called when a network interface is made
2225 * active by the system (IFF_UP).  At this point all resources needed
2226 * for transmit and receive operations are allocated, the interrupt
2227 * handler is registered with the OS, the netdev watchdog is enabled,
2228 * and the stack is notified that the interface is ready.
2229 *
2230 * Returns 0 on success, negative value on failure
2231 */
2232static int idpf_open(struct net_device *netdev)
2233{
2234	struct idpf_vport *vport;
2235	int err;
2236
2237	idpf_vport_ctrl_lock(netdev);
2238	vport = idpf_netdev_to_vport(netdev);
2239
2240	err = idpf_vport_open(vport, true);
2241
2242	idpf_vport_ctrl_unlock(netdev);
2243
2244	return err;
2245}
2246
2247/**
2248 * idpf_change_mtu - NDO callback to change the MTU
2249 * @netdev: network interface device structure
2250 * @new_mtu: new value for maximum frame size
2251 *
2252 * Returns 0 on success, negative on failure
2253 */
2254static int idpf_change_mtu(struct net_device *netdev, int new_mtu)
2255{
2256	struct idpf_vport *vport;
2257	int err;
2258
2259	idpf_vport_ctrl_lock(netdev);
2260	vport = idpf_netdev_to_vport(netdev);
2261
2262	netdev->mtu = new_mtu;
2263
2264	err = idpf_initiate_soft_reset(vport, IDPF_SR_MTU_CHANGE);
2265
2266	idpf_vport_ctrl_unlock(netdev);
2267
2268	return err;
2269}
2270
2271/**
2272 * idpf_features_check - Validate packet conforms to limits
2273 * @skb: skb buffer
2274 * @netdev: This port's netdev
2275 * @features: Offload features that the stack believes apply
2276 */
2277static netdev_features_t idpf_features_check(struct sk_buff *skb,
2278					     struct net_device *netdev,
2279					     netdev_features_t features)
2280{
2281	struct idpf_vport *vport = idpf_netdev_to_vport(netdev);
2282	struct idpf_adapter *adapter = vport->adapter;
2283	size_t len;
2284
2285	/* No point in doing any of this if neither checksum nor GSO are
2286	 * being requested for this frame.  We can rule out both by just
2287	 * checking for CHECKSUM_PARTIAL
2288	 */
2289	if (skb->ip_summed != CHECKSUM_PARTIAL)
2290		return features;
2291
2292	/* We cannot support GSO if the MSS is going to be less than
2293	 * 88 bytes. If it is then we need to drop support for GSO.
2294	 */
2295	if (skb_is_gso(skb) &&
2296	    (skb_shinfo(skb)->gso_size < IDPF_TX_TSO_MIN_MSS))
2297		features &= ~NETIF_F_GSO_MASK;
2298
2299	/* Ensure MACLEN is <= 126 bytes (63 words) and not an odd size */
2300	len = skb_network_offset(skb);
2301	if (unlikely(len & ~(126)))
2302		goto unsupported;
2303
2304	len = skb_network_header_len(skb);
2305	if (unlikely(len > idpf_get_max_tx_hdr_size(adapter)))
2306		goto unsupported;
2307
2308	if (!skb->encapsulation)
2309		return features;
2310
2311	/* L4TUNLEN can support 127 words */
2312	len = skb_inner_network_header(skb) - skb_transport_header(skb);
2313	if (unlikely(len & ~(127 * 2)))
2314		goto unsupported;
2315
2316	/* IPLEN can support at most 127 dwords */
2317	len = skb_inner_network_header_len(skb);
2318	if (unlikely(len > idpf_get_max_tx_hdr_size(adapter)))
2319		goto unsupported;
2320
2321	/* No need to validate L4LEN as TCP is the only protocol with a
2322	 * a flexible value and we support all possible values supported
2323	 * by TCP, which is at most 15 dwords
2324	 */
2325
2326	return features;
2327
2328unsupported:
2329	return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
2330}
2331
2332/**
2333 * idpf_set_mac - NDO callback to set port mac address
2334 * @netdev: network interface device structure
2335 * @p: pointer to an address structure
2336 *
2337 * Returns 0 on success, negative on failure
2338 **/
2339static int idpf_set_mac(struct net_device *netdev, void *p)
2340{
2341	struct idpf_netdev_priv *np = netdev_priv(netdev);
2342	struct idpf_vport_config *vport_config;
2343	struct sockaddr *addr = p;
2344	struct idpf_vport *vport;
2345	int err = 0;
2346
2347	idpf_vport_ctrl_lock(netdev);
2348	vport = idpf_netdev_to_vport(netdev);
2349
2350	if (!idpf_is_cap_ena(vport->adapter, IDPF_OTHER_CAPS,
2351			     VIRTCHNL2_CAP_MACFILTER)) {
2352		dev_info(&vport->adapter->pdev->dev, "Setting MAC address is not supported\n");
2353		err = -EOPNOTSUPP;
2354		goto unlock_mutex;
2355	}
2356
2357	if (!is_valid_ether_addr(addr->sa_data)) {
2358		dev_info(&vport->adapter->pdev->dev, "Invalid MAC address: %pM\n",
2359			 addr->sa_data);
2360		err = -EADDRNOTAVAIL;
2361		goto unlock_mutex;
2362	}
2363
2364	if (ether_addr_equal(netdev->dev_addr, addr->sa_data))
2365		goto unlock_mutex;
2366
2367	vport_config = vport->adapter->vport_config[vport->idx];
2368	err = idpf_add_mac_filter(vport, np, addr->sa_data, false);
2369	if (err) {
2370		__idpf_del_mac_filter(vport_config, addr->sa_data);
2371		goto unlock_mutex;
2372	}
2373
2374	if (is_valid_ether_addr(vport->default_mac_addr))
2375		idpf_del_mac_filter(vport, np, vport->default_mac_addr, false);
2376
2377	ether_addr_copy(vport->default_mac_addr, addr->sa_data);
2378	eth_hw_addr_set(netdev, addr->sa_data);
2379
2380unlock_mutex:
2381	idpf_vport_ctrl_unlock(netdev);
2382
2383	return err;
2384}
2385
2386/**
2387 * idpf_alloc_dma_mem - Allocate dma memory
2388 * @hw: pointer to hw struct
2389 * @mem: pointer to dma_mem struct
2390 * @size: size of the memory to allocate
2391 */
2392void *idpf_alloc_dma_mem(struct idpf_hw *hw, struct idpf_dma_mem *mem, u64 size)
2393{
2394	struct idpf_adapter *adapter = hw->back;
2395	size_t sz = ALIGN(size, 4096);
2396
2397	mem->va = dma_alloc_coherent(&adapter->pdev->dev, sz,
2398				     &mem->pa, GFP_KERNEL);
2399	mem->size = sz;
2400
2401	return mem->va;
2402}
2403
2404/**
2405 * idpf_free_dma_mem - Free the allocated dma memory
2406 * @hw: pointer to hw struct
2407 * @mem: pointer to dma_mem struct
2408 */
2409void idpf_free_dma_mem(struct idpf_hw *hw, struct idpf_dma_mem *mem)
2410{
2411	struct idpf_adapter *adapter = hw->back;
2412
2413	dma_free_coherent(&adapter->pdev->dev, mem->size,
2414			  mem->va, mem->pa);
2415	mem->size = 0;
2416	mem->va = NULL;
2417	mem->pa = 0;
2418}
2419
2420static const struct net_device_ops idpf_netdev_ops_splitq = {
2421	.ndo_open = idpf_open,
2422	.ndo_stop = idpf_stop,
2423	.ndo_start_xmit = idpf_tx_splitq_start,
2424	.ndo_features_check = idpf_features_check,
2425	.ndo_set_rx_mode = idpf_set_rx_mode,
2426	.ndo_validate_addr = eth_validate_addr,
2427	.ndo_set_mac_address = idpf_set_mac,
2428	.ndo_change_mtu = idpf_change_mtu,
2429	.ndo_get_stats64 = idpf_get_stats64,
2430	.ndo_set_features = idpf_set_features,
2431	.ndo_tx_timeout = idpf_tx_timeout,
2432};
2433
2434static const struct net_device_ops idpf_netdev_ops_singleq = {
2435	.ndo_open = idpf_open,
2436	.ndo_stop = idpf_stop,
2437	.ndo_start_xmit = idpf_tx_singleq_start,
2438	.ndo_features_check = idpf_features_check,
2439	.ndo_set_rx_mode = idpf_set_rx_mode,
2440	.ndo_validate_addr = eth_validate_addr,
2441	.ndo_set_mac_address = idpf_set_mac,
2442	.ndo_change_mtu = idpf_change_mtu,
2443	.ndo_get_stats64 = idpf_get_stats64,
2444	.ndo_set_features = idpf_set_features,
2445	.ndo_tx_timeout = idpf_tx_timeout,
2446};