Kevin Hilman | e38d92f | 2009-04-29 17:44:58 -0700 | [diff] [blame] | 1 | /* |
| 2 | * TI DaVinci DM646X EVM board |
| 3 | * |
| 4 | * Derived from: arch/arm/mach-davinci/board-evm.c |
| 5 | * Copyright (C) 2006 Texas Instruments. |
| 6 | * |
| 7 | * (C) 2007-2008, MontaVista Software, Inc. |
| 8 | * |
| 9 | * This file is licensed under the terms of the GNU General Public License |
| 10 | * version 2. This program is licensed "as is" without any warranty of any |
| 11 | * kind, whether express or implied. |
| 12 | * |
| 13 | */ |
| 14 | |
| 15 | /************************************************************************** |
| 16 | * Included Files |
| 17 | **************************************************************************/ |
| 18 | |
| 19 | #include <linux/kernel.h> |
| 20 | #include <linux/module.h> |
| 21 | #include <linux/init.h> |
| 22 | #include <linux/fs.h> |
| 23 | #include <linux/major.h> |
| 24 | #include <linux/root_dev.h> |
| 25 | #include <linux/dma-mapping.h> |
| 26 | #include <linux/serial.h> |
| 27 | #include <linux/serial_8250.h> |
| 28 | #include <linux/leds.h> |
| 29 | #include <linux/gpio.h> |
| 30 | #include <linux/io.h> |
| 31 | #include <linux/platform_device.h> |
| 32 | #include <linux/i2c.h> |
| 33 | #include <linux/i2c/at24.h> |
| 34 | #include <linux/i2c/pcf857x.h> |
| 35 | #include <linux/etherdevice.h> |
| 36 | |
| 37 | #include <asm/setup.h> |
| 38 | #include <asm/mach-types.h> |
| 39 | #include <asm/mach/arch.h> |
| 40 | #include <asm/mach/map.h> |
| 41 | #include <asm/mach/flash.h> |
| 42 | |
| 43 | #include <mach/dm646x.h> |
| 44 | #include <mach/common.h> |
| 45 | #include <mach/psc.h> |
| 46 | #include <mach/serial.h> |
| 47 | #include <mach/i2c.h> |
Kevin Hilman | ac7b75b | 2009-05-07 06:19:40 -0700 | [diff] [blame^] | 48 | #include <mach/mmc.h> |
| 49 | #include <mach/emac.h> |
| 50 | |
| 51 | #define DM646X_EVM_PHY_MASK (0x2) |
| 52 | #define DM646X_EVM_MDIO_FREQUENCY (2200000) /* PHY bus frequency */ |
| 53 | |
| 54 | static struct emac_platform_data dm646x_evm_emac_pdata = { |
| 55 | .phy_mask = DM646X_EVM_PHY_MASK, |
| 56 | .mdio_max_freq = DM646X_EVM_MDIO_FREQUENCY, |
| 57 | }; |
Kevin Hilman | e38d92f | 2009-04-29 17:44:58 -0700 | [diff] [blame] | 58 | |
| 59 | static struct davinci_uart_config uart_config __initdata = { |
| 60 | .enabled_uarts = (1 << 0), |
| 61 | }; |
| 62 | |
| 63 | /* LEDS */ |
| 64 | |
| 65 | static struct gpio_led evm_leds[] = { |
| 66 | { .name = "DS1", .active_low = 1, }, |
| 67 | { .name = "DS2", .active_low = 1, }, |
| 68 | { .name = "DS3", .active_low = 1, }, |
| 69 | { .name = "DS4", .active_low = 1, }, |
| 70 | }; |
| 71 | |
| 72 | static __initconst struct gpio_led_platform_data evm_led_data = { |
| 73 | .num_leds = ARRAY_SIZE(evm_leds), |
| 74 | .leds = evm_leds, |
| 75 | }; |
| 76 | |
| 77 | static struct platform_device *evm_led_dev; |
| 78 | |
| 79 | static int evm_led_setup(struct i2c_client *client, int gpio, |
| 80 | unsigned int ngpio, void *c) |
| 81 | { |
| 82 | struct gpio_led *leds = evm_leds; |
| 83 | int status; |
| 84 | |
| 85 | while (ngpio--) { |
| 86 | leds->gpio = gpio++; |
| 87 | leds++; |
| 88 | }; |
| 89 | |
| 90 | evm_led_dev = platform_device_alloc("leds-gpio", 0); |
| 91 | platform_device_add_data(evm_led_dev, &evm_led_data, |
| 92 | sizeof(evm_led_data)); |
| 93 | |
| 94 | evm_led_dev->dev.parent = &client->dev; |
| 95 | status = platform_device_add(evm_led_dev); |
| 96 | if (status < 0) { |
| 97 | platform_device_put(evm_led_dev); |
| 98 | evm_led_dev = NULL; |
| 99 | } |
| 100 | return status; |
| 101 | } |
| 102 | |
| 103 | static int evm_led_teardown(struct i2c_client *client, int gpio, |
| 104 | unsigned ngpio, void *c) |
| 105 | { |
| 106 | if (evm_led_dev) { |
| 107 | platform_device_unregister(evm_led_dev); |
| 108 | evm_led_dev = NULL; |
| 109 | } |
| 110 | return 0; |
| 111 | } |
| 112 | |
| 113 | static int evm_sw_gpio[4] = { -EINVAL, -EINVAL, -EINVAL, -EINVAL }; |
| 114 | |
| 115 | static int evm_sw_setup(struct i2c_client *client, int gpio, |
| 116 | unsigned ngpio, void *c) |
| 117 | { |
| 118 | int status; |
| 119 | int i; |
| 120 | char label[10]; |
| 121 | |
| 122 | for (i = 0; i < 4; ++i) { |
| 123 | snprintf(label, 10, "user_sw%d", i); |
| 124 | status = gpio_request(gpio, label); |
| 125 | if (status) |
| 126 | goto out_free; |
| 127 | evm_sw_gpio[i] = gpio++; |
| 128 | |
| 129 | status = gpio_direction_input(evm_sw_gpio[i]); |
| 130 | if (status) { |
| 131 | gpio_free(evm_sw_gpio[i]); |
| 132 | evm_sw_gpio[i] = -EINVAL; |
| 133 | goto out_free; |
| 134 | } |
| 135 | |
| 136 | status = gpio_export(evm_sw_gpio[i], 0); |
| 137 | if (status) { |
| 138 | gpio_free(evm_sw_gpio[i]); |
| 139 | evm_sw_gpio[i] = -EINVAL; |
| 140 | goto out_free; |
| 141 | } |
| 142 | } |
| 143 | return status; |
| 144 | out_free: |
| 145 | for (i = 0; i < 4; ++i) { |
| 146 | if (evm_sw_gpio[i] != -EINVAL) { |
| 147 | gpio_free(evm_sw_gpio[i]); |
| 148 | evm_sw_gpio[i] = -EINVAL; |
| 149 | } |
| 150 | } |
| 151 | return status; |
| 152 | } |
| 153 | |
| 154 | static int evm_sw_teardown(struct i2c_client *client, int gpio, |
| 155 | unsigned ngpio, void *c) |
| 156 | { |
| 157 | int i; |
| 158 | |
| 159 | for (i = 0; i < 4; ++i) { |
| 160 | if (evm_sw_gpio[i] != -EINVAL) { |
| 161 | gpio_unexport(evm_sw_gpio[i]); |
| 162 | gpio_free(evm_sw_gpio[i]); |
| 163 | evm_sw_gpio[i] = -EINVAL; |
| 164 | } |
| 165 | } |
| 166 | return 0; |
| 167 | } |
| 168 | |
| 169 | static int evm_pcf_setup(struct i2c_client *client, int gpio, |
| 170 | unsigned int ngpio, void *c) |
| 171 | { |
| 172 | int status; |
| 173 | |
| 174 | if (ngpio < 8) |
| 175 | return -EINVAL; |
| 176 | |
| 177 | status = evm_sw_setup(client, gpio, 4, c); |
| 178 | if (status) |
| 179 | return status; |
| 180 | |
| 181 | return evm_led_setup(client, gpio+4, 4, c); |
| 182 | } |
| 183 | |
| 184 | static int evm_pcf_teardown(struct i2c_client *client, int gpio, |
| 185 | unsigned int ngpio, void *c) |
| 186 | { |
| 187 | BUG_ON(ngpio < 8); |
| 188 | |
| 189 | evm_sw_teardown(client, gpio, 4, c); |
| 190 | evm_led_teardown(client, gpio+4, 4, c); |
| 191 | |
| 192 | return 0; |
| 193 | } |
| 194 | |
| 195 | static struct pcf857x_platform_data pcf_data = { |
| 196 | .gpio_base = DAVINCI_N_GPIO+1, |
| 197 | .setup = evm_pcf_setup, |
| 198 | .teardown = evm_pcf_teardown, |
| 199 | }; |
| 200 | |
| 201 | /* Most of this EEPROM is unused, but U-Boot uses some data: |
| 202 | * - 0x7f00, 6 bytes Ethernet Address |
| 203 | * - ... newer boards may have more |
| 204 | */ |
| 205 | static struct memory_accessor *at24_mem_acc; |
| 206 | |
| 207 | static void at24_setup(struct memory_accessor *mem_acc, void *context) |
| 208 | { |
Kevin Hilman | ac7b75b | 2009-05-07 06:19:40 -0700 | [diff] [blame^] | 209 | char mac_addr[ETH_ALEN]; |
Kevin Hilman | e38d92f | 2009-04-29 17:44:58 -0700 | [diff] [blame] | 210 | |
| 211 | at24_mem_acc = mem_acc; |
| 212 | |
| 213 | /* Read MAC addr from EEPROM */ |
| 214 | if (at24_mem_acc->read(at24_mem_acc, mac_addr, 0x7f00, ETH_ALEN) == |
Kevin Hilman | ac7b75b | 2009-05-07 06:19:40 -0700 | [diff] [blame^] | 215 | ETH_ALEN) { |
Kevin Hilman | e38d92f | 2009-04-29 17:44:58 -0700 | [diff] [blame] | 216 | pr_info("Read MAC addr from EEPROM: %pM\n", mac_addr); |
Kevin Hilman | ac7b75b | 2009-05-07 06:19:40 -0700 | [diff] [blame^] | 217 | memcpy(dm646x_evm_emac_pdata.mac_addr, mac_addr, ETH_ALEN); |
| 218 | } |
Kevin Hilman | e38d92f | 2009-04-29 17:44:58 -0700 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | static struct at24_platform_data eeprom_info = { |
| 222 | .byte_len = (256*1024) / 8, |
| 223 | .page_size = 64, |
| 224 | .flags = AT24_FLAG_ADDR16, |
| 225 | .setup = at24_setup, |
| 226 | }; |
| 227 | |
| 228 | int dm646xevm_eeprom_read(void *buf, off_t off, size_t count) |
| 229 | { |
| 230 | if (at24_mem_acc) |
| 231 | return at24_mem_acc->read(at24_mem_acc, buf, off, count); |
| 232 | return -ENODEV; |
| 233 | } |
| 234 | EXPORT_SYMBOL(dm646xevm_eeprom_read); |
| 235 | |
| 236 | int dm646xevm_eeprom_write(void *buf, off_t off, size_t count) |
| 237 | { |
| 238 | if (at24_mem_acc) |
| 239 | return at24_mem_acc->write(at24_mem_acc, buf, off, count); |
| 240 | return -ENODEV; |
| 241 | } |
| 242 | EXPORT_SYMBOL(dm646xevm_eeprom_write); |
| 243 | |
| 244 | static struct i2c_board_info __initdata i2c_info[] = { |
| 245 | { |
| 246 | I2C_BOARD_INFO("24c256", 0x50), |
| 247 | .platform_data = &eeprom_info, |
| 248 | }, |
| 249 | { |
| 250 | I2C_BOARD_INFO("pcf8574a", 0x38), |
| 251 | .platform_data = &pcf_data, |
| 252 | }, |
| 253 | }; |
| 254 | |
| 255 | static struct davinci_i2c_platform_data i2c_pdata = { |
| 256 | .bus_freq = 100 /* kHz */, |
| 257 | .bus_delay = 0 /* usec */, |
| 258 | }; |
| 259 | |
| 260 | static void __init evm_init_i2c(void) |
| 261 | { |
| 262 | davinci_init_i2c(&i2c_pdata); |
| 263 | i2c_register_board_info(1, i2c_info, ARRAY_SIZE(i2c_info)); |
| 264 | } |
| 265 | |
| 266 | static void __init davinci_map_io(void) |
| 267 | { |
| 268 | davinci_map_common_io(); |
| 269 | dm646x_init(); |
| 270 | } |
| 271 | |
| 272 | static __init void evm_init(void) |
| 273 | { |
| 274 | evm_init_i2c(); |
| 275 | davinci_serial_init(&uart_config); |
Kevin Hilman | ac7b75b | 2009-05-07 06:19:40 -0700 | [diff] [blame^] | 276 | dm646x_init_emac(&dm646x_evm_emac_pdata); |
Kevin Hilman | e38d92f | 2009-04-29 17:44:58 -0700 | [diff] [blame] | 277 | } |
| 278 | |
| 279 | static __init void davinci_dm646x_evm_irq_init(void) |
| 280 | { |
| 281 | davinci_irq_init(); |
| 282 | } |
| 283 | |
| 284 | MACHINE_START(DAVINCI_DM6467_EVM, "DaVinci DM646x EVM") |
| 285 | .phys_io = IO_PHYS, |
| 286 | .io_pg_offst = (__IO_ADDRESS(IO_PHYS) >> 18) & 0xfffc, |
| 287 | .boot_params = (0x80000100), |
| 288 | .map_io = davinci_map_io, |
| 289 | .init_irq = davinci_dm646x_evm_irq_init, |
| 290 | .timer = &davinci_timer, |
| 291 | .init_machine = evm_init, |
| 292 | MACHINE_END |
| 293 | |