openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'merge' of git://git.secretlab.ca/git/linux-2.6 

* 'merge' of git://git.secretlab.ca/git/linux-2.6:
  of/powerpc: fix fsl_msi device node pointer
  of/watchdog: gef_wdt.c: fix build breakage
  of/edac: fix build breakage in drivers
  of/net: fs_enet/mii-bitbang.c: fix build breakage
  of/usb: fsl_qe_udc.c: fix build breakage
  of/crypto: crypto4xx_core.c: fix build breakage
  of/dma: fix build breakage in ppc4xx adma driver
  of/mtd: nand: fix build breakage in drivers
  of/video: fix build breakage in FB drivers
  of/pcmcia: m8xx_pcmcia.c: Fix build failures
  of/rtc: rtc-mpc5121.c: Fix build failures
  of/dma: mpc512x_dma.c: Fix build failures
  of/mtd/nand: mpc5121_nfc.c: Fix build failures
  of/spi: mpc512x_psc_spi.c: Fix build failures
  watchdog: Fix build failure with OF changes
  of/spi: Fix build failure on spi_ppc4xx.c
  of/usb: fix build error due to of_node pointer move
  of/powerpc: fix 85xx RapidIO device node pointer
This commit is contained in:
Linus Torvalds 2010-06-03 07:17:31 -07:00
parent a57ee62749 ee227c577c
commit a652883a24
26 changed files with 67 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/powerpc/sysdev/fsl_msi.c
View File

@ -347,7 +347,7 @@ static int __devinit fsl_of_msi_probe(struct of_device *dev,
goto error_out; goto error_out;
} }
offset = 0; offset = 0;
p = of_get_property(dev->node, "msi-available-ranges", &len); p = of_get_property(dev->dev.of_node, "msi-available-ranges", &len);
if (p) if (p)
offset = *p / IRQS_PER_MSI_REG; offset = *p / IRQS_PER_MSI_REG;

2
arch/powerpc/sysdev/fsl_rio.c
View File

@ -1426,7 +1426,7 @@ int fsl_rio_setup(struct of_device *dev)
port->iores.flags = IORESOURCE_MEM; port->iores.flags = IORESOURCE_MEM;
port->iores.name = "rio_io_win"; port->iores.name = "rio_io_win";
priv->pwirq = irq_of_parse_and_map(dev->node, 0); priv->pwirq = irq_of_parse_and_map(dev->dev.of_node, 0);
priv->bellirq = irq_of_parse_and_map(dev->dev.of_node, 2); priv->bellirq = irq_of_parse_and_map(dev->dev.of_node, 2);
priv->txirq = irq_of_parse_and_map(dev->dev.of_node, 3); priv->txirq = irq_of_parse_and_map(dev->dev.of_node, 3);
priv->rxirq = irq_of_parse_and_map(dev->dev.of_node, 4); priv->rxirq = irq_of_parse_and_map(dev->dev.of_node, 4);

6
drivers/crypto/amcc/crypto4xx_core.c
View File

@ -1158,7 +1158,7 @@ static int __init crypto4xx_probe(struct of_device *ofdev,
struct device *dev = &ofdev->dev; struct device *dev = &ofdev->dev;
struct crypto4xx_core_device *core_dev; struct crypto4xx_core_device *core_dev;
rc = of_address_to_resource(ofdev->node, 0, &res); rc = of_address_to_resource(ofdev->dev.of_node, 0, &res);
if (rc) if (rc)
return -ENODEV; return -ENODEV;
@ -1215,13 +1215,13 @@ static int __init crypto4xx_probe(struct of_device *ofdev,
(unsigned long) dev); (unsigned long) dev);
/* Register for Crypto isr, Crypto Engine IRQ */ /* Register for Crypto isr, Crypto Engine IRQ */
core_dev->irq = irq_of_parse_and_map(ofdev->node, 0); core_dev->irq = irq_of_parse_and_map(ofdev->dev.of_node, 0);
rc = request_irq(core_dev->irq, crypto4xx_ce_interrupt_handler, 0, rc = request_irq(core_dev->irq, crypto4xx_ce_interrupt_handler, 0,
core_dev->dev->name, dev); core_dev->dev->name, dev);
if (rc) if (rc)
goto err_request_irq; goto err_request_irq;
core_dev->dev->ce_base = of_iomap(ofdev->node, 0); core_dev->dev->ce_base = of_iomap(ofdev->dev.of_node, 0);
if (!core_dev->dev->ce_base) { if (!core_dev->dev->ce_base) {
dev_err(dev, "failed to of_iomap\n"); dev_err(dev, "failed to of_iomap\n");
goto err_iomap; goto err_iomap;

10
drivers/dma/mpc512x_dma.c
View File

@ -630,7 +630,7 @@ mpc_dma_prep_memcpy(struct dma_chan *chan, dma_addr_t dst, dma_addr_t src,
static int __devinit mpc_dma_probe(struct of_device *op, static int __devinit mpc_dma_probe(struct of_device *op,
const struct of_device_id *match) const struct of_device_id *match)
{ {
struct device_node *dn = op->node; struct device_node *dn = op->dev.of_node;
struct device *dev = &op->dev; struct device *dev = &op->dev;
struct dma_device *dma; struct dma_device *dma;
struct mpc_dma *mdma; struct mpc_dma *mdma;
@ -771,12 +771,12 @@ static struct of_device_id mpc_dma_match[] = {
}; };
static struct of_platform_driver mpc_dma_driver = { static struct of_platform_driver mpc_dma_driver = {
.match_table = mpc_dma_match,
.probe = mpc_dma_probe, .probe = mpc_dma_probe,
.remove = __devexit_p(mpc_dma_remove), .remove = __devexit_p(mpc_dma_remove),
.driver = { .driver = {
.name = DRV_NAME, .name = DRV_NAME,
.owner = THIS_MODULE, .owner = THIS_MODULE,
.of_match_table = mpc_dma_match,
}, },
}; };

4
drivers/dma/ppc4xx/adma.c
View File

@ -4394,7 +4394,7 @@ static void ppc440spe_adma_release_irqs(struct ppc440spe_adma_device *adev,
static int __devinit ppc440spe_adma_probe(struct of_device *ofdev, static int __devinit ppc440spe_adma_probe(struct of_device *ofdev,
const struct of_device_id *match) const struct of_device_id *match)
{ {
struct device_node *np = ofdev->node; struct device_node *np = ofdev->dev.of_node;
struct resource res; struct resource res;
struct ppc440spe_adma_device *adev; struct ppc440spe_adma_device *adev;
struct ppc440spe_adma_chan *chan; struct ppc440spe_adma_chan *chan;
@ -4626,7 +4626,7 @@ static int __devinit ppc440spe_adma_probe(struct of_device *ofdev,
static int __devexit ppc440spe_adma_remove(struct of_device *ofdev) static int __devexit ppc440spe_adma_remove(struct of_device *ofdev)
{ {
struct ppc440spe_adma_device *adev = dev_get_drvdata(&ofdev->dev); struct ppc440spe_adma_device *adev = dev_get_drvdata(&ofdev->dev);
struct device_node *np = ofdev->node; struct device_node *np = ofdev->dev.of_node;
struct resource res; struct resource res;
struct dma_chan *chan, *_chan; struct dma_chan *chan, *_chan;
struct ppc_dma_chan_ref *ref, *_ref; struct ppc_dma_chan_ref *ref, *_ref;

12
drivers/edac/mpc85xx_edac.c
View File

@ -229,7 +229,7 @@ static int __devinit mpc85xx_pci_err_probe(struct of_device *op,
pdata->edac_idx = edac_pci_idx++; pdata->edac_idx = edac_pci_idx++;
res = of_address_to_resource(op->node, 0, &r); res = of_address_to_resource(op->dev.of_node, 0, &r);
if (res) { if (res) {
printk(KERN_ERR "%s: Unable to get resource for " printk(KERN_ERR "%s: Unable to get resource for "
"PCI err regs\n", __func__); "PCI err regs\n", __func__);
@ -274,7 +274,7 @@ static int __devinit mpc85xx_pci_err_probe(struct of_device *op,
} }
if (edac_op_state == EDAC_OPSTATE_INT) { if (edac_op_state == EDAC_OPSTATE_INT) {
pdata->irq = irq_of_parse_and_map(op->node, 0); pdata->irq = irq_of_parse_and_map(op->dev.of_node, 0);
res = devm_request_irq(&op->dev, pdata->irq, res = devm_request_irq(&op->dev, pdata->irq,
mpc85xx_pci_isr, IRQF_DISABLED, mpc85xx_pci_isr, IRQF_DISABLED,
"[EDAC] PCI err", pci); "[EDAC] PCI err", pci);
@ -529,7 +529,7 @@ static int __devinit mpc85xx_l2_err_probe(struct of_device *op,
edac_dev->ctl_name = pdata->name; edac_dev->ctl_name = pdata->name;
edac_dev->dev_name = pdata->name; edac_dev->dev_name = pdata->name;
res = of_address_to_resource(op->node, 0, &r); res = of_address_to_resource(op->dev.of_node, 0, &r);
if (res) { if (res) {
printk(KERN_ERR "%s: Unable to get resource for " printk(KERN_ERR "%s: Unable to get resource for "
"L2 err regs\n", __func__); "L2 err regs\n", __func__);
@ -576,7 +576,7 @@ static int __devinit mpc85xx_l2_err_probe(struct of_device *op,
} }
if (edac_op_state == EDAC_OPSTATE_INT) { if (edac_op_state == EDAC_OPSTATE_INT) {
pdata->irq = irq_of_parse_and_map(op->node, 0); pdata->irq = irq_of_parse_and_map(op->dev.of_node, 0);
res = devm_request_irq(&op->dev, pdata->irq, res = devm_request_irq(&op->dev, pdata->irq,
mpc85xx_l2_isr, IRQF_DISABLED, mpc85xx_l2_isr, IRQF_DISABLED,
"[EDAC] L2 err", edac_dev); "[EDAC] L2 err", edac_dev);
@ -978,7 +978,7 @@ static int __devinit mpc85xx_mc_err_probe(struct of_device *op,
mci->ctl_name = pdata->name; mci->ctl_name = pdata->name;
mci->dev_name = pdata->name; mci->dev_name = pdata->name;
res = of_address_to_resource(op->node, 0, &r); res = of_address_to_resource(op->dev.of_node, 0, &r);
if (res) { if (res) {
printk(KERN_ERR "%s: Unable to get resource for MC err regs\n", printk(KERN_ERR "%s: Unable to get resource for MC err regs\n",
__func__); __func__);
@ -1052,7 +1052,7 @@ static int __devinit mpc85xx_mc_err_probe(struct of_device *op,
out_be32(pdata->mc_vbase + MPC85XX_MC_ERR_SBE, 0x10000); out_be32(pdata->mc_vbase + MPC85XX_MC_ERR_SBE, 0x10000);
/* register interrupts */ /* register interrupts */
pdata->irq = irq_of_parse_and_map(op->node, 0); pdata->irq = irq_of_parse_and_map(op->dev.of_node, 0);
res = devm_request_irq(&op->dev, pdata->irq, res = devm_request_irq(&op->dev, pdata->irq,
mpc85xx_mc_isr, mpc85xx_mc_isr,
IRQF_DISABLED | IRQF_SHARED, IRQF_DISABLED | IRQF_SHARED,

6
drivers/edac/ppc4xx_edac.c
View File

@ -1022,7 +1022,7 @@ ppc4xx_edac_mc_init(struct mem_ctl_info *mci,
int status = 0; int status = 0;
const u32 memcheck = (mcopt1 & SDRAM_MCOPT1_MCHK_MASK); const u32 memcheck = (mcopt1 & SDRAM_MCOPT1_MCHK_MASK);
struct ppc4xx_edac_pdata *pdata = NULL; struct ppc4xx_edac_pdata *pdata = NULL;
const struct device_node *np = op->node; const struct device_node *np = op->dev.of_node;
if (match == NULL) if (match == NULL)
return -EINVAL; return -EINVAL;
@ -1113,7 +1113,7 @@ ppc4xx_edac_register_irq(struct of_device *op, struct mem_ctl_info *mci)
int status = 0; int status = 0;
int ded_irq, sec_irq; int ded_irq, sec_irq;
struct ppc4xx_edac_pdata *pdata = mci->pvt_info; struct ppc4xx_edac_pdata *pdata = mci->pvt_info;
struct device_node *np = op->node; struct device_node *np = op->dev.of_node;
ded_irq = irq_of_parse_and_map(np, INTMAP_ECCDED_INDEX); ded_irq = irq_of_parse_and_map(np, INTMAP_ECCDED_INDEX);
sec_irq = irq_of_parse_and_map(np, INTMAP_ECCSEC_INDEX); sec_irq = irq_of_parse_and_map(np, INTMAP_ECCSEC_INDEX);
@ -1243,7 +1243,7 @@ ppc4xx_edac_probe(struct of_device *op, const struct of_device_id *match)
int status = 0; int status = 0;
u32 mcopt1, memcheck; u32 mcopt1, memcheck;
dcr_host_t dcr_host; dcr_host_t dcr_host;
const struct device_node *np = op->node; const struct device_node *np = op->dev.of_node;
struct mem_ctl_info *mci = NULL; struct mem_ctl_info *mci = NULL;
static int ppc4xx_edac_instance; static int ppc4xx_edac_instance;

17
drivers/mtd/nand/fsl_upm.c
View File

@ -232,7 +232,7 @@ static int __devinit fun_probe(struct of_device *ofdev,
if (!fun) if (!fun)
return -ENOMEM; return -ENOMEM;
ret = of_address_to_resource(ofdev->node, 0, &io_res); ret = of_address_to_resource(ofdev->dev.of_node, 0, &io_res);
if (ret) { if (ret) {
dev_err(&ofdev->dev, "can't get IO base\n"); dev_err(&ofdev->dev, "can't get IO base\n");
goto err1; goto err1;
@ -244,7 +244,8 @@ static int __devinit fun_probe(struct of_device *ofdev,
goto err1; goto err1;
} }
prop = of_get_property(ofdev->node, "fsl,upm-addr-offset", &size); prop = of_get_property(ofdev->dev.of_node, "fsl,upm-addr-offset",
&size);
if (!prop || size != sizeof(uint32_t)) { if (!prop || size != sizeof(uint32_t)) {
dev_err(&ofdev->dev, "can't get UPM address offset\n"); dev_err(&ofdev->dev, "can't get UPM address offset\n");
ret = -EINVAL; ret = -EINVAL;
@ -252,7 +253,7 @@ static int __devinit fun_probe(struct of_device *ofdev,
} }
fun->upm_addr_offset = *prop; fun->upm_addr_offset = *prop;
prop = of_get_property(ofdev->node, "fsl,upm-cmd-offset", &size); prop = of_get_property(ofdev->dev.of_node, "fsl,upm-cmd-offset", &size);
if (!prop || size != sizeof(uint32_t)) { if (!prop || size != sizeof(uint32_t)) {
dev_err(&ofdev->dev, "can't get UPM command offset\n"); dev_err(&ofdev->dev, "can't get UPM command offset\n");
ret = -EINVAL; ret = -EINVAL;
@ -260,7 +261,7 @@ static int __devinit fun_probe(struct of_device *ofdev,
} }
fun->upm_cmd_offset = *prop; fun->upm_cmd_offset = *prop;
prop = of_get_property(ofdev->node, prop = of_get_property(ofdev->dev.of_node,
"fsl,upm-addr-line-cs-offsets", &size); "fsl,upm-addr-line-cs-offsets", &size);
if (prop && (size / sizeof(uint32_t)) > 0) { if (prop && (size / sizeof(uint32_t)) > 0) {
fun->mchip_count = size / sizeof(uint32_t); fun->mchip_count = size / sizeof(uint32_t);
@ -276,7 +277,7 @@ static int __devinit fun_probe(struct of_device *ofdev,
for (i = 0; i < fun->mchip_count; i++) { for (i = 0; i < fun->mchip_count; i++) {
fun->rnb_gpio[i] = -1; fun->rnb_gpio[i] = -1;
rnb_gpio = of_get_gpio(ofdev->node, i); rnb_gpio = of_get_gpio(ofdev->dev.of_node, i);
if (rnb_gpio >= 0) { if (rnb_gpio >= 0) {
ret = gpio_request(rnb_gpio, dev_name(&ofdev->dev)); ret = gpio_request(rnb_gpio, dev_name(&ofdev->dev));
if (ret) { if (ret) {
@ -292,13 +293,13 @@ static int __devinit fun_probe(struct of_device *ofdev,
} }
} }
prop = of_get_property(ofdev->node, "chip-delay", NULL); prop = of_get_property(ofdev->dev.of_node, "chip-delay", NULL);
if (prop) if (prop)
fun->chip_delay = *prop; fun->chip_delay = *prop;
else else
fun->chip_delay = 50; fun->chip_delay = 50;
prop = of_get_property(ofdev->node, "fsl,upm-wait-flags", &size); prop = of_get_property(ofdev->dev.of_node, "fsl,upm-wait-flags", &size);
if (prop && size == sizeof(uint32_t)) if (prop && size == sizeof(uint32_t))
fun->wait_flags = *prop; fun->wait_flags = *prop;
else else
@ -315,7 +316,7 @@ static int __devinit fun_probe(struct of_device *ofdev,
fun->dev = &ofdev->dev; fun->dev = &ofdev->dev;
fun->last_ctrl = NAND_CLE; fun->last_ctrl = NAND_CLE;
ret = fun_chip_init(fun, ofdev->node, &io_res); ret = fun_chip_init(fun, ofdev->dev.of_node, &io_res);
if (ret) if (ret)
goto err2; goto err2;

8
drivers/mtd/nand/mpc5121_nfc.c
View File

@ -650,7 +650,7 @@ static void mpc5121_nfc_free(struct device *dev, struct mtd_info *mtd)
static int __devinit mpc5121_nfc_probe(struct of_device *op, static int __devinit mpc5121_nfc_probe(struct of_device *op,
const struct of_device_id *match) const struct of_device_id *match)
{ {
struct device_node *rootnode, *dn = op->node; struct device_node *rootnode, *dn = op->dev.of_node;
struct device *dev = &op->dev; struct device *dev = &op->dev;
struct mpc5121_nfc_prv *prv; struct mpc5121_nfc_prv *prv;
struct resource res; struct resource res;
@ -889,12 +889,12 @@ static struct of_device_id mpc5121_nfc_match[] __devinitdata = {
}; };
static struct of_platform_driver mpc5121_nfc_driver = { static struct of_platform_driver mpc5121_nfc_driver = {
.match_table = mpc5121_nfc_match,
.probe = mpc5121_nfc_probe, .probe = mpc5121_nfc_probe,
.remove = __devexit_p(mpc5121_nfc_remove), .remove = __devexit_p(mpc5121_nfc_remove),
.driver = { .driver = {
.name = DRV_NAME, .name = DRV_NAME,
.owner = THIS_MODULE, .owner = THIS_MODULE,
.of_match_table = mpc5121_nfc_match,
}, },
}; };

4
drivers/mtd/nand/socrates_nand.c
View File

@ -183,7 +183,7 @@ static int __devinit socrates_nand_probe(struct of_device *ofdev,
return -ENOMEM; return -ENOMEM;
} }
host->io_base = of_iomap(ofdev->node, 0); host->io_base = of_iomap(ofdev->dev.of_node, 0);
if (host->io_base == NULL) { if (host->io_base == NULL) {
printk(KERN_ERR "socrates_nand: ioremap failed\n"); printk(KERN_ERR "socrates_nand: ioremap failed\n");
kfree(host); kfree(host);
@ -244,7 +244,7 @@ static int __devinit socrates_nand_probe(struct of_device *ofdev,
#ifdef CONFIG_MTD_OF_PARTS #ifdef CONFIG_MTD_OF_PARTS
if (num_partitions == 0) { if (num_partitions == 0) {
num_partitions = of_mtd_parse_partitions(&ofdev->dev, num_partitions = of_mtd_parse_partitions(&ofdev->dev,
ofdev->node, ofdev->dev.of_node,
&partitions); &partitions);
if (num_partitions < 0) { if (num_partitions < 0) {
res = num_partitions; res = num_partitions;

4
drivers/net/fs_enet/mii-bitbang.c
View File

@ -169,7 +169,7 @@ static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
new_bus->name = "CPM2 Bitbanged MII", new_bus->name = "CPM2 Bitbanged MII",
ret = fs_mii_bitbang_init(new_bus, ofdev->node); ret = fs_mii_bitbang_init(new_bus, ofdev->dev.of_node);
if (ret) if (ret)
goto out_free_bus; goto out_free_bus;
@ -181,7 +181,7 @@ static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
new_bus->parent = &ofdev->dev; new_bus->parent = &ofdev->dev;
dev_set_drvdata(&ofdev->dev, new_bus); dev_set_drvdata(&ofdev->dev, new_bus);
ret = of_mdiobus_register(new_bus, ofdev->node); ret = of_mdiobus_register(new_bus, ofdev->dev.of_node);
if (ret) if (ret)
goto out_free_irqs; goto out_free_irqs;

4
drivers/pcmcia/m8xx_pcmcia.c
View File

@ -1157,7 +1157,7 @@ static int __init m8xx_probe(struct of_device *ofdev,
unsigned int i, m, hwirq; unsigned int i, m, hwirq;
pcmconf8xx_t *pcmcia; pcmconf8xx_t *pcmcia;
int status; int status;
struct device_node *np = ofdev->node; struct device_node *np = ofdev->dev.of_node;
pcmcia_info("%s\n", version); pcmcia_info("%s\n", version);
@ -1301,7 +1301,7 @@ static struct of_platform_driver m8xx_pcmcia_driver = {
.driver = { .driver = {
.name = driver_name, .name = driver_name,
.owner = THIS_MODULE, .owner = THIS_MODULE,
.match_table = m8xx_pcmcia_match, .of_match_table = m8xx_pcmcia_match,
}, },
.probe = m8xx_probe, .probe = m8xx_probe,
.remove = m8xx_remove, .remove = m8xx_remove,

14
drivers/rtc/rtc-mpc5121.c
View File

@ -279,7 +279,7 @@ static int __devinit mpc5121_rtc_probe(struct of_device *op,
if (!rtc) if (!rtc)
return -ENOMEM; return -ENOMEM;
rtc->regs = of_iomap(op->node, 0); rtc->regs = of_iomap(op->dev.of_node, 0);
if (!rtc->regs) { if (!rtc->regs) {
dev_err(&op->dev, "%s: couldn't map io space\n", __func__); dev_err(&op->dev, "%s: couldn't map io space\n", __func__);
err = -ENOSYS; err = -ENOSYS;
@ -290,7 +290,7 @@ static int __devinit mpc5121_rtc_probe(struct of_device *op,
dev_set_drvdata(&op->dev, rtc); dev_set_drvdata(&op->dev, rtc);
rtc->irq = irq_of_parse_and_map(op->node, 1); rtc->irq = irq_of_parse_and_map(op->dev.of_node, 1);
err = request_irq(rtc->irq, mpc5121_rtc_handler, IRQF_DISABLED, err = request_irq(rtc->irq, mpc5121_rtc_handler, IRQF_DISABLED,
"mpc5121-rtc", &op->dev); "mpc5121-rtc", &op->dev);
if (err) { if (err) {
@ -299,7 +299,7 @@ static int __devinit mpc5121_rtc_probe(struct of_device *op,
goto out_dispose; goto out_dispose;
} }
rtc->irq_periodic = irq_of_parse_and_map(op->node, 0); rtc->irq_periodic = irq_of_parse_and_map(op->dev.of_node, 0);
err = request_irq(rtc->irq_periodic, mpc5121_rtc_handler_upd, err = request_irq(rtc->irq_periodic, mpc5121_rtc_handler_upd,
IRQF_DISABLED, "mpc5121-rtc_upd", &op->dev); IRQF_DISABLED, "mpc5121-rtc_upd", &op->dev);
if (err) { if (err) {
@ -365,9 +365,11 @@ static struct of_device_id mpc5121_rtc_match[] __devinitdata = {
}; };
static struct of_platform_driver mpc5121_rtc_driver = { static struct of_platform_driver mpc5121_rtc_driver = {
.owner = THIS_MODULE, .driver = {
.name = "mpc5121-rtc", .name = "mpc5121-rtc",
.match_table = mpc5121_rtc_match, .owner = THIS_MODULE,
.of_match_table = mpc5121_rtc_match,
},
.probe = mpc5121_rtc_probe, .probe = mpc5121_rtc_probe,
.remove = __devexit_p(mpc5121_rtc_remove), .remove = __devexit_p(mpc5121_rtc_remove),
}; };

12
drivers/spi/mpc512x_psc_spi.c
View File

@ -512,29 +512,29 @@ static int __init mpc512x_psc_spi_of_probe(struct of_device *op,
u64 regaddr64, size64; u64 regaddr64, size64;
s16 id = -1; s16 id = -1;
regaddr_p = of_get_address(op->node, 0, &size64, NULL); regaddr_p = of_get_address(op->dev.of_node, 0, &size64, NULL);
if (!regaddr_p) { if (!regaddr_p) {
dev_err(&op->dev, "Invalid PSC address\n"); dev_err(&op->dev, "Invalid PSC address\n");
return -EINVAL; return -EINVAL;
} }
regaddr64 = of_translate_address(op->node, regaddr_p); regaddr64 = of_translate_address(op->dev.of_node, regaddr_p);
/* get PSC id (0..11, used by port_config) */ /* get PSC id (0..11, used by port_config) */
if (op->dev.platform_data == NULL) { if (op->dev.platform_data == NULL) {
const u32 *psc_nump; const u32 *psc_nump;
psc_nump = of_get_property(op->node, "cell-index", NULL); psc_nump = of_get_property(op->dev.of_node, "cell-index", NULL);
if (!psc_nump || *psc_nump > 11) { if (!psc_nump || *psc_nump > 11) {
dev_err(&op->dev, "mpc512x_psc_spi: Device node %s " dev_err(&op->dev, "mpc512x_psc_spi: Device node %s "
"has invalid cell-index property\n", "has invalid cell-index property\n",
op->node->full_name); op->dev.of_node->full_name);
return -EINVAL; return -EINVAL;
} }
id = *psc_nump; id = *psc_nump;
} }
return mpc512x_psc_spi_do_probe(&op->dev, (u32) regaddr64, (u32) size64, return mpc512x_psc_spi_do_probe(&op->dev, (u32) regaddr64, (u32) size64,
irq_of_parse_and_map(op->node, 0), id); irq_of_parse_and_map(op->dev.of_node, 0), id);
} }
static int __exit mpc512x_psc_spi_of_remove(struct of_device *op) static int __exit mpc512x_psc_spi_of_remove(struct of_device *op)
@ -550,12 +550,12 @@ static struct of_device_id mpc512x_psc_spi_of_match[] = {
MODULE_DEVICE_TABLE(of, mpc512x_psc_spi_of_match); MODULE_DEVICE_TABLE(of, mpc512x_psc_spi_of_match);
static struct of_platform_driver mpc512x_psc_spi_of_driver = { static struct of_platform_driver mpc512x_psc_spi_of_driver = {
.match_table = mpc512x_psc_spi_of_match,
.probe = mpc512x_psc_spi_of_probe, .probe = mpc512x_psc_spi_of_probe,
.remove = __exit_p(mpc512x_psc_spi_of_remove), .remove = __exit_p(mpc512x_psc_spi_of_remove),
.driver = { .driver = {
.name = "mpc512x-psc-spi", .name = "mpc512x-psc-spi",
.owner = THIS_MODULE, .owner = THIS_MODULE,
.of_match_table = mpc512x_psc_spi_of_match,
}, },
}; };

2
drivers/spi/spi_ppc4xx.c
View File

@ -397,7 +397,7 @@ static int __init spi_ppc4xx_of_probe(struct of_device *op,
struct spi_master *master; struct spi_master *master;
struct spi_bitbang *bbp; struct spi_bitbang *bbp;
struct resource resource; struct resource resource;
struct device_node *np = op->node; struct device_node *np = op->dev.of_node;
struct device *dev = &op->dev; struct device *dev = &op->dev;
struct device_node *opbnp; struct device_node *opbnp;
int ret; int ret;

4
drivers/usb/gadget/fsl_qe_udc.c
View File

@ -2400,7 +2400,7 @@ EXPORT_SYMBOL(usb_gadget_unregister_driver);
static struct qe_udc __devinit *qe_udc_config(struct of_device *ofdev) static struct qe_udc __devinit *qe_udc_config(struct of_device *ofdev)
{ {
struct qe_udc *udc; struct qe_udc *udc;
struct device_node *np = ofdev->node; struct device_node *np = ofdev->dev.of_node;
unsigned int tmp_addr = 0; unsigned int tmp_addr = 0;
struct usb_device_para __iomem *usbpram; struct usb_device_para __iomem *usbpram;
unsigned int i; unsigned int i;
@ -2525,7 +2525,7 @@ static void qe_udc_release(struct device *dev)
static int __devinit qe_udc_probe(struct of_device *ofdev, static int __devinit qe_udc_probe(struct of_device *ofdev,
const struct of_device_id *match) const struct of_device_id *match)
{ {
struct device_node *np = ofdev->node; struct device_node *np = ofdev->dev.of_node;
struct qe_ep *ep; struct qe_ep *ep;
unsigned int ret = 0; unsigned int ret = 0;
unsigned int i; unsigned int i;

2
drivers/usb/host/ehci-xilinx-of.c
View File

@ -151,7 +151,7 @@ static const struct hc_driver ehci_xilinx_of_hc_driver = {
static int __devinit static int __devinit
ehci_hcd_xilinx_of_probe(struct of_device *op, const struct of_device_id *match) ehci_hcd_xilinx_of_probe(struct of_device *op, const struct of_device_id *match)
{ {
struct device_node *dn = op->node; struct device_node *dn = op->dev.of_node;
struct usb_hcd *hcd; struct usb_hcd *hcd;
struct ehci_hcd *ehci; struct ehci_hcd *ehci;
struct resource res; struct resource res;

2
drivers/video/bw2.c
View File

@ -275,7 +275,7 @@ static int __devinit bw2_do_default_mode(struct bw2_par *par,
static int __devinit bw2_probe(struct of_device *op, const struct of_device_id *match) static int __devinit bw2_probe(struct of_device *op, const struct of_device_id *match)
{ {
struct device_node *dp = op->node; struct device_node *dp = op->dev.of_node;
struct fb_info *info; struct fb_info *info;
struct bw2_par *par; struct bw2_par *par;
int linebytes, err; int linebytes, err;

2
drivers/video/cg14.c
View File

@ -465,7 +465,7 @@ static void cg14_unmap_regs(struct of_device *op, struct fb_info *info,
static int __devinit cg14_probe(struct of_device *op, const struct of_device_id *match) static int __devinit cg14_probe(struct of_device *op, const struct of_device_id *match)
{ {
struct device_node *dp = op->node; struct device_node *dp = op->dev.of_node;
struct fb_info *info; struct fb_info *info;
struct cg14_par *par; struct cg14_par *par;
int is_8mb, linebytes, i, err; int is_8mb, linebytes, i, err;

2
drivers/video/cg3.c
View File

@ -349,7 +349,7 @@ static int __devinit cg3_do_default_mode(struct cg3_par *par)
static int __devinit cg3_probe(struct of_device *op, static int __devinit cg3_probe(struct of_device *op,
const struct of_device_id *match) const struct of_device_id *match)
{ {
struct device_node *dp = op->node; struct device_node *dp = op->dev.of_node;
struct fb_info *info; struct fb_info *info;
struct cg3_par *par; struct cg3_par *par;
int linebytes, err; int linebytes, err;

2
drivers/video/leo.c
View File

@ -550,7 +550,7 @@ static void leo_unmap_regs(struct of_device *op, struct fb_info *info,
static int __devinit leo_probe(struct of_device *op, static int __devinit leo_probe(struct of_device *op,
const struct of_device_id *match) const struct of_device_id *match)
{ {
struct device_node *dp = op->node; struct device_node *dp = op->dev.of_node;
struct fb_info *info; struct fb_info *info;
struct leo_par *par; struct leo_par *par;
int linebytes, err; int linebytes, err;

2
drivers/video/mb862xx/mb862xxfb.c
View File

@ -553,7 +553,7 @@ static int mb862xx_gdc_init(struct mb862xxfb_par *par)
static int __devinit of_platform_mb862xx_probe(struct of_device *ofdev, static int __devinit of_platform_mb862xx_probe(struct of_device *ofdev,
const struct of_device_id *id) const struct of_device_id *id)
{ {
struct device_node *np = ofdev->node; struct device_node *np = ofdev->dev.of_node;
struct device *dev = &ofdev->dev; struct device *dev = &ofdev->dev;
struct mb862xxfb_par *par; struct mb862xxfb_par *par;
struct fb_info *info; struct fb_info *info;

2
drivers/video/p9100.c
View File

@ -251,7 +251,7 @@ static void p9100_init_fix(struct fb_info *info, int linebytes, struct device_no
static int __devinit p9100_probe(struct of_device *op, const struct of_device_id *match) static int __devinit p9100_probe(struct of_device *op, const struct of_device_id *match)
{ {
struct device_node *dp = op->node; struct device_node *dp = op->dev.of_node;
struct fb_info *info; struct fb_info *info;
struct p9100_par *par; struct p9100_par *par;
int linebytes, err; int linebytes, err;

2
drivers/video/tcx.c
View File

@ -365,7 +365,7 @@ static void tcx_unmap_regs(struct of_device *op, struct fb_info *info,
static int __devinit tcx_probe(struct of_device *op, static int __devinit tcx_probe(struct of_device *op,
const struct of_device_id *match) const struct of_device_id *match)
{ {
struct device_node *dp = op->node; struct device_node *dp = op->dev.of_node;
struct fb_info *info; struct fb_info *info;
struct tcx_par *par; struct tcx_par *par;
int linebytes, i, err; int linebytes, i, err;

2
drivers/watchdog/gef_wdt.c
View File

@ -273,7 +273,7 @@ static int __devinit gef_wdt_probe(struct of_device *dev,
bus_clk = freq; bus_clk = freq;
/* Map devices registers into memory */ /* Map devices registers into memory */
gef_wdt_regs = of_iomap(dev->node, 0); gef_wdt_regs = of_iomap(dev->dev.of_node, 0);
if (gef_wdt_regs == NULL) if (gef_wdt_regs == NULL)
return -ENOMEM; return -ENOMEM;

2
drivers/watchdog/mpc8xxx_wdt.c
View File

@ -189,7 +189,7 @@ static int __devinit mpc8xxx_wdt_probe(struct of_device *ofdev,
const struct of_device_id *match) const struct of_device_id *match)
{ {
int ret; int ret;
struct device_node *np = ofdev->node; struct device_node *np = ofdev->dev.of_node;
struct mpc8xxx_wdt_type *wdt_type = match->data; struct mpc8xxx_wdt_type *wdt_type = match->data;
u32 freq = fsl_get_sys_freq(); u32 freq = fsl_get_sys_freq();
bool enabled; bool enabled;