2 * TI DaVinci DM646X EVM board
4 * Derived from: arch/arm/mach-davinci/board-evm.c
5 * Copyright (C) 2006 Texas Instruments.
7 * (C) 2007-2008, MontaVista Software, Inc.
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.
15 /**************************************************************************
17 **************************************************************************/
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/leds.h>
22 #include <linux/gpio.h>
23 #include <linux/platform_device.h>
24 #include <linux/i2c.h>
25 #include <linux/i2c/at24.h>
26 #include <linux/i2c/pcf857x.h>
28 #include <media/tvp514x.h>
30 #include <linux/mtd/mtd.h>
31 #include <linux/mtd/nand.h>
32 #include <linux/mtd/partitions.h>
34 #include <asm/mach-types.h>
35 #include <asm/mach/arch.h>
37 #include <mach/dm646x.h>
38 #include <mach/common.h>
39 #include <mach/serial.h>
41 #include <mach/nand.h>
43 #define NAND_BLOCK_SIZE SZ_128K
45 /* Note: We are setting first partition as 'bootloader' constituting UBL, U-Boot
46 * and U-Boot environment this avoids dependency on any particular combination
47 * of UBL, U-Boot or flashing tools etc.
49 static struct mtd_partition davinci_nand_partitions
[] = {
51 /* UBL, U-Boot with environment */
53 .offset
= MTDPART_OFS_APPEND
,
54 .size
= 16 * NAND_BLOCK_SIZE
,
55 .mask_flags
= MTD_WRITEABLE
, /* force read-only */
58 .offset
= MTDPART_OFS_APPEND
,
63 .offset
= MTDPART_OFS_APPEND
,
64 .size
= MTDPART_SIZ_FULL
,
69 static struct davinci_nand_pdata davinci_nand_data
= {
72 .parts
= davinci_nand_partitions
,
73 .nr_parts
= ARRAY_SIZE(davinci_nand_partitions
),
74 .ecc_mode
= NAND_ECC_HW
,
78 #define DAVINCI_ASYNC_EMIF_CONTROL_BASE 0x20008000
79 #define DAVINCI_ASYNC_EMIF_DATA_CE0_BASE 0x42000000
81 static struct resource davinci_nand_resources
[] = {
83 .start
= DAVINCI_ASYNC_EMIF_DATA_CE0_BASE
,
84 .end
= DAVINCI_ASYNC_EMIF_DATA_CE0_BASE
+ SZ_32M
- 1,
85 .flags
= IORESOURCE_MEM
,
87 .start
= DAVINCI_ASYNC_EMIF_CONTROL_BASE
,
88 .end
= DAVINCI_ASYNC_EMIF_CONTROL_BASE
+ SZ_4K
- 1,
89 .flags
= IORESOURCE_MEM
,
93 static struct platform_device davinci_nand_device
= {
94 .name
= "davinci_nand",
97 .num_resources
= ARRAY_SIZE(davinci_nand_resources
),
98 .resource
= davinci_nand_resources
,
101 .platform_data
= &davinci_nand_data
,
105 #if defined(CONFIG_BLK_DEV_PALMCHIP_BK3710) || \
106 defined(CONFIG_BLK_DEV_PALMCHIP_BK3710_MODULE)
112 /* CPLD Register 0 bits to control ATA */
113 #define DM646X_EVM_ATA_RST BIT(0)
114 #define DM646X_EVM_ATA_PWD BIT(1)
116 /* CPLD Register 0 Client: used for I/O Control */
117 static int cpld_reg0_probe(struct i2c_client
*client
,
118 const struct i2c_device_id
*id
)
122 struct i2c_msg msg
[2] = {
124 .addr
= client
->addr
,
130 .addr
= client
->addr
,
137 /* Clear ATA_RSTn and ATA_PWD bits to enable ATA operation. */
138 i2c_transfer(client
->adapter
, msg
, 1);
139 data
&= ~(DM646X_EVM_ATA_RST
| DM646X_EVM_ATA_PWD
);
140 i2c_transfer(client
->adapter
, msg
+ 1, 1);
146 static const struct i2c_device_id cpld_reg_ids
[] = {
151 static struct i2c_driver dm6467evm_cpld_driver
= {
152 .driver
.name
= "cpld_reg0",
153 .id_table
= cpld_reg_ids
,
154 .probe
= cpld_reg0_probe
,
159 static struct gpio_led evm_leds
[] = {
160 { .name
= "DS1", .active_low
= 1, },
161 { .name
= "DS2", .active_low
= 1, },
162 { .name
= "DS3", .active_low
= 1, },
163 { .name
= "DS4", .active_low
= 1, },
166 static const struct gpio_led_platform_data evm_led_data
= {
167 .num_leds
= ARRAY_SIZE(evm_leds
),
171 static struct platform_device
*evm_led_dev
;
173 static int evm_led_setup(struct i2c_client
*client
, int gpio
,
174 unsigned int ngpio
, void *c
)
176 struct gpio_led
*leds
= evm_leds
;
184 evm_led_dev
= platform_device_alloc("leds-gpio", 0);
185 platform_device_add_data(evm_led_dev
, &evm_led_data
,
186 sizeof(evm_led_data
));
188 evm_led_dev
->dev
.parent
= &client
->dev
;
189 status
= platform_device_add(evm_led_dev
);
191 platform_device_put(evm_led_dev
);
197 static int evm_led_teardown(struct i2c_client
*client
, int gpio
,
198 unsigned ngpio
, void *c
)
201 platform_device_unregister(evm_led_dev
);
207 static int evm_sw_gpio
[4] = { -EINVAL
, -EINVAL
, -EINVAL
, -EINVAL
};
209 static int evm_sw_setup(struct i2c_client
*client
, int gpio
,
210 unsigned ngpio
, void *c
)
216 for (i
= 0; i
< 4; ++i
) {
217 snprintf(label
, 10, "user_sw%d", i
);
218 status
= gpio_request(gpio
, label
);
221 evm_sw_gpio
[i
] = gpio
++;
223 status
= gpio_direction_input(evm_sw_gpio
[i
]);
225 gpio_free(evm_sw_gpio
[i
]);
226 evm_sw_gpio
[i
] = -EINVAL
;
230 status
= gpio_export(evm_sw_gpio
[i
], 0);
232 gpio_free(evm_sw_gpio
[i
]);
233 evm_sw_gpio
[i
] = -EINVAL
;
239 for (i
= 0; i
< 4; ++i
) {
240 if (evm_sw_gpio
[i
] != -EINVAL
) {
241 gpio_free(evm_sw_gpio
[i
]);
242 evm_sw_gpio
[i
] = -EINVAL
;
248 static int evm_sw_teardown(struct i2c_client
*client
, int gpio
,
249 unsigned ngpio
, void *c
)
253 for (i
= 0; i
< 4; ++i
) {
254 if (evm_sw_gpio
[i
] != -EINVAL
) {
255 gpio_unexport(evm_sw_gpio
[i
]);
256 gpio_free(evm_sw_gpio
[i
]);
257 evm_sw_gpio
[i
] = -EINVAL
;
263 static int evm_pcf_setup(struct i2c_client
*client
, int gpio
,
264 unsigned int ngpio
, void *c
)
271 status
= evm_sw_setup(client
, gpio
, 4, c
);
275 return evm_led_setup(client
, gpio
+4, 4, c
);
278 static int evm_pcf_teardown(struct i2c_client
*client
, int gpio
,
279 unsigned int ngpio
, void *c
)
283 evm_sw_teardown(client
, gpio
, 4, c
);
284 evm_led_teardown(client
, gpio
+4, 4, c
);
289 static struct pcf857x_platform_data pcf_data
= {
290 .gpio_base
= DAVINCI_N_GPIO
+1,
291 .setup
= evm_pcf_setup
,
292 .teardown
= evm_pcf_teardown
,
295 /* Most of this EEPROM is unused, but U-Boot uses some data:
296 * - 0x7f00, 6 bytes Ethernet Address
297 * - ... newer boards may have more
300 static struct at24_platform_data eeprom_info
= {
301 .byte_len
= (256*1024) / 8,
303 .flags
= AT24_FLAG_ADDR16
,
304 .setup
= davinci_get_mac_addr
,
305 .context
= (void *)0x7f00,
308 static u8 dm646x_iis_serializer_direction
[] = {
309 TX_MODE
, RX_MODE
, INACTIVE_MODE
, INACTIVE_MODE
,
312 static u8 dm646x_dit_serializer_direction
[] = {
316 static struct snd_platform_data dm646x_evm_snd_data
[] = {
318 .tx_dma_offset
= 0x400,
319 .rx_dma_offset
= 0x400,
320 .op_mode
= DAVINCI_MCASP_IIS_MODE
,
321 .num_serializer
= ARRAY_SIZE(dm646x_iis_serializer_direction
),
323 .serial_dir
= dm646x_iis_serializer_direction
,
324 .eventq_no
= EVENTQ_0
,
327 .tx_dma_offset
= 0x400,
329 .op_mode
= DAVINCI_MCASP_DIT_MODE
,
330 .num_serializer
= ARRAY_SIZE(dm646x_dit_serializer_direction
),
332 .serial_dir
= dm646x_dit_serializer_direction
,
333 .eventq_no
= EVENTQ_0
,
337 static struct i2c_client
*cpld_client
;
339 static int cpld_video_probe(struct i2c_client
*client
,
340 const struct i2c_device_id
*id
)
342 cpld_client
= client
;
346 static int __devexit
cpld_video_remove(struct i2c_client
*client
)
352 static const struct i2c_device_id cpld_video_id
[] = {
357 static struct i2c_driver cpld_video_driver
= {
359 .name
= "cpld_video",
361 .probe
= cpld_video_probe
,
362 .remove
= cpld_video_remove
,
363 .id_table
= cpld_video_id
,
366 static void evm_init_cpld(void)
368 i2c_add_driver(&cpld_video_driver
);
371 static struct i2c_board_info __initdata i2c_info
[] = {
373 I2C_BOARD_INFO("24c256", 0x50),
374 .platform_data
= &eeprom_info
,
377 I2C_BOARD_INFO("pcf8574a", 0x38),
378 .platform_data
= &pcf_data
,
381 I2C_BOARD_INFO("cpld_reg0", 0x3a),
384 I2C_BOARD_INFO("tlv320aic33", 0x18),
387 I2C_BOARD_INFO("cpld_video", 0x3b),
391 static struct davinci_i2c_platform_data i2c_pdata
= {
392 .bus_freq
= 100 /* kHz */,
393 .bus_delay
= 0 /* usec */,
396 #define VIDCLKCTL_OFFSET (DAVINCI_SYSTEM_MODULE_BASE + 0x38)
397 #define VSCLKDIS_OFFSET (DAVINCI_SYSTEM_MODULE_BASE + 0x6c)
398 #define VCH2CLK_MASK (BIT_MASK(10) | BIT_MASK(9) | BIT_MASK(8))
399 #define VCH2CLK_SYSCLK8 (BIT(9))
400 #define VCH2CLK_AUXCLK (BIT(9) | BIT(8))
401 #define VCH3CLK_MASK (BIT_MASK(14) | BIT_MASK(13) | BIT_MASK(12))
402 #define VCH3CLK_SYSCLK8 (BIT(13))
403 #define VCH3CLK_AUXCLK (BIT(14) | BIT(13))
405 #define VIDCH2CLK (BIT(10))
406 #define VIDCH3CLK (BIT(11))
407 #define VIDCH1CLK (BIT(4))
408 #define TVP7002_INPUT (BIT(4))
409 #define TVP5147_INPUT (~BIT(4))
410 #define VPIF_INPUT_ONE_CHANNEL (BIT(5))
411 #define VPIF_INPUT_TWO_CHANNEL (~BIT(5))
412 #define TVP5147_CH0 "tvp514x-0"
413 #define TVP5147_CH1 "tvp514x-1"
415 static void __iomem
*vpif_vidclkctl_reg
;
416 static void __iomem
*vpif_vsclkdis_reg
;
417 /* spin lock for updating above registers */
418 static spinlock_t vpif_reg_lock
;
420 static int set_vpif_clock(int mux_mode
, int hd
)
427 if (!vpif_vidclkctl_reg
|| !vpif_vsclkdis_reg
|| !cpld_client
)
430 /* disable the clock */
431 spin_lock_irqsave(&vpif_reg_lock
, flags
);
432 value
= __raw_readl(vpif_vsclkdis_reg
);
433 value
|= (VIDCH3CLK
| VIDCH2CLK
);
434 __raw_writel(value
, vpif_vsclkdis_reg
);
435 spin_unlock_irqrestore(&vpif_reg_lock
, flags
);
437 val
= i2c_smbus_read_byte(cpld_client
);
446 err
= i2c_smbus_write_byte(cpld_client
, val
);
450 value
= __raw_readl(vpif_vidclkctl_reg
);
451 value
&= ~(VCH2CLK_MASK
);
452 value
&= ~(VCH3CLK_MASK
);
455 value
|= (VCH2CLK_SYSCLK8
| VCH3CLK_SYSCLK8
);
457 value
|= (VCH2CLK_AUXCLK
| VCH3CLK_AUXCLK
);
459 __raw_writel(value
, vpif_vidclkctl_reg
);
461 spin_lock_irqsave(&vpif_reg_lock
, flags
);
462 value
= __raw_readl(vpif_vsclkdis_reg
);
463 /* enable the clock */
464 value
&= ~(VIDCH3CLK
| VIDCH2CLK
);
465 __raw_writel(value
, vpif_vsclkdis_reg
);
466 spin_unlock_irqrestore(&vpif_reg_lock
, flags
);
471 static struct vpif_subdev_info dm646x_vpif_subdev
[] = {
475 I2C_BOARD_INFO("adv7343", 0x2a),
481 I2C_BOARD_INFO("ths7303", 0x2c),
486 static const char *output
[] = {
492 static struct vpif_display_config dm646x_vpif_display_config
= {
493 .set_clock
= set_vpif_clock
,
494 .subdevinfo
= dm646x_vpif_subdev
,
495 .subdev_count
= ARRAY_SIZE(dm646x_vpif_subdev
),
497 .output_count
= ARRAY_SIZE(output
),
498 .card_name
= "DM646x EVM",
502 * setup_vpif_input_path()
503 * @channel: channel id (0 - CH0, 1 - CH1)
504 * @sub_dev_name: ptr sub device name
506 * This will set vpif input to capture data from tvp514x or
509 static int setup_vpif_input_path(int channel
, const char *sub_dev_name
)
514 /* for channel 1, we don't do anything */
521 val
= i2c_smbus_read_byte(cpld_client
);
525 if (!strcmp(sub_dev_name
, TVP5147_CH0
) ||
526 !strcmp(sub_dev_name
, TVP5147_CH1
))
527 val
&= TVP5147_INPUT
;
529 val
|= TVP7002_INPUT
;
531 err
= i2c_smbus_write_byte(cpld_client
, val
);
538 * setup_vpif_input_channel_mode()
539 * @mux_mode: mux mode. 0 - 1 channel or (1) - 2 channel
541 * This will setup input mode to one channel (TVP7002) or 2 channel (TVP5147)
543 static int setup_vpif_input_channel_mode(int mux_mode
)
550 if (!vpif_vsclkdis_reg
|| !cpld_client
)
553 val
= i2c_smbus_read_byte(cpld_client
);
557 spin_lock_irqsave(&vpif_reg_lock
, flags
);
558 value
= __raw_readl(vpif_vsclkdis_reg
);
560 val
&= VPIF_INPUT_TWO_CHANNEL
;
563 val
|= VPIF_INPUT_ONE_CHANNEL
;
566 __raw_writel(value
, vpif_vsclkdis_reg
);
567 spin_unlock_irqrestore(&vpif_reg_lock
, flags
);
569 err
= i2c_smbus_write_byte(cpld_client
, val
);
576 static struct tvp514x_platform_data tvp5146_pdata
= {
582 #define TVP514X_STD_ALL (V4L2_STD_NTSC | V4L2_STD_PAL)
584 static struct vpif_subdev_info vpif_capture_sdev_info
[] = {
588 I2C_BOARD_INFO("tvp5146", 0x5d),
589 .platform_data
= &tvp5146_pdata
,
591 .input
= INPUT_CVBS_VI2B
,
592 .output
= OUTPUT_10BIT_422_EMBEDDED_SYNC
,
595 .if_type
= VPIF_IF_BT656
,
604 I2C_BOARD_INFO("tvp5146", 0x5c),
605 .platform_data
= &tvp5146_pdata
,
607 .input
= INPUT_SVIDEO_VI2C_VI1C
,
608 .output
= OUTPUT_10BIT_422_EMBEDDED_SYNC
,
611 .if_type
= VPIF_IF_BT656
,
619 static const struct vpif_input dm6467_ch0_inputs
[] = {
624 .type
= V4L2_INPUT_TYPE_CAMERA
,
625 .std
= TVP514X_STD_ALL
,
627 .subdev_name
= TVP5147_CH0
,
631 static const struct vpif_input dm6467_ch1_inputs
[] = {
636 .type
= V4L2_INPUT_TYPE_CAMERA
,
637 .std
= TVP514X_STD_ALL
,
639 .subdev_name
= TVP5147_CH1
,
643 static struct vpif_capture_config dm646x_vpif_capture_cfg
= {
644 .setup_input_path
= setup_vpif_input_path
,
645 .setup_input_channel_mode
= setup_vpif_input_channel_mode
,
646 .subdev_info
= vpif_capture_sdev_info
,
647 .subdev_count
= ARRAY_SIZE(vpif_capture_sdev_info
),
649 .inputs
= dm6467_ch0_inputs
,
650 .input_count
= ARRAY_SIZE(dm6467_ch0_inputs
),
653 .inputs
= dm6467_ch1_inputs
,
654 .input_count
= ARRAY_SIZE(dm6467_ch1_inputs
),
658 static void __init
evm_init_video(void)
660 vpif_vidclkctl_reg
= ioremap(VIDCLKCTL_OFFSET
, 4);
661 vpif_vsclkdis_reg
= ioremap(VSCLKDIS_OFFSET
, 4);
662 if (!vpif_vidclkctl_reg
|| !vpif_vsclkdis_reg
) {
663 pr_err("Can't map VPIF VIDCLKCTL or VSCLKDIS registers\n");
666 spin_lock_init(&vpif_reg_lock
);
668 dm646x_setup_vpif(&dm646x_vpif_display_config
,
669 &dm646x_vpif_capture_cfg
);
672 static void __init
evm_init_i2c(void)
674 davinci_init_i2c(&i2c_pdata
);
675 i2c_add_driver(&dm6467evm_cpld_driver
);
676 i2c_register_board_info(1, i2c_info
, ARRAY_SIZE(i2c_info
));
681 static void __init
davinci_map_io(void)
686 static struct davinci_uart_config uart_config __initdata
= {
687 .enabled_uarts
= (1 << 0),
690 #define DM646X_EVM_PHY_MASK (0x2)
691 #define DM646X_EVM_MDIO_FREQUENCY (2200000) /* PHY bus frequency */
693 static __init
void evm_init(void)
695 struct davinci_soc_info
*soc_info
= &davinci_soc_info
;
698 davinci_serial_init(&uart_config
);
699 dm646x_init_mcasp0(&dm646x_evm_snd_data
[0]);
700 dm646x_init_mcasp1(&dm646x_evm_snd_data
[1]);
702 platform_device_register(&davinci_nand_device
);
707 soc_info
->emac_pdata
->phy_mask
= DM646X_EVM_PHY_MASK
;
708 soc_info
->emac_pdata
->mdio_max_freq
= DM646X_EVM_MDIO_FREQUENCY
;
711 static __init
void davinci_dm646x_evm_irq_init(void)
716 MACHINE_START(DAVINCI_DM6467_EVM
, "DaVinci DM646x EVM")
718 .io_pg_offst
= (__IO_ADDRESS(IO_PHYS
) >> 18) & 0xfffc,
719 .boot_params
= (0x80000100),
720 .map_io
= davinci_map_io
,
721 .init_irq
= davinci_dm646x_evm_irq_init
,
722 .timer
= &davinci_timer
,
723 .init_machine
= evm_init
,