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, idx, 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 idx = edev->ulp_tbl->msix_base; 42 for (i = 0; i < num_msix; i++) { 43 ent[i].vector = bp->irq_tbl[idx + i].vector; 44 ent[i].ring_idx = idx + i; 45 if (bp->flags & BNXT_FLAG_CHIP_P5) { 46 ent[i].db_offset = DB_PF_OFFSET_P5; 47 if (BNXT_VF(bp)) 48 ent[i].db_offset = DB_VF_OFFSET_P5; 49 } else { 50 ent[i].db_offset = (idx + i) * 0x80; 51 } 52 } 53 } 54 55 int bnxt_register_dev(struct bnxt_en_dev *edev, 56 struct bnxt_ulp_ops *ulp_ops, 57 void *handle) 58 { 59 struct net_device *dev = edev->net; 60 struct bnxt *bp = netdev_priv(dev); 61 unsigned int max_stat_ctxs; 62 struct bnxt_ulp *ulp; 63 64 max_stat_ctxs = bnxt_get_max_func_stat_ctxs(bp); 65 if (max_stat_ctxs <= BNXT_MIN_ROCE_STAT_CTXS || 66 bp->cp_nr_rings == max_stat_ctxs) 67 return -ENOMEM; 68 69 ulp = edev->ulp_tbl; 70 if (!ulp) 71 return -ENOMEM; 72 73 ulp->handle = handle; 74 rcu_assign_pointer(ulp->ulp_ops, ulp_ops); 75 76 if (test_bit(BNXT_STATE_OPEN, &bp->state)) 77 bnxt_hwrm_vnic_cfg(bp, 0); 78 79 bnxt_fill_msix_vecs(bp, bp->edev->msix_entries); 80 edev->flags |= BNXT_EN_FLAG_MSIX_REQUESTED; 81 return 0; 82 } 83 EXPORT_SYMBOL(bnxt_register_dev); 84 85 void bnxt_unregister_dev(struct bnxt_en_dev *edev) 86 { 87 struct net_device *dev = edev->net; 88 struct bnxt *bp = netdev_priv(dev); 89 struct bnxt_ulp *ulp; 90 int i = 0; 91 92 ulp = edev->ulp_tbl; 93 if (ulp->msix_requested) 94 edev->flags &= ~BNXT_EN_FLAG_MSIX_REQUESTED; 95 96 if (ulp->max_async_event_id) 97 bnxt_hwrm_func_drv_rgtr(bp, NULL, 0, true); 98 99 RCU_INIT_POINTER(ulp->ulp_ops, NULL); 100 synchronize_rcu(); 101 ulp->max_async_event_id = 0; 102 ulp->async_events_bmap = NULL; 103 while (atomic_read(&ulp->ref_count) != 0 && i < 10) { 104 msleep(100); 105 i++; 106 } 107 return; 108 } 109 EXPORT_SYMBOL(bnxt_unregister_dev); 110 111 int bnxt_get_ulp_msix_num(struct bnxt *bp) 112 { 113 u32 roce_msix = BNXT_VF(bp) ? 114 BNXT_MAX_VF_ROCE_MSIX : BNXT_MAX_ROCE_MSIX; 115 116 return ((bp->flags & BNXT_FLAG_ROCE_CAP) ? 117 min_t(u32, roce_msix, num_online_cpus()) : 0); 118 } 119 120 int bnxt_get_ulp_msix_base(struct bnxt *bp) 121 { 122 if (bnxt_ulp_registered(bp->edev)) { 123 struct bnxt_en_dev *edev = bp->edev; 124 125 if (edev->ulp_tbl->msix_requested) 126 return edev->ulp_tbl->msix_base; 127 } 128 return 0; 129 } 130 131 int bnxt_get_ulp_stat_ctxs(struct bnxt *bp) 132 { 133 if (bnxt_ulp_registered(bp->edev)) { 134 struct bnxt_en_dev *edev = bp->edev; 135 136 if (edev->ulp_tbl->msix_requested) 137 return BNXT_MIN_ROCE_STAT_CTXS; 138 } 139 140 return 0; 141 } 142 143 int bnxt_send_msg(struct bnxt_en_dev *edev, 144 struct bnxt_fw_msg *fw_msg) 145 { 146 struct net_device *dev = edev->net; 147 struct bnxt *bp = netdev_priv(dev); 148 struct output *resp; 149 struct input *req; 150 u32 resp_len; 151 int rc; 152 153 if (bp->fw_reset_state) 154 return -EBUSY; 155 156 rc = hwrm_req_init(bp, req, 0 /* don't care */); 157 if (rc) 158 return rc; 159 160 rc = hwrm_req_replace(bp, req, fw_msg->msg, fw_msg->msg_len); 161 if (rc) 162 return rc; 163 164 hwrm_req_timeout(bp, req, fw_msg->timeout); 165 resp = hwrm_req_hold(bp, req); 166 rc = hwrm_req_send(bp, req); 167 resp_len = le16_to_cpu(resp->resp_len); 168 if (resp_len) { 169 if (fw_msg->resp_max_len < resp_len) 170 resp_len = fw_msg->resp_max_len; 171 172 memcpy(fw_msg->resp, resp, resp_len); 173 } 174 hwrm_req_drop(bp, req); 175 return rc; 176 } 177 EXPORT_SYMBOL(bnxt_send_msg); 178 179 void bnxt_ulp_stop(struct bnxt *bp) 180 { 181 struct bnxt_aux_priv *aux_priv = bp->aux_priv; 182 struct bnxt_en_dev *edev = bp->edev; 183 184 if (!edev) 185 return; 186 187 edev->flags |= BNXT_EN_FLAG_ULP_STOPPED; 188 if (aux_priv) { 189 struct auxiliary_device *adev; 190 191 adev = &aux_priv->aux_dev; 192 if (adev->dev.driver) { 193 struct auxiliary_driver *adrv; 194 pm_message_t pm = {}; 195 196 adrv = to_auxiliary_drv(adev->dev.driver); 197 edev->en_state = bp->state; 198 adrv->suspend(adev, pm); 199 } 200 } 201 } 202 203 void bnxt_ulp_start(struct bnxt *bp, int err) 204 { 205 struct bnxt_aux_priv *aux_priv = bp->aux_priv; 206 struct bnxt_en_dev *edev = bp->edev; 207 208 if (!edev) 209 return; 210 211 edev->flags &= ~BNXT_EN_FLAG_ULP_STOPPED; 212 213 if (err) 214 return; 215 216 if (edev->ulp_tbl->msix_requested) 217 bnxt_fill_msix_vecs(bp, edev->msix_entries); 218 219 if (aux_priv) { 220 struct auxiliary_device *adev; 221 222 adev = &aux_priv->aux_dev; 223 if (adev->dev.driver) { 224 struct auxiliary_driver *adrv; 225 226 adrv = to_auxiliary_drv(adev->dev.driver); 227 edev->en_state = bp->state; 228 adrv->resume(adev); 229 } 230 } 231 232 } 233 234 void bnxt_ulp_irq_stop(struct bnxt *bp) 235 { 236 struct bnxt_en_dev *edev = bp->edev; 237 struct bnxt_ulp_ops *ops; 238 239 if (!edev || !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED)) 240 return; 241 242 if (bnxt_ulp_registered(bp->edev)) { 243 struct bnxt_ulp *ulp = edev->ulp_tbl; 244 245 if (!ulp->msix_requested) 246 return; 247 248 ops = rtnl_dereference(ulp->ulp_ops); 249 if (!ops || !ops->ulp_irq_stop) 250 return; 251 ops->ulp_irq_stop(ulp->handle); 252 } 253 } 254 255 void bnxt_ulp_irq_restart(struct bnxt *bp, int err) 256 { 257 struct bnxt_en_dev *edev = bp->edev; 258 struct bnxt_ulp_ops *ops; 259 260 if (!edev || !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED)) 261 return; 262 263 if (bnxt_ulp_registered(bp->edev)) { 264 struct bnxt_ulp *ulp = edev->ulp_tbl; 265 struct bnxt_msix_entry *ent = NULL; 266 267 if (!ulp->msix_requested) 268 return; 269 270 ops = rtnl_dereference(ulp->ulp_ops); 271 if (!ops || !ops->ulp_irq_restart) 272 return; 273 274 if (!err) { 275 ent = kcalloc(ulp->msix_requested, sizeof(*ent), 276 GFP_KERNEL); 277 if (!ent) 278 return; 279 bnxt_fill_msix_vecs(bp, ent); 280 } 281 ops->ulp_irq_restart(ulp->handle, ent); 282 kfree(ent); 283 } 284 } 285 286 int bnxt_register_async_events(struct bnxt_en_dev *edev, 287 unsigned long *events_bmap, 288 u16 max_id) 289 { 290 struct net_device *dev = edev->net; 291 struct bnxt *bp = netdev_priv(dev); 292 struct bnxt_ulp *ulp; 293 294 ulp = edev->ulp_tbl; 295 ulp->async_events_bmap = events_bmap; 296 /* Make sure bnxt_ulp_async_events() sees this order */ 297 smp_wmb(); 298 ulp->max_async_event_id = max_id; 299 bnxt_hwrm_func_drv_rgtr(bp, events_bmap, max_id + 1, true); 300 return 0; 301 } 302 EXPORT_SYMBOL(bnxt_register_async_events); 303 304 void bnxt_rdma_aux_device_uninit(struct bnxt *bp) 305 { 306 struct bnxt_aux_priv *aux_priv; 307 struct auxiliary_device *adev; 308 309 /* Skip if no auxiliary device init was done. */ 310 if (!bp->aux_priv) 311 return; 312 313 aux_priv = bp->aux_priv; 314 adev = &aux_priv->aux_dev; 315 auxiliary_device_delete(adev); 316 auxiliary_device_uninit(adev); 317 } 318 319 static void bnxt_aux_dev_release(struct device *dev) 320 { 321 struct bnxt_aux_priv *aux_priv = 322 container_of(dev, struct bnxt_aux_priv, aux_dev.dev); 323 struct bnxt *bp = netdev_priv(aux_priv->edev->net); 324 325 ida_free(&bnxt_aux_dev_ids, aux_priv->id); 326 kfree(aux_priv->edev->ulp_tbl); 327 bp->edev = NULL; 328 kfree(aux_priv->edev); 329 kfree(aux_priv); 330 bp->aux_priv = NULL; 331 } 332 333 static void bnxt_set_edev_info(struct bnxt_en_dev *edev, struct bnxt *bp) 334 { 335 edev->net = bp->dev; 336 edev->pdev = bp->pdev; 337 edev->l2_db_size = bp->db_size; 338 edev->l2_db_size_nc = bp->db_size; 339 340 if (bp->flags & BNXT_FLAG_ROCEV1_CAP) 341 edev->flags |= BNXT_EN_FLAG_ROCEV1_CAP; 342 if (bp->flags & BNXT_FLAG_ROCEV2_CAP) 343 edev->flags |= BNXT_EN_FLAG_ROCEV2_CAP; 344 if (bp->flags & BNXT_FLAG_VF) 345 edev->flags |= BNXT_EN_FLAG_VF; 346 347 edev->chip_num = bp->chip_num; 348 edev->hw_ring_stats_size = bp->hw_ring_stats_size; 349 edev->pf_port_id = bp->pf.port_id; 350 edev->en_state = bp->state; 351 edev->bar0 = bp->bar0; 352 edev->ulp_tbl->msix_requested = bnxt_get_ulp_msix_num(bp); 353 } 354 355 void bnxt_rdma_aux_device_init(struct bnxt *bp) 356 { 357 struct auxiliary_device *aux_dev; 358 struct bnxt_aux_priv *aux_priv; 359 struct bnxt_en_dev *edev; 360 struct bnxt_ulp *ulp; 361 int rc; 362 363 if (!(bp->flags & BNXT_FLAG_ROCE_CAP)) 364 return; 365 366 aux_priv = kzalloc(sizeof(*bp->aux_priv), GFP_KERNEL); 367 if (!aux_priv) 368 goto exit; 369 370 aux_priv->id = ida_alloc(&bnxt_aux_dev_ids, GFP_KERNEL); 371 if (aux_priv->id < 0) { 372 netdev_warn(bp->dev, 373 "ida alloc failed for ROCE auxiliary device\n"); 374 kfree(aux_priv); 375 goto exit; 376 } 377 378 aux_dev = &aux_priv->aux_dev; 379 aux_dev->id = aux_priv->id; 380 aux_dev->name = "rdma"; 381 aux_dev->dev.parent = &bp->pdev->dev; 382 aux_dev->dev.release = bnxt_aux_dev_release; 383 384 rc = auxiliary_device_init(aux_dev); 385 if (rc) { 386 ida_free(&bnxt_aux_dev_ids, aux_priv->id); 387 kfree(aux_priv); 388 goto exit; 389 } 390 bp->aux_priv = aux_priv; 391 392 /* From this point, all cleanup will happen via the .release callback & 393 * any error unwinding will need to include a call to 394 * auxiliary_device_uninit. 395 */ 396 edev = kzalloc(sizeof(*edev), GFP_KERNEL); 397 if (!edev) 398 goto aux_dev_uninit; 399 400 aux_priv->edev = edev; 401 402 ulp = kzalloc(sizeof(*ulp), GFP_KERNEL); 403 if (!ulp) 404 goto aux_dev_uninit; 405 406 edev->ulp_tbl = ulp; 407 bp->edev = edev; 408 bnxt_set_edev_info(edev, bp); 409 410 rc = auxiliary_device_add(aux_dev); 411 if (rc) { 412 netdev_warn(bp->dev, 413 "Failed to add auxiliary device for ROCE\n"); 414 goto aux_dev_uninit; 415 } 416 417 return; 418 419 aux_dev_uninit: 420 auxiliary_device_uninit(aux_dev); 421 exit: 422 bp->flags &= ~BNXT_FLAG_ROCE_CAP; 423 } 424