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