bp->hwrm_spec_code > 0x10803)
                bp->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
 
-       rc = devlink_register(dl);
-       if (rc) {
-               netdev_warn(bp->dev, "devlink_register failed. rc=%d\n", rc);
-               goto err_dl_free;
-       }
-
+       devlink_register(dl);
        if (!BNXT_PF(bp))
                return 0;
 
        rc = devlink_port_register(dl, &bp->dl_port, bp->pf.port_id);
        if (rc) {
                netdev_err(bp->dev, "devlink_port_register failed\n");
-               goto err_dl_unreg;
+               goto err_dl_free;
        }
 
        rc = bnxt_dl_params_register(bp);
 
 err_dl_port_unreg:
        devlink_port_unregister(&bp->dl_port);
-err_dl_unreg:
-       devlink_unregister(dl);
 err_dl_free:
        bnxt_link_bp_to_dl(bp, NULL);
        devlink_free(dl);
 
        lio_devlink = devlink_priv(devlink);
        lio_devlink->oct = octeon_dev;
 
-       if (devlink_register(devlink)) {
-               devlink_free(devlink);
-               dev_err(&octeon_dev->pci_dev->dev,
-                       "devlink registration failed\n");
-               goto setup_nic_dev_free;
-       }
-
+       devlink_register(devlink);
        octeon_dev->devlink = devlink;
        octeon_dev->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
 
 
        struct net_device *net_dev = priv->net_dev;
        struct device *dev = net_dev->dev.parent;
        struct dpaa2_eth_devlink_priv *dl_priv;
-       int err;
 
        priv->devlink =
                devlink_alloc(&dpaa2_eth_devlink_ops, sizeof(*dl_priv), dev);
        dl_priv = devlink_priv(priv->devlink);
        dl_priv->dpaa2_priv = priv;
 
-       err = devlink_register(priv->devlink);
-       if (err) {
-               dev_err(dev, "devlink_register() = %d\n", err);
-               goto devlink_free;
-       }
-
+       devlink_register(priv->devlink);
        return 0;
-
-devlink_free:
-       devlink_free(priv->devlink);
-
-       return err;
 }
 
 void dpaa2_eth_dl_unregister(struct dpaa2_eth_priv *priv)
 
        struct pci_dev *pdev = hdev->pdev;
        struct hclge_devlink_priv *priv;
        struct devlink *devlink;
-       int ret;
 
        devlink = devlink_alloc(&hclge_devlink_ops,
                                sizeof(struct hclge_devlink_priv), &pdev->dev);
        priv->hdev = hdev;
        hdev->devlink = devlink;
 
-       ret = devlink_register(devlink);
-       if (ret) {
-               dev_err(&pdev->dev, "failed to register devlink, ret = %d\n",
-                       ret);
-               goto out_reg_fail;
-       }
-
+       devlink_register(devlink);
        devlink_reload_enable(devlink);
-
        return 0;
-
-out_reg_fail:
-       devlink_free(devlink);
-       return ret;
 }
 
 void hclge_devlink_uninit(struct hclge_dev *hdev)
 
        struct pci_dev *pdev = hdev->pdev;
        struct hclgevf_devlink_priv *priv;
        struct devlink *devlink;
-       int ret;
 
        devlink =
                devlink_alloc(&hclgevf_devlink_ops,
        priv->hdev = hdev;
        hdev->devlink = devlink;
 
-       ret = devlink_register(devlink);
-       if (ret) {
-               dev_err(&pdev->dev, "failed to register devlink, ret = %d\n",
-                       ret);
-               goto out_reg_fail;
-       }
-
+       devlink_register(devlink);
        devlink_reload_enable(devlink);
-
        return 0;
-
-out_reg_fail:
-       devlink_free(devlink);
-       return ret;
 }
 
 void hclgevf_devlink_uninit(struct hclgevf_dev *hdev)
 
        devlink_free(devlink);
 }
 
-int hinic_devlink_register(struct hinic_devlink_priv *priv)
+void hinic_devlink_register(struct hinic_devlink_priv *priv)
 {
        struct devlink *devlink = priv_to_devlink(priv);
 
-       return devlink_register(devlink);
+       devlink_register(devlink);
 }
 
 void hinic_devlink_unregister(struct hinic_devlink_priv *priv)
 
 
 struct devlink *hinic_devlink_alloc(struct device *dev);
 void hinic_devlink_free(struct devlink *devlink);
-int hinic_devlink_register(struct hinic_devlink_priv *priv);
+void hinic_devlink_register(struct hinic_devlink_priv *priv);
 void hinic_devlink_unregister(struct hinic_devlink_priv *priv);
 
 int hinic_health_reporters_create(struct hinic_devlink_priv *priv);
 
                return err;
        }
 
-       err = hinic_devlink_register(hwdev->devlink_dev);
-       if (err) {
-               dev_err(&hwif->pdev->dev, "Failed to register devlink\n");
-               hinic_pf_to_mgmt_free(&pfhwdev->pf_to_mgmt);
-               return err;
-       }
-
+       hinic_devlink_register(hwdev->devlink_dev);
        err = hinic_func_to_func_init(hwdev);
        if (err) {
                dev_err(&hwif->pdev->dev, "Failed to init mailbox\n");
 
  *
  * Return: zero on success or an error code on failure.
  */
-int ice_devlink_register(struct ice_pf *pf)
+void ice_devlink_register(struct ice_pf *pf)
 {
        struct devlink *devlink = priv_to_devlink(pf);
-       struct device *dev = ice_pf_to_dev(pf);
-       int err;
 
-       err = devlink_register(devlink);
-       if (err) {
-               dev_err(dev, "devlink registration failed: %d\n", err);
-               return err;
-       }
-
-       return 0;
+       devlink_register(devlink);
 }
 
 /**
 
 
 struct ice_pf *ice_allocate_pf(struct device *dev);
 
-int ice_devlink_register(struct ice_pf *pf);
+void ice_devlink_register(struct ice_pf *pf);
 void ice_devlink_unregister(struct ice_pf *pf);
 int ice_devlink_create_port(struct ice_vsi *vsi);
 void ice_devlink_destroy_port(struct ice_vsi *vsi);
 
 
        pf->msg_enable = netif_msg_init(debug, ICE_DFLT_NETIF_M);
 
-       err = ice_devlink_register(pf);
-       if (err) {
-               dev_err(dev, "ice_devlink_register failed: %d\n", err);
-               goto err_exit_unroll;
-       }
+       ice_devlink_register(pf);
 
 #ifndef CONFIG_DYNAMIC_DEBUG
        if (debug < -1)
 
                return -ENOMEM;
        }
 
-       err = devlink_register(dl);
-       if (err) {
-               dev_err(rvu->dev, "devlink register failed with error %d\n", err);
-               devlink_free(dl);
-               return err;
-       }
-
+       devlink_register(dl);
        rvu_dl = devlink_priv(dl);
        rvu_dl->dl = dl;
        rvu_dl->rvu = rvu;
 
                return -ENOMEM;
        }
 
-       err = devlink_register(dl);
-       if (err) {
-               dev_err(pfvf->dev, "devlink register failed with error %d\n", err);
-               devlink_free(dl);
-               return err;
-       }
-
+       devlink_register(dl);
        otx2_dl = devlink_priv(dl);
        otx2_dl->dl = dl;
        otx2_dl->pfvf = pfvf;
 
        struct devlink *dl = priv_to_devlink(sw);
        int err;
 
-       err = devlink_register(dl);
-       if (err) {
-               dev_err(prestera_dev(sw), "devlink_register failed: %d\n", err);
-               return err;
-       }
+       devlink_register(dl);
 
        err = prestera_devlink_traps_register(sw);
        if (err) {
 
        mutex_init(&dev->persist->interface_state_mutex);
        mutex_init(&dev->persist->pci_status_mutex);
 
-       ret = devlink_register(devlink);
-       if (ret)
-               goto err_persist_free;
+       devlink_register(devlink);
        ret = devlink_params_register(devlink, mlx4_devlink_params,
                                      ARRAY_SIZE(mlx4_devlink_params));
        if (ret)
                                  ARRAY_SIZE(mlx4_devlink_params));
 err_devlink_unregister:
        devlink_unregister(devlink);
-err_persist_free:
        kfree(dev->persist);
 err_devlink_free:
        devlink_free(devlink);
 
 {
        int err;
 
-       err = devlink_register(devlink);
-       if (err)
-               return err;
-
+       devlink_register(devlink);
        err = devlink_params_register(devlink, mlx5_devlink_params,
                                      ARRAY_SIZE(mlx5_devlink_params));
        if (err)
 
        if (err)
                goto err_emad_init;
 
-       if (!reload) {
-               err = devlink_register(devlink);
-               if (err)
-                       goto err_devlink_register;
-       }
+       if (!reload)
+               devlink_register(devlink);
 
        if (!reload) {
                err = mlxsw_core_params_register(mlxsw_core);
 err_register_params:
        if (!reload)
                devlink_unregister(devlink);
-err_devlink_register:
        mlxsw_emad_fini(mlxsw_core);
 err_emad_init:
        kfree(mlxsw_core->lag.mapping);
 
        if (err)
                goto out_put_ports;
 
-       err = devlink_register(devlink);
-       if (err)
-               goto out_ocelot_deinit;
-
+       devlink_register(devlink);
        err = mscc_ocelot_init_ports(pdev, ports);
        if (err)
                goto out_ocelot_devlink_unregister;
        mscc_ocelot_teardown_devlink_ports(ocelot);
 out_ocelot_devlink_unregister:
        devlink_unregister(devlink);
-out_ocelot_deinit:
        ocelot_deinit(ocelot);
 out_put_ports:
        of_node_put(ports);
 
        if (err)
                goto err_unmap;
 
-       err = devlink_register(devlink);
-       if (err)
-               goto err_app_clean;
-
+       devlink_register(devlink);
        err = nfp_shared_buf_register(pf);
        if (err)
                goto err_devlink_unreg;
 err_devlink_unreg:
        cancel_work_sync(&pf->port_refresh_work);
        devlink_unregister(devlink);
-err_app_clean:
        nfp_net_pf_app_clean(pf);
 err_unmap:
        nfp_net_pci_unmap_mem(pf);
 
        struct devlink_port_attrs attrs = {};
        int err;
 
-       err = devlink_register(dl);
-       if (err) {
-               dev_warn(ionic->dev, "devlink_register failed: %d\n", err);
-               return err;
-       }
-
+       devlink_register(dl);
        attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
        devlink_port_attrs_set(&ionic->dl_port, &attrs);
        err = devlink_port_register(dl, &ionic->dl_port, 0);
 
        qdevlink = devlink_priv(dl);
        qdevlink->cdev = cdev;
 
-       rc = devlink_register(dl);
-       if (rc)
-               goto err_free;
-
+       devlink_register(dl);
        rc = devlink_params_register(dl, qed_devlink_params,
                                     ARRAY_SIZE(qed_devlink_params));
        if (rc)
 
 err_unregister:
        devlink_unregister(dl);
-
-err_free:
        devlink_free(dl);
 
        return ERR_PTR(rc);
 
        dl_priv = devlink_priv(common->devlink);
        dl_priv->common = common;
 
-       ret = devlink_register(common->devlink);
-       if (ret) {
-               dev_err(dev, "devlink reg fail ret:%d\n", ret);
-               goto dl_free;
-       }
-
+       devlink_register(common->devlink);
        /* Provide devlink hook to switch mode when multiple external ports
         * are present NUSS switchdev driver is enabled.
         */
        }
 dl_unreg:
        devlink_unregister(common->devlink);
-dl_free:
        devlink_free(common->devlink);
-
        return ret;
 }
 
 
        dl_priv = devlink_priv(cpsw->devlink);
        dl_priv->cpsw = cpsw;
 
-       ret = devlink_register(cpsw->devlink);
-       if (ret) {
-               dev_err(dev, "DL reg fail ret:%d\n", ret);
-               goto dl_free;
-       }
-
+       devlink_register(cpsw->devlink);
        ret = devlink_params_register(cpsw->devlink, cpsw_devlink_params,
                                      ARRAY_SIZE(cpsw_devlink_params));
        if (ret) {
 
 dl_unreg:
        devlink_unregister(cpsw->devlink);
-dl_free:
        devlink_free(cpsw->devlink);
        return ret;
 }
 
        if (err)
                goto err_devlink_free;
 
-       err = devlink_register(devlink);
-       if (err)
-               goto err_resources_unregister;
-
+       devlink_register(devlink);
        err = devlink_params_register(devlink, nsim_devlink_params,
                                      ARRAY_SIZE(nsim_devlink_params));
        if (err)
                                  ARRAY_SIZE(nsim_devlink_params));
 err_dl_unregister:
        devlink_unregister(devlink);
-err_resources_unregister:
        devlink_resources_unregister(devlink, NULL);
 err_devlink_free:
        devlink_free(devlink);
 
        ipc_devlink->devlink_ctx = devlink_ctx;
        ipc_devlink->pcie = ipc_imem->pcie;
        ipc_devlink->dev = ipc_imem->dev;
-       rc = devlink_register(devlink_ctx);
-       if (rc) {
-               dev_err(ipc_devlink->dev, "devlink_register failed rc %d", rc);
-               goto free_dl;
-       }
+       devlink_register(devlink_ctx);
 
        rc = devlink_params_register(devlink_ctx, iosm_devlink_params,
                                     ARRAY_SIZE(iosm_devlink_params));
        devlink_params_unregister(devlink_ctx, iosm_devlink_params,
                                  ARRAY_SIZE(iosm_devlink_params));
 param_reg_fail:
-       devlink_unregister(devlink_ctx);
-free_dl:
        devlink_free(devlink_ctx);
 devlink_alloc_fail:
        return NULL;
 
                return -ENOMEM;
        }
 
-       err = devlink_register(devlink);
-       if (err)
-               goto out_free;
-
+       devlink_register(devlink);
        err = pci_enable_device(pdev);
        if (err) {
                dev_err(&pdev->dev, "pci_enable_device\n");
        pci_disable_device(pdev);
 out_unregister:
        devlink_unregister(devlink);
-out_free:
        devlink_free(devlink);
-
        return err;
 }
 
 
                goto netdev_free;
        }
 
-       err = devlink_register(devlink);
-       if (err)
-               goto netdev_free;
-
+       devlink_register(devlink);
        err = qlge_health_create_reporters(qdev);
-
        if (err)
                goto devlink_unregister;
 
 
 {
        return devlink_alloc_ns(ops, priv_size, &init_net, dev);
 }
-int devlink_register(struct devlink *devlink);
+void devlink_register(struct devlink *devlink);
 void devlink_unregister(struct devlink *devlink);
 void devlink_reload_enable(struct devlink *devlink);
 void devlink_reload_disable(struct devlink *devlink);
 
  *
  *     @devlink: devlink
  */
-int devlink_register(struct devlink *devlink)
+void devlink_register(struct devlink *devlink)
 {
        mutex_lock(&devlink_mutex);
        xa_set_mark(&devlinks, devlink->index, DEVLINK_REGISTERED);
        devlink_notify(devlink, DEVLINK_CMD_NEW);
        mutex_unlock(&devlink_mutex);
-       return 0;
 }
 EXPORT_SYMBOL_GPL(devlink_register);
 
 
        dl_priv = devlink_priv(ds->devlink);
        dl_priv->ds = ds;
 
-       err = devlink_register(ds->devlink);
-       if (err)
-               goto free_devlink;
-
+       devlink_register(ds->devlink);
        /* Setup devlink port instances now, so that the switch
         * setup() can register regions etc, against the ports
         */
                if (dp->ds == ds)
                        dsa_port_devlink_teardown(dp);
        devlink_unregister(ds->devlink);
-free_devlink:
        devlink_free(ds->devlink);
        ds->devlink = NULL;
-
        return err;
 }