Multiple x86 platforms support

[Chih-Wei Huang]

Hi,
As you may have noticed, the multiple x86 platforms support
has been pushed into master branch of the git server.

The basic goals of this architecture are

* provide a base target containing all common parts
(like keymaps, firmwares, ...) for any x86 product.
The target is called generic_x86 and can be inherited
by any other x86 target.
* give a chance for a target to be optimized for
a particular product.

Two targets (eeepc, q1u) in the vendor directory have been
re-organized to compliant to this architecture.

The MOST IMPORTANT THING you have to note is,
eeepc is no longer a generic target to support any x86 platform.
Now it only contains drivers and firmware for ASUS Eee PC family.
That is, it may not work on your hardware if it's not an Eee PC.

So you have two choices:

* Build and use the generic_x86 target. That is,
make iso_img TARGET_PRODUCT=generic_x86
(actually TARGET_PRODUCT=generic_x86 can be ignored --
it is the default target now)
It will generate an iso that contains all x86 drivers and firmwares.
On booting, it will auto detect your hardware and load necessary drivers.
If auto-detection works for you before, this should be ok for you now.

* If auto-detection doesn't work well on your hardware,
or you hope to optimize the image for your product,
you should consider to create a target for it.
You can read eeepc and q1u in vendor dir as examples.
Later I'll give more details about how to do it in another email.

Happy New Year!

--
Chih-Wei
Android-x86 project
http://www.android-x86.org

[hedwin]

Hi,

Is this only for the master branch or also applicable for the "side"branch(es) like donut_x86

Hedwin

--

You received this message because you are subscribed to the Google Groups "Android-x86" group.
To post to this group, send email to andro...@googlegroups.com.
To unsubscribe from this group, send email to android-x86...@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/android-x86?hl=en.

[Chih-Wei Huang]

Hi,
This email I describe how to create a target for your own device.
First, create vendor/xxx/yyy dir in your android-x86 tree,
where xxx is usually the vendor's name and yyy is the product name.
Then you at least have to create four makefiles:

* AndroidProducts.mk
This makefile should only contain PRODUCT_MAKEFILES
which is a list of product makefiles to expose to the build system.
So if your product name is yyy,
PRODUCT_MAKEFILES := * $(LOCAL_DIR)/yyy.mk

* The product makefile: yyy.mk
You have to define PRODUCT_PACKAGES,
PRODUCT_NAME, PRODUCT_DEVICE in it,
and call inherit-product to inherit from a product makefile.
I suggest to to inherit generic_x86.mk to get
all common x86 rules.

* The board config makefile: BoardConfig.mk
You can override some variables before including
$(GENERIC_X86_CONFIG_MK)

- TARGET_HAS_THIRD_PARTY_APPS
set to true if you hope to compile third party apps
like ConnectBot, FileManager introduced by Android-x86.
Default: false
- BOARD_USES_ALSA_AUDIO
Set to false if you don't want ALSA audio.
Default: true.
- BOARD_HAVE_BLUETOOTH
If you don't need bluetooth, set it to false.
Default: true.
- BOARD_USES_TSLIB
Set to true if you need tslib to calibrate the touchscreen.
Default: false
- BOARD_KERNEL_CMDLINE
You can customize your cmdline (kernel boot options)
- BOARD_WPA_SUPPLICANT_DRIVER
Set to true if you need wifi support

* The android board makefile: AndroidBoard.mk
You can override some variables before including
$(GENERIC_X86_ANDROID_MK)

- LOCAL_FIRMWARES
Specify the firmwares to be included in the target
The firmwares are supposed to be already in
build/target/board/generic_x86/firmware/.
You may also specify a different directory in
LOCAL_FIRMWARES_DIR.
- TARGET_INITRD_SCRIPTS
Specify a hook script to be added in the initrd.img.
Usually the script should contain a detect_hardware
function that will be called by the init script.
Read eeepc_info as an implementation example.
- TARGET_PREBUILT_APPS
If you want to include some prebuilt apps (apk files),
set them to this variable.
- TARGET_KERNEL_CONFIG
Specify a kernel config file for this target.
If not set, the default android-x86_defconfig
will be used.

Besides the four makefiles, you may also add the file
init.yyy.rc to do some initializations for your product
The file will be included automatically if exists,
and called by Android init on booting
(after executing init.rc).

Regards,

[Matt Richards]

Have this change been pushed to sf mirror?

--
--Matt

[Chih-Wei Huang]

Almost there, except the Eee PC optimized kernel config,
which I just did now.

2010/1/4 Matt Richards <mric...@gmail.com>:

[bitstate]

Hi :)

Hedwin: I just tried the make target "generic_x86" on a fresh sync of donut_x86 and there make finds no matches, so i think its only applicable for the master branch.

/Andreas

[Darren Mason]

Hi,

Gone through all the instructions on this and setup all the relevant
makefiles, however getting a problem which appears to be environment
related but I am not sure how to solve.

Call make iso_img TARGET_PRODUCT=<newtarget>

and after headers and stuff get copied to out directory it appears to
attempt the kernel compilation.
First step seems to be compiling conf so that it can get the kernel
config to build from.

I am getting a failure on zconf.tab.c not found.
It appears that this is a generated file which should happen as aprt
of the kernel make.
For some reason it is not happening when I use my new target.

If I go into the kernel directory and do a make menuconfig or
something similar then it seems to do the generation required and then
proceeds.
Going back to build my newtarget now gives me an 'unclean' kernel
which I am instrcuted to fix with 'make mrproper' - which then removes
the generated zconf.tab.c and I am back where I started.

Both other targets 'eeepc' and 'q1u' don't have the problem and seem
to work fine.

I have tried my target with TARGET_KERNEL_CONFIG set and without (so
it should use the default config). Both exhibit the same behaviour.

I am guessing that I have just overlooked something simple but am
struggling to solve by myself.

Has someone else successfully used the multiple platform support with
a successful kernel compile?

All help apprecisted. I can get actual errors later on. I am not
currently at the development machine.

I built the makefiles from copying the eeepc ones and editing.

Regards
Darren

[Chih-Wei Huang]

DO NOT use make in the kernel/ directory directly.
It will generates output files in kernel/ that will conflict
with Android-x86 build system.

Try this way to solve: (on the top dir of android-x86 tree)

make -C kernel distclean
rm -rf out/target/product/eeepc/obj/kernel out/target/product/eeepc/kernel
(or, more cleaner, just rm -rf out )

Then make your target again.

2010/2/5 Darren Mason <darre...@optushome.com.au>: