Yocto versus LTIB: what does freescale recommend?

[rebelalliance]

Hello,

I am beginning to embark on building up our i.MX6Q-based system.  I have been using LTIB (4.0.0) but recently switched to Yocto because that's where the most activity seems to be.

What I need to do is choose a build system for our custom board and use it to develop our applications.

What does freescale recommend?  LTIB or Yocto?

Thanks.

EDIT: Just found out that Yocto is not "officially" supported by Freescale and it uses an old BSP.  Does this mean that for real products LTIB 4.0.0 should be used as it is officially supported?

[Dhanyalakshmi]

Hello,

As i saw you have worked on LTIB.As I'm a beginner to learn about build system now i need to learn about LTIB.If you have any notes or information on LTIB can you please share so that i can utilize to work on it.

Thank You

[LeonardoSandova]

With no doubt, Yocto. Freescale will release one more BSP with LTIB, after that all releases will be Yocto Based. Yocto is a huge framework, takes time to get the feeling but it is worth learning it. I hope your transition is smooth!

Leo

[rebelalliance]

So you are recommending that I use Yocto, even though it is not officially released by Freescale?

I guess to really gauge which SDK to go with, I need to know when the 'official' Yocto release will take place.  That way I can decide what SDK to use based on my schedule and the release date of the 'official' Yocto SDK from Freescale.  What I'd like to try to avoid as much as possible is to begin development with LTIB now and then subsequently have to migrate to Yocto.  It just seems like extra work that doesn't need to be done when I could spend that time doing more SW development.  So, in summary, my questions are:

1. Is Yocto 'Dylan' branch good enough in terms of stability and features to begin development of a real-world product?
2. When is the 'official' Freescale Yocto release scheduled to be released?
3. Do you recommend starting development on latest LTIB and then migrating to Yocto when it's officially released, start on Yocto 'dylan' now and forget about LTIB, or just stick to LTIB and forget Yocto?

[RogerioNunes]

Let me try to add my 2 cents too:

* Although Freescale currently distributes the LTIB BSP as official package, there is no support for the user space libraries and tools in general. What is really supported in a BSP is uboot, kernel and specific libraries that are HW dependent (GPU, VPU,...). In other words, you should not expect official support if you have issues with generic user space packages (recipes, versions..), and this statement is valid for both LTIB and Yocto.

* Dylan is using kernel and HW dependent libs from the old BSP 1.1.0 for i.MX6Q, for instance, while the master branch is using kernel 3.0.35 from BSP 4.0.0 and HW libs from the BSP based on kernel 3.5.7 alfa (newer and not public). Also, all the branches are using more recent uboots from the mainline instead of the ones from the LTIB BSPs (forked in 2009). So Yocto is not always using old BSPs. It depends on the branch you're in.

* When you find a bug, if it's proven to be in one of the pieces of SW supported by Freescale, it does not really matter what building environment you' re in. You should see the same bug in all of them :smileyhappy:.

* If you start your project with the master branch from the Yocto BSP, which has recipes for the most recent LTIB BSP packages, you'll probably face a few issues trying to build images, because there has been a lot of activity in all the Yocto layers. According to the Yocto project schedule, next version will be released in the October time frame, so during the next couple of weeks, packages should be stabilized for the release. The same is happening on the meta-fsl-arm layer.

Good luck.

[rebelalliance]

Thanks for the clarifications.

I am reading conflicting info about new LTIB releases.  Will there be another LTIB release or not?

If I do go the Yocto route, should I start with Dylan branch and wait for the next official Yocto release (rather than start working on master now)?  How easy would it be to upgrade from Dylan to the next Yocto (1.5?) release?

[daiane_angolini]

I think there is one thing that must be clarified.

What is "official" to you?

As Rogerio Nunes told, Freescale only support those piece of code related to imx hardware itself. So the "official" package for GPU support is from Freescale.

But, if you look for a rootfs builder, the "official" is not from Freescale. If you´re around Yocto Project, so the "official" release is coming from yoctoproject.org. not from Freescale. The same if you decide to use buildroot or the rootfs from Linaro.

Regarding adopting Yocto or not, it´s completely up to you and your project. I´ve been seeing a lot of work from community to move to yocto. And when I say community I´m not saying imx-community, I´m saying embedded community, or ARM community. But, if you don´t want it to use it, you can create your onw script to build your stuff. I remember when I used to build ntp/ssh manually for every rootfs I needed.... :smileysilly:

If you decide to go to yocto. I would say, start creating the first image from dylan branch. If you only donwload the source code and create your image, it it´s a lot of work. It´s the task #1,2,3 and 4  from my training. Try the image. You don´t need to start customizing.

If you like it, and decide to go for it. Then, you will base your product on current stable branch, and you will work for improvements/bugfixes on master branch. It´s not that easy to change from stable to master/next stable, because a lot of packages are upgraded. If you application depends on ssh from a given version, you may face problems with the upgrade, for example.

And please, if you decide to use yocto, register yourself on https://lists.yoctoproject.org/listinfo/meta-freescale You will have a better yocto support there.

[rebelalliance]

What is "official" to me?

Is this sort of like the question what is the meaning of "life" to me? :smileyhappy:

By official I simply mean a supported and stable kernel with all the drivers for the IP on the silicon (SPI controller, GPU, I2C, USB, etc) which are tested and stable.  That is all there is to an SoC anyway.  I understand userland is the end-user's responsibility but given the kernel and drivers are stable, the userland stuff 'just works'.

So the reason I was querying was to ensure that the BSP (kernel and drivers) is stable so I won't have kernel oops on me when I am building an application.  Given that the BSP versions have changed between Yocto branches, it is conceivable that there are kernel-level fixes on the newer BSP releases that may be important for system stability.

I will start building our application now and choose Yocto or LTIB later when I have our custom board ready.  At the application layer, things are high level enough that it shouldn't matter what the underlying bits are at this point.

Thanks Daiane. :smileyhappy:

[OtavioSalvador]

My point of view is biased (I am a Yocto Project supporter) but I think for new projects does not make much sense to base on LTIB. You will be using a tool which will force you to use Ubuntu 10.04 version (or a heavily patched LTIB release) and will be harder to get wider support from community and/or vendors.

Many Semiconductors manufacturers are making Yocto BSPs available (officially or not), as Freescale, Intel, Texas Instruments and so on; this mean you can use same build system across multiple products and vendors and this easy your product maintenance and reduce total cost of development.

Several vendors offer commercial support/consultancy in Yocto. We, O.S. Systems, does it for several customers. You can also choose WindRiver, Montavista, Metro Graphics and others...

Yocto can also be used to generate the toolchain for you to use during development, as advised by LeonardoSandovalGonzalez, for user-space, kernel and u-boot development, before integrating it onto your custom layer for product development, daily builds and so on...

I hope it is impartial enough and give you good information to make your choice ;-)

Regards,

[rebelalliance]

Your advice is well appreciated.

Thank you.

[LeonardoSandova · Accepted solution]

One LTIB release more (release in two week from now), currently on sanity check. BTW, it is important that you pay attention on the building system but more important is to focus on what you want to do. In other words, develop your system with the tools you know (perhaps autotools and its friends, plain gcc comands, cmake, etc), use a rootfs NFS mounted system so after cross-compilation you have the binaries ready on target; once you have something ready to deliver, then think about LTIB/Yocto or even buildroot :smileyhappy:.

Leo

[LeonardoSandova]

my two-cents:

1. I am not the best to give an opinion, but there is a community on top, so in case you run into trouble, you get help. OtavioSalvador, he is the one with wider visibility.

2. I am not sure about the Yocto Freescale Release, but it wont happen this year. DaianeAngolini, can you narrow the date?

3. I suggest to start developing your stuff on a layer and append it to bblayers.conf. If your are not tight to stuff on meta-fsl-arm (.bbappend files) then adding the FSL release layer will be smooth, I believe. In general, doing recipes on Yocto is much more scalable than doing packages on LTIB.

Leo

[LaurenPost]

Yocto 3.5.7-1.0.0 alpha release was released in July and upgrades have been made to work with Yocto 1.5 pending in master branches in community.

We are planning another Yocto release this year with a new kernel version.    This work is already in development.

Please use Yocto.  LTIB will not be released any more going forward.