return ret;
 }
 
-static int mv643xx_eth_shared_remove(struct platform_device *pdev)
+static void mv643xx_eth_shared_remove(struct platform_device *pdev)
 {
        struct mv643xx_eth_shared_private *msp = platform_get_drvdata(pdev);
 
        mv643xx_eth_shared_of_remove();
        if (!IS_ERR(msp->clk))
                clk_disable_unprepare(msp->clk);
-       return 0;
 }
 
 static struct platform_driver mv643xx_eth_shared_driver = {
        .probe          = mv643xx_eth_shared_probe,
-       .remove         = mv643xx_eth_shared_remove,
+       .remove_new     = mv643xx_eth_shared_remove,
        .driver = {
                .name   = MV643XX_ETH_SHARED_NAME,
                .of_match_table = of_match_ptr(mv643xx_eth_shared_ids),
        return err;
 }
 
-static int mv643xx_eth_remove(struct platform_device *pdev)
+static void mv643xx_eth_remove(struct platform_device *pdev)
 {
        struct mv643xx_eth_private *mp = platform_get_drvdata(pdev);
        struct net_device *dev = mp->dev;
                clk_disable_unprepare(mp->clk);
 
        free_netdev(mp->dev);
-
-       return 0;
 }
 
 static void mv643xx_eth_shutdown(struct platform_device *pdev)
 
 static struct platform_driver mv643xx_eth_driver = {
        .probe          = mv643xx_eth_probe,
-       .remove         = mv643xx_eth_remove,
+       .remove_new     = mv643xx_eth_remove,
        .shutdown       = mv643xx_eth_shutdown,
        .driver = {
                .name   = MV643XX_ETH_NAME,
 
        return ret;
 }
 
-static int orion_mdio_remove(struct platform_device *pdev)
+static void orion_mdio_remove(struct platform_device *pdev)
 {
        struct mii_bus *bus = platform_get_drvdata(pdev);
        struct orion_mdio_dev *dev = bus->priv;
                clk_disable_unprepare(dev->clk[i]);
                clk_put(dev->clk[i]);
        }
-
-       return 0;
 }
 
 static const struct of_device_id orion_mdio_match[] = {
 
 static struct platform_driver orion_mdio_driver = {
        .probe = orion_mdio_probe,
-       .remove = orion_mdio_remove,
+       .remove_new = orion_mdio_remove,
        .driver = {
                .name = "orion-mdio",
                .of_match_table = orion_mdio_match,
 
 }
 
 /* Device removal routine */
-static int mvneta_remove(struct platform_device *pdev)
+static void mvneta_remove(struct platform_device *pdev)
 {
        struct net_device  *dev = platform_get_drvdata(pdev);
        struct mvneta_port *pp = netdev_priv(dev);
                                       1 << pp->id);
                mvneta_bm_put(pp->bm_priv);
        }
-
-       return 0;
 }
 
 #ifdef CONFIG_PM_SLEEP
 
 static struct platform_driver mvneta_driver = {
        .probe = mvneta_probe,
-       .remove = mvneta_remove,
+       .remove_new = mvneta_remove,
        .driver = {
                .name = MVNETA_DRIVER_NAME,
                .of_match_table = mvneta_match,
 
        return err;
 }
 
-static int mvneta_bm_remove(struct platform_device *pdev)
+static void mvneta_bm_remove(struct platform_device *pdev)
 {
        struct mvneta_bm *priv = platform_get_drvdata(pdev);
        u8 all_ports_map = 0xff;
        mvneta_bm_write(priv, MVNETA_BM_COMMAND_REG, MVNETA_BM_STOP_MASK);
 
        clk_disable_unprepare(priv->clk);
-
-       return 0;
 }
 
 static const struct of_device_id mvneta_bm_match[] = {
 
 static struct platform_driver mvneta_bm_driver = {
        .probe = mvneta_bm_probe,
-       .remove = mvneta_bm_remove,
+       .remove_new = mvneta_bm_remove,
        .driver = {
                .name = MVNETA_BM_DRIVER_NAME,
                .of_match_table = mvneta_bm_match,
 
        return err;
 }
 
-static int mvpp2_remove(struct platform_device *pdev)
+static void mvpp2_remove(struct platform_device *pdev)
 {
        struct mvpp2 *priv = platform_get_drvdata(pdev);
        struct fwnode_handle *fwnode = pdev->dev.fwnode;
        }
 
        if (is_acpi_node(port_fwnode))
-               return 0;
+               return;
 
        clk_disable_unprepare(priv->axi_clk);
        clk_disable_unprepare(priv->mg_core_clk);
        clk_disable_unprepare(priv->mg_clk);
        clk_disable_unprepare(priv->pp_clk);
        clk_disable_unprepare(priv->gop_clk);
-
-       return 0;
 }
 
 static const struct of_device_id mvpp2_match[] = {
 
 static struct platform_driver mvpp2_driver = {
        .probe = mvpp2_probe,
-       .remove = mvpp2_remove,
+       .remove_new = mvpp2_remove,
        .driver = {
                .name = MVPP2_DRIVER_NAME,
                .of_match_table = mvpp2_match,
 
        return err;
 }
 
-static int pxa168_eth_remove(struct platform_device *pdev)
+static void pxa168_eth_remove(struct platform_device *pdev)
 {
        struct net_device *dev = platform_get_drvdata(pdev);
        struct pxa168_eth_private *pep = netdev_priv(dev);
        mdiobus_free(pep->smi_bus);
        unregister_netdev(dev);
        free_netdev(dev);
-       return 0;
 }
 
 static void pxa168_eth_shutdown(struct platform_device *pdev)
 
 static struct platform_driver pxa168_eth_driver = {
        .probe = pxa168_eth_probe,
-       .remove = pxa168_eth_remove,
+       .remove_new = pxa168_eth_remove,
        .shutdown = pxa168_eth_shutdown,
        .resume = pxa168_eth_resume,
        .suspend = pxa168_eth_suspend,