BeagleBoard Rev C4 (Kernel 2.6.39.4) 7" TFT LCD

Discuss TI Beagleboard, Pandaboard, their related extensions and accessories
Duckshot
Posts: 6
Joined: Mon Oct 03, 2011 11:37 am

BeagleBoard Rev C4 (Kernel 2.6.39.4) 7" TFT LCD

Post by Duckshot » Tue Dec 06, 2011 2:30 am

I've been trying to get the LCD to work with my Beagleboard C4 and a 2.6.39.4 Kernel built with Buildroot. I have had a look at the explanations in the Android thread which has been very useful. However, I can't seem to get the LCD to display anything apart from a white screen.

I have enbled DVI and set the resolution to 800x480 via the u-boot bootargs. My DVI output is working fine for this, I thought the LCD would mirror the DVI output.

Should the LCD display the beagleboard orange screen on boot up like the DVI out?
Do I need to enable the raw LCD headers on the board for this to work?

Image

esky-sh
Posts: 1435
Joined: Sat Dec 20, 2008 4:21 am

Re: BeagleBoard Rev C4 (Kernel 2.6.39.4) 7" TFT LCD

Post by esky-sh » Tue Dec 06, 2011 3:31 am

There are 2 factors may be taken into consideration:

1. The timing of this LCD screen.
In kernel 2.6.32 dss, there is no resolution support for TFT 800x480. But it is there since kernel 2.6.37. It is located in file kernel/drivers/video/omap2/displays/panel-generic.c.
I suggest you to check into this file, compare if the resolution/timing you selected match with beada frame.

2. Hardware verify.
One of our customers, 'hanh96_clone' provides an android 2.3.4 test image for BB Rev C4 with the frame.
You can verify with it to ensure hardwares on you hand are all ok.

Duckshot
Posts: 6
Joined: Mon Oct 03, 2011 11:37 am

Re: BeagleBoard Rev C4 (Kernel 2.6.39.4) 7" TFT LCD

Post by Duckshot » Mon Dec 19, 2011 6:45 am

Thanks for your help.

It is now confirmed working with this Kernel.

The header connections were not soldered so the LCD signal was not coming through.

I made the same changes to board-omap3beagle.c as found in the Gingerbread thread.
I did not have to make any changes to ads7846.c.

The following needed to be added to the Kernel config:
MCSPI driver for OMAP
User mode SPI device driver support
GPIO-Based bitbanging SPI master
Utilities for Bitbanging


I then used tslib to calibrate the touchscreen. I should also note that I am using TinyX.
You need to set the touchscreen device for tslib chaging the enviroment variable:

export TSLIB_TSDEVICE=/dev/input/event1

I then ran ts_calibrate, then ts_test

tslib is supported by Embedded QT so in theory this should now work with the QT interface I am developing. I will post to confirm later.

Image
Last edited by Duckshot on Tue Dec 20, 2011 12:22 am, edited 1 time in total.

esky-sh
Posts: 1435
Joined: Sat Dec 20, 2008 4:21 am

Re: BeagleBoard Rev C4 (Kernel 2.6.39.4) 7" TFT LCD

Post by esky-sh » Mon Dec 19, 2011 6:16 pm

yes. you do not need to make any change in ad7846.c if you already have an explicit touch screen calibration method, e.g. ts_calibrate in ts.lib.

BTW, I can not see the picture you linked. -->
workingl.png
workingl.png (12.15 KiB) Viewed 11259 times

esky-sh
Posts: 1435
Joined: Sat Dec 20, 2008 4:21 am

Re: BeagleBoard Rev C4 (Kernel 2.6.39.4) 7" TFT LCD

Post by esky-sh » Wed Dec 21, 2011 2:02 am

Duckshot wrote:Thanks for your help.

It is now confirmed working with this Kernel.

The header connections were not soldered so the LCD signal was not coming through.

I made the same changes to board-omap3beagle.c as found in the Gingerbread thread.
I did not have to make any changes to ads7846.c.

The following needed to be added to the Kernel config:
MCSPI driver for OMAP
User mode SPI device driver support
GPIO-Based bitbanging SPI master
Utilities for Bitbanging


I then used tslib to calibrate the touchscreen. I should also note that I am using TinyX.
You need to set the touchscreen device for tslib chaging the enviroment variable:

export TSLIB_TSDEVICE=/dev/input/event1

I then ran ts_calibrate, then ts_test

tslib is supported by Embedded QT so in theory this should now work with the QT interface I am developing. I will post to confirm later.

Image
Nice looking for your handwriting.
Please do not forget update us when you make qtE work on this frame. :)

kgy
Posts: 4
Joined: Tue Sep 20, 2011 10:33 pm

Re: BeagleBoard Rev C4 (Kernel 2.6.39.4) 7" TFT LCD

Post by kgy » Sun Jan 29, 2012 4:15 am

Hi,

I am trying to do the same with Angstrom, using the kernel 2.6.39+. The display works, but the touch is not.
I have modified the u-boot according to the files downloaded from the FTP site: beagle-xm_android_source/uboot/beagle.h. Unfortunately i could not find one especially for Beagleboard-c4, however, it seems that there are C4-specific modifications in this file. The pin mux module is switched off in the kernel.
I tried to use the driver ads7846, without any result. It does nothing: just starts without any message, but no new input device is added. The existing input devices are all related to the keyboard and mouse. The other drivers you mentioned are all switched on.
I have added the device driver tsc-beada.c. It can be compiled and started without any problems, but also does nothing. I do not understand here the I2C and SPI bus usage: which one is necessary? (both?) The chip seems to have SPI bus.

Problems can be with the file board-omap3beagle.c: i see it already has the modifications, or maybe i miss something here. Can you send your patch of this file?

Do i miss something else?

Thanx in advance
Gyorgy Kovesdi

Duckshot
Posts: 6
Joined: Mon Oct 03, 2011 11:37 am

Re: BeagleBoard Rev C4 (Kernel 2.6.39.4) 7" TFT LCD

Post by Duckshot » Sun Jan 29, 2012 4:30 am

kgy wrote:Hi,

I am trying to do the same with Angstrom, using the kernel 2.6.39+. The display works, but the touch is not.
I have modified the u-boot according to the files downloaded from the FTP site: beagle-xm_android_source/uboot/beagle.h. Unfortunately i could not find one especially for Beagleboard-c4, however, it seems that there are C4-specific modifications in this file. The pin mux module is switched off in the kernel.
I tried to use the driver ads7846, without any result. It does nothing: just starts without any message, but no new input device is added. The existing input devices are all related to the keyboard and mouse. The other drivers you mentioned are all switched on.
I have added the device driver tsc-beada.c. It can be compiled and started without any problems, but also does nothing. I do not understand here the I2C and SPI bus usage: which one is necessary? (both?) The chip seems to have SPI bus.

Problems can be with the file board-omap3beagle.c: i see it already has the modifications, or maybe i miss something here. Can you send your patch of this file?

Do i miss something else?

Thanx in advance
Gyorgy Kovesdi
The only modifications I had to make to the code were in linux-2.6.39.4/arch/arm/mach-omap2/board-omap3beagle.c, enabling the ads7846 driver in the kernel with the other changes noted in my previous post. After rebuilding the Kernel the touchscreen was recognised on boot. I just followed the directions from the Gingerbread thread.

Here is my board-omap3beagle.c

Code: Select all

/*
 * linux/arch/arm/mach-omap2/board-omap3beagle.c
 *
 * Copyright (C) 2008 Texas Instruments
 *
 * Modified from mach-omap2/board-3430sdp.c
 *
 * Initial code: Syed Mohammed Khasim
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/leds.h>
#include <linux/backlight.h> //JJ
#include <linux/gpio.h>
#include <linux/input.h>
#include <linux/gpio_keys.h>
#include <linux/opp.h>

#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/mtd/nand.h>
#include <linux/mmc/host.h>

#include <linux/regulator/machine.h>
#include <linux/i2c/twl.h>

//For touchscreen JJ
#include <linux/spi/ads7846.h>

#include <mach/hardware.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <asm/mach/flash.h>

#include <plat/board.h>
#include <plat/common.h>
#include <plat/display.h>
#include <plat/panel-generic-dpi.h>
#include <plat/gpmc.h>
#include <plat/nand.h>
#include <plat/usb.h>
#include <plat/omap_device.h>

#include "mux.h"
#include "hsmmc.h"
#include "timer-gp.h"
#include "pm.h"

#define NAND_BLOCK_SIZE		SZ_128K

/*
 * OMAP3 Beagle revision
 * Run time detection of Beagle revision is done by reading GPIO.
 * GPIO ID -
 *	AXBX	= GPIO173, GPIO172, GPIO171: 1 1 1
 *	C1_3	= GPIO173, GPIO172, GPIO171: 1 1 0
 *	C4	= GPIO173, GPIO172, GPIO171: 1 0 1
 *	XM	= GPIO173, GPIO172, GPIO171: 0 0 0
 */
enum {
	OMAP3BEAGLE_BOARD_UNKN = 0,
	OMAP3BEAGLE_BOARD_AXBX,
	OMAP3BEAGLE_BOARD_C1_3,
	OMAP3BEAGLE_BOARD_C4,
	OMAP3BEAGLE_BOARD_XM,
};

static u8 omap3_beagle_version;

static void __init omap3_beagle_config_mcspi3_mux(void); //JJ
static void __init omap3_beagle_config_mcspi4_mux(void); //JJ

static u8 omap3_beagle_get_rev(void)
{
	return omap3_beagle_version;
}

static void __init omap3_beagle_init_rev(void)
{
	int ret;
	u16 beagle_rev = 0;

	omap_mux_init_gpio(171, OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_gpio(172, OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_gpio(173, OMAP_PIN_INPUT_PULLUP);

	ret = gpio_request(171, "rev_id_0");
	if (ret < 0)
		goto fail0;

	ret = gpio_request(172, "rev_id_1");
	if (ret < 0)
		goto fail1;

	ret = gpio_request(173, "rev_id_2");
	if (ret < 0)
		goto fail2;

	gpio_direction_input(171);
	gpio_direction_input(172);
	gpio_direction_input(173);

	beagle_rev = gpio_get_value(171) | (gpio_get_value(172) << 1)
			| (gpio_get_value(173) << 2);

	switch (beagle_rev) {
	case 7:
		printk(KERN_INFO "OMAP3 Beagle Rev: Ax/Bx\n");
		omap3_beagle_version = OMAP3BEAGLE_BOARD_AXBX;
		break;
	case 6:
		printk(KERN_INFO "OMAP3 Beagle Rev: C1/C2/C3\n");
		omap3_beagle_version = OMAP3BEAGLE_BOARD_C1_3;
		break;
	case 5:
		printk(KERN_INFO "OMAP3 Beagle Rev: C4\n");
		omap3_beagle_version = OMAP3BEAGLE_BOARD_C4;
		break;
	case 0:
		printk(KERN_INFO "OMAP3 Beagle Rev: xM\n");
		omap3_beagle_version = OMAP3BEAGLE_BOARD_XM;
		break;
	default:
		printk(KERN_INFO "OMAP3 Beagle Rev: unknown %hd\n", beagle_rev);
		omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
	}

	return;

fail2:
	gpio_free(172);
fail1:
	gpio_free(171);
fail0:
	printk(KERN_ERR "Unable to get revision detection GPIO pins\n");
	omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;

	return;
}

static struct mtd_partition omap3beagle_nand_partitions[] = {
	/* All the partition sizes are listed in terms of NAND block size */
	{
		.name		= "X-Loader",
		.offset		= 0,
		.size		= 4 * NAND_BLOCK_SIZE,
		.mask_flags	= MTD_WRITEABLE,	/* force read-only */
	},
	{
		.name		= "U-Boot",
		.offset		= MTDPART_OFS_APPEND,	/* Offset = 0x80000 */
		.size		= 15 * NAND_BLOCK_SIZE,
		.mask_flags	= MTD_WRITEABLE,	/* force read-only */
	},
	{
		.name		= "U-Boot Env",
		.offset		= MTDPART_OFS_APPEND,	/* Offset = 0x260000 */
		.size		= 1 * NAND_BLOCK_SIZE,
	},
	{
		.name		= "Kernel",
		.offset		= MTDPART_OFS_APPEND,	/* Offset = 0x280000 */
		.size		= 32 * NAND_BLOCK_SIZE,
	},
	{
		.name		= "File System",
		.offset		= MTDPART_OFS_APPEND,	/* Offset = 0x680000 */
		.size		= MTDPART_SIZ_FULL,
	},
};

static struct omap_nand_platform_data omap3beagle_nand_data = {
	.options	= NAND_BUSWIDTH_16,
	.parts		= omap3beagle_nand_partitions,
	.nr_parts	= ARRAY_SIZE(omap3beagle_nand_partitions),
	.dma_channel	= -1,		/* disable DMA in OMAP NAND driver */
	.nand_setup	= NULL,
	.dev_ready	= NULL,
};
//JJ START

static void __init omap3_beagle_config_mcspi3_mux(void)
{
        // NOTE: Clock pins need to be in input mode
	omap_mux_init_signal("sdmmc2_clk.mcspi3_clk", OMAP_PIN_INPUT);
	omap_mux_init_signal("sdmmc2_dat3.mcspi3_cs0", OMAP_PIN_OUTPUT);
	omap_mux_init_signal("sdmmc2_dat2.mcspi3_cs1", OMAP_PIN_OUTPUT);
	omap_mux_init_signal("sdmmc2_cmd.mcspi3_simo", OMAP_PIN_OUTPUT);
	omap_mux_init_signal("sdmmc2_dat0.mcspi3_somi", OMAP_PIN_INPUT_PULLUP);
}

static void __init omap3_beagle_config_mcspi4_mux(void)
{
        // NOTE: Clock pins need to be in input mode
	omap_mux_init_signal("mcbsp1_clkr.mcspi4_clk", OMAP_PIN_INPUT);
	omap_mux_init_signal("mcbsp1_fsx.mcspi4_cs0", OMAP_PIN_OUTPUT);
	omap_mux_init_signal("mcbsp1_dx.mcspi4_simo", OMAP_PIN_OUTPUT);
	omap_mux_init_signal("mcbsp1_dr.mcspi4_somi", OMAP_PIN_INPUT_PULLUP);
}


#ifdef CONFIG_TOUCHSCREEN_ADS7846

#define OMAP3_EVM_TS_GPIO       133

#include <plat/mcspi.h>
#include <linux/spi/spi.h>

static struct omap2_mcspi_device_config ads7846_mcspi_config = {
        .turbo_mode     = 0,
        .single_channel = 1,    /* 0: slave, 1: master */
};

static int ads7846_get_pendown_state(void)
{
        return !gpio_get_value(OMAP3_EVM_TS_GPIO);
}

struct ads7846_platform_data ads7846_config = {
        .x_max                  = 0x0fff,
        .y_max                  = 0x0fff,
        .x_plate_ohms           = 180,
        .pressure_max           = 255,
        .debounce_max           = 10,
        .debounce_tol           = 3,
        .debounce_rep           = 1,
        .get_pendown_state      = ads7846_get_pendown_state,
        .keep_vref_on           = 1,
        .settle_delay_usecs     = 150,
        .wakeup                         = true,
};

struct spi_board_info omap3evm_spi_board_info[] = {
        [0] = {
                .modalias               = "ads7846",
                .bus_num                = 3,
                .chip_select            = 0,
                .max_speed_hz           = 1500000,
                .controller_data        = &ads7846_mcspi_config,
                .irq                    = OMAP_GPIO_IRQ(OMAP3_EVM_TS_GPIO),
                .platform_data          = &ads7846_config,
        },
};

static void ads7846_dev_init(void)
{
	printk("Initialize ads7846 touch screen controller\n");

        if (gpio_request(OMAP3_EVM_TS_GPIO, "ADS7846 pendown") < 0)
                printk(KERN_ERR "can't get ads7846 pen down GPIO\n");

        gpio_direction_input(OMAP3_EVM_TS_GPIO);

        gpio_set_debounce(OMAP3_EVM_TS_GPIO, 0xa);
}

#else
static inline void __init ads7846_dev_init(void) { return; }
#endif









//END
/* DSS */

static int beagle_enable_dvi(struct omap_dss_device *dssdev)
{
	if (gpio_is_valid(dssdev->reset_gpio))
		gpio_set_value(dssdev->reset_gpio, 1);

	return 0;
}

static void beagle_disable_dvi(struct omap_dss_device *dssdev)
{
	if (gpio_is_valid(dssdev->reset_gpio))
		gpio_set_value(dssdev->reset_gpio, 0);
}

static struct panel_generic_dpi_data dvi_panel = {
	.name = "generic",
	.platform_enable = beagle_enable_dvi,
	.platform_disable = beagle_disable_dvi,
};

static struct omap_dss_device beagle_dvi_device = {
	.type = OMAP_DISPLAY_TYPE_DPI,
	.name = "dvi",
	.driver_name = "generic_dpi_panel",
	.data = &dvi_panel,
	.phy.dpi.data_lines = 24,
	.reset_gpio = -EINVAL,
};

static struct omap_dss_device beagle_tv_device = {
	.name = "tv",
	.driver_name = "venc",
	.type = OMAP_DISPLAY_TYPE_VENC,
	.phy.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO,
};

static struct omap_dss_device *beagle_dss_devices[] = {
	&beagle_dvi_device,
	&beagle_tv_device,
};

static struct omap_dss_board_info beagle_dss_data = {
	.num_devices = ARRAY_SIZE(beagle_dss_devices),
	.devices = beagle_dss_devices,
	.default_device = &beagle_dvi_device,
};

static struct regulator_consumer_supply beagle_vdac_supply =
	REGULATOR_SUPPLY("vdda_dac", "omapdss_venc");

static struct regulator_consumer_supply beagle_vdvi_supplies[] = {
	REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
};

static void __init beagle_display_init(void)
{
	int r;

	r = gpio_request(beagle_dvi_device.reset_gpio, "DVI reset");
	if (r < 0) {
		printk(KERN_ERR "Unable to get DVI reset GPIO\n");
		return;
	}

	gpio_direction_output(beagle_dvi_device.reset_gpio, 0);
}

#include "sdram-micron-mt46h32m32lf-6.h"

static struct omap2_hsmmc_info mmc[] = {
	{
		.mmc		= 1,
		.caps		= MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA,
		.gpio_wp	= 29,
	},
	{}	/* Terminator */
};

static struct regulator_consumer_supply beagle_vmmc1_supply = {
	.supply			= "vmmc",
};

static struct regulator_consumer_supply beagle_vsim_supply = {
	.supply			= "vmmc_aux",
};

static struct gpio_led gpio_leds[];

static int beagle_twl_gpio_setup(struct device *dev,
		unsigned gpio, unsigned ngpio)
{
	int r;

	if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
		mmc[0].gpio_wp = -EINVAL;
	} else if ((omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_C1_3) ||
		(omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_C4)) {
		omap_mux_init_gpio(23, OMAP_PIN_INPUT);
		mmc[0].gpio_wp = 23;
	} else {
		omap_mux_init_gpio(29, OMAP_PIN_INPUT);
	}
	/* gpio + 0 is "mmc0_cd" (input/IRQ) */
	mmc[0].gpio_cd = gpio + 0;
	omap2_hsmmc_init(mmc);

	/* link regulators to MMC adapters */
	beagle_vmmc1_supply.dev = mmc[0].dev;
	beagle_vsim_supply.dev = mmc[0].dev;

	/* REVISIT: need ehci-omap hooks for external VBUS
	 * power switch and overcurrent detect
	 */
	if (omap3_beagle_get_rev() != OMAP3BEAGLE_BOARD_XM) {
		r = gpio_request(gpio + 1, "EHCI_nOC");
		if (!r) {
			r = gpio_direction_input(gpio + 1);
			if (r)
				gpio_free(gpio + 1);
		}
		if (r)
			pr_err("%s: unable to configure EHCI_nOC\n", __func__);
	}

	/*
	 * TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, XM active
	 * high / others active low)
	 */
	gpio_request(gpio + TWL4030_GPIO_MAX, "nEN_USB_PWR");
	if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM)
		gpio_direction_output(gpio + TWL4030_GPIO_MAX, 1);
	else
		gpio_direction_output(gpio + TWL4030_GPIO_MAX, 0);

	/* DVI reset GPIO is different between beagle revisions */
	if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM)
		beagle_dvi_device.reset_gpio = 129;
	else
		beagle_dvi_device.reset_gpio = 170;

	/* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
	gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;

	/*
	 * gpio + 1 on Xm controls the TFP410's enable line (active low)
	 * gpio + 2 control varies depending on the board rev as follows:
	 * P7/P8 revisions(prototype): Camera EN
	 * A2+ revisions (production): LDO (supplies DVI, serial, led blocks)
	 */
	if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
		r = gpio_request(gpio + 1, "nDVI_PWR_EN");
		if (!r) {
			r = gpio_direction_output(gpio + 1, 0);
			if (r)
				gpio_free(gpio + 1);
		}
		if (r)
			pr_err("%s: unable to configure nDVI_PWR_EN\n",
				__func__);
		r = gpio_request(gpio + 2, "DVI_LDO_EN");
		if (!r) {
			r = gpio_direction_output(gpio + 2, 1);
			if (r)
				gpio_free(gpio + 2);
		}
		if (r)
			pr_err("%s: unable to configure DVI_LDO_EN\n",
				__func__);
	}

	return 0;
}

static struct twl4030_gpio_platform_data beagle_gpio_data = {
	.gpio_base	= OMAP_MAX_GPIO_LINES,
	.irq_base	= TWL4030_GPIO_IRQ_BASE,
	.irq_end	= TWL4030_GPIO_IRQ_END,
	.use_leds	= true,
	.pullups	= BIT(1),
	.pulldowns	= BIT(2) | BIT(6) | BIT(7) | BIT(8) | BIT(13)
				| BIT(15) | BIT(16) | BIT(17),
	.setup		= beagle_twl_gpio_setup,
};

/* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
static struct regulator_init_data beagle_vmmc1 = {
	.constraints = {
		.min_uV			= 1850000,
		.max_uV			= 3150000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= 1,
	.consumer_supplies	= &beagle_vmmc1_supply,
};

/* VSIM for MMC1 pins DAT4..DAT7 (2 mA, plus card == max 50 mA) */
static struct regulator_init_data beagle_vsim = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 3000000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= 1,
	.consumer_supplies	= &beagle_vsim_supply,
};

/* VDAC for DSS driving S-Video (8 mA unloaded, max 65 mA) */
static struct regulator_init_data beagle_vdac = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= 1,
	.consumer_supplies	= &beagle_vdac_supply,
};

/* VPLL2 for digital video outputs */
static struct regulator_init_data beagle_vpll2 = {
	.constraints = {
		.name			= "VDVI",
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= ARRAY_SIZE(beagle_vdvi_supplies),
	.consumer_supplies	= beagle_vdvi_supplies,
};

static struct twl4030_usb_data beagle_usb_data = {
	.usb_mode	= T2_USB_MODE_ULPI,
};

static struct twl4030_codec_audio_data beagle_audio_data;

static struct twl4030_codec_data beagle_codec_data = {
	.audio_mclk = 26000000,
	.audio = &beagle_audio_data,
};

static struct twl4030_platform_data beagle_twldata = {
	.irq_base	= TWL4030_IRQ_BASE,
	.irq_end	= TWL4030_IRQ_END,

	/* platform_data for children goes here */
	.usb		= &beagle_usb_data,
	.gpio		= &beagle_gpio_data,
	.codec		= &beagle_codec_data,
	.vmmc1		= &beagle_vmmc1,
	.vsim		= &beagle_vsim,
	.vdac		= &beagle_vdac,
	.vpll2		= &beagle_vpll2,
};

static struct i2c_board_info __initdata beagle_i2c_boardinfo[] = {
	{
		I2C_BOARD_INFO("twl4030", 0x48),
		.flags = I2C_CLIENT_WAKE,
		.irq = INT_34XX_SYS_NIRQ,
		.platform_data = &beagle_twldata,
	},
};

static struct i2c_board_info __initdata beagle_i2c_eeprom[] = {
       {
               I2C_BOARD_INFO("eeprom", 0x50),
       },
};

static int __init omap3_beagle_i2c_init(void)
{
	omap_register_i2c_bus(1, 2600, beagle_i2c_boardinfo,
			ARRAY_SIZE(beagle_i2c_boardinfo));
	/* Bus 3 is attached to the DVI port where devices like the pico DLP
	 * projector don't work reliably with 400kHz */
	omap_register_i2c_bus(3, 100, beagle_i2c_eeprom, ARRAY_SIZE(beagle_i2c_eeprom));
	return 0;
}

static struct gpio_led gpio_leds[] = {
	{
		.name			= "beagleboard::usr0",
		.default_trigger	= "heartbeat",
		.gpio			= 150,
	},
	{
		.name			= "beagleboard::usr1",
		.default_trigger	= "mmc0",
		.gpio			= 149,
	},
	{
		.name			= "beagleboard::pmu_stat",
		.gpio			= -EINVAL,	/* gets replaced */
		.active_low		= true,
	},
};

static struct gpio_led_platform_data gpio_led_info = {
	.leds		= gpio_leds,
	.num_leds	= ARRAY_SIZE(gpio_leds),
};

static struct platform_device leds_gpio = {
	.name	= "leds-gpio",
	.id	= -1,
	.dev	= {
		.platform_data	= &gpio_led_info,
	},
};

static struct gpio_keys_button gpio_buttons[] = {
	{
		//.code			= BTN_EXTRA,
		//.gpio			= 7,
		.code			= KEY_PROG1, //JJ
		.gpio			= 4,         //JJ
		.desc			= "user",
		.active_low	    = false,     //JJ		
		.wakeup			= 1,
	},
	{//JJ start
		.code			= KEY_PROG2,
		.gpio			= 137,
		.desc			= "s1",
		.active_low		= true,
 		.wakeup			= 1,
 	},
	{
		.code			= KEY_PROG3,
		.gpio			= 138,
		.desc			= "s2",
		.active_low		= true,
		.wakeup			= 1,
	},// JJ END

};

static struct gpio_keys_platform_data gpio_key_info = {
	.buttons	= gpio_buttons,
	.nbuttons	= ARRAY_SIZE(gpio_buttons),
};

static struct platform_device keys_gpio = {
	.name	= "gpio-keys",
	.id	= -1,
	.dev	= {
		.platform_data	= &gpio_key_info,
	},
};

static void __init omap3_beagle_init_early(void)
{
	omap2_init_common_infrastructure();
	omap2_init_common_devices(mt46h32m32lf6_sdrc_params,
				  mt46h32m32lf6_sdrc_params);
}

static void __init omap3_beagle_init_irq(void)
{
	omap_init_irq();
#ifdef CONFIG_OMAP_32K_TIMER
	omap2_gp_clockevent_set_gptimer(12);
#endif
}

static struct platform_device *omap3_beagle_devices[] __initdata = {
	&leds_gpio,
	&keys_gpio,
};

static void __init omap3beagle_flash_init(void)
{
	u8 cs = 0;
	u8 nandcs = GPMC_CS_NUM + 1;

	/* find out the chip-select on which NAND exists */
	while (cs < GPMC_CS_NUM) {
		u32 ret = 0;
		ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);

		if ((ret & 0xC00) == 0x800) {
			printk(KERN_INFO "Found NAND on CS%d\n", cs);
			if (nandcs > GPMC_CS_NUM)
				nandcs = cs;
		}
		cs++;
	}

	if (nandcs > GPMC_CS_NUM) {
		printk(KERN_INFO "NAND: Unable to find configuration "
				 "in GPMC\n ");
		return;
	}

	if (nandcs < GPMC_CS_NUM) {
		omap3beagle_nand_data.cs = nandcs;

		printk(KERN_INFO "Registering NAND on CS%d\n", nandcs);
		if (gpmc_nand_init(&omap3beagle_nand_data) < 0)
			printk(KERN_ERR "Unable to register NAND device\n");
	}
}

static const struct usbhs_omap_board_data usbhs_bdata __initconst = {

	.port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
	.port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
	.port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,

	.phy_reset  = true,
	.reset_gpio_port[0]  = -EINVAL,
	.reset_gpio_port[1]  = 147,
	.reset_gpio_port[2]  = -EINVAL
};

#ifdef CONFIG_OMAP_MUX
static struct omap_board_mux board_mux[] __initdata = {
	{ .reg_offset = OMAP_MUX_TERMINATOR },

//JJ Start
	#ifdef CONFIG_TOUCHSCREEN_ADS7846
        OMAP3_MUX(SDMMC2_DAT1, OMAP_MUX_MODE4 | OMAP_PIN_INPUT_PULLUP |
                               OMAP_PIN_OFF_INPUT_PULLUP | OMAP_PIN_OFF_OUTPUT_LOW |
                               OMAP_PIN_OFF_WAKEUPENABLE),
#endif

//JJ END
};
#endif

static struct omap_musb_board_data musb_board_data = {
	.interface_type		= MUSB_INTERFACE_ULPI,
	.mode			= MUSB_OTG,
	.power			= 100,
};

static void __init beagle_opp_init(void)
{
	int r = 0;

	/* Initialize the omap3 opp table */
	if (omap3_opp_init()) {
		pr_err("%s: opp default init failed\n", __func__);
		return;
	}

	/* Custom OPP enabled for XM */
	if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
		struct omap_hwmod *mh = omap_hwmod_lookup("mpu");
		struct omap_hwmod *dh = omap_hwmod_lookup("iva");
		struct device *dev;

		if (!mh || !dh) {
			pr_err("%s: Aiee.. no mpu/dsp devices? %p %p\n",
				__func__, mh, dh);
			return;
		}
		/* Enable MPU 1GHz and lower opps */
		dev = &mh->od->pdev.dev;
		r = opp_enable(dev, 800000000);
		/* TODO: MPU 1GHz needs SR and ABB */

		/* Enable IVA 800MHz and lower opps */
		dev = &dh->od->pdev.dev;
		r |= opp_enable(dev, 660000000);
		/* TODO: DSP 800MHz needs SR and ABB */
		if (r) {
			pr_err("%s: failed to enable higher opp %d\n",
				__func__, r);
			/*
			 * Cleanup - disable the higher freqs - we dont care
			 * about the results
			 */
			dev = &mh->od->pdev.dev;
			opp_disable(dev, 800000000);
			dev = &dh->od->pdev.dev;
			opp_disable(dev, 660000000);
		}
	}
	return;
}

static void __init omap3_beagle_init(void)
{
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
	omap3_beagle_init_rev();
	omap3_beagle_i2c_init();
	platform_add_devices(omap3_beagle_devices,
			ARRAY_SIZE(omap3_beagle_devices));
	omap_display_init(&beagle_dss_data);
	omap_serial_init();

	//JJ Start
	omap3_beagle_config_mcspi3_mux();
	omap3_beagle_config_mcspi4_mux();
	spi_register_board_info(omap3evm_spi_board_info, ARRAY_SIZE(omap3evm_spi_board_info));
	//JJ End

	omap_mux_init_gpio(170, OMAP_PIN_INPUT);
	gpio_request(170, "DVI_nPD");
	/* REVISIT leave DVI powered down until it's needed ... */
	gpio_direction_output(170, true);

	usb_musb_init(&musb_board_data);
	usbhs_init(&usbhs_bdata);
	omap3beagle_flash_init();

	ads7846_dev_init();

	/* Ensure SDRC pins are mux'd for self-refresh */
	omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
	omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);

	beagle_display_init();
	beagle_opp_init();
}

MACHINE_START(OMAP3_BEAGLE, "OMAP3 Beagle Board")
	/* Maintainer: Syed Mohammed Khasim - http://beagleboard.org */
	.boot_params	= 0x80000100,
	.reserve	= omap_reserve,
	.map_io		= omap3_map_io,
	.init_early	= omap3_beagle_init_early,
	.init_irq	= omap3_beagle_init_irq,
	.init_machine	= omap3_beagle_init,
	.timer		= &omap_timer,
MACHINE_END

Duckshot
Posts: 6
Joined: Mon Oct 03, 2011 11:37 am

Re: BeagleBoard Rev C4 (Kernel 2.6.39.4) 7" TFT LCD

Post by Duckshot » Sun Jan 29, 2012 4:40 am

Nice looking for your handwriting.
Please do not forget update us when you make qtE work on this frame. :)
Just to update that it works great with Qt Embedded. You'll need to set a few enviroment variables to get it working.

export QWS_MOUSE_PROTO=Tslib
export TSLIB_TSDEVICE=/dev/input/event1

You also need to make sure you have run the TS lib calibration routine mentioned in my ealier post.

kgy
Posts: 4
Joined: Tue Sep 20, 2011 10:33 pm

Re: BeagleBoard Rev C4 (Kernel 2.6.39.4) 7" TFT LCD

Post by kgy » Sun Jan 29, 2012 1:41 pm

I tried to read the forums you mentioned, but could not find any new info.
But at least i could do it with kernel version 3.0.17.

The current result is:

[ 0.157135] Initialize ads7846 touch screen controller
....
[ 4.378173] ads7846 spi3.0: touchscreen, irq 293
[ 4.383331] ads7846 spi3.0: no device detected, test read result was 0x00000000

I found this problem on the net, and the solution is probably in the pin mux settings. Unfortunately, the kernel module OMAP_MUX does not work for me (kernel does not boot with it) and probably it is necessary. Is it set for you?

Thanx
Gyorgy Kovesdi

Duckshot
Posts: 6
Joined: Mon Oct 03, 2011 11:37 am

Re: BeagleBoard Rev C4 (Kernel 2.6.39.4) 7" TFT LCD

Post by Duckshot » Sun Jan 29, 2012 2:57 pm

kgy wrote:I tried to read the forums you mentioned, but could not find any new info.
But at least i could do it with kernel version 3.0.17.

The current result is:

[ 0.157135] Initialize ads7846 touch screen controller
....
[ 4.378173] ads7846 spi3.0: touchscreen, irq 293
[ 4.383331] ads7846 spi3.0: no device detected, test read result was 0x00000000

I found this problem on the net, and the solution is probably in the pin mux settings. Unfortunately, the kernel module OMAP_MUX does not work for me (kernel does not boot with it) and probably it is necessary. Is it set for you?

Thanx
Gyorgy Kovesdi
Yes it is set in my kernel config; however I am unsure if it is essential.

Code: Select all

OMAP_MUX [=y]
OMAP_MUX_WARNINGS [=y]
OMAP_MUX_DEBUG [=y]

Post Reply

Who is online

Users browsing this forum: No registered users and 2 guests