For more information, join the team subscribe to the mailing list 
at the bottom of the Launchpad page

    http://launchpad.net/~hybrid-graphics-linux 

Please join this team if you are new by clicking on the "Join 
Team" link at the right of the Launchpad page. It's important to 
have as many users in the community as possible to request for 
appropriate support.

Monday, 28 June 2010

And one more

Please keep providing DSDT.dsl information in this bug report:
https://bugs.launchpad.net/bugs/312756
This is the list of calls to turn off the switchable graphics card in Linux so far:
\_SB.PCI0.P0P1.VGA._OFF
\_SB_.PCI0.OVGA.ATPX   
\_SB_.PCI0.OVGA.XTPX   
\_SB.PCI0.P0P2.PEGP._OFF
\_SB.PCI0.MXR0.MXM0._OFF
\_SB.PCI0.PEG1.GFX0._OFF
\_SB.PCI0.PEG1.GFX0.DOFF
\_SB.PCI0.XVR0.Z01I.DGOF
\_SB.PCI0.PEGR.GFX0._OFF

If you haven't tried the switchable graphics feature in Linux yet, have a look at your DSDT.dsl file. With a bit of luck, you may be able to identify one of the methods above.

acpi_call -- a simple way to call ACPI methods



One of the hybrid-graphics-linux Launchpad team members has created a Linux kernel module to call ACPI methods through /proc/acpi/call. The code is here:


http://github.com/mkottman/acpi_call

You can try it by installing the module and then calling it like this:

sudo insmod acpi_call.ko

echo '\_SB.PCI0.PEG1.GFX0.DOFF' > /proc/acpi/call







Yet another method

Please keep providing DSDT.dsl information in this bug report:
https://bugs.launchpad.net/bugs/312756
This is the list of calls to turn on/off the switchable graphics card in Linux so far:
status = acpi_get_handle(root_handle, "\\_SB.PCI0.P0P1.VGA._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB_.PCI0.OVGA.ATPX", &handle);
status = acpi_get_handle(root_handle, "\\_SB_.PCI0.OVGA.XTPX", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.P0P2.PEGP._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.MXR0.MXM0._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.PEG1.GFX0._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.PEG1.GFX0.DOFF",&handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.XVR0.Z01I.DGOF", &handle);

If you haven't tried the switchable graphics feature in Linux yet, have a look at your DSDT.dsl file. With a bit of luck, you may be able to identify one of the methods above.

Sunday, 27 June 2010

Yet another method

Please keep providing DSDT.dsl information in this bug report:
https://bugs.launchpad.net/bugs/312756
This
is the list of calls to turn on/off the switchable graphics card in
Linux so far:
status = acpi_get_handle(root_handle,
"\\_SB.PCI0.P0P1.VGA._OFF", &handle);
status =
acpi_get_handle(root_handle, "\\_SB_.PCI0.OVGA.ATPX", &handle);
status
= acpi_get_handle(root_handle, "\\_SB_.PCI0.OVGA.XTPX", &handle);
status
= acpi_get_handle(root_handle, "\\_SB.PCI0.P0P2.PEGP._OFF",
&handle);
status = acpi_get_handle(root_handle,
"\\_SB.PCI0.MXR0.MXM0._OFF", &handle);
status =
acpi_get_handle(root_handle, "\\_SB.PCI0.PEG1.GFX0._OFF", &handle);

status
= acpi_get_handle(root_handle, "\\_SB.PCI0.PEG1.GFX0.DOFF
",&handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.XVR0.Z01I.DGOF",
&handle);


If you haven't tried the switchable graphics
feature in Linux yet, have a look at your DSDT.dsl file. With a bit of
luck, you may be able to identify one of the methods above.

Saturday, 26 June 2010

ENZO -- an alternative to CUDA and OpenCL @ www.hpcwire.com

Reposting article from HPCwire:
HPCwire: PathScale Looks to One-Up CUDA, OpenCL with New GPU Compiler
Using the open source NVIDIA graphics driver -- Nouveau,
which is included in the Linux kernel -- PathScale created a fork off the
source code with high performance computing in mind. PathScale also
managed to recruit most of the talent from the driver project. PathScale's CTO, Bergström,
says the team was able to reverse engineer the NVIDIA ISA, register
details, and device exception handling. With that knowledge, they set
out to rewrite the code generator (compiler back-end), driver, and
runtime, focusing on improved memory management, error handling,
security and HPC-specific features, and performance.

Wednesday, 23 June 2010

A CUDA Back-End For Intel's Open-Source Driver? @ www.phoronix.com

[Phoronix] A CUDA Back-End For Intel's Open-Source Driver?
Posting the link for a very interesting article about CUDA for Intel's Open-Source Drivers at phoronix.

Monday, 21 June 2010

OpenCL support from open-source drivers -- what is to come

Zack Rusin recently blogged about advances in the Gallium infrastructure, with work him, Keith Whitwell and José Fonseca have just finished. With much happing lately in the open-source graphics drivers front, it is sometimes difficult to track what remains to be done in the GPGPU area for open-source Linux drivers.
One of the novelties in Gallium-land is the introduction of the concept of resources in the shader representation. Two new items of functionality have been added, the most interesting of them is Gather4, which comes from DirectX 11:
Gather4: Modern GPUs use dedicated hardware blocks known as texture units to fetch data rapidly into their processing cores. These texture units have historically been optimized for rendering graphics, where techniques such as bilinear filtering are typically used to improve image quality. Compute Shaders often make use of these same units to fetch data as well, but they generally have no use for their filtering capabilities, leaving them underutilized. GPUs with Shader Model 5.0 support have the ability to use the excess fetch capability with the Gather4 operation, which can fetch up to 4 values simultaneously and provide a 4xincrease in data bandwidth.

Sunday, 20 June 2010

Acer TimelineX 4280TG DSDT

One of the Acer Timeline/TimelineX Launchpad team members has reported the DSDT table for this laptops model. It contains one method that looks like will allow for the switch of the D-iscrete GPU:
                                Store (Zero, \_SB.PCI0.LPCB.EC0.PSBB)
                                If (LEqual (Local2, One))
                                {
                                    Store (Zero, \_SB.PCI0.LPCB.EC0.DGPU)
                                    If (LEqual (\_SB.PCI0.LPCB.EC0.PSTA, One))
                                    {
                                        Store (Zero, \_SB.PCI0.LPCB.EC0.PSTA)
                                    }

                                    \_SB.PCI0.LPCB.EC0.CPOL (0x14)
                                    Store (One, \_SB.PCI0.LPCB.EC0.QEVN)
                                }
There seems to be another DSDT for a similar model, according to this blog post:
http://skroslak.wordpress.com/2008/01/11/custom-dsdt-loading-on-toshiba-p100p105-laptops-for-ubuntudebian/
Nobody confirmed if this is the right way to go for this laptop, so we need to wait for confirmation on this one.

Saturday, 19 June 2010

OpenCL support from open-source drivers -- status today

Much has happened lately in the open-source graphics drivers front, and one of the questions people is asking is how far are we from having GPGPU support in the shape of open-source Linux drivers. While Nvidia and ATI both provide closed-source OpenCL drivers for Linux, the open-source front is not far from having the same level of functionality.

Work is underway at PathScale to make a kernel driver that supports GPGPU applications, at:

http://github.com/pathscale/pscnv

GPGPU program execution works fine with it already. It's currently missing error handling and has some race conditions, but that should be fixed soon.

OpenCL or even CUDA can be layered over it just fine, but PathScale cannot commit in doing that. This is were other open-source developers can step in.
Documentation for the relevant hardware bits is still sparse, but the irc channels #nouveau or #pathscale are great places to ask questions.

On the ATI open-source drivers front, the situation is also incomplete, but with good ways forward. The easiest method identified so far would be to add OpenCL support to Gallium. Zack Rusin started on an implementation although it's still incomplete, waiting for someone to step in:

http://cgit.freedesktop.org/mesa/clover/

Once the Gallium implementation is near completion, it should work on any gallium driver. Only hardware with DirectX capabilities will work for full functionality. The idea with Gallium is to abstract a basic the hardware driver behind a general interface and then write state tracker front ends that talk to the general interface. The state tracker implements an API like OpenGL, OpenVG, OpenCL, etc. That way, only one hardware driver is needed, and you support for multiple APIs comes for it.

Right now, the r300 Gallium driver is fairly complete, supporting r3xx-r5xx Radeons.  The r600 Gallium driver (for r6xx, r7xx Radeons) has only just started.

Documentation on AMD GPUs is available here:

http://wiki.x.org/wiki/DataSheets

Additionally, there are quite a few resources on the AMD developers website:

http://developer.amd.com/pages/default.aspx

Hopefully this short summary will atract interest from developers waiting for a sexy open-source project to work on.

Many thanks to Marcin Koscielnicki from PathScale and Alex Deucher from AMD for their reports.

Wednesday, 16 June 2010

Kernel mode-setting talk

[Phoronix] Talking About Kernel Mode-Setting
Kernel Mode-Setting enabled some of the interesting graphics drivers features that we are enjoying in the Linux community nowadays. Find in the link a talk about KMS.

Saturday, 12 June 2010

One more linux switchable methods that needs confirmation

One more that needs confirmation: Acer 5935g: http://launchpadlibrarian.net/50231929/DSDT.dsl


                                        If (LEqual (_T_2, One))
                                        {
                                            Store (0x1E, P80H)
                                            ^^PEGP.VGA._ON ()
                                            Store (0x1F, P80H)
                                            Return (GP18)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_2, 0x02))
                                            {
                                                Store (0x0E, P80H)
                                                ^^PEGP.VGA._OFF ()
                                                Store (0x0F, P80H)
                                                Return (GP18)
                                            }
                                        }

Please keep providing DSDT.dsl information in this bug report:
https://bugs.launchpad.net/bugs/312756
This is the list of calls to turn on/off the switchable graphics card in Linux so far:
status = acpi_get_handle(root_handle, "\\_SB.PCI0.P0P1.VGA._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB_.PCI0.OVGA.ATPX", &handle);
status = acpi_get_handle(root_handle, "\\_SB_.PCI0.OVGA.XTPX", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.P0P2.PEGP._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.MXR0.MXM0._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.PEG1.GFX0._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.PEG1.GFX0.DOFF",
&handle);


If you haven't tried the switchable graphics feature in Linux yet, have a look at your DSDT.dsl file. With a bit of luck, you may be able to identify one of the methods above.

Even more linux switchable methods

We received another method from a UL30JT laptop user, please keep providing DSDT.dsl information in this bug report:
https://bugs.launchpad.net/bugs/312756
This is the list of calls to turn on/off the switchable graphics card in Linux so far:
status = acpi_get_handle(root_handle, "\\_SB.PCI0.P0P1.VGA._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB_.PCI0.OVGA.ATPX", &handle);
status = acpi_get_handle(root_handle, "\\_SB_.PCI0.OVGA.XTPX", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.P0P2.PEGP._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.MXR0.MXM0._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.PEG1.GFX0._OFF", &handle);
status = acpi_get_handle(root_handle, "\\_SB.PCI0.PEG1.GFX0.DOFF",
&handle);


If you haven't tried the switchable graphics feature in Linux yet, have a look at your DSDT.dsl file. With a bit of luck, you may be able to identify one of the methods above.

One more hybrid graphics Linux method: Asus K52Jc

The Asus K52Jc laptop DSDT contains a method called:

\_SB.PCI0.PEG1.GFX0.DOFF

You can quite possibly use the lenovo_acpi module and substitute the default method for the one in your DSDT:

http://github.com/doudou/lenovo_acpi

Acer Aspire TimelineX 3820TG Linux hybrid graphics

Acer Aspire TimelineX 3820TG Linux hybrid graphics



00:02.0 VGA compatible controller [0300]: Intel Corporation Core
Processor Integrated Graphics Controller [8086:0046] (rev 12)

02:00.0 VGA compatible controller [0300]: ATI Technologies Inc
Redwood [Radeon HD 5600 Series] [1002:68c1]


To switch off the ATI card use the _SB.PCI0.P0P2.PEGP._OFF method as in:
http://linux-hybrid-graphics.blogspot.com/2010/06/more-linux-switchable-methods.html



See also http://ubuntuforums.org/showthread.php?p=9446283#post9446283



** Attachment added: "from Acer Aspire TimelineX 3820TG"

  http://launchpadlibrarian.net/50146289/DSDT.dsl

Friday, 11 June 2010

Linux Toshiba T135 (T100 Series) Headphone Jack howto

options snd-hda-intel model="olpc-xo-1_5"



to:



/etc/modprobe.d/alsa-base.conf

First steps with CUDA with Ubuntu 10.04 @ http://nsaunders.wordpress.com

Reposting from nsaunders blog:
First cautious steps with CUDA | What You’re Doing Is Rather Desperate









I recently obtained an account on our GPU cluster,
so I thought I should get my head around some of the technology that
drives GPU computing.

Put simply, GPUs can be used to perform calculations and since there are
many processors on a GPU, this can lead to quite substantial speed
increases as compared with CPUs. NVIDIA are
leading the way and they provide libraries and
software tools
for people interested in this field.

Development is typically performed using C, C++ or Fortran. I’m not a
compiled languages guy – I could just about manage a hello world
in C – so I’m relying on tools built by other people, such as R
gputools
.

Step 1 is to download and install the required libraries, toolkit and
possibly, drivers. I ran into a couple of minor problems on my machine,
so I thought I’d document them here.



Specifications

I run Ubuntu 10.04 on a 64-bit machine with a quad-core AMD Phenom II X4
955 Processor and a GeForce 9600 GT nVidia 512 MB card. The issues
documented here relate largely to Ubuntu 10.04.

Install the CUDA toolkit

This is reasonably straightforward. Note that the latest version of the
toolkit is for Ubuntu 9.04.


2chmod +x cudatoolkit_3.0_linux_64_ubuntu9.04.run
3sudo ./cudatoolkit_3.0_linux_64_ubuntu9.04.run

The installer asks where you would like to install the toolkit. I
chose /opt/cuda, over the default /usr/local/cuda. You then add
/opt/cuda/bin to your PATH and /opt/cuda/lib64 to LD_LIBRARY_PATH.
There are several ways to achieve this; I like to edit ~/.profile:


1# CUDA
2if [ -d "/opt/cuda/bin" ] ; then
3    PATH="/opt/cuda/bin:$PATH"
4    LD_LIBRARY_PATH="/opt/cuda/lib64:$LD_LIBRARY_PATH"
5fi

Download and unpack the SDK

This is also quite easy.


2chmod +x gpucomputingsdk_3.0_linux.run
3./gpucomputingsdk_3.0_linux.run

This simply unpacks the SDK to the default destination of
~/NVIDIA_GPU_Computing_SDK.


Fix up issues with compilation

In theory, the next step is to cd to
~/NVIDIA_GPU_Computing_SDK/C, type “make” and watch the sample
applications compile. There are a couple of problems with Ubuntu 10.04.

First, the version of GCC in the distribution is 4.4.3, whereas the SDK
requires, at most, 4.3.x. We need to install gcc-4.3:


1sudo apt-get install gcc-4.3

Next, we have to tell the SDK which GCC to use. Open up
~/NVIDIA_GPU_Computing_SDK/C/common/common.mk in a text editor and:


1# look for this line
2# NVCCFLAGS       :=
3# and change it to this
4NVCCFLAGS       :=
--compiler-bindir=/usr/bin/gcc-4.3

At this point, make still failed with errors related to
libraries. Ubuntu 10.04 has an up-to-date version of the NVIDIA video
driver, so there should be no need to update it. However, check whether
your system has libxi-dev, libxmu-dev and libglut3-dev
and install them if required.

My final make error was “unable to find -lcuda”. On my system,
it lives in /usr/lib/nvidia-current/libcuda.so. A temporary symbolic
link to /usr/lib did the trick:


1sudo ln -sf /usr/lib/nvidia-current/libcuda.so /usr/lib/

Finally, make works and creates 68 executables in the
directory ~/NVIDIA_GPU_Computing_SDK/C/bin/linux/release. If everything
went well, you can now enjoy a fast rendering of a smoke cloud, like
the one in the video at the top of this post, by running smokeParticles.


Next step – figuring out how to do something useful and
bioinformatics-related with this new toy.


I used several very helpful blog posts by other people to
troubleshoot these issues. Unfortunately, I don’t have the links with
me right now, so I’ll update this post later in the day.





Followers