Initial import
authorThomas White <taw27@cam.ac.uk>
Tue, 28 Apr 2009 16:01:37 +0000 (17:01 +0100)
committerThomas White <taw@bitwiz.org.uk>
Wed, 29 Apr 2009 00:56:25 +0000 (01:56 +0100)
COPYING [new file with mode: 0644]
Makefile [new file with mode: 0644]
dri2.c [new file with mode: 0644]
dri2.h [new file with mode: 0644]
gdri-cmdq-submission.c [new file with mode: 0644]
glamo-regs.h [new file with mode: 0644]

diff --git a/COPYING b/COPYING
new file mode 100644 (file)
index 0000000..94a9ed0
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/Makefile b/Makefile
new file mode 100644 (file)
index 0000000..642a246
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,21 @@
+CFLAGS=-g -W -Wall
+LIBS=-lX11 -lXext -ldrm
+CC=gcc
+
+gdri-cmdq-submission: gdri-cmdq-submission.o dri2.o
+       $(CC) gdri-cmdq-submission.o dri2.o -o gdri-cmdq-submission ${LIBS}
+
+dri2.o: dri2.c
+       $(CC) -c ${CFLAGS} ${CROSS_CFLAGS} dri2.c -o dri2.o
+
+gdri-cmdq-submission.o: gdri-cmdq-submission.c
+       $(CC) -c ${CFLAGS} ${CROSS_CFLAGS} gdri-cmdq-submission.c -o gdri-cmdq-submission.o
+
+clean:
+       rm -rf dri2.o gdri-cmdq-submission.o gdri-cmdq-submission
+
+install:
+       install -d -m 755 ${PREFIX}/bin
+       install -m 755 gdri-cmdq-submission ${PREFIX}/bin
+
+.PHONY: clean install
diff --git a/dri2.c b/dri2.c
new file mode 100644 (file)
index 0000000..3b48cd9
--- /dev/null
+++ b/dri2.c
@@ -0,0 +1,301 @@
+/*
+ * Copyright © 2008 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Soft-
+ * ware"), to deal in the Software without restriction, including without
+ * limitation the rights to use, copy, modify, merge, publish, distribute,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, provided that the above copyright
+ * notice(s) and this permission notice appear in all copies of the Soft-
+ * ware and that both the above copyright notice(s) and this permission
+ * notice appear in supporting documentation.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+ * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
+ * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
+ * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
+ * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
+ * MANCE OF THIS SOFTWARE.
+ *
+ * Except as contained in this notice, the name of a copyright holder shall
+ * not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization of
+ * the copyright holder.
+ *
+ * Authors:
+ *   Kristian Høgsberg (krh@redhat.com)
+ */
+
+
+#define NEED_REPLIES
+#include <X11/Xlibint.h>
+#include <X11/extensions/Xext.h>
+#include <X11/extensions/extutil.h>
+#include <X11/extensions/dri2proto.h>
+#include "xf86drm.h"
+#include "dri2.h"
+
+static char dri2ExtensionName[] = DRI2_NAME;
+static XExtensionInfo *dri2Info;
+static XEXT_GENERATE_CLOSE_DISPLAY (DRI2CloseDisplay, dri2Info)
+static /* const */ XExtensionHooks dri2ExtensionHooks = {
+    NULL,                              /* create_gc */
+    NULL,                              /* copy_gc */
+    NULL,                              /* flush_gc */
+    NULL,                              /* free_gc */
+    NULL,                              /* create_font */
+    NULL,                              /* free_font */
+    DRI2CloseDisplay,                  /* close_display */
+    NULL,                              /* wire_to_event */
+    NULL,                              /* event_to_wire */
+    NULL,                              /* error */
+    NULL,                              /* error_string */
+};
+
+static XEXT_GENERATE_FIND_DISPLAY (DRI2FindDisplay, dri2Info, 
+                                  dri2ExtensionName, 
+                                  &dri2ExtensionHooks, 
+                                  0, NULL)
+
+Bool DRI2QueryExtension(Display *dpy, int *eventBase, int *errorBase)
+{
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+
+    if (XextHasExtension(info)) {
+       *eventBase = info->codes->first_event;
+       *errorBase = info->codes->first_error;
+       return True;
+    }
+
+    return False;
+}
+
+Bool DRI2QueryVersion(Display *dpy, int *major, int *minor)
+{
+    XExtDisplayInfo *info = DRI2FindDisplay (dpy);
+    xDRI2QueryVersionReply rep;
+    xDRI2QueryVersionReq *req;
+
+    XextCheckExtension (dpy, info, dri2ExtensionName, False);
+
+    LockDisplay(dpy);
+    GetReq(DRI2QueryVersion, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2QueryVersion;
+    req->majorVersion = DRI2_MAJOR;
+    req->minorVersion = DRI2_MINOR;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+       return False;
+    }
+    *major = rep.majorVersion;
+    *minor = rep.minorVersion;
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    return True;
+}
+
+Bool DRI2Connect(Display *dpy, XID window,
+                char **driverName, char **deviceName)
+{
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2ConnectReply rep;
+    xDRI2ConnectReq *req;
+
+    XextCheckExtension (dpy, info, dri2ExtensionName, False);
+
+    LockDisplay(dpy);
+    GetReq(DRI2Connect, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2Connect;
+    req->window = window;
+    req->driverType = DRI2DriverDRI;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+       return False;
+    }
+
+    if (rep.driverNameLength == 0 && rep.deviceNameLength == 0) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+       return False;
+    }
+
+    *driverName = Xmalloc(rep.driverNameLength + 1);
+    if (*driverName == NULL) {
+       _XEatData(dpy, 
+                 ((rep.driverNameLength + 3) & ~3) +
+                 ((rep.deviceNameLength + 3) & ~3));
+       UnlockDisplay(dpy);
+       SyncHandle();
+       return False;
+    }
+    _XReadPad(dpy, *driverName, rep.driverNameLength);
+    (*driverName)[rep.driverNameLength] = '\0';
+
+    *deviceName = Xmalloc(rep.deviceNameLength + 1);
+    if (*deviceName == NULL) {
+       Xfree(*driverName);
+       _XEatData(dpy, ((rep.deviceNameLength + 3) & ~3));
+       UnlockDisplay(dpy);
+       SyncHandle();
+       return False;
+    }
+    _XReadPad(dpy, *deviceName, rep.deviceNameLength);
+    (*deviceName)[rep.deviceNameLength] = '\0';
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    return True;
+}
+
+Bool DRI2Authenticate(Display *dpy, XID window, drm_magic_t magic)
+{
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2AuthenticateReq *req;
+    xDRI2AuthenticateReply rep;
+
+    XextCheckExtension (dpy, info, dri2ExtensionName, False);
+
+    LockDisplay(dpy);
+    GetReq(DRI2Authenticate, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2Authenticate;
+    req->window = window;
+    req->magic = magic;
+
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+       return False;
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    return rep.authenticated;
+}
+
+void DRI2CreateDrawable(Display *dpy, XID drawable)
+{
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2CreateDrawableReq *req;
+
+    XextSimpleCheckExtension (dpy, info, dri2ExtensionName);
+
+    LockDisplay(dpy);
+    GetReq(DRI2CreateDrawable, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2CreateDrawable;
+    req->drawable = drawable;
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+void DRI2DestroyDrawable(Display *dpy, XID drawable)
+{
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2DestroyDrawableReq *req;
+
+    XextSimpleCheckExtension (dpy, info, dri2ExtensionName);
+
+    XSync(dpy, False);
+
+    LockDisplay(dpy);
+    GetReq(DRI2DestroyDrawable, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2DestroyDrawable;
+    req->drawable = drawable;
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+DRI2Buffer *DRI2GetBuffers(Display *dpy, XID drawable,
+                          int *width, int *height,
+                          unsigned int *attachments, int count,
+                          int *outCount)
+{
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2GetBuffersReply rep;
+    xDRI2GetBuffersReq *req;
+    DRI2Buffer *buffers;
+    xDRI2Buffer repBuffer;
+    CARD32 *p;
+    int i;
+
+    XextCheckExtension (dpy, info, dri2ExtensionName, False);
+
+    LockDisplay(dpy);
+    GetReqExtra(DRI2GetBuffers, count * 4, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2GetBuffers;
+    req->drawable = drawable;
+    req->count = count;
+    p = (CARD32 *) &req[1];
+    for (i = 0; i < count; i++)
+       p[i] = attachments[i];
+
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+       return NULL;
+    }
+
+    *width = rep.width;
+    *height = rep.height;
+    *outCount = rep.count;
+
+    buffers = Xmalloc(count * sizeof buffers[0]);
+    if (buffers == NULL) {
+       _XEatData(dpy, rep.count * sizeof repBuffer);
+       UnlockDisplay(dpy);
+       SyncHandle();
+       return NULL;
+    }
+
+    for (i = 0; i < rep.count; i++) {
+       _XReadPad(dpy, (char *) &repBuffer, sizeof repBuffer);
+       buffers[i].attachment = repBuffer.attachment;
+       buffers[i].name = repBuffer.name;
+       buffers[i].pitch = repBuffer.pitch;
+       buffers[i].cpp = repBuffer.cpp;
+       buffers[i].flags = repBuffer.flags;
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    return buffers;
+}
+
+void DRI2CopyRegion(Display *dpy, XID drawable, XserverRegion region,
+                   CARD32 dest, CARD32 src)
+{
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2CopyRegionReq *req;
+    xDRI2CopyRegionReply rep;
+
+    XextSimpleCheckExtension (dpy, info, dri2ExtensionName);
+
+    LockDisplay(dpy);
+    GetReq(DRI2CopyRegion, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2CopyRegion;
+    req->drawable = drawable;
+    req->region = region;
+    req->dest = dest;
+    req->src = src;
+
+    _XReply(dpy, (xReply *)&rep, 0, xFalse);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
diff --git a/dri2.h b/dri2.h
new file mode 100644 (file)
index 0000000..356c6bc
--- /dev/null
+++ b/dri2.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright © 2007,2008 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Soft-
+ * ware"), to deal in the Software without restriction, including without
+ * limitation the rights to use, copy, modify, merge, publish, distribute,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, provided that the above copyright
+ * notice(s) and this permission notice appear in all copies of the Soft-
+ * ware and that both the above copyright notice(s) and this permission
+ * notice appear in supporting documentation.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+ * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
+ * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
+ * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
+ * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
+ * MANCE OF THIS SOFTWARE.
+ *
+ * Except as contained in this notice, the name of a copyright holder shall
+ * not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization of
+ * the copyright holder.
+ *
+ * Authors:
+ *   Kristian Høgsberg (krh@redhat.com)
+ */
+
+#ifndef _DRI2_H_
+#define _DRI2_H_
+
+#include <X11/extensions/Xfixes.h>
+#include <X11/extensions/dri2tokens.h>
+
+typedef struct {
+    unsigned int attachment;
+    unsigned int name;
+    unsigned int pitch;
+    unsigned int cpp;
+    unsigned int flags;
+} DRI2Buffer;
+
+extern Bool
+DRI2QueryExtension(Display *display, int *eventBase, int *errorBase);
+extern Bool
+DRI2QueryVersion(Display *display, int *major, int *minor);
+extern Bool
+DRI2Connect(Display *display, XID window,
+           char **driverName, char **deviceName);
+extern Bool
+DRI2Authenticate(Display *display, XID window, drm_magic_t magic);
+extern void
+DRI2CreateDrawable(Display *display, XID drawable);
+extern void
+DRI2DestroyDrawable(Display *display, XID handle);
+extern DRI2Buffer *
+DRI2GetBuffers(Display *dpy, XID drawable,
+              int *width, int *height,
+              unsigned int *attachments, int count,
+              int *outCount);
+
+extern void
+DRI2CopyRegion(Display *dpy, XID drawable, XserverRegion region,
+              CARD32 dest, CARD32 src);
+
+#endif
diff --git a/gdri-cmdq-submission.c b/gdri-cmdq-submission.c
new file mode 100644 (file)
index 0000000..eafe65f
--- /dev/null
@@ -0,0 +1,141 @@
+/*
+ * gdri-cmdq-submission.c
+ *
+ * A small test of some Glamo DRI functions
+ *
+ * (c) 2009 Thomas White <taw@bitwiz.org.uk>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+#include <X11/Xmd.h>
+#include <stdint.h>
+#include <drm/drm.h>
+#include <drm/glamo_drm.h>
+
+#include "dri2.h"
+#include "glamo-regs.h"
+
+
+#define RING_LOCALS int __count = 0;
+#define OUT_REG(reg, val) cmds[__count++] = (reg); cmds[__count++] = (val);
+
+
+static int do_drm_authentication(Display *dpy)
+{
+       int scrnum;
+       Window root;
+       char *driver;
+       char *device;
+       int fd;
+       drm_magic_t magic;
+
+       /* Get default screen, root window and default visual */
+       scrnum = DefaultScreen(dpy);
+       root = RootWindow(dpy, scrnum);
+
+       /* Get device name */
+       if ( !DRI2Connect(dpy, root, &driver, &device) ) {
+               fprintf(stderr, "DRI2Connect failed\n");
+               return 1;
+       }
+
+       /* Open DRM device */
+       fd = open(device, O_RDWR);
+       if ( fd < 0 ) {
+               fprintf(stderr, "Couldn't open '%s': %s\n",
+                       device, strerror(errno));
+               return 1;
+       }
+
+       /* Get an authentication token */
+       if ( drmGetMagic(fd, &magic) ) {
+               fprintf(stderr, "drmGetMagic failed\n");
+               return 1;
+       }
+
+       /* Authenticate */
+       if ( DRI2Authenticate(dpy, root, magic) == False ) {
+               fprintf(stderr, "DRI2Authenticate failed\n");
+               return 1;
+       }
+
+       return fd;
+}
+
+int main()
+{
+       Display *dpy;
+       drm_glamo_cmd_buffer_t cmdbuf;
+       uint16_t *cmds;
+       int r;
+       uint32_t offset = 0x000000;
+       RING_LOCALS;
+       int fd;
+
+       /* Open display */
+       dpy = XOpenDisplay(NULL);
+       if ( dpy == NULL ) {
+               fprintf(stderr, "Can't open display '%s'\n",
+                       XDisplayName(NULL));
+               return 1;
+       }
+
+       fd = do_drm_authentication(dpy);
+
+       cmds = malloc(2*13*2);
+
+       OUT_REG(GLAMO_REG_2D_DST_ADDRL, offset & 0xffff);
+       OUT_REG(GLAMO_REG_2D_DST_ADDRH, (offset >> 16) & 0x7f);
+       OUT_REG(GLAMO_REG_2D_DST_PITCH, (480*2) & 0x7ff);
+       OUT_REG(GLAMO_REG_2D_DST_HEIGHT, 640);
+       OUT_REG(GLAMO_REG_2D_PAT_FG, 0xABCD);
+       OUT_REG(GLAMO_REG_2D_COMMAND2, 0x00aa);
+       OUT_REG(GLAMO_REG_2D_ID1, 0);
+       OUT_REG(GLAMO_REG_2D_ID2, 0);
+
+       OUT_REG(GLAMO_REG_2D_DST_X, 20);
+       OUT_REG(GLAMO_REG_2D_DST_Y, 20);
+       OUT_REG(GLAMO_REG_2D_RECT_WIDTH, 100);
+       OUT_REG(GLAMO_REG_2D_RECT_HEIGHT, 50);
+       OUT_REG(GLAMO_REG_2D_COMMAND3, 0);
+
+       cmdbuf.buf = (char *)cmds;
+       cmdbuf.bufsz = 2*13*2;
+       r = drmCommandWrite(fd, DRM_GLAMO_CMDBUF, &cmdbuf, sizeof(cmdbuf));
+       if ( r != 0 ) {
+            fprintf(stderr, "DRM_GLAMO_CMDBUF failed");
+            return 1;
+        }
+
+       printf("Success!\n");
+
+       close(fd);
+       XCloseDisplay(dpy);
+
+       return 0;
+}
diff --git a/glamo-regs.h b/glamo-regs.h
new file mode 100644 (file)
index 0000000..18a84d7
--- /dev/null
@@ -0,0 +1,783 @@
+#ifndef _GLAMO_REGS_H
+#define _GLAMO_REGS_H
+
+/* Smedia Glamo 336x/337x driver
+ *
+ * (C) 2007 by OpenMoko, Inc.
+ * Author: Harald Welte <laforge@openmoko.org>
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+enum glamo_regster_offsets {
+       GLAMO_REGOFS_GENERIC    = 0x0000,
+       GLAMO_REGOFS_HOSTBUS    = 0x0200,
+       GLAMO_REGOFS_MEMORY     = 0x0300,
+       GLAMO_REGOFS_VIDCAP     = 0x0400,
+       GLAMO_REGOFS_ISP        = 0x0500,
+       GLAMO_REGOFS_JPEG       = 0x0800,
+       GLAMO_REGOFS_MPEG       = 0x0c00,
+       GLAMO_REGOFS_LCD        = 0x1100,
+       GLAMO_REGOFS_MMC        = 0x1400,
+       GLAMO_REGOFS_MPROC0     = 0x1500,
+       GLAMO_REGOFS_MPROC1     = 0x1580,
+       GLAMO_REGOFS_CMDQUEUE   = 0x1600,
+       GLAMO_REGOFS_RISC       = 0x1680,
+       GLAMO_REGOFS_2D         = 0x1700,
+       GLAMO_REGOFS_3D         = 0x1b00,
+};
+
+
+enum glamo_register_generic {
+       GLAMO_REG_GCONF1        = 0x0000,
+       GLAMO_REG_GCONF2        = 0x0002,
+#define        GLAMO_REG_DEVICE_ID     GLAMO_REG_GCONF2
+       GLAMO_REG_GCONF3        = 0x0004,
+#define        GLAMO_REG_REVISION_ID   GLAMO_REG_GCONF3
+       GLAMO_REG_IRQ_GEN1      = 0x0006,
+#define GLAMO_REG_IRQ_ENABLE   GLAMO_REG_IRQ_GEN1
+       GLAMO_REG_IRQ_GEN2      = 0x0008,
+#define GLAMO_REG_IRQ_SET      GLAMO_REG_IRQ_GEN2
+       GLAMO_REG_IRQ_GEN3      = 0x000a,
+#define GLAMO_REG_IRQ_CLEAR    GLAMO_REG_IRQ_GEN3
+       GLAMO_REG_IRQ_GEN4      = 0x000c,
+#define GLAMO_REG_IRQ_STATUS   GLAMO_REG_IRQ_GEN4
+       GLAMO_REG_CLOCK_HOST    = 0x0010,
+       GLAMO_REG_CLOCK_MEMORY  = 0x0012,
+       GLAMO_REG_CLOCK_LCD     = 0x0014,
+       GLAMO_REG_CLOCK_MMC     = 0x0016,
+       GLAMO_REG_CLOCK_ISP     = 0x0018,
+       GLAMO_REG_CLOCK_JPEG    = 0x001a,
+       GLAMO_REG_CLOCK_3D      = 0x001c,
+       GLAMO_REG_CLOCK_2D      = 0x001e,
+       GLAMO_REG_CLOCK_RISC1   = 0x0020,       /* 3365 only? */
+       GLAMO_REG_CLOCK_RISC2   = 0x0022,       /* 3365 only? */
+       GLAMO_REG_CLOCK_MPEG    = 0x0024,
+       GLAMO_REG_CLOCK_MPROC   = 0x0026,
+
+       GLAMO_REG_CLOCK_GEN5_1  = 0x0030,
+       GLAMO_REG_CLOCK_GEN5_2  = 0x0032,
+       GLAMO_REG_CLOCK_GEN6    = 0x0034,
+       GLAMO_REG_CLOCK_GEN7    = 0x0036,
+       GLAMO_REG_CLOCK_GEN8    = 0x0038,
+       GLAMO_REG_CLOCK_GEN9    = 0x003a,
+       GLAMO_REG_CLOCK_GEN10   = 0x003c,
+       GLAMO_REG_CLOCK_GEN11   = 0x003e,
+       GLAMO_REG_PLL_GEN1      = 0x0040,
+       GLAMO_REG_PLL_GEN2      = 0x0042,
+       GLAMO_REG_PLL_GEN3      = 0x0044,
+       GLAMO_REG_PLL_GEN4      = 0x0046,
+       GLAMO_REG_PLL_GEN5      = 0x0048,
+       GLAMO_REG_GPIO_GEN1     = 0x0050,
+       GLAMO_REG_GPIO_GEN2     = 0x0052,
+       GLAMO_REG_GPIO_GEN3     = 0x0054,
+       GLAMO_REG_GPIO_GEN4     = 0x0056,
+       GLAMO_REG_GPIO_GEN5     = 0x0058,
+       GLAMO_REG_GPIO_GEN6     = 0x005a,
+       GLAMO_REG_GPIO_GEN7     = 0x005c,
+       GLAMO_REG_GPIO_GEN8     = 0x005e,
+       GLAMO_REG_GPIO_GEN9     = 0x0060,
+       GLAMO_REG_GPIO_GEN10    = 0x0062,
+       GLAMO_REG_DFT_GEN1      = 0x0070,
+       GLAMO_REG_DFT_GEN2      = 0x0072,
+       GLAMO_REG_DFT_GEN3      = 0x0074,
+       GLAMO_REG_DFT_GEN4      = 0x0076,
+
+       GLAMO_REG_DFT_GEN5      = 0x01e0,
+       GLAMO_REG_DFT_GEN6      = 0x01f0,
+};
+
+#define GLAMO_REG_HOSTBUS(x)   (GLAMO_REGOFS_HOSTBUS-2+(x*2))
+
+#define REG_MEM(x)             (GLAMO_REGOFS_MEMORY+(x))
+#define GLAMO_REG_MEM_TIMING(x)        (GLAMO_REG_MEM_TIMING1-2+(x*2))
+
+enum glamo_register_mem {
+       GLAMO_REG_MEM_TYPE      = REG_MEM(0x00),
+       GLAMO_REG_MEM_GEN       = REG_MEM(0x02),
+       GLAMO_REG_MEM_TIMING1   = REG_MEM(0x04),
+       GLAMO_REG_MEM_TIMING2   = REG_MEM(0x06),
+       GLAMO_REG_MEM_TIMING3   = REG_MEM(0x08),
+       GLAMO_REG_MEM_TIMING4   = REG_MEM(0x0a),
+       GLAMO_REG_MEM_TIMING5   = REG_MEM(0x0c),
+       GLAMO_REG_MEM_TIMING6   = REG_MEM(0x0e),
+       GLAMO_REG_MEM_TIMING7   = REG_MEM(0x10),
+       GLAMO_REG_MEM_TIMING8   = REG_MEM(0x12),
+       GLAMO_REG_MEM_TIMING9   = REG_MEM(0x14),
+       GLAMO_REG_MEM_TIMING10  = REG_MEM(0x16),
+       GLAMO_REG_MEM_TIMING11  = REG_MEM(0x18),
+       GLAMO_REG_MEM_POWER1    = REG_MEM(0x1a),
+       GLAMO_REG_MEM_POWER2    = REG_MEM(0x1c),
+       GLAMO_REG_MEM_LCD_BUF1  = REG_MEM(0x1e),
+       GLAMO_REG_MEM_LCD_BUF2  = REG_MEM(0x20),
+       GLAMO_REG_MEM_LCD_BUF3  = REG_MEM(0x22),
+       GLAMO_REG_MEM_LCD_BUF4  = REG_MEM(0x24),
+       GLAMO_REG_MEM_BIST1     = REG_MEM(0x26),
+       GLAMO_REG_MEM_BIST2     = REG_MEM(0x28),
+       GLAMO_REG_MEM_BIST3     = REG_MEM(0x2a),
+       GLAMO_REG_MEM_BIST4     = REG_MEM(0x2c),
+       GLAMO_REG_MEM_BIST5     = REG_MEM(0x2e),
+       GLAMO_REG_MEM_MAH1      = REG_MEM(0x30),
+       GLAMO_REG_MEM_MAH2      = REG_MEM(0x32),
+       GLAMO_REG_MEM_DRAM1     = REG_MEM(0x34),
+       GLAMO_REG_MEM_DRAM2     = REG_MEM(0x36),
+       GLAMO_REG_MEM_CRC       = REG_MEM(0x38),
+};
+
+#define GLAMO_MEM_TYPE_MASK    0x03
+
+enum glamo_reg_mem_dram1 {
+       GLAMO_MEM_DRAM1_EN_SDRAM_CLK    = (1 << 11),
+       GLAMO_MEM_DRAM1_SELF_REFRESH    = (1 << 12),
+};
+
+enum glamo_reg_mem_dram2 {
+       GLAMO_MEM_DRAM2_DEEP_PWRDOWN    = (1 << 12),
+};
+
+enum glamo_irq {
+       GLAMO_IRQ_HOSTBUS       = 0x0001,
+       GLAMO_IRQ_JPEG          = 0x0002,
+       GLAMO_IRQ_MPEG          = 0x0004,
+       GLAMO_IRQ_MPROC1        = 0x0008,
+       GLAMO_IRQ_MPROC0        = 0x0010,
+       GLAMO_IRQ_CMDQUEUE      = 0x0020,
+       GLAMO_IRQ_2D            = 0x0040,
+       GLAMO_IRQ_MMC           = 0x0080,
+       GLAMO_IRQ_RISC          = 0x0100,
+};
+
+enum glamo_reg_clock_host {
+       GLAMO_CLOCK_HOST_DG_BCLK        = 0x0001,
+       GLAMO_CLOCK_HOST_DG_M0CLK       = 0x0004,
+       GLAMO_CLOCK_HOST_RESET          = 0x1000,
+};
+
+enum glamo_reg_clock_mem {
+       GLAMO_CLOCK_MEM_DG_M1CLK        = 0x0001,
+       GLAMO_CLOCK_MEM_EN_M1CLK        = 0x0002,
+       GLAMO_CLOCK_MEM_DG_MOCACLK      = 0x0004,
+       GLAMO_CLOCK_MEM_EN_MOCACLK      = 0x0008,
+       GLAMO_CLOCK_MEM_RESET           = 0x1000,
+       GLAMO_CLOCK_MOCA_RESET          = 0x2000,
+};
+
+enum glamo_reg_clock_lcd {
+       GLAMO_CLOCK_LCD_DG_DCLK         = 0x0001,
+       GLAMO_CLOCK_LCD_EN_DCLK         = 0x0002,
+       GLAMO_CLOCK_LCD_DG_DMCLK        = 0x0004,
+       GLAMO_CLOCK_LCD_EN_DMCLK        = 0x0008,
+       //
+       GLAMO_CLOCK_LCD_EN_DHCLK        = 0x0020,
+       GLAMO_CLOCK_LCD_DG_M5CLK        = 0x0040,
+       GLAMO_CLOCK_LCD_EN_M5CLK        = 0x0080,
+       GLAMO_CLOCK_LCD_RESET           = 0x1000,
+};
+
+enum glamo_reg_clock_mmc {
+       GLAMO_CLOCK_MMC_DG_TCLK         = 0x0001,
+       GLAMO_CLOCK_MMC_EN_TCLK         = 0x0002,
+       GLAMO_CLOCK_MMC_DG_M9CLK        = 0x0004,
+       GLAMO_CLOCK_MMC_EN_M9CLK        = 0x0008,
+       GLAMO_CLOCK_MMC_RESET           = 0x1000,
+};
+
+enum glamo_reg_clock_isp {
+       GLAMO_CLOCK_ISP_DG_I1CLK        = 0x0001,
+       GLAMO_CLOCK_ISP_EN_I1CLK        = 0x0002,
+       GLAMO_CLOCK_ISP_DG_CCLK         = 0x0004,
+       GLAMO_CLOCK_ISP_EN_CCLK         = 0x0008,
+       //
+       GLAMO_CLOCK_ISP_EN_SCLK         = 0x0020,
+       GLAMO_CLOCK_ISP_DG_M2CLK        = 0x0040,
+       GLAMO_CLOCK_ISP_EN_M2CLK        = 0x0080,
+       GLAMO_CLOCK_ISP_DG_M15CLK       = 0x0100,
+       GLAMO_CLOCK_ISP_EN_M15CLK       = 0x0200,
+       GLAMO_CLOCK_ISP1_RESET          = 0x1000,
+       GLAMO_CLOCK_ISP2_RESET          = 0x2000,
+};
+
+enum glamo_reg_clock_jpeg {
+       GLAMO_CLOCK_JPEG_DG_JCLK        = 0x0001,
+       GLAMO_CLOCK_JPEG_EN_JCLK        = 0x0002,
+       GLAMO_CLOCK_JPEG_DG_M3CLK       = 0x0004,
+       GLAMO_CLOCK_JPEG_EN_M3CLK       = 0x0008,
+       GLAMO_CLOCK_JPEG_RESET          = 0x1000,
+};
+
+enum glamo_reg_clock_2d {
+       GLAMO_CLOCK_2D_DG_GCLK          = 0x0001,
+       GLAMO_CLOCK_2D_EN_GCLK          = 0x0002,
+       GLAMO_CLOCK_2D_DG_M7CLK         = 0x0004,
+       GLAMO_CLOCK_2D_EN_M7CLK         = 0x0008,
+       GLAMO_CLOCK_2D_DG_M6CLK         = 0x0010,
+       GLAMO_CLOCK_2D_EN_M6CLK         = 0x0020,
+       GLAMO_CLOCK_2D_RESET            = 0x1000,
+       GLAMO_CLOCK_2D_CMDQ_RESET       = 0x2000,
+};
+
+enum glamo_reg_clock_3d {
+       GLAMO_CLOCK_3D_DG_ECLK          = 0x0001,
+       GLAMO_CLOCK_3D_EN_ECLK          = 0x0002,
+       GLAMO_CLOCK_3D_DG_RCLK          = 0x0004,
+       GLAMO_CLOCK_3D_EN_RCLK          = 0x0008,
+       GLAMO_CLOCK_3D_DG_M8CLK         = 0x0010,
+       GLAMO_CLOCK_3D_EN_M8CLK         = 0x0020,
+       GLAMO_CLOCK_3D_BACK_RESET       = 0x1000,
+       GLAMO_CLOCK_3D_FRONT_RESET      = 0x2000,
+};
+
+enum glamo_reg_clock_mpeg {
+       GLAMO_CLOCK_MPEG_DG_X0CLK       = 0x0001,
+       GLAMO_CLOCK_MPEG_EN_X0CLK       = 0x0002,
+       GLAMO_CLOCK_MPEG_DG_X1CLK       = 0x0004,
+       GLAMO_CLOCK_MPEG_EN_X1CLK       = 0x0008,
+       GLAMO_CLOCK_MPEG_DG_X2CLK       = 0x0010,
+       GLAMO_CLOCK_MPEG_EN_X2CLK       = 0x0020,
+       GLAMO_CLOCK_MPEG_DG_X3CLK       = 0x0040,
+       GLAMO_CLOCK_MPEG_EN_X3CLK       = 0x0080,
+       GLAMO_CLOCK_MPEG_DG_X4CLK       = 0x0100,
+       GLAMO_CLOCK_MPEG_EN_X4CLK       = 0x0200,
+       GLAMO_CLOCK_MPEG_DG_X6CLK       = 0x0400,
+       GLAMO_CLOCK_MPEG_EN_X6CLK       = 0x0800,
+       GLAMO_CLOCK_MPEG_ENC_RESET      = 0x1000,
+       GLAMO_CLOCK_MPEG_DEC_RESET      = 0x2000,
+};
+
+enum glamo_reg_clock_mproc {
+       GLAMO_CLOCK_MPROC_DG_I0CLK      = 0x0001,
+       GLAMO_CLOCK_MPROC_EN_I0CLK      = 0x0002,
+       GLAMO_CLOCK_MPROC_DG_X5CLK      = 0x0004,
+       GLAMO_CLOCK_MPROC_EN_X5CLK      = 0x0008,
+       GLAMO_CLOCK_MPROC_EN_KCLK       = 0x0020,
+       GLAMO_CLOCK_MPROC_DG_M4CLK      = 0x0040,
+       GLAMO_CLOCK_MPROC_EN_M4CLK      = 0x0080,
+       GLAMO_CLOCK_MPROC_DG_M10CLK     = 0x0100,
+       GLAMO_CLOCK_MPROC_EN_M10CLK     = 0x0200,
+       GLAMO_CLOCK_MPROC_RESET         = 0x1000,
+};
+
+enum glamo_reg_clock51 {
+       GLAMO_CLOCK_GEN51_EN_DIV_MCLK   = 0x0001,
+       GLAMO_CLOCK_GEN51_EN_DIV_SCLK   = 0x0002,
+       GLAMO_CLOCK_GEN51_EN_DIV_JCLK   = 0x0004,
+       GLAMO_CLOCK_GEN51_EN_DIV_DCLK   = 0x0008,
+       GLAMO_CLOCK_GEN51_EN_DIV_DMCLK  = 0x0010,
+       GLAMO_CLOCK_GEN51_EN_DIV_DHCLK  = 0x0020,
+       GLAMO_CLOCK_GEN51_EN_DIV_GCLK   = 0x0040,
+       GLAMO_CLOCK_GEN51_EN_DIV_TCLK   = 0x0080,
+       /* FIXME: higher bits */
+};
+
+enum glamo_reg_clock52 {
+       GLAMO_CLOCK_GEN52_EN_DIV_ACLK   = 0x0001,
+       GLAMO_CLOCK_GEN52_EN_DIV_AMCLK  = 0x0002,
+       GLAMO_CLOCK_GEN52_EN_DIV_OCLK   = 0x0004,
+       GLAMO_CLOCK_GEN52_EN_DIV_ZCLK   = 0x0008,
+       GLAMO_CLOCK_GEN52_EN_DIV_ICLK   = 0x0010,
+       /* FIXME: higher bits */
+};
+
+enum glamo_reg_hostbus2 {
+       GLAMO_HOSTBUS2_MMIO_EN_ISP      = 0x0001,
+       GLAMO_HOSTBUS2_MMIO_EN_JPEG     = 0x0002,
+       GLAMO_HOSTBUS2_MMIO_EN_MPEG     = 0x0004,
+       GLAMO_HOSTBUS2_MMIO_EN_LCD      = 0x0008,
+       GLAMO_HOSTBUS2_MMIO_EN_MMC      = 0x0010,
+       GLAMO_HOSTBUS2_MMIO_EN_MICROP0  = 0x0020,
+       GLAMO_HOSTBUS2_MMIO_EN_MICROP1  = 0x0040,
+       GLAMO_HOSTBUS2_MMIO_EN_CMDQ     = 0x0080,
+       GLAMO_HOSTBUS2_MMIO_EN_RISC     = 0x0100,
+       GLAMO_HOSTBUS2_MMIO_EN_2D       = 0x0200,
+       GLAMO_HOSTBUS2_MMIO_EN_3D       = 0x0400,
+};
+
+/* LCD Controller */
+
+#define REG_LCD(x)     (GLAMO_REGOFS_LCD + (x))
+enum glamo_reg_lcd {
+       GLAMO_REG_LCD_MODE1             = REG_LCD(0x00),
+       GLAMO_REG_LCD_MODE2             = REG_LCD(0x02),
+       GLAMO_REG_LCD_MODE3             = REG_LCD(0x04),
+       GLAMO_REG_LCD_WIDTH             = REG_LCD(0x06),
+       GLAMO_REG_LCD_HEIGHT            = REG_LCD(0x08),
+       GLAMO_REG_LCD_POLARITY          = REG_LCD(0x0a),
+       GLAMO_REG_LCD_A_BASE1           = REG_LCD(0x0c),
+       GLAMO_REG_LCD_A_BASE2           = REG_LCD(0x0e),
+       GLAMO_REG_LCD_B_BASE1           = REG_LCD(0x10),
+       GLAMO_REG_LCD_B_BASE2           = REG_LCD(0x12),
+       GLAMO_REG_LCD_C_BASE1           = REG_LCD(0x14),
+       GLAMO_REG_LCD_C_BASE2           = REG_LCD(0x16),
+       GLAMO_REG_LCD_PITCH             = REG_LCD(0x18),
+       /* RES */
+       GLAMO_REG_LCD_HORIZ_TOTAL       = REG_LCD(0x1c),
+       /* RES */
+       GLAMO_REG_LCD_HORIZ_RETR_START  = REG_LCD(0x20),
+       /* RES */
+       GLAMO_REG_LCD_HORIZ_RETR_END    = REG_LCD(0x24),
+       /* RES */
+       GLAMO_REG_LCD_HORIZ_DISP_START  = REG_LCD(0x28),
+       /* RES */
+       GLAMO_REG_LCD_HORIZ_DISP_END    = REG_LCD(0x2c),
+       /* RES */
+       GLAMO_REG_LCD_VERT_TOTAL        = REG_LCD(0x30),
+       /* RES */
+       GLAMO_REG_LCD_VERT_RETR_START   = REG_LCD(0x34),
+       /* RES */
+       GLAMO_REG_LCD_VERT_RETR_END     = REG_LCD(0x38),
+       /* RES */
+       GLAMO_REG_LCD_VERT_DISP_START   = REG_LCD(0x3c),
+       /* RES */
+       GLAMO_REG_LCD_VERT_DISP_END     = REG_LCD(0x40),
+       /* RES */
+       GLAMO_REG_LCD_POL               = REG_LCD(0x44),
+       GLAMO_REG_LCD_DATA_START        = REG_LCD(0x46),
+       GLAMO_REG_LCD_FRATE_CONTRO      = REG_LCD(0x48),
+       GLAMO_REG_LCD_DATA_CMD_HDR      = REG_LCD(0x4a),
+       GLAMO_REG_LCD_SP_START          = REG_LCD(0x4c),
+       GLAMO_REG_LCD_SP_END            = REG_LCD(0x4e),
+       GLAMO_REG_LCD_CURSOR_BASE1      = REG_LCD(0x50),
+       GLAMO_REG_LCD_CURSOR_BASE2      = REG_LCD(0x52),
+       GLAMO_REG_LCD_CURSOR_PITCH      = REG_LCD(0x54),
+       GLAMO_REG_LCD_CURSOR_X_SIZE     = REG_LCD(0x56),
+       GLAMO_REG_LCD_CURSOR_Y_SIZE     = REG_LCD(0x58),
+       GLAMO_REG_LCD_CURSOR_X_POS      = REG_LCD(0x5a),
+       GLAMO_REG_LCD_CURSOR_Y_POS      = REG_LCD(0x5c),
+       GLAMO_REG_LCD_CURSOR_PRESET     = REG_LCD(0x5e),
+       GLAMO_REG_LCD_CURSOR_FG_COLOR   = REG_LCD(0x60),
+       /* RES */
+       GLAMO_REG_LCD_CURSOR_BG_COLOR   = REG_LCD(0x64),
+       /* RES */
+       GLAMO_REG_LCD_CURSOR_DST_COLOR  = REG_LCD(0x68),
+       /* RES */
+       GLAMO_REG_LCD_STATUS1           = REG_LCD(0x80),
+       GLAMO_REG_LCD_STATUS2           = REG_LCD(0x82),
+       GLAMO_REG_LCD_STATUS3           = REG_LCD(0x84),
+       GLAMO_REG_LCD_STATUS4           = REG_LCD(0x86),
+       /* RES */
+       GLAMO_REG_LCD_COMMAND1          = REG_LCD(0xa0),
+       GLAMO_REG_LCD_COMMAND2          = REG_LCD(0xa2),
+       /* RES */
+       GLAMO_REG_LCD_WFORM_DELAY1      = REG_LCD(0xb0),
+       GLAMO_REG_LCD_WFORM_DELAY2      = REG_LCD(0xb2),
+       /* RES */
+       GLAMO_REG_LCD_GAMMA_CORR        = REG_LCD(0x100),
+       /* RES */
+       GLAMO_REG_LCD_GAMMA_R_ENTRY01   = REG_LCD(0x110),
+       GLAMO_REG_LCD_GAMMA_R_ENTRY23   = REG_LCD(0x112),
+       GLAMO_REG_LCD_GAMMA_R_ENTRY45   = REG_LCD(0x114),
+       GLAMO_REG_LCD_GAMMA_R_ENTRY67   = REG_LCD(0x116),
+       GLAMO_REG_LCD_GAMMA_R_ENTRY8    = REG_LCD(0x118),
+       /* RES */
+       GLAMO_REG_LCD_GAMMA_G_ENTRY01   = REG_LCD(0x130),
+       GLAMO_REG_LCD_GAMMA_G_ENTRY23   = REG_LCD(0x132),
+       GLAMO_REG_LCD_GAMMA_G_ENTRY45   = REG_LCD(0x134),
+       GLAMO_REG_LCD_GAMMA_G_ENTRY67   = REG_LCD(0x136),
+       GLAMO_REG_LCD_GAMMA_G_ENTRY8    = REG_LCD(0x138),
+       /* RES */
+       GLAMO_REG_LCD_GAMMA_B_ENTRY01   = REG_LCD(0x150),
+       GLAMO_REG_LCD_GAMMA_B_ENTRY23   = REG_LCD(0x152),
+       GLAMO_REG_LCD_GAMMA_B_ENTRY45   = REG_LCD(0x154),
+       GLAMO_REG_LCD_GAMMA_B_ENTRY67   = REG_LCD(0x156),
+       GLAMO_REG_LCD_GAMMA_B_ENTRY8    = REG_LCD(0x158),
+       /* RES */
+       GLAMO_REG_LCD_SRAM_DRIVING1     = REG_LCD(0x160),
+       GLAMO_REG_LCD_SRAM_DRIVING2     = REG_LCD(0x162),
+       GLAMO_REG_LCD_SRAM_DRIVING3     = REG_LCD(0x164),
+};
+
+enum glamo_reg_lcd_mode1 {
+       GLAMO_LCD_MODE1_PWRSAVE         = 0x0001,
+       GLAMO_LCD_MODE1_PARTIAL_PRT     = 0x0002,
+       GLAMO_LCD_MODE1_HWFLIP          = 0x0004,
+       GLAMO_LCD_MODE1_LCD2            = 0x0008,
+       /* RES */
+       GLAMO_LCD_MODE1_PARTIAL_MODE    = 0x0020,
+       GLAMO_LCD_MODE1_CURSOR_DSTCOLOR = 0x0040,
+       GLAMO_LCD_MODE1_PARTIAL_ENABLE  = 0x0080,
+       GLAMO_LCD_MODE1_TVCLK_IN_ENABLE = 0x0100,
+       GLAMO_LCD_MODE1_HSYNC_HIGH_ACT  = 0x0200,
+       GLAMO_LCD_MODE1_VSYNC_HIGH_ACT  = 0x0400,
+       GLAMO_LCD_MODE1_HSYNC_FLIP      = 0x0800,
+       GLAMO_LCD_MODE1_GAMMA_COR_EN    = 0x1000,
+       GLAMO_LCD_MODE1_DITHER_EN       = 0x2000,
+       GLAMO_LCD_MODE1_CURSOR_EN       = 0x4000,
+       GLAMO_LCD_MODE1_ROTATE_EN       = 0x8000,
+};
+
+enum glamo_reg_lcd_mode2 {
+       GLAMO_LCD_MODE2_CRC_CHECK_EN    = 0x0001,
+       GLAMO_LCD_MODE2_DCMD_PER_LINE   = 0x0002,
+       GLAMO_LCD_MODE2_NOUSE_BDEF      = 0x0004,
+       GLAMO_LCD_MODE2_OUT_POS_MODE    = 0x0008,
+       GLAMO_LCD_MODE2_FRATE_CTRL_EN   = 0x0010,
+       GLAMO_LCD_MODE2_SINGLE_BUFFER   = 0x0020,
+       GLAMO_LCD_MODE2_SER_LSB_TO_MSB  = 0x0040,
+       /* FIXME */
+};
+
+enum glamo_reg_lcd_mode3 {
+       /* LCD color source data format */
+       GLAMO_LCD_SRC_RGB565            = 0x0000,
+       GLAMO_LCD_SRC_ARGB1555          = 0x4000,
+       GLAMO_LCD_SRC_ARGB4444          = 0x8000,
+       /* interface type */
+       GLAMO_LCD_MODE3_LCD             = 0x1000,
+       GLAMO_LCD_MODE3_RGB             = 0x0800,
+       GLAMO_LCD_MODE3_CPU             = 0x0000,
+       /* mode */
+       GLAMO_LCD_MODE3_RGB332          = 0x0000,
+       GLAMO_LCD_MODE3_RGB444          = 0x0100,
+       GLAMO_LCD_MODE3_RGB565          = 0x0200,
+       GLAMO_LCD_MODE3_RGB666          = 0x0300,
+       /* depth */
+       GLAMO_LCD_MODE3_6BITS           = 0x0000,
+       GLAMO_LCD_MODE3_8BITS           = 0x0010,
+       GLAMO_LCD_MODE3_9BITS           = 0x0020,
+       GLAMO_LCD_MODE3_16BITS          = 0x0030,
+       GLAMO_LCD_MODE3_18BITS          = 0x0040,
+};
+
+enum glamo_lcd_rot_mode {
+        GLAMO_LCD_ROT_MODE_0            = 0x0000,
+        GLAMO_LCD_ROT_MODE_180          = 0x2000,
+        GLAMO_LCD_ROT_MODE_MIRROR       = 0x4000,
+        GLAMO_LCD_ROT_MODE_FLIP         = 0x6000,
+        GLAMO_LCD_ROT_MODE_90           = 0x8000,
+        GLAMO_LCD_ROT_MODE_270          = 0xa000,
+};
+#define GLAMO_LCD_ROT_MODE_MASK         0xe000
+
+enum glamo_lcd_cmd_type {
+       GLAMO_LCD_CMD_TYPE_DISP         = 0x0000,
+       GLAMO_LCD_CMD_TYPE_PARALLEL     = 0x4000,
+       GLAMO_LCD_CMD_TYPE_SERIAL       = 0x8000,
+       GLAMO_LCD_CMD_TYPE_SERIAL_DIRECT= 0xc000,
+};
+#define GLAMO_LCD_CMD_TYPE_MASK                0xc000
+
+enum glamo_lcd_cmds {
+       GLAMO_LCD_CMD_DATA_DISP_FIRE    = 0x00,
+       GLAMO_LCD_CMD_DATA_DISP_SYNC    = 0x01,         /* RGB only */
+       /* switch to command mode, no display */
+       GLAMO_LCD_CMD_DATA_FIRE_NO_DISP = 0x02,
+       /* display until VSYNC, switch to command */
+       GLAMO_LCD_CMD_DATA_FIRE_VSYNC   = 0x11,
+       /* display until HSYNC, switch to command */
+       GLAMO_LCD_CMD_DATA_FIRE_HSYNC   = 0x12,
+       /* display until VSYNC, 1 black frame, VSYNC, switch to command */
+       GLAMO_LCD_CMD_DATA_FIRE_VSYNC_B = 0x13,
+       /* don't care about display and switch to command */
+       GLAMO_LCD_CMD_DATA_FIRE_FREE    = 0x14,         /* RGB only */
+       /* don't care about display, keep data display but disable data,
+        * and switch to command */
+       GLAMO_LCD_CMD_DATA_FIRE_FREE_D  = 0x15,         /* RGB only */
+};
+
+enum glamo_core_revisions {
+       GLAMO_CORE_REV_A0               = 0x0000,
+       GLAMO_CORE_REV_A1               = 0x0001,
+       GLAMO_CORE_REV_A2               = 0x0002,
+       GLAMO_CORE_REV_A3               = 0x0003,
+};
+
+#define REG_ISP(x)             (GLAMO_REGOFS_ISP+(x))
+
+enum glamo_register_isp {
+       GLAMO_REG_ISP_EN1               = REG_ISP(0x00),
+       GLAMO_REG_ISP_EN2               = REG_ISP(0x02),
+       GLAMO_REG_ISP_EN3               = REG_ISP(0x04),
+       GLAMO_REG_ISP_EN4               = REG_ISP(0x06),
+       GLAMO_REG_ISP_CAP_0_ADDRL       = REG_ISP(0x08),
+       GLAMO_REG_ISP_CAP_0_ADDRH       = REG_ISP(0x0a),
+       GLAMO_REG_ISP_CAP_1_ADDRL       = REG_ISP(0x0c),
+       GLAMO_REG_ISP_CAP_1_ADDRH       = REG_ISP(0x0e),
+       GLAMO_REG_ISP_DEC_Y_ADDRL       = REG_ISP(0x10),
+       GLAMO_REG_ISP_DEC_Y_ADDRH       = REG_ISP(0x12),
+       GLAMO_REG_ISP_DEC_U_ADDRL       = REG_ISP(0x14),
+       GLAMO_REG_ISP_DEC_U_ADDRH       = REG_ISP(0x16),
+       GLAMO_REG_ISP_DEC_V_ADDRL       = REG_ISP(0x18),
+       GLAMO_REG_ISP_DEC_V_ADDRH       = REG_ISP(0x1a),
+       GLAMO_REG_ISP_CAP_SEG_HEIGHT    = REG_ISP(0x1c),
+       GLAMO_REG_ISP_CAP_PITCH         = REG_ISP(0x1e),
+       GLAMO_REG_ISP_CAP_HEIGHT        = REG_ISP(0x20),
+       GLAMO_REG_ISP_CAP_WIDTH         = REG_ISP(0x22),
+       GLAMO_REG_ISP_DEC_PITCH_Y       = REG_ISP(0x24),
+       GLAMO_REG_ISP_DEC_PITCH_UV      = REG_ISP(0x26),
+       GLAMO_REG_ISP_DEC_HEIGHT        = REG_ISP(0x28),
+       GLAMO_REG_ISP_DEC_WIDTH         = REG_ISP(0x2a),
+       GLAMO_REG_ISP_ONFLY_MODE1       = REG_ISP(0x2c),
+       GLAMO_REG_ISP_ONFLY_MODE2       = REG_ISP(0x2e),
+       GLAMO_REG_ISP_ONFLY_MODE3       = REG_ISP(0x30),
+       GLAMO_REG_ISP_ONFLY_MODE4       = REG_ISP(0x32),
+       GLAMO_REG_ISP_ONFLY_MODE5       = REG_ISP(0x34),
+       //
+       GLAMO_REG_ISP_YUV2RGB_11        = REG_ISP(0x50),
+       GLAMO_REG_ISP_YUV2RGB_21        = REG_ISP(0x52),
+       GLAMO_REG_ISP_YUV2RGB_32        = REG_ISP(0x54),
+       GLAMO_REG_ISP_YUV2RGB_33        = REG_ISP(0x56),
+       GLAMO_REG_ISP_YUV2RGB_RG        = REG_ISP(0x58),
+       GLAMO_REG_ISP_YUV2RGB_B         = REG_ISP(0x5a),
+       //
+       GLAMO_REG_ISP_PORT1_SCALEH      = REG_ISP(0x76),
+       GLAMO_REG_ISP_PORT1_SCALEV      = REG_ISP(0x78),
+       GLAMO_REG_ISP_PORT2_SCALEH      = REG_ISP(0x7a),
+       GLAMO_REG_ISP_PORT2_SCALEV      = REG_ISP(0x7c),
+       GLAMO_REG_ISP_DEC_SCALEH        = REG_ISP(0x7e),
+       GLAMO_REG_ISP_DEC_SCALEV        = REG_ISP(0x80),
+       GLAMO_REG_ISP_TURBO             = REG_ISP(0x82),
+       GLAMO_REG_ISP_PORT1_CAP_EN      = REG_ISP(0x84),
+       GLAMO_REG_ISP_PORT1_CAP_0_ADDRL = REG_ISP(0x86),
+       GLAMO_REG_ISP_PORT1_CAP_0_ADDRH = REG_ISP(0x88),
+       GLAMO_REG_ISP_PORT1_CAP_1_ADDRL = REG_ISP(0x8a),
+       GLAMO_REG_ISP_PORT1_CAP_1_ADDRH = REG_ISP(0x8c),
+       GLAMO_REG_ISP_PORT1_CAP_WIDTH   = REG_ISP(0x8e),
+       GLAMO_REG_ISP_PORT1_CAP_HEIGHT  = REG_ISP(0x90),
+       GLAMO_REG_ISP_PORT1_CAP_PITCH   = REG_ISP(0x92),
+       GLAMO_REG_ISP_PORT1_CAP_CLIP_L  = REG_ISP(0x94),
+       GLAMO_REG_ISP_PORT1_CAP_CLIP_R  = REG_ISP(0x96),
+       GLAMO_REG_ISP_PORT1_CAP_CLIP_T  = REG_ISP(0x98),
+       GLAMO_REG_ISP_PORT1_CAP_CLIP_B  = REG_ISP(0x9a),
+       GLAMO_REG_ISP_PORT1_DEC_EN      = REG_ISP(0x9c),
+       GLAMO_REG_ISP_PORT1_DEC_0_ADDRL = REG_ISP(0x9e),
+       GLAMO_REG_ISP_PORT1_DEC_0_ADDRH = REG_ISP(0xa0),
+       GLAMO_REG_ISP_PORT1_DEC_1_ADDRL = REG_ISP(0xa2),
+       GLAMO_REG_ISP_PORT1_DEC_1_ADDRH = REG_ISP(0xa4),
+       GLAMO_REG_ISP_PORT1_DEC_WIDTH   = REG_ISP(0xa6),
+       GLAMO_REG_ISP_PORT1_DEC_HEIGHT  = REG_ISP(0xa8),
+       GLAMO_REG_ISP_PORT1_DEC_PITCH   = REG_ISP(0xaa),
+       GLAMO_REG_ISP_PORT1_DEC_CLIP_L  = REG_ISP(0xac),
+       GLAMO_REG_ISP_PORT1_DEC_CLIP_R  = REG_ISP(0xae),
+       GLAMO_REG_ISP_PORT1_DEC_CLIP_T  = REG_ISP(0xb0),
+       GLAMO_REG_ISP_PORT1_DEC_CLIP_B  = REG_ISP(0xb2),
+       GLAMO_REG_ISP_PORT2_EN          = REG_ISP(0xb4),
+       GLAMO_REG_ISP_PORT2_0_Y_ADDRL   = REG_ISP(0xb6),
+       GLAMO_REG_ISP_PORT2_0_Y_ADDRH   = REG_ISP(0xb8),
+       GLAMO_REG_ISP_PORT2_0_U_ADDRL   = REG_ISP(0xba),
+       GLAMO_REG_ISP_PORT2_0_U_ADDRH   = REG_ISP(0xbc),
+       GLAMO_REG_ISP_PORT2_0_V_ADDRL   = REG_ISP(0xbe),
+       GLAMO_REG_ISP_PORT2_0_V_ADDRH   = REG_ISP(0xc0),
+       GLAMO_REG_ISP_PORT2_1_Y_ADDRL   = REG_ISP(0xc2),
+       GLAMO_REG_ISP_PORT2_1_Y_ADDRH   = REG_ISP(0xc4),
+       GLAMO_REG_ISP_PORT2_1_U_ADDRL   = REG_ISP(0xc6),
+       GLAMO_REG_ISP_PORT2_1_U_ADDRH   = REG_ISP(0xc8),
+       GLAMO_REG_ISP_PORT2_1_V_ADDRL   = REG_ISP(0xca),
+       GLAMO_REG_ISP_PORT2_1_V_ADDRH   = REG_ISP(0xcc),
+       GLAMO_REG_ISP_PORT2_2_Y_ADDRL   = REG_ISP(0xce),
+       GLAMO_REG_ISP_PORT2_2_Y_ADDRH   = REG_ISP(0xd0),
+       GLAMO_REG_ISP_PORT2_2_U_ADDRL   = REG_ISP(0xd2),
+       GLAMO_REG_ISP_PORT2_2_U_ADDRH   = REG_ISP(0xd4),
+       GLAMO_REG_ISP_PORT2_2_V_ADDRL   = REG_ISP(0xd6),
+       GLAMO_REG_ISP_PORT2_2_V_ADDRH   = REG_ISP(0xd8),
+       GLAMO_REG_ISP_PORT2_WIDTH       = REG_ISP(0xda),
+       GLAMO_REG_ISP_PORT2_HEIGHT      = REG_ISP(0xdc),
+       GLAMO_REG_ISP_PORT2_Y_PITCH     = REG_ISP(0xde),
+       GLAMO_REG_ISP_PORT2_UV_PITCH    = REG_ISP(0xe0),
+       //
+       GLAMO_REG_ISP_OVERLAY_GR_KEY    = REG_ISP(0xe2),
+       GLAMO_REG_ISP_OVERLAY_B_KEY     = REG_ISP(0xe4),
+       GLAMO_REG_ISP_OVERLAY_ADDRL     = REG_ISP(0xe6),
+       GLAMO_REG_ISP_OVERLAY_ADDRH     = REG_ISP(0xe8),
+       GLAMO_REG_ISP_OVERLAY_X         = REG_ISP(0xea),
+       GLAMO_REG_ISP_OVERLAY_Y         = REG_ISP(0xec),
+       GLAMO_REG_ISP_OVERLAY_WIDTH     = REG_ISP(0xee),
+       GLAMO_REG_ISP_OVERLAY_HEIGHT    = REG_ISP(0xf0),
+       GLAMO_REG_ISP_OVERLAY_PITCH     = REG_ISP(0xf2),
+       GLAMO_REG_ISP_OVERLAY_BLOCK_XY  = REG_ISP(0xf4),
+       //
+       GLAMO_REG_ISP_RGB2YUV_11_12     = REG_ISP(0xf6),
+       GLAMO_REG_ISP_RGB2YUV_13_21     = REG_ISP(0xf8),
+       GLAMO_REG_ISP_RGB2YUV_22_23     = REG_ISP(0xfa),
+       GLAMO_REG_ISP_RGB2YUV_31_32     = REG_ISP(0xfc),
+       GLAMO_REG_ISP_RGB2YUV_33        = REG_ISP(0xfe),
+       //
+       GLAMO_REG_ISP_PORT1_SCALEH_MATRIX       = REG_ISP(0x10c),
+       //
+       GLAMO_REG_ISP_PORT1_SCALEV_MATRIX       = REG_ISP(0x120),
+       //
+       GLAMO_REG_ISP_PORT2_SCALEH_MATRIX       = REG_ISP(0x134),
+       //
+       GLAMO_REG_ISP_PORT2_SCALEV_MATRIX       = REG_ISP(0x148),
+       //
+       GLAMO_REG_ISP_DEC_SCALEH_MATRIX         = REG_ISP(0x15c),
+       //
+       GLAMO_REG_ISP_DEC_SCALEV_MATRIX         = REG_ISP(0x170),
+       //
+       GLAMO_REG_ISP_STATUS                    = REG_ISP(0x184),
+};
+
+enum glamo_isp_rot_mode {
+       GLAMO_ISP_ROT_MODE_0            = 0x0000,
+       GLAMO_ISP_ROT_MODE_90           = 0x0400,
+       GLAMO_ISP_ROT_MODE_270          = 0x0800,
+       GLAMO_ISP_ROT_MODE_180          = 0x0c00,
+       GLAMO_ISP_ROT_MODE_MIRROR       = 0x1000,
+       GLAMO_ISP_ROT_MODE_FLIP         = 0x1400,
+};
+#define GLAMO_ISP_ROT_MODE_MASK               0x1c00
+
+enum glamo_reg_isp_en1 {
+       GLAMO_ISP_EN1_FIRE_ISP          = 0x0001,
+       GLAMO_ISP_EN1_FIRE_CAP          = 0x0002,
+       GLAMO_ISP_EN1_VIDEO_CONF        = 0x0004,
+       GLAMO_ISP_EN1_BAYER_SRC         = 0x0008,
+       //
+       GLAMO_ISP_EN1_YUV_PACK          = 0x0040,
+       GLAMO_ISP_EN1_PLANE_MODE        = 0x0080,
+       GLAMO_ISP_EN1_YUV_INPUT         = 0x0100,
+       GLAMO_ISP_EN1_YUV420            = 0x0200,
+       //
+};
+
+enum glamo_reg_isp_en2 {
+       GLAMO_ISP_EN2_OVERLAY           = 0x0001,
+       GLAMO_ISP_EN2_LCD_OVERLAY       = 0x0002,
+};
+
+enum glamo_reg_isp_en3 {
+       //
+       GLAMO_ISP_EN3_SCALE_IMPROVE     = 0x0040,
+       GLAMO_ISP_EN3_PLANE_MODE        = 0x0080,
+       GLAMO_ISP_EN3_YUV_INPUT         = 0x0100,
+       GLAMO_ISP_EN3_YUV420            = 0x0200,
+       //
+};
+
+enum glamo_reg_isp_en4 {
+       GLAMO_ISP_EN4_OVERLAY           = 0x0001,
+       GLAMO_ISP_EN4_LCD_OVERLAY       = 0x0002,
+};
+
+enum glamo_reg_isp_port1_en {
+       GLAMO_ISP_PORT1_EN_OUTPUT       = 0x0001,
+//     GLAMO_ISP_PORT1_EN_SCALE        = 0x0002,
+       GLAMO_ISP_PORT1_EN_CLIP         = 0x0004,
+       GLAMO_ISP_PORT1_EN_CLIP_OUT     = 0x0008,
+       GLAMO_ISP_PORT1_EN_DUAL_BUF     = 0x0010,
+};
+
+enum glamo_reg_isp_port2_en {
+       GLAMO_ISP_PORT2_EN_OUTPUT       = 0x0001,
+       GLAMO_ISP_PORT2_EN_SCALE        = 0x0002,
+       GLAMO_ISP_PORT2_EN_JPEG         = 0x0010,
+       GLAMO_ISP_PORT2_EN_MPEG         = 0x0020,
+       GLAMO_ISP_PORT2_EN_ENCODE       = 0x0040,
+       GLAMO_ISP_PORT2_EN_DECODE       = 0x0080,
+};
+
+#define REG_MPEG(x)           (GLAMO_REGOFS_MPEG+(x))
+
+enum glamo_register_mpeg {
+      //
+      GLAMO_REG_MPEG_DC_ADDRL         = REG_MPEG(0x3c),
+      GLAMO_REG_MPEG_DC_ADDRH         = REG_MPEG(0x3e),
+      GLAMO_REG_MPEG_AC_ADDRL         = REG_MPEG(0x40),
+      GLAMO_REG_MPEG_AC_ADDRH         = REG_MPEG(0x42),
+      //
+      GLAMO_REG_MPEG_SAFE_1           = REG_MPEG(0x60),
+      GLAMO_REG_MPEG_SAFE_2           = REG_MPEG(0x62),
+      GLAMO_REG_MPEG_SAFE_3           = REG_MPEG(0x64),
+      //
+      GLAMO_REG_MPEG_DEC_OUT0_Y_ADDRL = REG_MPEG(0x6e),
+      GLAMO_REG_MPEG_DEC_OUT0_Y_ADDRH = REG_MPEG(0x70),
+      GLAMO_REG_MPEG_DEC_OUT0_U_ADDRL = REG_MPEG(0x72),
+      GLAMO_REG_MPEG_DEC_OUT0_U_ADDRH = REG_MPEG(0x74),
+      GLAMO_REG_MPEG_DEC_OUT0_V_ADDRL = REG_MPEG(0x76),
+      GLAMO_REG_MPEG_DEC_OUT0_V_ADDRH = REG_MPEG(0x78),
+      GLAMO_REG_MPEG_DEC_OUT1_Y_ADDRL = REG_MPEG(0x7a),
+      GLAMO_REG_MPEG_DEC_OUT1_Y_ADDRH = REG_MPEG(0x7c),
+      GLAMO_REG_MPEG_DEC_OUT1_U_ADDRL = REG_MPEG(0x7e),
+      GLAMO_REG_MPEG_DEC_OUT1_U_ADDRH = REG_MPEG(0x80),
+      GLAMO_REG_MPEG_DEC_OUT1_V_ADDRL = REG_MPEG(0x82),
+      GLAMO_REG_MPEG_DEC_OUT1_V_ADDRH = REG_MPEG(0x84),
+      GLAMO_REG_MPEG_DEC_OUT2_Y_ADDRL = REG_MPEG(0x86),
+      GLAMO_REG_MPEG_DEC_OUT2_Y_ADDRH = REG_MPEG(0x88),
+      GLAMO_REG_MPEG_DEC_OUT2_U_ADDRL = REG_MPEG(0x8a),
+      GLAMO_REG_MPEG_DEC_OUT2_U_ADDRH = REG_MPEG(0x8c),
+      GLAMO_REG_MPEG_DEC_OUT2_V_ADDRL = REG_MPEG(0x8e),
+      GLAMO_REG_MPEG_DEC_OUT2_V_ADDRH = REG_MPEG(0x90),
+      GLAMO_REG_MPEG_DEC_WIDTH        = REG_MPEG(0x92),
+      GLAMO_REG_MPEG_DEC_HEIGHT       = REG_MPEG(0x94),
+      GLAMO_REG_MPEG_SPECIAL          = REG_MPEG(0x96),
+      GLAMO_REG_MPEG_DEC_IN_ADDRL     = REG_MPEG(0x98),
+      GLAMO_REG_MPEG_DEC_IN_ADDRH     = REG_MPEG(0x9a),
+      //
+      GLAMO_REG_MPEG_DEBLK_THRESHOLD  = REG_MPEG(0xc0),
+      //
+      GLAMO_REG_MPEG_DEC_STATUS       = REG_MPEG(0xc8),
+      GLAMO_REG_MPEG_DEC_RB0          = REG_MPEG(0xca),
+      GLAMO_REG_MPEG_DEC_RB1          = REG_MPEG(0xcc),
+};
+
+#define REG_CMDQ(x)           (GLAMO_REGOFS_CMDQUEUE+(x))
+
+enum glamo_register_cq {
+       GLAMO_REG_CMDQ_BASE_ADDRL     = REG_CMDQ(0x00),
+       GLAMO_REG_CMDQ_BASE_ADDRH     = REG_CMDQ(0x02),
+       GLAMO_REG_CMDQ_LEN            = REG_CMDQ(0x04),
+       GLAMO_REG_CMDQ_WRITE_ADDRL    = REG_CMDQ(0x06),
+       GLAMO_REG_CMDQ_WRITE_ADDRH    = REG_CMDQ(0x08),
+       GLAMO_REG_CMDQ_FLIP           = REG_CMDQ(0x0a),
+       GLAMO_REG_CMDQ_CONTROL        = REG_CMDQ(0x0c),
+       GLAMO_REG_CMDQ_READ_ADDRL     = REG_CMDQ(0x0e),
+       GLAMO_REG_CMDQ_READ_ADDRH     = REG_CMDQ(0x10),
+       GLAMO_REG_CMDQ_STATUS         = REG_CMDQ(0x12),
+};
+
+#define REG_2D(x)              (GLAMO_REGOFS_2D+(x))
+
+enum glamo_register_2d {
+       GLAMO_REG_2D_SRC_ADDRL          = REG_2D(0x00),
+       GLAMO_REG_2D_SRC_ADDRH          = REG_2D(0x02),
+       GLAMO_REG_2D_SRC_PITCH          = REG_2D(0x04),
+       GLAMO_REG_2D_SRC_X              = REG_2D(0x06),
+       GLAMO_REG_2D_SRC_Y              = REG_2D(0x08),
+       GLAMO_REG_2D_DST_X              = REG_2D(0x0a),
+       GLAMO_REG_2D_DST_Y              = REG_2D(0x0c),
+       GLAMO_REG_2D_DST_ADDRL          = REG_2D(0x0e),
+       GLAMO_REG_2D_DST_ADDRH          = REG_2D(0x10),
+       GLAMO_REG_2D_DST_PITCH          = REG_2D(0x12),
+       GLAMO_REG_2D_DST_HEIGHT         = REG_2D(0x14),
+       GLAMO_REG_2D_RECT_WIDTH         = REG_2D(0x16),
+       GLAMO_REG_2D_RECT_HEIGHT        = REG_2D(0x18),
+       GLAMO_REG_2D_PAT_ADDRL          = REG_2D(0x1a),
+       GLAMO_REG_2D_PAT_ADDRH          = REG_2D(0x1c),
+       GLAMO_REG_2D_PAT_FG             = REG_2D(0x1e),
+       GLAMO_REG_2D_PAT_BG             = REG_2D(0x20),
+       GLAMO_REG_2D_SRC_FG             = REG_2D(0x22),
+       GLAMO_REG_2D_SRC_BG             = REG_2D(0x24),
+       GLAMO_REG_2D_MASK1              = REG_2D(0x26),
+       GLAMO_REG_2D_MASK2              = REG_2D(0x28),
+       GLAMO_REG_2D_MASK3              = REG_2D(0x2a),
+       GLAMO_REG_2D_MASK4              = REG_2D(0x2c),
+       GLAMO_REG_2D_ROT_X              = REG_2D(0x2e),
+       GLAMO_REG_2D_ROT_Y              = REG_2D(0x30),
+       GLAMO_REG_2D_LEFT_CLIP          = REG_2D(0x32),
+       GLAMO_REG_2D_TOP_CLIP           = REG_2D(0x34),
+       GLAMO_REG_2D_RIGHT_CLIP         = REG_2D(0x36),
+       GLAMO_REG_2D_BOTTOM_CLIP        = REG_2D(0x38),
+       GLAMO_REG_2D_COMMAND1           = REG_2D(0x3A),
+       GLAMO_REG_2D_COMMAND2           = REG_2D(0x3C),
+       GLAMO_REG_2D_COMMAND3           = REG_2D(0x3E),
+       GLAMO_REG_2D_SAFE               = REG_2D(0x40),
+       GLAMO_REG_2D_STATUS             = REG_2D(0x42),
+       GLAMO_REG_2D_ID1                = REG_2D(0x44),
+       GLAMO_REG_2D_ID2                = REG_2D(0x46),
+       GLAMO_REG_2D_ID3                = REG_2D(0x48),
+};
+
+#endif /* _GLAMO_REGS_H */