| /* |
| * Platform device setup for Marvell mv64360/mv64460 host bridges (Discovery) |
| * |
| * Author: Dale Farnsworth <dale@farnsworth.org> |
| * |
| * 2007 (c) MontaVista, Software, Inc. This file is licensed under |
| * the terms of the GNU General Public License version 2. This program |
| * is licensed "as is" without any warranty of any kind, whether express |
| * or implied. |
| */ |
| |
| #include <linux/stddef.h> |
| #include <linux/kernel.h> |
| #include <linux/init.h> |
| #include <linux/console.h> |
| #include <linux/mv643xx.h> |
| #include <linux/platform_device.h> |
| |
| #include <asm/prom.h> |
| |
| /* |
| * These functions provide the necessary setup for the mv64x60 drivers. |
| * These drivers are unusual in that they work on both the MIPS and PowerPC |
| * architectures. Because of that, the drivers do not support the normal |
| * PowerPC of_platform_bus_type. They support platform_bus_type instead. |
| */ |
| |
| /* |
| * Create MPSC platform devices |
| */ |
| static int __init mv64x60_mpsc_register_shared_pdev(struct device_node *np) |
| { |
| struct platform_device *pdev; |
| struct resource r[2]; |
| struct mpsc_shared_pdata pdata; |
| const phandle *ph; |
| struct device_node *mpscrouting, *mpscintr; |
| int err; |
| |
| ph = of_get_property(np, "mpscrouting", NULL); |
| mpscrouting = of_find_node_by_phandle(*ph); |
| if (!mpscrouting) |
| return -ENODEV; |
| |
| err = of_address_to_resource(mpscrouting, 0, &r[0]); |
| of_node_put(mpscrouting); |
| if (err) |
| return err; |
| |
| ph = of_get_property(np, "mpscintr", NULL); |
| mpscintr = of_find_node_by_phandle(*ph); |
| if (!mpscintr) |
| return -ENODEV; |
| |
| err = of_address_to_resource(mpscintr, 0, &r[1]); |
| of_node_put(mpscintr); |
| if (err) |
| return err; |
| |
| memset(&pdata, 0, sizeof(pdata)); |
| |
| pdev = platform_device_alloc(MPSC_SHARED_NAME, 0); |
| if (!pdev) |
| return -ENOMEM; |
| |
| err = platform_device_add_resources(pdev, r, 2); |
| if (err) |
| goto error; |
| |
| err = platform_device_add_data(pdev, &pdata, sizeof(pdata)); |
| if (err) |
| goto error; |
| |
| err = platform_device_add(pdev); |
| if (err) |
| goto error; |
| |
| return 0; |
| |
| error: |
| platform_device_put(pdev); |
| return err; |
| } |
| |
| |
| static int __init mv64x60_mpsc_device_setup(struct device_node *np, int id) |
| { |
| struct resource r[5]; |
| struct mpsc_pdata pdata; |
| struct platform_device *pdev; |
| const unsigned int *prop; |
| const phandle *ph; |
| struct device_node *sdma, *brg; |
| int err; |
| int port_number; |
| |
| /* only register the shared platform device the first time through */ |
| if (id == 0 && (err = mv64x60_mpsc_register_shared_pdev(np))) |
| return err; |
| |
| memset(r, 0, sizeof(r)); |
| |
| err = of_address_to_resource(np, 0, &r[0]); |
| if (err) |
| return err; |
| |
| of_irq_to_resource(np, 0, &r[4]); |
| |
| ph = of_get_property(np, "sdma", NULL); |
| sdma = of_find_node_by_phandle(*ph); |
| if (!sdma) |
| return -ENODEV; |
| |
| of_irq_to_resource(sdma, 0, &r[3]); |
| err = of_address_to_resource(sdma, 0, &r[1]); |
| of_node_put(sdma); |
| if (err) |
| return err; |
| |
| ph = of_get_property(np, "brg", NULL); |
| brg = of_find_node_by_phandle(*ph); |
| if (!brg) |
| return -ENODEV; |
| |
| err = of_address_to_resource(brg, 0, &r[2]); |
| of_node_put(brg); |
| if (err) |
| return err; |
| |
| prop = of_get_property(np, "block-index", NULL); |
| if (!prop) |
| return -ENODEV; |
| port_number = *(int *)prop; |
| |
| memset(&pdata, 0, sizeof(pdata)); |
| |
| pdata.cache_mgmt = 1; /* All current revs need this set */ |
| |
| prop = of_get_property(np, "max_idle", NULL); |
| if (prop) |
| pdata.max_idle = *prop; |
| |
| prop = of_get_property(brg, "current-speed", NULL); |
| if (prop) |
| pdata.default_baud = *prop; |
| |
| /* Default is 8 bits, no parity, no flow control */ |
| pdata.default_bits = 8; |
| pdata.default_parity = 'n'; |
| pdata.default_flow = 'n'; |
| |
| prop = of_get_property(np, "chr_1", NULL); |
| if (prop) |
| pdata.chr_1_val = *prop; |
| |
| prop = of_get_property(np, "chr_2", NULL); |
| if (prop) |
| pdata.chr_2_val = *prop; |
| |
| prop = of_get_property(np, "chr_10", NULL); |
| if (prop) |
| pdata.chr_10_val = *prop; |
| |
| prop = of_get_property(np, "mpcr", NULL); |
| if (prop) |
| pdata.mpcr_val = *prop; |
| |
| prop = of_get_property(brg, "bcr", NULL); |
| if (prop) |
| pdata.bcr_val = *prop; |
| |
| pdata.brg_can_tune = 1; /* All current revs need this set */ |
| |
| prop = of_get_property(brg, "clock-src", NULL); |
| if (prop) |
| pdata.brg_clk_src = *prop; |
| |
| prop = of_get_property(brg, "clock-frequency", NULL); |
| if (prop) |
| pdata.brg_clk_freq = *prop; |
| |
| pdev = platform_device_alloc(MPSC_CTLR_NAME, port_number); |
| if (!pdev) |
| return -ENOMEM; |
| |
| err = platform_device_add_resources(pdev, r, 5); |
| if (err) |
| goto error; |
| |
| err = platform_device_add_data(pdev, &pdata, sizeof(pdata)); |
| if (err) |
| goto error; |
| |
| err = platform_device_add(pdev); |
| if (err) |
| goto error; |
| |
| return 0; |
| |
| error: |
| platform_device_put(pdev); |
| return err; |
| } |
| |
| /* |
| * Create mv64x60_eth platform devices |
| */ |
| static int __init eth_register_shared_pdev(struct device_node *np) |
| { |
| struct platform_device *pdev; |
| struct resource r[1]; |
| int err; |
| |
| np = of_get_parent(np); |
| if (!np) |
| return -ENODEV; |
| |
| err = of_address_to_resource(np, 0, &r[0]); |
| of_node_put(np); |
| if (err) |
| return err; |
| |
| pdev = platform_device_register_simple(MV643XX_ETH_SHARED_NAME, 0, |
| r, 1); |
| if (IS_ERR(pdev)) |
| return PTR_ERR(pdev); |
| |
| return 0; |
| } |
| |
| static int __init mv64x60_eth_device_setup(struct device_node *np, int id) |
| { |
| struct resource r[1]; |
| struct mv643xx_eth_platform_data pdata; |
| struct platform_device *pdev; |
| struct device_node *phy; |
| const u8 *mac_addr; |
| const int *prop; |
| const phandle *ph; |
| int err; |
| |
| /* only register the shared platform device the first time through */ |
| if (id == 0 && (err = eth_register_shared_pdev(np))) |
| return err;; |
| |
| memset(r, 0, sizeof(r)); |
| of_irq_to_resource(np, 0, &r[0]); |
| |
| memset(&pdata, 0, sizeof(pdata)); |
| |
| prop = of_get_property(np, "block-index", NULL); |
| if (!prop) |
| return -ENODEV; |
| pdata.port_number = *prop; |
| |
| mac_addr = of_get_mac_address(np); |
| if (mac_addr) |
| memcpy(pdata.mac_addr, mac_addr, 6); |
| |
| prop = of_get_property(np, "speed", NULL); |
| if (prop) |
| pdata.speed = *prop; |
| |
| prop = of_get_property(np, "tx_queue_size", NULL); |
| if (prop) |
| pdata.tx_queue_size = *prop; |
| |
| prop = of_get_property(np, "rx_queue_size", NULL); |
| if (prop) |
| pdata.rx_queue_size = *prop; |
| |
| prop = of_get_property(np, "tx_sram_addr", NULL); |
| if (prop) |
| pdata.tx_sram_addr = *prop; |
| |
| prop = of_get_property(np, "tx_sram_size", NULL); |
| if (prop) |
| pdata.tx_sram_size = *prop; |
| |
| prop = of_get_property(np, "rx_sram_addr", NULL); |
| if (prop) |
| pdata.rx_sram_addr = *prop; |
| |
| prop = of_get_property(np, "rx_sram_size", NULL); |
| if (prop) |
| pdata.rx_sram_size = *prop; |
| |
| ph = of_get_property(np, "phy", NULL); |
| if (!ph) |
| return -ENODEV; |
| |
| phy = of_find_node_by_phandle(*ph); |
| if (phy == NULL) |
| return -ENODEV; |
| |
| prop = of_get_property(phy, "reg", NULL); |
| if (prop) { |
| pdata.force_phy_addr = 1; |
| pdata.phy_addr = *prop; |
| } |
| |
| of_node_put(phy); |
| |
| pdev = platform_device_alloc(MV643XX_ETH_NAME, pdata.port_number); |
| if (!pdev) |
| return -ENOMEM; |
| |
| err = platform_device_add_resources(pdev, r, 1); |
| if (err) |
| goto error; |
| |
| err = platform_device_add_data(pdev, &pdata, sizeof(pdata)); |
| if (err) |
| goto error; |
| |
| err = platform_device_add(pdev); |
| if (err) |
| goto error; |
| |
| return 0; |
| |
| error: |
| platform_device_put(pdev); |
| return err; |
| } |
| |
| /* |
| * Create mv64x60_i2c platform devices |
| */ |
| static int __init mv64x60_i2c_device_setup(struct device_node *np, int id) |
| { |
| struct resource r[2]; |
| struct platform_device *pdev; |
| struct mv64xxx_i2c_pdata pdata; |
| const unsigned int *prop; |
| int err; |
| |
| memset(r, 0, sizeof(r)); |
| |
| err = of_address_to_resource(np, 0, &r[0]); |
| if (err) |
| return err; |
| |
| of_irq_to_resource(np, 0, &r[1]); |
| |
| memset(&pdata, 0, sizeof(pdata)); |
| |
| prop = of_get_property(np, "freq_m", NULL); |
| if (!prop) |
| return -ENODEV; |
| pdata.freq_m = *prop; |
| |
| prop = of_get_property(np, "freq_n", NULL); |
| if (!prop) |
| return -ENODEV; |
| pdata.freq_n = *prop; |
| |
| prop = of_get_property(np, "timeout", NULL); |
| if (prop) |
| pdata.timeout = *prop; |
| else |
| pdata.timeout = 1000; /* 1 second */ |
| |
| prop = of_get_property(np, "retries", NULL); |
| if (prop) |
| pdata.retries = *prop; |
| else |
| pdata.retries = 1; |
| |
| pdev = platform_device_alloc(MV64XXX_I2C_CTLR_NAME, id); |
| if (!pdev) |
| return -ENOMEM; |
| |
| err = platform_device_add_resources(pdev, r, 2); |
| if (err) |
| goto error; |
| |
| err = platform_device_add_data(pdev, &pdata, sizeof(pdata)); |
| if (err) |
| goto error; |
| |
| err = platform_device_add(pdev); |
| if (err) |
| goto error; |
| |
| return 0; |
| |
| error: |
| platform_device_put(pdev); |
| return err; |
| } |
| |
| /* |
| * Create mv64x60_wdt platform devices |
| */ |
| static int __init mv64x60_wdt_device_setup(struct device_node *np, int id) |
| { |
| struct resource r; |
| struct platform_device *pdev; |
| struct mv64x60_wdt_pdata pdata; |
| const unsigned int *prop; |
| int err; |
| |
| err = of_address_to_resource(np, 0, &r); |
| if (err) |
| return err; |
| |
| memset(&pdata, 0, sizeof(pdata)); |
| |
| prop = of_get_property(np, "timeout", NULL); |
| if (!prop) |
| return -ENODEV; |
| pdata.timeout = *prop; |
| |
| np = of_get_parent(np); |
| if (!np) |
| return -ENODEV; |
| |
| prop = of_get_property(np, "clock-frequency", NULL); |
| of_node_put(np); |
| if (!prop) |
| return -ENODEV; |
| pdata.bus_clk = *prop / 1000000; /* wdt driver wants freq in MHz */ |
| |
| pdev = platform_device_alloc(MV64x60_WDT_NAME, id); |
| if (!pdev) |
| return -ENOMEM; |
| |
| err = platform_device_add_resources(pdev, &r, 1); |
| if (err) |
| goto error; |
| |
| err = platform_device_add_data(pdev, &pdata, sizeof(pdata)); |
| if (err) |
| goto error; |
| |
| err = platform_device_add(pdev); |
| if (err) |
| goto error; |
| |
| return 0; |
| |
| error: |
| platform_device_put(pdev); |
| return err; |
| } |
| |
| static int __init mv64x60_device_setup(void) |
| { |
| struct device_node *np = NULL; |
| int id; |
| int err; |
| |
| for (id = 0; |
| (np = of_find_compatible_node(np, "serial", "marvell,mpsc")); id++) |
| if ((err = mv64x60_mpsc_device_setup(np, id))) |
| goto error; |
| |
| for (id = 0; |
| (np = of_find_compatible_node(np, "network", |
| "marvell,mv64x60-eth")); |
| id++) |
| if ((err = mv64x60_eth_device_setup(np, id))) |
| goto error; |
| |
| for (id = 0; |
| (np = of_find_compatible_node(np, "i2c", "marvell,mv64x60-i2c")); |
| id++) |
| if ((err = mv64x60_i2c_device_setup(np, id))) |
| goto error; |
| |
| /* support up to one watchdog timer */ |
| np = of_find_compatible_node(np, NULL, "marvell,mv64x60-wdt"); |
| if (np) { |
| if ((err = mv64x60_wdt_device_setup(np, id))) |
| goto error; |
| of_node_put(np); |
| } |
| |
| |
| return 0; |
| |
| error: |
| of_node_put(np); |
| return err; |
| } |
| arch_initcall(mv64x60_device_setup); |
| |
| static int __init mv64x60_add_mpsc_console(void) |
| { |
| struct device_node *np = NULL; |
| const char *prop; |
| |
| prop = of_get_property(of_chosen, "linux,stdout-path", NULL); |
| if (prop == NULL) |
| goto not_mpsc; |
| |
| np = of_find_node_by_path(prop); |
| if (!np) |
| goto not_mpsc; |
| |
| if (!of_device_is_compatible(np, "marvell,mpsc")) |
| goto not_mpsc; |
| |
| prop = of_get_property(np, "block-index", NULL); |
| if (!prop) |
| goto not_mpsc; |
| |
| add_preferred_console("ttyMM", *(int *)prop, NULL); |
| |
| not_mpsc: |
| return 0; |
| } |
| console_initcall(mv64x60_add_mpsc_console); |