25 Replies Latest reply on Nov 17, 2015 11:46 AM by drslurm

    Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel

    mukelarvin_price

      Hi everyone. I am attempting to use the RIoT Board as the basis for a HMI design. I hope to document my progress in this forum. My only other experience configuring and building an embedded Linux/Android device is with the Beaglebone Black so I will be learning about the I.MX 6 and RIoT Board along the way.

       

      My plan is to make a "shield" or "cape" style adapter board which breaks out all of my required I/Os and allows me to connect a parallel RGB LCD and capacitive touch panel.

       

      I plan on configuring the RIoT board with the following I/Os:

       

      After examining the RIoT board User Manual, the I.MX 6 datasheet and the Freescale I/O Mux Tool I believe my goal can be achieved with the following pin mux:

       

      Pin Signal FunctionCPU BallLCD SignalsLCD Function (18 Bit RGB)My Desired Usage
      1VDD_NVCC 3.3V
      25VIN 5V
      3GND GND
      4GND GND
      5GPIO4_16 GPION19DI0_DISP_CLKPixel Clock
      6CSPI3_CLK SPI3 clock P24DISP0_DAT0B0
      7GPIO4_17 GPION21DI0_PIN15Data Enable
      8CSPI3_MOSI SPI3 master output salve inputP22DISP0_DAT1B1
      9GPIO4_18 GPION25DI0_PIN2Hsync
      10CSPI3_MISO SPI3 master input salve outputP23DISP0_DAT2B2
      11GPIO4_19 GPION20DI0_PIN3Vsync
      12CSPI3_CS0 SPI3 chip select 0P21DISP0_DAT3B3
      13CSPI3_CS1 SPI3 chip select 1 P20DISP0_DAT4B4
      14CSPI2_CS1 SPI2 chip select 1T22DISP0_DAT15R3
      15GPIO4_31 GPIOR21DISP0_DAT10G4
      16CSPI2_MOSI SPI2 master output salve inputT21DISP0_DAT16R4
      17GPIO5_05 GPIOT23DISP0_DAT11G5
      18CSPI2_MISO SPI2 master input salve outputU24DISP0_DAT17R5
      19GPIO5_06 GPIOT24DISP0_DAT12R0
      20CSPI2_CS0 SPI2 chip select 0V25DISP0_DAT18*NC
      21GPIO5_07 GPIOR20DISP0_DAT13R1
      22CSPI2_CLK SPI2 clockU23DISP0_DAT19*NC
      23GPIO5_08 GPIOU25DISP0_DAT14R2
      24UART3_RXD UART3 receive dataG22UART3_RXDUART3_RXD
      25GPIO4_26 GPIOR25DISP0_DAT5B5
      26UART3_TXD UART3 transmit dataF22UART3_TXDUART3_TXD
      27GPIO4_27 GPIOR23DISP0_DAT6G0
      28UART4_RXD UART4 receive dataV6ALT0, ecspi1.ECSPI1_MOSI
      29CSPI3_RDY SPI3 data validationR24DISP0_DAT7G1
      30UART4_TXD UART4 transmit dataW5ALT0, ecspi1.ECSPI1_SCLK
      31I2C3_SCL I2C3 master serial clockR4I2C3_SCL
      32UART5_RXD UART5 receive dataU6Unused
      33I2C3_SDA I2C3 master serial dataT3I2C3_SDA
      34UART5_TXD UART5 transmit dataU7ALT0, ecspi1.ECSPI1_MISO
      35I2C4_SCL I2C4 master serial clockR3Unused
      36PWM1 Pulse Width ModulationR22DISP0_DAT8G2
      37I2C4_SDA I2C4 master serial dataR5Unused
      38PWM2 Pulse Width ModulationT25DISP0_DAT9G3
      39GND GND
      40PWM3 Pulse Width ModulationC20PWM3

       

      It looks like I'm already short one PWM. Rats. Maybe I'll need to switch to an I2C controlled LED or use the Audio Out for the buzzer.

       

      My first step will be to rebuild the standard RIoT board Android image from source. (The source is still downloading. : ) )  Although I may chmod 777 the UARTS in the init.rc file so I can experiment with the Android Serial Port API (https://code.google.com/p/android-serialport-api/wiki/Building_the_project) sample program.

       

      Then I will try to rebuild the image with one of my desired pin muxes. Maybe SPI 1. That being said I'm not sure how to change the pin mux. I guess I'll be editing the board-mx6solo_RIoTboard.c file in some way.

        • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
          mukelarvin_price

          Looks like I need another PWM for brightness control of the LCD backlight. PWMS are in short supply!

           

          LCD4 pwm.png

           

          I plan on closely following the schematic of the BeagleBone LCD4 Cape for the LCD.

          https://github.com/CircuitCo/BeagleBone-LCD4-RevA1/blob/master/BeagleBone-LCD4-RevA1-schematic.pdf

            • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
              mukelarvin_price

              Well it took some doing but I was finally able to compile the RIoT board source code.

               

              I created an Ubuntu 12.04 virtual machine with 1 core, around 8 GB of RAM and 80 GB HD space.

              • Any more than 1 core and it would freeze up.
              • Without enough RAM compilation would fail. 4 GB didn't seem to work. 8 GB seemed like a safe amount.
              • 80 GB of HD just to play it safe.


              I tried to follow the instructions from v1.1 of the RIoT Board User Manual but found one typo. I'll just list the commands I used.


              Make sure everything is updated and install the necessary dependencies. Through trial and error and searching on forums I put together the following list. There may be extra stuff in here, I'm just sharing what I used.

              sudo apt-get update
              sudo apt-get install ia32-libs-multiarch libglapi-mesa:i386 git gnupg flex bison gperf build-essential \
                zip curl libc6-dev x11proto-core-dev lib32ncurses5-dev\
                libx11-dev:i386 lib32readline6-dev libgl1-mesa-glx:i386 \
                libgl1-mesa-dev g++-multilib mingw32 tofrodos \
                python-markdown libxml2-utils xsltproc zlib1g-dev:i386 \
                ia32-libs u-boot-tools minicom libncurses5-dev lib32z1-dev\
                uuid-dev    liblzo2-dev
              

               

              Install Repo just like the manual says.

              curl https://raw.github.com/android/tools_repo/stable/repo > ~/bin/repo
              chmod a+x ~/bin/repo
              export PATH=~/bin:$PATH
              

               

              Download the source from the repository. Strangely I found that the repo init would fail if I copy/pasted it into the terminal rather than typing it.

              mkdir ~/android-imx6-jb4.3-1.0.0
              cd ~/android-imx6-jb4.3-1.0.0
              repo init --repo-url=git://github.com/android/tools_repo.git -u git://github.com/embest-tech/imx-manifest.git -m embest_android_jb4.3_1.0.0
              

               

              Before compiling I had to make sure I had the correct Java JDK installed. I downloaded and installed the jdk-6u45-linux-x64.bin file from Oracle. http://www.oracle.com/technetwork/java/javasebusiness/downloads/java-archive-downloads-javase6-419409.html#jdk-6u45-oth-JPR

               

              sudo mkdir /usr/lib/jvm
              sudo chmod a+x jdk-6u45-linux-x64.bin
              sudo ./jdk-6u45-linux-x64.bin
              sudo mv jdk1.6.0_45 /usr/lib/jvm/
              

               

              Then I had to configure my system to find the JDK.

              sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk1.6.0_45/bin/java 1
              sudo update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/jdk1.6.0_45/bin/javac 1
              sudo update-alternatives --install /usr/bin/javaws javaws /usr/lib/jvm/jdk1.6.0_45/bin/javaws 1
              
              sudo update-alternatives --config java
              sudo update-alternatives --config javac
              sudo update-alternatives --config javaws
              export PATH=$PATH:/usr/lib/jvm/jdk1.6.0_45/bin
              

               

              Then I could start compiling. This is where the User Manual made an error. The lunch target is actually RIoTboard_6solo-user NOT riot_6solo-user.

               

              source build/envsetup.sh
              lunch RIoTboard_6solo-user
              make clean
              make
              

               

              Anyway that's what worked for me. I hope this helps someone.

            • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel

              Any particular reason for the parallel LCD ?   The LVDS interface gives you access to a wide range of panels following the Standard Panels Working Group specs.  I'm intending to try re-cycling a 15" display from a dead laptop in this way.

               

              Thought you might be needing another PWM for panel brightness, but there are other ways if you'r short.

               

              e14 also do the  LCD8000-97CLCD8000-97C it's a 1024x768 lvds capactive touchscreen and is compatible with the RIoT

              • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                mukelarvin_price

                Well I've had some problems.  I got a USB TTL serial cable so I could see what was going on during boot and I managed to blow up my board. My best guess is that I connected a 5 volt VCC line to one of the pins by mistake. I'm not sure. I was getting nonsense in my terminal window, then nothing, then the chip got really hot. : (

                 

                So I ordered a new one and am carrying on. This time I was very careful to scope all the pins before connecting anything and I cut the 5V line so I can't touch anything by accident.

                 

                Presently I am having trouble getting either the supplied Android image or one I've generated to boot from the eMMC. There are no problems during the MFGtool flashing process. The boot process begins but hangs on the line:

                Freeing init memory: 252k
                

                 

                I've pasted the entire boot log here. RIotBoard Android Boot Log (Hanging) - Pastebin.com

                 

                Going through the manual I noticed section 5.2.2 1) which says to change the BUILD_TARGET_LOCATION in /device/fsl/riot_6solo/BoardConfig.mk. (The directory is actually /device/fsl/RIotBoard_6solo/) I double checked and saw that I still had:

                BUILD_TARGET_LOCATION ?= sdmmc
                

                 

                So I went back to MFGtool and tried to write a card in the SD slot. It didn't work.

                I tried writing a card in the uSD slot. It did work.

                I tried booting from the uSD slot with the correct boot jumpers set. It didn't work.

                I put the uSD in an adapter and tried booting from the SD slot with the correct boot jumpers set. It DID work!

                 

                So I have successfully built my own image and got it to boot. I don't really need it to boot from the eMMC because my final product will boot from SD anyways. Next is to rebuild the image with user permissions for one of the uarts so I can access the uart from an Android app. Then comes the hard part... getting the LCD pins working.

                • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                  mukelarvin_price

                  Oh and another thing in case anyone has any thoughts on the subject...

                   

                  I recently attended the Android workshop at EELive in San Jose. http://www.eeliveshow.com/sanjose/conference/android-engineering-certificate-program.php

                   

                  The gist of the thing was that Android is great for a UI and not good for realtime processing. What they suggested was to use a Linux/Android hybrid system. The instructors had created an image for the Nexus 7 that had Android Kit Kat running on top of a Debian distribution. To demonstrate their point we used a fake oscilloscope app which displayed a lot of latency when sampling data in the Android user space. Then in the Debian user space, we made a Linux kernel module which sampled data with very little latency then read the data back into our fake oscilloscope app. It worked great and really made their point but they didn't show us HOW to make the hybrid system.

                   

                  So now I need to figure out how to make my own hybrid distribution. The RIoTboard, with it's Android focus, seems like a good candidate for this. So this is something I'd like to pursue in the long term.

                   

                  I found a website with some instructions that seem promising. http://whiteboard.ping.se/Android/Debian

                   

                  I'll be sure to share if I have any success.

                    • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                      mukelarvin_price

                      SPI Port Problems

                      Photo 2014-06-27, 2 05 36 PM.jpg

                       

                      Hey guys,

                      I've got a cape/shield now but I'm having trouble with the SPI port.

                       

                      Getting access to the SPI port

                      Just as a reminder, I'm using the Android distribution provided for the Riotboard which has the older kernel and uses board.c files instead of device trees. I'm trying to use ECSPI1 to send the initialization commands to the LCD. I realize I should be using some sort of kernel module to do this but I've had a little experience using spidev in userspace so I thought I'd try sending the commands that way first. Althoug I did find a good tutorial on writing SPI kernel modules. (Writing a Linux SPI driver - Part 1)

                       

                      I found this thread on the Freescale message board which discusses how to get spidev working.

                      https://community.freescale.com/thread/302612

                       

                      The pin multiplexing is set in board-mx6dl_RIoTboard.h

                      /* CSPI */
                        MX6DL_PAD_KEY_COL0__ECSPI1_SCLK,
                        MX6DL_PAD_KEY_ROW0__ECSPI1_MOSI,
                        MX6DL_PAD_KEY_COL1__ECSPI1_MISO,
                        MX6DL_PAD_KEY_ROW1__GPIO_4_9,
                      
                      
                      

                       

                      Then the port is initialized in board-mx6dl_RIoTboard.c, where it is set up to use the ads7846 touch panel driver. I changed the init structure to match my needs.

                      static struct spi_board_info imx6_RIoTboard_spi_devices[] __initdata = {
                              {
                                      /*.modalias = "ads7846",*/
                                       .modalias = "spidev",
                                      .bus_num = 0,
                                      .chip_select = 0,
                                      .max_speed_hz = 1500000,
                                      /*.irq = gpio_to_irq(RIoTboard_RES_TCH_INT),
                                      .platform_data = &ads7846_config,*/
                                      .mode= SPI_MODE_3
                              },
                      };
                      
                      
                      

                       

                      Then in the board initialization function I made sure that the correct SPI bus was being initialized.

                      /*!
                      * Board specific initialization.
                      */
                      static void __init mx6_RIoTboard_board_init(void)
                      {
                           ...
                      /* SPI */
                        imx6q_add_ecspi(0, &mx6solo_RIoTboard_spi_data);
                        spi_device_init();
                      
                      
                      

                       

                      I had to make sure that the spidev module added was into the kernel. In the file /kernel_imx/arch/arm/configs/imx6_android_defconfig I changed the line:

                      # CONFIG_SPI_SPIDEV is not set
                      
                      
                      

                      to:

                      CONFIG_SPI_SPIDEV=y
                      
                      
                      

                       

                      Once I had all that done I recompiled the Android image and put it on an SD card. When I looked in /dev I was rewarded with a file called spidev0.0.

                       

                      Compiling a binary to run on the Android shell

                      To test the SPI port I decided to use the spidev_test.c from:

                      https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/plain/Documentation/spi/spidev_test.c?id=95b1ed2ac7ffe32…

                       

                      First I changed the spidev.h location to be:

                      #include </home/riot/android-imx6-jb4.3-1.0.0/kernel_imx/include/linux/spi/spidev.h>
                      
                      
                      

                      and the device to be:

                      static const char *device = "/dev/spidev0.0";
                      
                      
                      

                       

                      I cross compiled the binary using the android gcc in the prebuilts, with the --sysroot referring to the headers in the ndk 8 folder.

                      riot@ubuntu:~/android-imx6-jb4.3-1.0.0$ '/home/riot/android-imx6-jb4.3-1.0.0/prebuilts/gcc/linux-x86/arm/arm-linux-androideabi-4.6/bin/arm-linux-androideabi-gcc-4.6.x-google' --sysroot='/home/riot/android-imx6-jb4.3-1.0.0/prebuilts/ndk/8/platforms/android-14/arch-arm'  -o ../spidev_test ../spidev_test.c
                      
                      
                      

                       

                      Next I booted my Riotboard, remounted the filesystem so that I could write to it and made a directory to put the binary in.

                      root@RIoTboard_6solo:/ # mount -w -o remount /dev/block/mmcblk0p5 /system
                      root@RIoTboard_6solo:/ # mkdir /system/lcdtest
                      
                      
                      

                       

                      From my Windows pc I connected the mini-usb and pushed the binary into the directory.

                      C:\>adb push spidev_test /system/lcdtest
                      853 KB/s (7868 bytes in 0.009s)
                      
                      
                      

                       

                      Back in the serial shell I made the binary executable and tried it out.

                      root@RIoTboard_6solo:/ # chmod 777 /system/lcdtest/spidev_test
                      root@RIoTboard_6solo:/ # /system/lcdtest/spidev_test -H -O
                      spi mode: 3
                      bits per word: 8
                      max speed: 500000 Hz (500 KHz)
                      
                      
                      FF FF FF FF FF FF
                      FF FF FF FF FF FF
                      FF FF FF FF FF FF
                      FF FF FF FF FF FF
                      FF FF FF FF FF FF
                      FF FF FF FF FF FF
                      FF FF
                      
                      
                      

                       

                      Everything nearly worked correct. I was scoping the output on my logic analyser and noticed that my Clock isn't operating at the correct polarity.

                      spidev_test_mode_3.png

                      The clock polarity appears to be mode 0 no matter what mode I set the spidev to be. Changing the frequency affects the output correctly. It's just the mode that won't change.

                       

                      Does anyone know what I may be doing wrong?

                        • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                          mukelarvin_price

                          The problem was that SPI modes with CPOL high aren't implemented in the spi_imx.c driver.

                           

                          This guy on the Freescale forum found a solution.

                          https://community.freescale.com/thread/313815

                           

                          I made the changes he suggested, however I still can't get my LCD to initialize correctly. The clock is at the right polarity now however there seems to be an extra pulse at the end of every message.

                          In the following instance I sent 0x11. That clocks out correctly, then there's one extra pulse of nothing at the end.

                          extra pulse.png

                          I'm in touch with my LCD manufacturer. Hopefully they can help.

                            • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel

                              Out of curiosity, did you try using the 3.16-rc* kernels to see if the driver has been sorted out somewhere between 3.0.35 and 3.16 ?

                               

                              If it has then you may be able to compare the two versions and work out what to change. There's also a 3.10.x provided by freescale that may just need some devicetree work for the RIoTboard.

                                • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                                  mukelarvin_price

                                  I took a look at the spi_imx.c in the newer kernel and it appears that they've made changes similar to those I found in that thread. Although what ended up working for me turned out to be much easier after all... the MOSI and MISO lines were switched! Oh brother.

                                    • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                                      mukelarvin_price

                                      (Nearly) Working Parallel RGB on RIoTBoard

                                      Photo 2014-07-14, 3 58 19 PM.jpg

                                      Presently I have the LCD working but the colours aren't quite right yet. I'll get to that later. I've been chipping away at this for a little while now so hopefully I don't forget any of the steps I've taken. The first step I want to talk about is getting the backlight PWM to work with the Android brightness controls.


                                      Brightness Control

                                      The brightness of the backlight LEDs is controlled with a PWM signal. First you have to make sure you have your PWM pin muxed correctly. I'm using PWM3 on pin 40 of the RIoTboard header. In my board-mx6dl_RIoTboard.h file I added:

                                      /* Display Backlight PWM */
                                      MX6DL_PAD_SD1_DAT1__PWM3_PWMO,
                                      


                                      Then in board-mx6solo_RIoTboard.c I found a structure that was being used to initialize the backlight of the LVDS connector. Since I'm not using LVDS I just hijacked the structure.

                                      static struct platform_pwm_backlight_data mx6_RIoTboard_pwm_backlight_data = {
                                        /* LVDS uses PWM4 but initializes #3. It turns out they're numbered 0-3, not 1-4. */
                                        //.pwm_id = 3,
                                        .pwm_id = 2,     // PWM3
                                        .max_brightness = 248,
                                        .dft_brightness = 128,
                                        .pwm_period_ns = 50000,
                                      };
                                      


                                      This structure is used later in the mx6_RIoTboard_board_init(void) function.

                                        imx6q_add_mxc_pwm(0);
                                        imx6q_add_mxc_pwm(1);
                                        imx6q_add_mxc_pwm(2); //PWM3 for my LCD
                                        imx6q_add_mxc_pwm(3);
                                        //imx6q_add_mxc_pwm_backlight(3, &mx6_RIoTboard_pwm_backlight_data); // Not used anymore
                                        imx6q_add_mxc_pwm_backlight(2, &mx6_RIoTboard_pwm_backlight_data);
                                      


                                      Finally, as far as I can remember, the last thing I had to edit was the init.rc file in android-imx6-jb4.3-1.0.0/device/fsl/RIoTboard_6solo/. Everywhere it said "3" I changed it to 2.

                                      # Default backlight device
                                      setprop hw.backlight.dev "pwm-backlight.2"
                                      # Chmod/chown FSL specific sys entry
                                      chown system system /sys/class/backlight/pwm-backlight.2/brightness
                                      chmod 0660 /sys/class/backlight/pwm-backlight.2/brightness
                                      


                                      After rebuilding the system I connected the board to an hdmi monitor. As I move the slider in Settings, Display, Brightness I can see a change in the PWM output on pin 40.


                                      Enabling the Parallel RGB Pins

                                      Looking at the RIoTboard schematic you can see that two of the 24 colour data pins are not connected.

                                      missing pins.PNG

                                      This means that we can only use bits 0-18. My LCD supports 18-bit colour so I'm attempting to use bits 0-17.

                                      Riot PinSignal NameColour Bit
                                      6DISP0_DAT0Blue 0
                                      8DISP0_DAT1Blue 1
                                      10DISP0_DAT2Blue 2
                                      12DISP0_DAT3Blue 3
                                      13DISP0_DAT4Blue 4
                                      25DISP0_DAT5Blue 5
                                      27DISP0_DAT6Green 0
                                      29DISP0_DAT7Green 1
                                      36DISP0_DAT8Green 2
                                      38DISP0_DAT9Green 3
                                      15DISP0_DAT10Green 4
                                      17DISP0_DAT11Green 5
                                      19DISP0_DAT12Red 0
                                      21DISP0_DAT13Red 1
                                      23DISP0_DAT14Red 2
                                      14DISP0_DAT15Red 3
                                      16DISP0_DAT16Red 4
                                      18DISP0_DAT17Red 5

                                      (From pages 99, 100 of IMX6SDLCEC_datasheet.pdf.)

                                       

                                      For the pin muxing I made sure I had the following entries in the board header file.

                                      /* DISPLAY */
                                        MX6DL_PAD_DI0_DISP_CLK__IPU1_DI0_DISP_CLK,
                                        MX6DL_PAD_DI0_PIN15__IPU1_DI0_PIN15, /* DE */
                                        MX6DL_PAD_DI0_PIN2__IPU1_DI0_PIN2, /* HSync */
                                        MX6DL_PAD_DI0_PIN3__IPU1_DI0_PIN3, /* VSync */
                                        //MX6DL_PAD_DI0_PIN4__IPU1_DI0_PIN4, /* Contrast not connected*/
                                        MX6DL_PAD_DISP0_DAT0__IPU1_DISP0_DAT_0,
                                        MX6DL_PAD_DISP0_DAT1__IPU1_DISP0_DAT_1,
                                        MX6DL_PAD_DISP0_DAT2__IPU1_DISP0_DAT_2,
                                        MX6DL_PAD_DISP0_DAT3__IPU1_DISP0_DAT_3,
                                        MX6DL_PAD_DISP0_DAT4__IPU1_DISP0_DAT_4,
                                        MX6DL_PAD_DISP0_DAT5__IPU1_DISP0_DAT_5,
                                        MX6DL_PAD_DISP0_DAT6__IPU1_DISP0_DAT_6,
                                        MX6DL_PAD_DISP0_DAT7__IPU1_DISP0_DAT_7,
                                        MX6DL_PAD_DISP0_DAT8__IPU1_DISP0_DAT_8,
                                        MX6DL_PAD_DISP0_DAT9__IPU1_DISP0_DAT_9,
                                        MX6DL_PAD_DISP0_DAT10__IPU1_DISP0_DAT_10,
                                        MX6DL_PAD_DISP0_DAT11__IPU1_DISP0_DAT_11,
                                        MX6DL_PAD_DISP0_DAT12__IPU1_DISP0_DAT_12,
                                        MX6DL_PAD_DISP0_DAT13__IPU1_DISP0_DAT_13,
                                        MX6DL_PAD_DISP0_DAT14__IPU1_DISP0_DAT_14,
                                        MX6DL_PAD_DISP0_DAT15__IPU1_DISP0_DAT_15,
                                        MX6DL_PAD_DISP0_DAT16__IPU1_DISP0_DAT_16,
                                        MX6DL_PAD_DISP0_DAT17__IPU1_DISP0_DAT_17,
                                        MX6DL_PAD_GPIO_7__GPIO_1_7,      // LCD Reset
                                      


                                      After rebuilding the system I boot the system with the bootargs.

                                      setenv bootargs console=ttymxc1,115200 init=/init nosmp video=mxcfb0:dev=lcd,CLAA-WVGA@60,bpp=18,if=RGB666 video=mxcfb1:off fbmem=10M vmalloc=400M androidboot.console=ttymxc1 androidboot.hardware=freescale
                                      

                                       

                                      Then checking the pins with an oscilloscope showed that I was getting RGB signals out on the correct pins.

                                       

                                      I need to take a break so I'll continue with how I configured the RGB timing to match my LCD tomorrow.

                                        • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                                          mcb1

                                          Nice work.

                                          I understand what you're trying to achieve, but way beyond my software skills.

                                           

                                          Mark

                                          • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                                            jafe2david

                                            Hi mukelarvin_price,

                                             

                                            I also using i.mx6 to drive this panel, i check everything are seems correct, spi driver , lcd driver, and spi signals. But the panel still not working with i.mx6. Could i ask you some questions ?

                                            1). Are you follow datasheet to init register ?

                                            2). Does these init parameter are correct on the datasheet ?

                                            3). About the nCS (Chip select pin), We need to put it low in every SPI write cycle ( Index + 8 Bit Data) or we need to put it low start form index and put it high after  whole data (index + data1+ data2 + .... dataN) ?

                                            4). Does the length of Index is 8 bits ?

                                            5). Data Register is 8 ot 16 bits ?

                                             

                                            Thanks.

                                              • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                                                mukelarvin_price

                                                Hi David,

                                                 

                                                Which panel are you using? Is it the LG panel or the Microtips panel?

                                                 

                                                I did not end up using the LG panel.

                                                 

                                                If it is the Microtips panel, this is the init script they provided for me.

                                                 

                                                void HX8369A_RGB_18bit_Initial(void)
                                                {
                                                // VCI=2.8V
                                                //************* Reset LCD Driver ****************//
                                                LCD_nRESET = 1;
                                                Delay(10); // Delay 1ms
                                                LCD_nRESET = 0;
                                                Delay(150); // Delay 10ms // This delay time is necessary
                                                LCD_nRESET = 1;
                                                Delay(200); // Delay 120 ms
                                                //************* Start Initial Sequence **********//
                                                SPI_WriteComm(0xB9); //Set_EXTC 
                                                SPI_WriteData(0xFF);    
                                                SPI_WriteData(0x83);    
                                                SPI_WriteData(0x69);                
                                                
                                                SPI_WriteComm(0xB1);  //Set Power  
                                                SPI_WriteData(0x01);  
                                                SPI_WriteData(0x00);  
                                                SPI_WriteData(0x34);  
                                                SPI_WriteData(0x06);  
                                                SPI_WriteData(0x00);  
                                                SPI_WriteData(0x0F);  
                                                SPI_WriteData(0x0F);  
                                                SPI_WriteData(0x2A);  
                                                SPI_WriteData(0x32);  
                                                SPI_WriteData(0x3F);  
                                                SPI_WriteData(0x3F);  
                                                SPI_WriteData(0x07);  
                                                SPI_WriteData(0x23);  
                                                SPI_WriteData(0x01);  
                                                SPI_WriteData(0xE6);  
                                                SPI_WriteData(0xE6);  
                                                SPI_WriteData(0xE6);  
                                                SPI_WriteData(0xE6);  
                                                SPI_WriteData(0xE6); 
                                                
                                                SPI_WriteComm(0xB2);  // SET Display  480x800 
                                                SPI_WriteData(0x00);   
                                                SPI_WriteData(0x2B);   
                                                SPI_WriteData(0x0A);   
                                                SPI_WriteData(0x0A);   
                                                SPI_WriteData(0x70);   
                                                SPI_WriteData(0x00);   
                                                SPI_WriteData(0xFF);   
                                                SPI_WriteData(0x00);   
                                                SPI_WriteData(0x00);   
                                                SPI_WriteData(0x00);   
                                                SPI_WriteData(0x00);   
                                                SPI_WriteData(0x03);   
                                                SPI_WriteData(0x03);   
                                                SPI_WriteData(0x00);   
                                                SPI_WriteData(0x01); 
                                                   
                                                SPI_WriteComm(0xB4);  // SET Display  480x800 
                                                SPI_WriteData(0x01);   
                                                SPI_WriteData(0x18);   
                                                SPI_WriteData(0x80); 
                                                SPI_WriteData(0x10);   
                                                SPI_WriteData(0x01);   
                                                
                                                SPI_WriteComm(0xB6);  // SET VCOM 
                                                SPI_WriteData(0x2C);   
                                                SPI_WriteData(0x2C);    
                                                
                                                SPI_WriteComm(0xD5);  //SET GIP 
                                                SPI_WriteData(0x00);   
                                                SPI_WriteData(0x05);   
                                                SPI_WriteData(0x03);   
                                                SPI_WriteData(0x00);   
                                                SPI_WriteData(0x01);   
                                                SPI_WriteData(0x09);   
                                                SPI_WriteData(0x10);   
                                                SPI_WriteData(0x80);   
                                                SPI_WriteData(0x37);   
                                                SPI_WriteData(0x37);   
                                                SPI_WriteData(0x20);   
                                                SPI_WriteData(0x31);   
                                                SPI_WriteData(0x46);   
                                                SPI_WriteData(0x8A);   
                                                SPI_WriteData(0x57);   
                                                SPI_WriteData(0x9B);   
                                                SPI_WriteData(0x20);   
                                                SPI_WriteData(0x31);   
                                                SPI_WriteData(0x46);   
                                                SPI_WriteData(0x8A);   
                                                SPI_WriteData(0x57);   
                                                SPI_WriteData(0x9B);   
                                                SPI_WriteData(0x07);   
                                                SPI_WriteData(0x0F);   
                                                SPI_WriteData(0x02);   
                                                SPI_WriteData(0x00); 
                                                
                                                SPI_WriteComm(0xE0);  //SET GAMMA 
                                                SPI_WriteData(0x00);  
                                                SPI_WriteData(0x08);  
                                                SPI_WriteData(0x0D);  
                                                SPI_WriteData(0x2D);  
                                                SPI_WriteData(0x34);  
                                                SPI_WriteData(0x3F);  
                                                SPI_WriteData(0x19);  
                                                SPI_WriteData(0x38);  
                                                SPI_WriteData(0x09);  
                                                SPI_WriteData(0x0E);  
                                                SPI_WriteData(0x0E);  
                                                SPI_WriteData(0x12);  
                                                SPI_WriteData(0x14);  
                                                SPI_WriteData(0x12);  
                                                SPI_WriteData(0x14);  
                                                SPI_WriteData(0x13);  
                                                SPI_WriteData(0x19);  
                                                SPI_WriteData(0x00);  
                                                SPI_WriteData(0x08);  
                                                SPI_WriteData(0x0D);  
                                                SPI_WriteData(0x2D);  
                                                SPI_WriteData(0x34);  
                                                SPI_WriteData(0x3F);  
                                                SPI_WriteData(0x19);  
                                                SPI_WriteData(0x38);  
                                                SPI_WriteData(0x09);  
                                                SPI_WriteData(0x0E);  
                                                SPI_WriteData(0x0E);  
                                                SPI_WriteData(0x12);  
                                                SPI_WriteData(0x14);  
                                                SPI_WriteData(0x12);  
                                                SPI_WriteData(0x14);  
                                                SPI_WriteData(0x13);  
                                                SPI_WriteData(0x19); 
                                                
                                                SPI_WriteComm(0xC1); //set DGC 
                                                SPI_WriteData(0x01); //enable DGC function 
                                                SPI_WriteData(0x02); //SET R-GAMMA 
                                                SPI_WriteData(0x08);  
                                                SPI_WriteData(0x12);  
                                                SPI_WriteData(0x1A);  
                                                SPI_WriteData(0x22);  
                                                SPI_WriteData(0x2A);  
                                                SPI_WriteData(0x31);  
                                                SPI_WriteData(0x36);  
                                                SPI_WriteData(0x3F);  
                                                SPI_WriteData(0x48);  
                                                SPI_WriteData(0x51);  
                                                SPI_WriteData(0x58);  
                                                SPI_WriteData(0x60);  
                                                SPI_WriteData(0x68);  
                                                SPI_WriteData(0x70);  
                                                SPI_WriteData(0x78);  
                                                SPI_WriteData(0x80);  
                                                SPI_WriteData(0x88);  
                                                SPI_WriteData(0x90);  
                                                SPI_WriteData(0x98);  
                                                SPI_WriteData(0xA0);  
                                                SPI_WriteData(0xA7);  
                                                SPI_WriteData(0xAF);  
                                                SPI_WriteData(0xB6);  
                                                SPI_WriteData(0xBE);  
                                                SPI_WriteData(0xC7);  
                                                SPI_WriteData(0xCE);  
                                                SPI_WriteData(0xD6);  
                                                SPI_WriteData(0xDE);  
                                                SPI_WriteData(0xE6);  
                                                SPI_WriteData(0xEF);  
                                                SPI_WriteData(0xF5);  
                                                SPI_WriteData(0xFB);  
                                                SPI_WriteData(0xFC); 
                                                SPI_WriteData(0xFE);  
                                                SPI_WriteData(0x8C);  
                                                SPI_WriteData(0xA4);  
                                                SPI_WriteData(0x19);  
                                                SPI_WriteData(0xEC);  
                                                SPI_WriteData(0x1B);  
                                                SPI_WriteData(0x4C);  
                                                SPI_WriteData(0x40);    
                                                SPI_WriteData(0x02); //SET G-Gamma 
                                                SPI_WriteData(0x08);  
                                                SPI_WriteData(0x12);  
                                                SPI_WriteData(0x1A);  
                                                SPI_WriteData(0x22);  
                                                SPI_WriteData(0x2A);  
                                                SPI_WriteData(0x31);  
                                                SPI_WriteData(0x36);  
                                                SPI_WriteData(0x3F);  
                                                SPI_WriteData(0x48);  
                                                SPI_WriteData(0x51);  
                                                SPI_WriteData(0x58);  
                                                SPI_WriteData(0x60);  
                                                SPI_WriteData(0x68);  
                                                SPI_WriteData(0x70);  
                                                SPI_WriteData(0x78);  
                                                SPI_WriteData(0x80);  
                                                SPI_WriteData(0x88);  
                                                SPI_WriteData(0x90);  
                                                SPI_WriteData(0x98);  
                                                SPI_WriteData(0xA0);  
                                                SPI_WriteData(0xA7);  
                                                SPI_WriteData(0xAF);  
                                                SPI_WriteData(0xB6);  
                                                SPI_WriteData(0xBE);  
                                                SPI_WriteData(0xC7);  
                                                SPI_WriteData(0xCE);  
                                                SPI_WriteData(0xD6);  
                                                SPI_WriteData(0xDE);  
                                                SPI_WriteData(0xE6);  
                                                SPI_WriteData(0xEF);  
                                                SPI_WriteData(0xF5);  
                                                SPI_WriteData(0xFB);  
                                                SPI_WriteData(0xFC); 
                                                SPI_WriteData(0xFE);  
                                                SPI_WriteData(0x8C);  
                                                SPI_WriteData(0xA4);  
                                                SPI_WriteData(0x19);  
                                                SPI_WriteData(0xEC);  
                                                SPI_WriteData(0x1B);  
                                                SPI_WriteData(0x4C);  
                                                SPI_WriteData(0x40);  
                                                SPI_WriteData(0x02); //SET B-Gamma 
                                                SPI_WriteData(0x08);  
                                                SPI_WriteData(0x12);  
                                                SPI_WriteData(0x1A);  
                                                SPI_WriteData(0x22);  
                                                SPI_WriteData(0x2A);  
                                                SPI_WriteData(0x31);  
                                                SPI_WriteData(0x36);  
                                                SPI_WriteData(0x3F);  
                                                SPI_WriteData(0x48);  
                                                SPI_WriteData(0x51);  
                                                SPI_WriteData(0x58);  
                                                SPI_WriteData(0x60);  
                                                SPI_WriteData(0x68);  
                                                SPI_WriteData(0x70);  
                                                SPI_WriteData(0x78);  
                                                SPI_WriteData(0x80);  
                                                SPI_WriteData(0x88);  
                                                SPI_WriteData(0x90);  
                                                SPI_WriteData(0x98);  
                                                SPI_WriteData(0xA0);  
                                                SPI_WriteData(0xA7);  
                                                SPI_WriteData(0xAF);  
                                                SPI_WriteData(0xB6);  
                                                SPI_WriteData(0xBE);  
                                                SPI_WriteData(0xC7);  
                                                SPI_WriteData(0xCE);  
                                                SPI_WriteData(0xD6);  
                                                SPI_WriteData(0xDE);  
                                                SPI_WriteData(0xE6);  
                                                SPI_WriteData(0xEF);  
                                                SPI_WriteData(0xF5);  
                                                SPI_WriteData(0xFB);  
                                                SPI_WriteData(0xFC); 
                                                SPI_WriteData(0xFE);  
                                                SPI_WriteData(0x8C);  
                                                SPI_WriteData(0xA4);  
                                                SPI_WriteData(0x19);  
                                                SPI_WriteData(0xEC);  
                                                SPI_WriteData(0x1B);  
                                                SPI_WriteData(0x4C);  
                                                SPI_WriteData(0x40); 
                                                
                                                
                                                SPI_WriteComm(0x36);  //Set_address_mode 
                                                SPI_WriteData(0x20);  
                                                
                                                SPI_WriteComm(0x3A);  //Set_pixel_format 
                                                SPI_WriteData(0x66);    
                                                
                                                //Set_LUT 
                                                SPI_WriteComm(0x2D);    
                                                for (i=0; i<=63; i++) 
                                                SPI_WriteData(i*4);   //Set_R_LUT 
                                                for (i=0; i<=63; i++) 
                                                SPI_WriteData(i*4);   //Set_G_LUT 
                                                for (i=0; i<=63; i++) 
                                                SPI_WriteData(i*4);   //Set_B_LUT   
                                                
                                                SPI_WriteComm(0x11);  //Sleep Out 
                                                Delay(120); 
                                                
                                                SPI_WriteComm(0x29);  //Display On 
                                                
                                                
                                                SPI_WriteComm(0x2C); //display on
                                                }
                                                
                                                
                                                void LCD_Enter Standby_HX8369A(void)
                                                {
                                                SPI_WriteComm(0x0028); // Display off
                                                
                                                
                                                SPI_WriteComm(0x0010); // Enter Standby mode
                                                }
                                                
                                                
                                                
                                                
                                                void LCD_Exit Standby _HX8369A(void)
                                                {
                                                SPI_WriteComm(0x11); // Standby out
                                                Delay(60);
                                                
                                                
                                                SPI_WriteComm(0x29); // Display on
                                                }
                                                
                                                
                                                
                                                
                                                void SPI_WriteComm(unsigned char i)
                                                {
                                                unsigned char n;
                                                SPI_CS=0;
                                                SPI_SDI=0;
                                                SPI_CLK=0;
                                                SPI_CLK=1;
                                                    
                                                for(n=0; n<8; n++)
                                                {  
                                                if(i&0x80) SPI_SDI=1;
                                                else SPI_SDI=0;
                                                i<<= 1;
                                                SPI_CLK=0;
                                                SPI_CLK=1;
                                                }
                                                
                                                
                                                SPI_CS=1;
                                                }
                                                
                                                
                                                
                                                
                                                void SPI_WriteData(unsigned char i)
                                                {
                                                unsigned char n;
                                                SPI_CS=0;
                                                SPI_SDI=1;
                                                SPI_CLK=0;
                                                SPI_CLK=1;
                                                    
                                                for(n=0; n<8; n++)
                                                {  
                                                if(i&0x80) SPI_SDI=1;
                                                else SPI_SDI=0;
                                                i<<= 1;
                                                SPI_CLK=0;
                                                SPI_CLK=1;
                                                }
                                                
                                                
                                                SPI_CS=1;
                                                }
                                                

                                                 

                                                Initially I tried to use the SPI platform device but then I realized I had my MISO and MOSI pins swapped on my adapter board. So I just bit banged the SPI out over GPIOs with the above script.

                                                  • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                                                    jafe2david

                                                    Dear Mukelarvin_price,

                                                     

                                                    Oh, I use LG 4.3" LCD, not Microtips.... I had try SPI platform driver and GPIO to simulate SPI, but both are not working. My SPI code as below FYR.

                                                     

                                                    ----------------------------------------------------------------------- Start

                                                    #include <linux/module.h>
                                                    #include <linux/delay.h>
                                                    #include <linux/spi/spi.h>
                                                    #include <linux/mutex.h>
                                                    #include <linux/gpio.h>
                                                    #include <linux/io.h>

                                                    struct device dev;
                                                    //
                                                    #define INDEX  0x70
                                                    #define DATA  0x72

                                                    struct LB043_DATA {
                                                    u8 type;
                                                    u8 data;
                                                    };

                                                    struct LB043_DATA display_mode_setting[] = {
                                                    // type, data

                                                    // Dummy command. NOP.
                                                    {INDEX, 0x00}, 

                                                    // Interface Pixel Format
                                                    {INDEX, 0x3A},  {DATA,  0x66},

                                                    // RGB Interface Setting
                                                    {INDEX, 0xB1},  {DATA, 0x01},  {DATA, 0x08}, {DATA, 0x08},

                                                    // Panel Characteristic Setting
                                                    {INDEX, 0xB2}, {DATA, 0x00}, {DATA,  0xC8},

                                                    // Panel Drive Setting
                                                    {INDEX, 0xB3}, {DATA,  0x00},

                                                    // Panel Mode Setting
                                                    {INDEX, 0xB4}, {DATA,  0x04},

                                                    // Display Control 1
                                                    {INDEX, 0xB5}, {DATA,  0x42}, {DATA,  0x10}, {DATA,  0x10}, {DATA,  0x00}, {DATA,  0x20},

                                                    // Display Control 2
                                                    {INDEX, 0xB6}, {DATA,  0x0B}, {DATA,  0x0F}, {DATA,  0x3C}, {DATA, 0x13}, {DATA, 0x13}, {DATA,  0xE8},

                                                    // Display Control 3
                                                    {INDEX, 0xB7}, {DATA,  0x46}, {DATA,  0x06}, {DATA,  0x0C}, {DATA,  0x00}, {DATA,  0x00},
                                                    };

                                                    struct LB043_DATA power_setting[] = {
                                                    // Internal Oscillator Setting
                                                    {INDEX, 0xC0}, {DATA,  0x01}, {DATA,  0x11},

                                                    // Power Control 3
                                                    {INDEX, 0xC3}, {DATA,  0x07}, {DATA,  0x03}, {DATA,  0x04}, {DATA,  0x04}, {DATA,  0x04},

                                                    // Power Control 4
                                                    {INDEX, 0xC4}, {DATA,  0x12}, {DATA,  0x24}, {DATA,  0x18}, {DATA,  0x18}, {DATA,  0x02}, {DATA,  0x49},

                                                    // Power Control 5
                                                    {INDEX, 0xC5}, {DATA,  0x6F}, {INDEX, 0xC6},

                                                    // Power Control 6
                                                    {DATA,  0x41}, {DATA,  0x63},
                                                    };

                                                    struct LB043_DATA gamma_setting[] = {
                                                    // Set Positive Gamma Curve for Red
                                                    {INDEX, 0xD0}, {DATA,  0x03},  {DATA,  0x07}, {DATA,  0x73}, {DATA,  0x35}, {DATA,  0x00}, {DATA,  0x01}, {DATA,  0x20}, {DATA,  0x00}, {DATA,  0x03},

                                                    // Set Positive Gamma Curve for Green
                                                    {INDEX, 0xD2}, {DATA,  0x03}, {DATA,  0x07}, {DATA,  0x73}, {DATA,  0x35}, {DATA,  0x00}, {DATA,  0x01}, {DATA,  0x20}, {DATA,  0x00}, {DATA,  0x03},

                                                    // Set Positive Gamma Curve for Blue
                                                    {INDEX, 0xD4}, {DATA,  0x03}, {DATA,  0x07}, {DATA,  0x73}, {DATA,  0x35}, {DATA,  0x00}, {DATA,  0x01}, {DATA,  0x20}, {DATA,  0x00}, {DATA,  0x03},
                                                    };

                                                    struct LB043_DATA sleepout_setting[] = {
                                                    {INDEX, 0x11},
                                                    };

                                                    struct LB043_DATA disp_on_setting[] = {
                                                    {INDEX, 0x29},
                                                    };

                                                    struct LB043_DATA disp_on_setting1[] = {
                                                    {INDEX, 0x2C},
                                                    };

                                                    //

                                                    void init_lb043wv2_panel_6(struct spi_device *spi)
                                                    {
                                                    u8 buf[16];
                                                    int i;

                                                    printk("[David INFO]==> %s panel_6.0\n", __func__);

                                                    spi->max_speed_hz= 400000;
                                                    spi->mode = SPI_MODE_3;

                                                    spi_setup(spi);

                                                    spi_set_drvdata(spi, &dev);

                                                    // Display Mode Settings
                                                    for(i=0; i < ARRAY_SIZE(display_mode_setting); i++) {
                                                      buf[0]=display_mode_setting[i].type;  buf[1]=display_mode_setting[i].data;
                                                      spi_write(spi, (const u8 *) buf, 2);
                                                    }

                                                    // Power_setting
                                                    for(i=0; i < ARRAY_SIZE(power_setting); i++) {
                                                      buf[0]=power_setting[i].type;      buf[1]=power_setting[i].data;
                                                      spi_write(spi,(const u8 *) buf, 2);
                                                    }

                                                    // Gamma_setting
                                                    for(i=0; i < ARRAY_SIZE(gamma_setting); i++) {
                                                      buf[0]=gamma_setting[i].type;      buf[1]=gamma_setting[i].data;
                                                      spi_write(spi, (const u8 *)buf, 2);
                                                    }

                                                    // sleep out
                                                    buf[0]=sleepout_setting[0].type;    
                                                    buf[1]=sleepout_setting[0].data; 
                                                    spi_write(spi, (const u8 *)buf, 2);    msleep(200);

                                                    // display on
                                                    buf[0]=disp_on_setting[0].type;     
                                                    buf[1]=disp_on_setting[0].data; 
                                                    spi_write(spi, (const u8 *)buf, 2);    msleep(200);

                                                    buf[0]=disp_on_setting1[0].type;     
                                                    buf[1]=disp_on_setting1[0].data; 
                                                    spi_write(spi, (const u8 *)buf, 2);

                                                    }

                                                    static int __devinit lb043wv2_panel_spi_probe(struct spi_device *spi)
                                                    {
                                                    printk("==> %s enter\n", __func__);
                                                    msleep(50);
                                                    init_lb043wv2_panel_6(spi);
                                                    msleep(100);
                                                    return 0;
                                                    }

                                                    static int __devexit lb043wv2_panel_spi_remove(struct spi_device *spi)
                                                    {
                                                    printk("==> %s\n", __func__);
                                                    return 0;
                                                    }

                                                    static struct spi_driver lb043wv2_spi_driver = {
                                                    .driver  = {
                                                      .name = "spidev",
                                                      .owner = THIS_MODULE,
                                                    },
                                                    .probe  = lb043wv2_panel_spi_probe,
                                                    .remove  = __devexit_p(lb043wv2_panel_spi_remove),
                                                    };

                                                    static int __init lb043wv2_panel_drv_init(void)
                                                    {
                                                    printk("==> %s\n", __func__);
                                                    return spi_register_driver(&lb043wv2_spi_driver);
                                                    }

                                                    static void __exit lb043wv2_panel_drv_exit(void)
                                                    {
                                                    printk("==> %s\n", __func__);
                                                    spi_unregister_driver(&lb043wv2_spi_driver);
                                                    }

                                                    module_init(lb043wv2_panel_drv_init);
                                                    module_exit(lb043wv2_panel_drv_exit);
                                                    MODULE_LICENSE("GPL"

                                                     

                                                    ------------------------------------------ End

                                                     

                                                    I will still working on LG Panel in  the next few days. If have any good news i would let you know...

                                                     

                                                    Thanks,

                                                    David

                                    • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                                      vsluiter

                                      Very nice. How do you know where to start looking for all these setting files? The few embedded Linux projects I've done, I'm always blown away by the plethora of setting files. Did you already have experience with projects like this, or can you recommend some websites?

                                        • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                                          mukelarvin_price

                                          The amount of files you need to edit REALLY stressed me out when I started. It seemed a little impossible. This is my first embedded Linux project too, although I have been working on it for months so I've picked up quite a bit. I started on the beaglebone black but eventually moved to the RIoTboard because our final product will use an IMX6 solo. The IMX6 seemed like a better platform for the long term because of the better connectivity options, it's faster, can be had with more cores if needed, etc.

                                           

                                          I learned most of it by searching the Freescale help boards, reading tutorials for other IMX6 based boards (Wandboard, SabreLite, Marsboard) and searching through the code. I started using an application called searchmonkey which searches the contents of files. For example, when I was trying to get the backlight to work I would never have know to change the init.rc file. But I just searched the whole android directory for the word "backlight", waited 20 minutes, then looked at the results for files or directories that had RIoT in the name. That and googling any file, structure, or variable name that I didn't understand. It feels like I'm averaging 200 google searches an hour.

                                        • Re: Recompiling Android for use with Parallel RGB TFT LCD and Capacitive Touch Panel
                                          tushar panda

                                          very impressive series of tweaks and hacks, the way you have been selecting and changing at right places thats brilliant.

                                          i appreciate your notoriety for changing things around display  and getting to a working state.