usb: phy: generic: allow multiples calls to usb_phy_generic_register()

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

it's now very easy to return a platform_device pointer
and have the caller pass it as argument when calling
usb_phy_generic_unregister().

Signed-off-by: Felipe Balbi <balbi@ti.com>

Felipe Balbi 12 years ago 2f36ff69 e741e637

+40 -27

6 changed files

expand all

drivers

usb

musb

am35x.c

blackfin.c

da8xx.c

tusb6010.c

phy

phy-generic.c

include

linux

usb

usb_phy_generic.h

+9 -3

drivers/usb/musb/am35x.c

··· 85 85 struct am35x_glue { 86 86 struct device *dev; 87 87 struct platform_device *musb; 88 + struct platform_device *phy; 88 89 struct clk *phy_clk; 89 90 struct clk *clk; 90 91 }; ··· 504 503 505 504 pdata->platform_ops = &am35x_ops; 506 505 507 - usb_phy_generic_register(); 506 + glue->phy = usb_phy_generic_register(); 507 + if (IS_ERR(glue->phy)) 508 + goto err7; 508 509 platform_set_drvdata(pdev, glue); 509 510 510 511 pinfo = am35x_dev_info; ··· 520 517 if (IS_ERR(musb)) { 521 518 ret = PTR_ERR(musb); 522 519 dev_err(&pdev->dev, "failed to register musb device: %d\n", ret); 523 - goto err7; 520 + goto err8; 524 521 } 525 522 526 523 return 0; 524 + 525 + err8: 526 + usb_phy_generic_unregister(glue->phy); 527 527 528 528 err7: 529 529 clk_disable(clk); ··· 552 546 struct am35x_glue *glue = platform_get_drvdata(pdev); 553 547 554 548 platform_device_unregister(glue->musb); 555 - usb_phy_generic_unregister(); 549 + usb_phy_generic_unregister(glue->phy); 556 550 clk_disable(glue->clk); 557 551 clk_disable(glue->phy_clk); 558 552 clk_put(glue->clk);

+8 -2

drivers/usb/musb/blackfin.c

··· 29 29 struct bfin_glue { 30 30 struct device *dev; 31 31 struct platform_device *musb; 32 + struct platform_device *phy; 32 33 }; 33 34 #define glue_to_musb(g) platform_get_drvdata(g->musb) 34 35 ··· 476 475 477 476 pdata->platform_ops = &bfin_ops; 478 477 479 - usb_phy_generic_register(); 478 + glue->phy = usb_phy_generic_register(); 479 + if (IS_ERR(glue->phy)) 480 + goto err2; 480 481 platform_set_drvdata(pdev, glue); 481 482 482 483 memset(musb_resources, 0x00, sizeof(*musb_resources) * ··· 516 513 return 0; 517 514 518 515 err3: 516 + usb_phy_generic_unregister(glue->phy); 517 + 518 + err2: 519 519 platform_device_put(musb); 520 520 521 521 err1: ··· 533 527 struct bfin_glue *glue = platform_get_drvdata(pdev); 534 528 535 529 platform_device_unregister(glue->musb); 536 - usb_phy_generic_unregister(); 530 + usb_phy_generic_unregister(glue->phy); 537 531 kfree(glue); 538 532 539 533 return 0;

+11 -3

drivers/usb/musb/da8xx.c

··· 85 85 struct da8xx_glue { 86 86 struct device *dev; 87 87 struct platform_device *musb; 88 + struct platform_device *phy; 88 89 struct clk *clk; 89 90 }; 90 91 ··· 511 510 512 511 pdata->platform_ops = &da8xx_ops; 513 512 514 - usb_phy_generic_register(); 513 + glue->phy = usb_phy_generic_register(); 514 + if (IS_ERR(glue->phy)) { 515 + ret = PTR_ERR(glue->phy); 516 + goto err5; 517 + } 515 518 platform_set_drvdata(pdev, glue); 516 519 517 520 memset(musb_resources, 0x00, sizeof(*musb_resources) * ··· 542 537 if (IS_ERR(musb)) { 543 538 ret = PTR_ERR(musb); 544 539 dev_err(&pdev->dev, "failed to register musb device: %d\n", ret); 545 - goto err5; 540 + goto err6; 546 541 } 547 542 548 543 return 0; 544 + 545 + err6: 546 + usb_phy_generic_unregister(glue->phy); 549 547 550 548 err5: 551 549 clk_disable(clk); ··· 568 560 struct da8xx_glue *glue = platform_get_drvdata(pdev); 569 561 570 562 platform_device_unregister(glue->musb); 571 - usb_phy_generic_unregister(); 563 + usb_phy_generic_unregister(glue->phy); 572 564 clk_disable(glue->clk); 573 565 clk_put(glue->clk); 574 566 kfree(glue);

+2 -1

drivers/usb/musb/tusb6010.c

··· 31 31 struct tusb6010_glue { 32 32 struct device *dev; 33 33 struct platform_device *musb; 34 + struct platform_device *phy; 34 35 }; 35 36 36 37 static void tusb_musb_set_vbus(struct musb *musb, int is_on); ··· 1223 1222 struct tusb6010_glue *glue = platform_get_drvdata(pdev); 1224 1223 1225 1224 platform_device_unregister(glue->musb); 1226 - usb_phy_generic_unregister(); 1225 + usb_phy_generic_unregister(glue->phy); 1227 1226 kfree(glue); 1228 1227 1229 1228 return 0;

+5 -14

drivers/usb/phy/phy-generic.c

··· 41 41 42 42 #include "phy-generic.h" 43 43 44 - static struct platform_device *pd; 45 - 46 - void usb_phy_generic_register(void) 44 + struct platform_device *usb_phy_generic_register(void) 47 45 { 48 - if (pd) 49 - return; 50 - pd = platform_device_register_simple("usb_phy_generic", -1, NULL, 0); 51 - if (IS_ERR(pd)) { 52 - pr_err("Unable to register generic usb transceiver\n"); 53 - pd = NULL; 54 - return; 55 - } 46 + return platform_device_register_simple("usb_phy_generic", 47 + PLATFORM_DEVID_AUTO, NULL, 0); 56 48 } 57 49 EXPORT_SYMBOL_GPL(usb_phy_generic_register); 58 50 59 - void usb_phy_generic_unregister(void) 51 + void usb_phy_generic_unregister(struct platform_device *pdev) 60 52 { 61 - platform_device_unregister(pd); 62 - pd = NULL; 53 + platform_device_unregister(pdev); 63 54 } 64 55 EXPORT_SYMBOL_GPL(usb_phy_generic_unregister); 65 56

+5 -4

include/linux/usb/usb_phy_generic.h

··· 15 15 16 16 #if defined(CONFIG_NOP_USB_XCEIV) || (defined(CONFIG_NOP_USB_XCEIV_MODULE) && defined(MODULE)) 17 17 /* sometimes transceivers are accessed only through e.g. ULPI */ 18 - extern void usb_phy_generic_register(void); 19 - extern void usb_phy_generic_unregister(void); 18 + extern struct platform_device *usb_phy_generic_register(void); 19 + extern void usb_phy_generic_unregister(struct platform_device *); 20 20 #else 21 - static inline void usb_phy_generic_register(void) 21 + static inline struct platform_device *usb_phy_generic_register(void) 22 22 { 23 + return NULL; 23 24 } 24 25 25 - static inline void usb_phy_generic_unregister(void) 26 + static inline void usb_phy_generic_unregister(struct platform_device *pdev) 26 27 { 27 28 } 28 29 #endif