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