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