1 /* Broadcom NetXtreme-C/E network driver. 2 * 3 * Copyright (c) 2016-2018 Broadcom Limited 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation. 8 */ 9 10 #include <linux/module.h> 11 12 #include <linux/kernel.h> 13 #include <linux/errno.h> 14 #include <linux/interrupt.h> 15 #include <linux/pci.h> 16 #include <linux/netdevice.h> 17 #include <linux/rtnetlink.h> 18 #include <linux/bitops.h> 19 #include <linux/irq.h> 20 #include <asm/byteorder.h> 21 #include <linux/bitmap.h> 22 #include <linux/auxiliary_bus.h> 23 24 #include "bnxt_hsi.h" 25 #include "bnxt.h" 26 #include "bnxt_hwrm.h" 27 #include "bnxt_ulp.h" 28 29 static DEFINE_IDA(bnxt_aux_dev_ids); 30 31 static void bnxt_fill_msix_vecs(struct bnxt *bp, struct bnxt_msix_entry *ent) 32 { 33 struct bnxt_en_dev *edev = bp->edev; 34 int num_msix, i; 35 36 if (!edev->ulp_tbl->msix_requested) { 37 netdev_warn(bp->dev, "Requested MSI-X vectors insufficient\n"); 38 return; 39 } 40 num_msix = edev->ulp_tbl->msix_requested; 41 for (i = 0; i < num_msix; i++) { 42 ent[i].vector = bp->irq_tbl[i].vector; 43 ent[i].ring_idx = i; 44 if (bp->flags & BNXT_FLAG_CHIP_P5_PLUS) 45 ent[i].db_offset = bp->db_offset; 46 else 47 ent[i].db_offset = i * 0x80; 48 } 49 } 50 51 int bnxt_get_ulp_msix_num(struct bnxt *bp) 52 { 53 if (bp->edev) 54 return bp->edev->ulp_num_msix_vec; 55 return 0; 56 } 57 58 void bnxt_set_ulp_msix_num(struct bnxt *bp, int num) 59 { 60 if (bp->edev) 61 bp->edev->ulp_num_msix_vec = num; 62 } 63 64 int bnxt_get_ulp_msix_num_in_use(struct bnxt *bp) 65 { 66 if (bnxt_ulp_registered(bp->edev)) 67 return bp->edev->ulp_num_msix_vec; 68 return 0; 69 } 70 71 int bnxt_get_ulp_stat_ctxs(struct bnxt *bp) 72 { 73 if (bp->edev) 74 return bp->edev->ulp_num_ctxs; 75 return 0; 76 } 77 78 void bnxt_set_ulp_stat_ctxs(struct bnxt *bp, int num_ulp_ctx) 79 { 80 if (bp->edev) 81 bp->edev->ulp_num_ctxs = num_ulp_ctx; 82 } 83 84 int bnxt_get_ulp_stat_ctxs_in_use(struct bnxt *bp) 85 { 86 if (bnxt_ulp_registered(bp->edev)) 87 return bp->edev->ulp_num_ctxs; 88 return 0; 89 } 90 91 void bnxt_set_dflt_ulp_stat_ctxs(struct bnxt *bp) 92 { 93 if (bp->edev) { 94 bp->edev->ulp_num_ctxs = BNXT_MIN_ROCE_STAT_CTXS; 95 /* Reserve one additional stat_ctx for PF0 (except 96 * on 1-port NICs) as it also creates one stat_ctx 97 * for PF1 in case of RoCE bonding. 98 */ 99 if (BNXT_PF(bp) && !bp->pf.port_id && 100 bp->port_count > 1) 101 bp->edev->ulp_num_ctxs++; 102 } 103 } 104 105 int bnxt_register_dev(struct bnxt_en_dev *edev, 106 struct bnxt_ulp_ops *ulp_ops, 107 void *handle) 108 { 109 struct net_device *dev = edev->net; 110 struct bnxt *bp = netdev_priv(dev); 111 unsigned int max_stat_ctxs; 112 struct bnxt_ulp *ulp; 113 int rc = 0; 114 115 netdev_lock(dev); 116 mutex_lock(&edev->en_dev_lock); 117 if (!bp->irq_tbl) { 118 rc = -ENODEV; 119 goto exit; 120 } 121 max_stat_ctxs = bnxt_get_max_func_stat_ctxs(bp); 122 if (max_stat_ctxs <= BNXT_MIN_ROCE_STAT_CTXS || 123 bp->cp_nr_rings == max_stat_ctxs) { 124 rc = -ENOMEM; 125 goto exit; 126 } 127 128 ulp = edev->ulp_tbl; 129 ulp->handle = handle; 130 rcu_assign_pointer(ulp->ulp_ops, ulp_ops); 131 132 if (test_bit(BNXT_STATE_OPEN, &bp->state)) 133 bnxt_hwrm_vnic_cfg(bp, &bp->vnic_info[BNXT_VNIC_DEFAULT]); 134 135 edev->ulp_tbl->msix_requested = bnxt_get_ulp_msix_num(bp); 136 137 bnxt_fill_msix_vecs(bp, bp->edev->msix_entries); 138 edev->flags |= BNXT_EN_FLAG_MSIX_REQUESTED; 139 exit: 140 mutex_unlock(&edev->en_dev_lock); 141 netdev_unlock(dev); 142 return rc; 143 } 144 EXPORT_SYMBOL(bnxt_register_dev); 145 146 void bnxt_unregister_dev(struct bnxt_en_dev *edev) 147 { 148 struct net_device *dev = edev->net; 149 struct bnxt *bp = netdev_priv(dev); 150 struct bnxt_ulp *ulp; 151 int i = 0; 152 153 ulp = edev->ulp_tbl; 154 netdev_lock(dev); 155 mutex_lock(&edev->en_dev_lock); 156 if (ulp->msix_requested) 157 edev->flags &= ~BNXT_EN_FLAG_MSIX_REQUESTED; 158 edev->ulp_tbl->msix_requested = 0; 159 160 if (ulp->max_async_event_id) 161 bnxt_hwrm_func_drv_rgtr(bp, NULL, 0, true); 162 163 RCU_INIT_POINTER(ulp->ulp_ops, NULL); 164 synchronize_rcu(); 165 ulp->max_async_event_id = 0; 166 ulp->async_events_bmap = NULL; 167 while (atomic_read(&ulp->ref_count) != 0 && i < 10) { 168 msleep(100); 169 i++; 170 } 171 mutex_unlock(&edev->en_dev_lock); 172 netdev_unlock(dev); 173 return; 174 } 175 EXPORT_SYMBOL(bnxt_unregister_dev); 176 177 static int bnxt_set_dflt_ulp_msix(struct bnxt *bp) 178 { 179 int roce_msix = BNXT_MAX_ROCE_MSIX; 180 181 if (BNXT_VF(bp)) 182 roce_msix = BNXT_MAX_ROCE_MSIX_VF; 183 else if (bp->port_partition_type) 184 roce_msix = BNXT_MAX_ROCE_MSIX_NPAR_PF; 185 186 /* NQ MSIX vectors should match the number of CPUs plus 1 more for 187 * the CREQ MSIX, up to the default. 188 */ 189 return min_t(int, roce_msix, num_online_cpus() + 1); 190 } 191 192 int bnxt_send_msg(struct bnxt_en_dev *edev, 193 struct bnxt_fw_msg *fw_msg) 194 { 195 struct net_device *dev = edev->net; 196 struct bnxt *bp = netdev_priv(dev); 197 struct output *resp; 198 struct input *req; 199 u32 resp_len; 200 int rc; 201 202 if (bp->fw_reset_state) 203 return -EBUSY; 204 205 rc = hwrm_req_init(bp, req, 0 /* don't care */); 206 if (rc) 207 return rc; 208 209 rc = hwrm_req_replace(bp, req, fw_msg->msg, fw_msg->msg_len); 210 if (rc) 211 goto drop_req; 212 213 hwrm_req_timeout(bp, req, fw_msg->timeout); 214 resp = hwrm_req_hold(bp, req); 215 rc = hwrm_req_send(bp, req); 216 resp_len = le16_to_cpu(resp->resp_len); 217 if (resp_len) { 218 if (fw_msg->resp_max_len < resp_len) 219 resp_len = fw_msg->resp_max_len; 220 221 memcpy(fw_msg->resp, resp, resp_len); 222 } 223 drop_req: 224 hwrm_req_drop(bp, req); 225 return rc; 226 } 227 EXPORT_SYMBOL(bnxt_send_msg); 228 229 void bnxt_ulp_stop(struct bnxt *bp) 230 { 231 struct bnxt_aux_priv *aux_priv = bp->aux_priv; 232 struct bnxt_en_dev *edev = bp->edev; 233 234 if (!edev) 235 return; 236 237 mutex_lock(&edev->en_dev_lock); 238 if (!bnxt_ulp_registered(edev)) { 239 mutex_unlock(&edev->en_dev_lock); 240 return; 241 } 242 243 edev->flags |= BNXT_EN_FLAG_ULP_STOPPED; 244 if (aux_priv) { 245 struct auxiliary_device *adev; 246 247 adev = &aux_priv->aux_dev; 248 if (adev->dev.driver) { 249 const struct auxiliary_driver *adrv; 250 pm_message_t pm = {}; 251 252 adrv = to_auxiliary_drv(adev->dev.driver); 253 edev->en_state = bp->state; 254 adrv->suspend(adev, pm); 255 } 256 } 257 mutex_unlock(&edev->en_dev_lock); 258 } 259 260 void bnxt_ulp_start(struct bnxt *bp, int err) 261 { 262 struct bnxt_aux_priv *aux_priv = bp->aux_priv; 263 struct bnxt_en_dev *edev = bp->edev; 264 265 if (!edev) 266 return; 267 268 edev->flags &= ~BNXT_EN_FLAG_ULP_STOPPED; 269 270 if (err) 271 return; 272 273 mutex_lock(&edev->en_dev_lock); 274 if (!bnxt_ulp_registered(edev)) { 275 mutex_unlock(&edev->en_dev_lock); 276 return; 277 } 278 279 if (edev->ulp_tbl->msix_requested) 280 bnxt_fill_msix_vecs(bp, edev->msix_entries); 281 282 if (aux_priv) { 283 struct auxiliary_device *adev; 284 285 adev = &aux_priv->aux_dev; 286 if (adev->dev.driver) { 287 const struct auxiliary_driver *adrv; 288 289 adrv = to_auxiliary_drv(adev->dev.driver); 290 edev->en_state = bp->state; 291 adrv->resume(adev); 292 } 293 } 294 mutex_unlock(&edev->en_dev_lock); 295 } 296 297 void bnxt_ulp_irq_stop(struct bnxt *bp) 298 { 299 struct bnxt_en_dev *edev = bp->edev; 300 struct bnxt_ulp_ops *ops; 301 bool reset = false; 302 303 if (!edev || !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED)) 304 return; 305 306 if (bnxt_ulp_registered(bp->edev)) { 307 struct bnxt_ulp *ulp = edev->ulp_tbl; 308 309 if (!ulp->msix_requested) 310 return; 311 312 netdev_lock(bp->dev); 313 ops = rcu_dereference(ulp->ulp_ops); 314 if (!ops || !ops->ulp_irq_stop) 315 return; 316 if (test_bit(BNXT_STATE_FW_RESET_DET, &bp->state)) 317 reset = true; 318 ops->ulp_irq_stop(ulp->handle, reset); 319 netdev_unlock(bp->dev); 320 } 321 } 322 323 void bnxt_ulp_irq_restart(struct bnxt *bp, int err) 324 { 325 struct bnxt_en_dev *edev = bp->edev; 326 struct bnxt_ulp_ops *ops; 327 328 if (!edev || !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED)) 329 return; 330 331 if (bnxt_ulp_registered(bp->edev)) { 332 struct bnxt_ulp *ulp = edev->ulp_tbl; 333 struct bnxt_msix_entry *ent = NULL; 334 335 if (!ulp->msix_requested) 336 return; 337 338 netdev_lock(bp->dev); 339 ops = rcu_dereference(ulp->ulp_ops); 340 if (!ops || !ops->ulp_irq_restart) 341 return; 342 343 if (!err) { 344 ent = kcalloc(ulp->msix_requested, sizeof(*ent), 345 GFP_KERNEL); 346 if (!ent) 347 return; 348 bnxt_fill_msix_vecs(bp, ent); 349 } 350 ops->ulp_irq_restart(ulp->handle, ent); 351 netdev_unlock(bp->dev); 352 kfree(ent); 353 } 354 } 355 356 void bnxt_ulp_async_events(struct bnxt *bp, struct hwrm_async_event_cmpl *cmpl) 357 { 358 u16 event_id = le16_to_cpu(cmpl->event_id); 359 struct bnxt_en_dev *edev = bp->edev; 360 struct bnxt_ulp_ops *ops; 361 struct bnxt_ulp *ulp; 362 363 if (!bnxt_ulp_registered(edev)) 364 return; 365 ulp = edev->ulp_tbl; 366 367 rcu_read_lock(); 368 369 ops = rcu_dereference(ulp->ulp_ops); 370 if (!ops || !ops->ulp_async_notifier) 371 goto exit_unlock_rcu; 372 if (!ulp->async_events_bmap || event_id > ulp->max_async_event_id) 373 goto exit_unlock_rcu; 374 375 /* Read max_async_event_id first before testing the bitmap. */ 376 smp_rmb(); 377 378 if (test_bit(event_id, ulp->async_events_bmap)) 379 ops->ulp_async_notifier(ulp->handle, cmpl); 380 exit_unlock_rcu: 381 rcu_read_unlock(); 382 } 383 384 void bnxt_register_async_events(struct bnxt_en_dev *edev, 385 unsigned long *events_bmap, u16 max_id) 386 { 387 struct net_device *dev = edev->net; 388 struct bnxt *bp = netdev_priv(dev); 389 struct bnxt_ulp *ulp; 390 391 ulp = edev->ulp_tbl; 392 ulp->async_events_bmap = events_bmap; 393 /* Make sure bnxt_ulp_async_events() sees this order */ 394 smp_wmb(); 395 ulp->max_async_event_id = max_id; 396 bnxt_hwrm_func_drv_rgtr(bp, events_bmap, max_id + 1, true); 397 } 398 EXPORT_SYMBOL(bnxt_register_async_events); 399 400 void bnxt_rdma_aux_device_uninit(struct bnxt *bp) 401 { 402 struct bnxt_aux_priv *aux_priv; 403 struct auxiliary_device *adev; 404 405 /* Skip if no auxiliary device init was done. */ 406 if (!bp->aux_priv) 407 return; 408 409 aux_priv = bp->aux_priv; 410 adev = &aux_priv->aux_dev; 411 auxiliary_device_uninit(adev); 412 } 413 414 static void bnxt_aux_dev_release(struct device *dev) 415 { 416 struct bnxt_aux_priv *aux_priv = 417 container_of(dev, struct bnxt_aux_priv, aux_dev.dev); 418 struct bnxt *bp = netdev_priv(aux_priv->edev->net); 419 420 ida_free(&bnxt_aux_dev_ids, aux_priv->id); 421 kfree(aux_priv->edev->ulp_tbl); 422 bp->edev = NULL; 423 kfree(aux_priv->edev); 424 kfree(aux_priv); 425 bp->aux_priv = NULL; 426 } 427 428 void bnxt_rdma_aux_device_del(struct bnxt *bp) 429 { 430 if (!bp->edev) 431 return; 432 433 auxiliary_device_delete(&bp->aux_priv->aux_dev); 434 } 435 436 static void bnxt_set_edev_info(struct bnxt_en_dev *edev, struct bnxt *bp) 437 { 438 edev->net = bp->dev; 439 edev->pdev = bp->pdev; 440 edev->l2_db_size = bp->db_size; 441 edev->l2_db_size_nc = bp->db_size; 442 edev->l2_db_offset = bp->db_offset; 443 mutex_init(&edev->en_dev_lock); 444 445 if (bp->flags & BNXT_FLAG_ROCEV1_CAP) 446 edev->flags |= BNXT_EN_FLAG_ROCEV1_CAP; 447 if (bp->flags & BNXT_FLAG_ROCEV2_CAP) 448 edev->flags |= BNXT_EN_FLAG_ROCEV2_CAP; 449 if (bp->flags & BNXT_FLAG_VF) 450 edev->flags |= BNXT_EN_FLAG_VF; 451 if (BNXT_ROCE_VF_RESC_CAP(bp)) 452 edev->flags |= BNXT_EN_FLAG_ROCE_VF_RES_MGMT; 453 if (BNXT_SW_RES_LMT(bp)) 454 edev->flags |= BNXT_EN_FLAG_SW_RES_LMT; 455 456 edev->chip_num = bp->chip_num; 457 edev->hw_ring_stats_size = bp->hw_ring_stats_size; 458 edev->pf_port_id = bp->pf.port_id; 459 edev->en_state = bp->state; 460 edev->bar0 = bp->bar0; 461 } 462 463 void bnxt_rdma_aux_device_add(struct bnxt *bp) 464 { 465 struct auxiliary_device *aux_dev; 466 int rc; 467 468 if (!bp->edev) 469 return; 470 471 aux_dev = &bp->aux_priv->aux_dev; 472 rc = auxiliary_device_add(aux_dev); 473 if (rc) { 474 netdev_warn(bp->dev, "Failed to add auxiliary device for ROCE\n"); 475 auxiliary_device_uninit(aux_dev); 476 bp->flags &= ~BNXT_FLAG_ROCE_CAP; 477 } 478 } 479 480 void bnxt_rdma_aux_device_init(struct bnxt *bp) 481 { 482 struct auxiliary_device *aux_dev; 483 struct bnxt_aux_priv *aux_priv; 484 struct bnxt_en_dev *edev; 485 struct bnxt_ulp *ulp; 486 int rc; 487 488 if (!(bp->flags & BNXT_FLAG_ROCE_CAP)) 489 return; 490 491 aux_priv = kzalloc(sizeof(*bp->aux_priv), GFP_KERNEL); 492 if (!aux_priv) 493 goto exit; 494 495 aux_priv->id = ida_alloc(&bnxt_aux_dev_ids, GFP_KERNEL); 496 if (aux_priv->id < 0) { 497 netdev_warn(bp->dev, 498 "ida alloc failed for ROCE auxiliary device\n"); 499 kfree(aux_priv); 500 goto exit; 501 } 502 503 aux_dev = &aux_priv->aux_dev; 504 aux_dev->id = aux_priv->id; 505 aux_dev->name = "rdma"; 506 aux_dev->dev.parent = &bp->pdev->dev; 507 aux_dev->dev.release = bnxt_aux_dev_release; 508 509 rc = auxiliary_device_init(aux_dev); 510 if (rc) { 511 ida_free(&bnxt_aux_dev_ids, aux_priv->id); 512 kfree(aux_priv); 513 goto exit; 514 } 515 bp->aux_priv = aux_priv; 516 517 /* From this point, all cleanup will happen via the .release callback & 518 * any error unwinding will need to include a call to 519 * auxiliary_device_uninit. 520 */ 521 edev = kzalloc(sizeof(*edev), GFP_KERNEL); 522 if (!edev) 523 goto aux_dev_uninit; 524 525 aux_priv->edev = edev; 526 527 ulp = kzalloc(sizeof(*ulp), GFP_KERNEL); 528 if (!ulp) 529 goto aux_dev_uninit; 530 531 edev->ulp_tbl = ulp; 532 bp->edev = edev; 533 bnxt_set_edev_info(edev, bp); 534 bp->ulp_num_msix_want = bnxt_set_dflt_ulp_msix(bp); 535 536 return; 537 538 aux_dev_uninit: 539 auxiliary_device_uninit(aux_dev); 540 exit: 541 bp->flags &= ~BNXT_FLAG_ROCE_CAP; 542 } 543