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

— Read more

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.

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.

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.

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.

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.

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.

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.

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.

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

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. view sourceprint? 1 wget http://developer.download.nvidia.com/compute/cuda/3_0/toolkit/cudatoolkit_3.0_linux_64_ubuntu9.04.run 2 chmod +x cudatoolkit_3.0_linux_64_ubuntu9.04.run 3 sudo ./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: view sourceprint? 1 # CUDA 2 if [ -d "/opt/cuda/bin" ] ; then 3     PATH="/opt/cuda/bin:$PATH" 4     LD_LIBRARY_PATH="/opt/cuda/lib64:$LD_LIBRARY_PATH" 5 fi Download and unpack the SDK This is also quite easy. view sourceprint? 1 wget http://developer.download.nvidia.com/compute/cuda/3_0/sdk/gpucomputingsdk_3.0_linux.run 2 chmod +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: view source print? 1 sudo 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: view sourceprint? 1 # look for this line 2 # NVCCFLAGS       := 3 # and change it to this 4 NVCCFLAGS       := --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: view sourceprint? 1 sudo 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.