Setting up cross compiling environment & Qt/X11 for the DXSERIES with the ELDK cross compiler

Transcription

1 Setting up cross compiling environment & Qt/X11 for the DXSERIES with the ELDK cross compiler Table of Contents 1 About this document Revision History Conventions Setting up ELDK Eclipse Install Eclipse Cross compile with Eclipse Executing with Eclipse Create a connection to the DXSERIES Set up Run and Debug Configuration Qt Setting up Qt/X Using Qt Using Qt in the Terminal Installing QtCreator Using Qt with QtCreator 1.x.x Using Qt with QtCreator 2.x.x Using Qt with Eclipse Running an application Copy files to DXSERIES Using Nautilus Installing Qt on the DXSERIES Special libraries Linux Kernel driver development Basic set up Compiling a module Running a module Integrate a module in the Kernel About this document This documents describes how to set up a cross compiling environment for the DXSERIES using the ELKD cross compiler. The whole environment is set up using the Ubuntu 32Bit Linux distribution. Additionally there are two ways described to use QtCreator and Eclipse to cross compile an application for the DXSERIES. With Eclipse it is also possible to remote launch the application from within the IDE on the DXSERIES. Anders Electronics provides a completely set up Ubuntu Bit within a VirtualBox virtual machine. 2 Revision History Revision Date Changes A 24/07/2012 Initial version B 27/07/2012 Added a lot of pictures 1/27

2 Added a chapter on how to copy files to the DXSERIES C 01/08/2012 Added chapter "Linux Kernel driver development" D 02/08/2012 Added chapter "Integrate a module in the Kernel" E 13/08/2012 Added Kernel include path to Eclipse project settings when building a kernel module F 14/08/2012 Added link to the wiki page G 29/08/2012 Added option -no-xrender to Qt configuration because the ELDK does not support xrender extension H 08/10/2012 Added more detailed how to add the Compiler and Debugger in Qt manually I 23/10/2012 Changed the path to the Qt-integration-tool for using it on Eclipse 3 Conventions All kinds of code and file snippets are shown like the line below. This is a code line If there is a $ at the beginning like in the line below, this means that this is a command to be executed in a terminal as a normal user. $ user command If there is a # in front of the line it is a command to be executed as root (super user): # root command All names from menues, folders and file names are written in italic. When commands have to be split in multiple lines it looks like this: export PATH=/opt/eldk-5.2.1/armv7a/sysroots/i686-eldk-linux/ usr/bin/armv7a-vfp-neon-linux-gnueabi/:$path 4 Setting up ELDK Install an Ubuntu LTS, 32 Bit system on a computer or a virtual machine. This will probably also work with other distributions. It is recommended to use LTS because there where problems with Drag&Drop in the Qt integration for Eclipse when using Ubuntu LTS. Make sure all updates are installed. Download the ELDK iso file for armv7a from For example: This mirror can be used alternatively because the denx.de server seems to be very slow: Extract the iso file to a folder like /home/anders/eldk Open a terminal and go to the directory where you put the installer: $ cd eldk Make sure that the installer script is executable: $ chmod +x install.sh 2/27

3 Install the ELDK: $./install.sh armv7a He asks for the user password to get root privileges and then he will install the ELDK into /opt/eldk /armv7a/. It is possible to install the ELDK into a different directory, see $./install --help for more information. Now you have to set up some environment variables that are required to use the cross compiler. Add this at the end of your.profile file in the users home directory. It may be required to modify it to the version number and paths according to the version of ELDK you are using (there are no spaces in the lines!). export PATH=/opt/eldk-5.2.1/armv7a/sysroots/i686-eldklinux/usr/bin/armv7avfp-neon-linux-gnueabi/:$PATH export PATH=/opt/eldk-5.2.1/armv7a/sysroots/i686-eldk-linux/usr/bin/:$PATH export ARCH=arm export PKG_CONFIG_PATH="/opt/eldk-5.2.1/armv7a/sysroots/i686-eldklinux/usr/lib/pkgconfig" export PKG_CONFIG_SYSROOT_DIR="/opt/eldk-5.2.1/armv7a/sysroots/i686-eldklinux" export CROSS_COMPILE=arm-linux-gnueabi- You will need to log off and on again that the changes will take effect. Now the basic cross compiling environment is set up. To compile a simple C program you type $ ${CROSS_COMPILE}gcc -o hello hello.c 5 Eclipse An more comfortable way of cross compiling is Eclipse. Besides the basic features you get from an IDE like syntax highlighting and automatic makefile generation Eclipse also provides functions for a remote launch of your application. 5.1 Install Eclipse Before you can install Eclipse you have to make sure that you have installed a Java Runtime Environment. Open a Terminal and execute this command: $ apt-get install default-jre Now go to and download the Eclipse Classic version for Linux 32Bit. Extract the archive to your desktop. Start Eclipse by executing the file called eclipse in the extracted folder. Go the Help Install new Software and add a new Repository by clicking on Add on the top right of the window. Call it CDT and use this link: This path may be adjusted, when you are not using Eclipse Juno. Click OK to add the new repository. 3/27

4 Select --All Available Sites-- from the drop down menu and wait for Eclipse to refresh the list below. Under CDT Main Features select: C/C++ Development Tools C/C++ Development Tools SDK Under CDT Optional Features select: C/C++ GCC Cross Compiler Support C/C++ Remote Launch Under Mobile and Device Development select: Remote System Explorer End-User Runtime Remote System Explorer User Actions Install the selected packages by following the instructions of the wizard. 5.2 Cross compile with Eclipse Eclipse offers some nice functions which allow you to cross compile your application. Create a new C project by going to File New Other. Select the C Project under C/C++ and click Next. 4/27

5 Set a name for the project, we will use cross1 in this example. Set the project type to Executable Empty Project. Set the Toolchains to Cross GCC and click Next. On the second page are no settings to be changed, just click Next. On the third page set the Cross compiler prefix to arm-linux-gnueabi- and the Cross compiler path to /opt/eldk-5.2.1/armv7a/sysroots/i686-eldk-linux/usr/bin/armv7a-vfp-neon-linux-gnueabi. 5/27

6 Press Finish to create the project. Create a new source file by clicking on File New Source File, call it main.c. Press Finish to create the file and add a small hello world program in the file: #include <stdio.h> int main(int argc, char* argv[]) { printf("hello world\n"); return 0; } 6/27

7 Compile the program by hitting the button with a hammer. When you open the Console at the bottom of Eclipse you should see him invoking the arm-linux-gnueabi-gcc cross compiler to compile the program. In the project directory you will find a file called cross1. This is the executable which you have to copy to the DXSERIES. How to do this will be described later in chapter Executing with Eclipse Now you can just copy the created file cross1 to the target and execute it. A better and easier way is to let Eclipse do that for you by a remote execution Create a connection to the DXSERIES First of all you will need to create a connection to the DXSERIES. Go to Window Show View Other, expand Remote Systems and select the Remote System Explorer and click OK. 7/27

8 At the bottom of Eclipse you should see a Remote Systems tab which should look like this: Create a new connection by clicking on the small symbol with a + in the Remote Systems tab. As Remote System Type select Linux and press Next. For the Host Name enter the IP address of your DXSERIES and press Next. In the Files tab select ssh.files for Configuration and press Next. In the Process tab select process.shell.linux for Configuration and press Next. In the Shells tab select ssh.shells for Configuration and press Next. In the SSH Terminals tab select ssh.terminals for Configuration and press Finish. Now you have a new connection in the Remote Systems tab. It is better to move the Remote Systems tab with Drag&Drop on the left side of Eclipse. 8/27

9 Right click on the connection and select Connect. He may ask you to accept the SSH connection and other things, accept that. After that you should be able to browse the remote file system by going to Sftp Files Root. He will also ask for a user name and password to use, use the user and password of the DXSERIES. He may also ask you to create a new password for the Eclipse password storage. It is now possible to Drag&Drop files from your local file browser to a folder in Eclipse. We will later introduce a even more comfortable way of copying files Set up Run and Debug Configuration To tell Eclipse to run the current application cross1 on the DXSERIES a special Run Configuration has to be created. Click on Run Run Configurations. Here are all the Run Configurations listed. If there is already any configuration you should remove it, because it will not be used. Double click on C/C++ Remote Application to create a new remote launch configuration. 9/27

10 Next to Connection select the connection you created before and click on Properties next to it. Here you have to set the remote workspace path. This path must exist! For example use /home/root/ and press OK. Make sure the box Select configuration using C/C++ Application is not checked. In Remote Absolute File Path For C/C++ Application set the complete path where to put the executable including the name of the file. For example /home/root/cross1. Put this in the field Commands to execute before application to make the file executable after Eclipse copied it to the DXSERIES: chmod 777 /home/root/cross1 After that click Apply and Close to save the settings. Now open Run Debug Configurations. There should already be a C/C++ Remote Application where Eclipse made the same settings as in the Run Configuration. 10/27

11 Go the the Debugger tab. In the area Debugger Option go to the tab Main and set this in the field GDB Debugger (there is no space in the line!): /opt/eldk-5.2.1/armv7a/sysroots/i686-eldk-linux/usr/bin/armv7a-vfp-neonlinux-gnueabi/arm-linux-gnueabi-gdb Click Apply and close the configuration dialogue. To support debugging on the DXSERIES you will have to install the gdbserver on it. The gdbserver is not required if you don't want to debug the application. When you are in the Remote System Explorer view of Eclipse you can open a terminal in Eclipse by right clicking on Ssh Terminals under your connection and select Launch Terminal. 11/27

12 Type this to install the gdbserver type this in the new created terminal: # opkg update # opkg install gdbserver The DXSERIES has to be connected to the internet. When you want to run or debug the application for the first time you have to go to Run Run/Debug Configurations, select the configuration you created and click the Run or Debug button. After that is is possible to run the application from the small arrow next to the run and debug buttons at the top of Eclipse. Here you click on the name of your run or debug configuration and he will automatically load the executable to the DXSERIES and execute it. You can see the output of the application in the Console tab of Eclipse. 6 Qt Qt is a powerful C++ library for creating graphical user interfaces and many more things. It is portable over many operation systems and platforms. There is also a embedded version of Qt called Qt/embedded which doesn't need a X server which makes systems very lightweight and fast. In this 12/27

13 document we will discuss how to set up Qt using the X server but compiling it for embedded use is not a big difference. 6.1 Setting up Qt/X11 You first need to set up the terminal compilation method described above. Download the Qt sources from Scroll a bit down to "Qt libraries". The file should have a name like qt-everywhere-opensource-src tar.gz. Extract the sources into you home directory: $ tar xzf Downloads/qt-everywhere-opensource-src tar.gz Change into the Qt directory: $ cd qt-everywhere-opensource-src Copy the modified configuration for Qt and replace the existing one. You will find the modified file in the Anders DXSERIES wiki: $ cp../downloads/qmake.conf mkspecs/qws/linux-arm-gnueabi-g++/qmake.conf Then open the file in mkspecs/qws/linux-arm-gnueabi-g++/qmake.conf and make sure that all the paths to the ELDK are correct. Make sure all required tools like make are installed: $ sudo apt-get install build-essential After that use the following command line to configure Qt. The path behind -prefix defines the folder where Qt will be installed. This is the folder for the local computer and the DXSERIES. You should not install it in / because this will cause problems with a local x86 installation of Qt. Execute the following command to configure the Qt sources (hit return after each line):./configure -arch arm -xplatform qws/linux-arm-gnueabi-g++ \ -force-pkg-config -nomake demos -nomake examples -no-openssl \ -no-sql-sqlite -no-phonon -no-phonon-backend -no-webkit \ -prefix /usr/local/trolltech/qt-arm-x11 \ -D QT_RX71_MULTITOUCH -confirm-license When the script finishes without any error continue compiling Qt: $ make -j X Where X is the number of cores your CPU has plus one. So type $ make -j 5 on a quad core machine. This will speed up things by using parallel compilation. Note: Depending on the speed of your computer this process can take several hours. To install Qt on your local machine (which is required to cross compile) just type $ sudo make install Now you should add /usr/local/trolltech/qt-arm-x11/bin to your PATH variable by adding the following line to your users.profile file in your home directory: export PATH=/usr/local/Trolltech/Qt-arm-X11/bin/:$PATH To open the file type: $ gedit ~/.profile You will have to log out and log in again for changes to take effect. 13/27

14 6.2 Using Qt There are tree different ways of using Qt for compilation. You can simply use the terminal to compile your Qt code, you can use the QtCreator or you can use Eclipse. For the QtCreator there are two guides, depending on which version of QtCreator you are using. It is recommended to use version 2 of QtCreator because it is much easier to set up cross compiling Using Qt in the Terminal To use Qt in the terminal you simply need to go into the folder where your sources are and run $ qmake -project to create the.pro file. This is required only once for each project but it needs to be done again when you add source files. After that you can create a make file by invoking $ qmake Qt will take care of cross compilation and you just have to run $ make to compile the project Installing QtCreator Install the normal QtCreator for X86 on your desktop machine. You do not need to install the whole Qt libraries, only what is required for the QtCreator itself. To install QtCreator on a Debian based system (like Ubuntu) type this in a terminal: $ sudo apt-get install qtcreator If you also want to install Qt libraries for a local compilation invoke this command: $ sudo apt-get install libqt4-dev Using Qt with QtCreator 1.x.x Start your QtCreator and create a simple project. Now go to Tools Options Debugger Gdb and select the ARM cross gdb: /opt/eldk-5.2.1/armv7a/sysroots/i686-eldk-linux/usr/bin/armv7a-vfp-neonlinux-gnueabi/arm-linux-gnueabi-gdb On the left side go to Qt4 Qt Versions and add a new Qt version to Manual. Call it something like Qt for ARM and add the qmake executable: /usr/local/trolltech/qt-arm-x11/bin/qmake Now the QtCreator is ready for cross compiling. There is one issue with the ELDK which causes g++ to complain about this: note: the mangling of 'va_list' has changed in GCC 4.4 This is a known issue and can be ignored. To tell GCC to suppress this message you can pass the argument -Wno-psabi to it. To do this in a Qt project add the following line at the end of your.pro file: QMAKE_CXXFLAGS += -Wno-psabi 14/27

15 6.2.4 Using Qt with QtCreator 2.x.x First create your project like you would do it for a normal desktop application. Therefore click on File New File or Project and select the type of project you want to create. For example a Qt GUI Application like below. Click Choose to continue. After that you will be asked to choose a project name: Enter a name and click Next to continue. The next step is to select which compilers to use. Normally you should let the default setting "For Each Qt Version One Debug And One Release". This will create a build configuration for your local Qt (if you have installed it) and the cross compiling version. 15/27

16 Follow the instructions to finish the wizard. Normally the QtCreator should automatically detect the cross compiler and the self build Qt. To check this click on the button above the Run button on the left side of QtCreator and click on the drop down menu next to Build. If the cross compiler was detected it should look like in the picture below. There should be two build targets with Qt-arm-X11 in the brackets, one for release and one for debug. If this does not work for you this normally means that you does not have set up your.profile file in your home directory correctly. Double check the paths in the.profile file. Or you forgot to log out and log in again. It is also possible to set it up manually by clicking on the Projects button on the left side of QtCreator. Here you can add the Qt libraries and the cross compiler tool chain manually. There are just a few steps to fix it: First click on the button Projects on the left of the Qt surface. Then the Build Settings will be shown. At the General block, you will find the Qt version. Just click on the button Manage just right of it. 16/27

17 In the up popped window, you see the Build & Run -Options, with four blocks called General, Qt Versions (in which you are right now), Tool Chains and CMake. Just stay in the Qt Versions and click on Add on the right top side. Next, you have to add the path to the qmake executable: /usr/local/trolltech/qt-arm-x11/bin/qmake and click open. Back to the Options window, the version name and the qmake location will be shown by the Qt: Version name : Qt (Qt-arm-X11). Now, change to the the Tool Chains. Go to the right side and add a GCC to the Tool Chains by clicking on add and GCC. After this, click on the GCC at the manual part of the list. You will see at the lower area the Compiler path and the Debugger. Just type in there the following lines: Compiler path: /opt/eldk-5.2.1/armv7a/sysroots/i686-eldk-linux/usr/bin/armv7a-vfpneon-linux-gnueabi/arm-linux-gnueabi-gcc 17/27

18 Debugger: /opt/eldk-5.2.1/armv7a/sysroots/i686-eldk-linux/usr/bin/armv7a-vfpneon-linux-gnueabi/arm-linux-gnueabi-gdb Just click Apply to save the settings. After restart the QtCreator, you will find the Qt-arm-X11-compiler in the compiler list Using Qt with Eclipse It is possible to combine Qt with Eclipse. This will make it possible to remote launch Qt applications like you maybe did already with a normal C/C++ application. First you have to follow the instructions above to install Eclipse and Qt for command line usage. Then go to the webpage ftp://ftp.qt.nokia.com/qteclipse/ and download the following Qt integration for Eclipse : qt-eclipse/integration-linux.x tar.gz. Install it by extracting it into your Eclipse folder: Start Eclipse by opening a Terminal and go to the folder where you installed Eclipse, for example: $ cd Desktop/eclipse Start Eclipse with this command: $./eclipse -clean Create a Qt Project by clicking on File New Other. Select Qt Qt GUI Project and press Next. 18/27

19 Enter a name for the project, for example QtCross1 and press Finish. When creating the first project Eclipse will complain about a missing Qt at the end of the creation process. Click on Open preferences to open the preferences of the project. It is also possible to open this dialogue by clicking on Window Preferences Qt Add afterwords. On the right side click on Add (you may need to increase the size of the window to see the button). Enter a version name like Qt ARM, the Qt bin path is /usr/local/trolltech/qt-arm-x11/bin and the Qt include path is /usr/local/trolltech/qt-arm-x11/include. Press Finish to finish the set up. After that the project is ready to compile. Click on Project Build project to compile the project. 19/27

20 If you want to set up a remote launch do it like described above with one extra thing. Set this in the field Commands to execute before application: chmod 777 /home/root/qtcross1;export DISPLAY=:0.0 Important is the additional export command which will tell your application where to find the X server. There are some problems with Eclipse to find the correct include paths and it shows some errors which are no errors, the application will compile just fine but Eclipse will not let you start the application. To solve this you have to disable the Code Analysis in Eclipse. Go to Window Preferences C/C++ Code Analysis. Uncheck all check boxes for the Code Analysis. After that Eclipse may still have some Warnings about not finding some include files. To fix this right click on your Qt project and select Properties. Click on C/C++ Include Paths and Symbols and add these two paths with Add External Include Path: /opt/eldk-5.2.1/armv7a/sysroots/armv7a-vfp-neon-linux-gnueabi/usr/include /opt/eldk-5.2.1/armv7a/sysroots/armv7a-vfp-neon-linuxgnueabi/usr/include/c++ 20/27

21 7 Running an application After you have compiled your application with you preferred IDE simply copy the application to the DXSERIES and run it. Follow the instructions below to copy the executable to the DXSERIES. 7.1 Copy files to DXSERIES When you are running Linux with Nautilus as file browser it is very simple to copy files to the DXSERIES. Nautilus is used for example in Ubuntu Using Nautilus First of all you have to set a password for the user you are going to use on the DXSERIES. Probably this will be root. Log in as the user and type $ passwd to change the password. After that open Nautilus on your host machine and click on File Connect to Server. As Type select SSH, enter the IP address of the DXSERIES in the field Server and type your user name and password. This should look like the picture below. Click on Connect to connect to the DXSERIES. Nautilus will create a SFTP network connection and mount it for you. You can right click on the mounted folder on the left side and select Add Bookmark to add this connection as a bookmark. 21/27

22 Keep in mind that you are acting as the user you selected when you created the connection. Means that as a normal user you don't have write access to files except those in you home directory. If you are logged in as root and create files in the home directory of an other user, the other use will not be able to delete or modify the files you created. 7.2 Installing Qt on the DXSERIES To run a Qt application on the DXSERIES it is required to copy the Qt libraries and some other stuff to the DXSERIES. You should first set up the connection to copy files to the DXSERIES like described in chapter 7.1. Now you have to copy the files from /usr/local/trolltech/ on your host machine in the same directory on the DXSERIES. It is required to be connected as root to the DXSERIES. The folder /usr/local/ may not exist on the DXSERIES, just create it. 7.3 Special libraries If you need special libraries and special versions from ELDK which already exist on the DXSERIES you need to run the application with a dynamic linker because it is not recommended to overwrite the existing libraries. To do this copy the rootfs of ELDK to the target system in a subdirectory, for example in /eldk. The rootfs of ELDK is located in /opt/eldk /armv7a/sysroots/i686-eldk-linux/ You should end up with a folder structure like /eldk/usr/lib/ on the DXSERIES. You do not have to copy the full rootfs. Required are only the folders /lib and /usr/lib. It is also possible to remove unneeded libraries from this folders. To run you application with a dynamic linker that uses special paths use the following command (this is a single line with a space at the line break): $ /eldk/lib/ld-linux.so.3 --library-path /eldk/lib:/eldk/usr/lib /path/to/your/program 8 Linux Kernel driver development It may be required to develop some drivers for Linux, for example to access the GPIOs. Eclipse offers with some tricks a great platform for kernel driver development. 8.1 Basic set up Before you can compile a kernel module you will need some files from the kernel. These files are included in the build image which you can download from the AndersDX wiki: Extract this archive to your home folder. These files include all the configuration that is required to build a kernel module and they also include the header files from the Linux kernel. 8.2 Compiling a module To compile a Kernel driver module in Eclipse you need to create a Makefile project in Eclipse. This means that you will have to create the Makefile your own but this is quite simple as the Kernel itself provides most of the settings. Go to File New Other C/C++ C Project and click Next. 22/27

23 On the next page enter a name for you kernel module and select Makefile project Empty project on the left of the wizard. The tool chain must be set to Cross GCC. Press Finish to finish the wizard. You will now find an empty project in the Project Explorer on the left site of Eclipse. Right click on it and select New Source File. Enter the same name as you named the project and attend the.c ending. 23/27

24 Press Finish to create the source file. Now you have to create the Makefile. Right click your project again and select New File and call it Makefile. Press Finish to create the Makefile. Now open the Makefile and add this content: obj-m += MyKernelModule.o all: make -C ~/build M=$(PWD) modules 24/27

25 clean: make -C ~/build M=$(PWD) clean You may change the path to the build folder which you extracted before and also the name of the.o file if you choose an other project name. Please make sure that in front of the lines with a make the spaces are tabs and no normal spaces! Otherwise the Makefile will not work! You will also need to add some include paths to Eclipse that Eclipse will find them. Right click on your project and select Properties. Go to C/C++ General and select Paths and Symbols. Click on GNU C and create a new path pointing to ~/build/include/ where you may replace the ~ symbol with the home directory of you user, for example /home/anders/build/include/. Now create your kernel module, below is a small hello world module. #include <linux/module.h> #include <linux/kernel.h> #include <linux/printk.h> int load_module(void) { printk(kern_info "module example loaded\n"); return 0; } void unload_module(void) { printk(kern_info "module example unloaded\n"); } MODULE_LICENSE("GPL"); module_init(load_module); module_exit(unload_module); To compile the module simple press the hammer at the top of Eclipse: 8.3 Running a module Of course you can now copy the created.ko file (which is the compiled module) to the DXSERIES and insert into the kernel with the insmod command but with Eclipse it is possible to remote launch the application. Go to Run Run Configurations and double click on C/C++ Remote Application to create a new remote launch. Select the connection to the DXSERIES or create a new one like described in chapter Click on Properties next to the connection and set the workspace path, for example /home/root/. Make sure the tick in front of "Select configuration using C/C++ Application" is removed. As Eclipse is not aware of kernel modules and how to treat them he will not find the generated.ko file in the field C/C++ Application. You will have to click Browse and navigate to your project folder and select the.ko file. Change the remote path to: /home/root/mykernelmodule.ko Now it is required to fool Eclipse. Normally it will try to run the executable by invoking a command like./mykernelmodule.ko but this is a kernel module and will not work. Type this in the field Commands to execute before application: rmmod MyKernelModule.ko;insmod MyKernelModule.ko;exit # 25/27

26 The first command will make sure that the module is unloaded, the second one will load the module. After that the command exit will be invoked because Eclipse would append this normally. The last character is a # which will convert all commands that Eclipse will append (like executing the application) to comments. Thus they will be ignored. This also means that it is not possible to debug the kernel module like you did it with a normal application through remote launch. When the module is not loaded (like at the first run) Eclipse will report an error like this: ERROR: Module MyKernelModule does not exist in /proc/modules Just ignore it. It is caused by the rmmod command which cannot find the loaded module. 8.4 Integrate a module in the Kernel Sometimes it is easier to integrate a driver in the kernel. Than you can provide a single patch for the kernel that will add the driver to your kernel, means that it will be very easy to use the driver. And integrating the driver into the kernel has an other advantage. You don't have to build it as a module, you can build it inside the kernel which means that it will be loaded much earlier and some driver must be included in the kernel image like display drivers. First of all you must find a category where to put the kernel. The backlight driver that is required for the DXSERIES is located in driver/video/backlight. Put the.c file of your driver into the correct directory. In this directory you should find two files called Kconfig and Makefile. Open the Kconfig file with a text editor. Here you have to add an menu entry that will be displayed when you run make menuconfig. Just look at the other entries, just copy one of them and edit like you need it. Make sure that in front of the options like tristate, depends and help are only tabs and no spaces! When you have to break the text for the help option make sure that in front of each line is a tab and two spaces. The depends line defines the depending of your driver. For example the DXSERIES backlight driver requires these depends: depends on BACKLIGHT_CLASS_DEVICE && CONFIG_OMAP_DM_TIMER The first line is very important, it looks something like this: config BACKLIGHT_OMAP3PWMBL Now open the Makefile and add an entry like the this: 26/27

27 obj-$(config_backlight_omap3pwmbl) += omap3-pwm-bl.o It is important that in both files the name of the config is the same, except that you leave out the CONFIG_ in the Kconfig file. After that save both files and run $ make menuconfig inside the kernel source tree and go to your driver and select it. If you want to change the default configuration for your driver after invoking make cm_t3730_defconfig edit the file arch/arm/configs/cm_t3730_defconfig. Just add your config variable. Like this if you want to build it in the kernel: CONFIG_BACKLIGHT_OMAP3PWMBL=y or like this if you want to build it as a module: CONFIG_BACKLIGHT_OMAP3PWMBL=m 27/27