tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

net: can: use platform_{get,set}_drvdata()

Use the wrapper functions for getting and setting the driver data using
platform_device instead of using dev_{get,set}_drvdata() with &pdev->dev,
so we can directly pass a struct platform_device.

Also, unnecessary dev_set_drvdata() is removed, because the driver core
clears the driver data to NULL after device_release or on probe failure.

Signed-off-by: Jingoo Han <jg1.han@samsung.com>
Signed-off-by: Marc Kleine-Budde <mkl@pengutronix.de>

authored by

Jingoo Han and committed by
Marc Kleine-Budde 00e4bbc8 4c4726fa

+20 -30
+4 -6
drivers/net/can/bfin_can.c
··· 580 580 priv->pin_list = pdata; 581 581 priv->can.clock.freq = get_sclk(); 582 582 583 - dev_set_drvdata(&pdev->dev, dev); 583 + platform_set_drvdata(pdev, dev); 584 584 SET_NETDEV_DEV(dev, &pdev->dev); 585 585 586 586 dev->flags |= IFF_ECHO; /* we support local echo */ ··· 613 613 614 614 static int bfin_can_remove(struct platform_device *pdev) 615 615 { 616 - struct net_device *dev = dev_get_drvdata(&pdev->dev); 616 + struct net_device *dev = platform_get_drvdata(pdev); 617 617 struct bfin_can_priv *priv = netdev_priv(dev); 618 618 struct resource *res; 619 619 620 620 bfin_can_set_reset_mode(dev); 621 621 622 622 unregister_candev(dev); 623 - 624 - dev_set_drvdata(&pdev->dev, NULL); 625 623 626 624 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 627 625 release_mem_region(res->start, resource_size(res)); ··· 633 635 #ifdef CONFIG_PM 634 636 static int bfin_can_suspend(struct platform_device *pdev, pm_message_t mesg) 635 637 { 636 - struct net_device *dev = dev_get_drvdata(&pdev->dev); 638 + struct net_device *dev = platform_get_drvdata(pdev); 637 639 struct bfin_can_priv *priv = netdev_priv(dev); 638 640 struct bfin_can_regs __iomem *reg = priv->membase; 639 641 int timeout = BFIN_CAN_TIMEOUT; ··· 656 658 657 659 static int bfin_can_resume(struct platform_device *pdev) 658 660 { 659 - struct net_device *dev = dev_get_drvdata(&pdev->dev); 661 + struct net_device *dev = platform_get_drvdata(pdev); 660 662 struct bfin_can_priv *priv = netdev_priv(dev); 661 663 struct bfin_can_regs __iomem *reg = priv->membase; 662 664
+2 -3
drivers/net/can/cc770/cc770_isa.c
··· 265 265 else 266 266 priv->clkout = COR_DEFAULT; 267 267 268 - dev_set_drvdata(&pdev->dev, dev); 268 + platform_set_drvdata(pdev, dev); 269 269 SET_NETDEV_DEV(dev, &pdev->dev); 270 270 271 271 err = register_cc770dev(dev); ··· 293 293 294 294 static int cc770_isa_remove(struct platform_device *pdev) 295 295 { 296 - struct net_device *dev = dev_get_drvdata(&pdev->dev); 296 + struct net_device *dev = platform_get_drvdata(pdev); 297 297 struct cc770_priv *priv = netdev_priv(dev); 298 298 int idx = pdev->id; 299 299 300 300 unregister_cc770dev(dev); 301 - dev_set_drvdata(&pdev->dev, NULL); 302 301 303 302 if (mem[idx]) { 304 303 iounmap(priv->reg_base);
+2 -2
drivers/net/can/cc770/cc770_platform.c
··· 216 216 priv->reg_base, dev->irq, priv->can.clock.freq, 217 217 priv->cpu_interface, priv->bus_config, priv->clkout); 218 218 219 - dev_set_drvdata(&pdev->dev, dev); 219 + platform_set_drvdata(pdev, dev); 220 220 SET_NETDEV_DEV(dev, &pdev->dev); 221 221 222 222 err = register_cc770dev(dev); ··· 240 240 241 241 static int cc770_platform_remove(struct platform_device *pdev) 242 242 { 243 - struct net_device *dev = dev_get_drvdata(&pdev->dev); 243 + struct net_device *dev = platform_get_drvdata(pdev); 244 244 struct cc770_priv *priv = netdev_priv(dev); 245 245 struct resource *mem; 246 246
+2 -3
drivers/net/can/grcan.c
··· 1646 1646 if (err) 1647 1647 goto exit_free_candev; 1648 1648 1649 - dev_set_drvdata(&ofdev->dev, dev); 1649 + platform_set_drvdata(ofdev, dev); 1650 1650 1651 1651 /* Reset device to allow bit-timing to be set. No need to call 1652 1652 * grcan_reset at this stage. That is done in grcan_open. ··· 1715 1715 1716 1716 static int grcan_remove(struct platform_device *ofdev) 1717 1717 { 1718 - struct net_device *dev = dev_get_drvdata(&ofdev->dev); 1718 + struct net_device *dev = platform_get_drvdata(ofdev); 1719 1719 struct grcan_priv *priv = netdev_priv(dev); 1720 1720 1721 1721 unregister_candev(dev); /* Will in turn call grcan_close */ 1722 1722 1723 1723 irq_dispose_mapping(dev->irq); 1724 - dev_set_drvdata(&ofdev->dev, NULL); 1725 1724 netif_napi_del(&priv->napi); 1726 1725 free_candev(dev); 1727 1726
+4 -6
drivers/net/can/mscan/mpc5xxx_can.c
··· 302 302 goto exit_free_mscan; 303 303 } 304 304 305 - dev_set_drvdata(&ofdev->dev, dev); 305 + platform_set_drvdata(ofdev, dev); 306 306 307 307 dev_info(&ofdev->dev, "MSCAN at 0x%p, irq %d, clock %d Hz\n", 308 308 priv->reg_base, dev->irq, priv->can.clock.freq); ··· 321 321 322 322 static int mpc5xxx_can_remove(struct platform_device *ofdev) 323 323 { 324 - struct net_device *dev = dev_get_drvdata(&ofdev->dev); 324 + struct net_device *dev = platform_get_drvdata(ofdev); 325 325 struct mscan_priv *priv = netdev_priv(dev); 326 - 327 - dev_set_drvdata(&ofdev->dev, NULL); 328 326 329 327 unregister_mscandev(dev); 330 328 iounmap(priv->reg_base); ··· 336 338 static struct mscan_regs saved_regs; 337 339 static int mpc5xxx_can_suspend(struct platform_device *ofdev, pm_message_t state) 338 340 { 339 - struct net_device *dev = dev_get_drvdata(&ofdev->dev); 341 + struct net_device *dev = platform_get_drvdata(ofdev); 340 342 struct mscan_priv *priv = netdev_priv(dev); 341 343 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base; 342 344 ··· 347 349 348 350 static int mpc5xxx_can_resume(struct platform_device *ofdev) 349 351 { 350 - struct net_device *dev = dev_get_drvdata(&ofdev->dev); 352 + struct net_device *dev = platform_get_drvdata(ofdev); 351 353 struct mscan_priv *priv = netdev_priv(dev); 352 354 struct mscan_regs *regs = (struct mscan_regs *)priv->reg_base; 353 355
+2 -3
drivers/net/can/sja1000/sja1000_isa.c
··· 197 197 else 198 198 priv->cdr = CDR_DEFAULT; 199 199 200 - dev_set_drvdata(&pdev->dev, dev); 200 + platform_set_drvdata(pdev, dev); 201 201 SET_NETDEV_DEV(dev, &pdev->dev); 202 202 203 203 err = register_sja1000dev(dev); ··· 225 225 226 226 static int sja1000_isa_remove(struct platform_device *pdev) 227 227 { 228 - struct net_device *dev = dev_get_drvdata(&pdev->dev); 228 + struct net_device *dev = platform_get_drvdata(pdev); 229 229 struct sja1000_priv *priv = netdev_priv(dev); 230 230 int idx = pdev->id; 231 231 232 232 unregister_sja1000dev(dev); 233 - dev_set_drvdata(&pdev->dev, NULL); 234 233 235 234 if (mem[idx]) { 236 235 iounmap(priv->reg_base);
+2 -4
drivers/net/can/sja1000/sja1000_of_platform.c
··· 72 72 73 73 static int sja1000_ofp_remove(struct platform_device *ofdev) 74 74 { 75 - struct net_device *dev = dev_get_drvdata(&ofdev->dev); 75 + struct net_device *dev = platform_get_drvdata(ofdev); 76 76 struct sja1000_priv *priv = netdev_priv(dev); 77 77 struct device_node *np = ofdev->dev.of_node; 78 78 struct resource res; 79 - 80 - dev_set_drvdata(&ofdev->dev, NULL); 81 79 82 80 unregister_sja1000dev(dev); 83 81 free_sja1000dev(dev); ··· 179 181 priv->reg_base, dev->irq, priv->can.clock.freq, 180 182 priv->ocr, priv->cdr); 181 183 182 - dev_set_drvdata(&ofdev->dev, dev); 184 + platform_set_drvdata(ofdev, dev); 183 185 SET_NETDEV_DEV(dev, &ofdev->dev); 184 186 185 187 err = register_sja1000dev(dev);
+2 -3
drivers/net/can/sja1000/sja1000_platform.c
··· 135 135 break; 136 136 } 137 137 138 - dev_set_drvdata(&pdev->dev, dev); 138 + platform_set_drvdata(pdev, dev); 139 139 SET_NETDEV_DEV(dev, &pdev->dev); 140 140 141 141 err = register_sja1000dev(dev); ··· 161 161 162 162 static int sp_remove(struct platform_device *pdev) 163 163 { 164 - struct net_device *dev = dev_get_drvdata(&pdev->dev); 164 + struct net_device *dev = platform_get_drvdata(pdev); 165 165 struct sja1000_priv *priv = netdev_priv(dev); 166 166 struct resource *res; 167 167 168 168 unregister_sja1000dev(dev); 169 - dev_set_drvdata(&pdev->dev, NULL); 170 169 171 170 if (priv->reg_base) 172 171 iounmap(priv->reg_base);