static int denali_dt_probe(struct platform_device *pdev) { struct resource *res; struct denali_dt *dt; const struct denali_dt_data *data; struct denali_nand_info *denali; int ret; dt = devm_kzalloc(&pdev->dev, sizeof(*dt), GFP_KERNEL); if (!dt) return -ENOMEM; denali = &dt->denali; data = of_device_get_match_data(&pdev->dev); if (data) { denali->revision = data->revision; denali->caps = data->caps; denali->ecc_caps = data->ecc_caps; } denali->dev = &pdev->dev; denali->irq = platform_get_irq(pdev, 0); if (denali->irq < 0) { dev_err(&pdev->dev, "no irq defined\n"); return denali->irq; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "denali_reg"); denali->reg = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(denali->reg)) return PTR_ERR(denali->reg); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_data"); denali->host = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(denali->host)) return PTR_ERR(denali->host); dt->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(dt->clk)) { dev_err(&pdev->dev, "no clk available\n"); return PTR_ERR(dt->clk); } ret = clk_prepare_enable(dt->clk); if (ret) return ret; denali->clk_x_rate = clk_get_rate(dt->clk); ret = denali_init(denali); if (ret) goto out_disable_clk; platform_set_drvdata(pdev, dt); return 0; out_disable_clk: clk_disable_unprepare(dt->clk); return ret; }
static int __board_nand_init(void) { struct denali_nand_info *denali; denali = kzalloc(sizeof(*denali), GFP_KERNEL); if (!denali) return -ENOMEM; /* * In the future, these base addresses should be taken from * Device Tree or platform data. */ denali->flash_reg = (void __iomem *)CONFIG_SYS_NAND_REGS_BASE; denali->flash_mem = (void __iomem *)CONFIG_SYS_NAND_DATA_BASE; return denali_init(denali); }
static int denali_dt_probe(struct udevice *dev) { struct denali_nand_info *denali = dev_get_priv(dev); const struct denali_dt_data *data; struct clk clk; struct resource res; int ret; data = (void *)dev_get_driver_data(dev); if (data) { denali->revision = data->revision; denali->caps = data->caps; denali->ecc_caps = data->ecc_caps; } denali->dev = dev; ret = dev_read_resource_byname(dev, "denali_reg", &res); if (ret) return ret; denali->reg = devm_ioremap(dev, res.start, resource_size(&res)); ret = dev_read_resource_byname(dev, "nand_data", &res); if (ret) return ret; denali->host = devm_ioremap(dev, res.start, resource_size(&res)); ret = clk_get_by_index(dev, 0, &clk); if (ret) return ret; ret = clk_enable(&clk); if (ret) return ret; denali->clk_x_rate = clk_get_rate(&clk); return denali_init(denali); }
static int __board_nand_init(void) { struct denali_nand_info *denali; denali = kzalloc(sizeof(*denali), GFP_KERNEL); if (!denali) return -ENOMEM; /* * If CONFIG_SYS_NAND_SELF_INIT is defined, each driver is responsible * for instantiating struct nand_chip, while drivers/mtd/nand/nand.c * still provides a "struct mtd_info nand_info" instance. */ denali->mtd = &nand_info[0]; /* * In the future, these base addresses should be taken from * Device Tree or platform data. */ denali->flash_reg = (void __iomem *)CONFIG_SYS_NAND_REGS_BASE; denali->flash_mem = (void __iomem *)CONFIG_SYS_NAND_DATA_BASE; return denali_init(denali); }
static int denali_dt_probe(struct udevice *dev) { struct denali_nand_info *denali = dev_get_priv(dev); const struct denali_dt_data *data; struct clk clk, clk_x, clk_ecc; struct resource res; int ret; data = (void *)dev_get_driver_data(dev); if (data) { denali->revision = data->revision; denali->caps = data->caps; denali->ecc_caps = data->ecc_caps; } denali->dev = dev; ret = dev_read_resource_byname(dev, "denali_reg", &res); if (ret) return ret; denali->reg = devm_ioremap(dev, res.start, resource_size(&res)); ret = dev_read_resource_byname(dev, "nand_data", &res); if (ret) return ret; denali->host = devm_ioremap(dev, res.start, resource_size(&res)); ret = clk_get_by_name(dev, "nand", &clk); if (ret) ret = clk_get_by_index(dev, 0, &clk); if (ret) return ret; ret = clk_get_by_name(dev, "nand_x", &clk_x); if (ret) clk_x.dev = NULL; ret = clk_get_by_name(dev, "ecc", &clk_ecc); if (ret) clk_ecc.dev = NULL; ret = clk_enable(&clk); if (ret) return ret; if (clk_x.dev) { ret = clk_enable(&clk_x); if (ret) return ret; } if (clk_ecc.dev) { ret = clk_enable(&clk_ecc); if (ret) return ret; } if (clk_x.dev) { denali->clk_rate = clk_get_rate(&clk); denali->clk_x_rate = clk_get_rate(&clk_x); } else { /* * Hardcode the clock rates for the backward compatibility. * This works for both SOCFPGA and UniPhier. */ dev_notice(dev, "necessary clock is missing. default clock rates are used.\n"); denali->clk_rate = 50000000; denali->clk_x_rate = 200000000; } ret = reset_get_bulk(dev, &denali->resets); if (ret) dev_warn(dev, "Can't get reset: %d\n", ret); else reset_deassert_bulk(&denali->resets); return denali_init(denali); }
static int denali_dt_probe(struct platform_device *ofdev) { struct resource *denali_reg, *nand_data; struct denali_dt *dt; struct denali_nand_info *denali; int ret; const struct of_device_id *of_id; of_id = of_match_device(denali_nand_dt_ids, &ofdev->dev); if (of_id) { ofdev->id_entry = of_id->data; } else { pr_err("Failed to find the right device id.\n"); return -ENOMEM; } dt = devm_kzalloc(&ofdev->dev, sizeof(*dt), GFP_KERNEL); if (!dt) return -ENOMEM; denali = &dt->denali; denali_reg = platform_get_resource_byname(ofdev, IORESOURCE_MEM, "denali_reg"); nand_data = platform_get_resource_byname(ofdev, IORESOURCE_MEM, "nand_data"); if (!denali_reg || !nand_data) { dev_err(&ofdev->dev, "resources not completely defined\n"); return -EINVAL; } denali->platform = DT; denali->dev = &ofdev->dev; denali->irq = platform_get_irq(ofdev, 0); if (denali->irq < 0) { dev_err(&ofdev->dev, "no irq defined\n"); return -ENXIO; } denali->flash_reg = request_and_map(&ofdev->dev, denali_reg); if (!denali->flash_reg) return -ENOMEM; denali->flash_mem = request_and_map(&ofdev->dev, nand_data); if (!denali->flash_mem) return -ENOMEM; if (!of_property_read_u32(ofdev->dev.of_node, "dma-mask", (u32 *)&denali_dma_mask)) { denali->dev->dma_mask = &denali_dma_mask; } else { denali->dev->dma_mask = NULL; } dt->clk = clk_get(&ofdev->dev, NULL); if (IS_ERR(dt->clk)) { dev_err(&ofdev->dev, "no clk available\n"); return PTR_ERR(dt->clk); } clk_prepare_enable(dt->clk); ret = denali_init(denali); if (ret) goto out_disable_clk; platform_set_drvdata(ofdev, dt); return 0; out_disable_clk: clk_disable_unprepare(dt->clk); clk_put(dt->clk); return ret; }
static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) { int ret; resource_size_t csr_base, mem_base; unsigned long csr_len, mem_len; struct denali_nand_info *denali; denali = devm_kzalloc(&dev->dev, sizeof(*denali), GFP_KERNEL); if (!denali) return -ENOMEM; ret = pcim_enable_device(dev); if (ret) { dev_err(&dev->dev, "Spectra: pci_enable_device failed.\n"); return ret; } if (id->driver_data == INTEL_CE4100) { mem_base = pci_resource_start(dev, 0); mem_len = pci_resource_len(dev, 1); csr_base = pci_resource_start(dev, 1); csr_len = pci_resource_len(dev, 1); } else { csr_base = pci_resource_start(dev, 0); csr_len = pci_resource_len(dev, 0); mem_base = pci_resource_start(dev, 1); mem_len = pci_resource_len(dev, 1); if (!mem_len) { mem_base = csr_base + csr_len; mem_len = csr_len; } } pci_set_master(dev); denali->dev = &dev->dev; denali->irq = dev->irq; denali->ecc_caps = &denali_pci_ecc_caps; denali->nand.ecc.options |= NAND_ECC_MAXIMIZE; denali->clk_rate = 50000000; /* 50 MHz */ denali->clk_x_rate = 200000000; /* 200 MHz */ ret = pci_request_regions(dev, DENALI_NAND_NAME); if (ret) { dev_err(&dev->dev, "Spectra: Unable to request memory regions\n"); return ret; } denali->reg = ioremap_nocache(csr_base, csr_len); if (!denali->reg) { dev_err(&dev->dev, "Spectra: Unable to remap memory region\n"); return -ENOMEM; } denali->host = ioremap_nocache(mem_base, mem_len); if (!denali->host) { dev_err(&dev->dev, "Spectra: ioremap_nocache failed!"); ret = -ENOMEM; goto failed_remap_reg; } ret = denali_init(denali); if (ret) goto failed_remap_mem; pci_set_drvdata(dev, denali); return 0; failed_remap_mem: iounmap(denali->host); failed_remap_reg: iounmap(denali->reg); return ret; }