board-dm355-evm.c (11245B)
1/* 2 * TI DaVinci EVM board support 3 * 4 * Author: Kevin Hilman, Deep Root Systems, LLC 5 * 6 * 2007 (c) MontaVista Software, Inc. This file is licensed under 7 * the terms of the GNU General Public License version 2. This program 8 * is licensed "as is" without any warranty of any kind, whether express 9 * or implied. 10 */ 11#include <linux/kernel.h> 12#include <linux/init.h> 13#include <linux/err.h> 14#include <linux/platform_device.h> 15#include <linux/mtd/mtd.h> 16#include <linux/mtd/partitions.h> 17#include <linux/mtd/rawnand.h> 18#include <linux/i2c.h> 19#include <linux/gpio.h> 20#include <linux/gpio/machine.h> 21#include <linux/clk.h> 22#include <linux/dm9000.h> 23#include <linux/videodev2.h> 24#include <media/i2c/tvp514x.h> 25#include <linux/spi/spi.h> 26#include <linux/spi/eeprom.h> 27#include <linux/platform_data/gpio-davinci.h> 28#include <linux/platform_data/i2c-davinci.h> 29#include <linux/platform_data/mtd-davinci.h> 30#include <linux/platform_data/mmc-davinci.h> 31#include <linux/platform_data/usb-davinci.h> 32 33#include <asm/mach-types.h> 34#include <asm/mach/arch.h> 35 36#include "serial.h" 37#include "common.h" 38#include "davinci.h" 39 40/* NOTE: this is geared for the standard config, with a socketed 41 * 2 GByte Micron NAND (MT29F16G08FAA) using 128KB sectors. If you 42 * swap chips, maybe with a different block size, partitioning may 43 * need to be changed. 44 */ 45#define NAND_BLOCK_SIZE SZ_128K 46 47static struct mtd_partition davinci_nand_partitions[] = { 48 { 49 /* UBL (a few copies) plus U-Boot */ 50 .name = "bootloader", 51 .offset = 0, 52 .size = 15 * NAND_BLOCK_SIZE, 53 .mask_flags = MTD_WRITEABLE, /* force read-only */ 54 }, { 55 /* U-Boot environment */ 56 .name = "params", 57 .offset = MTDPART_OFS_APPEND, 58 .size = 1 * NAND_BLOCK_SIZE, 59 .mask_flags = 0, 60 }, { 61 .name = "kernel", 62 .offset = MTDPART_OFS_APPEND, 63 .size = SZ_4M, 64 .mask_flags = 0, 65 }, { 66 .name = "filesystem1", 67 .offset = MTDPART_OFS_APPEND, 68 .size = SZ_512M, 69 .mask_flags = 0, 70 }, { 71 .name = "filesystem2", 72 .offset = MTDPART_OFS_APPEND, 73 .size = MTDPART_SIZ_FULL, 74 .mask_flags = 0, 75 } 76 /* two blocks with bad block table (and mirror) at the end */ 77}; 78 79static struct davinci_nand_pdata davinci_nand_data = { 80 .core_chipsel = 0, 81 .mask_chipsel = BIT(14), 82 .parts = davinci_nand_partitions, 83 .nr_parts = ARRAY_SIZE(davinci_nand_partitions), 84 .engine_type = NAND_ECC_ENGINE_TYPE_ON_HOST, 85 .bbt_options = NAND_BBT_USE_FLASH, 86 .ecc_bits = 4, 87}; 88 89static struct resource davinci_nand_resources[] = { 90 { 91 .start = DM355_ASYNC_EMIF_DATA_CE0_BASE, 92 .end = DM355_ASYNC_EMIF_DATA_CE0_BASE + SZ_32M - 1, 93 .flags = IORESOURCE_MEM, 94 }, { 95 .start = DM355_ASYNC_EMIF_CONTROL_BASE, 96 .end = DM355_ASYNC_EMIF_CONTROL_BASE + SZ_4K - 1, 97 .flags = IORESOURCE_MEM, 98 }, 99}; 100 101static struct platform_device davinci_nand_device = { 102 .name = "davinci_nand", 103 .id = 0, 104 105 .num_resources = ARRAY_SIZE(davinci_nand_resources), 106 .resource = davinci_nand_resources, 107 108 .dev = { 109 .platform_data = &davinci_nand_data, 110 }, 111}; 112 113#define DM355_I2C_SDA_PIN GPIO_TO_PIN(0, 15) 114#define DM355_I2C_SCL_PIN GPIO_TO_PIN(0, 14) 115 116static struct gpiod_lookup_table i2c_recovery_gpiod_table = { 117 .dev_id = "i2c_davinci.1", 118 .table = { 119 GPIO_LOOKUP("davinci_gpio", DM355_I2C_SDA_PIN, "sda", 120 GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN), 121 GPIO_LOOKUP("davinci_gpio", DM355_I2C_SCL_PIN, "scl", 122 GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN), 123 { } 124 }, 125}; 126 127static struct davinci_i2c_platform_data i2c_pdata = { 128 .bus_freq = 400 /* kHz */, 129 .bus_delay = 0 /* usec */, 130 .gpio_recovery = true, 131}; 132 133static int dm355evm_mmc_gpios = -EINVAL; 134 135static void dm355evm_mmcsd_gpios(unsigned gpio) 136{ 137 gpio_request(gpio + 0, "mmc0_ro"); 138 gpio_request(gpio + 1, "mmc0_cd"); 139 gpio_request(gpio + 2, "mmc1_ro"); 140 gpio_request(gpio + 3, "mmc1_cd"); 141 142 /* we "know" these are input-only so we don't 143 * need to call gpio_direction_input() 144 */ 145 146 dm355evm_mmc_gpios = gpio; 147} 148 149static struct i2c_board_info dm355evm_i2c_info[] = { 150 { I2C_BOARD_INFO("dm355evm_msp", 0x25), 151 .platform_data = dm355evm_mmcsd_gpios, 152 }, 153 /* { plus irq }, */ 154 { I2C_BOARD_INFO("tlv320aic33", 0x1b), }, 155}; 156 157static void __init evm_init_i2c(void) 158{ 159 gpiod_add_lookup_table(&i2c_recovery_gpiod_table); 160 davinci_init_i2c(&i2c_pdata); 161 162 gpio_request(5, "dm355evm_msp"); 163 gpio_direction_input(5); 164 dm355evm_i2c_info[0].irq = gpio_to_irq(5); 165 166 i2c_register_board_info(1, dm355evm_i2c_info, 167 ARRAY_SIZE(dm355evm_i2c_info)); 168} 169 170static struct resource dm355evm_dm9000_rsrc[] = { 171 { 172 /* addr */ 173 .start = 0x04014000, 174 .end = 0x04014001, 175 .flags = IORESOURCE_MEM, 176 }, { 177 /* data */ 178 .start = 0x04014002, 179 .end = 0x04014003, 180 .flags = IORESOURCE_MEM, 181 }, { 182 .flags = IORESOURCE_IRQ 183 | IORESOURCE_IRQ_HIGHEDGE /* rising (active high) */, 184 }, 185}; 186 187static struct dm9000_plat_data dm335evm_dm9000_platdata; 188 189static struct platform_device dm355evm_dm9000 = { 190 .name = "dm9000", 191 .id = -1, 192 .resource = dm355evm_dm9000_rsrc, 193 .num_resources = ARRAY_SIZE(dm355evm_dm9000_rsrc), 194 .dev = { 195 .platform_data = &dm335evm_dm9000_platdata, 196 }, 197}; 198 199static struct tvp514x_platform_data tvp5146_pdata = { 200 .clk_polarity = 0, 201 .hs_polarity = 1, 202 .vs_polarity = 1 203}; 204 205#define TVP514X_STD_ALL (V4L2_STD_NTSC | V4L2_STD_PAL) 206/* Inputs available at the TVP5146 */ 207static struct v4l2_input tvp5146_inputs[] = { 208 { 209 .index = 0, 210 .name = "Composite", 211 .type = V4L2_INPUT_TYPE_CAMERA, 212 .std = TVP514X_STD_ALL, 213 }, 214 { 215 .index = 1, 216 .name = "S-Video", 217 .type = V4L2_INPUT_TYPE_CAMERA, 218 .std = TVP514X_STD_ALL, 219 }, 220}; 221 222/* 223 * this is the route info for connecting each input to decoder 224 * ouput that goes to vpfe. There is a one to one correspondence 225 * with tvp5146_inputs 226 */ 227static struct vpfe_route tvp5146_routes[] = { 228 { 229 .input = INPUT_CVBS_VI2B, 230 .output = OUTPUT_10BIT_422_EMBEDDED_SYNC, 231 }, 232 { 233 .input = INPUT_SVIDEO_VI2C_VI1C, 234 .output = OUTPUT_10BIT_422_EMBEDDED_SYNC, 235 }, 236}; 237 238static struct vpfe_subdev_info vpfe_sub_devs[] = { 239 { 240 .name = "tvp5146", 241 .grp_id = 0, 242 .num_inputs = ARRAY_SIZE(tvp5146_inputs), 243 .inputs = tvp5146_inputs, 244 .routes = tvp5146_routes, 245 .can_route = 1, 246 .ccdc_if_params = { 247 .if_type = VPFE_BT656, 248 .hdpol = VPFE_PINPOL_POSITIVE, 249 .vdpol = VPFE_PINPOL_POSITIVE, 250 }, 251 .board_info = { 252 I2C_BOARD_INFO("tvp5146", 0x5d), 253 .platform_data = &tvp5146_pdata, 254 }, 255 } 256}; 257 258static struct vpfe_config vpfe_cfg = { 259 .num_subdevs = ARRAY_SIZE(vpfe_sub_devs), 260 .i2c_adapter_id = 1, 261 .sub_devs = vpfe_sub_devs, 262 .card_name = "DM355 EVM", 263 .ccdc = "DM355 CCDC", 264}; 265 266/* venc standards timings */ 267static struct vpbe_enc_mode_info dm355evm_enc_preset_timing[] = { 268 { 269 .name = "ntsc", 270 .timings_type = VPBE_ENC_STD, 271 .std_id = V4L2_STD_NTSC, 272 .interlaced = 1, 273 .xres = 720, 274 .yres = 480, 275 .aspect = {11, 10}, 276 .fps = {30000, 1001}, 277 .left_margin = 0x79, 278 .upper_margin = 0x10, 279 }, 280 { 281 .name = "pal", 282 .timings_type = VPBE_ENC_STD, 283 .std_id = V4L2_STD_PAL, 284 .interlaced = 1, 285 .xres = 720, 286 .yres = 576, 287 .aspect = {54, 59}, 288 .fps = {25, 1}, 289 .left_margin = 0x7E, 290 .upper_margin = 0x16 291 }, 292}; 293 294#define VENC_STD_ALL (V4L2_STD_NTSC | V4L2_STD_PAL) 295 296/* 297 * The outputs available from VPBE + ecnoders. Keep the 298 * the order same as that of encoders. First those from venc followed by that 299 * from encoders. Index in the output refers to index on a particular encoder. 300 * Driver uses this index to pass it to encoder when it supports more than 301 * one output. Application uses index of the array to set an output. 302 */ 303static struct vpbe_output dm355evm_vpbe_outputs[] = { 304 { 305 .output = { 306 .index = 0, 307 .name = "Composite", 308 .type = V4L2_OUTPUT_TYPE_ANALOG, 309 .std = VENC_STD_ALL, 310 .capabilities = V4L2_OUT_CAP_STD, 311 }, 312 .subdev_name = DM355_VPBE_VENC_SUBDEV_NAME, 313 .default_mode = "ntsc", 314 .num_modes = ARRAY_SIZE(dm355evm_enc_preset_timing), 315 .modes = dm355evm_enc_preset_timing, 316 .if_params = MEDIA_BUS_FMT_FIXED, 317 }, 318}; 319 320static struct vpbe_config dm355evm_display_cfg = { 321 .module_name = "dm355-vpbe-display", 322 .i2c_adapter_id = 1, 323 .osd = { 324 .module_name = DM355_VPBE_OSD_SUBDEV_NAME, 325 }, 326 .venc = { 327 .module_name = DM355_VPBE_VENC_SUBDEV_NAME, 328 }, 329 .num_outputs = ARRAY_SIZE(dm355evm_vpbe_outputs), 330 .outputs = dm355evm_vpbe_outputs, 331}; 332 333static struct platform_device *davinci_evm_devices[] __initdata = { 334 &dm355evm_dm9000, 335 &davinci_nand_device, 336}; 337 338static void __init dm355_evm_map_io(void) 339{ 340 dm355_init(); 341} 342 343static int dm355evm_mmc_get_cd(int module) 344{ 345 if (!gpio_is_valid(dm355evm_mmc_gpios)) 346 return -ENXIO; 347 /* low == card present */ 348 return !gpio_get_value_cansleep(dm355evm_mmc_gpios + 2 * module + 1); 349} 350 351static int dm355evm_mmc_get_ro(int module) 352{ 353 if (!gpio_is_valid(dm355evm_mmc_gpios)) 354 return -ENXIO; 355 /* high == card's write protect switch active */ 356 return gpio_get_value_cansleep(dm355evm_mmc_gpios + 2 * module + 0); 357} 358 359static struct davinci_mmc_config dm355evm_mmc_config = { 360 .get_cd = dm355evm_mmc_get_cd, 361 .get_ro = dm355evm_mmc_get_ro, 362 .wires = 4, 363 .max_freq = 50000000, 364 .caps = MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED, 365}; 366 367/* Don't connect anything to J10 unless you're only using USB host 368 * mode *and* have to do so with some kind of gender-bender. If 369 * you have proper Mini-B or Mini-A cables (or Mini-A adapters) 370 * the ID pin won't need any help. 371 */ 372#define USB_ID_VALUE 1 /* ID pulled low */ 373 374static struct spi_eeprom at25640a = { 375 .byte_len = SZ_64K / 8, 376 .name = "at25640a", 377 .page_size = 32, 378 .flags = EE_ADDR2, 379}; 380 381static const struct spi_board_info dm355_evm_spi_info[] __initconst = { 382 { 383 .modalias = "at25", 384 .platform_data = &at25640a, 385 .max_speed_hz = 10 * 1000 * 1000, /* at 3v3 */ 386 .bus_num = 0, 387 .chip_select = 0, 388 .mode = SPI_MODE_0, 389 }, 390}; 391 392static __init void dm355_evm_init(void) 393{ 394 struct clk *aemif; 395 int ret; 396 397 dm355_register_clocks(); 398 399 ret = dm355_gpio_register(); 400 if (ret) 401 pr_warn("%s: GPIO init failed: %d\n", __func__, ret); 402 403 gpio_request(1, "dm9000"); 404 gpio_direction_input(1); 405 dm355evm_dm9000_rsrc[2].start = gpio_to_irq(1); 406 407 aemif = clk_get(&dm355evm_dm9000.dev, "aemif"); 408 if (!WARN(IS_ERR(aemif), "unable to get AEMIF clock\n")) 409 clk_prepare_enable(aemif); 410 411 platform_add_devices(davinci_evm_devices, 412 ARRAY_SIZE(davinci_evm_devices)); 413 evm_init_i2c(); 414 davinci_serial_init(dm355_serial_device); 415 416 /* NOTE: NAND flash timings set by the UBL are slower than 417 * needed by MT29F16G08FAA chips ... EMIF.A1CR is 0x40400204 418 * but could be 0x0400008c for about 25% faster page reads. 419 */ 420 421 gpio_request(2, "usb_id_toggle"); 422 gpio_direction_output(2, USB_ID_VALUE); 423 /* irlml6401 switches over 1A in under 8 msec */ 424 davinci_setup_usb(1000, 8); 425 426 davinci_setup_mmc(0, &dm355evm_mmc_config); 427 davinci_setup_mmc(1, &dm355evm_mmc_config); 428 429 dm355_init_video(&vpfe_cfg, &dm355evm_display_cfg); 430 431 dm355_init_spi0(BIT(0), dm355_evm_spi_info, 432 ARRAY_SIZE(dm355_evm_spi_info)); 433 434 /* DM335 EVM uses ASP1; line-out is a stereo mini-jack */ 435 dm355_init_asp1(ASP1_TX_EVT_EN | ASP1_RX_EVT_EN); 436} 437 438MACHINE_START(DAVINCI_DM355_EVM, "DaVinci DM355 EVM") 439 .atag_offset = 0x100, 440 .map_io = dm355_evm_map_io, 441 .init_irq = dm355_init_irq, 442 .init_time = dm355_init_time, 443 .init_machine = dm355_evm_init, 444 .init_late = davinci_init_late, 445 .dma_zone_size = SZ_128M, 446MACHINE_END