int             retval;
        struct resource *res;
 
-       if (!dev->platform_data && !pdev->dev.of_node) {
+       if (!dev_get_platdata(dev) && !pdev->dev.of_node) {
                /* small (so we copy it) but critical! */
                DBG("missing platform_data\n");
                return -ENODEV;
        if (IS_ENABLED(CONFIG_OF) && pdev->dev.of_node)
                at91udc_of_init(udc, pdev->dev.of_node);
        else
-               memcpy(&udc->board, dev->platform_data,
+               memcpy(&udc->board, dev_get_platdata(dev),
                       sizeof(struct at91_udc_data));
        udc->pdev = pdev;
        udc->enabled = 0;
 
 static struct usba_ep * usba_udc_pdata(struct platform_device *pdev,
                                                 struct usba_udc *udc)
 {
-       struct usba_platform_data *pdata = pdev->dev.platform_data;
+       struct usba_platform_data *pdata = dev_get_platdata(&pdev->dev);
        struct usba_ep *eps;
        int i;
 
 
 static int bcm63xx_udc_probe(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
-       struct bcm63xx_usbd_platform_data *pd = dev->platform_data;
+       struct bcm63xx_usbd_platform_data *pd = dev_get_platdata(dev);
        struct bcm63xx_udc *udc;
        struct resource *res;
        int rc = -ENOMEM, i, irq;
 
        unsigned long freq;
        int ret;
 
-       pdata = pdev->dev.platform_data;
+       pdata = dev_get_platdata(&pdev->dev);
 
        mxc_ipg_clk = devm_clk_get(&pdev->dev, "ipg");
        if (IS_ERR(mxc_ipg_clk)) {
 
 int fsl_udc_clk_finalize(struct platform_device *pdev)
 {
-       struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+       struct fsl_usb2_platform_data *pdata = dev_get_platdata(&pdev->dev);
        int ret = 0;
 
        /* workaround ENGcm09152 for i.MX35 */
 
        struct fsl_usb2_platform_data *pdata;
        size_t size;
 
-       pdata = pdev->dev.platform_data;
+       pdata = dev_get_platdata(&pdev->dev);
        udc->phy_mode = pdata->phy_mode;
 
        udc->eps = kzalloc(sizeof(struct fsl_ep) * udc->max_ep, GFP_KERNEL);
                return -ENOMEM;
        }
 
-       pdata = pdev->dev.platform_data;
+       pdata = dev_get_platdata(&pdev->dev);
        udc_controller->pdata = pdata;
        spin_lock_init(&udc_controller->lock);
        udc_controller->stopped = 1;
 static int __exit fsl_udc_remove(struct platform_device *pdev)
 {
        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
+       struct fsl_usb2_platform_data *pdata = dev_get_platdata(&pdev->dev);
 
        DECLARE_COMPLETION(done);
 
 
 
 static int __init hidg_plat_driver_probe(struct platform_device *pdev)
 {
-       struct hidg_func_descriptor *func = pdev->dev.platform_data;
+       struct hidg_func_descriptor *func = dev_get_platdata(&pdev->dev);
        struct hidg_func_node *entry;
 
        if (!func) {
 
                goto clean_up;
        }
 
-       if (pdev->dev.platform_data == NULL) {
+       if (dev_get_platdata(&pdev->dev) == NULL) {
                dev_err(&pdev->dev, "no platform data\n");
                ret = -ENODEV;
                goto clean_up;
                goto clean_up;
        }
 
-       m66592->pdata = pdev->dev.platform_data;
+       m66592->pdata = dev_get_platdata(&pdev->dev);
        m66592->irq_trigger = ires->flags & IRQF_TRIGGER_MASK;
 
        spin_lock_init(&m66592->lock);
 
 
 static int mv_u3d_enable(struct mv_u3d *u3d)
 {
-       struct mv_usb_platform_data *pdata = u3d->dev->platform_data;
+       struct mv_usb_platform_data *pdata = dev_get_platdata(u3d->dev);
        int retval;
 
        if (u3d->active)
 
 static void mv_u3d_disable(struct mv_u3d *u3d)
 {
-       struct mv_usb_platform_data *pdata = u3d->dev->platform_data;
+       struct mv_usb_platform_data *pdata = dev_get_platdata(u3d->dev);
        if (u3d->clock_gating && u3d->active) {
                dev_dbg(u3d->dev, "disable u3d\n");
                if (pdata->phy_deinit)
                struct usb_gadget_driver *driver)
 {
        struct mv_u3d *u3d = container_of(g, struct mv_u3d, gadget);
-       struct mv_usb_platform_data *pdata = u3d->dev->platform_data;
+       struct mv_usb_platform_data *pdata = dev_get_platdata(u3d->dev);
        unsigned long flags;
 
        if (u3d->driver)
                struct usb_gadget_driver *driver)
 {
        struct mv_u3d *u3d = container_of(g, struct mv_u3d, gadget);
-       struct mv_usb_platform_data *pdata = u3d->dev->platform_data;
+       struct mv_usb_platform_data *pdata = dev_get_platdata(u3d->dev);
        unsigned long flags;
 
        u3d->vbus_valid_detect = 0;
 static int mv_u3d_probe(struct platform_device *dev)
 {
        struct mv_u3d *u3d = NULL;
-       struct mv_usb_platform_data *pdata = dev->dev.platform_data;
+       struct mv_usb_platform_data *pdata = dev_get_platdata(&dev->dev);
        int retval = 0;
        struct resource *r;
        size_t size;
 
-       if (!dev->dev.platform_data) {
+       if (!dev_get_platdata(&dev->dev)) {
                dev_err(&dev->dev, "missing platform_data\n");
                retval = -ENODEV;
                goto err_pdata;
 
 
 static int mv_udc_probe(struct platform_device *pdev)
 {
-       struct mv_usb_platform_data *pdata = pdev->dev.platform_data;
+       struct mv_usb_platform_data *pdata = dev_get_platdata(&pdev->dev);
        struct mv_udc *udc;
        int retval = 0;
        struct resource *r;
        }
 
        udc->done = &release_done;
-       udc->pdata = pdev->dev.platform_data;
+       udc->pdata = dev_get_platdata(&pdev->dev);
        spin_lock_init(&udc->lock);
 
        udc->dev = pdev;
 
        int                     hmc;
        struct usb_phy          *xceiv = NULL;
        const char              *type = NULL;
-       struct omap_usb_config  *config = pdev->dev.platform_data;
+       struct omap_usb_config  *config = dev_get_platdata(&pdev->dev);
        struct clk              *dc_clk = NULL;
        struct clk              *hhc_clk = NULL;
 
 
 
        /* other non-static parts of init */
        dev->dev = &pdev->dev;
-       dev->mach = pdev->dev.platform_data;
+       dev->mach = dev_get_platdata(&pdev->dev);
 
        dev->transceiver = usb_get_phy(USB_PHY_TYPE_USB2);
 
 
                return udc->irq;
 
        udc->dev = &pdev->dev;
-       udc->mach = pdev->dev.platform_data;
+       udc->mach = dev_get_platdata(&pdev->dev);
        udc->transceiver = usb_get_phy(USB_PHY_TYPE_USB2);
 
        gpio = udc->mach->gpio_pullup;
 
 
        spin_lock_init(&r8a66597->lock);
        platform_set_drvdata(pdev, r8a66597);
-       r8a66597->pdata = pdev->dev.platform_data;
+       r8a66597->pdata = dev_get_platdata(&pdev->dev);
        r8a66597->irq_sense_low = irq_trigger == IRQF_TRIGGER_LOW;
 
        r8a66597->gadget.ops = &r8a66597_gadget_ops;
 
 
 static int s3c_hsotg_probe(struct platform_device *pdev)
 {
-       struct s3c_hsotg_plat *plat = pdev->dev.platform_data;
+       struct s3c_hsotg_plat *plat = dev_get_platdata(&pdev->dev);
        struct usb_phy *phy;
        struct device *dev = &pdev->dev;
        struct s3c_hsotg_ep *eps;
        phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
        if (IS_ERR(phy)) {
                /* Fallback for pdata */
-               plat = pdev->dev.platform_data;
+               plat = dev_get_platdata(&pdev->dev);
                if (!plat) {
                        dev_err(&pdev->dev, "no platform data or transceiver defined\n");
                        return -EPROBE_DEFER;
 
        struct device *dev = &pdev->dev;
        struct resource *res;
        struct s3c_hsudc *hsudc;
-       struct s3c24xx_hsudc_platdata *pd = pdev->dev.platform_data;
+       struct s3c24xx_hsudc_platdata *pd = dev_get_platdata(&pdev->dev);
        int ret, i;
 
        hsudc = devm_kzalloc(&pdev->dev, sizeof(struct s3c_hsudc) +
 
        platform_set_drvdata(pdev, dev);
        hsudc->dev = dev;
-       hsudc->pd = pdev->dev.platform_data;
+       hsudc->pd = dev_get_platdata(&pdev->dev);
 
        hsudc->transceiver = usb_get_phy(USB_PHY_TYPE_USB2);
 
 
        }
 
        spin_lock_init(&udc->lock);
-       udc_info = pdev->dev.platform_data;
+       udc_info = dev_get_platdata(&pdev->dev);
 
        rsrc_start = S3C2410_PA_USBDEV;
        rsrc_len   = S3C24XX_SZ_USBDEV;