Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6

	    <entry></entry>

	    <entry>A place holder for future extensions and custom

(driver defined) buffer types

<constant>V4L2_BUF_TYPE_PRIVATE</constant> and higher.</entry>

<constant>V4L2_BUF_TYPE_PRIVATE</constant> and higher. Applications

should set this to 0.</entry>

	  </row>

	</tbody>

      </tgroup>

driver's incoming queue. The semantics depend on the selected I/O

method.</para>

    <para>To enqueue a <link linkend="mmap">memory mapped</link>

buffer applications set the <structfield>type</structfield> field of a

&v4l2-buffer; to the same buffer type as previously &v4l2-format;

<structfield>type</structfield> and &v4l2-requestbuffers;

<structfield>type</structfield>, the <structfield>memory</structfield>

field to <constant>V4L2_MEMORY_MMAP</constant> and the

    <para>To enqueue a buffer applications set the <structfield>type</structfield>

field of a &v4l2-buffer; to the same buffer type as was previously used

with &v4l2-format; <structfield>type</structfield> and &v4l2-requestbuffers;

<structfield>type</structfield>. Applications must also set the

<structfield>index</structfield> field. Valid index numbers range from

zero to the number of buffers allocated with &VIDIOC-REQBUFS;

(&v4l2-requestbuffers; <structfield>count</structfield>) minus one. The

<constant>V4L2_BUF_TYPE_VBI_OUTPUT</constant>) applications must also

initialize the <structfield>bytesused</structfield>,

<structfield>field</structfield> and

<structfield>timestamp</structfield> fields. See <xref

	linkend="buffer" /> for details. When

<structfield>timestamp</structfield> fields, see <xref

linkend="buffer" /> for details.

Applications must also set <structfield>flags</structfield> to 0. If a driver

supports capturing from specific video inputs and you want to specify a video

input, then <structfield>flags</structfield> should be set to

<constant>V4L2_BUF_FLAG_INPUT</constant> and the field

<structfield>input</structfield> must be initialized to the desired input.

The <structfield>reserved</structfield> field must be set to 0.

</para>

    <para>To enqueue a <link linkend="mmap">memory mapped</link>

buffer applications set the <structfield>memory</structfield>

field to <constant>V4L2_MEMORY_MMAP</constant>. When

<constant>VIDIOC_QBUF</constant> is called with a pointer to this

structure the driver sets the

<constant>V4L2_BUF_FLAG_MAPPED</constant> and

&EINVAL;.</para>

    <para>To enqueue a <link linkend="userp">user pointer</link>

buffer applications set the <structfield>type</structfield> field of a

&v4l2-buffer; to the same buffer type as previously &v4l2-format;

<structfield>type</structfield> and &v4l2-requestbuffers;

<structfield>type</structfield>, the <structfield>memory</structfield>

field to <constant>V4L2_MEMORY_USERPTR</constant> and the

buffer applications set the <structfield>memory</structfield>

field to <constant>V4L2_MEMORY_USERPTR</constant>, the

<structfield>m.userptr</structfield> field to the address of the

buffer and <structfield>length</structfield> to its size. When the

buffer is intended for output additional fields must be set as above.

buffer and <structfield>length</structfield> to its size.

When <constant>VIDIOC_QBUF</constant> is called with a pointer to this

structure the driver sets the <constant>V4L2_BUF_FLAG_QUEUED</constant>

flag and clears the <constant>V4L2_BUF_FLAG_MAPPED</constant> and

<structfield>flags</structfield> field, or it returns an error code.

This ioctl locks the memory pages of the buffer in physical memory,

they cannot be swapped out to disk. Buffers remain locked until

dequeued, until the &VIDIOC-STREAMOFF; or &VIDIOC-REQBUFS; ioctl are

dequeued, until the &VIDIOC-STREAMOFF; or &VIDIOC-REQBUFS; ioctl is

called, or until the device is closed.</para>

    <para>Applications call the <constant>VIDIOC_DQBUF</constant>

ioctl to dequeue a filled (capturing) or displayed (output) buffer

from the driver's outgoing queue. They just set the

<structfield>type</structfield> and <structfield>memory</structfield>

<structfield>type</structfield>, <structfield>memory</structfield>

and <structfield>reserved</structfield>

fields of a &v4l2-buffer; as above, when <constant>VIDIOC_DQBUF</constant>

is called with a pointer to this structure the driver fills the

remaining fields or returns an error code.</para>

&VIDIOC-REQBUFS; ioctl.</para>

    <para>Applications set the <structfield>type</structfield> field

    of a &v4l2-buffer; to the same buffer type as previously

    of a &v4l2-buffer; to the same buffer type as was previously used with

&v4l2-format; <structfield>type</structfield> and &v4l2-requestbuffers;

<structfield>type</structfield>, and the <structfield>index</structfield>

    field. Valid index numbers range from zero

to the number of buffers allocated with &VIDIOC-REQBUFS;

    (&v4l2-requestbuffers; <structfield>count</structfield>) minus one.

The <structfield>reserved</structfield> field should to set to 0.

After calling <constant>VIDIOC_QUERYBUF</constant> with a pointer to

    this structure drivers return an error code or fill the rest of

the structure.</para>

<constant>V4L2_BUF_FLAG_MAPPED</constant>,

<constant>V4L2_BUF_FLAG_QUEUED</constant> and

<constant>V4L2_BUF_FLAG_DONE</constant> flags will be valid. The

<structfield>memory</structfield> field will be set to

<constant>V4L2_MEMORY_MMAP</constant>, the <structfield>m.offset</structfield>

<structfield>memory</structfield> field will be set to the current

I/O method, the <structfield>m.offset</structfield>

contains the offset of the buffer from the start of the device memory,

the <structfield>length</structfield> field its size. The driver may

or may not set the remaining fields and flags, they are meaningless in

allocated with this ioctl before they can be mapped into the

application's address space. User buffers are allocated by

applications themselves, and this ioctl is merely used to switch the

driver into user pointer I/O mode.</para>

driver into user pointer I/O mode and to setup some internal structures.</para>

    <para>To allocate device buffers applications initialize three

fields of a <structname>v4l2_requestbuffers</structname> structure.

    <para>To allocate device buffers applications initialize all

fields of the <structname>v4l2_requestbuffers</structname> structure.

They set the <structfield>type</structfield> field to the respective

stream or buffer type, the <structfield>count</structfield> field to

the desired number of buffers, and <structfield>memory</structfield>

must be set to <constant>V4L2_MEMORY_MMAP</constant>. When the ioctl

is called with a pointer to this structure the driver attempts to

allocate the requested number of buffers and stores the actual number

the desired number of buffers, <structfield>memory</structfield>

must be set to the requested I/O method and the reserved array

must be zeroed. When the ioctl

is called with a pointer to this structure the driver will attempt to allocate

the requested number of buffers and it stores the actual number

allocated in the <structfield>count</structfield> field. It can be

smaller than the number requested, even zero, when the driver runs out

of free memory. A larger number is possible when the driver requires

more buffers to function correctly.<footnote>

	<para>For example video output requires at least two buffers,

of free memory. A larger number is also possible when the driver requires

more buffers to function correctly. For example video output requires at least two buffers,

one displayed and one filled by the application.</para>

	</footnote> When memory mapping I/O is not supported the ioctl

    <para>When the I/O method is not supported the ioctl

returns an &EINVAL;.</para>

    <para>Applications can call <constant>VIDIOC_REQBUFS</constant>

reason why munmap()ping one or even all buffers must imply

streamoff.--></para>

    <para>To negotiate user pointer I/O, applications initialize only

the <structfield>type</structfield> field and set

<structfield>memory</structfield> to

<constant>V4L2_MEMORY_USERPTR</constant>. When the ioctl is called

with a pointer to this structure the driver prepares for user pointer

I/O, when this I/O method is not supported the ioctl returns an

&EINVAL;.</para>

    <table pgwide="1" frame="none" id="v4l2-requestbuffers">

      <title>struct <structname>v4l2_requestbuffers</structname></title>

      <tgroup cols="3">

	  <row>

	    <entry>__u32</entry>

	    <entry><structfield>count</structfield></entry>

	    <entry>The number of buffers requested or granted. This

field is only used when <structfield>memory</structfield> is set to

<constant>V4L2_MEMORY_MMAP</constant>.</entry>

	    <entry>The number of buffers requested or granted.</entry>

	  </row>

	  <row>

	    <entry>&v4l2-buf-type;</entry>

	    <entry><structfield>reserved</structfield>[2]</entry>

	    <entry>A place holder for future extensions and custom

(driver defined) buffer types <constant>V4L2_BUF_TYPE_PRIVATE</constant> and

higher.</entry>

higher. This array should be zeroed by applications.</entry>

	  </row>

	</tbody>

      </tgroup>

		"dec3000s", "vp7041", "dibusb", "nxt2002", "nxt2004",

		"or51211", "or51132_qam", "or51132_vsb", "bluebird",

		"opera1", "cx231xx", "cx18", "cx23885", "pvrusb2", "mpc718",

		"af9015");

		"af9015", "ngene");

# Check args

syntax() if (scalar(@ARGV) != 1);

	die $@ if $@;

	print STDERR <<EOF;

Firmware(s) $outfile extracted successfully.

Now copy it(they) to either /usr/lib/hotplug/firmware or /lib/firmware

Now copy it(them) to either /usr/lib/hotplug/firmware or /lib/firmware

(depending on configuration of firmware hotplug).

EOF

	exit(0);

	close INFILE;

}

sub ngene {

    my $url = "http://www.digitaldevices.de/download/";

    my $file1 = "ngene_15.fw";

    my $hash1 = "d798d5a757121174f0dbc5f2833c0c85";

    my $file2 = "ngene_17.fw";

    my $hash2 = "26b687136e127b8ac24b81e0eeafc20b";

    checkstandard();

    wgetfile($file1, $url . $file1);

    verify($file1, $hash1);

    wgetfile($file2, $url . $file2);

    verify($file2, $hash2);

    "$file1, $file2";

}

# ---------------------------------------------------------------

# Utilities

sub syntax() {

    print STDERR "syntax: get_dvb_firmware <component>\n";

    print STDERR "Supported components:\n";

    @components = sort @components;

    for($i=0; $i < scalar(@components); $i++) {

	print STDERR "\t" . $components[$i] . "\n";

    }