camera: switch to CyanogenMod's version of the free software camera

Replicant's version locks up, sometimes already after taking only one picture.
CyanogenMod's camera seems more stable.
Only the preview format was changed to RGB565.
TODO: Incorporate fixes from both version.

Signed-off-by: Wolfgang Wiedmeyer <wolfgit@wiedmeyer.de>

20 files changed, 8651 insertions, 6708 deletions

diff --git a/camera/Android.mk b/camera/Android.mk
index 60bd5d7..a830b3d 100644
--- a/camera/Android.mk
+++ b/camera/Android.mk
@@ -1,4 +1,5 @@
-# Copyright (C) 2013-2014 Paul Kocialkowski <contact@paulk.fr>
+#
+# Copyright (C) 2013 Paul Kocialkowski
 #
 # 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
@@ -21,26 +22,31 @@ LOCAL_PATH := $(call my-dir)
 include $(CLEAR_VARS)
 
 LOCAL_SRC_FILES := \
-	smdk4x12_camera.c \
-	smdk4x12_exif.c \
-	smdk4x12_jpeg.c \
-	smdk4x12_param.c \
-	smdk4x12_utils.c \
-	smdk4x12_v4l2.c \
-	smdk4x12_v4l2_output.c \
-	smdk4x12_ion.c
+	exynos_camera.c \
+	exynos_exif.c \
+	exynos_jpeg.c \
+	exynos_param.c \
+	exynos_utils.c \
+	exynos_v4l2.c \
+	exynos_v4l2_output.c
 
 LOCAL_C_INCLUDES := \
 	$(LOCAL_PATH)/include \
 	system/media/camera/include \
 	hardware/samsung/exynos4/hal/include
 
-LOCAL_CFLAGS += -DEXYNOS_ION
-
-LOCAL_SHARED_LIBRARIES := libutils libcutils liblog libcamera_client libhardware libhwjpeg
+LOCAL_SHARED_LIBRARIES := libutils libcutils liblog libcamera_client libhardware
 LOCAL_PRELINK_MODULE := false
 
-LOCAL_MODULE := camera.smdk4x12
+ifeq ($(TARGET_SOC),exynos4x12)
+	LOCAL_SHARED_LIBRARIES += libhwjpeg
+	LOCAL_CFLAGS += -DEXYNOS_JPEG_HW
+
+	LOCAL_SRC_FILES += exynos_ion.c
+	LOCAL_CFLAGS += -DEXYNOS_ION
+endif
+
+LOCAL_MODULE := camera.$(TARGET_BOOTLOADER_BOARD_NAME)
 LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
 LOCAL_MODULE_TAGS := optional
 
diff --git a/camera/MODULE_LICENSE_GPL b/camera/MODULE_LICENSE_GPL
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/camera/MODULE_LICENSE_GPL
diff --git a/camera/NOTICE b/camera/NOTICE
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/camera/NOTICE
@@ -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/camera/exynos_camera.c b/camera/exynos_camera.c
new file mode 100644
index 0000000..12360ae
--- /dev/null
+++ b/camera/exynos_camera.c
@@ -0,0 +1,3887 @@
+/*
+ * Copyright (C) 2013 Paul Kocialkowski
+ *
+ * Based on crespo libcamera and exynos4 hal libcamera:
+ * Copyright 2008, The Android Open Source Project
+ * Copyright 2010, Samsung Electronics Co. LTD
+ *
+ * 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 <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <time.h>
+#include <errno.h>
+#include <malloc.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+
+#include <asm/types.h>
+
+#define LOG_TAG "exynos_camera"
+#include <utils/Log.h>
+#include <utils/Timers.h>
+
+#include "exynos_camera.h"
+
+#define BIG2LITTLE_ENDIAN(big)	((big & 0xff) << 24 | (big & 0xff00) << 8 | (big & 0xff0000) >> 8 | (big & 0xff000000) >> 24)
+
+/*
+ * Devices configurations
+ */
+
+struct exynos_camera_mbus_resolution exynos_camera_mbus_resolutions_s5k6a3_smdk4x12[] = {
+	// 16:9 ratio
+	{ 1280, 720,	1344, 756 },
+	// 4:3 ratio
+	{ 1280, 960,	1392, 1044 },
+	{ 960, 720,	1392, 1044 },
+	{ 640, 480,	1392, 1044 },
+	{ 320, 240,	1392, 1044 },
+	// 1:1 ratio
+	{ 1392, 1392,	1392, 1392 },
+	{ 704, 704,	1392, 1392 },
+	{ 320, 320,	1392, 1392 },
+};
+
+struct exynos_camera_videosnapshot_resolution exynos_camera_videosnapshot_resolutions_s5c73m3[] = {
+	//Capture Size - Snapshot Size
+	{ 1920, 1080,	3264, 1836 },
+	{ 1280, 720,	3264, 1836 },
+	{ 720, 480,	3264, 2176 },
+	{ 640, 480,	3264, 2488 },
+	{ 352, 288,	3264, 2488 },
+	{ 320, 240,	3264, 2488 },
+	{ 176, 144,	3264, 2488 },
+};
+
+struct exynos_camera_preset exynos_camera_presets_smdk4x12[] = {
+	{
+		.name = "S5C73M3",
+		.facing = CAMERA_FACING_BACK,
+		.orientation = 90,
+		.rotation = 0,
+		.hflip = 0,
+		.vflip = 0,
+		.capture_format = V4L2_PIX_FMT_INTERLEAVED,
+		.picture_format = V4L2_PIX_FMT_JPEG,
+		.fimc_is = 0,
+		.focal_length = 3.7f,
+		.horizontal_view_angle = 63.0f,
+		.vertical_view_angle = 49.3f,
+		.metering = METERING_CENTER,
+		.params = {
+			.preview_size_values = "960x720,1280x720,1184x666,960x640,704x576,640x480,352x288,320x240",
+			.preview_size = "960x720",
+			.preview_format_values = "yuv420sp,yuv420p,rgb565",
+			.preview_format = "rgb565",
+			.preview_frame_rate_values = "30,20,15",
+			.preview_frame_rate = 30,
+			.preview_fps_range_values = "(15000,15000),(15000,30000),(30000,30000)",
+			.preview_fps_range = "15000,30000",
+
+			.picture_size_values = "640x480,1024x768,1280x720,1600x1200,2560x1920,3264x2448,2048x1536,3264x1836,2048x1152,3264x2176",
+			.picture_size = "3264x2448",
+			.picture_format_values = "jpeg",
+			.picture_format = "jpeg",
+			.jpeg_thumbnail_size_values = "160x120,160x90,144x96",
+			.jpeg_thumbnail_width = 160,
+			.jpeg_thumbnail_height = 120,
+			.jpeg_thumbnail_quality = 100,
+			.jpeg_quality = 90,
+
+			.video_snapshot_supported = 1,
+			.full_video_snap_supported = 0,
+
+			.recording_size = "1280x720",
+			.recording_size_values = "1280x720,1920x1080,720x480,640x480,352x288,320x240,176x144",
+			.recording_format = "yuv420sp",
+
+			.focus_mode = "auto",
+			.focus_mode_values = "auto,infinity,macro,fixed,continuous-picture,continuous-video",
+			.focus_distances = "0.15,1.20,Infinity",
+			.focus_areas = "(0,0,0,0,0)",
+			.max_num_focus_areas = 1,
+
+			.max_detected_faces = 15,
+
+			.zoom_supported = 1,
+			.smooth_zoom_supported = 0,
+			.zoom_ratios = "100,102,104,109,111,113,119,121,124,131,134,138,146,150,155,159,165,170,182,189,200,213,222,232,243,255,283,300,319,364,400",
+			.zoom = 0,
+			.max_zoom = 30,
+
+			.auto_exposure_lock_supported = 1,
+			.auto_exposure_lock = 0,
+
+			.auto_white_balance_lock_supported = 1,
+			.auto_white_balance_lock = 0,
+
+			.flash_mode = "off",
+			.flash_mode_values = "off,auto,on,torch",
+
+			.exposure_compensation = 0,
+			.exposure_compensation_step = 0.5,
+			.min_exposure_compensation = -4,
+			.max_exposure_compensation = 4,
+
+			.whitebalance = "auto",
+			.whitebalance_values = "auto,incandescent,fluorescent,daylight,cloudy-daylight",
+
+			.antibanding = "auto",
+			.antibanding_values = "off,auto,50hz,60hz",
+
+			.scene_mode = "auto",
+			.scene_mode_values = "auto,portrait,landscape,night,beach,snow,sunset,fireworks,action,party,candlelight,dusk-dawn,fall-color,text,back-light,high-sensitivity",
+
+			.effect = "none",
+			.effect_values = "none,mono,negative,sepia,solarize,posterize,washed,vintage-warm,vintage-cold,point-blue,point-red-yellow,point-green",
+
+			.iso = "auto",
+			.iso_values = "auto,ISO100,ISO200,ISO400,ISO800",
+
+			.image_stabilization = "off",
+			.image_stabilization_values = "on,off",
+		},
+		.mbus_resolutions = NULL,
+		.mbus_resolutions_count = 0,
+
+		.videosnapshot_resolutions = (struct exynos_camera_videosnapshot_resolution *) &exynos_camera_videosnapshot_resolutions_s5c73m3,
+		.videosnapshot_resolutions_count = 7,
+	},
+	{
+		.name = "S5K6A3",
+		.facing = CAMERA_FACING_FRONT,
+		.orientation = 270,
+		.rotation = 0,
+		.hflip = 0,
+		.vflip = 0,
+		.capture_format = V4L2_PIX_FMT_UYVY,
+		.picture_format = V4L2_PIX_FMT_JPEG,
+		.fimc_is = 1,
+		.focal_length = 2.73f,
+		.horizontal_view_angle = 52.58f,
+		.vertical_view_angle = 52.58f,
+		.metering = METERING_CENTER,
+		.params = {
+			.preview_size_values = "1280x720,960x720,640x480,320x240,704x704,320x320",
+			.preview_size = "960x720",
+			.preview_format_values = "yuv420sp,yuv420p,rgb565",
+			.preview_format = "rgb565",
+			.preview_frame_rate_values = "30,20,15,8",
+			.preview_frame_rate = 30,
+			.preview_fps_range_values = "(8000,8000),(15000,15000),(15000,30000),(30000,30000)",
+			.preview_fps_range = "15000,30000",
+
+			.picture_size_values = "1280x960,1392x1392,640x480,1280x720,720x480,320x240",
+			.picture_size = "1280x960",
+			.picture_format_values = "jpeg",
+			.picture_format = "jpeg",
+			.jpeg_thumbnail_size_values = "160x120,160x160,160x90,144x96",
+			.jpeg_thumbnail_width = 160,
+			.jpeg_thumbnail_height = 120,
+			.jpeg_thumbnail_quality = 100,
+			.jpeg_quality = 90,
+
+			.video_snapshot_supported = 1,
+			.full_video_snap_supported = 1,
+
+			.recording_size = "1280x720",
+			.recording_size_values = "1280x720,720x480,640x480,352x288,320x320,320x240,176x144",
+			.recording_format = "yuv420sp",
+
+			.focus_mode = "fixed",
+			.focus_mode_values = "infinity,fixed",
+			.focus_distances = "0.20,0.25,Infinity",
+			.focus_areas = NULL,
+			.max_num_focus_areas = 0,
+
+			.zoom_supported = 0,
+
+			.auto_exposure_lock_supported = 0,
+			.auto_exposure_lock = 0,
+
+			.auto_white_balance_lock_supported = 0,
+			.auto_white_balance_lock = 0,
+
+			.flash_mode = NULL,
+			.flash_mode_values = NULL,
+
+			.max_detected_faces = 5,
+
+			.exposure_compensation = 0,
+			.exposure_compensation_step = 0.5,
+			.min_exposure_compensation = -4,
+			.max_exposure_compensation = 4,
+
+			.whitebalance = "auto",
+			.whitebalance_values = "auto,incandescent,fluorescent,daylight,cloudy-daylight",
+
+			.antibanding = NULL,
+			.antibanding_values = NULL,
+
+			.scene_mode = NULL,
+			.scene_mode_values = NULL,
+
+			.effect = "none",
+			.effect_values = "none,mono,negative,sepia,solarize,posterize,washed,vintage-warm,vintage-cold,point-blue,point-red-yellow,point-green",
+
+			.iso = "auto",
+			.iso_values = "auto",
+
+			.image_stabilization = "off",
+			.image_stabilization_values = "off",
+		},
+		.mbus_resolutions = (struct exynos_camera_mbus_resolution *) &exynos_camera_mbus_resolutions_s5k6a3_smdk4x12,
+		.mbus_resolutions_count = 8,
+	},
+};
+
+struct exynos_v4l2_node exynos_v4l2_nodes_smdk4x12[] = {
+	{	// FIMC0 is used for capture
+		.id = 0,
+		.node = "/dev/video0",
+	},
+	{	// FIMC1 is used for preview output
+		.id = 1,
+		.node = "/dev/video1",
+	},
+	{	// FIMC2 is used for picture output
+		.id = 2,
+		.node = "/dev/video2",
+	},
+	{	// FIMC3 is used for recording output
+		.id = 3,
+		.node = "/dev/video3",
+	},
+};
+
+struct exynox_camera_config exynos_camera_config_smdk4x12 = {
+	.presets = (struct exynos_camera_preset *) &exynos_camera_presets_smdk4x12,
+	.presets_count = 2,
+	.v4l2_nodes = (struct exynos_v4l2_node *) &exynos_v4l2_nodes_smdk4x12,
+	.v4l2_nodes_count = 4,
+};
+
+/*
+ * Exynos Camera
+ */
+
+struct exynox_camera_config *exynos_camera_config =
+	&exynos_camera_config_smdk4x12;
+
+int exynos_camera_start(struct exynos_camera *exynos_camera, int id)
+{
+	int rc;
+
+	if (exynos_camera == NULL || id >= exynos_camera->config->presets_count)
+		return -EINVAL;
+
+	// ION
+
+#ifdef EXYNOS_ION
+	rc = exynos_ion_init(exynos_camera);
+	if (rc < 0) {
+		ALOGE("%s: Unable to init ION", __func__);
+		goto error;
+	}
+
+	rc = exynos_ion_open(exynos_camera);
+	if (rc < 0) {
+		ALOGE("%s: Unable to open ION", __func__);
+		goto error;
+	}
+#endif
+
+	// V4L2
+
+	rc = exynos_v4l2_init(exynos_camera);
+	if (rc < 0) {
+		ALOGE("%s: Unable to init v4l2", __func__);
+		goto error;
+	}
+
+	// FIMC0
+
+	rc = exynos_v4l2_open(exynos_camera, 0);
+	if (rc < 0) {
+		ALOGE("%s: Unable to open v4l2 device", __func__);
+		goto error;
+	}
+
+	rc = exynos_v4l2_querycap_cap(exynos_camera, 0);
+	if (rc < 0) {
+		ALOGE("%s: Unable to query capabilities", __func__);
+		goto error;
+	}
+
+	rc = exynos_v4l2_enum_input(exynos_camera, 0, id);
+	if (rc < 0) {
+		ALOGE("%s: Unable to enumerate input", __func__);
+		goto error;
+	}
+
+	rc = exynos_v4l2_s_input(exynos_camera, 0, id);
+	if (rc < 0) {
+		ALOGE("%s: Unable to set inputs", __func__);
+		goto error;
+	}
+
+	// Recording
+
+	exynos_camera->recording_metadata = 1;
+
+	// Params
+
+	rc = exynos_camera_params_init(exynos_camera, id);
+	if (rc < 0) {
+		ALOGE("%s: Unable to init params", __func__);
+		goto error;
+	}
+
+	// Gralloc
+
+	rc = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const struct hw_module_t **) &exynos_camera->gralloc);
+	if (rc)
+		ALOGE("%s: Unable to get gralloc module", __func__);
+
+	rc = 0;
+	goto complete;
+
+error:
+	exynos_v4l2_close(exynos_camera, 0);
+
+#ifdef EXYNOS_ION
+	exynos_ion_close(exynos_camera);
+#endif
+
+	rc = -1;
+
+complete:
+	return rc;
+}
+
+void exynos_camera_stop(struct exynos_camera *exynos_camera)
+{
+	int i;
+	int id;
+
+	if (exynos_camera == NULL || exynos_camera->config == NULL)
+		return;
+
+	exynos_v4l2_close(exynos_camera, 0);
+
+#ifdef EXYNOS_ION
+	exynos_ion_close(exynos_camera);
+#endif
+}
+
+// Params
+
+int exynos_camera_params_init(struct exynos_camera *exynos_camera, int id)
+{
+	int rc;
+
+	if (exynos_camera == NULL || id >= exynos_camera->config->presets_count)
+		return -EINVAL;
+
+	// Camera params
+
+	exynos_camera->camera_rotation = exynos_camera->config->presets[id].rotation;
+	exynos_camera->camera_hflip = exynos_camera->config->presets[id].hflip;
+	exynos_camera->camera_vflip = exynos_camera->config->presets[id].vflip;
+	exynos_camera->camera_capture_format = exynos_camera->config->presets[id].capture_format;
+	exynos_camera->camera_picture_format = exynos_camera->config->presets[id].picture_format;
+	exynos_camera->camera_fimc_is = exynos_camera->config->presets[id].fimc_is;
+	exynos_camera->camera_focal_length = (int) (exynos_camera->config->presets[id].focal_length * 100);
+	exynos_camera->camera_metering = exynos_camera->config->presets[id].metering;
+
+	exynos_camera->camera_mbus_resolutions = exynos_camera->config->presets[id].mbus_resolutions;
+	exynos_camera->camera_mbus_resolutions_count = exynos_camera->config->presets[id].mbus_resolutions_count;
+
+	exynos_camera->camera_videosnapshot_resolutions = exynos_camera->config->presets[id].videosnapshot_resolutions;
+	exynos_camera->camera_videosnapshot_resolutions_count = exynos_camera->config->presets[id].videosnapshot_resolutions_count;
+
+
+	// Recording preview
+
+	exynos_param_string_set(exynos_camera, "preferred-preview-size-for-video",
+		exynos_camera->config->presets[id].params.preview_size);
+
+	// Preview
+
+	exynos_param_string_set(exynos_camera, "preview-size-values",
+		exynos_camera->config->presets[id].params.preview_size_values);
+	exynos_param_string_set(exynos_camera, "preview-size",
+		exynos_camera->config->presets[id].params.preview_size);
+	exynos_param_string_set(exynos_camera, "preview-format-values",
+		exynos_camera->config->presets[id].params.preview_format_values);
+	exynos_param_string_set(exynos_camera, "preview-format",
+		exynos_camera->config->presets[id].params.preview_format);
+	exynos_param_string_set(exynos_camera, "preview-frame-rate-values",
+		exynos_camera->config->presets[id].params.preview_frame_rate_values);
+	exynos_param_int_set(exynos_camera, "preview-frame-rate",
+		exynos_camera->config->presets[id].params.preview_frame_rate);
+	exynos_param_string_set(exynos_camera, "preview-fps-range-values",
+		exynos_camera->config->presets[id].params.preview_fps_range_values);
+	exynos_param_string_set(exynos_camera, "preview-fps-range",
+		exynos_camera->config->presets[id].params.preview_fps_range);
+
+	// Picture
+
+	exynos_param_string_set(exynos_camera, "picture-size-values",
+		exynos_camera->config->presets[id].params.picture_size_values);
+	exynos_param_string_set(exynos_camera, "picture-size",
+		exynos_camera->config->presets[id].params.picture_size);
+	exynos_param_string_set(exynos_camera, "picture-format-values",
+		exynos_camera->config->presets[id].params.picture_format_values);
+	exynos_param_string_set(exynos_camera, "picture-format",
+		exynos_camera->config->presets[id].params.picture_format);
+	exynos_param_string_set(exynos_camera, "jpeg-thumbnail-size-values",
+		exynos_camera->config->presets[id].params.jpeg_thumbnail_size_values);
+	exynos_param_int_set(exynos_camera, "jpeg-thumbnail-width",
+		exynos_camera->config->presets[id].params.jpeg_thumbnail_width);
+	exynos_param_int_set(exynos_camera, "jpeg-thumbnail-height",
+		exynos_camera->config->presets[id].params.jpeg_thumbnail_height);
+	exynos_param_int_set(exynos_camera, "jpeg-thumbnail-quality",
+		exynos_camera->config->presets[id].params.jpeg_thumbnail_quality);
+	exynos_param_int_set(exynos_camera, "jpeg-quality",
+		exynos_camera->config->presets[id].params.jpeg_quality);
+
+	if (exynos_camera->config->presets[id].params.video_snapshot_supported == 1)
+		exynos_param_string_set(exynos_camera, "video-snapshot-supported", "true");
+	if (exynos_camera->config->presets[id].params.full_video_snap_supported == 1)
+		exynos_param_string_set(exynos_camera, "full-video-snap-supported", "true");
+
+	// Recording
+
+	exynos_param_string_set(exynos_camera, "video-size",
+		exynos_camera->config->presets[id].params.recording_size);
+	exynos_param_string_set(exynos_camera, "video-size-values",
+		exynos_camera->config->presets[id].params.recording_size_values);
+	exynos_param_string_set(exynos_camera, "video-frame-format",
+		exynos_camera->config->presets[id].params.recording_format);
+
+	// Focus
+
+	exynos_param_string_set(exynos_camera, "focus-mode",
+		exynos_camera->config->presets[id].params.focus_mode);
+	exynos_param_string_set(exynos_camera, "focus-mode-values",
+		exynos_camera->config->presets[id].params.focus_mode_values);
+	exynos_param_string_set(exynos_camera, "focus-distances",
+		exynos_camera->config->presets[id].params.focus_distances);
+	if (exynos_camera->config->presets[id].params.max_num_focus_areas > 0) {
+		exynos_param_string_set(exynos_camera, "focus-areas",
+			exynos_camera->config->presets[id].params.focus_areas);
+		sprintf(exynos_camera->raw_focus_areas,"%s",
+			exynos_camera->config->presets[id].params.focus_areas);
+		exynos_param_int_set(exynos_camera, "max-num-focus-areas",
+			exynos_camera->config->presets[id].params.max_num_focus_areas);
+	}
+
+	// Face Detection
+	exynos_camera->max_detected_faces = exynos_camera->config->presets[id].params.max_detected_faces;
+	exynos_param_int_set(exynos_camera, "max-num-detected-faces-hw",
+		exynos_camera->max_detected_faces);
+
+	// Zoom
+
+	if (exynos_camera->config->presets[id].params.zoom_supported == 1) {
+		exynos_param_string_set(exynos_camera, "zoom-supported", "true");
+
+		if (exynos_camera->config->presets[id].params.smooth_zoom_supported == 1)
+			exynos_param_string_set(exynos_camera, "smooth-zoom-supported", "true");
+
+		if (exynos_camera->config->presets[id].params.zoom_ratios != NULL)
+			exynos_param_string_set(exynos_camera, "zoom-ratios", exynos_camera->config->presets[id].params.zoom_ratios);
+
+		exynos_param_int_set(exynos_camera, "zoom", exynos_camera->config->presets[id].params.zoom);
+		exynos_param_int_set(exynos_camera, "max-zoom", exynos_camera->config->presets[id].params.max_zoom);
+
+	} else {
+		exynos_param_string_set(exynos_camera, "zoom-supported", "false");
+	}
+
+	// AE lock
+
+	if (exynos_camera->config->presets[id].params.auto_exposure_lock_supported == 1) {
+		exynos_param_string_set(exynos_camera, "auto-exposure-lock-supported", "true");
+
+		if (exynos_camera->config->presets[id].params.auto_exposure_lock)
+			exynos_param_string_set(exynos_camera, "auto-exposure-lock", "true");
+		else
+			exynos_param_string_set(exynos_camera, "auto-exposure-lock", "false");
+	}
+
+	// AWB lock
+
+	if (exynos_camera->config->presets[id].params.auto_white_balance_lock_supported == 1) {
+		exynos_param_string_set(exynos_camera, "auto-whitebalance-lock-supported", "true");
+
+		if (exynos_camera->config->presets[id].params.auto_white_balance_lock)
+			exynos_param_string_set(exynos_camera, "auto-whitebalance-lock", "true");
+		else
+			exynos_param_string_set(exynos_camera, "auto-whitebalance-lock", "false");
+	}
+
+	// Flash
+
+	exynos_param_string_set(exynos_camera, "flash-mode",
+		exynos_camera->config->presets[id].params.flash_mode);
+	exynos_param_string_set(exynos_camera, "flash-mode-values",
+		exynos_camera->config->presets[id].params.flash_mode_values);
+
+	// Exposure
+
+	exynos_param_int_set(exynos_camera, "exposure-compensation",
+		exynos_camera->config->presets[id].params.exposure_compensation);
+	exynos_param_float_set(exynos_camera, "exposure-compensation-step",
+		exynos_camera->config->presets[id].params.exposure_compensation_step);
+	exynos_param_int_set(exynos_camera, "min-exposure-compensation",
+		exynos_camera->config->presets[id].params.min_exposure_compensation);
+	exynos_param_int_set(exynos_camera, "max-exposure-compensation",
+		exynos_camera->config->presets[id].params.max_exposure_compensation);
+
+	// Antibanding
+
+	exynos_param_string_set(exynos_camera, "antibanding",
+		exynos_camera->config->presets[id].params.antibanding);
+	exynos_param_string_set(exynos_camera, "antibanding-values",
+		exynos_camera->config->presets[id].params.antibanding_values);
+
+	// WB
+
+	exynos_param_string_set(exynos_camera, "whitebalance",
+		exynos_camera->config->presets[id].params.whitebalance);
+	exynos_param_string_set(exynos_camera, "whitebalance-values",
+		exynos_camera->config->presets[id].params.whitebalance_values);
+
+	// Scene mode
+
+	exynos_param_string_set(exynos_camera, "scene-mode",
+		exynos_camera->config->presets[id].params.scene_mode);
+	exynos_param_string_set(exynos_camera, "scene-mode-values",
+		exynos_camera->config->presets[id].params.scene_mode_values);
+
+	// Effect
+
+	exynos_param_string_set(exynos_camera, "effect",
+		exynos_camera->config->presets[id].params.effect);
+	exynos_param_string_set(exynos_camera, "effect-values",
+		exynos_camera->config->presets[id].params.effect_values);
+
+	// ISO
+
+	exynos_param_string_set(exynos_camera, "iso",
+		exynos_camera->config->presets[id].params.iso);
+	exynos_param_string_set(exynos_camera, "iso-values",
+		exynos_camera->config->presets[id].params.iso_values);
+
+	// Image stabilization (Anti-shake)
+
+	exynos_param_string_set(exynos_camera, "image-stabilization",
+	exynos_camera->config->presets[id].params.image_stabilization);
+	exynos_param_string_set(exynos_camera, "image-stabilization-values",
+	exynos_camera->config->presets[id].params.image_stabilization_values);
+
+	// Camera
+
+	exynos_param_float_set(exynos_camera, "focal-length",
+		exynos_camera->config->presets[id].focal_length);
+	exynos_param_float_set(exynos_camera, "horizontal-view-angle",
+		exynos_camera->config->presets[id].horizontal_view_angle);
+	exynos_param_float_set(exynos_camera, "vertical-view-angle",
+		exynos_camera->config->presets[id].vertical_view_angle);
+
+	rc = exynos_camera_params_apply(exynos_camera, 1);
+	if (rc < 0) {
+		ALOGE("%s: Unable to apply params", __func__);
+		return -1;
+	}
+
+	return 0;
+}
+
+static int validate_focus_areas(int l, int t, int r, int b, int w) {
+	if (!(l || r || t || b || w)) {
+		// All zeros is a valid area
+		return 0;
+	}
+
+	// If existing, a focus area must be contained between -1000 and 1000,
+	// on both dimensions
+	if (l < -1000 || t < -1000 || r > 1000 || b > 1000) {
+		return -EINVAL;
+	}
+	// No superimposed or reverted edges
+	if (l >= r || t >= b) {
+		return -EINVAL;
+	}
+	// If there's an area defined, weight must be positive and up to 1000
+	if ((l !=0 || r !=0) && (w < 1 || w > 1000)) {
+		return -EINVAL;
+	}
+	return 0;
+}
+
+int exynos_camera_params_apply(struct exynos_camera *exynos_camera, int force)
+{
+	char *recording_hint_string;
+	char *recording_preview_size_string;
+
+	char *preview_size_string;
+	int preview_width = 0;
+	int preview_height = 0;
+	char *preview_format_string;
+	int preview_format;
+	int preview_fps;
+
+	char *picture_size_string;
+	int picture_width = 0;
+	int picture_height = 0;
+	char *picture_format_string;
+	int picture_format;
+
+	int jpeg_thumbnail_width;
+	int jpeg_thumbnail_height;
+	int jpeg_thumbnail_quality;
+	int jpeg_quality;
+
+	char *video_size_string;
+	int recording_width = 0;
+	int recording_height = 0;
+	char *video_frame_format_string;
+	int recording_format;
+	int camera_sensor_mode;
+	int fimc_is_mode = 0;
+
+	char *focus_mode_string;
+	int focus_mode = FOCUS_MODE_DEFAULT;
+	char *focus_areas_string;
+	int focus_left, focus_top, focus_right, focus_bottom, focus_weight;
+	int focus_x;
+	int focus_y;
+
+	char *zoom_supported_string;
+	int zoom, max_zoom;
+
+	char *ae_lock_supported_string;
+	char *ae_lock_string;
+	int ae_lock = 0;
+
+	char *awb_lock_supported_string;
+	char *awb_lock_string;
+	int awb_lock = 0;
+	int aeawb = 0;
+
+	char *flash_mode_string;
+	int flash_mode = 0;
+
+	int exposure_compensation;
+	int min_exposure_compensation;
+	int max_exposure_compensation;
+
+	char *antibanding_string;
+	int antibanding;
+
+	char *whitebalance_string;
+	int whitebalance;
+
+	char *scene_mode_string;
+	int scene_mode;
+
+	char *effect_string;
+	int effect;
+
+	char *iso_string;
+	int iso;
+
+	char *image_stabilization_string;
+	int image_stabilization;
+
+	int w, h;
+	char *k;
+	int rc, i;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	// Preview
+
+	preview_size_string = exynos_param_string_get(exynos_camera, "preview-size");
+	if (preview_size_string != NULL) {
+		sscanf(preview_size_string, "%dx%d", &preview_width, &preview_height);
+
+		if (preview_width < 0 && preview_height < 0) {
+			char reset_preview[128];
+			sprintf(reset_preview, "%dx%d", exynos_camera->preview_width, exynos_camera->preview_height);
+			exynos_param_string_set(exynos_camera, "preview-size",
+				reset_preview);
+			return -EINVAL;
+		}
+		if (preview_width != 0 && preview_width != exynos_camera->preview_width)
+			exynos_camera->preview_width = preview_width;
+		if (preview_height != 0 && preview_height != exynos_camera->preview_height)
+			exynos_camera->preview_height = preview_height;
+	}
+
+	preview_format_string = exynos_param_string_get(exynos_camera, "preview-format");
+	if (preview_format_string != NULL) {
+		if (strcmp(preview_format_string, "yuv420sp") == 0) {
+			preview_format = V4L2_PIX_FMT_NV21;
+		} else if (strcmp(preview_format_string, "yuv420p") == 0) {
+			preview_format = V4L2_PIX_FMT_YUV420;
+		} else if (strcmp(preview_format_string, "rgb565") == 0) {
+			preview_format = V4L2_PIX_FMT_RGB565;
+		} else if (strcmp(preview_format_string, "rgb8888") == 0) {
+			preview_format = V4L2_PIX_FMT_RGB32;
+		} else {
+			ALOGE("%s: Unsupported preview format: %s", __func__, preview_format_string);
+			preview_format = V4L2_PIX_FMT_NV21;
+		}
+
+		if (preview_format != exynos_camera->preview_format)
+			exynos_camera->preview_format = preview_format;
+	}
+
+	preview_fps = exynos_param_int_get(exynos_camera, "preview-frame-rate");
+	if (preview_fps > 0)
+		exynos_camera->preview_fps = preview_fps;
+	else
+		exynos_camera->preview_fps = 0;
+
+	// Picture
+
+	picture_format_string = exynos_param_string_get(exynos_camera, "picture-format");
+	if (picture_format_string != NULL) {
+		if (strcmp(picture_format_string, "jpeg") == 0) {
+			picture_format = V4L2_PIX_FMT_JPEG;
+		} else {
+			ALOGE("%s: Unsupported picture format: %s", __func__, picture_format_string);
+			picture_format = V4L2_PIX_FMT_JPEG;
+		}
+
+		if (picture_format != exynos_camera->picture_format)
+			exynos_camera->picture_format = picture_format;
+	}
+
+	jpeg_thumbnail_width = exynos_param_int_get(exynos_camera, "jpeg-thumbnail-width");
+	if (jpeg_thumbnail_width > 0)
+		exynos_camera->jpeg_thumbnail_width = jpeg_thumbnail_width;
+
+	jpeg_thumbnail_height = exynos_param_int_get(exynos_camera, "jpeg-thumbnail-height");
+	if (jpeg_thumbnail_height > 0)
+		exynos_camera->jpeg_thumbnail_height = jpeg_thumbnail_height;
+
+	jpeg_thumbnail_quality = exynos_param_int_get(exynos_camera, "jpeg-thumbnail-quality");
+	if (jpeg_thumbnail_quality > 0)
+		exynos_camera->jpeg_thumbnail_quality = jpeg_thumbnail_quality;
+
+	jpeg_quality = exynos_param_int_get(exynos_camera, "jpeg-quality");
+	if (jpeg_quality <= 100 && jpeg_quality >= 0 && (jpeg_quality != exynos_camera->jpeg_quality || force)) {
+		exynos_camera->jpeg_quality = jpeg_quality;
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAM_JPEG_QUALITY, jpeg_quality);
+		if (rc < 0)
+			ALOGE("%s: Unable to set jpeg quality", __func__);
+	}
+
+	// Recording
+
+	video_size_string = exynos_param_string_get(exynos_camera, "video-size");
+	if (video_size_string == NULL)
+		video_size_string = exynos_param_string_get(exynos_camera, "preview-size");
+
+	if (video_size_string != NULL) {
+		sscanf(video_size_string, "%dx%d", &recording_width, &recording_height);
+
+		if (recording_width != 0 && recording_width != exynos_camera->recording_width)
+			exynos_camera->recording_width = recording_width;
+		if (recording_height != 0 && recording_height != exynos_camera->recording_height)
+			exynos_camera->recording_height = recording_height;
+	}
+
+	video_frame_format_string = exynos_param_string_get(exynos_camera, "video-frame-format");
+	if (video_frame_format_string != NULL) {
+		if (strcmp(video_frame_format_string, "yuv420sp") == 0) {
+			recording_format = V4L2_PIX_FMT_NV12;
+		} else if (strcmp(video_frame_format_string, "yuv420p") == 0) {
+			recording_format = V4L2_PIX_FMT_YUV420;
+		} else if (strcmp(video_frame_format_string, "rgb565") == 0) {
+			recording_format = V4L2_PIX_FMT_RGB565;
+		} else if (strcmp(video_frame_format_string, "rgb8888") == 0) {
+			recording_format = V4L2_PIX_FMT_RGB32;
+		} else {
+			ALOGE("%s: Unsupported recording format: %s", __func__, video_frame_format_string);
+			recording_format = V4L2_PIX_FMT_NV12;
+		}
+
+		if (recording_format != exynos_camera->recording_format)
+			exynos_camera->recording_format = recording_format;
+	}
+
+	recording_hint_string = exynos_param_string_get(exynos_camera, "recording-hint");
+	if (recording_hint_string != NULL && strcmp(recording_hint_string, "true") == 0) {
+		camera_sensor_mode = SENSOR_MOVIE;
+
+		k = exynos_param_string_get(exynos_camera, "preview-size-values");
+		while (recording_width != 0 && recording_height != 0) {
+			if (k == NULL)
+				break;
+
+			sscanf(k, "%dx%d", &w, &h);
+
+			// Look for same aspect ratio
+			if ((recording_width * h) / recording_height == w) {
+				preview_width = w;
+				preview_height = h;
+				break;
+			}
+
+			k = strchr(k, ',');
+			if (k == NULL)
+				break;
+
+			k++;
+		}
+
+		if (preview_width != 0 && preview_width != exynos_camera->preview_width)
+			exynos_camera->preview_width = preview_width;
+		if (preview_height != 0 && preview_height != exynos_camera->preview_height)
+			exynos_camera->preview_height = preview_height;
+
+		if (exynos_camera->camera_fimc_is)
+			fimc_is_mode = IS_MODE_PREVIEW_VIDEO;
+	} else {
+		camera_sensor_mode = SENSOR_CAMERA;
+
+		if (exynos_camera->camera_fimc_is)
+			fimc_is_mode = IS_MODE_PREVIEW_STILL;
+	}
+
+	// Picture size and Video Snapshot Resolution
+	picture_size_string = exynos_param_string_get(exynos_camera, "picture-size");
+	if (picture_size_string != NULL) {
+		sscanf(picture_size_string, "%dx%d", &picture_width, &picture_height);
+
+		if (camera_sensor_mode == SENSOR_MOVIE) {
+			//Set Video Recording SnapShot Resolutions
+			if (exynos_camera->camera_videosnapshot_resolutions != NULL) {
+				//Back Camera
+				if (!exynos_camera->camera_fimc_is) {
+					for (i = 0; i < exynos_camera->camera_videosnapshot_resolutions_count; i++) {
+						if (exynos_camera->camera_videosnapshot_resolutions[i].video_width == exynos_camera->recording_width && exynos_camera->camera_videosnapshot_resolutions[i].video_height == exynos_camera->recording_height) {
+							picture_width = exynos_camera->camera_videosnapshot_resolutions[i].snapshot_width;
+							picture_height = exynos_camera->camera_videosnapshot_resolutions[i].snapshot_height;
+							break;
+						}
+					}
+				} else {
+					//Front Facing Camera - Use Recording size as Snapshot size
+					picture_width = exynos_camera->recording_width;
+					picture_height = exynos_camera->recording_height;
+				}
+			}
+		}
+
+		if (picture_width != 0 && picture_height != 0 && (picture_width != exynos_camera->picture_width || picture_height != exynos_camera->picture_height)) {
+			exynos_camera->picture_width = picture_width;
+			exynos_camera->picture_height = picture_height;
+
+			if (!exynos_camera->camera_fimc_is) {
+				rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_JPEG_RESOLUTION, (picture_width & 0xffff) << 16 | (picture_height & 0xffff));
+				if (rc < 0)
+					ALOGE("%s: Unable to set jpeg resolution", __func__);
+			}
+		}
+	}
+
+	// Switching modes
+
+	if (camera_sensor_mode != exynos_camera->camera_sensor_mode) {
+		exynos_camera->camera_sensor_mode = camera_sensor_mode;
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_SENSOR_MODE, camera_sensor_mode);
+		if (rc < 0)
+			ALOGE("%s: Unable to set sensor mode", __func__);
+	}
+
+	if (exynos_camera->camera_fimc_is && fimc_is_mode != exynos_camera->fimc_is_mode) {
+		exynos_camera->fimc_is_mode = fimc_is_mode;
+
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_IS_S_FORMAT_SCENARIO, exynos_camera->fimc_is_mode);
+		if (rc < 0)
+			ALOGE("%s: Unable to set FIMC-IS scenario", __func__);
+	}
+
+	// Focus
+
+	focus_areas_string = exynos_param_string_get(exynos_camera, "focus-areas");
+	if (focus_areas_string != NULL) {
+		focus_left = focus_top = focus_right = focus_bottom = focus_weight = 0;
+
+		rc = sscanf(focus_areas_string, "(%d,%d,%d,%d,%d)",
+			&focus_left, &focus_top, &focus_right, &focus_bottom, &focus_weight);
+		if (rc != 5) {
+			ALOGE("%s: Unable to scan focus areas", __func__);
+		} else if (validate_focus_areas(focus_left, focus_top, focus_right, focus_bottom, focus_weight) != 0 || strstr(focus_areas_string, "),(")) {
+			exynos_param_string_set(exynos_camera, "focus-areas",
+				exynos_camera->raw_focus_areas);
+			return -EINVAL;
+		} else if ((focus_left != 0 || focus_right != 0) && (focus_top != 0 || focus_bottom != 0)) {
+                        sprintf(exynos_camera->raw_focus_areas,"%s",focus_areas_string);
+			focus_x = (((focus_left + focus_right) / 2) + 1000) * preview_width / 2000;
+			focus_y =  (((focus_top + focus_bottom) / 2) + 1000) * preview_height / 2000;
+
+			if (focus_x != exynos_camera->focus_x || force) {
+				exynos_camera->focus_x = focus_x;
+
+				rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_OBJECT_POSITION_X, focus_x);
+				if (rc < 0)
+					ALOGE("%s: Unable to set object x position", __func__);
+			}
+
+			if (focus_y != exynos_camera->focus_y || force) {
+				exynos_camera->focus_y = focus_y;
+
+				rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_OBJECT_POSITION_Y, focus_y);
+				if (rc < 0)
+					ALOGE("%s: Unable to set object y position", __func__);
+			}
+
+			/* After taking a picture, focus-areas is reseted by stock camera app to the center of the screen */
+			if (! ( (focus_x == (preview_width / 2)) && (focus_y == (preview_height / 2)) )) {
+				//ALOGV("%s focus_mode changed to %d due to focus-areas='%s'", __func__, focus_mode, focus_areas_string);
+				focus_mode = FOCUS_MODE_TOUCH;
+			}
+		}
+
+	}
+
+	// Zoom
+
+	zoom_supported_string = exynos_param_string_get(exynos_camera, "zoom-supported");
+	if (zoom_supported_string != NULL && strcmp(zoom_supported_string, "true") == 0) {
+		zoom = exynos_param_int_get(exynos_camera, "zoom");
+		max_zoom = exynos_param_int_get(exynos_camera, "max-zoom");
+		if (zoom <= max_zoom && zoom >= 0 && (zoom != exynos_camera->zoom || force)) {
+			exynos_camera->zoom = zoom;
+			rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_ZOOM, zoom);
+			if (rc < 0)
+				ALOGE("%s: Unable to set camera zoom", __func__);
+		} else if (zoom > max_zoom) {
+			exynos_param_int_set(exynos_camera, "zoom", max_zoom);
+			return -EINVAL;
+		}
+
+	}
+
+	// AE lock
+
+	ae_lock_supported_string = exynos_param_string_get(exynos_camera, "auto-exposure-lock-supported");
+	ae_lock_string = exynos_param_string_get(exynos_camera, "auto-exposure-lock");
+	if (ae_lock_supported_string != NULL && ae_lock_string != NULL && strcmp(ae_lock_supported_string, "true") == 0 && strcmp(ae_lock_string, "true") == 0)
+		ae_lock = 1;
+	else
+		ae_lock = 0;
+
+	// AWB lock
+
+	awb_lock_supported_string = exynos_param_string_get(exynos_camera, "auto-whitebalance-lock-supported");
+	awb_lock_string = exynos_param_string_get(exynos_camera, "auto-whitebalance-lock");
+	if (awb_lock_supported_string != NULL && awb_lock_string != NULL && strcmp(awb_lock_supported_string, "true") == 0 && strcmp(awb_lock_string, "true") == 0)
+		awb_lock = 1;
+	else
+		awb_lock = 0;
+
+	// Scene mode
+
+	scene_mode_string = exynos_param_string_get(exynos_camera, "scene-mode");
+	if (scene_mode_string != NULL) {
+		if (strcmp(scene_mode_string, "auto") == 0)
+			scene_mode = SCENE_MODE_NONE;
+		else if (strcmp(scene_mode_string, "portrait") == 0) {
+			scene_mode = SCENE_MODE_PORTRAIT;
+			flash_mode = FLASH_MODE_AUTO;
+		} else if (strcmp(scene_mode_string, "landscape") == 0)
+			scene_mode = SCENE_MODE_LANDSCAPE;
+		else if (strcmp(scene_mode_string, "night") == 0)
+			scene_mode = SCENE_MODE_NIGHTSHOT;
+		else if (strcmp(scene_mode_string, "beach") == 0)
+			scene_mode = SCENE_MODE_BEACH_SNOW;
+		else if (strcmp(scene_mode_string, "snow") == 0)
+			scene_mode = SCENE_MODE_BEACH_SNOW;
+		else if (strcmp(scene_mode_string, "sunset") == 0)
+			scene_mode = SCENE_MODE_SUNSET;
+		else if (strcmp(scene_mode_string, "fireworks") == 0)
+			scene_mode = SCENE_MODE_FIREWORKS;
+		else if (strcmp(scene_mode_string, "action") == 0)
+			scene_mode = SCENE_MODE_SPORTS;
+		else if (strcmp(scene_mode_string, "party") == 0) {
+			scene_mode = SCENE_MODE_PARTY_INDOOR;
+			flash_mode = FLASH_MODE_AUTO;
+		} else if (strcmp(scene_mode_string, "candlelight") == 0)
+			scene_mode = SCENE_MODE_CANDLE_LIGHT;
+		else if (strcmp(scene_mode_string, "dusk-dawn") == 0)
+			scene_mode = SCENE_MODE_DUSK_DAWN;
+		else if (strcmp(scene_mode_string, "fall-color") == 0)
+			scene_mode = SCENE_MODE_FALL_COLOR;
+		else if (strcmp(scene_mode_string, "back-light") == 0)
+			scene_mode = SCENE_MODE_BACK_LIGHT;
+		else if (strcmp(scene_mode_string, "text") == 0)
+			scene_mode = SCENE_MODE_TEXT;
+		else if (strcmp(scene_mode_string, "high-sensitivity") == 0)
+			scene_mode = SCENE_MODE_LOW_LIGHT;
+		else
+			scene_mode = SCENE_MODE_NONE;
+
+		if (scene_mode != exynos_camera->scene_mode || force) {
+			exynos_camera->scene_mode = scene_mode;
+			rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_SCENE_MODE, scene_mode);
+			if (rc < 0)
+				ALOGE("%s: Unable to set scene mode", __func__);
+		}
+
+		if (scene_mode != SCENE_MODE_NONE && !flash_mode && focus_mode == FOCUS_MODE_DEFAULT) {
+			flash_mode = FLASH_MODE_OFF;
+			focus_mode = FOCUS_MODE_AUTO;
+		}
+	}
+
+	// Flash
+
+	flash_mode_string = exynos_param_string_get(exynos_camera, "flash-mode");
+	if (flash_mode_string != NULL) {
+		if (flash_mode == 0) {
+			if (strcmp(flash_mode_string, "off") == 0)
+				flash_mode = FLASH_MODE_OFF;
+			else if (strcmp(flash_mode_string, "auto") == 0)
+				flash_mode = FLASH_MODE_AUTO;
+			else if (strcmp(flash_mode_string, "on") == 0)
+				flash_mode = FLASH_MODE_ON;
+			else if (strcmp(flash_mode_string, "torch") == 0)
+				flash_mode = FLASH_MODE_TORCH;
+			else {
+				exynos_param_string_set(exynos_camera, "flash-mode",
+					exynos_camera->raw_flash_mode);
+				return -EINVAL;
+			}
+		}
+
+		if (flash_mode != exynos_camera->flash_mode || force) {
+			exynos_camera->flash_mode = flash_mode;
+			sprintf(exynos_camera->raw_flash_mode, "%s", flash_mode_string);
+			rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_FLASH_MODE, flash_mode);
+			if (rc < 0)
+				ALOGE("%s:Unable to set flash mode", __func__);
+		}
+	}
+
+	// Lock Auto Exposure and White Balance only when Flash is OFF
+	if ((ae_lock != exynos_camera->ae_lock || awb_lock != exynos_camera->awb_lock || force) &&
+			exynos_camera->flash_mode == FLASH_MODE_OFF) {
+		exynos_camera->ae_lock = ae_lock;
+		exynos_camera->awb_lock = awb_lock;
+		aeawb = (ae_lock ? 0x1 : 0x0) | (awb_lock ? 0x2 : 0x0);
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, aeawb);
+		if (rc < 0)
+			ALOGE("%s: Unable to set AEAWB lock", __func__);
+	}
+
+	focus_mode_string = exynos_param_string_get(exynos_camera, "focus-mode");
+	if (focus_mode_string != NULL) {
+		if (focus_mode == FOCUS_MODE_DEFAULT) {
+			if (strcmp(focus_mode_string, "auto") == 0)
+				focus_mode = FOCUS_MODE_AUTO;
+			else if (strcmp(focus_mode_string, "infinity") == 0)
+				focus_mode = FOCUS_MODE_INFINITY;
+			else if (strcmp(focus_mode_string, "macro") == 0)
+				focus_mode = FOCUS_MODE_MACRO;
+			else if (strcmp(focus_mode_string, "fixed") == 0)
+				focus_mode = FOCUS_MODE_FIXED;
+			else if (strcmp(focus_mode_string, "facedetect") == 0)
+				focus_mode = FOCUS_MODE_FACEDETECT;
+			else if (strcmp(focus_mode_string, "continuous-video") == 0)
+				focus_mode = FOCUS_MODE_CONTINOUS_VIDEO;
+			else if (strcmp(focus_mode_string, "continuous-picture") == 0)
+				focus_mode = FOCUS_MODE_CONTINOUS_PICTURE;
+			else {
+				exynos_param_string_set(exynos_camera, "focus-mode",
+					exynos_camera->raw_focus_mode);
+				return -EINVAL;
+			}
+		}
+
+		if (focus_mode != exynos_camera->focus_mode || force) {
+			rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode);
+			if (rc < 0)
+				ALOGE("%s: Unable to set focus mode", __func__);
+		}
+
+		exynos_camera->focus_mode = focus_mode;
+		sprintf(exynos_camera->raw_focus_mode, "%s", focus_mode_string);
+	}
+
+	// Exposure
+
+	exposure_compensation = exynos_param_int_get(exynos_camera, "exposure-compensation");
+	min_exposure_compensation = exynos_param_int_get(exynos_camera, "min-exposure-compensation");
+	max_exposure_compensation = exynos_param_int_get(exynos_camera, "max-exposure-compensation");
+
+	if (exposure_compensation <= max_exposure_compensation && exposure_compensation >= min_exposure_compensation &&
+		(exposure_compensation != exynos_camera->exposure_compensation || force)) {
+		exynos_camera->exposure_compensation = exposure_compensation;
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_BRIGHTNESS, exposure_compensation);
+		if (rc < 0)
+			ALOGE("%s: Unable to set exposure", __func__);
+	}
+
+	// Antibanding
+
+	antibanding_string = exynos_param_string_get(exynos_camera, "antibanding");
+	if (antibanding_string != NULL) {
+		if (strcmp(antibanding_string, "auto") == 0)
+			antibanding = ANTI_BANDING_AUTO;
+		else if (strcmp(antibanding_string, "50hz") == 0)
+			antibanding = ANTI_BANDING_50HZ;
+		else if (strcmp(antibanding_string, "60hz") == 0)
+			antibanding = ANTI_BANDING_60HZ;
+		else if (strcmp(antibanding_string, "off") == 0)
+			antibanding = ANTI_BANDING_OFF;
+		else
+			antibanding = ANTI_BANDING_AUTO;
+
+		if (antibanding != exynos_camera->antibanding || force) {
+			exynos_camera->antibanding = antibanding;
+			rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_ANTI_BANDING, antibanding);
+			if (rc < 0)
+				ALOGE("%s: Unable to set antibanding", __func__);
+		}
+	}
+
+	// WB
+
+	whitebalance_string = exynos_param_string_get(exynos_camera, "whitebalance");
+	if (whitebalance_string != NULL) {
+		if (strcmp(whitebalance_string, "auto") == 0)
+			whitebalance = WHITE_BALANCE_AUTO;
+		else if (strcmp(whitebalance_string, "incandescent") == 0)
+			whitebalance = WHITE_BALANCE_TUNGSTEN;
+		else if (strcmp(whitebalance_string, "fluorescent") == 0)
+			whitebalance = WHITE_BALANCE_FLUORESCENT;
+		else if (strcmp(whitebalance_string, "daylight") == 0)
+			whitebalance = WHITE_BALANCE_SUNNY;
+		else if (strcmp(whitebalance_string, "cloudy-daylight") == 0)
+			whitebalance = WHITE_BALANCE_CLOUDY;
+		else
+			whitebalance = WHITE_BALANCE_AUTO;
+
+		if (whitebalance != exynos_camera->whitebalance || force) {
+			exynos_camera->whitebalance = whitebalance;
+			rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_WHITE_BALANCE, whitebalance);
+			if (rc < 0)
+				ALOGE("%s: Unable to set whitebalance", __func__);
+		}
+	}
+
+	// Effect
+
+	effect_string = exynos_param_string_get(exynos_camera, "effect");
+	if (effect_string != NULL) {
+		if (strcmp(effect_string, "auto") == 0)
+			effect = IMAGE_EFFECT_NONE;
+		if (strcmp(effect_string, "none") == 0)
+			effect = IMAGE_EFFECT_NONE;
+		else if (strcmp(effect_string, "mono") == 0)
+			effect = IMAGE_EFFECT_BNW;
+		else if (strcmp(effect_string, "negative") == 0)
+			effect = IMAGE_EFFECT_NEGATIVE;
+		else if (strcmp(effect_string, "sepia") == 0)
+			effect = IMAGE_EFFECT_SEPIA;
+		else if (strcmp(effect_string, "aqua") == 0)
+			effect = IMAGE_EFFECT_AQUA;
+		else if (strcmp(effect_string, "solarize") == 0)
+			effect = IMAGE_EFFECT_SOLARIZE;
+		else if (strcmp(effect_string, "posterize") == 0)
+			effect = IMAGE_EFFECT_POSTERIZE;
+		else if (strcmp(effect_string, "washed") == 0)
+			effect = IMAGE_EFFECT_WASHED;
+		else if (strcmp(effect_string, "sketch") == 0)
+			effect = IMAGE_EFFECT_SKETCH;
+		else if (strcmp(effect_string, "vintage-warm") == 0)
+			effect = IMAGE_EFFECT_VINTAGE_WARM;
+		else if (strcmp(effect_string, "vintage-cold") == 0)
+			effect = IMAGE_EFFECT_VINTAGE_COLD;
+		else if (strcmp(effect_string, "point-blue") == 0)
+			effect = IMAGE_EFFECT_POINT_BLUE;
+		else if (strcmp(effect_string, "point-red-yellow") == 0)
+			effect = IMAGE_EFFECT_POINT_RED_YELLOW;
+		else if (strcmp(effect_string, "point-green") == 0)
+			effect = IMAGE_EFFECT_POINT_GREEN;
+		else
+			effect = IMAGE_EFFECT_NONE;
+
+		if (effect != exynos_camera->effect || force) {
+			exynos_camera->effect = effect;
+			rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EFFECT, effect);
+			if (rc < 0)
+				ALOGE("%s: Unable to set effect", __func__);
+		}
+	}
+
+	// ISO
+
+	iso_string = exynos_param_string_get(exynos_camera, "iso");
+	if (iso_string != NULL) {
+		if (strcmp(iso_string, "auto") == 0)
+			iso = ISO_AUTO;
+		else if (strcmp(iso_string, "ISO50") == 0)
+			iso = ISO_50;
+		else if (strcmp(iso_string, "ISO100") == 0)
+			iso = ISO_100;
+		else if (strcmp(iso_string, "ISO200") == 0)
+			iso = ISO_200;
+		else if (strcmp(iso_string, "ISO400") == 0)
+			iso = ISO_400;
+		else if (strcmp(iso_string, "ISO800") == 0)
+			iso = ISO_800;
+		else
+			iso = ISO_AUTO;
+
+		if (iso != exynos_camera->iso || force) {
+			exynos_camera->iso = iso;
+			rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_ISO, iso);
+			if (rc < 0)
+				ALOGE("%s: Unable to set iso", __func__);
+		}
+	}
+
+	// Image stabilization (Anti-shake)
+
+	image_stabilization_string = exynos_param_string_get(exynos_camera, "image-stabilization");
+	if (image_stabilization_string != NULL) {
+		if (strcmp(image_stabilization_string, "on") == 0)
+			image_stabilization = ANTI_SHAKE_STILL_ON;
+		else
+			image_stabilization = ANTI_SHAKE_OFF;
+
+		if (image_stabilization != exynos_camera->image_stabilization || force) {
+			exynos_camera->image_stabilization = image_stabilization;
+			rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_ANTI_SHAKE, image_stabilization);
+			if (rc < 0)
+				ALOGE("%s: Unable to set image-stabilization", __func__);
+		}
+	}
+	ALOGD("%s: Preview size: %dx%d, picture size: %dx%d, recording size: %dx%d", __func__, preview_width, preview_height, picture_width, picture_height, recording_width, recording_height);
+
+	return 0;
+}
+
+// Capture
+
+int s5c73m3_interleaved_decode(struct exynos_camera *exynos_camera, void *data, int size,
+	void *yuv_data, int *yuv_size, int yuv_width, int yuv_height,
+	void *jpeg_data, int *jpeg_size, int *decoded, int *auto_focus_result,
+	struct exynos_exif *exif)
+{
+	exif_attribute_t *attributes;
+	camera_face_t caface[exynos_camera->max_detected_faces];
+	int yuv_length;
+	int jpeg_length;
+	int num_detected_faces;
+	int face;
+	unsigned char *yuv_p;
+	unsigned char *jpeg_p;
+	unsigned char *data_p;
+	unsigned int *offset_p;
+	unsigned int pointers_array_offset;
+	unsigned int pointers_array_size;
+	unsigned int interleaved_size;
+	unsigned char s5c73m3_auto_focus_result;
+	unsigned int yuv_offset_last;
+	unsigned int yuv_offset;
+	unsigned int yuv_line_size;
+	unsigned short *jpeg_start_p;
+	int gap;
+	unsigned int i;
+
+	if (data == NULL || size <= 0 || yuv_data == NULL || yuv_size == NULL || yuv_width <= 0 || yuv_height <= 0 || jpeg_data == NULL || jpeg_size == NULL || decoded == NULL || auto_focus_result == NULL)
+		return -EINVAL;
+
+	yuv_length = 0;
+	jpeg_length = 0;
+
+	data_p = (unsigned char *) data;
+	data_p += size - 0x1000; // End of the first plane (interleaved buffer)
+	data_p += 4046; // Experimental offset for decoded
+
+	*decoded = (int) *data_p;
+
+	data_p = (unsigned char *) data;
+	data_p += size - 0x1000; // End of the first plane (interleaved buffer)
+	data_p += 50; // Experimental offset for auto-focus result
+
+	*auto_focus_result = (int) *data_p;
+
+	data_p = (unsigned char *) data;
+	data_p += size - 0x1000; // End of the first plane (interleaved buffer)
+	data_p += 4084; // Experimental offset for interleaved size
+
+	// Read the pointers array offset
+	offset_p = (unsigned int *) data_p;
+	pointers_array_offset = BIG2LITTLE_ENDIAN(*offset_p);
+	interleaved_size = pointers_array_offset;
+
+	// Read the pointers array size, it should be 4 * yuv_height
+	data_p += sizeof(pointers_array_offset);
+	offset_p = (unsigned int *) data_p;
+	pointers_array_size = BIG2LITTLE_ENDIAN(*offset_p);
+
+	// FaceDetection Information
+	data_p = (unsigned char *) data;
+	data_p += size - 0x1000; // End of the first plane (interleaved buffer)
+	data_p += 108; //Number of Faces Detected
+
+	num_detected_faces = (int) *data_p;
+	data_p += 2; //Start of Face Detection Info
+
+	exynos_camera->mFaceData.faces = caface;
+	if (num_detected_faces > 0 && num_detected_faces < exynos_camera->max_detected_faces)
+	{
+		for (face = 0; face < num_detected_faces; face++) {
+			exynos_camera->mFaceData.faces[face].rect[0] = (short)(data_p[1] << 8) + data_p[0];
+			data_p += 2;
+			exynos_camera->mFaceData.faces[face].rect[1] = (short)(data_p[1] << 8) + data_p[0];
+			data_p += 2;
+			exynos_camera->mFaceData.faces[face].rect[2] = (short)(data_p[1] << 8) + data_p[0];
+			data_p += 2;
+			exynos_camera->mFaceData.faces[face].rect[3] = (short)(data_p[1] << 8) + data_p[0];
+			data_p += 2;
+			exynos_camera->mFaceData.faces[face].score = (short)(data_p[1] << 8) + data_p[0];
+			data_p += 2;
+			exynos_camera->mFaceData.faces[face].id = (short)(data_p[1] << 8) + data_p[0];
+			data_p += 2;
+		}
+	}
+	exynos_camera->mFaceData.number_of_faces = num_detected_faces;
+
+	if (!*decoded)
+		return 0;
+
+	attributes = &exif->attributes;
+
+	//Extract the EXIF from the Metadata
+	//Flash
+	data_p = (unsigned char *) data;
+	data_p += size - 0x1000; // End of the first plane (interleaved buffer)
+	data_p += 4; // EXIF Flash Offset
+	attributes->flash = (int) data_p[0];
+
+	//ISO
+	data_p += 4; // EXIF ISO Offset
+	attributes->iso_speed_rating = (data_p[1] << 8) + data_p[0];
+
+	//Exposure
+	data_p += 4; // EXIF Exposure Offset
+	attributes->brightness.num = (int) data_p[0];
+
+	//Exposure Bias
+	data_p += 4; // EXIF Exposure Bias Offset
+	attributes->exposure_bias.num = (data_p[1] << 8) + data_p[0];
+
+	//Exposure Time
+	data_p += 8; // EXIF Exposure Time Offset
+	attributes->exposure_time.den = (data_p[1] << 8) + data_p[0];
+
+
+	ALOGD("%s: Interleaved pointers array is at offset 0x%x, 0x%x bytes long\n", __func__, pointers_array_offset, pointers_array_size);
+
+	if ((int) pointers_array_offset > size || (int) pointers_array_size > size || (int) pointers_array_size < yuv_height * (int) sizeof(unsigned int)) {
+		ALOGE("%s: Invalid informations", __func__);
+		return -1;
+	}
+
+	data_p = (unsigned char *) data;
+	data_p += pointers_array_offset;
+	yuv_p = (unsigned char *) yuv_data;
+	jpeg_p = (unsigned char *) jpeg_data;
+	jpeg_start_p = NULL;
+
+	yuv_line_size = yuv_width * 2;
+	yuv_offset_last = 0;
+	yuv_offset = 0;
+	i = 0;
+
+	while (i < pointers_array_size) {
+		offset_p = (unsigned int *) data_p;
+		yuv_offset = BIG2LITTLE_ENDIAN(*offset_p);
+
+		if (yuv_offset > size - yuv_line_size)
+			return -1;
+
+		gap = yuv_offset - yuv_offset_last - yuv_line_size;
+
+		if (gap > 0) {
+			data_p = (unsigned char *) data + yuv_offset_last + yuv_line_size;
+
+			if (jpeg_start_p == NULL) {
+				jpeg_start_p = (unsigned short *) data_p;
+				if (*jpeg_start_p != 0xd8ff) {
+					ALOGE("%s: Invalid jpeg start", __func__);
+					return -1;
+				}
+			}
+
+			memcpy(jpeg_p, data_p, gap);
+			jpeg_p += gap;
+			jpeg_length += gap;
+		}
+
+		yuv_offset_last = yuv_offset;
+
+		data_p = (unsigned char *) data + yuv_offset;
+		memcpy(yuv_p, data_p, yuv_line_size);
+		yuv_p += yuv_line_size;
+		yuv_length += yuv_line_size;
+
+		data_p = (unsigned char *) offset_p;
+		data_p += sizeof(yuv_offset);
+		i += sizeof(yuv_offset);
+	}
+
+	gap = interleaved_size - yuv_offset_last - yuv_line_size;
+
+	if (gap > 0) {
+		data_p = (unsigned char *) data + yuv_offset_last + yuv_line_size;
+
+		memcpy(jpeg_p, data_p, gap);
+		jpeg_p += gap;
+		jpeg_length += gap;
+	}
+
+	*yuv_size = yuv_length;
+	*jpeg_size = jpeg_length;
+
+	return 0;
+}
+
+int exynos_camera_capture(struct exynos_camera *exynos_camera)
+{
+	struct exynos_camera_buffer *buffers = NULL;
+	struct exynos_camera_buffer *buffer;
+	int width, height, format;
+	int yuv_length, jpeg_length;
+	int jpeg_offset, jpeg_size;
+	int jpeg_thumbnail_offset, jpeg_thumbnail_size;
+	int buffers_count;
+	int buffer_length;
+	int auto_focus_result;
+	int current_af;
+	int decoded;
+	int busy;
+	void *pointer;
+	void *picture_yuv_pointer = NULL;
+	int address;
+	int offset;
+	int index;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	width = exynos_camera->capture_width;
+	height = exynos_camera->capture_height;
+	format = exynos_camera->capture_format;
+
+	buffers_count = exynos_camera->capture_buffers_count;
+	buffer_length = exynos_camera->capture_buffer_length;
+
+	// V4L2
+
+	index = exynos_v4l2_dqbuf_cap(exynos_camera, 0);
+	if (index < 0 || index >= buffers_count) {
+		rc = exynos_v4l2_poll(exynos_camera, 0);
+		if (rc < 0) {
+			ALOGE("%s Unable to poll", __func__);
+			goto error;
+		} else if (rc == 0) {
+			// Timeout
+			rc = 0;
+			goto complete;
+		}
+
+		index = exynos_v4l2_dqbuf_cap(exynos_camera, 0);
+		if (index < 0 || index >= buffers_count) {
+			ALOGE("%s: Unable to dequeue buffer", __func__);
+			goto error;
+		}
+	}
+
+	exynos_camera->capture_memory_index = index;
+
+	address = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_PADDR_Y, index);
+	if (address == 0 || address == (int) 0xffffffff) {
+		ALOGE("%s: Unable to get address", __func__);
+		goto error;
+	}
+
+	offset = address - exynos_camera->capture_memory_address;
+	if (offset != index * buffer_length)
+		ALOGE("%s: Inconsistent memory offset (0x%x/0x%x)", __func__, offset, index * buffer_length);
+
+	pointer = (void *) ((unsigned char *) exynos_camera->capture_memory->data + offset);
+
+	// Buffers
+
+	if (!exynos_camera->camera_fimc_is) {
+		yuv_length = jpeg_length = 0;
+		auto_focus_result = decoded = 0;
+
+		rc = s5c73m3_interleaved_decode(exynos_camera, pointer, buffer_length, exynos_camera->capture_yuv_buffer, &yuv_length, width, height, exynos_camera->capture_jpeg_buffer, &jpeg_length, &decoded, &auto_focus_result, &exynos_camera->exif);
+		if (rc < 0) {
+			ALOGE("%s: Unable to decode S5C73M3 interleaved", __func__);
+			goto error;
+		}
+
+		// AutoFocus
+		switch (auto_focus_result) {
+			case S5C73M3_CAF_STATUS_FOCUSING:
+			case S5C73M3_CAF_STATUS_FIND_SEARCHING_DIR:
+			case S5C73M3_AF_STATUS_FOCUSING:
+				current_af = CAMERA_AF_STATUS_IN_PROGRESS;
+				break;
+			case S5C73M3_CAF_STATUS_FOCUSED:
+			case S5C73M3_AF_STATUS_FOCUSED:
+				current_af = CAMERA_AF_STATUS_SUCCESS;
+				break;
+			case S5C73M3_CAF_STATUS_UNFOCUSED:
+			case S5C73M3_AF_STATUS_UNFOCUSED:
+				current_af = CAMERA_AF_STATUS_FAIL;
+				break;
+			case S5C73M3_AF_STATUS_INVALID:
+			default:
+				current_af = CAMERA_AF_STATUS_RESTART;
+		}
+
+		if (exynos_camera->auto_focus_enabled) {
+			rc = exynos_camera_auto_focus(exynos_camera, current_af);
+			if (rc < 0) {
+				ALOGE("%s: Unable to auto focus", __func__);
+				goto error;
+			}
+		}
+
+		// CAF
+		switch (auto_focus_result) {
+			case S5C73M3_CAF_STATUS_FOCUSING:
+			case S5C73M3_CAF_STATUS_FIND_SEARCHING_DIR:
+				current_af = CAMERA_AF_STATUS_IN_PROGRESS;
+				break;
+			case S5C73M3_CAF_STATUS_FOCUSED:
+				current_af = CAMERA_AF_STATUS_SUCCESS;
+				break;
+			case S5C73M3_CAF_STATUS_UNFOCUSED:
+			default:
+				current_af = CAMERA_AF_STATUS_RESTART;
+		}
+
+		rc = exynos_camera_continuous_auto_focus(exynos_camera, current_af);
+		if (rc < 0) {
+			ALOGE("%s: Unable to continuous auto focus", __func__);
+			goto error;
+		}
+
+		if (!decoded) {
+			buffers_count = 1;
+			buffers = (struct exynos_camera_buffer *) calloc(buffers_count, sizeof(struct exynos_camera_buffer));
+
+			buffer = buffers;
+
+			buffer->pointer = pointer;
+			buffer->address = address;
+			buffer->length = buffer_length;
+			buffer->width = width;
+			buffer->height = height;
+			buffer->format = V4L2_PIX_FMT_UYVY;
+		} else {
+			buffers_count = 2;
+			buffers = (struct exynos_camera_buffer *) calloc(buffers_count, sizeof(struct exynos_camera_buffer));
+
+			buffer = buffers;
+
+			memcpy(pointer, exynos_camera->capture_yuv_buffer, yuv_length);
+
+			buffer->pointer = pointer;
+			buffer->address = address;
+			buffer->length = yuv_length;
+			buffer->width = width;
+			buffer->height = height;
+			buffer->format = V4L2_PIX_FMT_UYVY;
+
+			memcpy(&exynos_camera->picture_yuv_buffer, buffer, sizeof(struct exynos_camera_buffer));
+
+			pointer = (void *) ((unsigned char *) pointer + yuv_length);
+			address += yuv_length;
+			buffer = (struct exynos_camera_buffer *) ((unsigned char *) buffer + sizeof(struct exynos_camera_buffer));
+
+			memcpy(pointer, exynos_camera->capture_jpeg_buffer, jpeg_length);
+
+			buffer->pointer = pointer;
+			buffer->address = address;
+			buffer->length = jpeg_length;
+			buffer->width = exynos_camera->picture_width;
+			buffer->height = exynos_camera->picture_height;
+			buffer->format = exynos_camera->picture_format;
+
+			memcpy(&exynos_camera->picture_jpeg_buffer, buffer, sizeof(struct exynos_camera_buffer));
+
+			exynos_camera_picture_thread_start(exynos_camera);
+
+			memcpy(buffer, &exynos_camera->picture_yuv_buffer, sizeof(struct exynos_camera_buffer));
+		}
+	} else {
+		buffers_count = 1;
+		buffers = (struct exynos_camera_buffer *) calloc(buffers_count, sizeof(struct exynos_camera_buffer));
+
+		buffer = buffers;
+
+		buffer->pointer = pointer;
+		buffer->address = address;
+		buffer->length = buffer_length;
+		buffer->width = width;
+		buffer->height = height;
+		buffer->format = format;
+
+		if (exynos_camera->picture_enabled) {
+			memcpy(&exynos_camera->picture_yuv_buffer, buffer, sizeof(struct exynos_camera_buffer));
+			exynos_camera_picture_thread_start(exynos_camera);
+		}
+	}
+
+	// Preview
+	if (exynos_camera->preview_enabled) {
+		memcpy(&exynos_camera->preview_buffer, buffer, sizeof(struct exynos_camera_buffer));
+		if (!exynos_camera->preview_output_enabled) {
+			rc = exynos_camera_preview_output_start(exynos_camera);
+			if (rc < 0) {
+				ALOGE("%s: Unable to start Preview Output", __func__);
+				goto error;
+			}
+		}
+		rc = exynos_camera_preview(exynos_camera);
+		if (rc < 0) {
+			ALOGE("%s: Unable to process Camera Preview", __func__);
+			goto error;
+		}
+	}
+
+	//Recording
+	if (exynos_camera->recording_enabled) {
+		if (exynos_camera->recording_output_enabled) {
+			memcpy(&exynos_camera->recording_buffer, buffer, sizeof(struct exynos_camera_buffer));
+
+			exynos_camera->recording_memory_index = index;
+
+			rc = exynos_camera_recording(exynos_camera);
+			if (rc < 0) {
+				ALOGE("%s: Unable to process Camera Recording", __func__);
+				goto error;
+			}
+		} else {
+			memcpy(&exynos_camera->recording_buffer, buffer, sizeof(struct exynos_camera_buffer));
+
+			rc = exynos_camera_recording_output_start(exynos_camera);
+			if (rc < 0) {
+				ALOGE("%s: Unable to start recording output", __func__);
+				goto error;
+			}
+
+		}
+	} else {
+		if (exynos_camera->recording_output_enabled)
+			exynos_camera_recording_output_stop(exynos_camera);
+	}
+
+	rc = exynos_v4l2_qbuf_cap(exynos_camera, 0, index);
+	if (rc < 0) {
+		ALOGE("%s: Unable to queue buffer", __func__);
+		goto error;
+	}
+
+	rc = 0;
+	goto complete;
+
+error:
+	rc = -1;
+
+complete:
+	if (buffers != NULL)
+		free(buffers);
+
+	return rc;
+}
+
+void *exynos_camera_capture_thread(void *data)
+{
+	struct exynos_camera *exynos_camera;
+	int rc;
+
+	if (data == NULL)
+		return NULL;
+
+	exynos_camera = (struct exynos_camera *) data;
+
+	ALOGE("%s: Starting thread", __func__);
+	exynos_camera->capture_thread_running = 1;
+
+	while (exynos_camera->capture_thread_enabled) {
+		pthread_mutex_lock(&exynos_camera->capture_lock_mutex);
+
+		while (exynos_camera->capture_enabled) {
+			pthread_mutex_lock(&exynos_camera->capture_mutex);
+
+			if (!exynos_camera->capture_enabled) {
+				pthread_mutex_unlock(&exynos_camera->capture_mutex);
+				break;
+			}
+
+			rc = exynos_camera_capture(exynos_camera);
+			if (rc < 0) {
+				ALOGE("%s: Unable to capture", __func__);
+				pthread_mutex_unlock(&exynos_camera->capture_mutex);
+				break;
+			}
+
+			pthread_mutex_unlock(&exynos_camera->capture_mutex);
+
+			// Wait a bit to let others lock the mutex if they need to
+			usleep(10);
+		}
+	}
+
+	exynos_camera->capture_thread_running = 0;
+	ALOGE("%s: Exiting thread", __func__);
+
+	return NULL;
+}
+
+void exynos_camera_picture_thread_start(struct exynos_camera *exynos_camera)
+{
+	int rc;
+
+	if (exynos_camera->picture_running)
+		return;
+
+	exynos_camera->picture_completed = 0;
+
+	pthread_attr_t thread_attr;
+	pthread_attr_init(&thread_attr);
+	pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
+
+	rc = pthread_create(&exynos_camera->picture_thread, &thread_attr, exynos_camera_picture, (void *) exynos_camera);
+	if (rc < 0)
+		ALOGE("%s: Unable to create thread", __func__);
+
+	exynos_camera->picture_running = 1;
+
+	return;
+}
+
+int exynos_camera_capture_thread_start(struct exynos_camera *exynos_camera)
+{
+	pthread_attr_t thread_attr;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	ALOGD("%s()", __func__);
+
+	if (exynos_camera->capture_thread_enabled) {
+		ALOGE("Capture thread was already started!");
+		return -1;
+	}
+
+	pthread_mutex_init(&exynos_camera->capture_mutex, NULL);
+	pthread_mutex_init(&exynos_camera->capture_lock_mutex, NULL);
+
+	// Initial lock
+	pthread_mutex_lock(&exynos_camera->capture_lock_mutex);
+
+	pthread_attr_init(&thread_attr);
+	pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
+
+	exynos_camera->capture_thread_enabled = 1;
+
+	rc = pthread_create(&exynos_camera->capture_thread, &thread_attr, exynos_camera_capture_thread, (void *) exynos_camera);
+	if (rc < 0) {
+		ALOGE("%s: Unable to create thread", __func__);
+		goto error;
+	}
+
+	rc = 0;
+	goto complete;
+
+error:
+	pthread_mutex_destroy(&exynos_camera->capture_mutex);
+	pthread_mutex_destroy(&exynos_camera->capture_lock_mutex);
+
+	rc = -1;
+
+complete:
+	return rc;
+}
+
+void exynos_camera_capture_thread_stop(struct exynos_camera *exynos_camera)
+{
+	int i;
+
+	if (exynos_camera == NULL)
+		return;
+
+	ALOGD("%s()", __func__);
+
+	if (!exynos_camera->capture_thread_enabled) {
+		ALOGE("Capture thread was already stopped!");
+		return;
+	}
+
+	exynos_camera->capture_enabled = 0;
+	exynos_camera->capture_thread_enabled = 0;
+
+	pthread_mutex_unlock(&exynos_camera->capture_lock_mutex);
+
+	// Wait for the thread to end
+	i = 0;
+	while (exynos_camera->capture_thread_running) {
+		if (i++ > 10000) {
+			ALOGE("Capture thread is taking too long to end, something is going wrong");
+			break;
+		}
+		usleep(100);
+	}
+
+	if (exynos_camera->capture_enabled) {
+		pthread_mutex_lock(&exynos_camera->capture_mutex);
+		exynos_camera_capture_stop(exynos_camera);
+		pthread_mutex_unlock(&exynos_camera->capture_mutex);
+	}
+
+	pthread_mutex_destroy(&exynos_camera->capture_mutex);
+	pthread_mutex_destroy(&exynos_camera->capture_lock_mutex);
+}
+
+int exynos_camera_capture_start(struct exynos_camera *exynos_camera)
+{
+	struct v4l2_streamparm fps_param;
+	int width, height, format;
+	int mbus_width, mbus_height;
+	int buffers_count, buffer_length;
+	camera_memory_t *memory = NULL;
+	int value;
+	int fd;
+	int rc;
+	int i;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	ALOGD("%s()", __func__);
+
+	if (exynos_camera->capture_enabled) {
+		ALOGE("Capture was already started!");
+		return -1;
+	}
+
+	width = exynos_camera->capture_width;
+	height = exynos_camera->capture_height;
+	format = exynos_camera->capture_format;
+
+	// V4L2
+
+	if (!exynos_camera->camera_fimc_is) {
+		ALOGD("Enabling hybrid capture");
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_HYBRID, 1);
+		if (rc < 0) {
+			ALOGE("%s: Unable to set hybrid", __func__);
+			goto error;
+		}
+	} else {
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_IS_S_FORMAT_SCENARIO, exynos_camera->fimc_is_mode);
+		if (rc < 0) {
+			ALOGE("%s: Unable to set FIMC-IS scenario", __func__);
+			goto error;
+		}
+	}
+
+	rc = exynos_v4l2_enum_fmt_cap(exynos_camera, 0, format);
+	if (rc < 0) {
+		ALOGE("%s: Unable to enumerate formats", __func__);
+		goto error;
+	}
+
+	mbus_width = width;
+	mbus_height = height;
+
+	if (exynos_camera->camera_mbus_resolutions != NULL) {
+		for (i = 0; i < exynos_camera->camera_mbus_resolutions_count; i++) {
+			if (exynos_camera->camera_mbus_resolutions[i].width == width && exynos_camera->camera_mbus_resolutions[i].height == height) {
+				mbus_width = exynos_camera->camera_mbus_resolutions[i].mbus_width;
+				mbus_height = exynos_camera->camera_mbus_resolutions[i].mbus_height;
+				break;
+			}
+		}
+	}
+
+	if (exynos_camera->camera_fimc_is) {
+		// Set MBUS width/height/format
+		rc = exynos_v4l2_s_fmt_pix(exynos_camera, 0, V4L2_BUF_TYPE_PRIVATE, mbus_width, mbus_height, format, exynos_camera->fimc_is_mode, V4L2_PIX_FMT_MODE_PREVIEW);
+		if (rc < 0) {
+			ALOGE("%s: Unable to set MBUS capture pixel format", __func__);
+			goto error;
+		}
+	}
+
+	rc = exynos_v4l2_s_fmt_pix_cap(exynos_camera, 0, width, height, format, V4L2_PIX_FMT_MODE_PREVIEW);
+	if (rc < 0) {
+		ALOGE("%s: Unable to set capture pixel format", __func__);
+		goto error;
+	}
+
+	if (!exynos_camera->camera_fimc_is) {
+		// Set MBUS width/height/format
+		rc = exynos_v4l2_s_fmt_pix(exynos_camera, 0, V4L2_BUF_TYPE_PRIVATE, mbus_width, mbus_height, format, V4L2_FIELD_NONE, V4L2_PIX_FMT_MODE_PREVIEW);
+		if (rc < 0) {
+			ALOGE("%s: Unable to set MBUS capture pixel format", __func__);
+			goto error;
+		}
+
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CACHEABLE, 0);
+		if (rc < 0) {
+			ALOGE("%s: Unable to set cacheable", __func__);
+			goto error;
+		}
+
+		// This must be set to 1 for interleaved data decoding
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_EMBEDDEDDATA_ENABLE, 1);
+		if (rc < 0) {
+			ALOGE("%s: Unable to set embdedded data enable", __func__);
+			goto error;
+		}
+	} else {
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CACHEABLE, 1);
+		if (rc < 0) {
+			ALOGE("%s: Unable to set cacheable", __func__);
+			goto error;
+		}
+
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_IS_S_SCENARIO_MODE, exynos_camera->fimc_is_mode);
+		if (rc < 0) {
+			ALOGE("%s: Unable to set FIMC-IS scenario mode", __func__);
+			goto error;
+		}
+	}
+
+	// Let's assume FIMC0 has memory available through mmap
+
+	for (i = EXYNOS_CAMERA_CAPTURE_BUFFERS_COUNT; i > 0; i--) {
+		rc = exynos_v4l2_reqbufs_cap(exynos_camera, 0, i);
+		if (rc >= 0)
+			break;
+	}
+
+	if (rc < 0) {
+		ALOGE("%s: Unable to request buffers", __func__);
+		goto error;
+	}
+
+	buffers_count = rc;
+	ALOGD("Found %d buffers available for capture!", buffers_count);
+
+	memset(&fps_param, 0, sizeof(fps_param));
+	fps_param.parm.capture.timeperframe.numerator = 1;
+	fps_param.parm.capture.timeperframe.denominator = exynos_camera->preview_fps;
+
+	rc = exynos_v4l2_s_parm_cap(exynos_camera, 0, &fps_param);
+	if (rc < 0) {
+		ALOGE("%s: Unable to set fps", __func__);
+		goto error;
+	}
+
+	for (i = 0; i < buffers_count; i++) {
+		rc = exynos_v4l2_querybuf_cap(exynos_camera, 0, i);
+		if (rc < 0) {
+			ALOGE("%s: Unable to query buffers", __func__);
+			goto error;
+		}
+	}
+
+	buffer_length = rc;
+
+	value = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_PADDR_Y, 0);
+	if (value == 0 || value == (int) 0xffffffff) {
+		ALOGE("%s: Unable to get address", __func__);
+		goto error;
+	}
+
+	exynos_camera->capture_memory_address = value;
+
+	if (EXYNOS_CAMERA_CALLBACK_DEFINED(request_memory)) {
+		fd = exynos_v4l2_fd(exynos_camera, 0);
+		if (fd < 0) {
+			ALOGE("%s: Unable to get v4l2 fd for id %d", __func__, 0);
+			goto error;
+		}
+
+		exynos_camera->capture_memory = NULL;
+
+		memory = exynos_camera->callbacks.request_memory(fd, buffer_length, buffers_count, exynos_camera->callbacks.user);
+		if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) {
+			ALOGE("%s: Unable to request memory", __func__);
+			goto error;
+		}
+
+		exynos_camera->capture_memory = memory;
+
+		memory = exynos_camera->callbacks.request_memory(-1, 1, 1, exynos_camera->callbacks.user);
+
+		exynos_camera->face_data = memory;
+	} else {
+		ALOGE("%s: No memory request function!", __func__);
+		goto error;
+	}
+
+	if (!exynos_camera->camera_fimc_is) {
+		exynos_camera->capture_yuv_buffer = malloc(buffer_length);
+		exynos_camera->capture_jpeg_buffer = malloc(buffer_length);
+	}
+
+	// Start EXIF
+	memset(&exynos_camera->exif, 0, sizeof(struct exynos_exif));
+	exynos_exif_start(exynos_camera, &exynos_camera->exif);
+
+	for (i = 0; i < buffers_count; i++) {
+		rc = exynos_v4l2_qbuf_cap(exynos_camera, 0, i);
+		if (rc < 0) {
+			ALOGE("%s: Unable to queue buffer", __func__);
+			goto error;
+		}
+	}
+
+	exynos_camera->capture_buffers_count = buffers_count;
+	exynos_camera->capture_buffer_length = buffer_length;
+
+	rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_ROTATION,
+		exynos_camera->camera_rotation);
+	if (rc < 0) {
+		ALOGE("%s: Unable to set rotation", __func__);
+		goto error;
+	}
+
+	rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_HFLIP,
+		exynos_camera->camera_hflip);
+	if (rc < 0) {
+		ALOGE("%s: Unable to set hflip", __func__);
+		goto error;
+	}
+
+	rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_VFLIP,
+		exynos_camera->camera_vflip);
+	if (rc < 0) {
+		ALOGE("%s: Unable to set vflip", __func__);
+		goto error;
+	}
+
+	rc = exynos_v4l2_streamon_cap(exynos_camera, 0);
+	if (rc < 0) {
+		ALOGE("%s: Unable to start stream", __func__);
+		goto error;
+	}
+
+	// Few Scene Modes require to be set after stream on
+	rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_SCENE_MODE, exynos_camera->scene_mode);
+	if (rc < 0) {
+		ALOGE("%s: Unable to set scene mode", __func__);
+		goto error;
+	}
+
+	if (exynos_camera->camera_fimc_is) {
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_IS_CMD_FD, IS_FD_COMMAND_START);
+		if (rc < 0) {
+			ALOGE("%s: Unable to start face detection", __func__);
+			goto error;
+		}
+	}
+
+	exynos_camera->capture_enabled = 1;
+	pthread_mutex_unlock(&exynos_camera->capture_lock_mutex);
+
+	rc = 0;
+	goto complete;
+
+error:
+	if (exynos_camera->face_data != NULL && exynos_camera->face_data->release != NULL) {
+		exynos_camera->face_data->release(exynos_camera->face_data);
+		exynos_camera->face_data = NULL;
+	}
+	if (exynos_camera->capture_memory != NULL && exynos_camera->capture_memory->release != NULL) {
+		exynos_camera->capture_memory->release(exynos_camera->capture_memory);
+		exynos_camera->capture_memory = NULL;
+	}
+
+	rc = -1;
+
+complete:
+	return rc;
+}
+
+void exynos_camera_capture_stop(struct exynos_camera *exynos_camera)
+{
+	int rc;
+	int i;
+
+	if (exynos_camera == NULL)
+		return;
+
+	ALOGD("%s()", __func__);
+
+	if (!exynos_camera->capture_enabled) {
+		ALOGE("Capture was already stopped!");
+		return;
+	}
+
+	if (!exynos_camera->camera_fimc_is) {
+		ALOGD("Disabling hybrid capture");
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_HYBRID, 0);
+		if (rc < 0)
+			ALOGE("%s: Unable to set hybrid", __func__);
+	}
+
+	if (exynos_camera->camera_fimc_is) {
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_IS_CMD_FD, IS_FD_COMMAND_STOP);
+		if (rc < 0)
+			ALOGE("%s: Unable to stop face detection", __func__);
+	}
+
+	rc = exynos_v4l2_streamoff_cap(exynos_camera, 0);
+	if (rc < 0) {
+		ALOGE("%s: Unable to stop stream", __func__);
+	}
+
+	if (exynos_camera->face_data != NULL && exynos_camera->face_data->release != NULL) {
+		exynos_camera->face_data->release(exynos_camera->face_data);
+		exynos_camera->face_data = NULL;
+	}
+
+	if (exynos_camera->capture_memory != NULL && exynos_camera->capture_memory->release != NULL) {
+		exynos_camera->capture_memory->release(exynos_camera->capture_memory);
+		exynos_camera->capture_memory = NULL;
+	}
+
+	if (exynos_camera->capture_yuv_buffer != NULL) {
+		free(exynos_camera->capture_yuv_buffer);
+		exynos_camera->capture_yuv_buffer = NULL;
+	}
+
+	if (exynos_camera->capture_jpeg_buffer != NULL) {
+		free(exynos_camera->capture_jpeg_buffer);
+		exynos_camera->capture_jpeg_buffer = NULL;
+	}
+
+	if (&exynos_camera->exif.enabled)
+		exynos_exif_stop(exynos_camera, &exynos_camera->exif);
+
+	exynos_camera->capture_enabled = 0;
+}
+
+int exynos_camera_capture_setup(struct exynos_camera *exynos_camera)
+{
+	int width, height, format;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	ALOGD("%s()", __func__);
+
+	format = exynos_camera->camera_capture_format;
+
+	width = exynos_camera->preview_width;
+	height = exynos_camera->preview_height;
+
+	ALOGD("%s: Selected width: %d, height: %d, format: 0x%x", __func__, width, height, format);
+
+	if (!exynos_camera->capture_enabled) {
+		exynos_camera->capture_width = width;
+		exynos_camera->capture_height = height;
+		exynos_camera->capture_format = format;
+
+		rc = exynos_camera_capture_start(exynos_camera);
+		if (rc < 0) {
+			ALOGE("%s: Unable to start capture", __func__);
+			return -1;
+		}
+	} else if (exynos_camera->capture_width != width || exynos_camera->capture_height != height || exynos_camera->capture_format != format) {
+		exynos_camera_capture_stop(exynos_camera);
+
+		exynos_camera->capture_width = width;
+		exynos_camera->capture_height = height;
+		exynos_camera->capture_format = format;
+
+		rc = exynos_camera_capture_start(exynos_camera);
+		if (rc < 0) {
+			ALOGE("%s: Unable to start capture", __func__);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+// Preview
+
+int exynos_camera_preview_output_start(struct exynos_camera *exynos_camera)
+{
+	struct exynos_v4l2_output *output;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	ALOGD("%s()", __func__);
+
+	if (exynos_camera->preview_output_enabled) {
+		ALOGE("Preview was already started!");
+		return -1;
+	}
+
+	output = &exynos_camera->preview_output;
+
+	memset(output, 0, sizeof(struct exynos_v4l2_output));
+	output->v4l2_id = 1;
+	output->width = exynos_camera->preview_width;
+	output->height = exynos_camera->preview_height;
+	output->format = exynos_camera->preview_format;
+	output->buffer_width = exynos_camera->preview_buffer.width;
+	output->buffer_height = exynos_camera->preview_buffer.height;
+	output->buffer_format = exynos_camera->preview_buffer.format;
+	output->buffers_count = EXYNOS_CAMERA_PREVIEW_BUFFERS_COUNT;
+
+	rc = exynos_v4l2_output_start(exynos_camera, output);
+	if (rc < 0) {
+		ALOGE("%s: Unable to start preview output", __func__);
+		goto error;
+	}
+
+	exynos_camera->preview_output_enabled = 1;
+
+	rc = 0;
+	goto complete;
+
+error:
+	rc = -1;
+
+complete:
+	return rc;
+}
+
+void exynos_camera_preview_output_stop(struct exynos_camera *exynos_camera)
+{
+	struct exynos_v4l2_output *output;
+
+	if (exynos_camera == NULL)
+		return;
+
+	ALOGD("%s()", __func__);
+
+	if (!exynos_camera->preview_output_enabled) {
+		ALOGE("Preview was already stopped!");
+		return;
+	}
+
+	output = &exynos_camera->preview_output;
+
+	exynos_v4l2_output_stop(exynos_camera, output);
+
+	exynos_camera->preview_output_enabled = 0;
+}
+
+int exynos_camera_preview(struct exynos_camera *exynos_camera)
+{
+	struct exynos_v4l2_output *output;
+	int width, height, format;
+	buffer_handle_t *window_buffer;
+	void *window_data;
+	int window_stride;
+	camera_memory_t *memory;
+	camera_face_t caface[exynos_camera->max_detected_faces];
+	void *memory_pointer;
+	int memory_index;
+	int memory_size;
+	int rc;
+
+	if (exynos_camera == NULL)
+		goto error;
+
+//     ALOGD("%s()", __func__);
+
+	width = exynos_camera->preview_width;
+	height = exynos_camera->preview_height;
+	format = exynos_camera->preview_format;
+
+	output = &exynos_camera->preview_output;
+
+	if (exynos_camera->preview_output_enabled) {
+		rc = exynos_v4l2_output(exynos_camera, output, exynos_camera->preview_buffer.address);
+		if (rc < 0) {
+			ALOGE("%s: Unable to output preview", __func__);
+			goto error;
+		}
+
+		memory = output->memory;
+		memory_index = output->memory_index;
+		memory_pointer = (void *) ((unsigned char *) memory->data + output->buffer_length * memory_index);
+		memory_size = output->buffer_length;
+	} else {
+		// In that case, we can directly use the capture memory
+		memory = exynos_camera->capture_memory;
+		memory_index = exynos_camera->capture_memory_index;
+		memory_pointer = exynos_camera->preview_buffer.pointer;
+		memory_size = exynos_camera->preview_buffer.length;
+	}
+
+	if (exynos_camera->preview_window != NULL && exynos_camera->gralloc != NULL) {
+		int ret = exynos_camera->preview_window->dequeue_buffer(exynos_camera->preview_window, &window_buffer, &window_stride);
+		if (ret < 0) {
+			ALOGE("%s: Error in dequeueing buffer", __func__);
+			goto error;
+		}
+		ret = exynos_camera->gralloc->lock(exynos_camera->gralloc, *window_buffer, GRALLOC_USAGE_YUV_ADDR | GRALLOC_USAGE_SW_WRITE_OFTEN, 0, 0, width, height, &window_data);
+
+		if (window_data == NULL || ret == -EINVAL) {
+			ALOGE("%s: Unable to lock gralloc", __func__);
+			goto error;
+		}
+
+		memcpy(window_data, memory_pointer, memory_size);
+
+		exynos_camera->gralloc->unlock(exynos_camera->gralloc, *window_buffer);
+		exynos_camera->preview_window->enqueue_buffer(exynos_camera->preview_window, window_buffer);
+	}
+
+	if (exynos_camera->camera_fimc_is) {
+		exynos_camera->mFaceData.faces = caface;
+		exynos_v4l2_s_ext_ctrl_face_detection(exynos_camera, 0, &exynos_camera->mFaceData);
+	}
+
+	if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_PREVIEW_FRAME) && EXYNOS_CAMERA_CALLBACK_DEFINED(data) && !exynos_camera->callback_lock) {
+		exynos_camera->callbacks.data(CAMERA_MSG_PREVIEW_FRAME, memory, memory_index, NULL, exynos_camera->callbacks.user);
+	}
+
+	if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_PREVIEW_METADATA) && EXYNOS_CAMERA_CALLBACK_DEFINED(data) && !exynos_camera->callback_lock) {
+		exynos_camera->callbacks.data(CAMERA_MSG_PREVIEW_METADATA, exynos_camera->face_data, 0, &exynos_camera->mFaceData, exynos_camera->callbacks.user);
+	}
+
+	if (exynos_camera->preview_output_enabled) {
+		rc = exynos_v4l2_output_release(exynos_camera, output);
+		if (rc < 0) {
+			ALOGE("%s: Unable to release preview output", __func__);
+			goto error;
+		}
+	}
+
+	rc = 0;
+	goto complete;
+
+error:
+	rc = -1;
+
+complete:
+	return rc;
+}
+
+int exynos_camera_preview_start(struct exynos_camera *exynos_camera)
+{
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	ALOGD("%s()", __func__);
+
+	if (exynos_camera->preview_enabled) {
+		ALOGE("Preview was already started!");
+		return -1;
+	}
+
+	exynos_camera_capture_setup(exynos_camera);
+
+	exynos_camera->preview_enabled = 1;
+
+	return 0;
+}
+
+void exynos_camera_preview_stop(struct exynos_camera *exynos_camera)
+{
+	int i;
+
+	if (exynos_camera == NULL)
+		return;
+
+	ALOGD("%s()", __func__);
+
+	if (!exynos_camera->preview_enabled) {
+		ALOGE("Preview was already stopped!");
+		return;
+	}
+
+	exynos_camera->preview_enabled = 0;
+
+	if (exynos_camera->capture_enabled) {
+		pthread_mutex_lock(&exynos_camera->capture_mutex);
+		exynos_camera_capture_stop(exynos_camera);
+		pthread_mutex_unlock(&exynos_camera->capture_mutex);
+	}
+
+	if (exynos_camera->preview_output_enabled)
+		exynos_camera_preview_output_stop(exynos_camera);
+
+	exynos_camera->preview_window = NULL;
+}
+
+// Picture
+
+void *exynos_camera_picture(void *data)
+{
+	struct exynos_camera *exynos_camera;
+	struct exynos_camera_buffer *jpeg_buffer;
+	struct exynos_camera_buffer *yuv_buffer;
+	struct exynos_v4l2_output output;
+	struct exynos_jpeg jpeg;
+	int output_enabled = 0;
+	int width, height, format;
+	int buffer_width, buffer_height, buffer_format, buffer_address;
+	camera_memory_t *memory = NULL;
+	int memory_size;
+	unsigned char *p;
+	camera_memory_t *jpeg_memory = NULL;
+	void *jpeg_data = NULL;
+	int jpeg_size = 0;
+	camera_memory_t *jpeg_thumbnail_memory = NULL;
+	void *jpeg_thumbnail_data = NULL;
+	int jpeg_thumbnail_size = 0;
+	void *yuv_data = NULL;
+	int yuv_address = 0;
+	int yuv_size = 0;
+	void *yuv_thumbnail_data = NULL;
+	int yuv_thumbnail_address;
+	int yuv_thumbnail_size = 0;
+	int rc;
+
+	exynos_camera = (struct exynos_camera *) data;
+
+	if (exynos_camera == NULL)
+		goto error;
+
+	ALOGD("%s()", __func__);
+
+	jpeg_buffer = &exynos_camera->picture_jpeg_buffer;
+	yuv_buffer = &exynos_camera->picture_yuv_buffer;
+
+	if (jpeg_buffer->pointer != NULL && jpeg_buffer->length > 0) {
+		jpeg_data = jpeg_buffer->pointer;
+		jpeg_size = jpeg_buffer->length;
+	}
+
+	if (yuv_buffer->pointer != NULL && yuv_buffer->length > 0) {
+		yuv_data = yuv_buffer->pointer;
+		yuv_address = yuv_buffer->address;
+		yuv_size = yuv_buffer->length;
+	}
+
+	// JPEG
+
+	if (jpeg_data == NULL) {
+		if (yuv_data == NULL || yuv_size <= 0) {
+			ALOGE("%s: Unable to create jpeg without an YUV buffer", __func__);
+			goto error;
+		}
+
+		width = exynos_camera->picture_width;
+		height = exynos_camera->picture_height;
+		format = yuv_buffer->format;
+
+		buffer_width = yuv_buffer->width;
+		buffer_height = yuv_buffer->height;
+		buffer_format = yuv_buffer->format;
+		buffer_address = yuv_buffer->address;
+
+		if ((width != buffer_width && height != buffer_height) || exynos_camera->camera_fimc_is) {
+			format = EXYNOS_CAMERA_PICTURE_OUTPUT_FORMAT;
+
+			memset(&output, 0, sizeof(output));
+			output.v4l2_id = 2;
+			output.width = width;
+			output.height = height;
+			output.format = format;
+			output.buffer_width = buffer_width;
+			output.buffer_height = buffer_height;
+			output.buffer_format = buffer_format;
+			output.buffers_count = 1;
+
+			rc = exynos_v4l2_output_start(exynos_camera, &output);
+			if (rc < 0) {
+				ALOGE("%s: Unable to start picture output", __func__);
+				goto error;
+			}
+
+			rc = exynos_v4l2_output(exynos_camera, &output, buffer_address);
+			if (rc < 0) {
+				ALOGE("%s: Unable to output picture", __func__);
+				goto error;
+			}
+
+			output_enabled = 1;
+
+			yuv_data = output.memory->data;
+			yuv_address = output.memory_address;
+			yuv_size = output.buffer_length;
+
+			if (exynos_camera->camera_fimc_is)
+				exynos_exif_create(exynos_camera, &exynos_camera->exif);
+		}
+
+		memset(&jpeg, 0, sizeof(jpeg));
+		jpeg.width = width;
+		jpeg.height = height;
+		jpeg.format = format;
+		jpeg.quality = exynos_camera->jpeg_quality;
+
+		rc = exynos_jpeg_start(exynos_camera, &jpeg);
+		if (rc < 0) {
+			ALOGE("%s: Unable to start jpeg", __func__);
+			goto error;
+		}
+
+		if (jpeg.memory_in_pointer == NULL) {
+			ALOGE("%s: Invalid memory input pointer", __func__);
+			goto error;
+		}
+
+		memcpy(jpeg.memory_in_pointer, yuv_data, yuv_size);
+
+		rc = exynos_jpeg(exynos_camera, &jpeg);
+		if (rc < 0) {
+			ALOGE("%s: Unable to jpeg", __func__);
+			goto error;
+		}
+
+		jpeg_size = jpeg.memory_out_size;
+		if (jpeg_size <= 0) {
+			ALOGE("%s: Invalid jpeg size", __func__);
+			goto error;
+		}
+
+		if (EXYNOS_CAMERA_CALLBACK_DEFINED(request_memory)) {
+			jpeg_memory = exynos_camera->callbacks.request_memory(-1, jpeg_size, 1, exynos_camera->callbacks.user);
+			if (jpeg_memory == NULL || jpeg_memory->data == NULL || jpeg_memory->data == MAP_FAILED) {
+				ALOGE("%s: Unable to request memory", __func__);
+				goto error;
+			}
+		} else {
+			ALOGE("%s: No memory request function!", __func__);
+			goto error;
+		}
+
+		jpeg_data = jpeg_memory->data;
+
+		memcpy(jpeg_data, jpeg.memory_out_pointer, jpeg_size);
+
+		exynos_jpeg_stop(exynos_camera, &jpeg);
+
+		if (output_enabled) {
+			exynos_v4l2_output_stop(exynos_camera, &output);
+			output_enabled = 0;
+		}
+	}
+
+	// Thumbnail
+
+	if (yuv_data == NULL || yuv_size <= 0) {
+		ALOGE("%s: Unable to create jpeg thumbnail without an YUV buffer", __func__);
+		goto error;
+	}
+
+	width = exynos_camera->jpeg_thumbnail_width;
+	height = exynos_camera->jpeg_thumbnail_height;
+	format = yuv_buffer->format;
+
+	buffer_width = yuv_buffer->width;
+	buffer_height = yuv_buffer->height;
+	buffer_format = yuv_buffer->format;
+	buffer_address = yuv_buffer->address;
+
+	if (width != buffer_width && height != buffer_height) {
+		format = EXYNOS_CAMERA_PICTURE_OUTPUT_FORMAT;
+
+		memset(&output, 0, sizeof(output));
+		output.v4l2_id = 2;
+		output.width = width;
+		output.height = height;
+		output.format = format;
+		output.buffer_width = buffer_width;
+		output.buffer_height = buffer_height;
+		output.buffer_format = buffer_format;
+		output.buffers_count = 1;
+
+		rc = exynos_v4l2_output_start(exynos_camera, &output);
+		if (rc < 0) {
+			ALOGE("%s: Unable to start thumbnail picture output", __func__);
+			goto error;
+		}
+
+		output_enabled = 1;
+
+		rc = exynos_v4l2_output(exynos_camera, &output, buffer_address);
+		if (rc < 0) {
+			ALOGE("%s: Unable to output thumbnail picture", __func__);
+			goto error;
+		}
+
+		yuv_thumbnail_data = output.memory->data;
+		yuv_thumbnail_address = output.memory_address;
+		yuv_thumbnail_size = output.buffer_length;
+	}
+
+	memset(&jpeg, 0, sizeof(jpeg));
+	jpeg.width = width;
+	jpeg.height = height;
+	jpeg.format = format;
+	jpeg.quality = exynos_camera->jpeg_thumbnail_quality;
+
+	rc = exynos_jpeg_start(exynos_camera, &jpeg);
+	if (rc < 0) {
+		ALOGE("%s: Unable to start jpeg", __func__);
+		goto error;
+	}
+
+	if (jpeg.memory_in_pointer == NULL) {
+		ALOGE("%s: Invalid memory input pointer", __func__);
+		goto error;
+	}
+
+	memcpy(jpeg.memory_in_pointer, yuv_thumbnail_data, yuv_thumbnail_size);
+
+	rc = exynos_jpeg(exynos_camera, &jpeg);
+	if (rc < 0) {
+		ALOGE("%s: Unable to jpeg", __func__);
+		goto error;
+	}
+
+	jpeg_thumbnail_size = jpeg.memory_out_size;
+	if (jpeg_thumbnail_size <= 0) {
+		ALOGE("%s: Invalid jpeg size", __func__);
+		goto error;
+	}
+
+	if (EXYNOS_CAMERA_CALLBACK_DEFINED(request_memory)) {
+		jpeg_thumbnail_memory = exynos_camera->callbacks.request_memory(-1, jpeg_thumbnail_size, 1, exynos_camera->callbacks.user);
+		if (jpeg_thumbnail_memory == NULL || jpeg_thumbnail_memory->data == NULL || jpeg_thumbnail_memory->data == MAP_FAILED) {
+			ALOGE("%s: Unable to request memory", __func__);
+			goto error;
+		}
+	} else {
+		ALOGE("%s: No memory request function!", __func__);
+		goto error;
+	}
+
+	jpeg_thumbnail_data = jpeg_thumbnail_memory->data;
+
+	memcpy(jpeg_thumbnail_data, jpeg.memory_out_pointer, jpeg_thumbnail_size);
+
+	exynos_jpeg_stop(exynos_camera, &jpeg);
+
+	if (output_enabled) {
+		exynos_v4l2_output_stop(exynos_camera, &output);
+		output_enabled = 0;
+	}
+
+	// EXIF
+	exynos_exif_create(exynos_camera, &exynos_camera->exif);
+
+	exynos_camera->exif.jpeg_thumbnail_data = jpeg_thumbnail_data;
+	exynos_camera->exif.jpeg_thumbnail_size = jpeg_thumbnail_size;
+
+	rc = exynos_exif(exynos_camera, &exynos_camera->exif);
+	if (rc < 0) {
+		ALOGE("%s: Unable to exif", __func__);
+		goto error;
+	}
+
+	memory_size = exynos_camera->exif.memory_size + jpeg_size;
+
+	if (EXYNOS_CAMERA_CALLBACK_DEFINED(request_memory)) {
+		memory = exynos_camera->callbacks.request_memory(-1, memory_size, 1, exynos_camera->callbacks.user);
+		if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) {
+			ALOGE("%s: Unable to request memory", __func__);
+			goto error;
+		}
+	} else {
+		ALOGE("%s: No memory request function!", __func__);
+		goto error;
+	}
+
+	p = (unsigned char *) memory->data;
+
+	// Copy the first two bytes of the JPEG picture
+	memcpy(p, jpeg_data, 2);
+	p += 2;
+
+	// Copy the EXIF data
+	memcpy(p, exynos_camera->exif.memory->data, exynos_camera->exif.memory_size);
+	p += exynos_camera->exif.memory_size;
+
+	// Copy the JPEG picture
+	memcpy(p, (void *) ((unsigned char *) jpeg_data + 2), jpeg_size - 2);
+
+	exynos_camera->picture_memory = memory;
+
+	goto complete;
+
+error:
+	if (output_enabled)
+		exynos_v4l2_output_stop(exynos_camera, &output);
+
+	if (memory != NULL && memory->release != NULL) {
+		memory->release(memory);
+		exynos_camera->picture_memory = NULL;
+	}
+
+	if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_ERROR) && EXYNOS_CAMERA_CALLBACK_DEFINED(notify) && !exynos_camera->callback_lock)
+		exynos_camera->callbacks.notify(CAMERA_MSG_ERROR, -1, 0, exynos_camera->callbacks.user);
+
+complete:
+	if (jpeg_memory != NULL && jpeg_memory->release != NULL)
+		jpeg_memory->release(jpeg_memory);
+
+	if (jpeg_thumbnail_memory != NULL && jpeg_thumbnail_memory->release != NULL)
+		jpeg_thumbnail_memory->release(jpeg_thumbnail_memory);
+
+
+	exynos_camera->picture_completed = 1;
+
+	exynos_camera_picture_stop(exynos_camera);
+	exynos_camera->picture_running = 0;
+
+	return NULL;
+}
+
+int exynos_camera_picture_start(struct exynos_camera *exynos_camera)
+{
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	ALOGD("%s()", __func__);
+
+	if (exynos_camera->picture_enabled) {
+		ALOGE("Picture was already started!");
+		return 0;
+	}
+
+	if (!exynos_camera->camera_fimc_is) {
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_CAPTURE, 0);
+		if (rc < 0) {
+			ALOGE("%s: Unable to set capture", __func__);
+			return -1;
+		}
+
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_HYBRID_CAPTURE, 1);
+		if (rc < 0) {
+			ALOGE("%s: Unable to set hybrid capture", __func__);
+			return -1;
+		}
+	}
+
+	exynos_camera->picture_enabled = 1;
+
+	return 0;
+}
+
+void exynos_camera_picture_stop(struct exynos_camera *exynos_camera)
+{
+	camera_memory_t *memory;
+	int rc, i;
+
+	if (exynos_camera == NULL)
+		return;
+
+	ALOGD("%s()", __func__);
+
+	if (!exynos_camera->picture_enabled) {
+		ALOGE("Picture was already stopped!");
+		return;
+	}
+
+	memory = exynos_camera->picture_memory;
+
+	if (exynos_camera->picture_completed && memory != NULL) {
+		// It is important to return at this point (and not before) for burst
+
+		if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_SHUTTER) && EXYNOS_CAMERA_CALLBACK_DEFINED(notify) && !exynos_camera->callback_lock)
+			exynos_camera->callbacks.notify(CAMERA_MSG_SHUTTER, 0, 0, exynos_camera->callbacks.user);
+
+		if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_COMPRESSED_IMAGE) && EXYNOS_CAMERA_CALLBACK_DEFINED(data) && !exynos_camera->callback_lock)
+			exynos_camera->callbacks.data(CAMERA_MSG_COMPRESSED_IMAGE, memory, 0, NULL, exynos_camera->callbacks.user);
+
+		if (memory->release != NULL) {
+			memory->release(memory);
+			exynos_camera->picture_memory = NULL;
+		}
+	}
+
+	rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, AE_UNLOCK_AWB_UNLOCK);
+	if (rc < 0)
+		ALOGE("%s: Unable to set AEAWB lock", __func__);
+
+	exynos_camera->picture_enabled = 0;
+}
+
+// Recording
+
+int exynos_camera_recording_output_start(struct exynos_camera *exynos_camera)
+{
+	struct exynos_v4l2_output *output;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	ALOGD("%s()", __func__);
+
+	if (exynos_camera->recording_output_enabled) {
+		ALOGE("Recording was already started!");
+		return -1;
+	}
+
+	output = &exynos_camera->recording_output;
+
+	memset(output, 0, sizeof(struct exynos_v4l2_output));
+	output->v4l2_id = 3;
+	output->width = exynos_camera->recording_width;
+	output->height = exynos_camera->recording_height;
+	output->format = exynos_camera->recording_format;
+	output->buffer_width = exynos_camera->recording_buffer.width;
+	output->buffer_height = exynos_camera->recording_buffer.height;
+	output->buffer_format = exynos_camera->recording_buffer.format;
+	output->buffers_count = EXYNOS_CAMERA_RECORDING_BUFFERS_COUNT;
+
+	rc = exynos_v4l2_output_start(exynos_camera, output);
+	if (rc < 0) {
+		ALOGE("%s: Unable to start recording output", __func__);
+		goto error;
+	}
+
+	exynos_camera->recording_output_enabled = 1;
+
+	rc = 0;
+	goto complete;
+
+error:
+	rc = -1;
+
+complete:
+	return rc;
+}
+
+void exynos_camera_recording_output_stop(struct exynos_camera *exynos_camera)
+{
+	struct exynos_v4l2_output *output;
+
+	if (exynos_camera == NULL)
+		return;
+
+	ALOGD("%s()", __func__);
+
+	if (!exynos_camera->recording_output_enabled) {
+		ALOGE("Recording was already stopped!");
+		return;
+	}
+
+	output = &exynos_camera->recording_output;
+
+	exynos_v4l2_output_stop(exynos_camera, output);
+
+	exynos_camera->recording_output_enabled = 0;
+}
+
+void exynos_camera_recording_frame_release(struct exynos_camera *exynos_camera)
+{
+	struct exynos_v4l2_output *output;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return;
+
+//	ALOGD("%s()", __func__);
+
+	output = &exynos_camera->recording_output;
+
+	if (!exynos_camera->recording_output_enabled) {
+		ALOGE("%s: Recording output should always be enabled", __func__);
+		return;
+	}
+
+	rc = exynos_v4l2_output_release(exynos_camera, output);
+	if (rc < 0) {
+		ALOGE("%s: Unable to release recording output", __func__);
+		return;
+	}
+}
+
+int exynos_camera_recording(struct exynos_camera *exynos_camera)
+{
+	struct exynos_v4l2_output *output;
+	struct exynos_camera_addrs *addrs;
+	int width, height, format;
+	camera_memory_t *memory;
+	int memory_address;
+	int memory_index;
+	int buffer_length;
+	int buffers_count;
+	nsecs_t timestamp;
+	int rc;
+
+	if (exynos_camera == NULL)
+		goto error;
+
+//	ALOGD("%s()", __func__);
+
+	width = exynos_camera->recording_width;
+	height = exynos_camera->recording_height;
+	format = exynos_camera->recording_format;
+
+	output = &exynos_camera->recording_output;
+
+	buffer_length = exynos_camera->recording_buffer_length;
+	buffers_count = exynos_camera->recording_buffers_count;
+
+	timestamp = systemTime(1);
+
+	if (!exynos_camera->recording_output_enabled) {
+		ALOGE("%s: Recording output should always be enabled", __func__);
+		goto error;
+	}
+
+	rc = exynos_v4l2_output(exynos_camera, output, exynos_camera->recording_buffer.address);
+	if (rc < 0) {
+		ALOGE("%s: Unable to output recording", __func__);
+		goto error;
+	}
+
+	if (exynos_camera->recording_metadata) {
+		memory = exynos_camera->recording_memory;
+		memory_index = exynos_camera->recording_memory_index;
+		memory_address = output->memory_address + output->buffer_length * output->memory_index;
+
+		addrs = (struct exynos_camera_addrs *) ((unsigned char *) memory->data + buffer_length * memory_index);
+		memset(addrs, 0, sizeof(struct exynos_camera_addrs));
+		addrs->type = 0; // kMetadataBufferTypeCameraSource
+		addrs->index = memory_index;
+
+		exynos_camera_yuv_planes(width, height, format, memory_address, (int *) &addrs->y, (int *) &addrs->cbcr, NULL);
+	} else {
+		memory = output->memory;
+		memory_index = output->memory_index;
+	}
+
+	if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_VIDEO_FRAME) && EXYNOS_CAMERA_CALLBACK_DEFINED(data_timestamp) && !exynos_camera->callback_lock)
+		exynos_camera->callbacks.data_timestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, memory, memory_index, exynos_camera->callbacks.user);
+	else
+		exynos_camera_recording_frame_release(exynos_camera);
+
+	rc = 0;
+	goto complete;
+
+error:
+	rc = -1;
+
+complete:
+	return rc;
+}
+
+int exynos_camera_recording_start(struct exynos_camera *exynos_camera)
+{
+	int rc;
+
+	camera_memory_t *memory = NULL;
+	int buffer_length;
+	int buffers_count;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	ALOGD("%s()", __func__);
+
+	if (exynos_camera->recording_enabled) {
+		ALOGE("Recording was already started!");
+		return -1;
+	}
+
+	exynos_camera->recording_enabled = 1;
+
+	if (exynos_camera->recording_metadata) {
+		buffer_length = sizeof(struct exynos_camera_addrs);
+		buffers_count = EXYNOS_CAMERA_RECORDING_BUFFERS_COUNT;
+
+		if (EXYNOS_CAMERA_CALLBACK_DEFINED(request_memory)) {
+			memory = exynos_camera->callbacks.request_memory(-1, buffer_length, buffers_count, exynos_camera->callbacks.user);
+			if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) {
+				ALOGE("%s: Unable to request memory", __func__);
+				goto error;
+			}
+		} else {
+			ALOGE("%s: No memory request function!", __func__);
+			goto error;
+		}
+
+		exynos_camera->recording_memory = memory;
+		exynos_camera->recording_buffer_length = buffer_length;
+		exynos_camera->recording_buffers_count = buffers_count;
+	}
+
+	rc = 0;
+	goto complete;
+
+error:
+	if (memory != NULL && memory->release != NULL) {
+		memory->release(memory);
+		exynos_camera->recording_memory = NULL;
+	}
+
+	rc = -1;
+
+complete:
+	return rc;
+}
+
+void exynos_camera_recording_stop(struct exynos_camera *exynos_camera)
+{
+	int i;
+
+	if (exynos_camera == NULL)
+		return;
+
+	ALOGD("%s()", __func__);
+
+	if (!exynos_camera->recording_enabled) {
+		ALOGE("Recording was already stopped!");
+		return;
+	}
+
+	exynos_camera->recording_enabled = 0;
+
+}
+
+// Auto-focus
+
+
+int exynos_camera_auto_focus(struct exynos_camera *exynos_camera, int auto_focus_status)
+{
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+//	ALOGD("%s()", __func__);
+
+	switch (auto_focus_status) {
+		case CAMERA_AF_STATUS_SUCCESS:
+			if (exynos_camera->auto_focus_started) {
+				if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS) && EXYNOS_CAMERA_CALLBACK_DEFINED(notify) && !exynos_camera->callback_lock)
+					exynos_camera->callbacks.notify(CAMERA_MSG_FOCUS, 1, 0, exynos_camera->callbacks.user);
+				exynos_camera_auto_focus_finish(exynos_camera);
+			}
+			break;
+		case CAMERA_AF_STATUS_FAIL:
+			if (exynos_camera->auto_focus_started) {
+				if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS) && EXYNOS_CAMERA_CALLBACK_DEFINED(notify) && !exynos_camera->callback_lock)
+					exynos_camera->callbacks.notify(CAMERA_MSG_FOCUS, 0, 0, exynos_camera->callbacks.user);
+				exynos_camera_auto_focus_finish(exynos_camera);
+			}
+			break;
+		case CAMERA_AF_STATUS_IN_PROGRESS:
+			exynos_camera->auto_focus_started = 1;
+			break;
+		case CAMERA_AF_STATUS_RESTART:
+		default:
+			break;
+	}
+
+	return 0;
+}
+
+int exynos_camera_continuous_auto_focus(struct exynos_camera *exynos_camera, int auto_focus_status)
+{
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	switch (auto_focus_status) {
+		case CAMERA_AF_STATUS_IN_PROGRESS:
+			if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS_MOVE) && EXYNOS_CAMERA_CALLBACK_DEFINED(notify) && !exynos_camera->callback_lock)
+				exynos_camera->callbacks.notify(CAMERA_MSG_FOCUS_MOVE, 1, 0, exynos_camera->callbacks.user);
+
+			break;
+		case CAMERA_AF_STATUS_SUCCESS:
+			if (EXYNOS_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS_MOVE) && EXYNOS_CAMERA_CALLBACK_DEFINED(notify) && !exynos_camera->callback_lock)
+				exynos_camera->callbacks.notify(CAMERA_MSG_FOCUS_MOVE, 0, 0, exynos_camera->callbacks.user);
+			break;
+		case CAMERA_AF_STATUS_RESTART:
+		default:
+			break;
+	}
+
+	return 0;
+}
+
+int exynos_camera_auto_focus_start(struct exynos_camera *exynos_camera)
+{
+	int auto_focus;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	ALOGD("%s()", __func__);
+
+	auto_focus = AUTO_FOCUS_ON | (exynos_camera->preview_width & 0xfff) << 20 | (exynos_camera->preview_height & 0xfff) << 8;
+
+	rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_SET_AUTO_FOCUS, auto_focus);
+	if (rc < 0) {
+		ALOGE("%s: Unable to set auto-focus on", __func__);
+		goto error;
+	}
+
+	exynos_camera->auto_focus_enabled = 1;
+
+	rc = 0;
+	goto complete;
+
+error:
+
+	rc = -1;
+
+complete:
+	return rc;
+}
+
+void exynos_camera_auto_focus_finish(struct exynos_camera *exynos_camera)
+{
+	int rc;
+
+	ALOGD("%s()", __func__);
+
+	if (!exynos_camera->auto_focus_enabled) {
+		return;
+	}
+
+	exynos_camera->auto_focus_enabled = 0;
+	exynos_camera->auto_focus_started = 0;
+
+	rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, AE_UNLOCK_AWB_UNLOCK);
+	if (rc < 0)
+		ALOGE("%s: Unable to set AEAWB lock", __func__);
+}
+
+void exynos_camera_auto_focus_stop(struct exynos_camera *exynos_camera)
+{
+	int rc;
+	int i;
+
+	if (exynos_camera == NULL)
+		return;
+
+	ALOGD("%s()", __func__);
+
+	if (exynos_camera->auto_focus_enabled) {
+		rc = exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF);
+		if (rc < 0)
+			ALOGE("%s: Unable to set auto-focus off", __func__);
+			exynos_camera_auto_focus_finish(exynos_camera);
+	}
+
+}
+
+/*
+ * Exynos Camera OPS
+ */
+
+int exynos_camera_set_preview_window(struct camera_device *dev,
+	struct preview_stream_ops *w)
+{
+	struct exynos_camera *exynos_camera;
+
+	int width, height, format, gralloc_format;
+
+	buffer_handle_t *buffer;
+	int stride;
+	void *addr = NULL;
+
+	int rc;
+
+	ALOGD("%s(%p, %p)", __func__, dev, w);
+
+	if (dev == NULL || dev->priv == NULL)
+		return -EINVAL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	if (w == NULL) {
+		exynos_camera->preview_window = NULL;
+		return 0;
+	}
+
+	if (w->set_buffer_count == NULL || w->set_usage == NULL || w->set_buffers_geometry == NULL)
+		goto error;
+
+	rc = w->set_buffer_count(w, EXYNOS_CAMERA_GRALLOC_BUFFERS_COUNT);
+	if (rc) {
+		ALOGE("%s: Unable to set buffer count: %d", __func__, EXYNOS_CAMERA_GRALLOC_BUFFERS_COUNT);
+		goto error;
+	}
+
+	rc = w->set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN);
+	if (rc) {
+		ALOGE("%s: Unable to set usage", __func__);
+		goto error;
+	}
+
+	width = exynos_camera->preview_width;
+	height = exynos_camera->preview_height;
+	format = exynos_camera->preview_format;
+
+	switch (format) {
+		case V4L2_PIX_FMT_NV21:
+			gralloc_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
+			break;
+		case V4L2_PIX_FMT_YUV420:
+			gralloc_format = HAL_PIXEL_FORMAT_YV12;
+			break;
+		case V4L2_PIX_FMT_RGB565:
+			gralloc_format = HAL_PIXEL_FORMAT_RGB_565;
+			break;
+		case V4L2_PIX_FMT_RGB32:
+			gralloc_format = HAL_PIXEL_FORMAT_RGBX_8888;
+			break;
+		default:
+			gralloc_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
+			break;
+	}
+
+	rc = w->set_buffers_geometry(w, width, height, gralloc_format);
+	if (rc) {
+		ALOGE("%s: Unable to set buffers geometry", __func__);
+		goto error;
+	}
+
+	exynos_camera->preview_window = w;
+
+	rc = 0;
+	goto complete;
+
+error:
+	exynos_camera->preview_window = NULL;
+	rc = -1;
+
+complete:
+	return rc;
+}
+
+void exynos_camera_set_callbacks(struct camera_device *dev,
+	camera_notify_callback notify_cb,
+	camera_data_callback data_cb,
+	camera_data_timestamp_callback data_cb_timestamp,
+	camera_request_memory get_memory,
+	void *user)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p, %p)", __func__, dev, user);
+
+	if (dev == NULL || dev->priv == NULL)
+		return;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera->callbacks.notify = notify_cb;
+	exynos_camera->callbacks.data = data_cb;
+	exynos_camera->callbacks.data_timestamp = data_cb_timestamp;
+	exynos_camera->callbacks.request_memory = get_memory;
+	exynos_camera->callbacks.user = user;
+}
+
+void exynos_camera_enable_msg_type(struct camera_device *dev, int32_t msg_type)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p, %d)", __func__, dev, msg_type);
+
+	if (dev == NULL || dev->priv == NULL)
+		return;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera->messages_enabled |= msg_type;
+}
+
+void exynos_camera_disable_msg_type(struct camera_device *dev, int32_t msg_type)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p, %d)", __func__, dev, msg_type);
+
+	if (dev == NULL || dev->priv == NULL)
+		return;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera->messages_enabled &= ~msg_type;
+}
+
+int exynos_camera_msg_type_enabled(struct camera_device *dev, int32_t msg_type)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p, %d)", __func__, dev, msg_type);
+
+	if (dev == NULL || dev->priv == NULL)
+		return -EINVAL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	return exynos_camera->messages_enabled & msg_type;
+}
+
+int exynos_camera_start_preview(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+	int rc;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	if (dev == NULL || dev->priv == NULL)
+		return -EINVAL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera->callback_lock = 1;
+	rc = exynos_camera_preview_start(exynos_camera);
+	exynos_camera->callback_lock = 0;
+
+	return rc;
+}
+
+void exynos_camera_stop_preview(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	if (dev == NULL || dev->priv == NULL)
+		return;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera->callback_lock = 1;
+	exynos_camera_preview_stop(exynos_camera);
+	exynos_camera->callback_lock = 0;
+}
+
+int exynos_camera_preview_enabled(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	if (dev == NULL || dev->priv == NULL)
+		return -EINVAL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	return exynos_camera->preview_enabled;
+}
+
+int exynos_camera_store_meta_data_in_buffers(struct camera_device *dev,
+	int enable)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p, %d)", __func__, dev, enable);
+
+	if (dev == NULL || dev->priv == NULL)
+		return -EINVAL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	if (!exynos_camera->recording_enabled)
+		exynos_camera->recording_metadata = enable;
+	else
+		ALOGE("%s: Recording is running!", __func__);
+
+	return 0;
+}
+
+int exynos_camera_start_recording(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+	int rc;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera->callback_lock = 1;
+	rc = exynos_camera_recording_start(exynos_camera);
+	exynos_camera->callback_lock = 0;
+
+	return rc;
+}
+
+void exynos_camera_stop_recording(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera->callback_lock = 1;
+	exynos_camera_recording_stop(exynos_camera);
+	exynos_camera->callback_lock = 0;
+}
+
+int exynos_camera_recording_enabled(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	if (dev == NULL || dev->priv == NULL)
+		return -EINVAL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	return exynos_camera->recording_enabled;
+}
+
+void exynos_camera_release_recording_frame(struct camera_device *dev,
+	const void *opaque)
+{
+	struct exynos_camera *exynos_camera;
+
+//	ALOGD("%s(%p, %p)", __func__, dev, opaque);
+
+	if (dev == NULL || dev->priv == NULL)
+		return;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera_recording_frame_release(exynos_camera);
+}
+
+int exynos_camera_start_auto_focus(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	if (dev == NULL || dev->priv == NULL)
+		return -EINVAL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	return exynos_camera_auto_focus_start(exynos_camera);
+}
+
+int exynos_camera_cancel_auto_focus(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	if (dev == NULL || dev->priv == NULL)
+		return -EINVAL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera_auto_focus_stop(exynos_camera);
+
+	return 0;
+}
+
+int exynos_camera_take_picture(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+	int rc;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	if (dev == NULL || dev->priv == NULL)
+		return -EINVAL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera->callback_lock = 1;
+	rc = exynos_camera_picture_start(exynos_camera);
+	exynos_camera->callback_lock = 0;
+
+	return rc;
+}
+
+int exynos_camera_cancel_picture(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+	int rc;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	if (dev == NULL || dev->priv == NULL)
+		return -EINVAL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera->callback_lock = 1;
+	exynos_camera_picture_stop(exynos_camera);
+	exynos_camera->callback_lock = 0;
+
+	return 0;
+}
+
+int exynos_camera_set_parameters(struct camera_device *dev,
+	const char *params)
+{
+	struct exynos_camera *exynos_camera;
+	int rc;
+
+	ALOGD("%s(%p, %s)", __func__, dev, params);
+
+	if (dev == NULL || dev->priv == NULL || params == NULL)
+		return -EINVAL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	if (strstr(params, "gps-timestamp=") == NULL) {
+		/* Make sure the GPS data is ignored, it may have
+		 * been explicitly erased with removeGpsData()
+		 */
+		exynos_param_int_set(exynos_camera, "gps-timestamp", -1);
+		exynos_param_int_set(exynos_camera, "gps-latitude", -1);
+		exynos_param_int_set(exynos_camera, "gps-longitude", -1);
+	}
+
+	rc = exynos_params_string_set(exynos_camera, (char *) params);
+	if (rc < 0) {
+		ALOGE("%s: Unable to set params string", __func__);
+		return -1;
+	}
+
+	rc = exynos_camera_params_apply(exynos_camera, 0);
+	if (rc < 0) {
+		ALOGE("%s: Unable to apply params", __func__);
+		return -1;
+	}
+
+	return 0;
+}
+
+char *exynos_camera_get_parameters(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+	char *params;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	if (dev == NULL || dev->priv == NULL)
+		return NULL;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	params = exynos_params_string_get(exynos_camera);
+	if (params == NULL) {
+		ALOGE("%s: Couldn't find any param", __func__);
+		return strdup("");
+	}
+
+	return params;
+}
+
+void exynos_camera_put_parameters(struct camera_device *dev, char *params)
+{
+	ALOGD("%s(%p)", __func__, dev);
+
+	if (params != NULL)
+		free(params);
+}
+
+int setFaceDetect(struct exynos_camera *exynos_camera, int face_detect)
+{
+	ALOGD("%s(face_detect(%d))", __func__, face_detect);
+	if (exynos_camera->camera_fimc_is) {
+		if (face_detect < IS_FD_COMMAND_STOP || IS_FD_COMMAND_MAX <= face_detect) {
+			ALOGE("ERR(%s):Invalid face_detect value (%d)", __func__, face_detect);
+			return -1;
+		}
+	} else {
+		if (face_detect < FACE_DETECTION_OFF || FACE_DETECTION_MAX <= face_detect) {
+			ALOGE("ERR(%s):Invalid face_detect value (%d)", __func__, face_detect);
+			return -1;
+		}
+	}
+
+	if (exynos_camera->camera_fimc_is) {
+		if (exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_IS_CMD_FD, face_detect) < 0) {
+			ALOGE("ERR(%s):Fail on V4L2_CID_IS_CMD_FD", __func__);
+			return -1;
+		}
+	} else {
+		if (exynos_v4l2_s_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_FACE_DETECTION, face_detect) < 0) {
+			ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACE_DETECTION", __func__);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int exynos_camera_send_command(struct camera_device *dev,
+	int32_t cmd, int32_t arg1, int32_t arg2)
+{
+	struct exynos_camera *exynos_camera;
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	ALOGD("%s(%p, %d, %d, %d)", __func__, dev, cmd, arg1, arg2);
+	switch (cmd) {
+		case CAMERA_CMD_START_FACE_DETECTION:
+			if (setFaceDetect(exynos_camera, FACE_DETECTION_ON) < 0) {
+				ALOGE("ERR: Fail on setFaceDetect(ON)");
+				return -EINVAL;
+			} else {
+				return 0;
+			}
+			break;
+		case CAMERA_CMD_STOP_FACE_DETECTION:
+			if (setFaceDetect(exynos_camera, FACE_DETECTION_OFF) < 0) {
+				ALOGE("ERR: Fail on setFaceDetect(OFF)");
+				return -EINVAL;
+			} else {
+				return 0;
+			}
+			break;
+		default:
+			break;
+	}
+
+	return 0;
+}
+
+void exynos_camera_release(struct camera_device *dev)
+{
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p)", __func__, dev);
+
+	if (dev == NULL || dev->priv == NULL)
+		return;
+
+	exynos_camera = (struct exynos_camera *) dev->priv;
+
+	exynos_camera_capture_thread_stop(exynos_camera);
+
+	exynos_camera_stop(exynos_camera);
+}
+
+int exynos_camera_dump(struct camera_device *dev, int fd)
+{
+	ALOGD("%s(%p, %d)", __func__, dev, fd);
+
+	return 0;
+}
+
+/*
+ * Interface
+ */
+
+struct camera_device_ops exynos_camera_ops = {
+	.set_preview_window = exynos_camera_set_preview_window,
+	.set_callbacks = exynos_camera_set_callbacks,
+	.enable_msg_type = exynos_camera_enable_msg_type,
+	.disable_msg_type = exynos_camera_disable_msg_type,
+	.msg_type_enabled = exynos_camera_msg_type_enabled,
+	.start_preview = exynos_camera_start_preview,
+	.stop_preview = exynos_camera_stop_preview,
+	.preview_enabled = exynos_camera_preview_enabled,
+	.store_meta_data_in_buffers = exynos_camera_store_meta_data_in_buffers,
+	.start_recording = exynos_camera_start_recording,
+	.stop_recording = exynos_camera_stop_recording,
+	.recording_enabled = exynos_camera_recording_enabled,
+	.release_recording_frame = exynos_camera_release_recording_frame,
+	.auto_focus = exynos_camera_start_auto_focus,
+	.cancel_auto_focus = exynos_camera_cancel_auto_focus,
+	.take_picture = exynos_camera_take_picture,
+	.cancel_picture = exynos_camera_cancel_picture,
+	.set_parameters = exynos_camera_set_parameters,
+	.get_parameters = exynos_camera_get_parameters,
+	.put_parameters = exynos_camera_put_parameters,
+	.send_command = exynos_camera_send_command,
+	.release = exynos_camera_release,
+	.dump = exynos_camera_dump,
+};
+
+int exynos_camera_close(hw_device_t *device)
+{
+	struct camera_device *camera_device;
+	struct exynos_camera *exynos_camera;
+
+	ALOGD("%s(%p)", __func__, device);
+
+	if (device == NULL)
+		return -EINVAL;
+
+	camera_device = (struct camera_device *) device;
+
+	if (camera_device->priv != NULL) {
+		free(camera_device->priv);
+	}
+
+	free(camera_device);
+
+	return 0;
+}
+
+int exynos_camera_open(const struct hw_module_t* module, const char *camera_id,
+	struct hw_device_t** device)
+{
+	struct camera_device *camera_device = NULL;
+	struct exynos_camera *exynos_camera = NULL;
+	int id;
+	int rc;
+
+	ALOGD("%s(%p, %s, %p)", __func__, module, camera_id, device);
+
+	if (module == NULL || camera_id == NULL || device == NULL)
+		return -EINVAL;
+
+	id = atoi(camera_id);
+	if (id < 0)
+		return -EINVAL;
+
+	exynos_camera = calloc(1, sizeof(struct exynos_camera));
+	exynos_camera->config = exynos_camera_config;
+
+	if (exynos_camera->config->v4l2_nodes_count > EXYNOS_CAMERA_MAX_V4L2_NODES_COUNT)
+		goto error_preset;
+
+	if (id >= exynos_camera->config->presets_count)
+		goto error_preset;
+
+	rc = exynos_camera_start(exynos_camera, id);
+	if (rc < 0) {
+		ALOGE("%s: Unable to start camera", __func__);
+		goto error;
+	}
+
+	rc = exynos_camera_capture_thread_start(exynos_camera);
+	if (rc < 0) {
+		ALOGE("%s: Unable to start capture thread", __func__);
+		goto error;
+	}
+
+	camera_device = calloc(1, sizeof(struct camera_device));
+	camera_device->common.tag = HARDWARE_DEVICE_TAG;
+	camera_device->common.version = 0;
+	camera_device->common.module = (struct hw_module_t *) module;
+	camera_device->common.close = exynos_camera_close;
+
+	camera_device->ops = &exynos_camera_ops;
+	camera_device->priv = exynos_camera;
+
+	*device = (struct hw_device_t *) &(camera_device->common);
+
+	return 0;
+
+error:
+	exynos_camera_stop(exynos_camera);
+
+error_device:
+	if (camera_device != NULL)
+		free(camera_device);
+
+error_preset:
+	if (exynos_camera != NULL)
+		free(exynos_camera);
+
+	return -1;
+}
+
+int exynos_camera_get_number_of_cameras(void)
+{
+	ALOGD("%s()", __func__);
+
+	if (exynos_camera_config == NULL || exynos_camera_config->presets == NULL) {
+		ALOGE("%s: Unable to find proper camera config", __func__);
+		return -1;
+	}
+
+	return exynos_camera_config->presets_count;
+}
+
+int exynos_camera_get_camera_info(int id, struct camera_info *info)
+{
+	ALOGD("%s(%d, %p)", __func__, id, info);
+
+	if (id < 0 || info == NULL)
+		return -EINVAL;
+
+	if (exynos_camera_config == NULL || exynos_camera_config->presets == NULL) {
+		ALOGE("%s: Unable to find proper camera config", __func__);
+		return -1;
+	}
+
+	if (id >= exynos_camera_config->presets_count)
+		return -EINVAL;
+
+	ALOGD("Selected camera: %s", exynos_camera_config->presets[id].name);
+
+	info->facing = exynos_camera_config->presets[id].facing;
+	info->orientation = exynos_camera_config->presets[id].orientation;
+
+	return 0;
+}
+
+struct hw_module_methods_t exynos_camera_module_methods = {
+	.open = exynos_camera_open,
+};
+
+struct camera_module HAL_MODULE_INFO_SYM = {
+	.common = {
+		.tag = HARDWARE_MODULE_TAG,
+		.hal_api_version = HARDWARE_HAL_API_VERSION,
+		.module_api_version = CAMERA_MODULE_API_VERSION_1_0,
+		.id = CAMERA_HARDWARE_MODULE_ID,
+		.name = "Exynos Camera - Dheeraj CVR",
+		.author = "Paul Kocialkowski",
+		.methods = &exynos_camera_module_methods,
+	},
+	.get_number_of_cameras = exynos_camera_get_number_of_cameras,
+	.get_camera_info = exynos_camera_get_camera_info,
+};
diff --git a/camera/exynos_camera.h b/camera/exynos_camera.h
new file mode 100644
index 0000000..e411b73
--- /dev/null
+++ b/camera/exynos_camera.h
@@ -0,0 +1,674 @@
+/*
+ * Copyright (C) 2013 Paul Kocialkowski
+ *
+ * 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 <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <pthread.h>
+
+#include <linux/videodev2.h>
+#include <linux/videodev2_exynos_camera.h>
+#include <linux/videodev2_exynos_media.h>
+#include <linux/fimc.h>
+
+#include <linux/s5c73m3.h>
+
+#ifdef EXYNOS_JPEG_HW
+#include <jpeg_hal.h>
+#endif
+#include <Exif.h>
+
+#include <hardware/hardware.h>
+#include <hardware/camera.h>
+
+#ifndef _EXYNOS_CAMERA_H_
+#define _EXYNOS_CAMERA_H_
+
+#define EXYNOS_CAMERA_MAX_V4L2_NODES_COUNT	4
+
+#define EXYNOS_CAMERA_CAPTURE_BUFFERS_COUNT	6
+#define EXYNOS_CAMERA_PREVIEW_BUFFERS_COUNT	6
+#define EXYNOS_CAMERA_RECORDING_BUFFERS_COUNT	6
+#define EXYNOS_CAMERA_GRALLOC_BUFFERS_COUNT	3
+
+#define EXYNOS_CAMERA_PICTURE_OUTPUT_FORMAT	V4L2_PIX_FMT_YUYV
+
+#define EXYNOS_CAMERA_MSG_ENABLED(msg) (exynos_camera->messages_enabled & msg)
+#define EXYNOS_CAMERA_CALLBACK_DEFINED(cb) (exynos_camera->callbacks.cb != NULL)
+
+#define EXYNOS_CAMERA_ALIGN(value) ((value + (0x10000 - 1)) & ~(0x10000 - 1))
+
+/*
+ * Structures
+ */
+
+struct exynos_camera;
+
+struct list_head {
+	struct list_head *next;
+	struct list_head *prev;
+};
+
+enum exynos_param_type {
+	EXYNOS_PARAM_INT,
+	EXYNOS_PARAM_FLOAT,
+	EXYNOS_PARAM_STRING,
+};
+
+union exynos_param_data {
+	int integer;
+	float floating;
+	char *string;
+};
+
+struct exynos_param {
+	struct list_head list;
+
+	char *key;
+	union exynos_param_data data;
+	enum exynos_param_type type;
+};
+
+struct exynos_camera_buffer {
+	void *pointer;
+	int address;
+	int length;
+
+	int width;
+	int height;
+	int format;
+};
+
+struct exynos_camera_mbus_resolution {
+	int width;
+	int height;
+	int mbus_width;
+	int mbus_height;
+};
+
+struct exynos_camera_videosnapshot_resolution {
+	int video_width;
+	int video_height;
+	int snapshot_width;
+	int snapshot_height;
+};
+
+struct exynos_camera_params {
+	char *preview_size_values;
+	char *preview_size;
+	char *preview_format_values;
+	char *preview_format;
+	char *preview_frame_rate_values;
+	int preview_frame_rate;
+	char *preview_fps_range_values;
+	char *preview_fps_range;
+
+	char *picture_size_values;
+	char *picture_size;
+	char *picture_format_values;
+	char *picture_format;
+	char *jpeg_thumbnail_size_values;
+	int jpeg_thumbnail_width;
+	int jpeg_thumbnail_height;
+	int jpeg_thumbnail_quality;
+	int jpeg_quality;
+
+	int video_snapshot_supported;
+	int full_video_snap_supported;
+
+	char *recording_size;
+	char *recording_size_values;
+	char *recording_format;
+
+	char *focus_mode;
+	char *focus_mode_values;
+	char *focus_distances;
+	char *focus_areas;
+	int max_num_focus_areas;
+
+	int max_detected_faces;
+
+	int zoom_supported;
+	int smooth_zoom_supported;
+	char *zoom_ratios;
+	int zoom;
+	int max_zoom;
+
+	int auto_exposure_lock_supported;
+	int auto_exposure_lock;
+
+	int auto_white_balance_lock_supported;
+	int auto_white_balance_lock;
+
+	char *flash_mode;
+	char *flash_mode_values;
+
+	int exposure_compensation;
+	float exposure_compensation_step;
+	int min_exposure_compensation;
+	int max_exposure_compensation;
+
+	char *whitebalance;
+	char *whitebalance_values;
+
+	char *antibanding;
+	char *antibanding_values;
+
+	char *scene_mode;
+	char *scene_mode_values;
+
+	char *effect;
+	char *effect_values;
+
+	char *iso;
+	char *iso_values;
+
+	char *image_stabilization; // Anti-shake
+	char *image_stabilization_values;
+};
+
+struct exynos_camera_preset {
+	char *name;
+	int facing;
+	int orientation;
+
+	int rotation;
+	int hflip;
+	int vflip;
+
+	int capture_format;
+	int picture_format;
+	int fimc_is;
+
+	float focal_length;
+	float horizontal_view_angle;
+	float vertical_view_angle;
+
+	int metering;
+
+	struct exynos_camera_params params;
+	struct exynos_camera_mbus_resolution *mbus_resolutions;
+	int mbus_resolutions_count;
+	struct exynos_camera_videosnapshot_resolution *videosnapshot_resolutions;
+	int videosnapshot_resolutions_count;
+};
+
+struct exynos_v4l2_node {
+	int id;
+	char *node;
+};
+
+struct exynos_v4l2_output {
+	int enabled;
+
+	int v4l2_id;
+
+	int width;
+	int height;
+	int format;
+
+	int buffer_width;
+	int buffer_height;
+	int buffer_format;
+
+	camera_memory_t *memory;
+	int memory_address;
+#ifdef EXYNOS_ION
+	int memory_ion_fd;
+#endif
+	int memory_index;
+	int buffers_count;
+	int buffer_length;
+};
+
+struct exynos_exif {
+	int enabled;
+
+	exif_attribute_t attributes;
+	void *jpeg_thumbnail_data;
+	int jpeg_thumbnail_size;
+
+	camera_memory_t *memory;
+	int memory_size;
+};
+
+#ifdef EXYNOS_JPEG_HW
+struct exynos_jpeg {
+	int enabled;
+
+	int fd;
+	struct jpeg_buf buffer_in;
+	struct jpeg_buf buffer_out;
+	camera_memory_t *memory_in;
+	void *memory_in_pointer;
+#ifdef EXYNOS_ION
+	int memory_in_ion_fd;
+#endif
+	camera_memory_t *memory_out;
+	void *memory_out_pointer;
+	int memory_out_size;
+#ifdef EXYNOS_ION
+	int memory_out_ion_fd;
+#endif
+
+	int width;
+	int height;
+	int format;
+
+	int quality;
+};
+#endif
+
+struct exynox_camera_config {
+	struct exynos_camera_preset *presets;
+	int presets_count;
+
+	struct exynos_v4l2_node *v4l2_nodes;
+	int v4l2_nodes_count;
+};
+
+struct exynos_camera_callbacks {
+	camera_notify_callback notify;
+	camera_data_callback data;
+	camera_data_timestamp_callback data_timestamp;
+	camera_request_memory request_memory;
+	void *user;
+};
+
+struct exynos_camera {
+	int v4l2_fds[EXYNOS_CAMERA_MAX_V4L2_NODES_COUNT];
+	int ion_fd;
+
+	struct exynox_camera_config *config;
+	struct exynos_param *params;
+
+	struct exynos_camera_callbacks callbacks;
+	int callback_lock;
+	int messages_enabled;
+
+	gralloc_module_t *gralloc;
+
+	// Capture
+
+	pthread_t capture_thread;
+	pthread_mutex_t capture_mutex;
+	pthread_mutex_t capture_lock_mutex;
+	int capture_thread_running;
+	int capture_thread_enabled;
+
+	int capture_enabled;
+	struct exynos_exif exif;
+	camera_memory_t *capture_memory;
+	int capture_memory_address;
+	int capture_memory_index;
+	void *capture_yuv_buffer;
+	void *capture_jpeg_buffer;
+	int capture_width;
+	int capture_height;
+	int capture_format;
+	int capture_buffers_count;
+	int capture_buffer_length;
+
+	// Preview
+	int preview_enabled;
+	int preview_stopping;
+
+	int preview_output_enabled;
+	struct preview_stream_ops *preview_window;
+	struct exynos_camera_buffer preview_buffer;
+	struct exynos_v4l2_output preview_output;
+
+	// Picture
+
+	pthread_t picture_thread;
+	int picture_running;
+	int picture_enabled;
+
+	int picture_completed;
+	camera_memory_t *picture_memory;
+	struct exynos_camera_buffer picture_jpeg_buffer;
+	struct exynos_camera_buffer picture_yuv_buffer;
+
+	// Face Detection
+	camera_frame_metadata_t mFaceData;
+	camera_memory_t *face_data;
+	int max_detected_faces;
+
+	// Recording
+
+	int recording_running;
+	int recording_enabled;
+
+	int recording_output_enabled;
+	camera_memory_t *recording_memory;
+	int recording_memory_index;
+	struct exynos_camera_buffer recording_buffer;
+	struct exynos_v4l2_output recording_output;
+	int recording_buffers_count;
+	int recording_buffer_length;
+	int recording_metadata;
+
+	// Auto-focus
+
+	int auto_focus_enabled;
+	int auto_focus_started;
+
+	// Camera params
+
+	int camera_rotation;
+	int camera_hflip;
+	int camera_vflip;
+	int camera_capture_format;
+	int camera_picture_format;
+	int camera_fimc_is;
+	int camera_focal_length;
+	int camera_metering;
+
+	struct exynos_camera_mbus_resolution *camera_mbus_resolutions;
+	int camera_mbus_resolutions_count;
+	struct exynos_camera_videosnapshot_resolution *camera_videosnapshot_resolutions;
+	int camera_videosnapshot_resolutions_count;
+
+	int camera_sensor_mode;
+	int fimc_is_mode;
+
+	// Params
+
+	int preview_width;
+	int preview_height;
+	int preview_format;
+	int preview_fps;
+	int picture_width;
+	int picture_height;
+	int picture_format;
+	int jpeg_thumbnail_width;
+	int jpeg_thumbnail_height;
+	int jpeg_thumbnail_quality;
+	int jpeg_quality;
+	int recording_width;
+	int recording_height;
+	int recording_format;
+	int focus_mode;
+	int focus_x;
+	int focus_y;
+	int zoom;
+	int ae_lock;
+	int awb_lock;
+	int flash_mode;
+	int exposure_compensation;
+	int whitebalance;
+	int antibanding;
+	int scene_mode;
+	int effect;
+	int iso;
+	int metering;
+	int image_stabilization;
+	char raw_focus_areas[PAGE_SIZE];
+	char raw_focus_mode[64];
+	char raw_flash_mode[64];
+};
+
+struct exynos_camera_addrs {
+	unsigned int type;
+	unsigned int y;
+	unsigned int cbcr;
+	unsigned int index;
+	unsigned int reserved;
+};
+
+// This is because the linux header uses anonymous union
+struct exynos_v4l2_ext_control {
+	__u32 id;
+	__u32 size;
+	__u32 reserved2[1];
+	union {
+		__s32 value;
+		__s64 value64;
+		char *string;
+	} data;
+} __attribute__ ((packed));
+
+/*
+ * Camera
+ */
+
+// Camera
+int exynos_camera_start(struct exynos_camera *exynos_camera, int id);
+void exynos_camera_stop(struct exynos_camera *exynos_camera);
+
+// Params
+int exynos_camera_params_init(struct exynos_camera *exynos_camera, int id);
+int exynos_camera_params_apply(struct exynos_camera *exynos_camera, int force);
+
+// Capture
+int exynos_camera_capture(struct exynos_camera *exynos_camera);
+int exynos_camera_capture_start(struct exynos_camera *exynos_camera);
+void exynos_camera_capture_stop(struct exynos_camera *exynos_camera);
+int exynos_camera_capture_setup(struct exynos_camera *exynos_camera);
+
+// Preview
+int exynos_camera_preview_output_start(struct exynos_camera *exynos_camera);
+void exynos_camera_preview_output_stop(struct exynos_camera *exynos_camera);
+int exynos_camera_preview(struct exynos_camera *exynos_camera);
+int exynos_camera_preview_start(struct exynos_camera *exynos_camera);
+void exynos_camera_preview_stop(struct exynos_camera *exynos_camera);
+
+// Picture
+void *exynos_camera_picture(void *data);
+int exynos_camera_picture_start(struct exynos_camera *exynos_camera);
+void exynos_camera_picture_thread_start(struct exynos_camera *exynos_camera);
+void exynos_camera_picture_stop(struct exynos_camera *exynos_camera);
+
+// Recording
+int exynos_camera_recording_output_start(struct exynos_camera *exynos_camera);
+void exynos_camera_recording_output_stop(struct exynos_camera *exynos_camera);
+void exynos_camera_recording_frame_release(struct exynos_camera *exynos_camera);
+int exynos_camera_recording(struct exynos_camera *exynos_camera);
+int exynos_camera_recording_start(struct exynos_camera *exynos_camera);
+void exynos_camera_recording_stop(struct exynos_camera *exynos_camera);
+
+// Auto-focus
+int exynos_camera_auto_focus(struct exynos_camera *exynos_camera, int auto_focus_status);
+int exynos_camera_continuous_auto_focus(struct exynos_camera *exynos_camera, int auto_focus_status);
+int exynos_camera_auto_focus_start(struct exynos_camera *exynos_camera);
+void exynos_camera_auto_focus_finish(struct exynos_camera *exynos_camera);
+void exynos_camera_auto_focus_stop(struct exynos_camera *exynos_camera);
+
+/*
+ * EXIF
+ */
+
+int exynos_exif_start(struct exynos_camera *exynos_camera, struct exynos_exif *exif);
+int exynos_exif_create(struct exynos_camera *exynos_camera, struct exynos_exif *exif);
+void exynos_exif_stop(struct exynos_camera *exynos_camera,
+	struct exynos_exif *exif);
+int exynos_exif(struct exynos_camera *exynos_camera, struct exynos_exif *exif);
+
+/*
+ * ION
+ */
+
+#ifdef EXYNOS_ION
+int exynos_ion_init(struct exynos_camera *exynos_camera);
+int exynos_ion_open(struct exynos_camera *exynos_camera);
+void exynos_ion_close(struct exynos_camera *exynos_camera);
+int exynos_ion_alloc(struct exynos_camera *exynos_camera, int size);
+int exynos_ion_free(struct exynos_camera *exynos_camera, int fd);
+int exynos_ion_phys(struct exynos_camera *exynos_camera, int fd);
+int exynos_ion_msync(struct exynos_camera *exynos_camera, int fd,
+	int offset, int size);
+#endif
+
+/*
+ * Jpeg
+ */
+
+int exynos_jpeg_start(struct exynos_camera *exynos_camera,
+	struct exynos_jpeg *jpeg);
+void exynos_jpeg_stop(struct exynos_camera *exynos_camera,
+	struct exynos_jpeg *jpeg);
+int exynos_jpeg(struct exynos_camera *exynos_camera, struct exynos_jpeg *jpeg);
+
+/*
+ * Param
+ */
+
+int exynos_param_int_get(struct exynos_camera *exynos_camera,
+	char *key);
+float exynos_param_float_get(struct exynos_camera *exynos_camera,
+	char *key);
+char *exynos_param_string_get(struct exynos_camera *exynos_camera,
+	char *key);
+int exynos_param_int_set(struct exynos_camera *exynos_camera,
+	char *key, int integer);
+int exynos_param_float_set(struct exynos_camera *exynos_camera,
+	char *key, float floating);
+int exynos_param_string_set(struct exynos_camera *exynos_camera,
+	char *key, char *string);
+char *exynos_params_string_get(struct exynos_camera *exynos_camera);
+int exynos_params_string_set(struct exynos_camera *exynos_camera, char *string);
+
+/*
+ * Utils
+ */
+
+int list_head_insert(struct list_head *list, struct list_head *prev,
+	struct list_head *next);
+void list_head_remove(struct list_head *list);
+
+int exynos_camera_buffer_length(int width, int height, int format);
+void exynos_camera_yuv_planes(int width, int height, int format, int address, int *address_y, int *address_cb, int *address_cr);
+
+/*
+ * V4L2
+ */
+
+int exynos_v4l2_init(struct exynos_camera *exynos_camera);
+int exynos_v4l2_index(struct exynos_camera *exynos_camera, int exynos_v4l2_id);
+int exynos_v4l2_fd(struct exynos_camera *exynos_camera, int exynos_v4l2_id);
+
+int exynos_v4l2_open(struct exynos_camera *exynos_camera, int exynos_v4l2_id);
+void exynos_v4l2_close(struct exynos_camera *exynos_camera, int exynos_v4l2_id);
+int exynos_v4l2_ioctl(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int request, void *data);
+int exynos_v4l2_poll(struct exynos_camera *exynos_camera, int exynos_v4l2_id);
+int exynos_v4l2_qbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int type, int memory, int index, unsigned long userptr);
+int exynos_v4l2_s_ext_ctrl_face_detection(struct exynos_camera *exynos_camera,
+	int id, void *value);
+int exynos_v4l2_qbuf_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int index);
+int exynos_v4l2_qbuf_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int index, unsigned long userptr);
+int exynos_v4l2_dqbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int type, int memory);
+int exynos_v4l2_dqbuf_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id);
+int exynos_v4l2_dqbuf_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id);
+int exynos_v4l2_reqbufs(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type, int memory, int count);
+int exynos_v4l2_reqbufs_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int count);
+int exynos_v4l2_reqbufs_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int count);
+int exynos_v4l2_querybuf(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type, int memory, int index);
+int exynos_v4l2_querybuf_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int index);
+int exynos_v4l2_querybuf_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int index);
+int exynos_v4l2_querycap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int flags);
+int exynos_v4l2_querycap_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id);
+int exynos_v4l2_querycap_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id);
+int exynos_v4l2_streamon(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type);
+int exynos_v4l2_streamon_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id);
+int exynos_v4l2_streamon_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id);
+int exynos_v4l2_streamoff(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type);
+int exynos_v4l2_streamoff_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id);
+int exynos_v4l2_streamoff_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id);
+int exynos_v4l2_g_fmt(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int type, int *width, int *height, int *fmt);
+int exynos_v4l2_g_fmt_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int *width, int *height, int *fmt);
+int exynos_v4l2_g_fmt_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int *width, int *height, int *fmt);
+int exynos_v4l2_s_fmt_pix(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type, int width, int height, int fmt, int field,
+	int priv);
+int exynos_v4l2_s_fmt_pix_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int width, int height, int fmt, int priv);
+int exynos_v4l2_s_fmt_pix_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int width, int height, int fmt, int priv);
+int exynos_v4l2_s_fmt_win(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int left, int top, int width, int height);
+int exynos_v4l2_enum_fmt(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type, int fmt);
+int exynos_v4l2_enum_fmt_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int fmt);
+int exynos_v4l2_enum_fmt_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int fmt);
+int exynos_v4l2_enum_input(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int id);
+int exynos_v4l2_s_input(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int id);
+int exynos_v4l2_g_ext_ctrls(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, struct v4l2_ext_control *control, int count);
+int exynos_v4l2_g_ctrl(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int id, int *value);
+int exynos_v4l2_s_ctrl(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int id, int value);
+int exynos_v4l2_s_parm(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int type, struct v4l2_streamparm *streamparm);
+int exynos_v4l2_s_parm_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, struct v4l2_streamparm *streamparm);
+int exynos_v4l2_s_parm_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, struct v4l2_streamparm *streamparm);
+int exynos_v4l2_s_crop(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int type, int left, int top, int width, int height);
+int exynos_v4l2_s_crop_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int left, int top, int width, int height);
+int exynos_v4l2_s_crop_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int left, int top, int width, int height);
+int exynos_v4l2_g_fbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	void **base, int *width, int *height, int *fmt);
+int exynos_v4l2_s_fbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	void *base, int width, int height, int fmt);
+
+/*
+ * V4L2 Output
+ */
+
+int exynos_v4l2_output_start(struct exynos_camera *exynos_camera,
+	struct exynos_v4l2_output *output);
+void exynos_v4l2_output_stop(struct exynos_camera *exynos_camera,
+	struct exynos_v4l2_output *output);
+int exynos_v4l2_output(struct exynos_camera *exynos_camera,
+	struct exynos_v4l2_output *output, int buffer_address);
+int exynos_v4l2_output_release(struct exynos_camera *exynos_camera,
+	struct exynos_v4l2_output *output);
+
+#endif
diff --git a/camera/smdk4x12_exif.c b/camera/exynos_exif.c
index f2024fd..486b256 100644
--- a/camera/smdk4x12_exif.c
+++ b/camera/exynos_exif.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 Paul Kocialkowski <contact@paulk.fr>
+ * Copyright (C) 2013 Paul Kocialkowski
  *
  * Based on crespo libcamera and exynos4 hal libcamera:
  * Copyright 2008, The Android Open Source Project
@@ -33,21 +33,21 @@
 
 #include <Exif.h>
 
-#define LOG_TAG "smdk4x12_camera"
+#define LOG_TAG "exynos_camera"
 #include <utils/Log.h>
 #include <cutils/properties.h>
 
-#include "smdk4x12_camera.h"
+#include "exynos_camera.h"
 
-int smdk4x12_exif_attributes_create_static(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_exif *exif)
+int exynos_exif_attributes_create_static(struct exynos_camera *exynos_camera,
+	struct exynos_exif *exif)
 {
 	exif_attribute_t *attributes;
 	unsigned char gps_version[] = { 0x02, 0x02, 0x00, 0x00 };
 	char property[PROPERTY_VALUE_MAX];
 	uint32_t av;
 
-	if (smdk4x12_camera == NULL || exif == NULL)
+	if (exynos_camera == NULL || exif == NULL)
 		return -EINVAL;
 
 	attributes = &exif->attributes;
@@ -104,8 +104,8 @@ int smdk4x12_exif_attributes_create_static(struct smdk4x12_camera *smdk4x12_came
 	return 0;
 }
 
-int smdk4x12_exif_attributes_create_gps(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_exif *exif)
+int exynos_exif_attributes_create_gps(struct exynos_camera *exynos_camera,
+	struct exynos_exif *exif)
 {
 	exif_attribute_t *attributes;
 	float gps_latitude_float, gps_longitude_float, gps_altitude_float;
@@ -117,18 +117,18 @@ int smdk4x12_exif_attributes_create_gps(struct smdk4x12_camera *smdk4x12_camera,
 
 	struct tm time_info;
 
-	if (smdk4x12_camera == NULL || exif == NULL)
+	if (exynos_camera == NULL || exif == NULL)
 		return -EINVAL;
 
 	attributes = &exif->attributes;
 
-	gps_latitude_float = smdk4x12_param_float_get(smdk4x12_camera, "gps-latitude");
-	gps_longitude_float = smdk4x12_param_float_get(smdk4x12_camera, "gps-longitude");
-	gps_altitude_float = smdk4x12_param_float_get(smdk4x12_camera, "gps-altitude");
+	gps_latitude_float = exynos_param_float_get(exynos_camera, "gps-latitude");
+	gps_longitude_float = exynos_param_float_get(exynos_camera, "gps-longitude");
+	gps_altitude_float = exynos_param_float_get(exynos_camera, "gps-altitude");
 	if (gps_altitude_float == -1)
-		gps_altitude_float = (float) smdk4x12_param_int_get(smdk4x12_camera, "gps-altitude");
-	gps_timestamp_int = smdk4x12_param_int_get(smdk4x12_camera, "gps-timestamp");
-	gps_processing_method_string = smdk4x12_param_string_get(smdk4x12_camera, "gps-processing-method");
+		gps_altitude_float = (float) exynos_param_int_get(exynos_camera, "gps-altitude");
+	gps_timestamp_int = exynos_param_int_get(exynos_camera, "gps-timestamp");
+	gps_processing_method_string = exynos_param_string_get(exynos_camera, "gps-processing-method");
 
 	if (gps_latitude_float == -1 || gps_longitude_float == -1 ||
 		gps_altitude_float == -1 || gps_timestamp_int <= 0 ||
@@ -195,13 +195,14 @@ int smdk4x12_exif_attributes_create_gps(struct smdk4x12_camera *smdk4x12_camera,
 	snprintf((char *) attributes->gps_datestamp, sizeof(attributes->gps_datestamp),
 		"%04d:%02d:%02d", time_info.tm_year + 1900, time_info.tm_mon + 1, time_info.tm_mday);
 
+	strcpy((char *) attributes->gps_processing_method, gps_processing_method_string);
 	attributes->enableGps = true;
 
 	return 0;
 }
 
-int smdk4x12_exif_attributes_create_params(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_exif *exif)
+int exynos_exif_attributes_create_params(struct exynos_camera *exynos_camera,
+	struct exynos_exif *exif)
 {
 	exif_attribute_t *attributes;
 	uint32_t av, tv, bv, sv, ev;
@@ -216,25 +217,25 @@ int smdk4x12_exif_attributes_create_params(struct smdk4x12_camera *smdk4x12_came
 
 	int rc;
 
-	if (smdk4x12_camera == NULL || exif == NULL)
+	if (exynos_camera == NULL || exif == NULL)
 		return -EINVAL;
 
 	attributes = &exif->attributes;
 
 	// Picture size
 
-	attributes->width = smdk4x12_camera->picture_width;
-	attributes->height = smdk4x12_camera->picture_height;
+	attributes->width = exynos_camera->picture_width;
+	attributes->height = exynos_camera->picture_height;
 
 	// Thumbnail
 
-	attributes->widthThumb = smdk4x12_camera->jpeg_thumbnail_width;
-	attributes->heightThumb = smdk4x12_camera->jpeg_thumbnail_height;
+	attributes->widthThumb = exynos_camera->jpeg_thumbnail_width;
+	attributes->heightThumb = exynos_camera->jpeg_thumbnail_height;
 	attributes->enableThumb = true;
 
 	// Orientation
 
-	rotation = smdk4x12_param_int_get(smdk4x12_camera, "rotation");
+	rotation = exynos_param_int_get(exynos_camera, "rotation");
 	switch (rotation) {
 		case 90:
 			attributes->orientation = EXIF_ORIENTATION_90;
@@ -258,84 +259,74 @@ int smdk4x12_exif_attributes_create_params(struct smdk4x12_camera *smdk4x12_came
 	strftime((char *) attributes->date_time, sizeof(attributes->date_time),
 		"%Y:%m:%d %H:%M:%S", time_info);
 
-	attributes->focal_length.num = smdk4x12_camera->camera_focal_length;
+	attributes->focal_length.num = exynos_camera->camera_focal_length;
 	attributes->focal_length.den = EXIF_DEF_FOCAL_LEN_DEN;
 
-	if (smdk4x12_camera->camera_capture_format == V4L2_PIX_FMT_INTERLEAVED) {
-		attributes->shutter_speed.num = APEX_EXPOSURE_TO_SHUTTER(smdk4x12_camera->capture_exif_exposure_time);
-		attributes->shutter_speed.den = 100;
-
-		attributes->exposure_time.num = 1;
-		attributes->exposure_time.den = smdk4x12_camera->capture_exif_exposure_time;
-
-		attributes->iso_speed_rating = smdk4x12_camera->capture_exif_iso;
-
-		attributes->flash = smdk4x12_camera->capture_exif_flash;
-
-		bv = smdk4x12_camera->capture_exif_exposure;
-		ev = smdk4x12_camera->capture_exif_exposure_bias;
-	} else {
-		shutter_speed = 100;
-		rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_EXIF_TV,
-			&shutter_speed);
+	// Only Query the Front Camera Sensor for EXIF Attributes.
+	if (exynos_camera->camera_fimc_is) {
+		rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EXIF_EXPTIME,
+			&exposure_time);
 		if (rc < 0)
-			ALOGE("%s: Unable to get shutter speed", __func__);
-
-		attributes->shutter_speed.num = shutter_speed;
-		attributes->shutter_speed.den = 100;
+			ALOGE("%s: Unable to get exposure time", __func__);
 
-		attributes->exposure_time.num = 1;
-		attributes->exposure_time.den = APEX_SHUTTER_TO_EXPOSURE(shutter_speed);
+		attributes->exposure_time.den = exposure_time;
 
-		rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_EXIF_ISO,
+		rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EXIF_ISO,
 			&iso_speed);
 		if (rc < 0)
 			ALOGE("%s: Unable to get iso", __func__);
 
 		attributes->iso_speed_rating = iso_speed;
 
-		rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_EXIF_FLASH,
+		rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EXIF_FLASH,
 			&flash_results);
 		if (rc < 0)
 			ALOGE("%s: Unable to get flash", __func__);
 
 		attributes->flash = flash_results;
 
-		rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_EXIF_BV,
-			(int *) &bv);
+		rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EXIF_BV,
+		(int *) &bv);
 		if (rc < 0) {
 			ALOGE("%s: Unable to get bv", __func__);
 			goto bv_static;
 		}
 
-		rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_EXIF_EBV,
+		rc = exynos_v4l2_g_ctrl(exynos_camera, 0, V4L2_CID_CAMERA_EXIF_EBV,
 			(int *) &ev);
 		if (rc < 0) {
 			ALOGE("%s: Unable to get ebv", __func__);
 			goto bv_static;
 		}
-	}
 
-	goto bv_camera;
+		goto bv_ioctl;
 
 bv_static:
-	exposure = smdk4x12_param_int_get(smdk4x12_camera, "exposure-compensation");
-	if (exposure < 0)
-		exposure = EV_DEFAULT;
+		exposure = exynos_param_int_get(exynos_camera, "exposure-compensation");
+		if (exposure < 0)
+			exposure = EV_DEFAULT;
+
+		av = APEX_FNUM_TO_APERTURE((double) attributes->fnumber.num /
+			attributes->fnumber.den);
+		tv = APEX_EXPOSURE_TO_SHUTTER((double) attributes->exposure_time.num /
+			attributes->exposure_time.den);
+		sv = APEX_ISO_TO_FILMSENSITIVITY(iso_speed);
+		bv = av + tv - sv;
+		ev = exposure - EV_DEFAULT;
+
+
+bv_ioctl:
+		attributes->brightness.num = bv;
+	}
+
+	attributes->shutter_speed.num = APEX_EXPOSURE_TO_SHUTTER(attributes->exposure_time.den);
+	attributes->shutter_speed.den = 100;
+
+	attributes->exposure_time.num = 1;
 
-	av = APEX_FNUM_TO_APERTURE((double) attributes->fnumber.num /
-		attributes->fnumber.den);
-	tv = APEX_EXPOSURE_TO_SHUTTER((double) attributes->exposure_time.num /
-		attributes->exposure_time.den);
-	sv = APEX_ISO_TO_FILMSENSITIVITY(iso_speed);
-	bv = av + tv - sv;
-	ev = exposure - EV_DEFAULT;
-
-bv_camera:
-	attributes->brightness.num = bv;
 	attributes->brightness.den = EXIF_DEF_APEX_DEN;
 
-	if (smdk4x12_camera->scene_mode == SCENE_MODE_BEACH_SNOW) {
+	if (exynos_camera->scene_mode == SCENE_MODE_BEACH_SNOW) {
 		attributes->exposure_bias.num = EXIF_DEF_APEX_DEN;
 		attributes->exposure_bias.den = EXIF_DEF_APEX_DEN;
 	} else {
@@ -343,7 +334,7 @@ bv_camera:
 		attributes->exposure_bias.den = EXIF_DEF_APEX_DEN;
 	}
 
-	switch (smdk4x12_camera->camera_metering) {
+	switch (exynos_camera->camera_metering) {
 		case METERING_CENTER:
 			attributes->metering_mode = EXIF_METERING_CENTER;
 			break;
@@ -358,13 +349,13 @@ bv_camera:
 			break;
 	}
 
-	if (smdk4x12_camera->whitebalance == WHITE_BALANCE_AUTO ||
-		smdk4x12_camera->whitebalance == WHITE_BALANCE_BASE)
+	if (exynos_camera->whitebalance == WHITE_BALANCE_AUTO ||
+		exynos_camera->whitebalance == WHITE_BALANCE_BASE)
 		attributes->white_balance = EXIF_WB_AUTO;
 	else
 		attributes->white_balance = EXIF_WB_MANUAL;
 
-	switch (smdk4x12_camera->scene_mode) {
+	switch (exynos_camera->scene_mode) {
 		case SCENE_MODE_PORTRAIT:
 			attributes->scene_capture_type = EXIF_SCENE_PORTRAIT;
 			break;
@@ -379,7 +370,7 @@ bv_camera:
 			break;
 	}
 
-	rc = smdk4x12_exif_attributes_create_gps(smdk4x12_camera, exif);
+	rc = exynos_exif_attributes_create_gps(exynos_camera, exif);
 	if (rc < 0) {
 		ALOGE("%s: Unable to create GPS attributes", __func__);
 		return -1;
@@ -388,7 +379,7 @@ bv_camera:
 	return 0;
 }
 
-int smdk4x12_exif_write_data(void *exif_data, unsigned short tag,
+int exynos_exif_write_data(void *exif_data, unsigned short tag,
 	unsigned short type, unsigned int count, unsigned int *offset, void *start,
 	void *data, int length)
 {
@@ -424,11 +415,11 @@ int smdk4x12_exif_write_data(void *exif_data, unsigned short tag,
 	return size;
 }
 
-int smdk4x12_exif_start(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif *exif)
+int exynos_exif_start(struct exynos_camera *exynos_camera, struct exynos_exif *exif)
 {
 	int rc;
 
-	if (smdk4x12_camera == NULL || exif == NULL)
+	if (exynos_camera == NULL || exif == NULL)
 		return -EINVAL;
 
 	ALOGD("%s()", __func__);
@@ -438,13 +429,15 @@ int smdk4x12_exif_start(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12
 		return -1;
 	}
 
-	rc = smdk4x12_exif_attributes_create_static(smdk4x12_camera, exif);
+	memset(&exif->attributes, 0, sizeof(exif_attribute_t));
+
+	rc = exynos_exif_attributes_create_static(exynos_camera, exif);
 	if (rc < 0) {
 		ALOGE("%s: Unable to create exif attributes", __func__);
 		goto error;
 	}
 
-	rc = smdk4x12_exif_attributes_create_params(smdk4x12_camera, exif);
+	rc = exynos_exif_attributes_create_params(exynos_camera, exif);
 	if (rc < 0) {
 		ALOGE("%s: Unable to create exif parameters", __func__);
 		goto error;
@@ -462,10 +455,28 @@ complete:
 	return rc;
 }
 
-void smdk4x12_exif_stop(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_exif *exif)
+int exynos_exif_create(struct exynos_camera *exynos_camera, struct exynos_exif *exif)
+{
+	int rc;
+
+	rc = exynos_exif_attributes_create_params(exynos_camera, exif);
+	if (rc < 0) {
+		ALOGE("%s: Unable to create exif parameters", __func__);
+		goto error;
+	}
+
+	goto complete;
+error:
+	rc = -1;
+
+complete:
+	return rc;
+}
+
+void exynos_exif_stop(struct exynos_camera *exynos_camera,
+	struct exynos_exif *exif)
 {
-	if (smdk4x12_camera == NULL || exif == NULL)
+	if (exynos_camera == NULL || exif == NULL)
 		return;
 
 	ALOGD("%s()", __func__);
@@ -483,7 +494,7 @@ void smdk4x12_exif_stop(struct smdk4x12_camera *smdk4x12_camera,
 	exif->enabled = 0;
 }
 
-int smdk4x12_exif(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif *exif)
+int exynos_exif(struct exynos_camera *exynos_camera, struct exynos_exif *exif)
 {
 	// Markers
 	unsigned char exif_app1_marker[] = { 0xff, 0xe1 };
@@ -510,7 +521,7 @@ int smdk4x12_exif(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif
 	int count;
 	int rc;
 
-	if (smdk4x12_camera == NULL || exif == NULL)
+	if (exynos_camera == NULL || exif == NULL)
 		return -EINVAL;
 
 	ALOGD("%s()", __func__);
@@ -532,8 +543,8 @@ int smdk4x12_exif(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif
 
 	memory_size = EXIF_FILE_SIZE + jpeg_thumbnail_size;
 
-	if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) {
-		memory = smdk4x12_camera->callbacks.request_memory(-1, memory_size, 1, smdk4x12_camera->callbacks.user);
+	if (EXYNOS_CAMERA_CALLBACK_DEFINED(request_memory)) {
+		memory = exynos_camera->callbacks.request_memory(-1, memory_size, 1, exynos_camera->callbacks.user);
 		if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) {
 			ALOGE("%s: Unable to request memory", __func__);
 			goto error;
@@ -571,39 +582,39 @@ int smdk4x12_exif(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif
 	offset = 8 + NUM_SIZE + value * IFD_SIZE + OFFSET_SIZE;
 
 	// Write EXIF data
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_IMAGE_WIDTH,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_IMAGE_WIDTH,
 		EXIF_TYPE_LONG, 1, NULL, NULL, &attributes->width, sizeof(attributes->width));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_IMAGE_HEIGHT,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_IMAGE_HEIGHT,
 		EXIF_TYPE_LONG, 1, NULL, NULL, &attributes->height, sizeof(attributes->height));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_MAKE,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_MAKE,
 		EXIF_TYPE_ASCII, strlen((char *) attributes->maker) + 1, &offset, exif_ifd_start, &attributes->maker, sizeof(char));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_MODEL,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_MODEL,
 		EXIF_TYPE_ASCII, strlen((char *) attributes->model) + 1, &offset, exif_ifd_start, &attributes->model, sizeof(char));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_ORIENTATION,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_ORIENTATION,
 		EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->orientation, sizeof(attributes->orientation));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_SOFTWARE,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_SOFTWARE,
 		EXIF_TYPE_ASCII, strlen((char *) attributes->software) + 1, &offset, exif_ifd_start, &attributes->software, sizeof(char));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_DATE_TIME,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_DATE_TIME,
 		EXIF_TYPE_ASCII, 20, &offset, exif_ifd_start, &attributes->date_time, sizeof(char));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_YCBCR_POSITIONING,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_YCBCR_POSITIONING,
 		EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->ycbcr_positioning, sizeof(attributes->ycbcr_positioning));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_EXIF_IFD_POINTER,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_EXIF_IFD_POINTER,
 		EXIF_TYPE_LONG, 1, NULL, NULL, &offset, sizeof(offset));
 	pointer += count;
 
@@ -624,63 +635,63 @@ int smdk4x12_exif(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif
 
 	offset += NUM_SIZE + NUM_0TH_IFD_EXIF * IFD_SIZE + OFFSET_SIZE;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_EXPOSURE_TIME,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_EXPOSURE_TIME,
 		EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &attributes->exposure_time, sizeof(attributes->exposure_time));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_FNUMBER,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_FNUMBER,
 		EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &attributes->fnumber, sizeof(attributes->fnumber));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_EXPOSURE_PROGRAM,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_EXPOSURE_PROGRAM,
 		EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->exposure_program, sizeof(attributes->exposure_program));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_ISO_SPEED_RATING,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_ISO_SPEED_RATING,
 		EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->iso_speed_rating, sizeof(attributes->iso_speed_rating));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_EXIF_VERSION,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_EXIF_VERSION,
 		EXIF_TYPE_UNDEFINED, 4, NULL, NULL, &attributes->exif_version, sizeof(char));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_DATE_TIME_ORG,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_DATE_TIME_ORG,
 		EXIF_TYPE_ASCII, 20, &offset, exif_ifd_start, &attributes->date_time, sizeof(char));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_DATE_TIME_DIGITIZE,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_DATE_TIME_DIGITIZE,
 		EXIF_TYPE_ASCII, 20, &offset, exif_ifd_start, &attributes->date_time, sizeof(char));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_SHUTTER_SPEED,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_SHUTTER_SPEED,
 		EXIF_TYPE_SRATIONAL, 1, &offset, exif_ifd_start, &attributes->shutter_speed, sizeof(attributes->shutter_speed));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_APERTURE,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_APERTURE,
 		EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &attributes->aperture, sizeof(attributes->aperture));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_BRIGHTNESS,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_BRIGHTNESS,
 		EXIF_TYPE_SRATIONAL, 1, &offset, exif_ifd_start, &attributes->brightness, sizeof(attributes->brightness));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_EXPOSURE_BIAS,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_EXPOSURE_BIAS,
 		EXIF_TYPE_SRATIONAL, 1, &offset, exif_ifd_start, &attributes->exposure_bias, sizeof(attributes->exposure_bias));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_MAX_APERTURE,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_MAX_APERTURE,
 		EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &attributes->max_aperture, sizeof(attributes->max_aperture));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_METERING_MODE,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_METERING_MODE,
 		EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->metering_mode, sizeof(attributes->metering_mode));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_FLASH,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_FLASH,
 		EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->flash, sizeof(attributes->flash));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_FOCAL_LENGTH,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_FOCAL_LENGTH,
 		EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &attributes->focal_length, sizeof(attributes->focal_length));
 	pointer += count;
 
@@ -688,31 +699,31 @@ int smdk4x12_exif(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif
 	memmove(attributes->user_comment + sizeof(user_comment_code), attributes->user_comment, value);
 	memcpy(attributes->user_comment, user_comment_code, sizeof(user_comment_code));
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_USER_COMMENT,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_USER_COMMENT,
 		EXIF_TYPE_UNDEFINED, value + sizeof(user_comment_code), &offset, exif_ifd_start, &attributes->user_comment, sizeof(char));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_COLOR_SPACE,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_COLOR_SPACE,
 		EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->color_space, sizeof(attributes->color_space));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_PIXEL_X_DIMENSION,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_PIXEL_X_DIMENSION,
 		EXIF_TYPE_LONG, 1, NULL, NULL, &attributes->width, sizeof(attributes->width));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_PIXEL_Y_DIMENSION,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_PIXEL_Y_DIMENSION,
 		EXIF_TYPE_LONG, 1, NULL, NULL, &attributes->height, sizeof(attributes->height));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_EXPOSURE_MODE,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_EXPOSURE_MODE,
 		EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->exposure_mode, sizeof(attributes->exposure_mode));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_WHITE_BALANCE,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_WHITE_BALANCE,
 		EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->white_balance, sizeof(attributes->white_balance));
 	pointer += count;
 
-	count = smdk4x12_exif_write_data(pointer, EXIF_TAG_SCENCE_CAPTURE_TYPE,
+	count = exynos_exif_write_data(pointer, EXIF_TAG_SCENCE_CAPTURE_TYPE,
 		EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->scene_capture_type, sizeof(attributes->scene_capture_type));
 	pointer += count;
 
@@ -723,7 +734,7 @@ int smdk4x12_exif(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif
 	// GPS
 	if (attributes->enableGps) {
 		pointer = (unsigned char *) exif_ifd_gps;
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_GPS_IFD_POINTER,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_IFD_POINTER,
 			EXIF_TYPE_LONG, 1, NULL, NULL, &offset, sizeof(offset));
 
 		pointer = (unsigned char *) exif_ifd_start + offset;
@@ -738,35 +749,35 @@ int smdk4x12_exif(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif
 
 		offset += NUM_SIZE + value * IFD_SIZE + OFFSET_SIZE;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_GPS_VERSION_ID,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_VERSION_ID,
 			EXIF_TYPE_BYTE, 4, NULL, NULL, &attributes->gps_version_id, sizeof(char));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_GPS_LATITUDE_REF,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_LATITUDE_REF,
 			EXIF_TYPE_ASCII, 2, NULL, NULL, &attributes->gps_latitude_ref, sizeof(char));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_GPS_LATITUDE,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_LATITUDE,
 			EXIF_TYPE_RATIONAL, 3, &offset, exif_ifd_start, &attributes->gps_latitude, sizeof(attributes->gps_latitude[0]));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_GPS_LONGITUDE_REF,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_LONGITUDE_REF,
 			EXIF_TYPE_ASCII, 2, NULL, NULL, &attributes->gps_longitude_ref, sizeof(char));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_GPS_LONGITUDE,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_LONGITUDE,
 			EXIF_TYPE_RATIONAL, 3, &offset, exif_ifd_start, &attributes->gps_longitude, sizeof(attributes->gps_longitude[0]));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_GPS_ALTITUDE_REF,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_ALTITUDE_REF,
 			EXIF_TYPE_BYTE, 1, NULL, NULL, &attributes->gps_altitude_ref, sizeof(char));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_GPS_ALTITUDE,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_ALTITUDE,
 			EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &attributes->gps_altitude, sizeof(attributes->gps_altitude));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_GPS_TIMESTAMP,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_TIMESTAMP,
 			EXIF_TYPE_RATIONAL, 3, &offset, exif_ifd_start, &attributes->gps_timestamp, sizeof(attributes->gps_timestamp[0]));
 		pointer += count;
 
@@ -778,14 +789,14 @@ int smdk4x12_exif(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif
 			memcpy(data, &exif_ascii_prefix, sizeof(exif_ascii_prefix));
 			memcpy((void *) ((int) data + (int) sizeof(exif_ascii_prefix)), attributes->gps_processing_method, value);
 
-			count = smdk4x12_exif_write_data(pointer, EXIF_TAG_GPS_PROCESSING_METHOD,
+			count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_PROCESSING_METHOD,
 				EXIF_TYPE_UNDEFINED, value + sizeof(exif_ascii_prefix), &offset, exif_ifd_start, data, sizeof(char));
 			pointer += count;
 
 			free(data);
 		}
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_GPS_DATESTAMP,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_GPS_DATESTAMP,
 				EXIF_TYPE_ASCII, 11, &offset, exif_ifd_start, &attributes->gps_datestamp, 1);
 		pointer += count;
 
@@ -806,41 +817,41 @@ int smdk4x12_exif(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif
 
 		offset += NUM_SIZE + NUM_1TH_IFD_TIFF * IFD_SIZE + OFFSET_SIZE;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_IMAGE_WIDTH,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_IMAGE_WIDTH,
 				EXIF_TYPE_LONG, 1, NULL, NULL, &attributes->widthThumb, sizeof(attributes->widthThumb));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_IMAGE_HEIGHT,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_IMAGE_HEIGHT,
 				EXIF_TYPE_LONG, 1, NULL, NULL, &attributes->heightThumb, sizeof(attributes->heightThumb));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_COMPRESSION_SCHEME,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_COMPRESSION_SCHEME,
 				EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->compression_scheme, sizeof(attributes->compression_scheme));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_ORIENTATION,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_ORIENTATION,
 				EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->orientation, sizeof(attributes->orientation));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_X_RESOLUTION,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_X_RESOLUTION,
 				EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &attributes->x_resolution, sizeof(attributes->x_resolution));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_Y_RESOLUTION,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_Y_RESOLUTION,
 				EXIF_TYPE_RATIONAL, 1, &offset, exif_ifd_start, &attributes->y_resolution, sizeof(attributes->y_resolution));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_RESOLUTION_UNIT,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_RESOLUTION_UNIT,
 				EXIF_TYPE_SHORT, 1, NULL, NULL, &attributes->resolution_unit, sizeof(attributes->resolution_unit));
 		pointer += count;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_JPEG_INTERCHANGE_FORMAT,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_JPEG_INTERCHANGE_FORMAT,
 				EXIF_TYPE_LONG, 1, NULL, NULL, &offset, sizeof(offset));
 		pointer += count;
 
 		value = (unsigned int) jpeg_thumbnail_size;
 
-		count = smdk4x12_exif_write_data(pointer, EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LEN,
+		count = exynos_exif_write_data(pointer, EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LEN,
 				EXIF_TYPE_LONG, 1, NULL, NULL, &value, sizeof(value));
 		pointer += count;
 
diff --git a/camera/smdk4x12_ion.c b/camera/exynos_ion.c
index 39b2b06..6adf7cc 100644
--- a/camera/smdk4x12_ion.c
+++ b/camera/exynos_ion.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr>
+ * Copyright (C) 2013 Paul Kocialkowski
  *
  * 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
@@ -22,21 +22,21 @@
 #include <malloc.h>
 #include <ctype.h>
 
-#include <ion.h>
+#include <linux/ion.h>
 
-#define LOG_TAG "smdk4x12_ion"
+#define LOG_TAG "exynos_ion"
 #include <utils/Log.h>
 
-#include "smdk4x12_camera.h"
+#include "exynos_camera.h"
 
-int smdk4x12_ion_init(struct smdk4x12_camera *smdk4x12_camera)
+int exynos_ion_init(struct exynos_camera *exynos_camera)
 {
-	smdk4x12_camera->ion_fd = -1;
+	exynos_camera->ion_fd = -1;
 
 	return 0;
 }
 
-int smdk4x12_ion_open(struct smdk4x12_camera *smdk4x12_camera)
+int exynos_ion_open(struct exynos_camera *exynos_camera)
 {
 	int fd;
 
@@ -46,20 +46,20 @@ int smdk4x12_ion_open(struct smdk4x12_camera *smdk4x12_camera)
 		return -1;
 	}
 
-	smdk4x12_camera->ion_fd = fd;
+	exynos_camera->ion_fd = fd;
 
 	return 0;
 }
 
-void smdk4x12_ion_close(struct smdk4x12_camera *smdk4x12_camera)
+void exynos_ion_close(struct exynos_camera *exynos_camera)
 {
-	if (smdk4x12_camera->ion_fd >= 0)
-		close(smdk4x12_camera->ion_fd);
+	if (exynos_camera->ion_fd >= 0)
+		close(exynos_camera->ion_fd);
 
-	smdk4x12_camera->ion_fd = -1;
+	exynos_camera->ion_fd = -1;
 }
 
-int smdk4x12_ion_alloc(struct smdk4x12_camera *smdk4x12_camera, int size)
+int exynos_ion_alloc(struct exynos_camera *exynos_camera, int size)
 {
 	struct ion_allocation_data alloc_data;
 	struct ion_fd_data share_data;
@@ -70,7 +70,7 @@ int smdk4x12_ion_alloc(struct smdk4x12_camera *smdk4x12_camera, int size)
 
 	page_size = getpagesize();
 
-	fd = smdk4x12_camera->ion_fd;
+	fd = exynos_camera->ion_fd;
 	if (fd < 0)
 		return -1;
 
@@ -100,13 +100,13 @@ int smdk4x12_ion_alloc(struct smdk4x12_camera *smdk4x12_camera, int size)
 	return share_data.fd;
 }
 
-int smdk4x12_ion_free(struct smdk4x12_camera *smdk4x12_camera, int fd)
+int exynos_ion_free(struct exynos_camera *exynos_camera, int fd)
 {
 	close(fd);
 	return 0;
 }
 
-int smdk4x12_ion_phys(struct smdk4x12_camera *smdk4x12_camera, int fd)
+int exynos_ion_phys(struct exynos_camera *exynos_camera, int fd)
 {
 	struct ion_custom_data custom_data;
 	struct ion_phys_data phys_data;
@@ -119,7 +119,7 @@ int smdk4x12_ion_phys(struct smdk4x12_camera *smdk4x12_camera, int fd)
 	custom_data.cmd = ION_EXYNOS_CUSTOM_PHYS;
 	custom_data.arg = (unsigned long) &phys_data;
 
-	fd = smdk4x12_camera->ion_fd;
+	fd = exynos_camera->ion_fd;
 	if (fd < 0)
 		return -1;
 
@@ -130,7 +130,7 @@ int smdk4x12_ion_phys(struct smdk4x12_camera *smdk4x12_camera, int fd)
 	return (int) phys_data.phys;
 }
 
-int smdk4x12_ion_msync(struct smdk4x12_camera *smdk4x12_camera, int fd,
+int exynos_ion_msync(struct exynos_camera *exynos_camera, int fd,
 	int offset, int size)
 {
 	struct ion_custom_data custom_data;
@@ -147,7 +147,7 @@ int smdk4x12_ion_msync(struct smdk4x12_camera *smdk4x12_camera, int fd,
 	custom_data.cmd = ION_EXYNOS_CUSTOM_MSYNC;
 	custom_data.arg = (unsigned long) &msync_data;
 
-	fd = smdk4x12_camera->ion_fd;
+	fd = exynos_camera->ion_fd;
 	if (fd < 0)
 		return -1;
 
diff --git a/camera/smdk4x12_jpeg.c b/camera/exynos_jpeg.c
index 88cdd71..24e74fc 100644
--- a/camera/smdk4x12_jpeg.c
+++ b/camera/exynos_jpeg.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr>
+ * Copyright (C) 2013 Paul Kocialkowski
  *
  * 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
@@ -28,13 +28,14 @@
 
 #include <asm/types.h>
 
-#define LOG_TAG "smdk4x12_jpeg"
+#define LOG_TAG "exynos_jpeg"
 #include <utils/Log.h>
 
-#include "smdk4x12_camera.h"
+#include "exynos_camera.h"
 
-int smdk4x12_jpeg_start(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_jpeg *jpeg)
+#ifdef EXYNOS_JPEG_HW
+int exynos_jpeg_start(struct exynos_camera *exynos_camera,
+	struct exynos_jpeg *jpeg)
 {
 	struct jpeg_config config;
 	struct jpeg_buf *buffer_in;
@@ -47,7 +48,7 @@ int smdk4x12_jpeg_start(struct smdk4x12_camera *smdk4x12_camera,
 	int fd = -1;
 	int rc;
 
-	if (smdk4x12_camera == NULL || jpeg == NULL)
+	if (exynos_camera == NULL || jpeg == NULL)
 		return -EINVAL;
 
 	ALOGD("%s()", __func__);
@@ -116,18 +117,18 @@ int smdk4x12_jpeg_start(struct smdk4x12_camera *smdk4x12_camera,
 		// Input
 
 		buffer_in->memory = V4L2_MEMORY_USERPTR;
-		buffer_in->length[0] = smdk4x12_camera_buffer_length(jpeg->width, jpeg->height, jpeg->format);
+		buffer_in->length[0] = exynos_camera_buffer_length(jpeg->width, jpeg->height, jpeg->format);
 
-		memory_ion_fd = smdk4x12_ion_alloc(smdk4x12_camera, buffer_in->length[0]);
+		memory_ion_fd = exynos_ion_alloc(exynos_camera, buffer_in->length[0]);
 		if (memory_ion_fd < 0) {
 			ALOGE("%s: Unable to alloc input ION memory", __func__);
 			goto error;
 		}
 
-		address = smdk4x12_ion_phys(smdk4x12_camera, memory_ion_fd);
+		address = exynos_ion_phys(exynos_camera, memory_ion_fd);
 
-		if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) {
-			memory = smdk4x12_camera->callbacks.request_memory(memory_ion_fd, buffer_in->length[0], 1, smdk4x12_camera->callbacks.user);
+		if (EXYNOS_CAMERA_CALLBACK_DEFINED(request_memory)) {
+			memory = exynos_camera->callbacks.request_memory(memory_ion_fd, buffer_in->length[0], 1, exynos_camera->callbacks.user);
 			if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) {
 				ALOGE("%s: Unable to request memory", __func__);
 				goto error;
@@ -153,16 +154,16 @@ int smdk4x12_jpeg_start(struct smdk4x12_camera *smdk4x12_camera,
 		buffer_out->memory = V4L2_MEMORY_USERPTR;
 		buffer_out->length[0] = jpeg->width * jpeg->height * 4;
 
-		memory_ion_fd = smdk4x12_ion_alloc(smdk4x12_camera, buffer_out->length[0]);
+		memory_ion_fd = exynos_ion_alloc(exynos_camera, buffer_out->length[0]);
 		if (memory_ion_fd < 0) {
 			ALOGE("%s: Unable to alloc output ION memory", __func__);
 			goto error;
 		}
 
-		address = smdk4x12_ion_phys(smdk4x12_camera, memory_ion_fd);
+		address = exynos_ion_phys(exynos_camera, memory_ion_fd);
 
-		if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) {
-			memory = smdk4x12_camera->callbacks.request_memory(memory_ion_fd, buffer_out->length[0], 1, smdk4x12_camera->callbacks.user);
+		if (EXYNOS_CAMERA_CALLBACK_DEFINED(request_memory)) {
+			memory = exynos_camera->callbacks.request_memory(memory_ion_fd, buffer_out->length[0], 1, exynos_camera->callbacks.user);
 			if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) {
 				ALOGE("%s: Unable to request memory", __func__);
 				goto error;
@@ -215,7 +216,7 @@ error:
 		jpeg->memory_in = NULL;
 #ifdef EXYNOS_ION
 		if (jpeg->memory_in_ion_fd >= 0) {
-			smdk4x12_ion_free(smdk4x12_camera, jpeg->memory_in_ion_fd);
+			exynos_ion_free(exynos_camera, jpeg->memory_in_ion_fd);
 			jpeg->memory_in_ion_fd = -1;
 		}
 #endif
@@ -227,7 +228,7 @@ error:
 
 #ifdef EXYNOS_ION
 		if (jpeg->memory_out_ion_fd >= 0) {
-			smdk4x12_ion_free(smdk4x12_camera, jpeg->memory_out_ion_fd);
+			exynos_ion_free(exynos_camera, jpeg->memory_out_ion_fd);
 			jpeg->memory_out_ion_fd = -1;
 		}
 #endif
@@ -239,15 +240,15 @@ complete:
 	return rc;
 }
 
-void smdk4x12_jpeg_stop(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_jpeg *jpeg)
+void exynos_jpeg_stop(struct exynos_camera *exynos_camera,
+	struct exynos_jpeg *jpeg)
 {
 	struct jpeg_buf *buffer_in;
 	struct jpeg_buf *buffer_out;
 	int fd = -1;
 	int rc;
 
-	if (smdk4x12_camera == NULL || jpeg == NULL)
+	if (exynos_camera == NULL || jpeg == NULL)
 		return;
 
 	ALOGD("%s()", __func__);
@@ -272,7 +273,7 @@ void smdk4x12_jpeg_stop(struct smdk4x12_camera *smdk4x12_camera,
 		jpeg->memory_in = NULL;
 #ifdef EXYNOS_ION
 		if (jpeg->memory_in_ion_fd >= 0) {
-			smdk4x12_ion_free(smdk4x12_camera, jpeg->memory_in_ion_fd);
+			exynos_ion_free(exynos_camera, jpeg->memory_in_ion_fd);
 			jpeg->memory_in_ion_fd = -1;
 		}
 #endif
@@ -284,7 +285,7 @@ void smdk4x12_jpeg_stop(struct smdk4x12_camera *smdk4x12_camera,
 
 #ifdef EXYNOS_ION
 		if (jpeg->memory_out_ion_fd >= 0) {
-			smdk4x12_ion_free(smdk4x12_camera, jpeg->memory_out_ion_fd);
+			exynos_ion_free(exynos_camera, jpeg->memory_out_ion_fd);
 			jpeg->memory_out_ion_fd = -1;
 		}
 #endif
@@ -293,7 +294,7 @@ void smdk4x12_jpeg_stop(struct smdk4x12_camera *smdk4x12_camera,
 	jpeg->enabled = 0;
 }
 
-int smdk4x12_jpeg(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_jpeg *jpeg)
+int exynos_jpeg(struct exynos_camera *exynos_camera, struct exynos_jpeg *jpeg)
 {
 	struct jpeg_buf *buffer_in;
 	struct jpeg_buf *buffer_out;
@@ -301,7 +302,7 @@ int smdk4x12_jpeg(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_jpeg
 	int fd = -1;
 	int rc;
 
-	if (smdk4x12_camera == NULL || jpeg == NULL)
+	if (exynos_camera == NULL || jpeg == NULL)
 		return -EINVAL;
 
 	ALOGD("%s()", __func__);
@@ -322,7 +323,7 @@ int smdk4x12_jpeg(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_jpeg
 
 #ifdef EXYNOS_ION
 	if (jpeg->memory_in != NULL && jpeg->memory_in_ion_fd >= 0) {
-		rc = smdk4x12_ion_msync(smdk4x12_camera, jpeg->memory_in_ion_fd, 0, buffer_in->length[0]);
+		rc = exynos_ion_msync(exynos_camera, jpeg->memory_in_ion_fd, 0, buffer_in->length[0]);
 		if (rc < 0) {
 			ALOGE("%s: Unable to sync ION memory", __func__);
 			goto error;
@@ -346,7 +347,7 @@ int smdk4x12_jpeg(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_jpeg
 
 #ifdef EXYNOS_ION
 	if (jpeg->memory_out != NULL && jpeg->memory_out_ion_fd >= 0) {
-		rc = smdk4x12_ion_msync(smdk4x12_camera, jpeg->memory_out_ion_fd, 0, memory_size);
+		rc = exynos_ion_msync(exynos_camera, jpeg->memory_out_ion_fd, 0, memory_size);
 		if (rc < 0) {
 			ALOGE("%s: Unable to sync ION memory", __func__);
 			goto error;
@@ -377,7 +378,7 @@ error:
 
 #ifdef EXYNOS_ION
 		if (jpeg->memory_in_ion_fd >= 0) {
-			smdk4x12_ion_free(smdk4x12_camera, jpeg->memory_in_ion_fd);
+			exynos_ion_free(exynos_camera, jpeg->memory_in_ion_fd);
 			jpeg->memory_in_ion_fd = -1;
 		}
 #endif
@@ -389,7 +390,7 @@ error:
 
 #ifdef EXYNOS_ION
 		if (jpeg->memory_out_ion_fd >= 0) {
-			smdk4x12_ion_free(smdk4x12_camera, jpeg->memory_out_ion_fd);
+			exynos_ion_free(exynos_camera, jpeg->memory_out_ion_fd);
 			jpeg->memory_out_ion_fd = -1;
 		}
 #endif
@@ -400,3 +401,4 @@ error:
 complete:
 	return rc;
 }
+#endif
diff --git a/camera/smdk4x12_param.c b/camera/exynos_param.c
index b39ec7e..f41f4f6 100644
--- a/camera/smdk4x12_param.c
+++ b/camera/exynos_param.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr>
+ * Copyright (C) 2013 Paul Kocialkowski
  *
  * 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
@@ -22,22 +22,22 @@
 #include <malloc.h>
 #include <ctype.h>
 
-#define LOG_TAG "smdk4x12_param"
+#define LOG_TAG "exynos_param"
 #include <utils/Log.h>
 
-#include "smdk4x12_camera.h"
+#include "exynos_camera.h"
 
-int smdk4x12_param_register(struct smdk4x12_camera *smdk4x12_camera, char *key,
-	union smdk4x12_param_data data, enum smdk4x12_param_type type)
+int exynos_param_register(struct exynos_camera *exynos_camera, char *key,
+	union exynos_param_data data, enum exynos_param_type type)
 {
 	struct list_head *list_end;
 	struct list_head *list;
-	struct smdk4x12_param *param;
+	struct exynos_param *param;
 
-	if (smdk4x12_camera == NULL || key == NULL)
+	if (exynos_camera == NULL || key == NULL)
 		return -EINVAL;
 
-	param = (struct smdk4x12_param *) calloc(1, sizeof(struct smdk4x12_param));
+	param = (struct exynos_param *) calloc(1, sizeof(struct exynos_param));
 	if (param == NULL)
 		return -ENOMEM;
 
@@ -58,15 +58,15 @@ int smdk4x12_param_register(struct smdk4x12_camera *smdk4x12_camera, char *key,
 	}
 	param->type = type;
 
-	list_end = (struct list_head *) smdk4x12_camera->params;
+	list_end = (struct list_head *) exynos_camera->params;
 	while (list_end != NULL && list_end->next != NULL)
 		list_end = list_end->next;
 
 	list = (struct list_head *) param;
 	list_head_insert(list, list_end, NULL);
 
-	if (smdk4x12_camera->params == NULL)
-		smdk4x12_camera->params = param;
+	if (exynos_camera->params == NULL)
+		exynos_camera->params = param;
 
 	return 0;
 
@@ -81,26 +81,26 @@ error:
 	return -1;
 }
 
-void smdk4x12_param_unregister(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_param *param)
+void exynos_param_unregister(struct exynos_camera *exynos_camera,
+	struct exynos_param *param)
 {
 	struct list_head *list;
 
-	if (smdk4x12_camera == NULL || param == NULL)
+	if (exynos_camera == NULL || param == NULL)
 		return;
 
-	list = (struct list_head *) smdk4x12_camera->params;
+	list = (struct list_head *) exynos_camera->params;
 	while (list != NULL) {
 		if ((void *) list == (void *) param) {
 			list_head_remove(list);
 
-			if ((void *) list == (void *) smdk4x12_camera->params)
-				smdk4x12_camera->params = (struct smdk4x12_param *) list->next;
+			if ((void *) list == (void *) exynos_camera->params)
+				exynos_camera->params = (struct exynos_param *) list->next;
 
 			if (param->type == EXYNOS_PARAM_STRING && param->data.string != NULL)
 				free(param->data.string);
 
-			memset(param, 0, sizeof(struct smdk4x12_param));
+			memset(param, 0, sizeof(struct exynos_param));
 			free(param);
 
 			break;
@@ -111,18 +111,18 @@ list_continue:
 	}
 }
 
-struct smdk4x12_param *smdk4x12_param_find_key(struct smdk4x12_camera *smdk4x12_camera,
+struct exynos_param *exynos_param_find_key(struct exynos_camera *exynos_camera,
 	char *key)
 {
-	struct smdk4x12_param *param;
+	struct exynos_param *param;
 	struct list_head *list;
 
-	if (smdk4x12_camera == NULL || key == NULL)
+	if (exynos_camera == NULL || key == NULL)
 		return NULL;
 
-	list = (struct list_head *) smdk4x12_camera->params;
+	list = (struct list_head *) exynos_camera->params;
 	while (list != NULL) {
-		param = (struct smdk4x12_param *) list;
+		param = (struct exynos_param *) list;
 		if (param->key == NULL)
 			goto list_continue;
 
@@ -136,12 +136,12 @@ list_continue:
 	return NULL;
 }
 
-int smdk4x12_param_data_set(struct smdk4x12_camera *smdk4x12_camera, char *key,
-	union smdk4x12_param_data data, enum smdk4x12_param_type type)
+int exynos_param_data_set(struct exynos_camera *exynos_camera, char *key,
+	union exynos_param_data data, enum exynos_param_type type)
 {
-	struct smdk4x12_param *param;
+	struct exynos_param *param;
 
-	if (smdk4x12_camera == NULL || key == NULL)
+	if (exynos_camera == NULL || key == NULL)
 		return -EINVAL;
 
 	if (strchr(key, '=') || strchr(key, ';'))
@@ -151,10 +151,10 @@ int smdk4x12_param_data_set(struct smdk4x12_camera *smdk4x12_camera, char *key,
 		(strchr(data.string, '=') || strchr(data.string, ';')))
 		return -EINVAL;
 
-	param = smdk4x12_param_find_key(smdk4x12_camera, key);
+	param = exynos_param_find_key(exynos_camera, key);
 	if (param == NULL) {
 		// The key isn't in the list yet
-		smdk4x12_param_register(smdk4x12_camera, key, data, type);
+		exynos_param_register(exynos_camera, key, data, type);
 		return 0;
 	}
 
@@ -183,15 +183,15 @@ int smdk4x12_param_data_set(struct smdk4x12_camera *smdk4x12_camera, char *key,
 	return 0;
 }
 
-int smdk4x12_param_data_get(struct smdk4x12_camera *smdk4x12_camera, char *key,
-	union smdk4x12_param_data *data, enum smdk4x12_param_type type)
+int exynos_param_data_get(struct exynos_camera *exynos_camera, char *key,
+	union exynos_param_data *data, enum exynos_param_type type)
 {
-	struct smdk4x12_param *param;
+	struct exynos_param *param;
 
-	if (smdk4x12_camera == NULL || key == NULL || data == NULL)
+	if (exynos_camera == NULL || key == NULL || data == NULL)
 		return -EINVAL;
 
-	param = smdk4x12_param_find_key(smdk4x12_camera, key);
+	param = exynos_param_find_key(exynos_camera, key);
 	if (param == NULL || param->type != type)
 		return -1;
 
@@ -200,16 +200,16 @@ int smdk4x12_param_data_get(struct smdk4x12_camera *smdk4x12_camera, char *key,
 	return 0;
 }
 
-int smdk4x12_param_int_get(struct smdk4x12_camera *smdk4x12_camera,
+int exynos_param_int_get(struct exynos_camera *exynos_camera,
 	char *key)
 {
-	union smdk4x12_param_data data;
+	union exynos_param_data data;
 	int rc;
 
-	if (smdk4x12_camera == NULL || key == NULL)
+	if (exynos_camera == NULL || key == NULL)
 		return -EINVAL;
 
-	rc = smdk4x12_param_data_get(smdk4x12_camera, key, &data, EXYNOS_PARAM_INT);
+	rc = exynos_param_data_get(exynos_camera, key, &data, EXYNOS_PARAM_INT);
 	if (rc < 0) {
 		ALOGE("%s: Unable to get data for key %s", __func__, key);
 		return -1;
@@ -218,16 +218,16 @@ int smdk4x12_param_int_get(struct smdk4x12_camera *smdk4x12_camera,
 	return data.integer;
 }
 
-float smdk4x12_param_float_get(struct smdk4x12_camera *smdk4x12_camera,
+float exynos_param_float_get(struct exynos_camera *exynos_camera,
 	char *key)
 {
-	union smdk4x12_param_data data;
+	union exynos_param_data data;
 	int rc;
 
-	if (smdk4x12_camera == NULL || key == NULL)
+	if (exynos_camera == NULL || key == NULL)
 		return -EINVAL;
 
-	rc = smdk4x12_param_data_get(smdk4x12_camera, key, &data, EXYNOS_PARAM_FLOAT);
+	rc = exynos_param_data_get(exynos_camera, key, &data, EXYNOS_PARAM_FLOAT);
 	if (rc < 0) {
 		ALOGE("%s: Unable to get data for key %s", __func__, key);
 		return -1;
@@ -236,16 +236,16 @@ float smdk4x12_param_float_get(struct smdk4x12_camera *smdk4x12_camera,
 	return data.floating;
 }
 
-char *smdk4x12_param_string_get(struct smdk4x12_camera *smdk4x12_camera,
+char *exynos_param_string_get(struct exynos_camera *exynos_camera,
 	char *key)
 {
-	union smdk4x12_param_data data;
+	union exynos_param_data data;
 	int rc;
 
-	if (smdk4x12_camera == NULL || key == NULL)
+	if (exynos_camera == NULL || key == NULL)
 		return NULL;
 
-	rc = smdk4x12_param_data_get(smdk4x12_camera, key, &data, EXYNOS_PARAM_STRING);
+	rc = exynos_param_data_get(exynos_camera, key, &data, EXYNOS_PARAM_STRING);
 	if (rc < 0) {
 		ALOGE("%s: Unable to get data for key %s", __func__, key);
 		return NULL;
@@ -254,18 +254,18 @@ char *smdk4x12_param_string_get(struct smdk4x12_camera *smdk4x12_camera,
 	return data.string;
 }
 
-int smdk4x12_param_int_set(struct smdk4x12_camera *smdk4x12_camera,
+int exynos_param_int_set(struct exynos_camera *exynos_camera,
 	char *key, int integer)
 {
-	union smdk4x12_param_data data;
+	union exynos_param_data data;
 	int rc;
 
-	if (smdk4x12_camera == NULL || key == NULL)
+	if (exynos_camera == NULL || key == NULL)
 		return -EINVAL;
 
 	data.integer = integer;
 
-	rc = smdk4x12_param_data_set(smdk4x12_camera, key, data, EXYNOS_PARAM_INT);
+	rc = exynos_param_data_set(exynos_camera, key, data, EXYNOS_PARAM_INT);
 	if (rc < 0) {
 		ALOGE("%s: Unable to set data for key %s", __func__, key);
 		return -1;
@@ -274,18 +274,18 @@ int smdk4x12_param_int_set(struct smdk4x12_camera *smdk4x12_camera,
 	return 0;
 }
 
-int smdk4x12_param_float_set(struct smdk4x12_camera *smdk4x12_camera,
+int exynos_param_float_set(struct exynos_camera *exynos_camera,
 	char *key, float floating)
 {
-	union smdk4x12_param_data data;
+	union exynos_param_data data;
 	int rc;
 
-	if (smdk4x12_camera == NULL || key == NULL)
+	if (exynos_camera == NULL || key == NULL)
 		return -EINVAL;
 
 	data.floating = floating;
 
-	rc = smdk4x12_param_data_set(smdk4x12_camera, key, data, EXYNOS_PARAM_FLOAT);
+	rc = exynos_param_data_set(exynos_camera, key, data, EXYNOS_PARAM_FLOAT);
 	if (rc < 0) {
 		ALOGE("%s: Unable to set data for key %s", __func__, key);
 		return -1;
@@ -294,18 +294,18 @@ int smdk4x12_param_float_set(struct smdk4x12_camera *smdk4x12_camera,
 	return 0;
 }
 
-int smdk4x12_param_string_set(struct smdk4x12_camera *smdk4x12_camera,
+int exynos_param_string_set(struct exynos_camera *exynos_camera,
 	char *key, char *string)
 {
-	union smdk4x12_param_data data;
+	union exynos_param_data data;
 	int rc;
 
-	if (smdk4x12_camera == NULL || key == NULL || string == NULL)
+	if (exynos_camera == NULL || key == NULL || string == NULL)
 		return -EINVAL;
 
 	data.string = string;
 
-	rc = smdk4x12_param_data_set(smdk4x12_camera, key, data, EXYNOS_PARAM_STRING);
+	rc = exynos_param_data_set(exynos_camera, key, data, EXYNOS_PARAM_STRING);
 	if (rc < 0) {
 		ALOGE("%s: Unable to set data for key %s", __func__, key);
 		return -1;
@@ -314,21 +314,21 @@ int smdk4x12_param_string_set(struct smdk4x12_camera *smdk4x12_camera,
 	return 0;
 }
 
-char *smdk4x12_params_string_get(struct smdk4x12_camera *smdk4x12_camera)
+char *exynos_params_string_get(struct exynos_camera *exynos_camera)
 {
-	struct smdk4x12_param *param;
+	struct exynos_param *param;
 	struct list_head *list;
 	char *string = NULL;
 	char *s = NULL;
 	int length = 0;
 	int l = 0;
 
-	if (smdk4x12_camera == NULL)
+	if (exynos_camera == NULL)
 		return NULL;
 
-	list = (struct list_head *) smdk4x12_camera->params;
+	list = (struct list_head *) exynos_camera->params;
 	while (list != NULL) {
-		param = (struct smdk4x12_param *) list;
+		param = (struct exynos_param *) list;
 		if (param->key == NULL)
 			goto list_continue_length;
 
@@ -360,9 +360,9 @@ list_continue_length:
 	string = calloc(1, length);
 	s = string;
 
-	list = (struct list_head *) smdk4x12_camera->params;
+	list = (struct list_head *) exynos_camera->params;
 	while (list != NULL) {
-		param = (struct smdk4x12_param *) list;
+		param = (struct exynos_param *) list;
 		if (param->key == NULL)
 			goto list_continue;
 
@@ -402,10 +402,10 @@ list_continue:
 	return string;
 }
 
-int smdk4x12_params_string_set(struct smdk4x12_camera *smdk4x12_camera, char *string)
+int exynos_params_string_set(struct exynos_camera *exynos_camera, char *string)
 {
-	union smdk4x12_param_data data;
-	enum smdk4x12_param_type type;
+	union exynos_param_data data;
+	enum exynos_param_type type;
 
 	char *d = NULL;
 	char *s = NULL;
@@ -418,7 +418,7 @@ int smdk4x12_params_string_set(struct smdk4x12_camera *smdk4x12_camera, char *st
 	int rc;
 	int i;
 
-	if (smdk4x12_camera == NULL || string == NULL)
+	if (exynos_camera == NULL || string == NULL)
 		return -1;
 
 	d = strdup(string);
@@ -467,7 +467,7 @@ int smdk4x12_params_string_set(struct smdk4x12_camera *smdk4x12_camera, char *st
 				goto error;
 		}
 
-		rc = smdk4x12_param_data_set(smdk4x12_camera, key, data, type);
+		rc = exynos_param_data_set(exynos_camera, key, data, type);
 		if (rc < 0) {
 			ALOGE("%s: Unable to set data for key %s", __func__, key);
 			goto error;
diff --git a/camera/smdk4x12_utils.c b/camera/exynos_utils.c
index 90d2167..c969656 100644
--- a/camera/smdk4x12_utils.c
+++ b/camera/exynos_utils.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr>
+ * Copyright (C) 2013 Paul Kocialkowski
  *
  * 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
@@ -22,10 +22,10 @@
 #include <malloc.h>
 #include <ctype.h>
 
-#define LOG_TAG "smdk4x12_utils"
+#define LOG_TAG "exynos_utils"
 #include <utils/Log.h>
 
-#include "smdk4x12_camera.h"
+#include "exynos_camera.h"
 
 int list_head_insert(struct list_head *list, struct list_head *prev,
 	struct list_head *next)
@@ -56,7 +56,7 @@ void list_head_remove(struct list_head *list)
 }
 
 
-int smdk4x12_camera_buffer_length(int width, int height, int format)
+int exynos_camera_buffer_length(int width, int height, int format)
 {
 	float bpp;
 	int buffer_length;
@@ -82,8 +82,8 @@ int smdk4x12_camera_buffer_length(int width, int height, int format)
 		case V4L2_PIX_FMT_YUV420:
 		case V4L2_PIX_FMT_YVU420:
 			bpp = 1.5f;
-			buffer_length = SMDK4x12_CAMERA_ALIGN(width * height);
-			buffer_length += SMDK4x12_CAMERA_ALIGN(width * height / 2);
+			buffer_length = EXYNOS_CAMERA_ALIGN(width * height);
+			buffer_length += EXYNOS_CAMERA_ALIGN(width * height / 2);
 			break;
 		case V4L2_PIX_FMT_NV21:
 			bpp = 1.5f;
@@ -100,7 +100,7 @@ int smdk4x12_camera_buffer_length(int width, int height, int format)
 	return buffer_length;
 }
 
-void smdk4x12_camera_yuv_planes(int width, int height, int format, int address, int *address_y, int *address_cb, int *address_cr)
+void exynos_camera_yuv_planes(int width, int height, int format, int address, int *address_y, int *address_cb, int *address_cr)
 {
 	switch (format) {
 		case V4L2_PIX_FMT_RGB32:
@@ -116,12 +116,12 @@ void smdk4x12_camera_yuv_planes(int width, int height, int format, int address,
 			if (address_y != NULL)
 				*address_y = address;
 
-			address += SMDK4x12_CAMERA_ALIGN(width * height);
+			address += EXYNOS_CAMERA_ALIGN(width * height);
 
 			if (address_cb != NULL)
 				*address_cb = address;
 
-			address += SMDK4x12_CAMERA_ALIGN(width * height / 4);
+			address += EXYNOS_CAMERA_ALIGN(width * height / 4);
 
 			if (address_cr != NULL)
 				*address_cr = address;
@@ -131,7 +131,7 @@ void smdk4x12_camera_yuv_planes(int width, int height, int format, int address,
 			if (address_y != NULL)
 				*address_y = address;
 
-			address += SMDK4x12_CAMERA_ALIGN(width * height);
+			address += EXYNOS_CAMERA_ALIGN(width * height);
 
 			if (address_cb != NULL)
 				*address_cb = address;
@@ -156,19 +156,3 @@ void smdk4x12_camera_yuv_planes(int width, int height, int format, int address,
 			break;
 	}
 }
-
-int smdk4x12_gralloc_format(int format)
-{
-	switch (format) {
-		case V4L2_PIX_FMT_NV21:
-			return HAL_PIXEL_FORMAT_YCrCb_420_SP;
-		case V4L2_PIX_FMT_YUV420:
-			return HAL_PIXEL_FORMAT_YV12;
-		case V4L2_PIX_FMT_RGB565:
-			return HAL_PIXEL_FORMAT_RGB_565;
-		case V4L2_PIX_FMT_RGB32:
-			return HAL_PIXEL_FORMAT_RGBX_8888;
-		default:
-			return HAL_PIXEL_FORMAT_YCrCb_420_SP;
-	}
-}
diff --git a/camera/exynos_v4l2.c b/camera/exynos_v4l2.c
new file mode 100644
index 0000000..2768676
--- /dev/null
+++ b/camera/exynos_v4l2.c
@@ -0,0 +1,802 @@
+/*
+ * Copyright (C) 2013 Paul Kocialkowski
+ *
+ * Based on crespo libcamera and exynos4 hal libcamera:
+ * Copyright 2008, The Android Open Source Project
+ * Copyright 2010, Samsung Electronics Co. LTD
+ *
+ * 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 <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <malloc.h>
+#include <poll.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+
+#include <asm/types.h>
+
+#define LOG_TAG "exynos_v4l2"
+#include <utils/Log.h>
+
+#include "exynos_camera.h"
+
+int exynos_v4l2_init(struct exynos_camera *exynos_camera)
+{
+	int i;
+
+	for (i = 0; i < EXYNOS_CAMERA_MAX_V4L2_NODES_COUNT; i++)
+		exynos_camera->v4l2_fds[i] = -1;
+
+	return 0;
+}
+
+int exynos_v4l2_index(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
+{
+	int index;
+	int i;
+
+	if (exynos_camera == NULL || exynos_camera->config == NULL ||
+		exynos_camera->config->v4l2_nodes == NULL)
+		return -EINVAL;
+
+	if (exynos_v4l2_id > exynos_camera->config->v4l2_nodes_count)
+		return -1;
+
+	index = -1;
+	for (i = 0; i < exynos_camera->config->v4l2_nodes_count; i++) {
+		if (exynos_camera->config->v4l2_nodes[i].id == exynos_v4l2_id &&
+			exynos_camera->config->v4l2_nodes[i].node != NULL) {
+			index = i;
+		}
+	}
+
+	return index;
+}
+
+int exynos_v4l2_fd(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
+{
+	int index;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	index = exynos_v4l2_index(exynos_camera, exynos_v4l2_id);
+	if (index < 0) {
+		ALOGE("%s: Unable to get v4l2 index for id %d", __func__, exynos_v4l2_id);
+		return -1;
+	}
+
+	return exynos_camera->v4l2_fds[index];
+}
+
+int exynos_v4l2_open(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
+{
+	char *node;
+	int index;
+	int fd;
+
+	if (exynos_camera == NULL || exynos_camera->config == NULL ||
+		exynos_camera->config->v4l2_nodes == NULL)
+		return -EINVAL;
+
+	index = exynos_v4l2_index(exynos_camera, exynos_v4l2_id);
+	if (index < 0) {
+		ALOGE("%s: Unable to get v4l2 node for id %d", __func__, exynos_v4l2_id);
+		return -1;
+	}
+
+	node = exynos_camera->config->v4l2_nodes[index].node;
+	fd = open(node, O_RDWR);
+	if (fd < 0) {
+		ALOGE("%s: Unable to open v4l2 node for id %d", __func__, exynos_v4l2_id);
+		return -1;
+	}
+
+	exynos_camera->v4l2_fds[index] = fd;
+
+	return 0;
+}
+
+void exynos_v4l2_close(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
+{
+	int index;
+
+	if (exynos_camera == NULL || exynos_camera->config == NULL ||
+		exynos_camera->config->v4l2_nodes == NULL)
+		return;
+
+	index = exynos_v4l2_index(exynos_camera, exynos_v4l2_id);
+	if (index < 0) {
+		ALOGE("%s: Unable to get v4l2 node for id %d", __func__, exynos_v4l2_id);
+		return;
+	}
+
+	if (exynos_camera->v4l2_fds[index] >= 0)
+		close(exynos_camera->v4l2_fds[index]);
+
+	exynos_camera->v4l2_fds[index] = -1;
+}
+
+int exynos_v4l2_ioctl(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int request, void *data)
+{
+	int fd;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	fd = exynos_v4l2_fd(exynos_camera, exynos_v4l2_id);
+	if (fd < 0) {
+		ALOGE("%s: Unable to get v4l2 fd for id %d", __func__, exynos_v4l2_id);
+		return -1;
+	}
+
+	return ioctl(fd, request, data);
+}
+
+int exynos_v4l2_poll(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
+{
+	struct pollfd events;
+	int fd;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	fd = exynos_v4l2_fd(exynos_camera, exynos_v4l2_id);
+	if (fd < 0) {
+		ALOGE("%s: Unable to get v4l2 fd for id %d", __func__, exynos_v4l2_id);
+		return -1;
+	}
+
+	memset(&events, 0, sizeof(events));
+	events.fd = fd;
+	events.events = POLLIN | POLLERR;
+
+	rc = poll(&events, 1, 1000);
+	if (rc < 0 || events.revents & POLLERR)
+		return -1;
+
+	return rc;
+}
+
+int exynos_v4l2_qbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int type, int memory, int index, unsigned long userptr)
+{
+	struct v4l2_buffer buffer;
+	int rc;
+
+	if (exynos_camera == NULL || index < 0)
+		return -EINVAL;
+
+	memset(&buffer, 0, sizeof(buffer));
+	buffer.type = type;
+	buffer.memory = memory;
+	buffer.index = index;
+
+	if (userptr)
+		buffer.m.userptr = userptr;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_QBUF, &buffer);
+	return rc;
+}
+
+int exynos_v4l2_qbuf_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int index)
+{
+	return exynos_v4l2_qbuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		V4L2_MEMORY_MMAP, index, 0);
+}
+
+int exynos_v4l2_qbuf_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int index, unsigned long userptr)
+{
+	return exynos_v4l2_qbuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		V4L2_MEMORY_USERPTR, index, userptr);
+}
+
+int exynos_v4l2_dqbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int type, int memory)
+{
+	struct v4l2_buffer buffer;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	memset(&buffer, 0, sizeof(buffer));
+	buffer.type = type;
+	buffer.memory = memory;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_DQBUF, &buffer);
+	if (rc < 0)
+		return rc;
+
+	return buffer.index;
+}
+
+int exynos_v4l2_s_ext_ctrl_face_detection(struct exynos_camera *exynos_camera,
+	int id, void *value)
+{
+	struct v4l2_ext_control ext_ctrl_fd[111];
+	struct v4l2_ext_controls ext_ctrls_fd;
+	struct v4l2_ext_controls *ctrls;
+	camera_frame_metadata_t *facedata = (camera_frame_metadata_t *)value;
+	int i, ret;
+
+	ext_ctrl_fd[0].id = V4L2_CID_IS_FD_GET_FACE_COUNT;
+	for (i = 0; i < exynos_camera->max_detected_faces; i++) {
+		ext_ctrl_fd[22*i+1].id = V4L2_CID_IS_FD_GET_FACE_FRAME_NUMBER;
+		ext_ctrl_fd[22*i+2].id = V4L2_CID_IS_FD_GET_FACE_CONFIDENCE;
+		ext_ctrl_fd[22*i+3].id = V4L2_CID_IS_FD_GET_FACE_SMILE_LEVEL;
+		ext_ctrl_fd[22*i+4].id = V4L2_CID_IS_FD_GET_FACE_BLINK_LEVEL;
+		ext_ctrl_fd[22*i+5].id = V4L2_CID_IS_FD_GET_FACE_TOPLEFT_X;
+		ext_ctrl_fd[22*i+6].id = V4L2_CID_IS_FD_GET_FACE_TOPLEFT_Y;
+		ext_ctrl_fd[22*i+7].id = V4L2_CID_IS_FD_GET_FACE_BOTTOMRIGHT_X;
+		ext_ctrl_fd[22*i+8].id = V4L2_CID_IS_FD_GET_FACE_BOTTOMRIGHT_Y;
+		ext_ctrl_fd[22*i+9].id = V4L2_CID_IS_FD_GET_LEFT_EYE_TOPLEFT_X;
+		ext_ctrl_fd[22*i+10].id = V4L2_CID_IS_FD_GET_LEFT_EYE_TOPLEFT_Y;
+		ext_ctrl_fd[22*i+11].id = V4L2_CID_IS_FD_GET_LEFT_EYE_BOTTOMRIGHT_X;
+		ext_ctrl_fd[22*i+12].id = V4L2_CID_IS_FD_GET_LEFT_EYE_BOTTOMRIGHT_Y;
+		ext_ctrl_fd[22*i+13].id = V4L2_CID_IS_FD_GET_RIGHT_EYE_TOPLEFT_X;
+		ext_ctrl_fd[22*i+14].id = V4L2_CID_IS_FD_GET_RIGHT_EYE_TOPLEFT_Y;
+		ext_ctrl_fd[22*i+15].id = V4L2_CID_IS_FD_GET_RIGHT_EYE_BOTTOMRIGHT_X;
+		ext_ctrl_fd[22*i+16].id = V4L2_CID_IS_FD_GET_RIGHT_EYE_BOTTOMRIGHT_Y;
+		ext_ctrl_fd[22*i+17].id = V4L2_CID_IS_FD_GET_MOUTH_TOPLEFT_X;
+		ext_ctrl_fd[22*i+18].id = V4L2_CID_IS_FD_GET_MOUTH_TOPLEFT_Y;
+		ext_ctrl_fd[22*i+19].id = V4L2_CID_IS_FD_GET_MOUTH_BOTTOMRIGHT_X;
+		ext_ctrl_fd[22*i+20].id = V4L2_CID_IS_FD_GET_MOUTH_BOTTOMRIGHT_Y;
+		ext_ctrl_fd[22*i+21].id = V4L2_CID_IS_FD_GET_ANGLE;
+		ext_ctrl_fd[22*i+22].id = V4L2_CID_IS_FD_GET_NEXT;
+	}
+
+	ext_ctrls_fd.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
+	ext_ctrls_fd.count = 111;
+	ext_ctrls_fd.controls = ext_ctrl_fd;
+	ctrls = &ext_ctrls_fd;
+
+	ret = exynos_v4l2_ioctl(exynos_camera, id, VIDIOC_G_EXT_CTRLS, &ext_ctrls_fd);
+
+	facedata->number_of_faces = ext_ctrls_fd.controls[0].value;
+
+	for(i = 0; i < facedata->number_of_faces; i++) {
+		facedata->faces[i].rect[0] = ext_ctrl_fd[22*i+5].value;
+		facedata->faces[i].rect[1] = ext_ctrl_fd[22*i+6].value;
+		facedata->faces[i].rect[2] = ext_ctrl_fd[22*i+7].value;
+		facedata->faces[i].rect[3] = ext_ctrl_fd[22*i+8].value;
+		facedata->faces[i].score = ext_ctrl_fd[22*i+2].value;
+		/* TODO : id is unique value for each face. We need to suppot this. */
+		facedata->faces[i].id = 0;
+		facedata->faces[i].left_eye[0] = (ext_ctrl_fd[22*i+9].value + ext_ctrl_fd[22*i+11].value) / 2;
+		facedata->faces[i].left_eye[1] = (ext_ctrl_fd[22*i+10].value + ext_ctrl_fd[22*i+12].value) / 2;
+		facedata->faces[i].right_eye[0] = (ext_ctrl_fd[22*i+13].value + ext_ctrl_fd[22*i+15].value) / 2;
+		facedata->faces[i].right_eye[1] = (ext_ctrl_fd[22*i+14].value + ext_ctrl_fd[22*i+16].value) / 2;
+		facedata->faces[i].mouth[0] = (ext_ctrl_fd[22*i+17].value + ext_ctrl_fd[22*i+19].value) / 2;
+		facedata->faces[i].mouth[1] = (ext_ctrl_fd[22*i+18].value + ext_ctrl_fd[22*i+20].value) / 2;
+	}
+
+	return ret;
+}
+
+int exynos_v4l2_dqbuf_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id)
+{
+	return exynos_v4l2_dqbuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		V4L2_MEMORY_MMAP);
+}
+
+int exynos_v4l2_dqbuf_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id)
+{
+	return exynos_v4l2_dqbuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		V4L2_MEMORY_USERPTR);
+}
+
+int exynos_v4l2_reqbufs(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type, int memory, int count)
+{
+	struct v4l2_requestbuffers requestbuffers;
+	int rc;
+
+	if (exynos_camera == NULL || count < 0)
+		return -EINVAL;
+
+	requestbuffers.type = type;
+	requestbuffers.count = count;
+	requestbuffers.memory = memory;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_REQBUFS, &requestbuffers);
+	if (rc < 0)
+		return rc;
+
+	return requestbuffers.count;
+}
+
+int exynos_v4l2_reqbufs_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int count)
+{
+	return exynos_v4l2_reqbufs(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		V4L2_MEMORY_MMAP, count);
+}
+
+int exynos_v4l2_reqbufs_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int count)
+{
+	return exynos_v4l2_reqbufs(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		V4L2_MEMORY_USERPTR, count);
+}
+
+int exynos_v4l2_querybuf(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type, int memory, int index)
+{
+	struct v4l2_buffer buffer;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	memset(&buffer, 0, sizeof(buffer));
+	buffer.type = type;
+	buffer.memory = memory;
+	buffer.index = index;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_QUERYBUF, &buffer);
+	if (rc < 0)
+		return rc;
+
+	return buffer.length;
+}
+
+int exynos_v4l2_querybuf_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int index)
+{
+	return exynos_v4l2_querybuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		V4L2_MEMORY_MMAP, index);
+}
+
+int exynos_v4l2_querybuf_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int index)
+{
+	return exynos_v4l2_querybuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		V4L2_MEMORY_USERPTR, index);
+}
+
+int exynos_v4l2_querycap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int flags)
+{
+	struct v4l2_capability cap;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_QUERYCAP, &cap);
+	if (rc < 0)
+		return rc;
+
+	if (!(cap.capabilities & flags))
+		return -1;
+
+	return 0;
+}
+
+int exynos_v4l2_querycap_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id)
+{
+	return exynos_v4l2_querycap(exynos_camera, exynos_v4l2_id, V4L2_CAP_VIDEO_CAPTURE);
+}
+
+int exynos_v4l2_querycap_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id)
+{
+	return exynos_v4l2_querycap(exynos_camera, exynos_v4l2_id, V4L2_CAP_VIDEO_OUTPUT);
+}
+
+int exynos_v4l2_streamon(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type)
+{
+	enum v4l2_buf_type buf_type;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	buf_type = type;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_STREAMON, &buf_type);
+	return rc;
+}
+
+int exynos_v4l2_streamon_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id)
+{
+	return exynos_v4l2_streamon(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE);
+}
+
+int exynos_v4l2_streamon_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id)
+{
+	return exynos_v4l2_streamon(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT);
+}
+
+int exynos_v4l2_streamoff(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type)
+{
+	enum v4l2_buf_type buf_type;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	buf_type = type;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_STREAMOFF, &buf_type);
+	return rc;
+}
+
+int exynos_v4l2_streamoff_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id)
+{
+	return exynos_v4l2_streamoff(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE);
+}
+
+int exynos_v4l2_streamoff_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id)
+{
+	return exynos_v4l2_streamoff(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT);
+}
+
+int exynos_v4l2_g_fmt(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int type, int *width, int *height, int *fmt)
+{
+	struct v4l2_format format;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	format.type = type;
+	format.fmt.pix.field = V4L2_FIELD_NONE;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_G_FMT, &format);
+	if (rc < 0)
+		return rc;
+
+	if (width != NULL)
+		*width = format.fmt.pix.width;
+	if (height != NULL)
+		*height = format.fmt.pix.height;
+	if (fmt != NULL)
+		*fmt = format.fmt.pix.pixelformat;
+
+	return 0;
+}
+
+int exynos_v4l2_g_fmt_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int *width, int *height, int *fmt)
+{
+	return exynos_v4l2_g_fmt(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		width, height, fmt);
+}
+
+int exynos_v4l2_g_fmt_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int *width, int *height, int *fmt)
+{
+	return exynos_v4l2_g_fmt(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		width, height, fmt);
+}
+
+int exynos_v4l2_s_fmt_pix(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type, int width, int height, int fmt, int field,
+	int priv)
+{
+	struct v4l2_format format;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	memset(&format, 0, sizeof(format));
+	format.type = type;
+	format.fmt.pix.width = width;
+	format.fmt.pix.height = height;
+	format.fmt.pix.pixelformat = fmt;
+	format.fmt.pix.field = field;
+	format.fmt.pix.priv = priv;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_FMT, &format);
+	return rc;
+
+	return 0;
+}
+
+int exynos_v4l2_s_fmt_pix_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int width, int height, int fmt, int priv)
+{
+	return exynos_v4l2_s_fmt_pix(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		width, height, fmt, V4L2_FIELD_NONE, priv);
+}
+
+int exynos_v4l2_s_fmt_pix_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int width, int height, int fmt, int priv)
+{
+	return exynos_v4l2_s_fmt_pix(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		width, height, fmt, V4L2_FIELD_NONE, priv);
+}
+
+int exynos_v4l2_s_fmt_win(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int left, int top, int width, int height)
+{
+	struct v4l2_format format;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	memset(&format, 0, sizeof(format));
+	format.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
+	format.fmt.win.w.left = left;
+	format.fmt.win.w.top = top;
+	format.fmt.win.w.width = width;
+	format.fmt.win.w.height = height;
+
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_FMT, &format);
+	return rc;
+}
+
+int exynos_v4l2_enum_fmt(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int type, int fmt)
+{
+	struct v4l2_fmtdesc fmtdesc;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	fmtdesc.type = type;
+	fmtdesc.index = 0;
+
+	do {
+		rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_ENUM_FMT, &fmtdesc);
+		if (rc < 0)
+			return rc;
+
+		if (fmtdesc.pixelformat == (unsigned int) fmt)
+			return 0;
+
+		fmtdesc.index++;
+	} while (rc >= 0);
+
+	return -1;
+}
+
+int exynos_v4l2_enum_fmt_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int fmt)
+{
+	return exynos_v4l2_enum_fmt(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		fmt);
+}
+
+int exynos_v4l2_enum_fmt_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int fmt)
+{
+	return exynos_v4l2_enum_fmt(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		fmt);
+}
+
+int exynos_v4l2_enum_input(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int id)
+{
+	struct v4l2_input input;
+	int rc;
+
+	if (exynos_camera == NULL || id < 0)
+		return -EINVAL;
+
+	input.index = id;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_ENUMINPUT, &input);
+	if (rc < 0)
+		return rc;
+
+	if (input.name[0] == '\0')
+		return -1;
+
+	return 0;
+}
+
+int exynos_v4l2_s_input(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int id)
+{
+	struct v4l2_input input;
+	int rc;
+
+	if (exynos_camera == NULL || id < 0)
+		return -EINVAL;
+
+	input.index = id;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_INPUT, &input);
+	return rc;
+}
+
+int exynos_v4l2_g_ext_ctrls(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, struct v4l2_ext_control *control, int count)
+{
+	struct v4l2_ext_controls controls;
+	int rc;
+
+	if (exynos_camera == NULL || control == NULL)
+		return -EINVAL;
+
+	memset(&controls, 0, sizeof(controls));
+	controls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
+	controls.count = count;
+	controls.controls = control;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_G_EXT_CTRLS, &controls);
+	return rc;
+}
+
+int exynos_v4l2_g_ctrl(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int id, int *value)
+{
+	struct v4l2_control control;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	control.id = id;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_G_CTRL, &control);
+	if (rc < 0)
+		return rc;
+
+	if (value != NULL)
+		*value = control.value;
+
+	return 0;
+}
+
+int exynos_v4l2_s_ctrl(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int id, int value)
+{
+	struct v4l2_control control;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	control.id = id;
+	control.value = value;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_CTRL, &control);
+	if (rc < 0)
+		return rc;
+
+	return control.value;
+}
+
+int exynos_v4l2_s_parm(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int type, struct v4l2_streamparm *streamparm)
+{
+	int rc;
+
+	if (exynos_camera == NULL || streamparm == NULL)
+		return -EINVAL;
+
+	streamparm->type = type;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_PARM, streamparm);
+	return rc;
+}
+
+int exynos_v4l2_s_parm_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, struct v4l2_streamparm *streamparm)
+{
+	return exynos_v4l2_s_parm(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		streamparm);
+}
+
+int exynos_v4l2_s_parm_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, struct v4l2_streamparm *streamparm)
+{
+	return exynos_v4l2_s_parm(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		streamparm);
+}
+
+int exynos_v4l2_s_crop(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	int type, int left, int top, int width, int height)
+{
+	struct v4l2_crop crop;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	crop.type = type;
+	crop.c.left = left;
+	crop.c.top = top;
+	crop.c.width = width;
+	crop.c.height = height;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_CROP, &crop);
+	return rc;
+}
+
+int exynos_v4l2_s_crop_cap(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int left, int top, int width, int height)
+{
+	return exynos_v4l2_s_crop(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		left, top, width, height);
+}
+
+int exynos_v4l2_s_crop_out(struct exynos_camera *exynos_camera,
+	int exynos_v4l2_id, int left, int top, int width, int height)
+{
+	return exynos_v4l2_s_crop(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		left, top, width, height);
+}
+
+int exynos_v4l2_g_fbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	void **base, int *width, int *height, int *fmt)
+{
+	struct v4l2_framebuffer framebuffer;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_G_FBUF, &framebuffer);
+	if (rc < 0)
+		return rc;
+
+	if (base != NULL)
+		*base = framebuffer.base;
+	if (width != NULL)
+		*width = framebuffer.fmt.width;
+	if (height != NULL)
+		*height = framebuffer.fmt.height;
+	if (fmt != NULL)
+		*fmt = framebuffer.fmt.pixelformat;
+
+	return 0;
+}
+
+int exynos_v4l2_s_fbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
+	void *base, int width, int height, int fmt)
+{
+	struct v4l2_framebuffer framebuffer;
+	int rc;
+
+	if (exynos_camera == NULL)
+		return -EINVAL;
+
+	memset(&framebuffer, 0, sizeof(framebuffer));
+	framebuffer.base = base;
+	framebuffer.fmt.width = width;
+	framebuffer.fmt.height = height;
+	framebuffer.fmt.pixelformat = fmt;
+
+	rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_FBUF, &framebuffer);
+	return rc;
+}
diff --git a/camera/smdk4x12_v4l2_output.c b/camera/exynos_v4l2_output.c
index 0f8cad2..2a39fd2 100644
--- a/camera/smdk4x12_v4l2_output.c
+++ b/camera/exynos_v4l2_output.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr>
+ * Copyright (C) 2013 Paul Kocialkowski
  *
  * 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
@@ -28,13 +28,13 @@
 
 #include <asm/types.h>
 
-#define LOG_TAG "smdk4x12_v4l2_output"
+#define LOG_TAG "exynos_v4l2_output"
 #include <utils/Log.h>
 
-#include "smdk4x12_camera.h"
+#include "exynos_camera.h"
 
-int smdk4x12_v4l2_output_start(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_v4l2_output *output)
+int exynos_v4l2_output_start(struct exynos_camera *exynos_camera,
+	struct exynos_v4l2_output *output)
 {
 	int width, height, format;
 	int buffer_width, buffer_height, buffer_format;
@@ -50,7 +50,7 @@ int smdk4x12_v4l2_output_start(struct smdk4x12_camera *smdk4x12_camera,
 	int rc;
 	int i;
 
-	if (smdk4x12_camera == NULL || output == NULL)
+	if (exynos_camera == NULL || output == NULL)
 		return -EINVAL;
 
 //	ALOGD("%s()", __func__);
@@ -76,28 +76,28 @@ int smdk4x12_v4l2_output_start(struct smdk4x12_camera *smdk4x12_camera,
 		goto error;
 	}
 
-	buffer_length = smdk4x12_camera_buffer_length(width, height, format);
+	buffer_length = exynos_camera_buffer_length(width, height, format);
 
-	rc = smdk4x12_v4l2_open(smdk4x12_camera, v4l2_id);
+	rc = exynos_v4l2_open(exynos_camera, v4l2_id);
 	if (rc < 0) {
 		ALOGE("%s: Unable to open v4l2 device", __func__);
 		goto error;
 	}
 
-	rc = smdk4x12_v4l2_querycap_out(smdk4x12_camera, v4l2_id);
+	rc = exynos_v4l2_querycap_out(exynos_camera, v4l2_id);
 	if (rc < 0) {
 		ALOGE("%s: Unable to query capabilities", __func__);
 		goto error;
 	}
 
-	rc = smdk4x12_v4l2_g_fmt_out(smdk4x12_camera, v4l2_id, NULL, NULL, NULL);
+	rc = exynos_v4l2_g_fmt_out(exynos_camera, v4l2_id, NULL, NULL, NULL);
 	if (rc < 0) {
 		ALOGE("%s: Unable to get format", __func__);
 		goto error;
 	}
 
 	value = 0;
-	rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, v4l2_id, V4L2_CID_RESERVED_MEM_BASE_ADDR, &value);
+	rc = exynos_v4l2_g_ctrl(exynos_camera, v4l2_id, V4L2_CID_RESERVED_MEM_BASE_ADDR, &value);
 	if (rc < 0) {
 		ALOGE("%s: Unable to get address", __func__);
 		goto error;
@@ -106,7 +106,7 @@ int smdk4x12_v4l2_output_start(struct smdk4x12_camera *smdk4x12_camera,
 	memory_address = value;
 
 	value = 0;
-	rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, v4l2_id, V4L2_CID_RESERVED_MEM_SIZE, &value);
+	rc = exynos_v4l2_g_ctrl(exynos_camera, v4l2_id, V4L2_CID_RESERVED_MEM_SIZE, &value);
 	if (rc < 0) {
 		ALOGE("%s: Unable to get size", __func__);
 		goto error;
@@ -114,25 +114,25 @@ int smdk4x12_v4l2_output_start(struct smdk4x12_camera *smdk4x12_camera,
 
 	memory_size = value * 1024;
 
-	rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, v4l2_id, V4L2_CID_OVLY_MODE, FIMC_OVLY_NONE_MULTI_BUF);
+	rc = exynos_v4l2_s_ctrl(exynos_camera, v4l2_id, V4L2_CID_OVLY_MODE, FIMC_OVLY_NONE_MULTI_BUF);
 	if (rc < 0) {
 		ALOGE("%s: Unable to set overlay mode", __func__);
 		goto error;
 	}
 
-	rc = smdk4x12_v4l2_s_fmt_pix_out(smdk4x12_camera, v4l2_id, buffer_width, buffer_height, buffer_format, 0);
+	rc = exynos_v4l2_s_fmt_pix_out(exynos_camera, v4l2_id, buffer_width, buffer_height, buffer_format, 0);
 	if (rc < 0) {
 		ALOGE("%s: Unable to set output pixel format!", __func__);
 		goto error;
 	}
 
-	rc = smdk4x12_v4l2_s_crop_out(smdk4x12_camera, v4l2_id, 0, 0, buffer_width, buffer_height);
+	rc = exynos_v4l2_s_crop_out(exynos_camera, v4l2_id, 0, 0, buffer_width, buffer_height);
 	if (rc < 0) {
 		ALOGE("%s: Unable to crop", __func__);
 		goto error;
 	}
 
-	rc = smdk4x12_v4l2_reqbufs_out(smdk4x12_camera, v4l2_id, 1);
+	rc = exynos_v4l2_reqbufs_out(exynos_camera, v4l2_id, 1);
 	if (rc < 0) {
 		ALOGE("%s: Unable to request buffers", __func__);
 		goto error;
@@ -151,14 +151,14 @@ int smdk4x12_v4l2_output_start(struct smdk4x12_camera *smdk4x12_camera,
 		buffers_count = i;
 		ALOGD("Found %d buffers available for output!", buffers_count);
 
-		if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) {
-			fd = smdk4x12_v4l2_fd(smdk4x12_camera, v4l2_id);
+		if (EXYNOS_CAMERA_CALLBACK_DEFINED(request_memory)) {
+			fd = exynos_v4l2_fd(exynos_camera, v4l2_id);
 			if (fd < 0) {
 				ALOGE("%s: Unable to get v4l2 fd for id %d", __func__, v4l2_id);
 				goto error;
 			}
 
-			memory = smdk4x12_camera->callbacks.request_memory(fd, buffer_length, buffers_count, smdk4x12_camera->callbacks.user);
+			memory = exynos_camera->callbacks.request_memory(fd, buffer_length, buffers_count, exynos_camera->callbacks.user);
 			if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) {
 				ALOGE("%s: Unable to request memory", __func__);
 				goto error;
@@ -169,14 +169,14 @@ int smdk4x12_v4l2_output_start(struct smdk4x12_camera *smdk4x12_camera,
 		}
 	} else {
 #ifdef EXYNOS_ION
-		memory_ion_fd = smdk4x12_ion_alloc(smdk4x12_camera, buffers_count * buffer_length);
+		memory_ion_fd = exynos_ion_alloc(exynos_camera, buffers_count * buffer_length);
 		if (memory_ion_fd < 0) {
 			ALOGE("%s: Unable to alloc ION memory", __func__);
 			goto error;
 		}
 
-		if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) {
-			memory = smdk4x12_camera->callbacks.request_memory(memory_ion_fd, buffer_length, buffers_count, smdk4x12_camera->callbacks.user);
+		if (EXYNOS_CAMERA_CALLBACK_DEFINED(request_memory)) {
+			memory = exynos_camera->callbacks.request_memory(memory_ion_fd, buffer_length, buffers_count, exynos_camera->callbacks.user);
 			if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) {
 				ALOGE("%s: Unable to request memory", __func__);
 				goto error;
@@ -186,7 +186,7 @@ int smdk4x12_v4l2_output_start(struct smdk4x12_camera *smdk4x12_camera,
 			goto error;
 		}
 
-		memory_address = smdk4x12_ion_phys(smdk4x12_camera, memory_ion_fd);
+		memory_address = exynos_ion_phys(exynos_camera, memory_ion_fd);
 #else
 		ALOGE("%s: Unable to find memory", __func__);
 		goto error;
@@ -215,10 +215,10 @@ error:
 
 #ifdef EXYNOS_ION
 	if (memory_ion_fd >= 0)
-		smdk4x12_ion_free(smdk4x12_camera, memory_ion_fd);
+		exynos_ion_free(exynos_camera, memory_ion_fd);
 #endif
 
-	smdk4x12_v4l2_close(smdk4x12_camera, v4l2_id);
+	exynos_v4l2_close(exynos_camera, v4l2_id);
 
 	rc = -1;
 
@@ -226,13 +226,13 @@ complete:
 	return rc;
 }
 
-void smdk4x12_v4l2_output_stop(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_v4l2_output *output)
+void exynos_v4l2_output_stop(struct exynos_camera *exynos_camera,
+	struct exynos_v4l2_output *output)
 {
 	int v4l2_id;
 	int rc;
 
-	if (smdk4x12_camera == NULL || output == NULL)
+	if (exynos_camera == NULL || output == NULL)
 		return;
 
 //	ALOGD("%s()", __func__);
@@ -244,7 +244,7 @@ void smdk4x12_v4l2_output_stop(struct smdk4x12_camera *smdk4x12_camera,
 
 	v4l2_id = output->v4l2_id;
 
-	rc = smdk4x12_v4l2_reqbufs_out(smdk4x12_camera, v4l2_id, 0);
+	rc = exynos_v4l2_reqbufs_out(exynos_camera, v4l2_id, 0);
 	if (rc < 0)
 		ALOGE("%s: Unable to request buffers", __func__);
 
@@ -255,18 +255,18 @@ void smdk4x12_v4l2_output_stop(struct smdk4x12_camera *smdk4x12_camera,
 
 #ifdef EXYNOS_ION
 	if (output->memory_ion_fd >= 0) {
-		smdk4x12_ion_free(smdk4x12_camera, output->memory_ion_fd);
+		exynos_ion_free(exynos_camera, output->memory_ion_fd);
 		output->memory_ion_fd = -1;
 	}
 #endif
 
-	smdk4x12_v4l2_close(smdk4x12_camera, v4l2_id);
+	exynos_v4l2_close(exynos_camera, v4l2_id);
 
 	output->enabled = 0;
 }
 
-int smdk4x12_v4l2_output(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_v4l2_output *output, int buffer_address)
+int exynos_v4l2_output(struct exynos_camera *exynos_camera,
+	struct exynos_v4l2_output *output, int buffer_address)
 {
 	struct fimc_buf fimc_buffer;
 	void *fb_base;
@@ -277,7 +277,7 @@ int smdk4x12_v4l2_output(struct smdk4x12_camera *smdk4x12_camera,
 	int v4l2_id;
 	int rc;
 
-	if (smdk4x12_camera == NULL || output == NULL)
+	if (exynos_camera == NULL || output == NULL)
 		return -EINVAL;
 
 //	ALOGD("%s()", __func__);
@@ -298,13 +298,13 @@ int smdk4x12_v4l2_output(struct smdk4x12_camera *smdk4x12_camera,
 	buffer_length = output->buffer_length;
 	v4l2_id = output->v4l2_id;
 
-	rc = smdk4x12_v4l2_g_fbuf(smdk4x12_camera, v4l2_id, &fb_base, NULL, NULL, NULL);
+	rc = exynos_v4l2_g_fbuf(exynos_camera, v4l2_id, &fb_base, NULL, NULL, NULL);
 	if (rc < 0) {
 		ALOGE("%s: Unable to get fbuf", __func__);
 		goto error;
 	}
 
-	rc = smdk4x12_v4l2_s_fbuf(smdk4x12_camera, v4l2_id, fb_base, width, height, format);
+	rc = exynos_v4l2_s_fbuf(exynos_camera, v4l2_id, fb_base, width, height, format);
 	if (rc < 0) {
 		ALOGE("%s: Unable to set fbuf", __func__);
 		goto error;
@@ -314,21 +314,21 @@ int smdk4x12_v4l2_output(struct smdk4x12_camera *smdk4x12_camera,
 
 	address = output->memory_address + buffer_length * output->memory_index;
 
-	smdk4x12_camera_yuv_planes(width, height, format, address, (int *) &fimc_buffer.base[0], (int *) &fimc_buffer.base[1], (int *) &fimc_buffer.base[2]);
+	exynos_camera_yuv_planes(width, height, format, address, (int *) &fimc_buffer.base[0], (int *) &fimc_buffer.base[1], (int *) &fimc_buffer.base[2]);
 
-	rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, v4l2_id, V4L2_CID_DST_INFO, (int) &fimc_buffer);
+	rc = exynos_v4l2_s_ctrl(exynos_camera, v4l2_id, V4L2_CID_DST_INFO, (int) &fimc_buffer);
 	if (rc < 0) {
 		ALOGE("%s: Unable to set dst info", __func__);
 		goto error;
 	}
 
-	rc = smdk4x12_v4l2_s_fmt_win(smdk4x12_camera, v4l2_id, 0, 0, width, height);
+	rc = exynos_v4l2_s_fmt_win(exynos_camera, v4l2_id, 0, 0, width, height);
 	if (rc < 0) {
 		ALOGE("%s: Unable to set overlay win", __func__);
 		goto error;
 	}
 
-	rc = smdk4x12_v4l2_streamon_out(smdk4x12_camera, v4l2_id);
+	rc = exynos_v4l2_streamon_out(exynos_camera, v4l2_id);
 	if (rc < 0) {
 		ALOGE("%s: Unable to start stream", __func__);
 		goto error;
@@ -336,21 +336,21 @@ int smdk4x12_v4l2_output(struct smdk4x12_camera *smdk4x12_camera,
 
 	memset(&fimc_buffer, 0, sizeof(fimc_buffer));
 
-	smdk4x12_camera_yuv_planes(buffer_width, buffer_height, buffer_format, buffer_address, (int *) &fimc_buffer.base[0], (int *) &fimc_buffer.base[1], (int *) &fimc_buffer.base[2]);
+	exynos_camera_yuv_planes(buffer_width, buffer_height, buffer_format, buffer_address, (int *) &fimc_buffer.base[0], (int *) &fimc_buffer.base[1], (int *) &fimc_buffer.base[2]);
 
-	rc = smdk4x12_v4l2_qbuf_out(smdk4x12_camera, v4l2_id, 0, (unsigned long) &fimc_buffer);
+	rc = exynos_v4l2_qbuf_out(exynos_camera, v4l2_id, 0, (unsigned long) &fimc_buffer);
 	if (rc < 0) {
 		ALOGE("%s: Unable to queue buffer", __func__);
 		goto error;
 	}
 
-	rc = smdk4x12_v4l2_dqbuf_out(smdk4x12_camera, v4l2_id);
+	rc = exynos_v4l2_dqbuf_out(exynos_camera, v4l2_id);
 	if (rc < 0) {
 		ALOGE("%s: Unable to dequeue buffer", __func__);
 		goto error;
 	}
 
-	rc = smdk4x12_v4l2_streamoff_out(smdk4x12_camera, v4l2_id);
+	rc = exynos_v4l2_streamoff_out(exynos_camera, v4l2_id);
 	if (rc < 0) {
 		ALOGE("%s: Unable to stop stream", __func__);
 		goto error;
@@ -366,13 +366,13 @@ complete:
 	return rc;
 }
 
-int smdk4x12_v4l2_output_release(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_v4l2_output *output)
+int exynos_v4l2_output_release(struct exynos_camera *exynos_camera,
+	struct exynos_v4l2_output *output)
 {
 	int buffers_count;
 	int memory_index;
 
-	if (smdk4x12_camera == NULL || output == NULL)
+	if (exynos_camera == NULL || output == NULL)
 		return -EINVAL;
 
 //	ALOGD("%s()", __func__);
diff --git a/camera/include/fimc.h b/camera/include/fimc.h
deleted file mode 100644
index 3e7732d..0000000
--- a/camera/include/fimc.h
+++ /dev/null
@@ -1,405 +0,0 @@
-/* linux/drivers/media/video/samsung/fimc/fimc.h
- *
- * Copyright (c) 2010 Samsung Electronics Co., Ltd.
- *		http://www.samsung.com/
- *
- * Header file for Samsung Camera Interface (FIMC) driver
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
-*/
-
-
-#ifndef __FIMC_H
-#define __FIMC_H __FILE__
-
-typedef unsigned int dma_addr_t;
-typedef __u32  u32;
-typedef __s32  s32;
-
-#ifdef __KERNEL__
-#include <linux/wait.h>
-#include <linux/mutex.h>
-#include <linux/i2c.h>
-#include <linux/fb.h>
-#include <linux/videodev2.h>
-#include <linux/platform_device.h>
-#include <media/v4l2-common.h>
-#include <media/v4l2-device.h>
-#include <media/v4l2-ioctl.h>
-#include <media/videobuf-core.h>
-#ifdef CONFIG_SLP_DMABUF
-#include <media/videobuf2-core.h>
-#endif
-#include <media/v4l2-mediabus.h>
-#if defined(CONFIG_BUSFREQ_OPP) || defined(CONFIG_BUSFREQ_LOCK_WRAPPER)
-#include <mach/dev.h>
-#endif
-#include <plat/media.h>
-#include <plat/fimc.h>
-#include <plat/cpu.h>
-#endif
-
-#ifdef CONFIG_PM_RUNTIME
-#include <linux/pm_runtime.h>
-#endif
-
-#define FIMC_NAME		"s3c-fimc"
-#define FIMC_CMA_NAME		"fimc"
-
-#define FIMC_CORE_CLK		"sclk_fimc"
-
-extern int fimc_clk_rate(void);
-
-#define EXYNOS_BUSFREQ_NAME	"exynos-busfreq"
-
-#if defined(CONFIG_ARCH_EXYNOS4)
-#define FIMC_DEVICES		4
-#define FIMC_PHYBUFS		32
-#define FIMC_MAXCAMS		7
-#else
-#define FIMC_DEVICES		3
-#define FIMC_PHYBUFS		4
-#define FIMC_MAXCAMS		5
-#endif
-
-#define FIMC_SUBDEVS		3
-#define FIMC_OUTBUFS		3
-#define FIMC_INQUEUES		10
-#if defined(CONFIG_SLP)
-#define FIMC_MAX_CTXS		8
-#else
-#define FIMC_MAX_CTXS		4
-#endif
-#define FIMC_TPID		3
-#define FIMC_CAPBUFS		32
-#define FIMC_ONESHOT_TIMEOUT	200
-#define FIMC_DQUEUE_TIMEOUT	1000
-
-#define FIMC_FIFOOFF_CNT	1000000 /* Sufficiently big value for stop */
-
-#define FORMAT_FLAGS_PACKED	0x1
-#define FORMAT_FLAGS_PLANAR	0x2
-
-#define FIMC_ADDR_Y		0
-#define FIMC_ADDR_CB		1
-#define FIMC_ADDR_CR		2
-
-#define FIMC_HD_WIDTH		1280
-#define FIMC_HD_HEIGHT		720
-
-#define FIMC_FHD_WIDTH		1920
-#define FIMC_FHD_HEIGHT		1080
-
-#define FIMC_MMAP_IDX		-1
-#define FIMC_USERPTR_IDX	-2
-
-#define FIMC_HCLK		0
-#define FIMC_SCLK		1
-#define CSI_CH_0		0
-#define CSI_CH_1		1
-#if defined(CONFIG_VIDEO_FIMC_FIFO)
-#define FIMC_OVLY_MODE FIMC_OVLY_FIFO
-#elif defined(CONFIG_VIDEO_FIMC_DMA_AUTO)
-#define FIMC_OVLY_MODE FIMC_OVLY_DMA_AUTO
-#endif
-
-#define PINGPONG_2ADDR_MODE
-#if defined(PINGPONG_2ADDR_MODE)
-#define FIMC_PINGPONG 2
-#endif
-
-#define check_bit(data, loc)	((data) & (0x1<<(loc)))
-#define FRAME_SEQ		0xf
-
-#define fimc_cam_use		((pdata->use_cam) ? 1 : 0)
-
-#define L2_FLUSH_ALL	SZ_1M
-#define L1_FLUSH_ALL	SZ_64K
-
-/*
- * ENUMERATIONS
-*/
-enum fimc_status {
-	FIMC_READY_OFF		= 0x00,
-	FIMC_STREAMOFF		= 0x01,
-	FIMC_READY_ON		= 0x02,
-	FIMC_STREAMON		= 0x03,
-	FIMC_STREAMON_IDLE	= 0x04, /* oneshot mode */
-	FIMC_OFF_SLEEP		= 0x05,
-	FIMC_ON_SLEEP		= 0x06,
-	FIMC_ON_IDLE_SLEEP	= 0x07, /* oneshot mode */
-	FIMC_READY_RESUME	= 0x08,
-	FIMC_BUFFER_STOP	= 0x09,
-	FIMC_BUFFER_START	= 0x0A,
-};
-
-enum fimc_fifo_state {
-	FIFO_CLOSE,
-	FIFO_SLEEP,
-};
-
-enum fimc_fimd_state {
-	FIMD_OFF,
-	FIMD_ON,
-};
-
-enum fimc_rot_flip {
-	FIMC_XFLIP	= 0x01,
-	FIMC_YFLIP	= 0x02,
-	FIMC_ROT	= 0x10,
-};
-
-enum fimc_input {
-	FIMC_SRC_CAM,
-	FIMC_SRC_MSDMA,
-};
-
-enum fimc_overlay_mode {
-	FIMC_OVLY_NOT_FIXED		= 0x0,	/* Overlay mode isn't fixed. */
-	FIMC_OVLY_FIFO			= 0x1,	/* Non-destructive Overlay with FIFO */
-	FIMC_OVLY_DMA_AUTO		= 0x2,	/* Non-destructive Overlay with DMA */
-	FIMC_OVLY_DMA_MANUAL		= 0x3,	/* Non-destructive Overlay with DMA */
-	FIMC_OVLY_NONE_SINGLE_BUF	= 0x4,	/* Destructive Overlay with DMA single destination buffer */
-	FIMC_OVLY_NONE_MULTI_BUF	= 0x5,	/* Destructive Overlay with DMA multiple dstination buffer */
-};
-
-enum fimc_autoload {
-	FIMC_AUTO_LOAD,
-	FIMC_ONE_SHOT,
-};
-
-enum fimc_log {
-	FIMC_LOG_DEBUG		= 0x1000,
-	FIMC_LOG_INFO_L2	= 0x0200,
-	FIMC_LOG_INFO_L1	= 0x0100,
-	FIMC_LOG_WARN		= 0x0010,
-	FIMC_LOG_ERR		= 0x0001,
-};
-
-enum fimc_range {
-	FIMC_RANGE_NARROW	= 0x0,
-	FIMC_RANGE_WIDE		= 0x1,
-};
-
-enum fimc_pixel_format_type{
-	FIMC_RGB,
-	FIMC_YUV420,
-	FIMC_YUV422,
-	FIMC_YUV444,
-};
-
-enum fimc_framecnt_seq {
-	FIMC_FRAMECNT_SEQ_DISABLE,
-	FIMC_FRAMECNT_SEQ_ENABLE,
-};
-
-enum fimc_sysmmu_flag {
-	FIMC_SYSMMU_OFF,
-	FIMC_SYSMMU_ON,
-};
-
-enum fimc_id {
-	FIMC0 = 0x0,
-	FIMC1 = 0x1,
-	FIMC2 = 0x2,
-	FIMC3 = 0x3,
-};
-
-enum fimc_power_status {
-	FIMC_POWER_OFF,
-	FIMC_POWER_ON,
-	FIMC_POWER_SUSPEND,
-};
-
-enum cam_mclk_status {
-	CAM_MCLK_OFF,
-	CAM_MCLK_ON,
-};
-
-enum fimc_plane_num {
-	PLANE_1 = 0x1,
-	PLANE_2 = 0x2,
-	PLANE_3 = 0x3,
-	PLANE_4 = 0x4,
-};
-
-/*
- * STRUCTURES
-*/
-
-/* for reserved memory */
-struct fimc_meminfo {
-#ifdef CONFIG_USE_FIMC_CMA
-	void		*cpu_addr;
-#endif
-	dma_addr_t	base;		/* buffer base */
-	size_t		size;		/* total length */
-	dma_addr_t	curr;		/* current addr */
-	dma_addr_t	vaddr_base;		/* buffer base */
-	dma_addr_t	vaddr_curr;		/* current addr */
-};
-
-struct fimc_buf {
-	dma_addr_t	base[3];
-	size_t		length[3];
-};
-
-struct fimc_overlay_buf {
-	u32 vir_addr[3];
-	size_t size[3];
-	u32 phy_addr[3];
-};
-
-struct fimc_overlay {
-	enum fimc_overlay_mode mode;
-	struct fimc_overlay_buf buf;
-	s32 req_idx;
-};
-
-/* for output overlay device */
-struct fimc_idx {
-	int ctx;
-	int idx;
-};
-
-struct fimc_ctx_idx {
-	struct fimc_idx prev;
-	struct fimc_idx active;
-	struct fimc_idx next;
-};
-
-/* scaler abstraction: local use recommended */
-struct fimc_scaler {
-	u32 bypass;
-	u32 hfactor;
-	u32 vfactor;
-	u32 pre_hratio;
-	u32 pre_vratio;
-	u32 pre_dst_width;
-	u32 pre_dst_height;
-	u32 scaleup_h;
-	u32 scaleup_v;
-	u32 main_hratio;
-	u32 main_vratio;
-	u32 real_width;
-	u32 real_height;
-	u32 shfactor;
-	u32 skipline;
-};
-
-struct s3cfb_user_window {
-	int x;
-	int y;
-};
-
-enum s3cfb_data_path_t {
-	DATA_PATH_FIFO	= 0,
-	DATA_PATH_DMA	= 1,
-	DATA_PATH_IPC	= 2,
-};
-
-enum s3cfb_mem_owner_t {
-	DMA_MEM_NONE	= 0,
-	DMA_MEM_FIMD	= 1,
-	DMA_MEM_OTHER	= 2,
-};
-#define S3CFB_WIN_OFF_ALL	_IO('F', 202)
-#define S3CFB_WIN_POSITION	_IOW('F', 203, struct s3cfb_user_window)
-#define S3CFB_GET_LCD_WIDTH	_IOR('F', 302, int)
-#define S3CFB_GET_LCD_HEIGHT	_IOR('F', 303, int)
-#define S3CFB_SET_WRITEBACK	_IOW('F', 304, u32)
-#define S3CFB_SET_WIN_ON	_IOW('F', 305, u32)
-#define S3CFB_SET_WIN_OFF	_IOW('F', 306, u32)
-#define S3CFB_SET_WIN_PATH	_IOW('F', 307, enum s3cfb_data_path_t)
-#define S3CFB_SET_WIN_ADDR	_IOW('F', 308, unsigned long)
-#define S3CFB_SET_WIN_MEM	_IOW('F', 309, enum s3cfb_mem_owner_t)
-/* ------------------------------------------------------------------------ */
-
-struct fimc_fbinfo {
-	struct fb_fix_screeninfo	*fix;
-	struct fb_var_screeninfo	*var;
-	int				lcd_hres;
-	int				lcd_vres;
-	u32				is_enable;
-	/* lcd fifo control */
-
-	int (*open_fifo)(int id, int ch, int (*do_priv)(void *), void *param);
-	int (*close_fifo)(int id, int (*do_priv)(void *), void *param);
-};
-
-struct fimc_limit {
-	u32 pre_dst_w;
-	u32 bypass_w;
-	u32 trg_h_no_rot;
-	u32 trg_h_rot;
-	u32 real_w_no_rot;
-	u32 real_h_rot;
-};
-
-enum FIMC_EFFECT_FIN {
-	FIMC_EFFECT_FIN_BYPASS = 0,
-	FIMC_EFFECT_FIN_ARBITRARY_CBCR,
-	FIMC_EFFECT_FIN_NEGATIVE,
-	FIMC_EFFECT_FIN_ART_FREEZE,
-	FIMC_EFFECT_FIN_EMBOSSING,
-	FIMC_EFFECT_FIN_SILHOUETTE,
-};
-
-
-struct fimc_effect {
-	int ie_on;
-	int ie_after_sc;
-	enum FIMC_EFFECT_FIN fin;
-	int pat_cb;
-	int pat_cr;
-};
-
-/* debug macro */
-#define FIMC_LOG_DEFAULT	(FIMC_LOG_WARN | FIMC_LOG_ERR)
-
-#define FIMC_DEBUG(fmt, ...)						\
-	do {								\
-		if (ctrl->log & FIMC_LOG_DEBUG)				\
-			printk(KERN_DEBUG FIMC_NAME "%d: "		\
-				fmt, ctrl->id, ##__VA_ARGS__);			\
-	} while (0)
-
-#define FIMC_INFO_L2(fmt, ...)						\
-	do {								\
-		if (ctrl->log & FIMC_LOG_INFO_L2)			\
-			printk(KERN_INFO FIMC_NAME "%d: "		\
-				fmt, ctrl->id, ##__VA_ARGS__);			\
-	} while (0)
-
-#define FIMC_INFO_L1(fmt, ...)						\
-	do {								\
-		if (ctrl->log & FIMC_LOG_INFO_L1)			\
-			printk(KERN_INFO FIMC_NAME "%d: "		\
-				fmt, ctrl->id, ##__VA_ARGS__);			\
-	} while (0)
-
-#define FIMC_WARN(fmt, ...)						\
-	do {								\
-		if (ctrl->log & FIMC_LOG_WARN)				\
-			printk(KERN_WARNING FIMC_NAME "%d: "		\
-				fmt, ctrl->id, ##__VA_ARGS__);			\
-	} while (0)
-
-
-#define FIMC_ERROR(fmt, ...)						\
-	do {								\
-		if (ctrl->log & FIMC_LOG_ERR)				\
-			printk(KERN_ERR FIMC_NAME "%d: "		\
-				fmt, ctrl->id, ##__VA_ARGS__);			\
-	} while (0)
-
-
-#define fimc_dbg(fmt, ...)		FIMC_DEBUG(fmt, ##__VA_ARGS__)
-#define fimc_info2(fmt, ...)		FIMC_INFO_L2(fmt, ##__VA_ARGS__)
-#define fimc_info1(fmt, ...)		FIMC_INFO_L1(fmt, ##__VA_ARGS__)
-#define fimc_warn(fmt, ...)		FIMC_WARN(fmt, ##__VA_ARGS__)
-#define fimc_err(fmt, ...)		FIMC_ERROR(fmt, ##__VA_ARGS__)
-
-#endif /* __FIMC_H */
diff --git a/camera/include/ion.h b/camera/include/linux/ion.h
index 29dba57..29dba57 100644
--- a/camera/include/ion.h
+++ b/camera/include/linux/ion.h
diff --git a/camera/include/s5c73m3.h b/camera/include/linux/s5c73m3.h
index ffb582e..ffb582e 100644
--- a/camera/include/s5c73m3.h
+++ b/camera/include/linux/s5c73m3.h
diff --git a/camera/include/linux/videodev2_exynos_camera.h b/camera/include/linux/videodev2_exynos_camera.h
new file mode 100644
index 0000000..557b5e1
--- /dev/null
+++ b/camera/include/linux/videodev2_exynos_camera.h
@@ -0,0 +1,2047 @@
+/*
+ * Video for Linux Two header file for samsung
+ *
+ * Copyright (C) 2009, Dongsoo Nathaniel Kim<dongsoo45.kim@samsung.com>
+ *
+ * This header file contains several v4l2 APIs to be proposed to v4l2
+ * community and until bein accepted, will be used restrictly in Samsung's
+ * camera interface driver FIMC.
+ *
+ * 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.
+ */
+
+#ifndef __LINUX_VIDEODEV2_SAMSUNG_H
+#define __LINUX_VIDEODEV2_SAMSUNG_H
+
+/* Values for 'capabilities' field */
+/* Object detection device */
+#define V4L2_CAP_OBJ_RECOGNITION	0x10000000
+/* strobe control */
+#define V4L2_CAP_STROBE			0x20000000
+
+#define V4L2_CID_FOCUS_MODE		(V4L2_CID_CAMERA_CLASS_BASE+17)
+/* Focus Methods */
+enum v4l2_focus_mode {
+	V4L2_FOCUS_MODE_AUTO		= 0,
+	V4L2_FOCUS_MODE_MACRO		= 1,
+	V4L2_FOCUS_MODE_MANUAL		= 2,
+	V4L2_FOCUS_MODE_LASTP		= 2,
+};
+
+#define V4L2_CID_ZOOM_MODE		(V4L2_CID_CAMERA_CLASS_BASE+18)
+/* Zoom Methods */
+enum v4l2_zoom_mode {
+	V4L2_ZOOM_MODE_CONTINUOUS	= 0,
+	V4L2_ZOOM_MODE_OPTICAL		= 1,
+	V4L2_ZOOM_MODE_DIGITAL		= 2,
+	V4L2_ZOOM_MODE_LASTP		= 2,
+};
+
+/* Exposure Methods */
+#define V4L2_CID_PHOTOMETRY		(V4L2_CID_CAMERA_CLASS_BASE+19)
+enum v4l2_photometry_mode {
+	V4L2_PHOTOMETRY_MULTISEG	= 0, /*Multi Segment*/
+	V4L2_PHOTOMETRY_CWA		= 1, /*Centre Weighted Average*/
+	V4L2_PHOTOMETRY_SPOT		= 2,
+	V4L2_PHOTOMETRY_AFSPOT		= 3, /*Spot metering on focused point*/
+	V4L2_PHOTOMETRY_LASTP		= V4L2_PHOTOMETRY_AFSPOT,
+};
+
+/* Manual exposure control items menu type: iris, shutter, iso */
+#define V4L2_CID_CAM_APERTURE	(V4L2_CID_CAMERA_CLASS_BASE+20)
+enum v4l2_aperture_mode {
+	APERTURE_F_AUTO = 0,
+	APERTURE_F_2_8,
+	APERTURE_F_3_2,
+	APERTURE_F_3_6,
+	APERTURE_F_4_0,
+	APERTURE_F_4_5,
+	APERTURE_F_5_1,
+	APERTURE_F_5_7,
+	APERTURE_F_6_4,
+	APERTURE_F_7_2,
+	APERTURE_MAX,
+};
+#define V4L2_CID_CAM_SHUTTER	(V4L2_CID_CAMERA_CLASS_BASE+21)
+#define V4L2_CID_CAM_ISO	(V4L2_CID_CAMERA_CLASS_BASE+22)
+
+/* Following CIDs are menu type */
+#define V4L2_CID_SCENEMODE	(V4L2_CID_CAMERA_CLASS_BASE+23)
+#define V4L2_CID_CAM_STABILIZE	(V4L2_CID_CAMERA_CLASS_BASE+24)
+#define V4L2_CID_CAM_MULTISHOT	(V4L2_CID_CAMERA_CLASS_BASE+25)
+
+/* Control dynamic range */
+#define V4L2_CID_CAM_DR		(V4L2_CID_CAMERA_CLASS_BASE+26)
+
+/* White balance preset control */
+#define V4L2_CID_WHITE_BALANCE_PRESET (V4L2_CID_CAMERA_CLASS_BASE+27)
+#define V4L2_CID_CAM_SENSOR_FW_VER (V4L2_CID_CAMERA_CLASS_BASE + 28)
+#define V4L2_CID_CAM_PHONE_FW_VER (V4L2_CID_CAMERA_CLASS_BASE + 29)
+
+/* CID extensions */
+#define V4L2_CID_ROTATION		(V4L2_CID_PRIVATE_BASE + 0)
+#define V4L2_CID_PADDR_Y		(V4L2_CID_PRIVATE_BASE + 1)
+#define V4L2_CID_PADDR_CB		(V4L2_CID_PRIVATE_BASE + 2)
+#define V4L2_CID_PADDR_CR		(V4L2_CID_PRIVATE_BASE + 3)
+#define V4L2_CID_PADDR_CBCR		(V4L2_CID_PRIVATE_BASE + 4)
+#define V4L2_CID_OVERLAY_AUTO		(V4L2_CID_PRIVATE_BASE + 5)
+#define V4L2_CID_OVERLAY_VADDR0		(V4L2_CID_PRIVATE_BASE + 6)
+#define V4L2_CID_OVERLAY_VADDR1		(V4L2_CID_PRIVATE_BASE + 7)
+#define V4L2_CID_OVERLAY_VADDR2		(V4L2_CID_PRIVATE_BASE + 8)
+#define V4L2_CID_OVLY_MODE		(V4L2_CID_PRIVATE_BASE + 9)
+#define V4L2_CID_DST_INFO		(V4L2_CID_PRIVATE_BASE + 10)
+/* UMP secure id control */
+#define V4L2_CID_GET_UMP_SECURE_ID	(V4L2_CID_PRIVATE_BASE + 11)
+#define V4L2_CID_GET_PHY_SRC_YADDR	(V4L2_CID_PRIVATE_BASE + 12)
+#define V4L2_CID_GET_PHY_SRC_CADDR	(V4L2_CID_PRIVATE_BASE + 13)
+#define V4L2_CID_IMAGE_EFFECT_FN	(V4L2_CID_PRIVATE_BASE + 16)
+#define V4L2_CID_IMAGE_EFFECT_APPLY	(V4L2_CID_PRIVATE_BASE + 17)
+#define V4L2_CID_IMAGE_EFFECT_CB	(V4L2_CID_PRIVATE_BASE + 18)
+#define V4L2_CID_IMAGE_EFFECT_CR	(V4L2_CID_PRIVATE_BASE + 19)
+#define V4L2_CID_RESERVED_MEM_BASE_ADDR	(V4L2_CID_PRIVATE_BASE + 20)
+#define V4L2_CID_FIMC_VERSION		(V4L2_CID_PRIVATE_BASE + 21)
+
+#define V4L2_CID_CACHE_FLUSH		(V4L2_CID_PRIVATE_BASE + 61)
+#define V4L2_CID_RESERVED_MEM_SIZE	(V4L2_CID_PRIVATE_BASE + 63)
+#define V4L2_CID_STREAM_PAUSE			(V4L2_CID_PRIVATE_BASE + 53)
+#define V4L2_CID_CACHE_FLUSH			(V4L2_CID_PRIVATE_BASE + 61)
+#define V4L2_CID_RESERVED_MEM_SIZE		(V4L2_CID_PRIVATE_BASE + 63)
+
+/* CID Extensions for camera sensor operations */
+#define V4L2_CID_CAM_PREVIEW_ONOFF		(V4L2_CID_PRIVATE_BASE + 64)
+#define V4L2_CID_CAM_CAPTURE			(V4L2_CID_PRIVATE_BASE + 65)
+/* #define V4L2_CID_CAM_JPEG_MEMSIZE	(V4L2_CID_PRIVATE_BASE + 66) */
+
+#define V4L2_CID_CAM_DATE_INFO_YEAR		(V4L2_CID_PRIVATE_BASE + 14)
+#define V4L2_CID_CAM_DATE_INFO_MONTH		(V4L2_CID_PRIVATE_BASE + 15)
+#define V4L2_CID_CAM_DATE_INFO_DATE		(V4L2_CID_PRIVATE_BASE + 22)
+#define V4L2_CID_CAM_SENSOR_VER			(V4L2_CID_PRIVATE_BASE + 23)
+#define V4L2_CID_CAM_FW_MINOR_VER		(V4L2_CID_PRIVATE_BASE + 24)
+#define V4L2_CID_CAM_FW_MAJOR_VER		(V4L2_CID_PRIVATE_BASE + 25)
+#define V4L2_CID_CAM_PRM_MINOR_VER		(V4L2_CID_PRIVATE_BASE + 26)
+#define V4L2_CID_CAM_PRM_MAJOR_VER		(V4L2_CID_PRIVATE_BASE + 27)
+#define V4L2_CID_CAM_FW_VER			(V4L2_CID_PRIVATE_BASE + 28)
+#define V4L2_CID_CAM_SET_FW_ADDR		(V4L2_CID_PRIVATE_BASE + 29)
+#define V4L2_CID_CAM_SET_FW_SIZE		(V4L2_CID_PRIVATE_BASE + 30)
+#define V4L2_CID_CAM_UPDATE_FW	(V4L2_CID_PRIVATE_BASE + 31)
+enum v4l2_firmware_mode {
+	FW_MODE_NONE,
+	FW_MODE_VERSION,
+	FW_MODE_UPDATE,
+	FW_MODE_DUMP,
+};
+
+#define V4L2_CID_CAM_JPEG_MAIN_SIZE		(V4L2_CID_PRIVATE_BASE + 32)
+#define V4L2_CID_CAM_JPEG_MAIN_OFFSET		(V4L2_CID_PRIVATE_BASE + 33)
+#define V4L2_CID_CAM_JPEG_THUMB_SIZE		(V4L2_CID_PRIVATE_BASE + 34)
+#define V4L2_CID_CAM_JPEG_THUMB_OFFSET		(V4L2_CID_PRIVATE_BASE + 35)
+#define V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET	(V4L2_CID_PRIVATE_BASE + 36)
+#define V4L2_CID_CAM_JPEG_QUALITY	(V4L2_CID_PRIVATE_BASE + 37)
+#define V4L2_CID_CAM_SENSOR_MAKER	(V4L2_CID_PRIVATE_BASE + 38)
+#define V4L2_CID_CAM_SENSOR_OPTICAL	(V4L2_CID_PRIVATE_BASE + 39)
+#define V4L2_CID_CAM_AF_VER_LOW		(V4L2_CID_PRIVATE_BASE + 40)
+#define V4L2_CID_CAM_AF_VER_HIGH	(V4L2_CID_PRIVATE_BASE + 41)
+#define V4L2_CID_CAM_GAMMA_RG_LOW	(V4L2_CID_PRIVATE_BASE + 42)
+#define V4L2_CID_CAM_GAMMA_RG_HIGH	(V4L2_CID_PRIVATE_BASE + 43)
+#define V4L2_CID_CAM_GAMMA_BG_LOW	(V4L2_CID_PRIVATE_BASE + 44)
+#define V4L2_CID_CAM_GAMMA_BG_HIGH	(V4L2_CID_PRIVATE_BASE + 45)
+#define V4L2_CID_CAM_DUMP_FW		(V4L2_CID_PRIVATE_BASE + 46)
+#define V4L2_CID_CAM_GET_DUMP_SIZE  (V4L2_CID_PRIVATE_BASE + 47)
+#define V4L2_CID_CAMERA_VT_MODE		(V4L2_CID_PRIVATE_BASE + 48)
+enum cam_vt_mode {
+	CAM_VT_MODE_NONE ,
+	CAM_VT_MODE_3G ,
+	CAM_VT_MODE_VOIP ,
+};
+
+#define V4L2_CID_CAMERA_VGA_BLUR	(V4L2_CID_PRIVATE_BASE + 49)
+#define V4L2_CID_CAMERA_CAPTURE		(V4L2_CID_PRIVATE_BASE + 50)
+#define V4L2_CID_CAMERA_HDR (V4L2_CID_PRIVATE_BASE + 51)
+#define V4L2_CID_CAMERA_HYBRID		(V4L2_CID_PRIVATE_BASE + 52)
+
+#define V4L2_CID_MAIN_SW_DATE_INFO_YEAR		(V4L2_CID_PRIVATE_BASE + 54)
+#define V4L2_CID_MAIN_SW_DATE_INFO_MONTH	(V4L2_CID_PRIVATE_BASE + 55)
+#define V4L2_CID_MAIN_SW_DATE_INFO_DATE		(V4L2_CID_PRIVATE_BASE + 56)
+#define V4L2_CID_MAIN_SW_FW_MINOR_VER		(V4L2_CID_PRIVATE_BASE + 57)
+#define V4L2_CID_MAIN_SW_FW_MAJOR_VER		(V4L2_CID_PRIVATE_BASE + 58)
+#define V4L2_CID_MAIN_SW_PRM_MINOR_VER		(V4L2_CID_PRIVATE_BASE + 59)
+#define V4L2_CID_MAIN_SW_PRM_MAJOR_VER		(V4L2_CID_PRIVATE_BASE + 60)
+#define V4L2_CID_CAMERA_HYBRID_CAPTURE		(V4L2_CID_PRIVATE_BASE + 62)
+#define V4L2_CID_CAMERA_FAST_MODE		(V4L2_CID_PRIVATE_BASE + 66)
+enum cam_fast_mode {
+	FAST_MODE_SUBSAMPLING_NONE ,
+	FAST_MODE_SUBSAMPLING_HALF ,
+	FAST_MODE_SUBSAMPLING_QUARTER ,
+};
+#define V4L2_CID_CAMERA_POSTVIEW_CAPTURE	(V4L2_CID_PRIVATE_BASE + 67)
+#define V4L2_CID_CAMERA_CAPTURE_MODE		(V4L2_CID_PRIVATE_BASE + 68)
+#define V4L2_CID_CAMERA_YUV_CAPTURE (V4L2_CID_PRIVATE_BASE + 69)
+
+#define V4L2_CID_FIMC_IS_BASE			(V4L2_CTRL_CLASS_CAMERA | 0x1000)
+#define V4L2_CID_FIMC_IS_TUNE_BASE		(V4L2_CTRL_CLASS_CAMERA | 0x2000)
+#define V4L2_CID_FIMC_IS_ISP_DBG_BASE	(V4L2_CTRL_CLASS_CAMERA | 0x3000)
+
+#define V4L2_CID_IS_LOAD_FW			(V4L2_CID_FIMC_IS_BASE + 10)
+#define V4L2_CID_IS_INIT_PARAM			(V4L2_CID_FIMC_IS_BASE + 11)
+#define V4L2_CID_IS_RESET			(V4L2_CID_FIMC_IS_BASE + 12)
+#define V4L2_CID_IS_S_POWER			(V4L2_CID_FIMC_IS_BASE + 13)
+enum is_set_power {
+	IS_POWER_OFF,
+	IS_POWER_ON
+};
+
+#define V4L2_CID_IS_S_STREAM			(V4L2_CID_FIMC_IS_BASE + 14)
+enum is_set_stream {
+	IS_DISABLE_STREAM,
+	IS_ENABLE_STREAM
+};
+
+#define V4L2_CID_IS_S_SCENARIO_MODE		(V4L2_CID_FIMC_IS_BASE + 15)
+#define V4L2_CID_IS_S_FORMAT_SCENARIO		(V4L2_CID_FIMC_IS_BASE + 16)
+enum scenario_mode {
+	IS_MODE_PREVIEW_STILL,
+	IS_MODE_PREVIEW_VIDEO,
+	IS_MODE_CAPTURE_STILL,
+	IS_MODE_CAPTURE_VIDEO,
+	IS_MODE_MAX
+};
+
+/* global */
+#define V4L2_CID_IS_CAMERA_SHOT_MODE_NORMAL	(V4L2_CID_FIMC_IS_BASE + 400)
+/* value : 1 : single shot , >=2 : continuous shot */
+
+#define V4L2_CID_IS_CAMERA_SENSOR_NUM		(V4L2_CID_FIMC_IS_BASE + 201)
+
+#define V4L2_CID_IS_CAMERA_FOCUS_MODE		(V4L2_CID_FIMC_IS_BASE + 401)
+enum is_focus_mode {
+	IS_FOCUS_MODE_AUTO,
+	IS_FOCUS_MODE_MACRO,
+	IS_FOCUS_MODE_INFINITY,
+	IS_FOCUS_MODE_CONTINUOUS,
+	IS_FOCUS_MODE_TOUCH,
+	IS_FOCUS_MODE_FACEDETECT,
+	IS_FOCUS_MODE_IDLE,
+	IS_FOCUS_MODE_MAX,
+};
+
+#define V4L2_CID_IS_CAMERA_FLASH_MODE		(V4L2_CID_FIMC_IS_BASE + 402)
+enum is_flash_mode {
+	IS_FLASH_MODE_OFF,
+	IS_FLASH_MODE_AUTO,
+	IS_FLASH_MODE_AUTO_REDEYE,
+	IS_FLASH_MODE_ON,
+	IS_FLASH_MODE_TORCH,
+	IS_FLASH_MODE_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_AWB_MODE		(V4L2_CID_FIMC_IS_BASE + 403)
+enum is_awb_mode {
+	IS_AWB_AUTO,
+	IS_AWB_DAYLIGHT,
+	IS_AWB_CLOUDY,
+	IS_AWB_TUNGSTEN,
+	IS_AWB_FLUORESCENT,
+	IS_AWB_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_IMAGE_EFFECT		(V4L2_CID_FIMC_IS_BASE + 404)
+enum is_image_effect {
+	IS_IMAGE_EFFECT_DISABLE,
+	IS_IMAGE_EFFECT_MONOCHROME,
+	IS_IMAGE_EFFECT_NEGATIVE_MONO,
+	IS_IMAGE_EFFECT_NEGATIVE_COLOR,
+	IS_IMAGE_EFFECT_SEPIA,
+	IS_IMAGE_EFFECT_SEPIA_CB,
+	IS_IMAGE_EFFECT_SEPIA_CR,
+	IS_IMAGE_EFFECT_NEGATIVE,
+	IS_IMAGE_EFFECT_ARTFREEZE,
+	IS_IMAGE_EFFECT_EMBOSSING,
+	IS_IMAGE_EFFECT_SILHOUETTE,
+	IS_IMAGE_EFFECT_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_ISO			(V4L2_CID_FIMC_IS_BASE + 405)
+enum is_iso {
+	IS_ISO_AUTO,
+	IS_ISO_50,
+	IS_ISO_100,
+	IS_ISO_200,
+	IS_ISO_400,
+	IS_ISO_800,
+	IS_ISO_1600,
+	IS_ISO_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_CONTRAST		(V4L2_CID_FIMC_IS_BASE + 406)
+enum is_contrast {
+	IS_CONTRAST_AUTO,
+	IS_CONTRAST_MINUS_2,
+	IS_CONTRAST_MINUS_1,
+	IS_CONTRAST_DEFAULT,
+	IS_CONTRAST_PLUS_1,
+	IS_CONTRAST_PLUS_2,
+	IS_CONTRAST_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_SATURATION		(V4L2_CID_FIMC_IS_BASE + 407)
+enum is_saturation {
+	IS_SATURATION_MINUS_2,
+	IS_SATURATION_MINUS_1,
+	IS_SATURATION_DEFAULT,
+	IS_SATURATION_PLUS_1,
+	IS_SATURATION_PLUS_2,
+	IS_SATURATION_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_SHARPNESS		(V4L2_CID_FIMC_IS_BASE + 408)
+enum is_sharpness {
+	IS_SHARPNESS_MINUS_2,
+	IS_SHARPNESS_MINUS_1,
+	IS_SHARPNESS_DEFAULT,
+	IS_SHARPNESS_PLUS_1,
+	IS_SHARPNESS_PLUS_2,
+	IS_SHARPNESS_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_EXPOSURE		(V4L2_CID_FIMC_IS_BASE + 409)
+enum is_exposure {
+	IS_EXPOSURE_MINUS_4,
+	IS_EXPOSURE_MINUS_3,
+	IS_EXPOSURE_MINUS_2,
+	IS_EXPOSURE_MINUS_1,
+	IS_EXPOSURE_DEFAULT,
+	IS_EXPOSURE_PLUS_1,
+	IS_EXPOSURE_PLUS_2,
+	IS_EXPOSURE_PLUS_3,
+	IS_EXPOSURE_PLUS_4,
+	IS_EXPOSURE_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_BRIGHTNESS		(V4L2_CID_FIMC_IS_BASE + 410)
+enum is_brightness {
+	IS_BRIGHTNESS_MINUS_2,
+	IS_BRIGHTNESS_MINUS_1,
+	IS_BRIGHTNESS_DEFAULT,
+	IS_BRIGHTNESS_PLUS_1,
+	IS_BRIGHTNESS_PLUS_2,
+	IS_BRIGHTNESS_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_HUE			(V4L2_CID_FIMC_IS_BASE + 411)
+enum is_hue {
+	IS_HUE_MINUS_2,
+	IS_HUE_MINUS_1,
+	IS_HUE_DEFAULT,
+	IS_HUE_PLUS_1,
+	IS_HUE_PLUS_2,
+	IS_HUE_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_METERING		(V4L2_CID_FIMC_IS_BASE + 412)
+enum is_metering {
+	IS_METERING_AVERAGE,
+	IS_METERING_SPOT,
+	IS_METERING_MATRIX,
+	IS_METERING_CENTER,
+	IS_METERING_MAX
+};
+#define V4L2_CID_IS_CAMERA_METERING_POSITION_X	(V4L2_CID_FIMC_IS_BASE + 500)
+#define V4L2_CID_IS_CAMERA_METERING_POSITION_Y	(V4L2_CID_FIMC_IS_BASE + 501)
+#define V4L2_CID_IS_CAMERA_METERING_WINDOW_X	(V4L2_CID_FIMC_IS_BASE + 502)
+#define V4L2_CID_IS_CAMERA_METERING_WINDOW_Y	(V4L2_CID_FIMC_IS_BASE + 503)
+
+#define V4L2_CID_IS_CAMERA_AFC_MODE		(V4L2_CID_FIMC_IS_BASE + 413)
+enum is_afc_mode {
+	IS_AFC_DISABLE,
+	IS_AFC_AUTO,
+	IS_AFC_MANUAL_50HZ,
+	IS_AFC_MANUAL_60HZ,
+	IS_AFC_MAX
+};
+
+#define V4L2_CID_IS_AWB_LOCK_UNLOCK		(V4L2_CID_FIMC_IS_BASE + 496)
+enum is_awb_lock_unlock {
+	IS_AWB_LOCK,
+	IS_AWB_UNLOCK,
+	IS_AWB_LOCK_UNLOCK_MAX
+};
+
+#define V4L2_CID_IS_AE_LOCK_UNLOCK		(V4L2_CID_FIMC_IS_BASE + 497)
+enum is_ae_lock_unlock {
+	IS_AE_LOCK,
+	IS_AE_UNLOCK,
+	IS_AE_LOCK_UNLOCK_MAX
+};
+
+#define V4L2_CID_IS_FD_GET_FACE_COUNT			(V4L2_CID_FIMC_IS_BASE + 600)
+#define V4L2_CID_IS_FD_GET_FACE_FRAME_NUMBER		(V4L2_CID_FIMC_IS_BASE + 601)
+#define V4L2_CID_IS_FD_GET_FACE_CONFIDENCE		(V4L2_CID_FIMC_IS_BASE + 602)
+#define V4L2_CID_IS_FD_GET_FACE_SMILE_LEVEL		(V4L2_CID_FIMC_IS_BASE + 603)
+#define V4L2_CID_IS_FD_GET_FACE_BLINK_LEVEL		(V4L2_CID_FIMC_IS_BASE + 604)
+#define V4L2_CID_IS_FD_GET_FACE_TOPLEFT_X		(V4L2_CID_FIMC_IS_BASE + 605)
+#define V4L2_CID_IS_FD_GET_FACE_TOPLEFT_Y		(V4L2_CID_FIMC_IS_BASE + 606)
+#define V4L2_CID_IS_FD_GET_FACE_BOTTOMRIGHT_X		(V4L2_CID_FIMC_IS_BASE + 607)
+#define V4L2_CID_IS_FD_GET_FACE_BOTTOMRIGHT_Y		(V4L2_CID_FIMC_IS_BASE + 608)
+#define V4L2_CID_IS_FD_GET_LEFT_EYE_TOPLEFT_X		(V4L2_CID_FIMC_IS_BASE + 609)
+#define V4L2_CID_IS_FD_GET_LEFT_EYE_TOPLEFT_Y		(V4L2_CID_FIMC_IS_BASE + 610)
+#define V4L2_CID_IS_FD_GET_LEFT_EYE_BOTTOMRIGHT_X	(V4L2_CID_FIMC_IS_BASE + 611)
+#define V4L2_CID_IS_FD_GET_LEFT_EYE_BOTTOMRIGHT_Y	(V4L2_CID_FIMC_IS_BASE + 612)
+#define V4L2_CID_IS_FD_GET_RIGHT_EYE_TOPLEFT_X		(V4L2_CID_FIMC_IS_BASE + 613)
+#define V4L2_CID_IS_FD_GET_RIGHT_EYE_TOPLEFT_Y		(V4L2_CID_FIMC_IS_BASE + 614)
+#define V4L2_CID_IS_FD_GET_RIGHT_EYE_BOTTOMRIGHT_X	(V4L2_CID_FIMC_IS_BASE + 615)
+#define V4L2_CID_IS_FD_GET_RIGHT_EYE_BOTTOMRIGHT_Y	(V4L2_CID_FIMC_IS_BASE + 616)
+#define V4L2_CID_IS_FD_GET_MOUTH_TOPLEFT_X		(V4L2_CID_FIMC_IS_BASE + 617)
+#define V4L2_CID_IS_FD_GET_MOUTH_TOPLEFT_Y		(V4L2_CID_FIMC_IS_BASE + 618)
+#define V4L2_CID_IS_FD_GET_MOUTH_BOTTOMRIGHT_X		(V4L2_CID_FIMC_IS_BASE + 619)
+#define V4L2_CID_IS_FD_GET_MOUTH_BOTTOMRIGHT_Y		(V4L2_CID_FIMC_IS_BASE + 620)
+#define V4L2_CID_IS_FD_GET_ANGLE			(V4L2_CID_FIMC_IS_BASE + 621)
+#define V4L2_CID_IS_FD_GET_YAW_ANGLE			(V4L2_CID_FIMC_IS_BASE + 622)
+#define V4L2_CID_IS_FD_GET_NEXT				(V4L2_CID_FIMC_IS_BASE + 623)
+#define V4L2_CID_IS_FD_GET_DATA				(V4L2_CID_FIMC_IS_BASE + 624)
+
+#define V4L2_CID_IS_FD_SET_MAX_FACE_NUMBER		(V4L2_CID_FIMC_IS_BASE + 650)
+#define V4L2_CID_IS_FD_SET_ROLL_ANGLE			(V4L2_CID_FIMC_IS_BASE + 651)
+
+enum is_fd_roll_angle {
+	/* 0, 45, 0, -45 */
+	IS_FD_ROLL_ANGLE_BASIC		= 0,
+	/* 0, 30, 0, -30, 0, 45, 0, -45 */
+	IS_FD_ROLL_ANGLE_PRECISE_BASIC	= 1,
+	/* 0, 90, 0, -90 */
+	IS_FD_ROLL_ANGLE_SIDES		= 2,
+	/* 0, 90, 0, -90 0, 45, 0, -45 */
+	IS_FD_ROLL_ANGLE_PRECISE_SIDES	= 3,
+	/* 0, 90, 0, -90, 0, 180 */
+	IS_FD_ROLL_ANGLE_FULL		= 4,
+	/* 0, 90, 0, -90, 0, 180, 0, 135, 0, -135 */
+	IS_FD_ROLL_ANGLE_PRECISE_FULL	= 5,
+};
+
+#define V4L2_CID_IS_FD_SET_YAW_ANGLE	(V4L2_CID_FIMC_IS_BASE + 652)
+enum is_fd_yaw_angle {
+	IS_FD_YAW_ANGLE_0	= 0,
+	IS_FD_YAW_ANGLE_45	= 1,
+	IS_FD_YAW_ANGLE_90	= 2,
+	IS_FD_YAW_ANGLE_45_90	= 3,
+};
+
+#define V4L2_CID_IS_FD_SET_SMILE_MODE	(V4L2_CID_FIMC_IS_BASE + 653)
+enum is_fd_smile_mode {
+	IS_FD_SMILE_MODE_DISABLE	= 0,
+	IS_FD_SMILE_MODE_ENABLE		= 1,
+};
+
+#define V4L2_CID_IS_FD_SET_BLINK_MODE	(V4L2_CID_FIMC_IS_BASE + 654)
+enum is_fd_blink_mode {
+	IS_FD_BLINK_MODE_DISABLE	= 0,
+	IS_FD_BLINK_MODE_ENABLE		= 1,
+};
+
+#define V4L2_CID_IS_FD_SET_EYE_DETECT_MODE	(V4L2_CID_FIMC_IS_BASE + 655)
+enum is_fd_eye_detect_mode {
+	IS_FD_EYE_DETECT_DISABLE	= 0,
+	IS_FD_EYE_DETECT_ENABLE		= 1,
+};
+
+#define V4L2_CID_IS_FD_SET_MOUTH_DETECT_MODE	(V4L2_CID_FIMC_IS_BASE + 656)
+enum is_fd_mouth_detect_mode {
+	IS_FD_MOUTH_DETECT_DISABLE	= 0,
+	IS_FD_MOUTH_DETECT_ENABLE	= 1,
+};
+
+#define V4L2_CID_IS_FD_SET_ORIENTATION_MODE  (V4L2_CID_FIMC_IS_BASE + 657)
+enum is_fd_orientation_mode {
+	IS_FD_ORIENTATION_DISABLE	= 0,
+	IS_FD_ORIENTATION_ENABLE	= 1,
+};
+
+#define V4L2_CID_IS_FD_SET_ORIENTATION	(V4L2_CID_FIMC_IS_BASE + 658)
+#define V4L2_CID_IS_FD_SET_DATA_ADDRESS	(V4L2_CID_FIMC_IS_BASE + 659)
+
+#define V4L2_CID_IS_SET_ISP			(V4L2_CID_FIMC_IS_BASE + 440)
+enum is_isp_bypass_mode {
+	IS_ISP_BYPASS_DISABLE,
+	IS_ISP_BYPASS_ENABLE,
+	IS_ISP_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_DRC			(V4L2_CID_FIMC_IS_BASE + 441)
+enum is_drc_bypass_mode {
+	IS_DRC_BYPASS_DISABLE,
+	IS_DRC_BYPASS_ENABLE,
+	IS_DRC_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_FD			(V4L2_CID_FIMC_IS_BASE + 442)
+enum is_fd_bypass_mode {
+	IS_FD_BYPASS_DISABLE,
+	IS_FD_BYPASS_ENABLE,
+	IS_FD_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_ODC			(V4L2_CID_FIMC_IS_BASE + 443)
+enum is_odc_bypass_mode {
+	IS_ODC_BYPASS_DISABLE,
+	IS_ODC_BYPASS_ENABLE,
+	IS_ODC_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_DIS			(V4L2_CID_FIMC_IS_BASE + 444)
+enum is_dis_bypass_mode {
+	IS_DIS_BYPASS_DISABLE,
+	IS_DIS_BYPASS_ENABLE,
+	IS_DIS_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_3DNR			(V4L2_CID_FIMC_IS_BASE + 445)
+enum is_tdnr_bypass_mode {
+	IS_TDNR_BYPASS_DISABLE,
+	IS_TDNR_BYPASS_ENABLE,
+	IS_TDNR_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_SCALERC			(V4L2_CID_FIMC_IS_BASE + 446)
+enum is_scalerc_bypass_mode {
+	IS_SCALERC_BYPASS_DISABLE,
+	IS_SCALERC_BYPASS_ENABLE,
+	IS_SCALERC_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_SCALERP			(V4L2_CID_FIMC_IS_BASE + 446)
+enum is_scalerp_bypass_mode {
+	IS_SCALERP_BYPASS_DISABLE,
+	IS_SCALERP_BYPASS_ENABLE,
+	IS_SCALERP_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_ROTATION_MODE		(V4L2_CID_FIMC_IS_BASE + 450)
+enum is_rotation_mode {
+	IS_ROTATION_0,
+	IS_ROTATION_90,
+	IS_ROTATION_180,
+	IS_ROTATION_270,
+	IS_ROTATION_MAX
+};
+
+#define V4L2_CID_IS_3DNR_1ST_FRAME_MODE		(V4L2_CID_FIMC_IS_BASE + 451)
+enum is_tdnr_1st_frame_mode {
+	IS_TDNR_1ST_FRAME_NOPROCESSING,
+	IS_TDNR_1ST_FRAME_2DNR,
+	IS_TDNR_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_OBJECT_POSITION_X	(V4L2_CID_FIMC_IS_BASE + 452)
+#define V4L2_CID_IS_CAMERA_OBJECT_POSITION_Y	(V4L2_CID_FIMC_IS_BASE + 453)
+#define V4L2_CID_IS_CAMERA_WINDOW_SIZE_X	(V4L2_CID_FIMC_IS_BASE + 454)
+#define V4L2_CID_IS_CAMERA_WINDOW_SIZE_Y	(V4L2_CID_FIMC_IS_BASE + 455)
+
+#define V4L2_CID_IS_CAMERA_EXIF_EXPTIME		(V4L2_CID_FIMC_IS_BASE + 456)
+#define V4L2_CID_IS_CAMERA_EXIF_FLASH		(V4L2_CID_FIMC_IS_BASE + 457)
+#define V4L2_CID_IS_CAMERA_EXIF_ISO		(V4L2_CID_FIMC_IS_BASE + 458)
+#define V4L2_CID_IS_CAMERA_EXIF_SHUTTERSPEED	(V4L2_CID_FIMC_IS_BASE + 459)
+#define V4L2_CID_IS_CAMERA_EXIF_BRIGHTNESS	(V4L2_CID_FIMC_IS_BASE + 460)
+
+#define V4L2_CID_IS_CAMERA_ISP_SEL_INPUT	(V4L2_CID_FIMC_IS_BASE + 461)
+enum is_isp_sel_input {
+	IS_ISP_INPUT_OTF,
+	IS_ISP_INPUT_DMA1,
+	IS_ISP_INPUT_DMA2,
+	IS_ISP_INPUT_DMA12,
+	IS_ISP_INPUT_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_ISP_SEL_OUTPUT	(V4L2_CID_FIMC_IS_BASE + 462)
+enum is_isp_sel_output {
+	IS_ISP_OUTPUT_OTF,
+	IS_ISP_OUTPUT_DMA1,
+	IS_ISP_OUTPUT_DMA2,
+	IS_ISP_OUTPUT_DMA12,
+	IS_ISP_OUTPUT_OTF_DMA1,
+	IS_ISP_OUTPUT_OTF_DMA2,
+	IS_ISP_OUTPUT_OTF_DMA12,
+	IS_ISP_OUTPUT_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_DRC_SEL_INPUT	(V4L2_CID_FIMC_IS_BASE + 463)
+enum is_drc_sel_input {
+	IS_DRC_INPUT_OTF,
+	IS_DRC_INPUT_DMA,
+	IS_DRC_INPUT_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_FD_SEL_INPUT		(V4L2_CID_FIMC_IS_BASE + 464)
+enum is_fd_sel_input {
+	IS_FD_INPUT_OTF,
+	IS_FD_INPUT_DMA,
+	IS_FD_INPUT_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_INIT_WIDTH		(V4L2_CID_FIMC_IS_BASE + 465)
+#define V4L2_CID_IS_CAMERA_INIT_HEIGHT		(V4L2_CID_FIMC_IS_BASE + 466)
+
+#define V4L2_CID_IS_CMD_ISP			(V4L2_CID_FIMC_IS_BASE + 467)
+enum is_isp_cmd_mode {
+	IS_ISP_COMMAND_STOP,
+	IS_ISP_COMMAND_START,
+	IS_ISP_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_DRC			(V4L2_CID_FIMC_IS_BASE + 468)
+enum is_drc_cmd_mode {
+	IS_DRC_COMMAND_STOP,
+	IS_DRC_COMMAND_START,
+	IS_DRC_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_FD			(V4L2_CID_FIMC_IS_BASE + 469)
+enum is_fd_cmd_mode {
+	IS_FD_COMMAND_STOP,
+	IS_FD_COMMAND_START,
+	IS_FD_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_ODC			(V4L2_CID_FIMC_IS_BASE + 470)
+enum is_odc_cmd_mode {
+	IS_ODC_COMMAND_STOP,
+	IS_ODC_COMMAND_START,
+	IS_ODC_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_DIS			(V4L2_CID_FIMC_IS_BASE + 471)
+enum is_dis_cmd_mode {
+	IS_DIS_COMMAND_STOP,
+	IS_DIS_COMMAND_START,
+	IS_DIS_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_TDNR			(V4L2_CID_FIMC_IS_BASE + 472)
+enum is_tdnr_cmd_mode {
+	IS_TDNR_COMMAND_STOP,
+	IS_TDNR_COMMAND_START,
+	IS_TDNR_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_SCALERC			(V4L2_CID_FIMC_IS_BASE + 473)
+enum is_scalerc_cmd_mode {
+	IS_SCALERC_COMMAND_STOP,
+	IS_SCALERC_COMMAND_START,
+	IS_SCALERC_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_SCALERP			(V4L2_CID_FIMC_IS_BASE + 474)
+enum is_scalerp_cmd_mode {
+	IS_SCALERP_COMMAND_STOP,
+	IS_SCALERP_COMMAND_START,
+	IS_SCALERP_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_GET_SENSOR_OFFSET_X		(V4L2_CID_FIMC_IS_BASE + 480)
+#define V4L2_CID_IS_GET_SENSOR_OFFSET_Y		(V4L2_CID_FIMC_IS_BASE + 481)
+#define V4L2_CID_IS_GET_SENSOR_WIDTH		(V4L2_CID_FIMC_IS_BASE + 482)
+#define V4L2_CID_IS_GET_SENSOR_HEIGHT		(V4L2_CID_FIMC_IS_BASE + 483)
+
+#define V4L2_CID_IS_GET_FRAME_VALID		(V4L2_CID_FIMC_IS_BASE + 484)
+#define V4L2_CID_IS_SET_FRAME_VALID		(V4L2_CID_FIMC_IS_BASE + 485)
+#define V4L2_CID_IS_GET_FRAME_BADMARK		(V4L2_CID_FIMC_IS_BASE + 486)
+#define V4L2_CID_IS_SET_FRAME_BADMARK		(V4L2_CID_FIMC_IS_BASE + 487)
+#define V4L2_CID_IS_GET_FRAME_CAPTURED		(V4L2_CID_FIMC_IS_BASE + 488)
+#define V4L2_CID_IS_SET_FRAME_CAPTURED		(V4L2_CID_FIMC_IS_BASE + 489)
+#define V4L2_CID_IS_SET_FRAME_NUMBER		(V4L2_CID_FIMC_IS_BASE + 490)
+#define V4L2_CID_IS_GET_FRAME_NUMBER		(V4L2_CID_FIMC_IS_BASE + 491)
+#define V4L2_CID_IS_CLEAR_FRAME_NUMBER		(V4L2_CID_FIMC_IS_BASE + 492)
+#define V4L2_CID_IS_GET_LOSTED_FRAME_NUMBER	(V4L2_CID_FIMC_IS_BASE + 493)
+#define V4L2_CID_IS_ISP_DMA_BUFFER_NUM		(V4L2_CID_FIMC_IS_BASE + 494)
+#define V4L2_CID_IS_ISP_DMA_BUFFER_ADDRESS	(V4L2_CID_FIMC_IS_BASE + 495)
+
+#define V4L2_CID_IS_ZOOM_STATE			(V4L2_CID_FIMC_IS_BASE + 660)
+#define V4L2_CID_IS_ZOOM_MAX_LEVEL		(V4L2_CID_FIMC_IS_BASE + 661)
+#define V4L2_CID_IS_ZOOM			(V4L2_CID_FIMC_IS_BASE + 662)
+#define V4L2_CID_IS_FW_DEBUG_REGION_ADDR	(V4L2_CID_FIMC_IS_BASE + 663)
+
+#define V4L2_CID_IS_TUNE_SEL_ENTRY		(V4L2_CID_FIMC_IS_TUNE_BASE)
+#define V4L2_CID_IS_TUNE_SENSOR_EXPOSURE	(V4L2_CID_FIMC_IS_TUNE_BASE + 1)
+#define V4L2_CID_IS_TUNE_SENSOR_ANALOG_GAIN	(V4L2_CID_FIMC_IS_TUNE_BASE + 2)
+#define V4L2_CID_IS_TUNE_SENSOR_FRAME_RATE	(V4L2_CID_FIMC_IS_TUNE_BASE + 3)
+#define V4L2_CID_IS_TUNE_SENSOR_ACTUATOR_POS	(V4L2_CID_FIMC_IS_TUNE_BASE + 4)
+
+enum v4l2_blur {
+	BLUR_LEVEL_0 = 0,
+	BLUR_LEVEL_1,
+	BLUR_LEVEL_2,
+	BLUR_LEVEL_3,
+	BLUR_LEVEL_MAX,
+};
+
+#if 1
+#define V4L2_CID_CAMERA_SCENE_MODE		(V4L2_CID_PRIVATE_BASE+70)
+enum v4l2_scene_mode {
+	SCENE_MODE_BASE,
+	SCENE_MODE_NONE,
+	SCENE_MODE_PORTRAIT,
+	SCENE_MODE_NIGHTSHOT,
+	SCENE_MODE_BACK_LIGHT,
+	SCENE_MODE_LANDSCAPE,
+	SCENE_MODE_SPORTS,
+	SCENE_MODE_PARTY_INDOOR,
+	SCENE_MODE_BEACH_SNOW,
+	SCENE_MODE_SUNSET,
+	SCENE_MODE_DUSK_DAWN,
+	SCENE_MODE_FALL_COLOR,
+	SCENE_MODE_FIREWORKS,
+	SCENE_MODE_TEXT,
+	SCENE_MODE_CANDLE_LIGHT,
+	SCENE_MODE_LOW_LIGHT,
+	SCENE_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_FLASH_MODE		(V4L2_CID_PRIVATE_BASE+71)
+enum v4l2_flash_mode {
+	FLASH_MODE_BASE,
+	FLASH_MODE_OFF,
+	FLASH_MODE_AUTO,
+	FLASH_MODE_ON,
+	FLASH_MODE_TORCH,
+	FLASH_MODE_RED_EYE,
+	FLASH_MODE_FILL_IN,
+	FLASH_MODE_SLOW_SYNC,
+	FLASH_MODE_RED_EYE_FIX,
+	FLASH_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_BRIGHTNESS		(V4L2_CID_PRIVATE_BASE+72)
+enum v4l2_ev_mode {
+	EV_MINUS_4	= -4,
+	EV_MINUS_3	= -3,
+	EV_MINUS_2	= -2,
+	EV_MINUS_1	= -1,
+	EV_DEFAULT	= 0,
+	EV_PLUS_1	= 1,
+	EV_PLUS_2	= 2,
+	EV_PLUS_3	= 3,
+	EV_PLUS_4	= 4,
+	EV_MAX,
+	EV_MAX_V4L2	= EV_MAX,
+};
+
+enum v4l2_exposure {
+	EXPOSURE_MINUS_6 = -6,
+	EXPOSURE_MINUS_5 = -5,
+	EXPOSURE_MINUS_4 = -4,
+	EXPOSURE_MINUS_3 = -3,
+	EXPOSURE_MINUS_2 = -2,
+	EXPOSURE_MINUS_1 = -1,
+	EXPOSURE_DEFAULT = 0,
+	EXPOSURE_PLUS_1	= 1,
+	EXPOSURE_PLUS_2	= 2,
+	EXPOSURE_PLUS_3	= 3,
+	EXPOSURE_PLUS_4	= 4,
+	EXPOSURE_PLUS_5	= 5,
+	EXPOSURE_PLUS_6	= 6,
+	EXPOSURE_MAX,
+};
+
+#define V4L2_CID_CAMERA_WHITE_BALANCE	(V4L2_CID_PRIVATE_BASE+73)
+enum v4l2_wb_mode {
+	WHITE_BALANCE_BASE = 0,
+	WHITE_BALANCE_AUTO,
+	WHITE_BALANCE_SUNNY,
+	WHITE_BALANCE_CLOUDY,
+	WHITE_BALANCE_TUNGSTEN,
+	WHITE_BALANCE_FLUORESCENT,
+	WHITE_BALANCE_FLUORESCENT_H,
+	WHITE_BALANCE_FLUORESCENT_L,
+	WHITE_BALANCE_CUSTOM,
+	WHITE_BALANCE_K,
+	WHITE_BALANCE_INCANDESCENT,
+	WHITE_BALANCE_PROHIBITION,
+	WHITE_BALANCE_HORIZON,
+	WHITE_BALANCE_LEDLIGHT,
+	WHITE_BALANCE_MAX,
+};
+
+#define V4L2_CID_CAMERA_EFFECT			(V4L2_CID_PRIVATE_BASE+74)
+enum v4l2_effect_mode {
+	IMAGE_EFFECT_BASE = 0,
+	IMAGE_EFFECT_NONE,
+	IMAGE_EFFECT_BNW,
+	IMAGE_EFFECT_SEPIA,
+	IMAGE_EFFECT_AQUA,
+	IMAGE_EFFECT_ANTIQUE,
+	IMAGE_EFFECT_NEGATIVE,
+	IMAGE_EFFECT_SHARPEN,
+	IMAGE_EFFECT_SKETCH,
+	IMAGE_EFFECT_WASHED,
+	IMAGE_EFFECT_VINTAGE_WARM,
+	IMAGE_EFFECT_VINTAGE_COLD,
+	IMAGE_EFFECT_SOLARIZE,
+	IMAGE_EFFECT_POSTERIZE,
+	IMAGE_EFFECT_POINT_BLUE,
+	IMAGE_EFFECT_POINT_RED_YELLOW,
+	IMAGE_EFFECT_POINT_COLOR_3,
+	IMAGE_EFFECT_POINT_GREEN,
+	IMAGE_EFFECT_POINT_RED,
+	IMAGE_EFFECT_POINT_YELLOW,
+	IMAGE_EFFECT_CARTOONIZE,
+	IMAGE_EFFECT_MAX,
+};
+
+#define V4L2_CID_CAMERA_ISO		(V4L2_CID_PRIVATE_BASE+75)
+enum v4l2_iso_mode {
+	ISO_AUTO = 0,
+	ISO_50,
+	ISO_100,
+	ISO_200,
+	ISO_400,
+	ISO_800,
+	ISO_1600,
+	ISO_3200,
+	ISO_SPORTS,
+	ISO_NIGHT,
+	ISO_MOVIE,
+	ISO_MAX,
+};
+
+#define V4L2_CID_CAMERA_METERING	(V4L2_CID_PRIVATE_BASE+76)
+enum v4l2_metering_mode {
+	METERING_BASE = 0,
+	METERING_MATRIX,
+	METERING_CENTER,
+	METERING_SPOT,
+	METERING_MAX,
+};
+
+#define V4L2_CID_CAMERA_CONTRAST	(V4L2_CID_PRIVATE_BASE+77)
+enum v4l2_contrast_mode {
+	CONTRAST_MINUS_2 = 0,
+	CONTRAST_MINUS_1,
+	CONTRAST_DEFAULT,
+	CONTRAST_PLUS_1,
+	CONTRAST_PLUS_2,
+	CONTRAST_MAX,
+};
+
+#define V4L2_CID_CAMERA_SATURATION		(V4L2_CID_PRIVATE_BASE+78)
+enum v4l2_saturation_mode {
+	SATURATION_MINUS_2 = 0,
+	SATURATION_MINUS_1,
+	SATURATION_DEFAULT,
+	SATURATION_PLUS_1,
+	SATURATION_PLUS_2,
+	SATURATION_MAX,
+};
+
+#define V4L2_CID_CAMERA_SHARPNESS		(V4L2_CID_PRIVATE_BASE+79)
+enum v4l2_sharpness_mode {
+	SHARPNESS_MINUS_2 = 0,
+	SHARPNESS_MINUS_1,
+	SHARPNESS_DEFAULT,
+	SHARPNESS_PLUS_1,
+	SHARPNESS_PLUS_2,
+	SHARPNESS_MAX,
+};
+
+#define V4L2_CID_CAMERA_WDR		(V4L2_CID_PRIVATE_BASE+80)
+enum v4l2_wdr_mode {
+	WDR_OFF,
+	WDR_ON,
+	WDR_MAX,
+};
+
+#define V4L2_CID_CAMERA_ANTI_SHAKE		(V4L2_CID_PRIVATE_BASE+81)
+enum v4l2_anti_shake_mode {
+	ANTI_SHAKE_OFF,
+	ANTI_SHAKE_STILL_ON,
+	ANTI_SHAKE_MOVIE_ON,
+	ANTI_SHAKE_MAX,
+};
+
+#define V4L2_CID_CAMERA_TOUCH_AF_START_STOP (V4L2_CID_PRIVATE_BASE+82)
+enum v4l2_touch_af {
+	TOUCH_AF_STOP = 0,
+	TOUCH_AF_START,
+	TOUCH_AF_MAX,
+};
+
+#define V4L2_CID_CAMERA_SMART_AUTO		(V4L2_CID_PRIVATE_BASE+83)
+enum v4l2_smart_auto {
+	SMART_AUTO_OFF = 0,
+	SMART_AUTO_ON,
+	SMART_AUTO_MAX,
+};
+
+#define V4L2_CID_CAMERA_VINTAGE_MODE		(V4L2_CID_PRIVATE_BASE+84)
+enum v4l2_vintage_mode {
+	VINTAGE_MODE_BASE,
+	VINTAGE_MODE_OFF,
+	VINTAGE_MODE_NORMAL,
+	VINTAGE_MODE_WARM,
+	VINTAGE_MODE_COOL,
+	VINTAGE_MODE_BNW,
+	VINTAGE_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_JPEG_QUALITY		(V4L2_CID_PRIVATE_BASE+85)
+#define V4L2_CID_CAMERA_CAPTURE_THUMB (V4L2_CID_PRIVATE_BASE + 86)
+#define V4L2_CID_CAMERA_YUV_SNAPSHOT	(V4L2_CID_PRIVATE_BASE + 87)
+#define V4L2_CID_CAMERA_LOW_LIGHT_MODE	(V4L2_CID_PRIVATE_BASE + 88)
+#define V4L2_CID_CAMERA_GPS_LATITUDE	(V4L2_CID_CAMERA_CLASS_BASE+30)
+/* (V4L2_CID_PRIVATE_BASE+87) */
+#define V4L2_CID_CAMERA_GPS_LONGITUDE	(V4L2_CID_CAMERA_CLASS_BASE + 31)
+/* (V4L2_CID_PRIVATE_BASE+88) */
+#define V4L2_CID_CAMERA_GPS_TIMESTAMP	(V4L2_CID_CAMERA_CLASS_BASE + 32)
+/* (V4L2_CID_PRIVATE_BASE+89)*/
+#define V4L2_CID_CAMERA_GPS_ALTITUDE	(V4L2_CID_CAMERA_CLASS_BASE + 33)
+#define V4L2_CID_CAMERA_EXIF_TIME_INFO	(V4L2_CID_CAMERA_CLASS_BASE + 34)
+#define V4L2_CID_CAMERA_GPS_PROCESSINGMETHOD	(V4L2_CID_CAMERA_CLASS_BASE+35)
+
+#define V4L2_CID_FOCUS_AUTO_MODE				(V4L2_CID_CAMERA_CLASS_BASE+36)
+enum v4l2_focus_mode_type {
+	V4L2_FOCUS_AUTO_NORMAL = 0,
+	V4L2_FOCUS_AUTO_MACRO,
+	V4L2_FOCUS_AUTO_CONTINUOUS,
+	V4L2_FOCUS_AUTO_FACE_DETECTION,
+	V4L2_FOCUS_AUTO_RECTANGLE,
+	V4L2_FOCUS_AUTO_MAX,
+};
+#define V4L2_CID_FOCUS_AUTO_RECTANGLE_LEFT		(V4L2_CID_CAMERA_CLASS_BASE+37)
+#define V4L2_CID_FOCUS_AUTO_RECTANGLE_TOP		(V4L2_CID_CAMERA_CLASS_BASE+38)
+#define V4L2_CID_FOCUS_AUTO_RECTANGLE_WIDTH		(V4L2_CID_CAMERA_CLASS_BASE+39)
+#define V4L2_CID_FOCUS_AUTO_RECTANGLE_HEIGHT		(V4L2_CID_CAMERA_CLASS_BASE+40)
+
+#define V4L2_CID_CAMERA_ZOOM	(V4L2_CID_PRIVATE_BASE+90)
+enum v4l2_zoom_level {
+	ZOOM_LEVEL_0 = 0,
+	ZOOM_LEVEL_1,
+	ZOOM_LEVEL_2,
+	ZOOM_LEVEL_3,
+	ZOOM_LEVEL_4,
+	ZOOM_LEVEL_5,
+	ZOOM_LEVEL_6,
+	ZOOM_LEVEL_7,
+	ZOOM_LEVEL_8,
+	ZOOM_LEVEL_9,
+	ZOOM_LEVEL_10,
+	ZOOM_LEVEL_11,
+	ZOOM_LEVEL_12,
+	ZOOM_LEVEL_MAX = 31,
+};
+
+#define V4L2_CID_CAMERA_FACE_DETECTION		(V4L2_CID_PRIVATE_BASE+91)
+enum v4l2_face_detection {
+	FACE_DETECTION_OFF = 0,
+	FACE_DETECTION_ON,
+	FACE_DETECTION_NOLINE,
+	FACE_DETECTION_ON_BEAUTY,
+	FACE_DETECTION_NORMAL,
+	FACE_DETECTION_SMILE_SHOT,
+	FACE_DETECTION_BLINK,
+	FACE_DETECTION_MAX,
+};
+
+#define V4L2_CID_CAMERA_SMART_AUTO_STATUS	(V4L2_CID_PRIVATE_BASE+92)
+enum v4l2_smart_auto_status {
+	SMART_AUTO_STATUS_AUTO = 0,
+	SMART_AUTO_STATUS_LANDSCAPE,
+	SMART_AUTO_STATUS_PORTRAIT,
+	SMART_AUTO_STATUS_MACRO,
+	SMART_AUTO_STATUS_NIGHT,
+	SMART_AUTO_STATUS_PORTRAIT_NIGHT,
+	SMART_AUTO_STATUS_BACKLIT,
+	SMART_AUTO_STATUS_PORTRAIT_BACKLIT,
+	SMART_AUTO_STATUS_ANTISHAKE,
+	SMART_AUTO_STATUS_PORTRAIT_ANTISHAKE,
+	SMART_AUTO_STATUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_SET_AUTO_FOCUS		(V4L2_CID_PRIVATE_BASE+93)
+enum v4l2_auto_focus {
+	AUTO_FOCUS_OFF = 0,
+	AUTO_FOCUS_ON,
+	AUTO_FOCUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_BEAUTY_SHOT		(V4L2_CID_PRIVATE_BASE+94)
+enum v4l2_beauty_shot {
+	BEAUTY_SHOT_OFF = 0,
+	BEAUTY_SHOT_ON,
+	BEAUTY_SHOT_MAX,
+};
+
+#define V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK	(V4L2_CID_PRIVATE_BASE+95)
+enum v4l2_ae_awb_lockunlock {
+	AE_UNLOCK_AWB_UNLOCK = 0,
+	AE_LOCK_AWB_UNLOCK,
+	AE_UNLOCK_AWB_LOCK,
+	AE_LOCK_AWB_LOCK,
+	AE_AWB_MAX
+};
+
+#define V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK	(V4L2_CID_PRIVATE_BASE+96)
+enum v4l2_face_lock {
+	FACE_LOCK_OFF = 0,
+	FACE_LOCK_ON,
+	FIRST_FACE_TRACKING,
+	FACE_LOCK_MAX,
+};
+
+#define V4L2_CID_CAMERA_OBJECT_POSITION_X	(V4L2_CID_PRIVATE_BASE+97)
+#define V4L2_CID_CAMERA_OBJECT_POSITION_Y	(V4L2_CID_PRIVATE_BASE+98)
+#define V4L2_CID_CAMERA_FOCUS_MODE		(V4L2_CID_PRIVATE_BASE+99)
+enum v4l2_focusmode {
+	FOCUS_MODE_AUTO = 0,
+	FOCUS_MODE_MACRO,
+	FOCUS_MODE_FACEDETECT,
+	FOCUS_MODE_AUTO_DEFAULT,
+	FOCUS_MODE_MACRO_DEFAULT,
+	FOCUS_MODE_FACEDETECT_DEFAULT,
+	FOCUS_MODE_INFINITY,
+	FOCUS_MODE_FIXED,
+	FOCUS_MODE_CONTINOUS,
+	FOCUS_MODE_CONTINOUS_PICTURE,
+	FOCUS_MODE_CONTINOUS_PICTURE_MACRO,
+	FOCUS_MODE_CONTINOUS_VIDEO,
+	FOCUS_MODE_TOUCH,
+	FOCUS_MODE_MANUAL,
+	FOCUS_MODE_MULTI,
+	FOCUS_MODE_OBJECT_TRACKING,
+	FOCUS_MODE_MAX,
+	FOCUS_MODE_DEFAULT = (1 << 8),
+};
+
+#define V4L2_CID_CAMERA_OBJ_TRACKING_STATUS	(V4L2_CID_PRIVATE_BASE+100)
+enum v4l2_obj_tracking_status {
+	OBJECT_TRACKING_STATUS_BASE = 0,
+	OBJECT_TRACKING_STATUS_SUCCESS = 1,
+	OBJECT_TRACKING_STATUS_MISSING = 2,
+	OBJECT_TRACKING_STATUS_FAIL = 3,
+	OBJECT_TRACKING_STATUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP	(V4L2_CID_PRIVATE_BASE+101)
+enum v4l2_ot_start_stop {
+	OT_STOP = 0,
+	OT_START,
+	OT_MAX,
+};
+
+#define V4L2_CID_CAMERA_CAF_START_STOP	(V4L2_CID_PRIVATE_BASE+102)
+enum v4l2_caf_start_stop {
+	CAF_STOP = 0,
+	CAF_START,
+	CAF_MAX,
+};
+
+#define V4L2_CID_CAMERA_AUTO_FOCUS_RESULT	(V4L2_CID_PRIVATE_BASE+103)
+enum v4l2_af_status {
+	CAMERA_AF_STATUS_IN_PROGRESS = 0,
+	CAMERA_AF_STATUS_SUCCESS,
+	CAMERA_AF_STATUS_FAIL,
+	CAMERA_AF_STATUS_1ST_SUCCESS,
+	CAMERA_AF_STATUS_RESTART,
+	CAMERA_AF_STATUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_FRAME_RATE		(V4L2_CID_PRIVATE_BASE+104)
+enum v4l2_frame_rate {
+	FRAME_RATE_AUTO = 0,
+	FRAME_RATE_7 = 7,
+	FRAME_RATE_15 = 15,
+	FRAME_RATE_20 = 20,
+	FRAME_RATE_25 = 25,
+	FRAME_RATE_30 = 30,
+	FRAME_RATE_60 = 60,
+	FRAME_RATE_120 = 120,
+	FRAME_RATE_MAX
+};
+
+#define V4L2_CID_CAMERA_ANTI_BANDING		(V4L2_CID_PRIVATE_BASE+105)
+enum v4l2_anti_banding {
+	ANTI_BANDING_AUTO = 0,
+	ANTI_BANDING_50HZ = 1,
+	ANTI_BANDING_60HZ = 2,
+	ANTI_BANDING_50_60Hz = 3,
+	ANTI_BANDING_OFF = 4,
+};
+
+#define V4L2_CID_CAMERA_SET_GAMMA	(V4L2_CID_PRIVATE_BASE+106)
+enum v4l2_gamma_mode {
+	GAMMA_OFF = 0,
+	GAMMA_ON = 1,
+	GAMMA_MAX,
+};
+
+#define V4L2_CID_CAMERA_SET_SLOW_AE	(V4L2_CID_PRIVATE_BASE+107)
+enum v4l2_slow_ae_mode {
+	SLOW_AE_OFF,
+	SLOW_AE_ON,
+	SLOW_AE_MAX,
+};
+
+#define V4L2_CID_CAMERA_BATCH_REFLECTION	(V4L2_CID_PRIVATE_BASE+108)
+#define V4L2_CID_CAMERA_EXIF_ORIENTATION	(V4L2_CID_PRIVATE_BASE+109)
+#define V4L2_CID_CAMERA_GET_LUX			(V4L2_CID_PRIVATE_BASE+110)
+
+/* s1_camera [ Defense process by ESD input ] */
+#define V4L2_CID_CAMERA_RESET			(V4L2_CID_PRIVATE_BASE+111)
+#define V4L2_CID_CAMERA_CHECK_DATALINE		(V4L2_CID_PRIVATE_BASE+112)
+#define V4L2_CID_CAMERA_CHECK_DATALINE_STOP	(V4L2_CID_PRIVATE_BASE+113)
+
+#endif
+
+/* Modify NTTS1 */
+#if defined(CONFIG_ARIES_NTT)
+#define V4L2_CID_CAMERA_AE_AWB_DISABLE_LOCK	(V4L2_CID_PRIVATE_BASE+114)
+#endif
+#define V4L2_CID_CAMERA_THUMBNAIL_NULL		(V4L2_CID_PRIVATE_BASE+115)
+#define V4L2_CID_CAMERA_SENSOR_MODE		(V4L2_CID_PRIVATE_BASE+116)
+enum v4l2_sensor_mode {
+	SENSOR_CAMERA,
+	SENSOR_MOVIE,
+};
+
+enum stream_mode_t {
+	STREAM_MODE_CAM_OFF,
+	STREAM_MODE_CAM_ON,
+	STREAM_MODE_MOVIE_OFF,
+	STREAM_MODE_MOVIE_ON,
+	STREAM_MODE_WAIT_OFF
+};
+
+#define V4L2_CID_CAMERA_EXIF_EXPTIME		(V4L2_CID_PRIVATE_BASE+117)
+#define V4L2_CID_CAMERA_EXIF_FLASH	(V4L2_CID_PRIVATE_BASE+118)
+#define V4L2_CID_CAMERA_EXIF_ISO		(V4L2_CID_PRIVATE_BASE+119)
+#define V4L2_CID_CAMERA_EXIF_TV		(V4L2_CID_PRIVATE_BASE+120)
+#define V4L2_CID_CAMERA_EXIF_BV		(V4L2_CID_PRIVATE_BASE+121)
+#define V4L2_CID_CAMERA_EXIF_EBV		(V4L2_CID_PRIVATE_BASE+122)
+#define V4L2_CID_CAMERA_CHECK_ESD		(V4L2_CID_PRIVATE_BASE+123)
+#define V4L2_CID_CAMERA_APP_CHECK		(V4L2_CID_PRIVATE_BASE+124)
+#define V4L2_CID_CAMERA_CHECK_SENSOR_STATUS	(V4L2_CID_PRIVATE_BASE+150)
+#define V4L2_CID_CAMERA_DEFAULT_FOCUS_POSITION  (V4L2_CID_PRIVATE_BASE+151)
+#define V4L2_CID_CAMERA_BUSFREQ_LOCK		(V4L2_CID_PRIVATE_BASE+125)
+#define V4L2_CID_CAMERA_BUSFREQ_UNLOCK		(V4L2_CID_PRIVATE_BASE+126)
+
+/* If you would like to control AE and AWB lock with signle command,
+ * use V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK above.
+ */
+#define V4L2_CID_CAMERA_AE_LOCK_UNLOCK	(V4L2_CID_PRIVATE_BASE + 127)
+enum v4l2_ae_lockunlock {
+	AE_UNLOCK = 0,
+	AE_LOCK,
+	AE_LOCK_MAX
+};
+
+#define V4L2_CID_CAMERA_AWB_LOCK_UNLOCK	(V4L2_CID_PRIVATE_BASE + 128)
+enum v4l2_awb_lockunlock {
+	AWB_UNLOCK = 0,
+	AWB_LOCK,
+	AWB_LOCK_MAX
+};
+
+#define V4L2_CID_CAMERA_SENSOR_OUTPUT_SIZE  (V4L2_CID_PRIVATE_BASE + 129)
+#define V4L2_CID_EMBEDDEDDATA_ENABLE	(V4L2_CID_PRIVATE_BASE + 130)
+#define V4L2_CID_CAMERA_JPEG_RESOLUTION	 (V4L2_CID_PRIVATE_BASE + 131)
+#define V4L2_CID_CAMERA_FACE_ZOOM  (V4L2_CID_PRIVATE_BASE + 132)
+enum v4l2_face_zoom {
+	FACE_ZOOM_STOP = 0,
+	FACE_ZOOM_START
+};
+
+/* control for post processing block in ISP */
+#define V4L2_CID_CAMERA_SET_ODC				(V4L2_CID_PRIVATE_BASE+127)
+enum set_odc_mode {
+	CAMERA_ODC_ON,
+	CAMERA_ODC_OFF
+};
+
+#define V4L2_CID_CAMERA_SET_DIS				(V4L2_CID_PRIVATE_BASE+128)
+enum set_dis_mode {
+	CAMERA_DIS_ON,
+	CAMERA_DIS_OFF
+};
+
+#define V4L2_CID_CAMERA_SET_3DNR				(V4L2_CID_PRIVATE_BASE+129)
+enum set_3dnr_mode {
+	CAMERA_3DNR_ON,
+	CAMERA_3DNR_OFF
+};
+
+#define V4L2_CID_CAMERA_BRACKET     (V4L2_CID_PRIVATE_BASE+134)
+enum v4l2_face_bracket_mode {
+	BRACKET_MODE_OFF = 0,
+	BRACKET_MODE_AEB,
+	BRACKET_MODE_WBB,
+	BRACKET_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_BRACKET_AEB     (V4L2_CID_PRIVATE_BASE+135)
+enum v4l2_face_bracket_aeb_value {
+	BRACKET_AEB_VALUE1 = 1,
+	BRACKET_AEB_VALUE2,
+	BRACKET_AEB_VALUE3,
+	BRACKET_AEB_VALUE4,
+	BRACKET_AEB_VALUE5,
+	BRACKET_AEB_VALUE6,
+};
+
+#define V4L2_CID_CAMERA_BRACKET_WBB     (V4L2_CID_PRIVATE_BASE+136)
+enum v4l2_face_bracket_wbb_value {
+	BRACKET_WBB_OFF = 0,
+	BRACKET_WBB_VALUE1 = 1,
+	BRACKET_WBB_VALUE2,
+	BRACKET_WBB_VALUE3,
+	BRACKET_WBB_VALUE4,
+	BRACKET_WBB_VALUE5,
+	BRACKET_WBB_VALUE6,
+};
+
+#define V4L2_CID_CAMERA_DRIVE_DIAL    (V4L2_CID_PRIVATE_BASE+137)
+enum v4l2_drive_dial {
+	DRIVEDIAL_SINGLE = 1,
+	DRIVEDIAL_BKT = 2,
+	DRIVEDIAL_CONTI_3 = 3,
+	DRIVEDIAL_CONTI_5 = 5,
+	DRIVEDIAL_CONTI_10 = 10,
+};
+
+enum v4l2_running_cap_mode {
+	RUNNING_MODE_SINGLE = 0,
+	RUNNING_MODE_CONTINUOUS,
+	RUNNING_MODE_BEST,
+	RUNNING_MODE_LOWLIGHT,
+	RUNNING_MODE_AE_BRACKET,
+	RUNNING_MODE_WB_BRACKET,
+	RUNNING_MODE_HDR,
+	RUNNING_MODE_BLINK,
+	RUNNING_MODE_RAW,
+	RUNNING_MODE_BURST,
+	RUNNING_MODE_MAX
+};
+
+enum v4l2_continuous_mode {
+	CONTINUOUS_MODE_OFF = 0,
+	CONTINUOUS_MODE_ON,
+	CONTINUOUS_MODE_MAX,
+};
+
+enum v4l2_continuous_fps {
+	MULTI_CAPTURE_FPS_1 = 0,
+	MULTI_CAPTURE_FPS_10,
+	MULTI_CAPTURE_FPS_5,
+	MULTI_CAPTURE_FPS_3,
+	MULTI_CAPTURE_FPS_MAX,
+};
+
+enum v4l2_burst_mode {
+	BURST_MODE_OFF = 0,
+	BURST_MODE_ON,
+};
+
+enum v4l2_best_mode {
+	BEST_MODE_OFF = 0,
+	BEST_MODE_ON,
+	BEST_MODE_MAX,};
+
+enum v4l2_lowlight_mode {
+	LOWLIGHT_MODE_OFF = 0,
+	LOWLIGHT_MODE_ON,
+	LOWLIGHT_MODE_MAX,};
+
+#define V4L2_CID_CAMERA_FD_EYE_BLINK_RESULT    (V4L2_CID_PRIVATE_BASE+138)
+
+#define V4L2_CID_CAMERA_OPTICAL_ZOOM_STEP      (V4L2_CID_PRIVATE_BASE + 139)
+#define V4L2_CID_CAMERA_OPTICAL_ZOOM_CTRL      (V4L2_CID_PRIVATE_BASE + 140)
+enum v4l2_optical_zoom_ctrl {
+	V4L2_OPTICAL_ZOOM_STOP,
+	V4L2_OPTICAL_ZOOM_TELE_START,
+	V4L2_OPTICAL_ZOOM_WIDE_START,
+	V4L2_OPTICAL_ZOOM_SLOW_TELE_START,
+	V4L2_OPTICAL_ZOOM_SLOW_WIDE_START,
+};
+
+#define V4L2_CID_CAMERA_LDC    (V4L2_CID_PRIVATE_BASE+142)
+enum set_LDC_mode {
+	LDC_SET_OFF = 0,
+	LDC_SET_ON = 1,
+};
+
+#define V4L2_CID_CAMERA_LSC    (V4L2_CID_PRIVATE_BASE+143)
+enum set_LSC_mode {
+	LSC_SET_OFF = 0,
+	LSC_SET_ON = 1,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_OIS    (V4L2_CID_PRIVATE_BASE+147)
+enum set_Factory_OIS {
+	FACTORY_OIS_RETURN_TO_CENTER = 0,
+	FACTORY_OIS_RUN = 1,
+	FACTORY_OIS_START = 2,
+	FACTORY_OIS_STOP = 3,
+	FACTORY_OIS_MODE_ON = 4,
+	FACTORY_OIS_MODE_OFF = 5,
+	FACTORY_OIS_LOG = 6,
+	FACTORY_OIS_ON = 7,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_ZOOM_RANGE_CHECK_DATA_MIN \
+	(V4L2_CID_PRIVATE_BASE+148)
+#define V4L2_CID_CAMERA_FACTORY_ZOOM_RANGE_CHECK_DATA_MAX \
+	(V4L2_CID_PRIVATE_BASE+149)
+#define V4L2_CID_CAMERA_FACTORY_ZOOM_SLOPE_CHECK_DATA_MIN \
+	(V4L2_CID_PRIVATE_BASE+152)
+#define V4L2_CID_CAMERA_FACTORY_ZOOM_SLOPE_CHECK_DATA_MAX \
+	(V4L2_CID_PRIVATE_BASE+153)
+#define V4L2_CID_CAMERA_FACTORY_ZOOM_STEP  (V4L2_CID_PRIVATE_BASE+154)
+#define V4L2_CID_CAMERA_FACTORY_ZOOM    (V4L2_CID_PRIVATE_BASE+155)
+enum set_Factory_Zoom {
+	FACTORY_ZOOM_MOVE_STEP = 0,
+	FACTORY_ZOOM_RANGE_CHECK_START = 1,
+	FACTORY_ZOOM_RANGE_CHECK_STOP = 2,
+	FACTORY_ZOOM_SLOPE_CHECK_START = 3,
+	FACTORY_ZOOM_SLOPE_CHECK_STOP = 4,
+	FACTORY_ZOOM_SET_RANGE_CHECK_DATA = 5,
+	FACTORY_ZOOM_SET_SLOPE_CHECK_DATA = 6,
+	FACTORY_ZOOM_STEP_TELE = 7,
+	FACTORY_ZOOM_STEP_WIDE = 8,
+	FACTORY_ZOOM_MOVE_END_CHECK = 9,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_PUNT_RANGE_DATA_MIN \
+	(V4L2_CID_PRIVATE_BASE+156)
+#define V4L2_CID_CAMERA_FACTORY_PUNT_RANGE_DATA_MAX \
+	(V4L2_CID_PRIVATE_BASE+157)
+#define V4L2_CID_CAMERA_FACTORY_PUNT_RANGE_DATA_NUM \
+	(V4L2_CID_PRIVATE_BASE+158)
+#define V4L2_CID_CAMERA_FACTORY_PUNT    (V4L2_CID_PRIVATE_BASE+159)
+enum set_Factory_Punt {
+	FACTORY_PUNT_RANGE_START = 0,
+	FACTORY_PUNT_RANGE_STOP = 1,
+	FACTORY_PUNT_SHORT_SCAN_DATA = 2,
+	FACTORY_PUNT_SHORT_SCAN_START = 3,
+	FACTORY_PUNT_SHORT_SCAN_STOP = 4,
+	FACTORY_PUNT_LONG_SCAN_DATA = 5,
+	FACTORY_PUNT_LONG_SCAN_START = 6,
+	FACTORY_PUNT_LONG_SCAN_STOP = 7,
+	FACTORY_PUNT_LOG = 8,
+	FACTORY_PUNT_SET_RANGE_DATA = 9,
+	FACTORY_PUNT_EEP_WRITE = 10,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_FAIL_STOP    (V4L2_CID_PRIVATE_BASE+160)
+enum set_Factory_Fail_Stop {
+	FACTORY_FAIL_STOP_ON = 0,
+	FACTORY_FAIL_STOP_OFF = 1,
+	FACTORY_FAIL_STOP_RUN = 2,
+	FACTORY_FAIL_STOP_STOP = 3,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_NODEFOCUS    (V4L2_CID_PRIVATE_BASE+161)
+enum set_Factory_NoDeFocus {
+	FACTORY_NODEFOCUSYES_ON = 0,
+	FACTORY_NODEFOCUSYES_OFF = 1,
+	FACTORY_NODEFOCUSYES_RUN = 2,
+	FACTORY_NODEFOCUSYES_STOP = 3,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_INTERPOLATION    (V4L2_CID_PRIVATE_BASE+162)
+enum set_Factory_Interpolation {
+	FACTORY_INTERPOLATION_USE = 0,
+	FACTORY_INTERPOLATION_RELEASE = 1,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_DOWN_RESULT (V4L2_CID_PRIVATE_BASE+163)
+#define V4L2_CID_CAMERA_FACTORY_END_RESULT (V4L2_CID_PRIVATE_BASE+164)
+#define V4L2_CID_CAMERA_FACTORY_COMMON    (V4L2_CID_PRIVATE_BASE+165)
+enum set_Factory_Common {
+	FACTORY_FIRMWARE_DOWNLOAD = 0,
+	FACTORY_DOWNLOAD_CHECK = 1,
+	FACTORY_END_CHECK = 2,
+	FACTORY_COMMON_SET_FOCUS_ZONE_MACRO = 3,
+	FACTORY_FPS30_ON = 4,
+	FACTORY_FPS30_OFF = 5,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_VIB    (V4L2_CID_PRIVATE_BASE+166)
+enum set_Factory_Vib {
+	FACTORY_VIB_START = 0,
+	FACTORY_VIB_STOP = 1,
+	FACTORY_VIB_LOG = 2,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_GYRO    (V4L2_CID_PRIVATE_BASE+167)
+enum set_Factory_Gyro {
+	FACTORY_GYRO_START = 0,
+	FACTORY_GYRO_STOP = 1,
+	FACTORY_GYRO_LOG = 2,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_BACKLASH    (V4L2_CID_PRIVATE_BASE+168)
+enum set_Factory_Backlash {
+	FACTORY_BACKLASH_INPUT = 0,
+	FACTORY_BACKLASH_MAX_THR = 1,
+	FACTORY_BACKLASH_WIDE_RUN = 2,
+	FACTORY_BACKLASH_LOG = 3,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_AF_STEP_SET    (V4L2_CID_PRIVATE_BASE+169)
+#define V4L2_CID_CAMERA_FACTORY_AF_POSITION    (V4L2_CID_PRIVATE_BASE+170)
+#define V4L2_CID_CAMERA_FACTORY_AF_INT_RESULT (V4L2_CID_PRIVATE_BASE+171)
+#define V4L2_CID_CAMERA_FACTORY_AF    (V4L2_CID_PRIVATE_BASE+172)
+enum set_Factory_AF {
+	FACTORY_AF_LOCK_ON_SET = 0,
+	FACTORY_AF_LOCK_OFF_SET = 1,
+	FACTORY_AF_MOVE = 2,
+	FACTORY_AF_STEP_LOG = 3,
+	FACTORY_AF_LOCK_START = 4,
+	FACTORY_AF_LOCK_STOP = 5,
+	FACTORY_AF_FOCUS_LOG = 6,
+	FACTORY_AF_INT_SET = 7,
+	FACTORY_AF_SCAN_LIMIT_START = 8,
+	FACTORY_AF_SCAN_LIMIT_STOP = 10,
+	FACTORY_AF_SCAN_RANGE_START = 11,
+	FACTORY_AF_SCAN_RANGE_STOP = 12,
+	FACTORY_AF_STEP_SAVE = 13,
+	FACTORY_AF_LED_END_CHECK = 14,
+	FACTORY_AF_LED_LOG = 15,
+	FACTORY_AF_MOVE_END_CHECK = 16,
+	FACTORY_AF_SCAN_END_CHECK = 17,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_DEFOCUS_WIDE    (V4L2_CID_PRIVATE_BASE+173)
+#define V4L2_CID_CAMERA_FACTORY_DEFOCUS_TELE (V4L2_CID_PRIVATE_BASE+174)
+#define V4L2_CID_CAMERA_FACTORY_DEFOCUS    (V4L2_CID_PRIVATE_BASE+175)
+enum set_Factory_DeFocus {
+	FACTORY_DEFOCUS_RUN = 0,
+	FACTORY_DEFOCUS_STOP = 1,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_RESOL_CAP    (V4L2_CID_PRIVATE_BASE+176)
+enum set_Factory_Resol_Cap {
+	FACTORY_CAP_COMP_ON = 0,
+	FACTORY_CAP_COMP_OFF = 1,
+	FACTORY_CAP_BARREL_ON = 2,
+	FACTORY_CAP_BARREL_OFF = 3,
+	FACTORY_CAP_BARREL_START = 4,
+	FACTORY_CAP_BARREL_STOP = 5,
+	FACTORY_CAP_COMP_START = 6,
+	FACTORY_CAP_COMP_STOP = 7,
+};
+
+#define V4L2_CID_CAMERA_SET_G_VALUE          (V4L2_CID_PRIVATE_BASE + 177)
+#define V4L2_CID_CAMERA_SET_B_VALUE          (V4L2_CID_PRIVATE_BASE + 178)
+#define V4L2_CID_CAMERA_SET_A_VALUE          (V4L2_CID_PRIVATE_BASE + 179)
+#define V4L2_CID_CAMERA_SET_M_VALUE          (V4L2_CID_PRIVATE_BASE + 180)
+#define V4L2_CID_CAMERA_SET_GBAM          (V4L2_CID_PRIVATE_BASE + 181)
+#define V4L2_CID_CAMERA_SET_K_VALUE          (V4L2_CID_PRIVATE_BASE + 182)
+#define V4L2_CID_CAMERA_SET_FLASH_EVC_STEP   (V4L2_CID_PRIVATE_BASE + 183)
+
+#define V4L2_CID_CAMERA_APERTURE_CMD (V4L2_CID_PRIVATE_BASE+184)
+enum set_Factory_Aperture_Cmd {
+	FACTORY_CMD_PREVIEW = 0,
+	FACTORY_CMD_CAPTURE = 1,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_OIS_RANGE_DATA_X_MIN (V4L2_CID_PRIVATE_BASE+185)
+#define V4L2_CID_CAMERA_FACTORY_OIS_RANGE_DATA_X_MAX (V4L2_CID_PRIVATE_BASE+186)
+#define V4L2_CID_CAMERA_FACTORY_OIS_RANGE_DATA_Y_MIN (V4L2_CID_PRIVATE_BASE+187)
+#define V4L2_CID_CAMERA_FACTORY_OIS_RANGE_DATA_Y_MAX (V4L2_CID_PRIVATE_BASE+188)
+#define V4L2_CID_CAMERA_FACTORY_OIS_RANGE_DATA_X_GAIN \
+	(V4L2_CID_PRIVATE_BASE+189)
+#define V4L2_CID_CAMERA_FACTORY_OIS_RANGE_DATA_PEAK_X \
+	(V4L2_CID_PRIVATE_BASE+190)
+#define V4L2_CID_CAMERA_FACTORY_OIS_RANGE_DATA_PEAK_Y \
+	(V4L2_CID_PRIVATE_BASE+191)
+
+#define V4L2_CID_CAMERA_FACTORY_VIB_RANGE_DATA_X_MIN (V4L2_CID_PRIVATE_BASE+192)
+#define V4L2_CID_CAMERA_FACTORY_VIB_RANGE_DATA_X_MAX (V4L2_CID_PRIVATE_BASE+193)
+#define V4L2_CID_CAMERA_FACTORY_VIB_RANGE_DATA_Y_MIN (V4L2_CID_PRIVATE_BASE+194)
+#define V4L2_CID_CAMERA_FACTORY_VIB_RANGE_DATA_Y_MAX (V4L2_CID_PRIVATE_BASE+195)
+#define V4L2_CID_CAMERA_FACTORY_VIB_RANGE_DATA_PEAK_X \
+	(V4L2_CID_PRIVATE_BASE+196)
+#define V4L2_CID_CAMERA_FACTORY_VIB_RANGE_DATA_PEAK_Y \
+	(V4L2_CID_PRIVATE_BASE+197)
+
+#define V4L2_CID_CAMERA_FACTORY_GYRO_RANGE_DATA_X_MIN \
+	(V4L2_CID_PRIVATE_BASE+198)
+#define V4L2_CID_CAMERA_FACTORY_GYRO_RANGE_DATA_X_MAX \
+	(V4L2_CID_PRIVATE_BASE+199)
+#define V4L2_CID_CAMERA_FACTORY_GYRO_RANGE_DATA_Y_MIN \
+	(V4L2_CID_PRIVATE_BASE+200)
+#define V4L2_CID_CAMERA_FACTORY_GYRO_RANGE_DATA_Y_MAX \
+	(V4L2_CID_PRIVATE_BASE+202)
+
+#define V4L2_CID_CAMERA_FACTORY_TEST_NUMBER (V4L2_CID_PRIVATE_BASE+203)
+
+#define V4L2_CID_CAMERA_FACTORY_BACKLASH_COUNT (V4L2_CID_PRIVATE_BASE+204)
+#define V4L2_CID_CAMERA_FACTORY_BACKLASH_MAXTHRESHOLD \
+	(V4L2_CID_PRIVATE_BASE+205)
+
+#define V4L2_CID_CAMERA_FACTORY_CAPTURE_CTRL (V4L2_CID_PRIVATE_BASE + 206)
+enum set_Factory_Cap_Ctrl {
+	FACTORY_STILL_CAP_NORMAL = 0,
+	FACTORY_STILL_CAP_DUALCAP = 1,
+	FACTORY_DUAL_CAP_ON = 2,
+	FACTORY_DUAL_CAP_OFF = 3,
+};
+
+#define V4L2_CID_CAMERA_DUAL_POSTVIEW          (V4L2_CID_PRIVATE_BASE + 207)
+#define V4L2_CID_CAMERA_DUAL_CAPTURE           (V4L2_CID_PRIVATE_BASE + 208)
+#define V4L2_CID_CAMERA_SET_DUAL_CAPTURE       (V4L2_CID_PRIVATE_BASE + 209)
+#define V4L2_CID_CAMERA_DUAL_CAPTURE_MODE	(V4L2_CID_PRIVATE_BASE + 210)
+
+#define V4L2_CID_CAMERA_FOCUS_AREA_MODE        (V4L2_CID_PRIVATE_BASE + 211)
+enum set_fouce_area {
+	V4L2_FOCUS_AREA_CENTER = 0,
+	V4L2_FOCUS_AREA_MULTI = 1,
+	V4L2_FOCUS_AREA_SMART_TOUCH = 2,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_AF_SCAN_LIMIT_MIN    (V4L2_CID_PRIVATE_BASE+212)
+#define V4L2_CID_CAMERA_FACTORY_AF_SCAN_LIMIT_MAX    (V4L2_CID_PRIVATE_BASE+213)
+#define V4L2_CID_CAMERA_FACTORY_AF_SCAN_RANGE_MIN    (V4L2_CID_PRIVATE_BASE+214)
+#define V4L2_CID_CAMERA_FACTORY_AF_SCAN_RANGE_MAX    (V4L2_CID_PRIVATE_BASE+215)
+#define V4L2_CID_CAM_APERTURE_PREVIEW	(V4L2_CID_PRIVATE_BASE+216)
+#define V4L2_CID_CAM_APERTURE_CAPTURE	(V4L2_CID_PRIVATE_BASE+217)
+
+#define V4L2_CID_CAMERA_FACTORY_AF_ZONE	(V4L2_CID_PRIVATE_BASE+218)
+enum set_Factory_AFZone_Cmd {
+	FACTORY_AFZONE_NORMAL = 0,
+	FACTORY_AFZONE_MACRO,
+	FACTORY_AFZONE_AUTO,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_OIS_SHIFT	(V4L2_CID_PRIVATE_BASE+219)
+#define V4L2_CID_CAMERA_FACTORY_FLICKER	(V4L2_CID_PRIVATE_BASE+220)
+enum set_Factory_Flicker_Cmd {
+	FACTORY_FLICKER_AUTO = 0,
+	FACTORY_FLICKER_50HZ,
+	FACTORY_FLICKER_60HZ,
+	FACTORY_FLICKER_50_60,
+	FACTORY_FLICKER_OFF,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_AF_LENS	(V4L2_CID_PRIVATE_BASE+221)
+enum set_Factory_AFLENS_Cmd {
+	FACTORY_AFLENS_OPEN = 0,
+	FACTORY_AFLENS_CLOSE,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_LV_TARGET	(V4L2_CID_PRIVATE_BASE+222)
+
+#define V4L2_CID_CAMERA_FACTORY_ADJ_IRIS_RANGE_MIN (V4L2_CID_PRIVATE_BASE+223)
+#define V4L2_CID_CAMERA_FACTORY_ADJ_IRIS_RANGE_MAX (V4L2_CID_PRIVATE_BASE+224)
+#define V4L2_CID_CAMERA_FACTORY_ADJ_IRIS	(V4L2_CID_PRIVATE_BASE+225)
+enum set_Factory_Adj_IRIS_Cmd {
+	FACTORY_ADJ_IRIS_RUN = 0,
+	FACTORY_ADJ_IRIS_STOP,
+	FACTORY_ADJ_IRIS_END_CHECK,
+	FACTORY_ADJ_IRIS_LOG,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_ADJ_GAIN_LIVEVIEW_RANGE_MIN \
+	(V4L2_CID_PRIVATE_BASE+226)
+#define V4L2_CID_CAMERA_FACTORY_ADJ_GAIN_LIVEVIEW_RANGE_MAX \
+	(V4L2_CID_PRIVATE_BASE+227)
+#define V4L2_CID_CAMERA_FACTORY_ADJ_GAIN_LIVEVIEW (V4L2_CID_PRIVATE_BASE+228)
+enum set_Factory_Adj_Gain_LiveView_Cmd {
+	FACTORY_ADJ_GAIN_LIVEVIEW_RUN = 0,
+	FACTORY_ADJ_GAIN_LIVEVIEW_STOP,
+	FACTORY_ADJ_GAIN_LIVEVIEW_END_CHECK,
+	FACTORY_ADJ_GAIN_LIVEVIEW_LOG,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_SH_CLOSE_IRIS_NUM (V4L2_CID_PRIVATE_BASE+229)
+#define V4L2_CID_CAMERA_FACTORY_SH_CLOSE_SET_IRIS (V4L2_CID_PRIVATE_BASE+230)
+#define V4L2_CID_CAMERA_FACTORY_SH_CLOSE_ISO	(V4L2_CID_PRIVATE_BASE+231)
+#define V4L2_CID_CAMERA_FACTORY_SH_CLOSE_RANGE (V4L2_CID_PRIVATE_BASE+232)
+#define V4L2_CID_CAMERA_FACTORY_SH_CLOSE_SPEEDTIME_X (V4L2_CID_PRIVATE_BASE+233)
+#define V4L2_CID_CAMERA_FACTORY_SH_CLOSE_SPEEDTIME_Y (V4L2_CID_PRIVATE_BASE+234)
+#define V4L2_CID_CAMERA_FACTORY_SH_CLOSE	(V4L2_CID_PRIVATE_BASE+235)
+enum set_Factory_SH_Close_Cmd {
+	FACTORY_SH_CLOSE_RUN = 0,
+	FACTORY_SH_CLOSE_STOP,
+	FACTORY_SH_CLOSE_END_CHECK,
+	FACTORY_SH_CLOSE_LOG,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_CAPTURE_GAIN_RANGE_MIN	\
+	(V4L2_CID_PRIVATE_BASE+236)
+#define V4L2_CID_CAMERA_FACTORY_CAPTURE_GAIN_RANGE_MAX	\
+	(V4L2_CID_PRIVATE_BASE+237)
+#define V4L2_CID_CAMERA_FACTORY_CAPTURE_GAIN	(V4L2_CID_PRIVATE_BASE+238)
+enum set_Factory_Capture_Gain_Cmd {
+	FACTORY_CAPTURE_GAIN_RUN = 0,
+	FACTORY_CAPTURE_GAIN_STOP,
+	FACTORY_CAPTURE_GAIN_END_CHECK,
+	FACTORY_CAPTURE_GAIN_LOG,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_LSC_TABLE	(V4L2_CID_PRIVATE_BASE+239)
+#define V4L2_CID_CAMERA_FACTORY_LSC_REFERENCE (V4L2_CID_PRIVATE_BASE+240)
+
+#define V4L2_CID_CAMERA_FACTORY_PUNT_SHORT_SCAN_DATA (V4L2_CID_PRIVATE_BASE+241)
+#define V4L2_CID_CAMERA_FACTORY_PUNT_LONG_SCAN_DATA (V4L2_CID_PRIVATE_BASE+242)
+
+#define V4L2_CID_CAMERA_PASM_MODE		(V4L2_CID_PRIVATE_BASE + 243)
+enum set_camera_mode_Cmd {
+	MODE_SMART_AUTO = 0,
+	MODE_PROGRAM,
+	MODE_A,
+	MODE_S,
+	MODE_M,
+	MODE_VIDEO,
+	MODE_BACKGROUND_BLUR,
+	MODE_HIGH_SPEED,
+	MODE_LIGHT_TRAIL_SHOT,
+	MODE_WATERFALL,
+	MODE_SILHOUETTE,
+	MODE_SUNSET,
+	MODE_CLOSE_UP,
+	MODE_FIREWORKS,
+	MODE_CROSS_FILTER,
+	MODE_BACKLIGHT,
+	MODE_BLUE_SKY,
+	MODE_NATURAL_GREEN,
+	MODE_BEST_GROUP_POSE,
+	MODE_FOOD,
+	MODE_START_FILTER,
+	MODE_MOVING_SHOT,
+};
+
+#define V4L2_CID_CAMERA_SHUTTER_SPEED		(V4L2_CID_PRIVATE_BASE + 244)
+#define V4L2_CID_CAMERA_F_NUMBER		(V4L2_CID_PRIVATE_BASE + 245)
+
+#define V4L2_CID_CAMERA_IMAGE_STABILIZER       (V4L2_CID_PRIVATE_BASE + 246)
+enum set_Image_Stabilizer {
+	V4L2_IMAGE_STABILIZER_OFF = 0,
+	V4L2_IMAGE_STABILIZER_OIS = 1,
+	V4L2_IMAGE_STABILIZER_DUALIS = 2,
+};
+
+#define V4L2_CID_CAMERA_IS_OIS_MODE            (V4L2_CID_PRIVATE_BASE + 247)
+enum set_IS_OIS_mode {
+	V4L2_IS_OIS_NONE = 0,
+	V4L2_IS_OIS_MOVIE = 1,
+	V4L2_IS_OIS_STILL = 2,
+	V4L2_IS_OIS_MULTI = 3,
+	V4L2_IS_OIS_VSS = 4,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_AE_TARGET (V4L2_CID_PRIVATE_BASE + 248)
+
+#define V4L2_CID_CAMERA_AV		(V4L2_CID_PRIVATE_BASE + 249)
+#define V4L2_CID_CAMERA_TV		(V4L2_CID_PRIVATE_BASE + 250)
+#define V4L2_CID_CAMERA_SV		(V4L2_CID_PRIVATE_BASE + 251)
+#define V4L2_CID_CAMERA_EV		(V4L2_CID_PRIVATE_BASE + 252)
+
+#define V4L2_CID_CAMERA_SCENE_SUB_MODE		(V4L2_CID_PRIVATE_BASE + 253)
+
+#define V4L2_CID_CAMERA_WB_CUSTOM_X		(V4L2_CID_PRIVATE_BASE + 254)
+#define V4L2_CID_CAMERA_WB_CUSTOM_Y		(V4L2_CID_PRIVATE_BASE + 255)
+#define V4L2_CID_CAMERA_WB_CUSTOM_VALUE		(V4L2_CID_PRIVATE_BASE + 256)
+
+#define V4L2_CID_CAMERA_RED_EYE_FIX_RESULT     (V4L2_CID_PRIVATE_BASE + 257)
+#define V4L2_CID_CAMERA_FACTORY_FLASH		(V4L2_CID_PRIVATE_BASE + 258)
+enum set_Factory_Flash_Cmd {
+	FACTORY_FLASH_STROBE_CHECK_ON = 0,
+	FACTORY_FLASH_STROBE_CHECK_OFF = 1,
+	FACTORY_FLASH_CHARGE = 2,
+	FACTORY_FLASH_LOG = 3,
+	FACTORY_FLASH_CHARGE_END_CHECK = 4,
+	FACTORY_FLASH_STROBE_CHARGE_END_CHECK = 5,
+	FACTORY_FLASH_WB_LOG = 6,
+	FACTORY_ADJ_FLASH_WB_LOG = 7,
+	FACTORY_ADJ_FLASH_WB_END_CHECK = 8,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_WB		(V4L2_CID_PRIVATE_BASE + 259)
+enum set_Factory_WB_Cmd {
+	FACTORY_WB_INDOOR_RUN = 0,
+	FACTORY_WB_INDOOR_END_CHECK = 1,
+	FACTORY_WB_OUTDOOR_RUN = 2,
+	FACTORY_WB_OUTDOOR_END_CHECK = 3,
+	FACTORY_WB_LOG = 4,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_FLASH_RANGE_X (V4L2_CID_PRIVATE_BASE + 260)
+#define V4L2_CID_CAMERA_FACTORY_FLASH_RANGE_Y (V4L2_CID_PRIVATE_BASE + 261)
+
+#define V4L2_CID_CAMERA_FACTORY_WB_IN_RG_VALUE (V4L2_CID_PRIVATE_BASE + 262)
+#define V4L2_CID_CAMERA_FACTORY_WB_IN_BG_VALUE (V4L2_CID_PRIVATE_BASE + 263)
+#define V4L2_CID_CAMERA_FACTORY_WB_OUT_RG_VALUE	(V4L2_CID_PRIVATE_BASE + 264)
+#define V4L2_CID_CAMERA_FACTORY_WB_OUT_BG_VALUE	(V4L2_CID_PRIVATE_BASE + 265)
+
+#define V4L2_CID_CAMERA_FACTORY_AFLED_RANGE_DATA_START_X \
+	(V4L2_CID_PRIVATE_BASE + 266)
+#define V4L2_CID_CAMERA_FACTORY_AFLED_RANGE_DATA_END_X \
+	(V4L2_CID_PRIVATE_BASE + 267)
+#define V4L2_CID_CAMERA_FACTORY_AFLED_RANGE_DATA_START_Y \
+	(V4L2_CID_PRIVATE_BASE + 268)
+#define V4L2_CID_CAMERA_FACTORY_AFLED_RANGE_DATA_END_Y \
+	(V4L2_CID_PRIVATE_BASE + 269)
+
+#define V4L2_CID_CAMERA_FACTORY_AF_LED_TIME (V4L2_CID_PRIVATE_BASE + 270)
+
+#define V4L2_CID_CAMERA_FACTORY_AF_DIFF_CHECK_MIN (V4L2_CID_PRIVATE_BASE + 271)
+#define V4L2_CID_CAMERA_FACTORY_AF_DIFF_CHECK_MAX (V4L2_CID_PRIVATE_BASE + 272)
+
+#define V4L2_CID_CAMERA_FACTORY_DEFECTPIXEL	(V4L2_CID_PRIVATE_BASE + 273)
+enum set_Factory_DefectPixel_Cmd {
+	FACTORY_DEFECTPIXEL_SCENARIO_6 = 0,
+	FACTORY_DEFECTPIXEL_RUN,
+	FACTORY_DEFECTPIXEL_END_CHECK,
+	FACTORY_DEFECTPIXEL_LOG,
+	FACTORY_DEFECTPIXEL_CID_1,
+	FACTORY_DEFECTPIXEL_CID_2,
+	FACTORY_DEFECTPIXEL_CID_3,
+	FACTORY_DEFECTPIXEL_WRITE_BLACK,
+	FACTORY_DEFECTPIXEL_WRITE_WHITE,
+	FACTORY_DEFECTPIXEL_CID_WRITE,
+	FACTORY_DEFECTPIXEL_FLASH_MERGE,
+	FACTORY_DEFECTPIXEL_DOT_WRITE_CHECK,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_DFPX_NLV_CAP (V4L2_CID_PRIVATE_BASE + 274)
+#define V4L2_CID_CAMERA_FACTORY_DFPX_NLV_DR0 (V4L2_CID_PRIVATE_BASE + 275)
+#define V4L2_CID_CAMERA_FACTORY_DFPX_NLV_DR1 (V4L2_CID_PRIVATE_BASE + 276)
+#define V4L2_CID_CAMERA_FACTORY_DFPX_NLV_DR2 (V4L2_CID_PRIVATE_BASE + 277)
+#define V4L2_CID_CAMERA_FACTORY_DFPX_NLV_DR_HS (V4L2_CID_PRIVATE_BASE + 278)
+
+#define V4L2_CID_CAMERA_FACTORY_AF_LED_LV_MIN (V4L2_CID_PRIVATE_BASE + 279)
+#define V4L2_CID_CAMERA_FACTORY_AF_LED_LV_MAX (V4L2_CID_PRIVATE_BASE + 280)
+
+#define V4L2_CID_CAMERA_FACTORY_CAM_SYS_MODE (V4L2_CID_PRIVATE_BASE + 281)
+enum set_Factory_Sysmode_Cmd {
+	FACTORY_SYSMODE_CAPTURE = 0,
+	FACTORY_SYSMODE_MONITOR = 1,
+	FACTORY_SYSMODE_PARAM = 2,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_ISP_FW_CHECK (V4L2_CID_PRIVATE_BASE + 282)
+#define V4L2_CID_CAMERA_FACTORY_OIS_VER_CHECK (V4L2_CID_PRIVATE_BASE + 283)
+
+#define V4L2_CID_CAMERA_SMART_SCENE_DETECT    (V4L2_CID_PRIVATE_BASE+284)
+enum set_smartscenedetect_mode {
+	SMART_SCENE_DETECT_OFF = 0,
+	SMART_SCENE_DETECT_ON = 1,
+};
+#define V4L2_CID_CAMERA_SMART_MOVIE_RECORDING    (V4L2_CID_PRIVATE_BASE+285)
+#define V4L2_CID_CAMERA_SMART_AUTO_S1_PUSH    (V4L2_CID_PRIVATE_BASE+286)
+
+#define V4L2_CID_CAMERA_FACTORY_WB_RANGE_FLASH_WRITE \
+	(V4L2_CID_PRIVATE_BASE + 287)
+
+#define V4L2_CID_CAMERA_FACTORY_FLASH_CHR_CHK_TM \
+	(V4L2_CID_PRIVATE_BASE + 288)
+
+#define V4L2_CID_CAMERA_EXIF_AV (V4L2_CID_PRIVATE_BASE + 289)
+#define V4L2_CID_CAMERA_FACE_DETECT_NUMBER (V4L2_CID_PRIVATE_BASE+290)
+#define V4L2_CID_CAMERA_EXIF_FL (V4L2_CID_PRIVATE_BASE + 291)
+
+#define V4L2_CID_CAMERA_SMART_ZOOM             (V4L2_CID_PRIVATE_BASE + 292)
+enum set_Smart_Zoom {
+	V4L2_SMART_ZOOM_OFF = 0,
+	V4L2_SMART_ZOOM_ON = 1,
+};
+
+#define V4L2_CID_CAMERA_CAF             (V4L2_CID_PRIVATE_BASE + 293)
+
+#define V4L2_CID_CAMERA_FACTORY_LIVEVIEW_OFFSET_MARK \
+	(V4L2_CID_PRIVATE_BASE + 294)
+#define V4L2_CID_CAMERA_FACTORY_LIVEVIEW_OFFSET_VAL \
+	(V4L2_CID_PRIVATE_BASE + 295)
+
+#define V4L2_CID_CAMERA_FACTORY_CAPTURE_GAIN_OFFSET_MARK \
+	(V4L2_CID_PRIVATE_BASE + 296)
+#define V4L2_CID_CAMERA_FACTORY_CAPTURE_GAIN_OFFSET_VAL \
+	(V4L2_CID_PRIVATE_BASE + 297)
+
+#define V4L2_CID_CAMERA_FACTORY_WB_RANGE (V4L2_CID_PRIVATE_BASE + 298)
+
+#define V4L2_CID_CAMERA_LV		(V4L2_CID_PRIVATE_BASE + 299)
+
+#define V4L2_CID_PHYSICAL_ROTATION		(V4L2_CID_PRIVATE_BASE + 300)
+
+#define V4L2_CID_CAMERA_FOCUS_RANGE	(V4L2_CID_PRIVATE_BASE + 301)
+enum set_fouce_range {
+	V4L2_FOCUS_RANGE_AUTO = 0,
+	V4L2_FOCUS_RANGE_MACRO = 1,
+	V4L2_FOCUS_RANGE_AUTO_MACRO = 2,
+};
+
+#define V4L2_CID_CAMERA_TIME_INFO              (V4L2_CID_PRIVATE_BASE + 302)
+
+#define V4L2_CID_CAMERA_AF_LED                 (V4L2_CID_PRIVATE_BASE + 303)
+enum set_AF_LED {
+	V4L2_AF_LED_OFF = 0,
+	V4L2_AF_LED_ON = 1,
+};
+
+#define V4L2_CID_CAMERA_LENS_TIMER             (V4L2_CID_PRIVATE_BASE + 304)
+
+#define V4L2_CID_CAMERA_FLASH_BATT_INFO        (V4L2_CID_PRIVATE_BASE + 305)
+enum set_FLASH_BATT_INFO {
+	V4L2_FLASH_NORMAL_BATT = 0,
+	V4L2_FLASH_LOW_BATT = 1,
+};
+
+#define V4L2_CID_CAMERA_STREAM_PART2     (V4L2_CID_PRIVATE_BASE + 306)
+
+#define V4L2_CID_CAMERA_WIDGET_MODE_LEVEL    (V4L2_CID_PRIVATE_BASE+307)
+enum v4l2_widget_mode_level {
+	V4L2_WIDGET_MODE_LEVEL_1 = 1,
+	V4L2_WIDGET_MODE_LEVEL_2 = 2,
+	V4L2_WIDGET_MODE_LEVEL_3 = 3,
+};
+
+#define V4L2_CID_CAMERA_SMART_READ1            (V4L2_CID_PRIVATE_BASE + 308)
+#define V4L2_CID_CAMERA_SMART_READ2            (V4L2_CID_PRIVATE_BASE + 309)
+
+#define V4L2_CID_CAMERA_PREVIEW_WIDTH     (V4L2_CID_PRIVATE_BASE + 310)
+#define V4L2_CID_CAMERA_PREVIEW_HEIGHT     (V4L2_CID_PRIVATE_BASE + 311)
+#define V4L2_CID_CAMERA_PREVIEW_SIZE     (V4L2_CID_PRIVATE_BASE + 312)
+
+#define V4L2_CID_CAMERA_WARNING_CONDITION	(V4L2_CID_PRIVATE_BASE + 313)
+#define V4L2_CID_CAMERA_EXIF_FL_35mm		 (V4L2_CID_PRIVATE_BASE + 314)
+
+#define V4L2_CID_CAMERA_LENS_STATUS            (V4L2_CID_PRIVATE_BASE + 315)
+#define V4L2_CID_CAMERA_HOLD_LENS            (V4L2_CID_PRIVATE_BASE + 316)
+
+/*      Pixel format FOURCC depth  Description  */
+enum v4l2_pix_format_mode {
+	V4L2_PIX_FMT_MODE_PREVIEW,
+	V4L2_PIX_FMT_MODE_CAPTURE,
+	V4L2_PIX_FMT_MODE_HDR,
+	V4L2_PIX_FMT_MODE_VT_MIRROR,
+	V4L2_PIX_FMT_MODE_VT_NONMIRROR,
+};
+
+#define V4L2_CID_SET_CONTINUE_FPS		(V4L2_CID_PRIVATE_BASE + 500)
+#define V4L2_CID_CONTINUESHOT_PROC	(V4L2_CID_PRIVATE_BASE + 501)
+enum v4l2_continuecshot_proc_state {
+	V4L2_INT_STATE_FRAME_SYNC = 0,
+	V4L2_INT_STATE_CAPTURE_SYNC,
+	V4L2_INT_STATE_CONTINUE_CANCEL,
+	V4L2_INT_STATE_CONTINUE_END,
+	V4L2_INT_STATE_START_CAPTURE,
+};
+
+#define V4L2_CID_CAMERA_GET_MODE	(V4L2_CID_PRIVATE_BASE + 502)
+
+#define V4L2_CID_CAMERA_FACTORY_SEND_SETTING \
+	(V4L2_CID_PRIVATE_BASE + 503)
+#define V4L2_CID_CAMERA_FACTORY_SEND_VALUE \
+	(V4L2_CID_PRIVATE_BASE + 504)
+
+#define V4L2_CID_CAMERA_FACTORY_TILT_SCAN_MIN \
+	(V4L2_CID_PRIVATE_BASE + 505)
+#define V4L2_CID_CAMERA_FACTORY_TILT_SCAN_MAX \
+	(V4L2_CID_PRIVATE_BASE + 506)
+#define V4L2_CID_CAMERA_FACTORY_TILT_FIELD \
+	(V4L2_CID_PRIVATE_BASE + 507)
+#define V4L2_CID_CAMERA_FACTORY_TILT_AF_RANGE_MIN \
+	(V4L2_CID_PRIVATE_BASE + 508)
+#define V4L2_CID_CAMERA_FACTORY_TILT_AF_RANGE_MAX \
+	(V4L2_CID_PRIVATE_BASE + 509)
+#define V4L2_CID_CAMERA_FACTORY_TILT_DIFF_RANGE_MIN \
+	(V4L2_CID_PRIVATE_BASE + 510)
+#define V4L2_CID_CAMERA_FACTORY_TILT_DIFF_RANGE_MAX \
+	(V4L2_CID_PRIVATE_BASE + 511)
+
+#define V4L2_CID_CAMERA_FACTORY_IR_R_GAIN_MIN \
+	(V4L2_CID_PRIVATE_BASE + 512)
+#define V4L2_CID_CAMERA_FACTORY_IR_R_GAIN_MAX \
+	(V4L2_CID_PRIVATE_BASE + 513)
+#define V4L2_CID_CAMERA_FACTORY_IR_B_GAIN_MIN \
+	(V4L2_CID_PRIVATE_BASE + 514)
+#define V4L2_CID_CAMERA_FACTORY_IR_B_GAIN_MAX \
+	(V4L2_CID_PRIVATE_BASE + 515)
+
+#define V4L2_CID_CAMERA_FACTORY_FLASH_MAN_CHARGE \
+	(V4L2_CID_PRIVATE_BASE + 516)
+#define V4L2_CID_CAMERA_FACTORY_FLASH_MAN_EN \
+	(V4L2_CID_PRIVATE_BASE + 517)
+
+#define V4L2_CID_CAMERA_FACTORY_SEND_WORD_VALUE \
+	(V4L2_CID_PRIVATE_BASE + 518)
+#define V4L2_CID_CAMERA_FACTORY_SEND_LONG_VALUE \
+	(V4L2_CID_PRIVATE_BASE + 519)
+
+#define V4L2_CID_CAMERA_FACTORY_DFPX_NLV_DR1_HD \
+	(V4L2_CID_PRIVATE_BASE + 520)
+
+#define V4L2_CID_BURSTSHOT_PROC	(V4L2_CID_PRIVATE_BASE + 521)
+enum v4l2_burst_proc_state {
+	V4L2_INT_STATE_BURST_START = 0,
+	V4L2_INT_STATE_BURST_SYNC,
+	V4L2_INT_STATE_BURST_STOP,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_TILT \
+	(V4L2_CID_PRIVATE_BASE + 522)
+enum set_Factory_Tilt {
+	FACTORY_TILT_ONE_SCRIPT_RUN = 0,
+	FACTORY_TILT_ONE_SCRIPT_DISP1,
+	FACTORY_TILT_ONE_SCRIPT_DISP2,
+	FACTORY_TILT_ONE_SCRIPT_DISP3,
+	FACTORY_TILT_ONE_SCRIPT_DISP4,
+	FACTORY_TILT_ONE_SCRIPT_DISP5,
+};
+
+#define V4L2_CID_CAMERA_FACTORY_IR_CHECK \
+	(V4L2_CID_PRIVATE_BASE + 523)
+enum set_Factory_IR_Check {
+	FACTORY_IR_CHECK_LOG = 0,
+};
+
+#define V4L2_CID_BURSTSHOT_SET_POSTVIEW_SIZE  (V4L2_CID_PRIVATE_BASE + 524)
+
+#define V4L2_CID_BURSTSHOT_SET_SNAPSHOT_SIZE  (V4L2_CID_PRIVATE_BASE + 525)
+
+/* ISP DEBUG CODE  */
+#define V4L2_CID_ISP_DEBUG_READ	(V4L2_CID_FIMC_IS_ISP_DBG_BASE + 1)
+#define V4L2_CID_ISP_DEBUG_WRITE (V4L2_CID_FIMC_IS_ISP_DBG_BASE + 2)
+#define V4L2_CID_ISP_DEBUG_READ_MEM (V4L2_CID_FIMC_IS_ISP_DBG_BASE + 3)
+#define V4L2_CID_ISP_DEBUG_WRITE_MEM (V4L2_CID_FIMC_IS_ISP_DBG_BASE + 4)
+#define V4L2_CID_ISP_DEBUG_READ_FILE (V4L2_CID_FIMC_IS_ISP_DBG_BASE + 5)
+#define V4L2_CID_ISP_DEBUG_WRITE_FILE (V4L2_CID_FIMC_IS_ISP_DBG_BASE + 6)
+#define V4L2_CID_ISP_DEBUG_LOGV (V4L2_CID_FIMC_IS_ISP_DBG_BASE + 7)
+
+/* 12  Y/CbCr 4:2:0 64x32 macroblocks */
+#define V4L2_PIX_FMT_NV12T    v4l2_fourcc('T', 'V', '1', '2')
+#define V4L2_PIX_FMT_NV21T    v4l2_fourcc('T', 'V', '2', '1')
+#define V4L2_PIX_FMT_INTERLEAVED    v4l2_fourcc('I', 'T', 'L', 'V')
+
+/*
+ *  * V4L2 extention for digital camera
+ *   */
+/* Strobe flash light */
+enum v4l2_strobe_control {
+	/* turn off the flash light */
+	V4L2_STROBE_CONTROL_OFF		= 0,
+	/* turn on the flash light */
+	V4L2_STROBE_CONTROL_ON		= 1,
+	/* act guide light before splash */
+	V4L2_STROBE_CONTROL_AFGUIDE	= 2,
+	/* charge the flash light */
+	V4L2_STROBE_CONTROL_CHARGE	= 3,
+};
+
+enum v4l2_strobe_conf {
+	V4L2_STROBE_OFF			= 0,	/* Always off */
+	V4L2_STROBE_ON			= 1,	/* Always splashes */
+	/* Auto control presets */
+	V4L2_STROBE_AUTO		= 2,
+	V4L2_STROBE_REDEYE_REDUCTION	= 3,
+	V4L2_STROBE_SLOW_SYNC		= 4,
+	V4L2_STROBE_FRONT_CURTAIN	= 5,
+	V4L2_STROBE_REAR_CURTAIN	= 6,
+	/* Extra manual control presets */
+	/* keep turned on until turning off */
+	V4L2_STROBE_PERMANENT		= 7,
+	V4L2_STROBE_EXTERNAL		= 8,
+};
+
+enum v4l2_strobe_status {
+	V4L2_STROBE_STATUS_OFF		= 0,
+	/* while processing configurations */
+	V4L2_STROBE_STATUS_BUSY		= 1,
+	V4L2_STROBE_STATUS_ERR		= 2,
+	V4L2_STROBE_STATUS_CHARGING	= 3,
+	V4L2_STROBE_STATUS_CHARGED	= 4,
+};
+
+/* capabilities field */
+/* No strobe supported */
+#define V4L2_STROBE_CAP_NONE		0x0000
+/* Always flash off mode */
+#define V4L2_STROBE_CAP_OFF		0x0001
+/* Always use flash light mode */
+#define V4L2_STROBE_CAP_ON		0x0002
+/* Flashlight works automatic */
+#define V4L2_STROBE_CAP_AUTO		0x0004
+/* Red-eye reduction */
+#define V4L2_STROBE_CAP_REDEYE		0x0008
+/* Slow sync */
+#define V4L2_STROBE_CAP_SLOWSYNC	0x0010
+/* Front curtain */
+#define V4L2_STROBE_CAP_FRONT_CURTAIN	0x0020
+/* Rear curtain */
+#define V4L2_STROBE_CAP_REAR_CURTAIN	0x0040
+/* keep turned on until turning off */
+#define V4L2_STROBE_CAP_PERMANENT	0x0080
+/* use external strobe */
+#define V4L2_STROBE_CAP_EXTERNAL	0x0100
+
+/* Set mode and Get status */
+struct v4l2_strobe {
+	/* off/on/charge:0/1/2 */
+	enum	v4l2_strobe_control control;
+	/* supported strobe capabilities */
+	__u32	capabilities;
+	enum	v4l2_strobe_conf mode;
+	enum	v4l2_strobe_status status;	/* read only */
+/* default is 0 and range of value varies from each models */
+	__u32	flash_ev;
+	__u32	reserved[4];
+};
+
+#define VIDIOC_S_STROBE     _IOWR('V', 83, struct v4l2_strobe)
+#define VIDIOC_G_STROBE     _IOR('V', 84, struct v4l2_strobe)
+
+/* Object recognition and collateral actions */
+enum v4l2_recog_mode {
+	V4L2_RECOGNITION_MODE_OFF	= 0,
+	V4L2_RECOGNITION_MODE_ON	= 1,
+	V4L2_RECOGNITION_MODE_LOCK	= 2,
+};
+
+enum v4l2_recog_action {
+	V4L2_RECOGNITION_ACTION_NONE	= 0,	/* only recognition */
+	V4L2_RECOGNITION_ACTION_BLINK	= 1,	/* Capture on blinking */
+	V4L2_RECOGNITION_ACTION_SMILE	= 2,	/* Capture on smiling */
+};
+
+enum v4l2_recog_pattern {
+	V4L2_RECOG_PATTERN_FACE		= 0, /* Face */
+	V4L2_RECOG_PATTERN_HUMAN	= 1, /* Human */
+	V4L2_RECOG_PATTERN_CHAR		= 2, /* Character */
+};
+
+struct v4l2_recog_rect {
+	enum	v4l2_recog_pattern  p;	/* detected pattern */
+	struct	v4l2_rect  o;	/* detected area */
+	__u32	reserved[4];
+};
+
+struct v4l2_recog_data {
+	__u8	detect_cnt;		/* detected object counter */
+	struct	v4l2_rect	o;	/* detected area */
+	__u32	reserved[4];
+};
+
+struct v4l2_recognition {
+	enum v4l2_recog_mode	mode;
+
+	/* Which pattern to detect */
+	enum v4l2_recog_pattern  pattern;
+
+	/* How many object to detect */
+	__u8	obj_num;
+
+	/* select detected object */
+	__u32	detect_idx;
+
+	/* read only :Get object coordination */
+	struct v4l2_recog_data	data;
+
+	enum v4l2_recog_action	action;
+	__u32	reserved[4];
+};
+
+#define VIDIOC_S_RECOGNITION	_IOWR('V', 85, struct v4l2_recognition)
+#define VIDIOC_G_RECOGNITION	_IOR('V', 86, struct v4l2_recognition)
+
+#endif /* __LINUX_VIDEODEV2_SAMSUNG_H */
diff --git a/camera/include/linux/videodev2_exynos_media.h b/camera/include/linux/videodev2_exynos_media.h
new file mode 100644
index 0000000..2768201
--- /dev/null
+++ b/camera/include/linux/videodev2_exynos_media.h
@@ -0,0 +1,225 @@
+/*
+ * Video for Linux Two header file for Exynos
+ *
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *		http://www.samsung.com
+ *
+ * This header file contains several v4l2 APIs to be proposed to v4l2
+ * community and until being accepted, will be used restrictly for Exynos.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __LINUX_VIDEODEV2_EXYNOS_H
+#define __LINUX_VIDEODEV2_EXYNOS_H
+
+/*      Pixel format          FOURCC                     depth  Description  */
+
+/* two planes -- one Y, one Cr + Cb interleaved  */
+#define V4L2_PIX_FMT_YUV444_2P v4l2_fourcc('Y', 'U', '2', 'P') /* 24  Y/CbCr */
+#define V4L2_PIX_FMT_YVU444_2P v4l2_fourcc('Y', 'V', '2', 'P') /* 24  Y/CrCb */
+
+/* three planes -- one Y, one Cr, one Cb */
+#define V4L2_PIX_FMT_YUV444_3P v4l2_fourcc('Y', 'U', '3', 'P') /* 24  Y/Cb/Cr */
+
+/* two non contiguous planes - one Y, one Cr + Cb interleaved  */
+/* 21  Y/CrCb 4:2:0  */
+#define V4L2_PIX_FMT_NV21M    v4l2_fourcc('N', 'M', '2', '1')
+/* 12  Y/CbCr 4:2:0 16x16 macroblocks */
+#define V4L2_PIX_FMT_NV12MT_16X16 v4l2_fourcc('V', 'M', '1', '2')
+
+/* three non contiguous planes - Y, Cb, Cr */
+/* 12  YVU420 planar */
+#define V4L2_PIX_FMT_YVU420M  v4l2_fourcc('Y', 'V', 'U', 'M')
+
+/* compressed formats */
+#define V4L2_PIX_FMT_H264_MVC v4l2_fourcc('M', '2', '6', '4') /* H264 MVC */
+#define V4L2_PIX_FMT_FIMV     v4l2_fourcc('F', 'I', 'M', 'V') /* FIMV  */
+#define V4L2_PIX_FMT_FIMV1    v4l2_fourcc('F', 'I', 'M', '1') /* FIMV1 */
+#define V4L2_PIX_FMT_FIMV2    v4l2_fourcc('F', 'I', 'M', '2') /* FIMV2 */
+#define V4L2_PIX_FMT_FIMV3    v4l2_fourcc('F', 'I', 'M', '3') /* FIMV3 */
+#define V4L2_PIX_FMT_FIMV4    v4l2_fourcc('F', 'I', 'M', '4') /* FIMV4 */
+#define V4L2_PIX_FMT_VP8      v4l2_fourcc('V', 'P', '8', '0') /* VP8 */
+
+/* yuv444 of JFIF JPEG */
+#define V4L2_PIX_FMT_JPEG_444 v4l2_fourcc('J', 'P', 'G', '4')
+/* yuv422 of JFIF JPEG */
+#define V4L2_PIX_FMT_JPEG_422 v4l2_fourcc('J', 'P', 'G', '2')
+/* yuv420 of JFIF JPEG */
+#define V4L2_PIX_FMT_JPEG_420 v4l2_fourcc('J', 'P', 'G', '0')
+/* grey of JFIF JPEG */
+#define V4L2_PIX_FMT_JPEG_GRAY v4l2_fourcc('J', 'P', 'G', 'G')
+
+/*
+ *	C O N T R O L S
+ */
+/* CID base for Exynos controls (USER_CLASS) */
+#define V4L2_CID_EXYNOS_BASE		(V4L2_CTRL_CLASS_USER | 0x2000)
+
+/* for rgb alpha function */
+#define V4L2_CID_GLOBAL_ALPHA		(V4L2_CID_EXYNOS_BASE + 1)
+
+/* cacheable configuration */
+#define V4L2_CID_CACHEABLE		(V4L2_CID_EXYNOS_BASE + 10)
+
+/* jpeg captured size */
+#define V4L2_CID_CAM_JPEG_MEMSIZE	(V4L2_CID_EXYNOS_BASE + 20)
+#define V4L2_CID_CAM_JPEG_ENCODEDSIZE	(V4L2_CID_EXYNOS_BASE + 21)
+
+#define V4L2_CID_SET_SHAREABLE		(V4L2_CID_EXYNOS_BASE + 40)
+
+/* TV configuration */
+#define V4L2_CID_TV_LAYER_BLEND_ENABLE	(V4L2_CID_EXYNOS_BASE + 50)
+#define V4L2_CID_TV_LAYER_BLEND_ALPHA	(V4L2_CID_EXYNOS_BASE + 51)
+#define V4L2_CID_TV_PIXEL_BLEND_ENABLE	(V4L2_CID_EXYNOS_BASE + 52)
+#define V4L2_CID_TV_CHROMA_ENABLE	(V4L2_CID_EXYNOS_BASE + 53)
+#define V4L2_CID_TV_CHROMA_VALUE	(V4L2_CID_EXYNOS_BASE + 54)
+#define V4L2_CID_TV_HPD_STATUS		(V4L2_CID_EXYNOS_BASE + 55)
+#define V4L2_CID_TV_LAYER_PRIO		(V4L2_CID_EXYNOS_BASE + 56)
+#define V4L2_CID_TV_SET_DVI_MODE	(V4L2_CID_EXYNOS_BASE + 57)
+
+/* for color space conversion equation selection */
+#define V4L2_CID_CSC_EQ_MODE		(V4L2_CID_EXYNOS_BASE + 100)
+#define V4L2_CID_CSC_EQ			(V4L2_CID_EXYNOS_BASE + 101)
+#define V4L2_CID_CSC_RANGE		(V4L2_CID_EXYNOS_BASE + 102)
+
+/* for DRM playback scenario */
+#define V4L2_CID_USE_SYSMMU		(V4L2_CID_EXYNOS_BASE + 200)
+#define V4L2_CID_M2M_CTX_NUM		(V4L2_CID_EXYNOS_BASE + 201)
+
+/* CID base for MFC controls (MPEG_CLASS) */
+#define V4L2_CID_MPEG_MFC_BASE		(V4L2_CTRL_CLASS_MPEG | 0x2000)
+
+#define V4L2_CID_MPEG_VIDEO_H264_SEI_FP_AVAIL		\
+					(V4L2_CID_MPEG_MFC_BASE + 1)
+#define V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRGMENT_ID	\
+					(V4L2_CID_MPEG_MFC_BASE + 2)
+#define V4L2_CID_MPEG_VIDEO_H264_SEI_FP_INFO		\
+					(V4L2_CID_MPEG_MFC_BASE + 3)
+#define V4L2_CID_MPEG_VIDEO_H264_SEI_FP_GRID_POS	\
+					(V4L2_CID_MPEG_MFC_BASE + 4)
+
+#define V4L2_CID_MPEG_MFC51_VIDEO_PACKED_PB		\
+					(V4L2_CID_MPEG_MFC_BASE + 5)
+#define V4L2_CID_MPEG_MFC51_VIDEO_FRAME_TAG		\
+					(V4L2_CID_MPEG_MFC_BASE + 6)
+#define V4L2_CID_MPEG_MFC51_VIDEO_CRC_ENABLE		\
+					(V4L2_CID_MPEG_MFC_BASE + 7)
+#define V4L2_CID_MPEG_MFC51_VIDEO_CRC_DATA_LUMA		\
+					(V4L2_CID_MPEG_MFC_BASE + 8)
+#define V4L2_CID_MPEG_MFC51_VIDEO_CRC_DATA_CHROMA	\
+					(V4L2_CID_MPEG_MFC_BASE + 9)
+#define V4L2_CID_MPEG_MFC51_VIDEO_CRC_DATA_LUMA_BOT	\
+					(V4L2_CID_MPEG_MFC_BASE + 10)
+#define V4L2_CID_MPEG_MFC51_VIDEO_CRC_DATA_CHROMA_BOT	\
+					(V4L2_CID_MPEG_MFC_BASE + 11)
+#define V4L2_CID_MPEG_MFC51_VIDEO_CRC_GENERATED		\
+					(V4L2_CID_MPEG_MFC_BASE + 12)
+#define V4L2_CID_MPEG_MFC51_VIDEO_CHECK_STATE		\
+					(V4L2_CID_MPEG_MFC_BASE + 13)
+#define V4L2_CID_MPEG_MFC51_VIDEO_DISPLAY_STATUS	\
+					(V4L2_CID_MPEG_MFC_BASE + 14)
+
+#define V4L2_CID_MPEG_MFC51_VIDEO_LUMA_ADDR	\
+					(V4L2_CID_MPEG_MFC_BASE + 15)
+#define V4L2_CID_MPEG_MFC51_VIDEO_CHROMA_ADDR	\
+					(V4L2_CID_MPEG_MFC_BASE + 16)
+
+#define V4L2_CID_MPEG_MFC51_VIDEO_STREAM_SIZE		\
+					(V4L2_CID_MPEG_MFC_BASE + 17)
+#define V4L2_CID_MPEG_MFC51_VIDEO_FRAME_COUNT		\
+					(V4L2_CID_MPEG_MFC_BASE + 18)
+#define V4L2_CID_MPEG_MFC51_VIDEO_FRAME_TYPE		\
+					(V4L2_CID_MPEG_MFC_BASE + 19)
+enum v4l2_mpeg_mfc51_video_frame_type {
+	V4L2_MPEG_MFC51_VIDEO_FRAME_TYPE_NOT_CODED	= 0,
+	V4L2_MPEG_MFC51_VIDEO_FRAME_TYPE_I_FRAME	= 1,
+	V4L2_MPEG_MFC51_VIDEO_FRAME_TYPE_P_FRAME	= 2,
+	V4L2_MPEG_MFC51_VIDEO_FRAME_TYPE_B_FRAME	= 3,
+	V4L2_MPEG_MFC51_VIDEO_FRAME_TYPE_SKIPPED	= 4,
+	V4L2_MPEG_MFC51_VIDEO_FRAME_TYPE_OTHERS		= 5,
+};
+
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_INTERLACE	\
+					(V4L2_CID_MPEG_MFC_BASE + 20)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_RC_FRAME_RATE	\
+					(V4L2_CID_MPEG_MFC_BASE + 21)
+#define V4L2_CID_MPEG_MFC51_VIDEO_MPEG4_VOP_TIME_RES	\
+					(V4L2_CID_MPEG_MFC_BASE + 22)
+#define V4L2_CID_MPEG_MFC51_VIDEO_MPEG4_VOP_FRM_DELTA	\
+					(V4L2_CID_MPEG_MFC_BASE + 23)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H263_RC_FRAME_RATE	\
+					(V4L2_CID_MPEG_MFC_BASE + 24)
+
+#define V4L2_CID_MPEG_MFC6X_VIDEO_FRAME_DELTA		\
+					(V4L2_CID_MPEG_MFC_BASE + 25)
+
+#define V4L2_CID_MPEG_MFC51_VIDEO_I_PERIOD_CH	V4L2_CID_MPEG_VIDEO_GOP_SIZE
+#define V4L2_CID_MPEG_MFC51_VIDEO_FRAME_RATE_CH		\
+				V4L2_CID_MPEG_MFC51_VIDEO_H264_RC_FRAME_RATE
+#define V4L2_CID_MPEG_MFC51_VIDEO_BIT_RATE_CH	V4L2_CID_MPEG_VIDEO_BITRATE
+
+/* proposed CIDs, based on 3.3-rc3 */
+#define V4L2_CID_MPEG_VIDEO_VBV_DELAY		(V4L2_CID_MPEG_MFC_BASE + 26)
+
+#define V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_S_B \
+	V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY
+
+#define V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING		\
+					(V4L2_CID_MPEG_MFC_BASE + 27)
+#define V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0		\
+					(V4L2_CID_MPEG_MFC_BASE + 28)
+#define V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE	\
+					(V4L2_CID_MPEG_MFC_BASE + 29)
+enum v4l2_mpeg_video_h264_sei_fp_arrangement_type {
+	V4L2_MPEG_VIDEO_H264_SEI_FP_TYPE_CHEKERBOARD	= 0,
+	V4L2_MPEG_VIDEO_H264_SEI_FP_TYPE_COLUMN		= 1,
+	V4L2_MPEG_VIDEO_H264_SEI_FP_TYPE_ROW		= 2,
+	V4L2_MPEG_VIDEO_H264_SEI_FP_TYPE_SIDE_BY_SIDE	= 3,
+	V4L2_MPEG_VIDEO_H264_SEI_FP_TYPE_TOP_BOTTOM	= 4,
+	V4L2_MPEG_VIDEO_H264_SEI_FP_TYPE_TEMPORAL	= 5,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_FMO		(V4L2_CID_MPEG_MFC_BASE + 30)
+#define V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE	(V4L2_CID_MPEG_MFC_BASE + 31)
+enum v4l2_mpeg_video_h264_fmo_map_type {
+	V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_INTERLEAVED_SLICES		= 0,
+	V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_SCATTERED_SLICES		= 1,
+	V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_FOREGROUND_WITH_LEFT_OVER	= 2,
+	V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_BOX_OUT			= 3,
+	V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_RASTER_SCAN			= 4,
+	V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_WIPE_SCAN			= 5,
+	V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_EXPLICIT			= 6,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP	\
+					(V4L2_CID_MPEG_MFC_BASE + 32)
+#define V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION	\
+					(V4L2_CID_MPEG_MFC_BASE + 33)
+enum v4l2_mpeg_video_h264_fmo_change_dir {
+	V4L2_MPEG_VIDEO_H264_FMO_CHANGE_DIR_RIGHT	= 0,
+	V4L2_MPEG_VIDEO_H264_FMO_CHANGE_DIR_LEFT	= 1,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE	\
+					(V4L2_CID_MPEG_MFC_BASE + 34)
+#define V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH		\
+					(V4L2_CID_MPEG_MFC_BASE + 35)
+#define V4L2_CID_MPEG_VIDEO_H264_ASO			\
+					(V4L2_CID_MPEG_MFC_BASE + 36)
+#define V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER	\
+					(V4L2_CID_MPEG_MFC_BASE + 37)
+#define V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING		\
+					(V4L2_CID_MPEG_MFC_BASE + 38)
+#define V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE	\
+					(V4L2_CID_MPEG_MFC_BASE + 39)
+enum v4l2_mpeg_video_h264_hierarchical_coding_type {
+	V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_B	= 0,
+	V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_P	= 1,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER	\
+					(V4L2_CID_MPEG_MFC_BASE + 40)
+#define V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP	\
+					(V4L2_CID_MPEG_MFC_BASE + 41)
+#define V4L2_CID_MPEG_VIDEO_H264_MVC_VIEW_ID		\
+					(V4L2_CID_MPEG_MFC_BASE + 42)
+#endif /* __LINUX_VIDEODEV2_EXYNOS_H */
diff --git a/camera/smdk4x12_camera.c b/camera/smdk4x12_camera.c
deleted file mode 100644
index 53cc16f..0000000
--- a/camera/smdk4x12_camera.c
+++ /dev/null
@@ -1,4530 +0,0 @@
-/*
- * Copyright (C) 2013-2014 Paul Kocialkowski <contact@paulk.fr>
- *
- * Based on crespo libcamera and exynos4 hal libcamera:
- * Copyright 2008, The Android Open Source Project
- * Copyright 2010, Samsung Electronics Co. LTD
- *
- * 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 <fcntl.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <time.h>
-#include <errno.h>
-#include <malloc.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/mman.h>
-#include <sys/ioctl.h>
-
-#include <asm/types.h>
-
-#define LOG_TAG "smdk4x12_camera"
-#include <utils/Log.h>
-#include <utils/Timers.h>
-
-#include "smdk4x12_camera.h"
-
-#define BIG2LITTLE_ENDIAN(big)	((big & 0xff) << 24 | (big & 0xff00) << 8 | (big & 0xff0000) >> 8 | (big & 0xff000000) >> 24)
-
-/*
- * Devices configurations
- */
-
-struct smdk4x12_camera_mbus_resolution smdk4x12_camera_mbus_resolutions_s5k6a3_galaxys3[] = {
-	// 16:9 ratio
-	{ 1280, 720,	1344, 756 },
-	// 4:3 ratio
-	{ 1280, 960,	1392, 1044 },
-	{ 960, 720,	1392, 1044 },
-	{ 640, 480,	1392, 1044 },
-	{ 320, 240,	1392, 1044 },
-	// 1:1 ratio
-	{ 1392, 1392,	1392, 1392 },
-	{ 704, 704,	1392, 1392 },
-	{ 320, 320,	1392, 1392 },
-};
-
-struct smdk4x12_camera_preset smdk4x12_camera_presets_galaxys3[] = {
-	{
-		.name = "S5C73M3",
-		.facing = CAMERA_FACING_BACK,
-		.orientation = 90,
-		.rotation = 0,
-		.hflip = 0,
-		.vflip = 0,
-		.capture_format = V4L2_PIX_FMT_INTERLEAVED,
-		.picture_format = 0,
-		.fimc_is = 0,
-		.focal_length = 3.7f,
-		.horizontal_view_angle = 63.0f,
-		.vertical_view_angle = 49.3f,
-		.metering = METERING_CENTER,
-		.params = {
-			.preview_size_values = "960x720,1280x720,1184x666,960x640,704x576,640x480,352x288,320x240",
-			.preview_size = "960x720",
-			.preview_format_values = "yuv420sp,yuv420p,rgb565",
-			.preview_format = "rgb565",
-			.preview_frame_rate_values = "30,20,15",
-			.preview_frame_rate = 30,
-			.preview_fps_range_values = "(15000,15000),(15000,30000),(30000,30000)",
-			.preview_fps_range = "15000,30000",
-
-			.picture_size_values = "640x480,1024x768,1280x720,1600x1200,2560x1920,3264x2448,2048x1536,3264x1836,2048x1152,3264x2176",
-			.picture_size = "3264x2448",
-			.picture_format_values = "jpeg",
-			.picture_format = "jpeg",
-			.jpeg_thumbnail_size_values = "160x120,160x90,144x96",
-			.jpeg_thumbnail_width = 160,
-			.jpeg_thumbnail_height = 120,
-			.jpeg_thumbnail_quality = 100,
-			.jpeg_quality = 90,
-
-			.video_snapshot_supported = 0,
-			.full_video_snap_supported = 0,
-
-			.recording_size = "1280x720",
-			.recording_size_values = "1280x720,1920x1080,720x480,640x480,352x288,320x240,176x144",
-			.recording_format = "yuv420sp",
-
-			.focus_mode = "continuous-picture",
-			.focus_mode_values = "auto,infinity,macro,fixed,continuous-picture,continuous-video",
-			.focus_distances = "0.15,1.20,Infinity",
-			.focus_areas = NULL,
-			.max_num_focus_areas = 1,
-
-			.zoom_supported = 1,
-			.smooth_zoom_supported = 0,
-			.zoom_ratios = "100,102,104,109,111,113,119,121,124,131,134,138,146,150,155,159,165,170,182,189,200,213,222,232,243,255,283,300,319,364,400",
-			.zoom = 0,
-			.max_zoom = 30,
-
-			.auto_exposure_lock_supported = 1,
-			.auto_exposure_lock = 0,
-
-			.auto_white_balance_lock_supported = 1,
-			.auto_white_balance_lock = 0,
-
-			.flash_mode = "auto",
-			.flash_mode_values = "auto,on,torch,off",
-
-			.exposure_compensation = 0,
-			.exposure_compensation_step = 0.5,
-			.min_exposure_compensation = -4,
-			.max_exposure_compensation = 4,
-
-			.whitebalance = "auto",
-			.whitebalance_values = "auto,incandescent,fluorescent,daylight,cloudy-daylight",
-
-			.antibanding = "auto",
-			.antibanding_values = "auto,60hz,50hz,off",
-
-			.scene_mode = "auto",
-			.scene_mode_values = "auto,portrait,landscape,night,beach,snow,sunset,fireworks,sports,party,candlelight,dusk-dawn,fall-color,text,back-light",
-
-			.effect = "none",
-			.effect_values = "none,mono,negative,sepia,solarize,posterize,washed,vintage-warm,vintage-cold,point-blue,point-red-yellow,point-green",
-
-			.iso = "auto",
-			.iso_values = "auto,ISO100,ISO200,ISO400,ISO800",
-
-			.image_stabilization = "off",
-			.image_stabilization_values = "on,off",
-		},
-		.mbus_resolutions = NULL,
-		.mbus_resolutions_count = 0,
-	},
-	{
-		.name = "S5K6A3",
-		.facing = CAMERA_FACING_FRONT,
-		.orientation = 270,
-		.rotation = 0,
-		.hflip = 0,
-		.vflip = 0,
-		.capture_format = 0,
-		.picture_format = V4L2_PIX_FMT_YUYV,
-		.fimc_is = 1,
-		.focal_length = 2.73f,
-		.horizontal_view_angle = 52.58f,
-		.vertical_view_angle = 52.58f,
-		.metering = METERING_CENTER,
-		.params = {
-			.preview_size_values = "1280x720,960x720,640x480,320x240,704x704,320x320",
-			.preview_size = "960x720",
-			.preview_format_values = "yuv420sp,yuv420p,rgb565",
-			.preview_format = "rgb565",
-			.preview_frame_rate_values = "30,20,15,8",
-			.preview_frame_rate = 30,
-			.preview_fps_range_values = "(8000,8000),(15000,15000),(15000,30000),(30000,30000)",
-			.preview_fps_range = "15000,30000",
-
-			.picture_size_values = "1344x756,1280x720,1392x1044,1280x960,960x720,640x480,1392x1392",
-			.picture_size = "1280x960",
-			.picture_format_values = "jpeg",
-			.picture_format = "jpeg",
-			.jpeg_thumbnail_size_values = "160x120,160x160,160x90,144x96",
-			.jpeg_thumbnail_width = 160,
-			.jpeg_thumbnail_height = 120,
-			.jpeg_thumbnail_quality = 100,
-			.jpeg_quality = 90,
-
-			.video_snapshot_supported = 0,
-			.full_video_snap_supported = 0,
-
-			.recording_size = "1280x720",
-			.recording_size_values = "1280x720,720x480,640x480,352x288,320x320,320x240,176x144",
-			.recording_format = "yuv420sp",
-
-			.focus_mode = "fixed",
-			.focus_mode_values = "infinity,fixed",
-			.focus_distances = "0.20,0.25,Infinity",
-			.focus_areas = NULL,
-			.max_num_focus_areas = 0,
-
-			.zoom_supported = 0,
-
-			.auto_exposure_lock_supported = 0,
-			.auto_exposure_lock = 0,
-
-			.auto_white_balance_lock_supported = 0,
-			.auto_white_balance_lock = 0,
-
-			.flash_mode = NULL,
-			.flash_mode_values = NULL,
-
-			.exposure_compensation = 0,
-			.exposure_compensation_step = 0.5,
-			.min_exposure_compensation = -4,
-			.max_exposure_compensation = 4,
-
-			.whitebalance = "auto",
-			.whitebalance_values = "auto,incandescent,fluorescent,daylight,cloudy-daylight",
-
-			.antibanding = NULL,
-			.antibanding_values = NULL,
-
-			.scene_mode = NULL,
-			.scene_mode_values = NULL,
-
-			.effect = "none",
-			.effect_values = "none,mono,negative,sepia,solarize,posterize,washed,vintage-warm,vintage-cold,point-blue,point-red-yellow,point-green",
-
-			.iso = "auto",
-			.iso_values = "auto",
-
-			.image_stabilization = "off",
-			.image_stabilization_values = "off",
-		},
-		.mbus_resolutions = (struct smdk4x12_camera_mbus_resolution *) &smdk4x12_camera_mbus_resolutions_s5k6a3_galaxys3,
-		.mbus_resolutions_count = 8,
-	},
-};
-
-struct smdk4x12_v4l2_node smdk4x12_v4l2_nodes_galaxys3[] = {
-	{	// FIMC0 is used for capture
-		.id = 0,
-		.node = "/dev/video0",
-	},
-	{	// FIMC1 is used for preview output
-		.id = 1,
-		.node = "/dev/video1",
-	},
-	{	// FIMC2 is used for picture output
-		.id = 2,
-		.node = "/dev/video2",
-	},
-	{	// FIMC3 is used for recording output
-		.id = 3,
-		.node = "/dev/video3",
-	},
-};
-
-struct exynox_camera_config smdk4x12_camera_config_galaxys3 = {
-	.presets = (struct smdk4x12_camera_preset *) &smdk4x12_camera_presets_galaxys3,
-	.presets_count = 2,
-	.v4l2_nodes = (struct smdk4x12_v4l2_node *) &smdk4x12_v4l2_nodes_galaxys3,
-	.v4l2_nodes_count = 4,
-};
-
-/*
- * SMDK4x12 Camera
- */
-
-struct exynox_camera_config *smdk4x12_camera_config =
-	&smdk4x12_camera_config_galaxys3;
-
-int smdk4x12_camera_start(struct smdk4x12_camera *smdk4x12_camera, int id)
-{
-	int rc;
-
-	if (smdk4x12_camera == NULL || id >= smdk4x12_camera->config->presets_count)
-		return -EINVAL;
-
-	// ION
-
-#ifdef EXYNOS_ION
-	rc = smdk4x12_ion_init(smdk4x12_camera);
-	if (rc < 0) {
-		ALOGE("%s: Unable to init ION", __func__);
-		goto error;
-	}
-
-	rc = smdk4x12_ion_open(smdk4x12_camera);
-	if (rc < 0) {
-		ALOGE("%s: Unable to open ION", __func__);
-		goto error;
-	}
-#endif
-
-	// V4L2
-
-	rc = smdk4x12_v4l2_init(smdk4x12_camera);
-	if (rc < 0) {
-		ALOGE("%s: Unable to init v4l2", __func__);
-		goto error;
-	}
-
-	// FIMC0
-
-	rc = smdk4x12_v4l2_open(smdk4x12_camera, 0);
-	if (rc < 0) {
-		ALOGE("%s: Unable to open v4l2 device", __func__);
-		goto error;
-	}
-
-	rc = smdk4x12_v4l2_querycap_cap(smdk4x12_camera, 0);
-	if (rc < 0) {
-		ALOGE("%s: Unable to query capabilities", __func__);
-		goto error;
-	}
-
-	rc = smdk4x12_v4l2_enum_input(smdk4x12_camera, 0, id);
-	if (rc < 0) {
-		ALOGE("%s: Unable to enumerate input", __func__);
-		goto error;
-	}
-
-	rc = smdk4x12_v4l2_s_input(smdk4x12_camera, 0, id);
-	if (rc < 0) {
-		ALOGE("%s: Unable to set inputs", __func__);
-		goto error;
-	}
-
-	// Recording
-
-	smdk4x12_camera->recording_metadata = 1;
-
-	// Params
-
-	rc = smdk4x12_camera_params_init(smdk4x12_camera, id);
-	if (rc < 0) {
-		ALOGE("%s: Unable to init params", __func__);
-		goto error;
-	}
-
-	// Gralloc
-
-	rc = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const struct hw_module_t **) &smdk4x12_camera->gralloc);
-	if (rc)
-		ALOGE("%s: Unable to get gralloc module", __func__);
-
-	rc = 0;
-	goto complete;
-
-error:
-	smdk4x12_v4l2_close(smdk4x12_camera, 0);
-
-#ifdef EXYNOS_ION
-	smdk4x12_ion_close(smdk4x12_camera);
-#endif
-
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-void smdk4x12_camera_stop(struct smdk4x12_camera *smdk4x12_camera)
-{
-	int i;
-	int id;
-
-	if (smdk4x12_camera == NULL || smdk4x12_camera->config == NULL)
-		return;
-
-	smdk4x12_v4l2_close(smdk4x12_camera, 0);
-
-#ifdef EXYNOS_ION
-	smdk4x12_ion_close(smdk4x12_camera);
-#endif
-}
-
-// Params
-
-int smdk4x12_camera_params_init(struct smdk4x12_camera *smdk4x12_camera, int id)
-{
-	int rc;
-
-	if (smdk4x12_camera == NULL || id >= smdk4x12_camera->config->presets_count)
-		return -EINVAL;
-
-	// Camera params
-
-	smdk4x12_camera->camera_rotation = smdk4x12_camera->config->presets[id].rotation;
-	smdk4x12_camera->camera_hflip = smdk4x12_camera->config->presets[id].hflip;
-	smdk4x12_camera->camera_vflip = smdk4x12_camera->config->presets[id].vflip;
-	smdk4x12_camera->camera_capture_format = smdk4x12_camera->config->presets[id].capture_format;
-	smdk4x12_camera->camera_picture_format = smdk4x12_camera->config->presets[id].picture_format;
-	smdk4x12_camera->camera_fimc_is = smdk4x12_camera->config->presets[id].fimc_is;
-	smdk4x12_camera->camera_focal_length = (int) (smdk4x12_camera->config->presets[id].focal_length * 100);
-	smdk4x12_camera->camera_metering = smdk4x12_camera->config->presets[id].metering;
-
-	smdk4x12_camera->camera_mbus_resolutions = smdk4x12_camera->config->presets[id].mbus_resolutions;
-	smdk4x12_camera->camera_mbus_resolutions_count = smdk4x12_camera->config->presets[id].mbus_resolutions_count;
-
-	// Recording preview
-
-	smdk4x12_param_string_set(smdk4x12_camera, "preferred-preview-size-for-video",
-		smdk4x12_camera->config->presets[id].params.preview_size);
-
-	// Preview
-
-	smdk4x12_param_string_set(smdk4x12_camera, "preview-size-values",
-		smdk4x12_camera->config->presets[id].params.preview_size_values);
-	smdk4x12_param_string_set(smdk4x12_camera, "preview-size",
-		smdk4x12_camera->config->presets[id].params.preview_size);
-	smdk4x12_param_string_set(smdk4x12_camera, "preview-format-values",
-		smdk4x12_camera->config->presets[id].params.preview_format_values);
-	smdk4x12_param_string_set(smdk4x12_camera, "preview-format",
-		smdk4x12_camera->config->presets[id].params.preview_format);
-	smdk4x12_param_string_set(smdk4x12_camera, "preview-frame-rate-values",
-		smdk4x12_camera->config->presets[id].params.preview_frame_rate_values);
-	smdk4x12_param_int_set(smdk4x12_camera, "preview-frame-rate",
-		smdk4x12_camera->config->presets[id].params.preview_frame_rate);
-	smdk4x12_param_string_set(smdk4x12_camera, "preview-fps-range-values",
-		smdk4x12_camera->config->presets[id].params.preview_fps_range_values);
-	smdk4x12_param_string_set(smdk4x12_camera, "preview-fps-range",
-		smdk4x12_camera->config->presets[id].params.preview_fps_range);
-
-	// Picture
-
-	smdk4x12_param_string_set(smdk4x12_camera, "picture-size-values",
-		smdk4x12_camera->config->presets[id].params.picture_size_values);
-	smdk4x12_param_string_set(smdk4x12_camera, "picture-size",
-		smdk4x12_camera->config->presets[id].params.picture_size);
-	smdk4x12_param_string_set(smdk4x12_camera, "picture-format-values",
-		smdk4x12_camera->config->presets[id].params.picture_format_values);
-	smdk4x12_param_string_set(smdk4x12_camera, "picture-format",
-		smdk4x12_camera->config->presets[id].params.picture_format);
-	smdk4x12_param_string_set(smdk4x12_camera, "jpeg-thumbnail-size-values",
-		smdk4x12_camera->config->presets[id].params.jpeg_thumbnail_size_values);
-	smdk4x12_param_int_set(smdk4x12_camera, "jpeg-thumbnail-width",
-		smdk4x12_camera->config->presets[id].params.jpeg_thumbnail_width);
-	smdk4x12_param_int_set(smdk4x12_camera, "jpeg-thumbnail-height",
-		smdk4x12_camera->config->presets[id].params.jpeg_thumbnail_height);
-	smdk4x12_param_int_set(smdk4x12_camera, "jpeg-thumbnail-quality",
-		smdk4x12_camera->config->presets[id].params.jpeg_thumbnail_quality);
-	smdk4x12_param_int_set(smdk4x12_camera, "jpeg-quality",
-		smdk4x12_camera->config->presets[id].params.jpeg_quality);
-
-	if (smdk4x12_camera->config->presets[id].params.video_snapshot_supported == 1)
-		smdk4x12_param_string_set(smdk4x12_camera, "video-snapshot-supported", "true");
-	if (smdk4x12_camera->config->presets[id].params.full_video_snap_supported == 1)
-		smdk4x12_param_string_set(smdk4x12_camera, "full-video-snap-supported", "true");
-
-	// Recording
-
-	smdk4x12_param_string_set(smdk4x12_camera, "video-size",
-		smdk4x12_camera->config->presets[id].params.recording_size);
-	smdk4x12_param_string_set(smdk4x12_camera, "video-size-values",
-		smdk4x12_camera->config->presets[id].params.recording_size_values);
-	smdk4x12_param_string_set(smdk4x12_camera, "video-frame-format",
-		smdk4x12_camera->config->presets[id].params.recording_format);
-
-	// Focus
-
-	smdk4x12_param_string_set(smdk4x12_camera, "focus-mode",
-		smdk4x12_camera->config->presets[id].params.focus_mode);
-	smdk4x12_param_string_set(smdk4x12_camera, "focus-mode-values",
-		smdk4x12_camera->config->presets[id].params.focus_mode_values);
-	smdk4x12_param_string_set(smdk4x12_camera, "focus-distances",
-		smdk4x12_camera->config->presets[id].params.focus_distances);
-	if (smdk4x12_camera->config->presets[id].params.max_num_focus_areas > 0) {
-		smdk4x12_param_string_set(smdk4x12_camera, "focus-areas",
-			smdk4x12_camera->config->presets[id].params.focus_areas);
-		smdk4x12_param_int_set(smdk4x12_camera, "max-num-focus-areas",
-			smdk4x12_camera->config->presets[id].params.max_num_focus_areas);
-	}
-
-	// Zoom
-
-	if (smdk4x12_camera->config->presets[id].params.zoom_supported == 1) {
-		smdk4x12_param_string_set(smdk4x12_camera, "zoom-supported", "true");
-
-		if (smdk4x12_camera->config->presets[id].params.smooth_zoom_supported == 1)
-			smdk4x12_param_string_set(smdk4x12_camera, "smooth-zoom-supported", "true");
-
-		if (smdk4x12_camera->config->presets[id].params.zoom_ratios != NULL)
-			smdk4x12_param_string_set(smdk4x12_camera, "zoom-ratios", smdk4x12_camera->config->presets[id].params.zoom_ratios);
-
-		smdk4x12_param_int_set(smdk4x12_camera, "zoom", smdk4x12_camera->config->presets[id].params.zoom);
-		smdk4x12_param_int_set(smdk4x12_camera, "max-zoom", smdk4x12_camera->config->presets[id].params.max_zoom);
-
-	} else {
-		smdk4x12_param_string_set(smdk4x12_camera, "zoom-supported", "false");
-	}
-
-	// AE lock
-
-	if (smdk4x12_camera->config->presets[id].params.auto_exposure_lock_supported == 1) {
-		smdk4x12_param_string_set(smdk4x12_camera, "auto-exposure-lock-supported", "true");
-
-		if (smdk4x12_camera->config->presets[id].params.auto_exposure_lock)
-			smdk4x12_param_string_set(smdk4x12_camera, "auto-exposure-lock", "true");
-		else
-			smdk4x12_param_string_set(smdk4x12_camera, "auto-exposure-lock", "false");
-	}
-
-	// AWB lock
-
-	if (smdk4x12_camera->config->presets[id].params.auto_white_balance_lock_supported == 1) {
-		smdk4x12_param_string_set(smdk4x12_camera, "auto-whitebalance-lock-supported", "true");
-
-		if (smdk4x12_camera->config->presets[id].params.auto_white_balance_lock)
-			smdk4x12_param_string_set(smdk4x12_camera, "auto-whitebalance-lock", "true");
-		else
-			smdk4x12_param_string_set(smdk4x12_camera, "auto-whitebalance-lock", "false");
-	}
-
-	// Flash
-
-	smdk4x12_param_string_set(smdk4x12_camera, "flash-mode",
-		smdk4x12_camera->config->presets[id].params.flash_mode);
-	smdk4x12_param_string_set(smdk4x12_camera, "flash-mode-values",
-		smdk4x12_camera->config->presets[id].params.flash_mode_values);
-
-	// Exposure
-
-	smdk4x12_param_int_set(smdk4x12_camera, "exposure-compensation",
-		smdk4x12_camera->config->presets[id].params.exposure_compensation);
-	smdk4x12_param_float_set(smdk4x12_camera, "exposure-compensation-step",
-		smdk4x12_camera->config->presets[id].params.exposure_compensation_step);
-	smdk4x12_param_int_set(smdk4x12_camera, "min-exposure-compensation",
-		smdk4x12_camera->config->presets[id].params.min_exposure_compensation);
-	smdk4x12_param_int_set(smdk4x12_camera, "max-exposure-compensation",
-		smdk4x12_camera->config->presets[id].params.max_exposure_compensation);
-
-	// Antibanding
-
-	smdk4x12_param_string_set(smdk4x12_camera, "antibanding",
-		smdk4x12_camera->config->presets[id].params.antibanding);
-	smdk4x12_param_string_set(smdk4x12_camera, "antibanding-values",
-		smdk4x12_camera->config->presets[id].params.antibanding_values);
-
-	// WB
-
-	smdk4x12_param_string_set(smdk4x12_camera, "whitebalance",
-		smdk4x12_camera->config->presets[id].params.whitebalance);
-	smdk4x12_param_string_set(smdk4x12_camera, "whitebalance-values",
-		smdk4x12_camera->config->presets[id].params.whitebalance_values);
-
-	// Scene mode
-
-	smdk4x12_param_string_set(smdk4x12_camera, "scene-mode",
-		smdk4x12_camera->config->presets[id].params.scene_mode);
-	smdk4x12_param_string_set(smdk4x12_camera, "scene-mode-values",
-		smdk4x12_camera->config->presets[id].params.scene_mode_values);
-
-	// Effect
-
-	smdk4x12_param_string_set(smdk4x12_camera, "effect",
-		smdk4x12_camera->config->presets[id].params.effect);
-	smdk4x12_param_string_set(smdk4x12_camera, "effect-values",
-		smdk4x12_camera->config->presets[id].params.effect_values);
-
-	// ISO
-
-	smdk4x12_param_string_set(smdk4x12_camera, "iso",
-		smdk4x12_camera->config->presets[id].params.iso);
-	smdk4x12_param_string_set(smdk4x12_camera, "iso-values",
-		smdk4x12_camera->config->presets[id].params.iso_values);
-
-	// Image stabilization
-
-	smdk4x12_param_string_set(smdk4x12_camera, "image-stabilization",
-		smdk4x12_camera->config->presets[id].params.image_stabilization);
-	smdk4x12_param_string_set(smdk4x12_camera, "image-stabilization-values",
-		smdk4x12_camera->config->presets[id].params.image_stabilization_values);
-
-	// Camera
-
-	smdk4x12_param_float_set(smdk4x12_camera, "focal-length",
-		smdk4x12_camera->config->presets[id].focal_length);
-	smdk4x12_param_float_set(smdk4x12_camera, "horizontal-view-angle",
-		smdk4x12_camera->config->presets[id].horizontal_view_angle);
-	smdk4x12_param_float_set(smdk4x12_camera, "vertical-view-angle",
-		smdk4x12_camera->config->presets[id].vertical_view_angle);
-
-	rc = smdk4x12_camera_params_apply(smdk4x12_camera, 1);
-	if (rc < 0) {
-		ALOGE("%s: Unable to apply params", __func__);
-		return -1;
-	}
-
-	return 0;
-}
-
-int smdk4x12_camera_params_apply(struct smdk4x12_camera *smdk4x12_camera, int force)
-{
-	char *recording_hint_string;
-	char *recording_preview_size_string;
-
-	char *preview_size_string;
-	int preview_width = 0;
-	int preview_height = 0;
-	char *preview_format_string;
-	int preview_format;
-	int preview_fps;
-
-	char *picture_size_string;
-	int picture_width = 0;
-	int picture_height = 0;
-	char *picture_format_string;
-	int picture_format;
-
-	int jpeg_thumbnail_width;
-	int jpeg_thumbnail_height;
-	int jpeg_thumbnail_quality;
-	int jpeg_quality;
-
-	char *video_size_string;
-	int recording_width = 0;
-	int recording_height = 0;
-	char *video_frame_format_string;
-	int recording_format;
-	int camera_sensor_mode;
-	int fimc_is_mode = 0;
-
-	char *focus_mode_string;
-	int focus_mode = 0;
-	char *focus_areas_string;
-	int focus_left, focus_top, focus_right, focus_bottom, focus_weigth;
-	int focus_x;
-	int focus_y;
-
-	char *zoom_supported_string;
-	int zoom, max_zoom;
-
-	char *ae_lock_supported_string;
-	char *ae_lock_string;
-	int ae_lock = 0;
-
-	char *awb_lock_supported_string;
-	char *awb_lock_string;
-	int awb_lock = 0;
-	int aeawb = 0;
-
-	char *flash_mode_string;
-	int flash_mode;
-
-	int exposure_compensation;
-	int min_exposure_compensation;
-	int max_exposure_compensation;
-
-	char *antibanding_string;
-	int antibanding;
-
-	char *whitebalance_string;
-	int whitebalance;
-
-	char *scene_mode_string;
-	int scene_mode;
-
-	char *effect_string;
-	int effect;
-
-	char *iso_string;
-	int iso;
-
-	char *image_stabilization_string;
-	int image_stabilization;
-
-	int w, h;
-	char *k;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	// Preview
-
-	preview_size_string = smdk4x12_param_string_get(smdk4x12_camera, "preview-size");
-	if (preview_size_string != NULL) {
-		sscanf(preview_size_string, "%dx%d", &preview_width, &preview_height);
-
-		if (preview_width != 0 && preview_width != smdk4x12_camera->preview_width)
-			smdk4x12_camera->preview_width = preview_width;
-		if (preview_height != 0 && preview_height != smdk4x12_camera->preview_height)
-			smdk4x12_camera->preview_height = preview_height;
-	}
-
-	preview_format_string = smdk4x12_param_string_get(smdk4x12_camera, "preview-format");
-	if (preview_format_string != NULL) {
-		if (strcmp(preview_format_string, "yuv420sp") == 0) {
-			preview_format = V4L2_PIX_FMT_NV21;
-		} else if (strcmp(preview_format_string, "yuv420p") == 0) {
-			preview_format = V4L2_PIX_FMT_YUV420;
-		} else if (strcmp(preview_format_string, "rgb565") == 0) {
-			preview_format = V4L2_PIX_FMT_RGB565;
-		} else if (strcmp(preview_format_string, "rgb8888") == 0) {
-			preview_format = V4L2_PIX_FMT_RGB32;
-		} else {
-			ALOGE("%s: Unsupported preview format: %s", __func__, preview_format_string);
-			preview_format = V4L2_PIX_FMT_NV21;
-		}
-
-		if (preview_format != smdk4x12_camera->preview_format)
-			smdk4x12_camera->preview_format = preview_format;
-	}
-
-	preview_fps = smdk4x12_param_int_get(smdk4x12_camera, "preview-frame-rate");
-	if (preview_fps > 0)
-		smdk4x12_camera->preview_fps = preview_fps;
-	else
-		smdk4x12_camera->preview_fps = 0;
-
-	// Picture
-
-	picture_size_string = smdk4x12_param_string_get(smdk4x12_camera, "picture-size");
-	if (picture_size_string != NULL) {
-		sscanf(picture_size_string, "%dx%d", &picture_width, &picture_height);
-
-		if (picture_width != 0 && picture_height != 0 && (picture_width != smdk4x12_camera->picture_width || picture_height != smdk4x12_camera->picture_height)) {
-			smdk4x12_camera->picture_width = picture_width;
-			smdk4x12_camera->picture_height = picture_height;
-
-			if (smdk4x12_camera->camera_capture_format == V4L2_PIX_FMT_INTERLEAVED) {
-				rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_JPEG_RESOLUTION, (picture_width & 0xffff) << 16 | (picture_height & 0xffff));
-				if (rc < 0)
-					ALOGE("%s: Unablet to set jpeg resolution", __func__);
-			}
-		}
-	}
-
-	picture_format_string = smdk4x12_param_string_get(smdk4x12_camera, "picture-format");
-	if (picture_format_string != NULL) {
-		if (strcmp(picture_format_string, "jpeg") == 0) {
-			picture_format = V4L2_PIX_FMT_JPEG;
-		} else {
-			ALOGE("%s: Unsupported picture format: %s", __func__, picture_format_string);
-			picture_format = V4L2_PIX_FMT_JPEG;
-		}
-
-		if (picture_format != smdk4x12_camera->picture_format)
-			smdk4x12_camera->picture_format = picture_format;
-	}
-
-	jpeg_thumbnail_width = smdk4x12_param_int_get(smdk4x12_camera, "jpeg-thumbnail-width");
-	if (jpeg_thumbnail_width > 0)
-		smdk4x12_camera->jpeg_thumbnail_width = jpeg_thumbnail_width;
-
-	jpeg_thumbnail_height = smdk4x12_param_int_get(smdk4x12_camera, "jpeg-thumbnail-height");
-	if (jpeg_thumbnail_height > 0)
-		smdk4x12_camera->jpeg_thumbnail_height = jpeg_thumbnail_height;
-
-	jpeg_thumbnail_quality = smdk4x12_param_int_get(smdk4x12_camera, "jpeg-thumbnail-quality");
-	if (jpeg_thumbnail_quality > 0)
-		smdk4x12_camera->jpeg_thumbnail_quality = jpeg_thumbnail_quality;
-
-	jpeg_quality = smdk4x12_param_int_get(smdk4x12_camera, "jpeg-quality");
-	if (jpeg_quality <= 100 && jpeg_quality >= 0 && (jpeg_quality != smdk4x12_camera->jpeg_quality || force)) {
-		smdk4x12_camera->jpeg_quality = jpeg_quality;
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAM_JPEG_QUALITY, jpeg_quality);
-		if (rc < 0)
-			ALOGE("%s: Unable to set jpeg quality", __func__);
-	}
-
-	// Recording
-
-	video_size_string = smdk4x12_param_string_get(smdk4x12_camera, "video-size");
-	if (video_size_string == NULL)
-		video_size_string = smdk4x12_param_string_get(smdk4x12_camera, "preview-size");
-
-	if (video_size_string != NULL) {
-		sscanf(video_size_string, "%dx%d", &recording_width, &recording_height);
-
-		if (recording_width != 0 && recording_width != smdk4x12_camera->recording_width)
-			smdk4x12_camera->recording_width = recording_width;
-		if (recording_height != 0 && recording_height != smdk4x12_camera->recording_height)
-			smdk4x12_camera->recording_height = recording_height;
-	}
-
-	video_frame_format_string = smdk4x12_param_string_get(smdk4x12_camera, "video-frame-format");
-	if (video_frame_format_string != NULL) {
-		if (strcmp(video_frame_format_string, "yuv420sp") == 0) {
-			recording_format = V4L2_PIX_FMT_NV12;
-		} else if (strcmp(video_frame_format_string, "yuv420p") == 0) {
-			recording_format = V4L2_PIX_FMT_YUV420;
-		} else if (strcmp(video_frame_format_string, "rgb565") == 0) {
-			recording_format = V4L2_PIX_FMT_RGB565;
-		} else if (strcmp(video_frame_format_string, "rgb8888") == 0) {
-			recording_format = V4L2_PIX_FMT_RGB32;
-		} else {
-			ALOGE("%s: Unsupported recording format: %s", __func__, video_frame_format_string);
-			recording_format = V4L2_PIX_FMT_NV12;
-		}
-
-		if (recording_format != smdk4x12_camera->recording_format)
-			smdk4x12_camera->recording_format = recording_format;
-	}
-
-	recording_hint_string = smdk4x12_param_string_get(smdk4x12_camera, "recording-hint");
-	if (recording_hint_string != NULL && strcmp(recording_hint_string, "true") == 0) {
-		camera_sensor_mode = SENSOR_MOVIE;
-
-		k = smdk4x12_param_string_get(smdk4x12_camera, "preview-size-values");
-		while (recording_width != 0 && recording_height != 0) {
-			if (k == NULL)
-				break;
-
-			sscanf(k, "%dx%d", &w, &h);
-
-			// Look for same aspect ratio
-			if ((recording_width * h) / recording_height == w) {
-				preview_width = w;
-				preview_height = h;
-				break;
-			}
-
-			k = strchr(k, ',');
-			if (k == NULL)
-				break;
-
-			k++;
-		}
-
-		if (preview_width != 0 && preview_width != smdk4x12_camera->preview_width)
-			smdk4x12_camera->preview_width = preview_width;
-		if (preview_height != 0 && preview_height != smdk4x12_camera->preview_height)
-			smdk4x12_camera->preview_height = preview_height;
-
-		if (smdk4x12_camera->camera_fimc_is)
-			fimc_is_mode = IS_MODE_PREVIEW_VIDEO;
-	} else {
-		camera_sensor_mode = SENSOR_CAMERA;
-
-		if (smdk4x12_camera->camera_fimc_is)
-			fimc_is_mode = IS_MODE_PREVIEW_STILL;
-	}
-
-	// Switching modes
-
-	if (camera_sensor_mode != smdk4x12_camera->camera_sensor_mode) {
-		smdk4x12_camera->camera_sensor_mode = camera_sensor_mode;
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_SENSOR_MODE, camera_sensor_mode);
-		if (rc < 0)
-			ALOGE("%s: Unable to set sensor mode", __func__);
-	}
-
-	if (smdk4x12_camera->camera_fimc_is && fimc_is_mode != smdk4x12_camera->fimc_is_mode) {
-		smdk4x12_camera->fimc_is_mode = fimc_is_mode;
-
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_IS_S_FORMAT_SCENARIO, smdk4x12_camera->fimc_is_mode);
-		if (rc < 0)
-			ALOGE("%s: Unable to set FIMC-IS scenario", __func__);
-	}
-
-	// Focus
-
-	focus_areas_string = smdk4x12_param_string_get(smdk4x12_camera, "focus-areas");
-	if (focus_areas_string != NULL) {
-		focus_left = focus_top = focus_right = focus_bottom = focus_weigth = 0;
-
-		rc = sscanf(focus_areas_string, "(%d,%d,%d,%d,%d)",
-			&focus_left, &focus_top, &focus_right, &focus_bottom, &focus_weigth);
-		if (rc != 5) {
-			ALOGE("%s: Unable to scan focus areas", __func__);
-		} else if (focus_left != 0 && focus_top != 0 && focus_right != 0 && focus_bottom != 0) {
-			focus_x = (((focus_left + focus_right) / 2) + 1000) * preview_width / 2000;
-			focus_y =  (((focus_top + focus_bottom) / 2) + 1000) * preview_height / 2000;
-
-			if (focus_x != smdk4x12_camera->focus_x || force) {
-				smdk4x12_camera->focus_x = focus_x;
-
-				rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_OBJECT_POSITION_X, focus_x);
-				if (rc < 0)
-					ALOGE("%s: Unable to set object x position", __func__);
-			}
-
-			if (focus_y != smdk4x12_camera->focus_y || force) {
-				smdk4x12_camera->focus_y = focus_y;
-
-				rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_OBJECT_POSITION_Y, focus_y);
-				if (rc < 0)
-					ALOGE("%s: Unable to set object y position", __func__);
-			}
-
-			focus_mode = FOCUS_MODE_TOUCH;
-		}
-	}
-
-	focus_mode_string = smdk4x12_param_string_get(smdk4x12_camera, "focus-mode");
-	if (focus_mode_string != NULL) {
-		if (focus_mode == 0) {
-			if (strcmp(focus_mode_string, "auto") == 0)
-				focus_mode = FOCUS_MODE_AUTO;
-			else if (strcmp(focus_mode_string, "infinity") == 0)
-				focus_mode = FOCUS_MODE_INFINITY;
-			else if (strcmp(focus_mode_string, "macro") == 0)
-				focus_mode = FOCUS_MODE_MACRO;
-			else if (strcmp(focus_mode_string, "fixed") == 0)
-				focus_mode = FOCUS_MODE_FIXED;
-			else if (strcmp(focus_mode_string, "facedetect") == 0)
-				focus_mode = FOCUS_MODE_FACEDETECT;
-			else if (strcmp(focus_mode_string, "continuous-video") == 0)
-				focus_mode = FOCUS_MODE_CONTINOUS_VIDEO;
-			else if (strcmp(focus_mode_string, "continuous-picture") == 0)
-				focus_mode = FOCUS_MODE_CONTINOUS_PICTURE;
-			else
-				focus_mode = FOCUS_MODE_AUTO;
-		}
-
-		if (focus_mode != smdk4x12_camera->focus_mode || force) {
-			rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode);
-			if (rc < 0)
-				ALOGE("%s: Unable to set focus mode", __func__);
-		}
-
-		smdk4x12_camera->focus_mode = focus_mode;
-	}
-
-	// Zoom
-
-	zoom_supported_string = smdk4x12_param_string_get(smdk4x12_camera, "zoom-supported");
-	if (zoom_supported_string != NULL && strcmp(zoom_supported_string, "true") == 0) {
-		zoom = smdk4x12_param_int_get(smdk4x12_camera, "zoom");
-		max_zoom = smdk4x12_param_int_get(smdk4x12_camera, "max-zoom");
-		if (zoom <= max_zoom && zoom >= 0 && (zoom != smdk4x12_camera->zoom || force)) {
-			smdk4x12_camera->zoom = zoom;
-			rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_ZOOM, zoom);
-			if (rc < 0)
-				ALOGE("%s: Unable to set camera zoom", __func__);
-		}
-
-	}
-
-	// AE lock
-
-	ae_lock_supported_string = smdk4x12_param_string_get(smdk4x12_camera, "auto-exposure-lock-supported");
-	ae_lock_string = smdk4x12_param_string_get(smdk4x12_camera, "auto-exposure-lock");
-	if (ae_lock_supported_string != NULL && ae_lock_string != NULL && strcmp(ae_lock_supported_string, "true") == 0 && strcmp(ae_lock_string, "true") == 0)
-		ae_lock = 1;
-	else
-		ae_lock = 0;
-
-	// AWB lock
-
-	awb_lock_supported_string = smdk4x12_param_string_get(smdk4x12_camera, "auto-whitebalance-lock-supported");
-	awb_lock_string = smdk4x12_param_string_get(smdk4x12_camera, "auto-whitebalance-lock");
-	if (awb_lock_supported_string != NULL && awb_lock_string != NULL && strcmp(awb_lock_supported_string, "true") == 0 && strcmp(awb_lock_string, "true") == 0)
-		awb_lock = 1;
-	else
-		awb_lock = 0;
-
-	if (ae_lock != smdk4x12_camera->ae_lock || awb_lock != smdk4x12_camera->awb_lock || force) {
-		smdk4x12_camera->ae_lock = ae_lock;
-		smdk4x12_camera->awb_lock = awb_lock;
-		aeawb = (ae_lock ? 0x1 : 0x0) | (awb_lock ? 0x2 : 0x0);
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, aeawb);
-		if (rc < 0)
-			ALOGE("%s: Unable to set AEAWB lock", __func__);
-	}
-
-	// Flash
-
-	flash_mode_string = smdk4x12_param_string_get(smdk4x12_camera, "flash-mode");
-	if (flash_mode_string != NULL) {
-		if (strcmp(flash_mode_string, "off") == 0)
-			flash_mode = FLASH_MODE_OFF;
-		else if (strcmp(flash_mode_string, "auto") == 0)
-			flash_mode = FLASH_MODE_AUTO;
-		else if (strcmp(flash_mode_string, "on") == 0)
-			flash_mode = FLASH_MODE_ON;
-		else if (strcmp(flash_mode_string, "torch") == 0)
-			flash_mode = FLASH_MODE_TORCH;
-		else
-			flash_mode = FLASH_MODE_AUTO;
-
-		if (flash_mode != smdk4x12_camera->flash_mode || force) {
-			smdk4x12_camera->flash_mode = flash_mode;
-			rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_FLASH_MODE, flash_mode);
-			if (rc < 0)
-				ALOGE("%s:Unable to set flash mode", __func__);
-		}
-	}
-
-	// Exposure
-
-	exposure_compensation = smdk4x12_param_int_get(smdk4x12_camera, "exposure-compensation");
-	min_exposure_compensation = smdk4x12_param_int_get(smdk4x12_camera, "min-exposure-compensation");
-	max_exposure_compensation = smdk4x12_param_int_get(smdk4x12_camera, "max-exposure-compensation");
-
-	if (exposure_compensation <= max_exposure_compensation && exposure_compensation >= min_exposure_compensation &&
-		(exposure_compensation != smdk4x12_camera->exposure_compensation || force)) {
-		smdk4x12_camera->exposure_compensation = exposure_compensation;
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_BRIGHTNESS, exposure_compensation);
-		if (rc < 0)
-			ALOGE("%s: Unable to set exposure", __func__);
-	}
-
-	// Antibanding
-
-	antibanding_string = smdk4x12_param_string_get(smdk4x12_camera, "antibanding");
-	if (antibanding_string != NULL) {
-		if (strcmp(antibanding_string, "auto") == 0)
-			antibanding = ANTI_BANDING_AUTO;
-		else if (strcmp(antibanding_string, "50hz") == 0)
-			antibanding = ANTI_BANDING_50HZ;
-		else if (strcmp(antibanding_string, "60hz") == 0)
-			antibanding = ANTI_BANDING_60HZ;
-		else if (strcmp(antibanding_string, "off") == 0)
-			antibanding = ANTI_BANDING_OFF;
-		else
-			antibanding = ANTI_BANDING_AUTO;
-
-		if (antibanding != smdk4x12_camera->antibanding || force) {
-			smdk4x12_camera->antibanding = antibanding;
-			rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_ANTI_BANDING, antibanding);
-			if (rc < 0)
-				ALOGE("%s: Unable to set antibanding", __func__);
-		}
-	}
-
-	// WB
-
-	whitebalance_string = smdk4x12_param_string_get(smdk4x12_camera, "whitebalance");
-	if (whitebalance_string != NULL) {
-		if (strcmp(whitebalance_string, "auto") == 0)
-			whitebalance = WHITE_BALANCE_AUTO;
-		else if (strcmp(whitebalance_string, "incandescent") == 0)
-			whitebalance = WHITE_BALANCE_TUNGSTEN;
-		else if (strcmp(whitebalance_string, "fluorescent") == 0)
-			whitebalance = WHITE_BALANCE_FLUORESCENT;
-		else if (strcmp(whitebalance_string, "daylight") == 0)
-			whitebalance = WHITE_BALANCE_SUNNY;
-		else if (strcmp(whitebalance_string, "cloudy-daylight") == 0)
-			whitebalance = WHITE_BALANCE_CLOUDY;
-		else
-			whitebalance = WHITE_BALANCE_AUTO;
-
-		if (whitebalance != smdk4x12_camera->whitebalance || force) {
-			smdk4x12_camera->whitebalance = whitebalance;
-			rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_WHITE_BALANCE, whitebalance);
-			if (rc < 0)
-				ALOGE("%s: Unable to set whitebalance", __func__);
-		}
-	}
-
-	// Scene mode
-
-	scene_mode_string = smdk4x12_param_string_get(smdk4x12_camera, "scene-mode");
-	if (scene_mode_string != NULL) {
-		if (strcmp(scene_mode_string, "auto") == 0)
-			scene_mode = SCENE_MODE_NONE;
-		else if (strcmp(scene_mode_string, "portrait") == 0)
-			scene_mode = SCENE_MODE_PORTRAIT;
-		else if (strcmp(scene_mode_string, "landscape") == 0)
-			scene_mode = SCENE_MODE_LANDSCAPE;
-		else if (strcmp(scene_mode_string, "night") == 0)
-			scene_mode = SCENE_MODE_NIGHTSHOT;
-		else if (strcmp(scene_mode_string, "beach") == 0)
-			scene_mode = SCENE_MODE_BEACH_SNOW;
-		else if (strcmp(scene_mode_string, "snow") == 0)
-			scene_mode = SCENE_MODE_BEACH_SNOW;
-		else if (strcmp(scene_mode_string, "sunset") == 0)
-			scene_mode = SCENE_MODE_SUNSET;
-		else if (strcmp(scene_mode_string, "fireworks") == 0)
-			scene_mode = SCENE_MODE_FIREWORKS;
-		else if (strcmp(scene_mode_string, "sports") == 0)
-			scene_mode = SCENE_MODE_SPORTS;
-		else if (strcmp(scene_mode_string, "party") == 0)
-			scene_mode = SCENE_MODE_PARTY_INDOOR;
-		else if (strcmp(scene_mode_string, "candlelight") == 0)
-			scene_mode = SCENE_MODE_CANDLE_LIGHT;
-		else if (strcmp(scene_mode_string, "dusk-dawn") == 0)
-			scene_mode = SCENE_MODE_DUSK_DAWN;
-		else if (strcmp(scene_mode_string, "fall-color") == 0)
-			scene_mode = SCENE_MODE_FALL_COLOR;
-		else if (strcmp(scene_mode_string, "back-light") == 0)
-			scene_mode = SCENE_MODE_BACK_LIGHT;
-		else if (strcmp(scene_mode_string, "text") == 0)
-			scene_mode = SCENE_MODE_TEXT;
-		else
-			scene_mode = SCENE_MODE_NONE;
-
-		if (scene_mode != smdk4x12_camera->scene_mode || force) {
-			smdk4x12_camera->scene_mode = scene_mode;
-			rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_SCENE_MODE, scene_mode);
-			if (rc < 0)
-				ALOGE("%s: Unable to set scene mode", __func__);
-		}
-	}
-
-	// Effect
-
-	effect_string = smdk4x12_param_string_get(smdk4x12_camera, "effect");
-	if (effect_string != NULL) {
-		if (strcmp(effect_string, "auto") == 0)
-			effect = IMAGE_EFFECT_NONE;
-		if (strcmp(effect_string, "none") == 0)
-			effect = IMAGE_EFFECT_NONE;
-		else if (strcmp(effect_string, "mono") == 0)
-			effect = IMAGE_EFFECT_BNW;
-		else if (strcmp(effect_string, "negative") == 0)
-			effect = IMAGE_EFFECT_NEGATIVE;
-		else if (strcmp(effect_string, "sepia") == 0)
-			effect = IMAGE_EFFECT_SEPIA;
-		else if (strcmp(effect_string, "aqua") == 0)
-			effect = IMAGE_EFFECT_AQUA;
-		else if (strcmp(effect_string, "solarize") == 0)
-			effect = IMAGE_EFFECT_SOLARIZE;
-		else if (strcmp(effect_string, "posterize") == 0)
-			effect = IMAGE_EFFECT_POSTERIZE;
-		else if (strcmp(effect_string, "washed") == 0)
-			effect = IMAGE_EFFECT_WASHED;
-		else if (strcmp(effect_string, "sketch") == 0)
-			effect = IMAGE_EFFECT_SKETCH;
-		else if (strcmp(effect_string, "vintage-warm") == 0)
-			effect = IMAGE_EFFECT_VINTAGE_WARM;
-		else if (strcmp(effect_string, "vintage-cold") == 0)
-			effect = IMAGE_EFFECT_VINTAGE_COLD;
-		else if (strcmp(effect_string, "point-blue") == 0)
-			effect = IMAGE_EFFECT_POINT_BLUE;
-		else if (strcmp(effect_string, "point-red-yellow") == 0)
-			effect = IMAGE_EFFECT_POINT_RED_YELLOW;
-		else if (strcmp(effect_string, "point-green") == 0)
-			effect = IMAGE_EFFECT_POINT_GREEN;
-		else
-			effect = IMAGE_EFFECT_NONE;
-
-		if (effect != smdk4x12_camera->effect || force) {
-			smdk4x12_camera->effect = effect;
-			rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_EFFECT, effect);
-			if (rc < 0)
-				ALOGE("%s: Unable to set effect", __func__);
-		}
-	}
-
-	// ISO
-
-	iso_string = smdk4x12_param_string_get(smdk4x12_camera, "iso");
-	if (iso_string != NULL) {
-		if (strcmp(iso_string, "auto") == 0)
-			iso = ISO_AUTO;
-		else if (strcmp(iso_string, "ISO50") == 0)
-			iso = ISO_50;
-		else if (strcmp(iso_string, "ISO100") == 0)
-			iso = ISO_100;
-		else if (strcmp(iso_string, "ISO200") == 0)
-			iso = ISO_200;
-		else if (strcmp(iso_string, "ISO400") == 0)
-			iso = ISO_400;
-		else if (strcmp(iso_string, "ISO800") == 0)
-			iso = ISO_800;
-		else
-			iso = ISO_AUTO;
-
-		if (iso != smdk4x12_camera->iso || force) {
-			smdk4x12_camera->iso = iso;
-			rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_ISO, iso);
-			if (rc < 0)
-				ALOGE("%s: Unable to set iso", __func__);
-		}
-	}
-
-	// Image stabilization
-
-	image_stabilization_string = smdk4x12_param_string_get(smdk4x12_camera, "image-stabilization");
-	if (image_stabilization_string != NULL) {
-		if (strcmp(image_stabilization_string, "on") == 0)
-			image_stabilization = ANTI_SHAKE_STILL_ON;
-		else
-			image_stabilization = ANTI_SHAKE_OFF;
-
-		if (image_stabilization != smdk4x12_camera->image_stabilization || force) {
-			smdk4x12_camera->image_stabilization = image_stabilization;
-			rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_ANTI_SHAKE, image_stabilization);
-			if (rc < 0)
-				ALOGE("%s: Unable to set image-stabilization", __func__);
-		}
-	}
-
-	ALOGD("%s: Preview size: %dx%d, picture size: %dx%d, recording size: %dx%d", __func__, preview_width, preview_height, picture_width, picture_height, recording_width, recording_height);
-
-	return 0;
-}
-
-// Capture
-
-int s5c73m3_interleaved_decode(void *data, int size,
-	void *yuv_data, int *yuv_size, int yuv_width, int yuv_height,
-	void *jpeg_data, int *jpeg_size, int *decoded, int *auto_focus_result,
-	int *exif_flash, int *exif_iso, int *exif_exposure,
-	int *exif_exposure_bias, int *exif_exposure_time)
-{
-	int yuv_length;
-	int jpeg_length;
-	unsigned char *yuv_p;
-	unsigned char *jpeg_p;
-	unsigned char *data_p;
-	unsigned int *offset_p;
-	unsigned int pointers_array_offset;
-	unsigned int pointers_array_size;
-	unsigned int interleaved_size;
-	unsigned char s5c73m3_auto_focus_result;
-	unsigned int yuv_offset_last;
-	unsigned int yuv_offset;
-	unsigned int yuv_line_size;
-	unsigned short *jpeg_start_p;
-	int gap;
-	unsigned int i;
-
-	if (data == NULL || size <= 0 || yuv_data == NULL || yuv_size == NULL || yuv_width <= 0 || yuv_height <= 0 || jpeg_data == NULL || jpeg_size == NULL || decoded == NULL || auto_focus_result == NULL || exif_flash == NULL || exif_iso == NULL || exif_exposure == NULL || exif_exposure_bias == NULL || exif_exposure_time == NULL)
-		return -EINVAL;
-
-	yuv_length = 0;
-	jpeg_length = 0;
-
-	data_p = (unsigned char *) data;
-	data_p += size - 0x1000; // End of the first plane (interleaved buffer)
-	data_p += 4046; // Experimental offset for decoded
-
-	*decoded = (int) *data_p;
-
-	data_p = (unsigned char *) data;
-	data_p += size - 0x1000; // End of the first plane (interleaved buffer)
-	data_p += 50; // Experimental offset for auto-focus result
-
-	s5c73m3_auto_focus_result = *data_p;
-	switch (s5c73m3_auto_focus_result) {
-		case S5C73M3_AF_STATUS_FOCUSING:
-		case S5C73M3_CAF_STATUS_FOCUSING:
-			*auto_focus_result = CAMERA_AF_STATUS_IN_PROGRESS;
-			break;
-		case S5C73M3_AF_STATUS_FOCUSED:
-		case S5C73M3_CAF_STATUS_FOCUSED:
-			*auto_focus_result = CAMERA_AF_STATUS_SUCCESS;
-			break;
-		case S5C73M3_AF_STATUS_INVALID:
-		case S5C73M3_CAF_STATUS_FIND_SEARCHING_DIR:
-		case S5C73M3_AF_STATUS_UNFOCUSED:
-		case S5C73M3_CAF_STATUS_UNFOCUSED:
-		default:
-			*auto_focus_result = CAMERA_AF_STATUS_FAIL;
-			break;
-	}
-
-	data_p = (unsigned char *) data;
-	data_p += size - 0x1000; // End of the first plane (interleaved buffer)
-	data_p += 4; // EXIF flash offset
-	*exif_flash = (int) *data_p;
-
-	data_p += 4; // EXIF ISO offset
-	*exif_iso = (int) ((data_p[1] << 8) | (data_p[0] & 0xff));
-
-	data_p += 4; // EXIF exposure offset
-	*exif_exposure = (int) *data_p;
-
-	data_p += 4; // EXIF exposure bias offset
-	*exif_exposure_bias = (int) ((data_p[1] << 8) | (data_p[0] & 0xff));
-
-	data_p += 8; // EXIF exposure time offset
-	*exif_exposure_time = (int) ((data_p[1] << 8) | (data_p[0] & 0xff));
-
-	data_p = (unsigned char *) data;
-	data_p += size - 0x1000; // End of the first plane (interleaved buffer)
-	data_p += 4084; // Experimental offset for interleaved size
-
-	// Read the pointers array offset
-	offset_p = (unsigned int *) data_p;
-	pointers_array_offset = BIG2LITTLE_ENDIAN(*offset_p);
-	interleaved_size = pointers_array_offset;
-
-	// Read the pointers array size, it should be 4 * yuv_height
-	data_p += sizeof(pointers_array_offset);
-	offset_p = (unsigned int *) data_p;
-	pointers_array_size = BIG2LITTLE_ENDIAN(*offset_p);
-
-	if (!*decoded)
-		return 0;
-
-	ALOGD("%s: Interleaved pointers array is at offset 0x%x, 0x%x bytes long\n", __func__, pointers_array_offset, pointers_array_size);
-
-	if ((int) pointers_array_offset > size || (int) pointers_array_size > size || (int) pointers_array_size < yuv_height * (int) sizeof(unsigned int)) {
-		ALOGE("%s: Invalid informations", __func__);
-		return -1;
-	}
-
-	data_p = (unsigned char *) data;
-	data_p += pointers_array_offset;
-	yuv_p = (unsigned char *) yuv_data;
-	jpeg_p = (unsigned char *) jpeg_data;
-	jpeg_start_p = NULL;
-
-	yuv_line_size = yuv_width * 2;
-	yuv_offset_last = 0;
-	yuv_offset = 0;
-	i = 0;
-
-	while (i < pointers_array_size) {
-		offset_p = (unsigned int *) data_p;
-		yuv_offset = BIG2LITTLE_ENDIAN(*offset_p);
-
-		if (yuv_offset > size - yuv_line_size)
-			return -1;
-
-		gap = yuv_offset - yuv_offset_last - yuv_line_size;
-
-		if (gap > 0) {
-			data_p = (unsigned char *) data + yuv_offset_last + yuv_line_size;
-
-			if (jpeg_start_p == NULL) {
-				jpeg_start_p = (unsigned short *) data_p;
-				if (*jpeg_start_p != 0xd8ff) {
-					ALOGE("%s: Invalid jpeg start", __func__);
-					return -1;
-				}
-			}
-
-			memcpy(jpeg_p, data_p, gap);
-			jpeg_p += gap;
-			jpeg_length += gap;
-		}
-
-		yuv_offset_last = yuv_offset;
-
-		data_p = (unsigned char *) data + yuv_offset;
-		memcpy(yuv_p, data_p, yuv_line_size);
-		yuv_p += yuv_line_size;
-		yuv_length += yuv_line_size;
-
-		data_p = (unsigned char *) offset_p;
-		data_p += sizeof(yuv_offset);
-		i += sizeof(yuv_offset);
-	}
-
-	gap = interleaved_size - yuv_offset_last - yuv_line_size;
-
-	if (gap > 0) {
-		data_p = (unsigned char *) data + yuv_offset_last + yuv_line_size;
-
-		memcpy(jpeg_p, data_p, gap);
-		jpeg_p += gap;
-		jpeg_length += gap;
-	}
-
-	*yuv_size = yuv_length;
-	*jpeg_size = jpeg_length;
-
-	return 0;
-}
-
-int smdk4x12_camera_capture(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_camera_capture_listener *listener;
-	struct smdk4x12_camera_buffer *buffers = NULL;
-	struct smdk4x12_camera_buffer *buffer;
-	struct list_head *list;
-	int width, height, format;
-	int yuv_length, jpeg_length;
-	int jpeg_offset, jpeg_size;
-	int jpeg_thumbnail_offset, jpeg_thumbnail_size;
-	int buffers_count;
-	int buffer_length;
-	int auto_focus_result;
-	int decoded;
-	int busy;
-	void *pointer;
-	int address;
-	int offset;
-	int index;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	width = smdk4x12_camera->capture_width;
-	height = smdk4x12_camera->capture_height;
-	format = smdk4x12_camera->capture_format;
-
-	buffers_count = smdk4x12_camera->capture_buffers_count;
-	buffer_length = smdk4x12_camera->capture_buffer_length;
-
-	// V4L2
-
-	index = smdk4x12_v4l2_dqbuf_cap(smdk4x12_camera, 0);
-	if (index < 0 || index >= buffers_count) {
-		rc = smdk4x12_v4l2_poll(smdk4x12_camera, 0);
-		if (rc < 0) {
-			ALOGE("%s Unable to poll", __func__);
-			goto error;
-		} else if (rc == 0) {
-			// Timeout
-			rc = 0;
-			goto complete;
-		}
-
-		index = smdk4x12_v4l2_dqbuf_cap(smdk4x12_camera, 0);
-		if (index < 0 || index >= buffers_count) {
-			ALOGE("%s: Unable to dequeue buffer", __func__);
-			goto error;
-		}
-	}
-
-	smdk4x12_camera->capture_memory_index = index;
-
-	address = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_PADDR_Y, index);
-	if (address == 0 || address == (int) 0xffffffff) {
-		ALOGE("%s: Unable to get address", __func__);
-		goto error;
-	}
-
-	offset = address - smdk4x12_camera->capture_memory_address;
-	if (offset != index * buffer_length)
-		ALOGE("%s: Inconsistent memory offset (0x%x/0x%x)", __func__, offset, index * buffer_length);
-
-	pointer = (void *) ((unsigned char *) smdk4x12_camera->capture_memory->data + offset);
-
-	// Buffers
-
-	switch (format) {
-		case V4L2_PIX_FMT_INTERLEAVED:
-			yuv_length = jpeg_length = 0;
-			auto_focus_result = decoded = 0;
-
-			rc = s5c73m3_interleaved_decode(pointer, buffer_length, smdk4x12_camera->capture_yuv_buffer, &yuv_length, width, height, smdk4x12_camera->capture_jpeg_buffer, &jpeg_length, &decoded, &auto_focus_result, &smdk4x12_camera->capture_exif_flash, &smdk4x12_camera->capture_exif_iso, &smdk4x12_camera->capture_exif_exposure, &smdk4x12_camera->capture_exif_exposure_bias, &smdk4x12_camera->capture_exif_exposure_time);
-			if (rc < 0) {
-				ALOGE("%s: Unable to decode S5C73M3 interleaved", __func__);
-				goto error;
-			}
-
-			if (auto_focus_result != smdk4x12_camera->auto_focus_result) {
-				if (!smdk4x12_camera->auto_focus_thread_enabled) {
-					smdk4x12_camera->auto_focus_result = auto_focus_result;
-
-					rc = smdk4x12_camera_auto_focus(smdk4x12_camera, auto_focus_result);
-					if (rc < 0) {
-						ALOGE("%s: Unable to auto focus", __func__);
-						goto error;
-					}
-				}
-			}
-
-			if (!decoded) {
-				buffers_count = 1;
-				buffers = (struct smdk4x12_camera_buffer *) calloc(buffers_count, sizeof(struct smdk4x12_camera_buffer));
-
-				buffer = buffers;
-
-				buffer->pointer = pointer;
-				buffer->address = address;
-				buffer->length = smdk4x12_camera_buffer_length(width, height, V4L2_PIX_FMT_UYVY);
-				buffer->width = width;
-				buffer->height = height;
-				buffer->format = V4L2_PIX_FMT_UYVY;
-			} else {
-				buffers_count = 2;
-				buffers = (struct smdk4x12_camera_buffer *) calloc(buffers_count, sizeof(struct smdk4x12_camera_buffer));
-
-				buffer = buffers;
-
-				memcpy(pointer, smdk4x12_camera->capture_yuv_buffer, yuv_length);
-
-				buffer->pointer = pointer;
-				buffer->address = address;
-				buffer->length = yuv_length;
-				buffer->width = width;
-				buffer->height = height;
-				buffer->format = V4L2_PIX_FMT_UYVY;
-
-				pointer = (void *) ((unsigned char *) pointer + yuv_length);
-				address += yuv_length;
-				buffer = (struct smdk4x12_camera_buffer *) ((unsigned char *) buffer + sizeof(struct smdk4x12_camera_buffer));
-
-				memcpy(pointer, smdk4x12_camera->capture_jpeg_buffer, jpeg_length);
-
-				buffer->pointer = pointer;
-				buffer->address = address;
-				buffer->length = jpeg_length;
-				buffer->width = smdk4x12_camera->picture_width;
-				buffer->height = smdk4x12_camera->picture_height;
-				buffer->format = V4L2_PIX_FMT_JPEG;
-
-				smdk4x12_camera->capture_hybrid = 0;
-			}
-			break;
-		case V4L2_PIX_FMT_JPEG:
-			jpeg_size = jpeg_offset = 0;
-			jpeg_thumbnail_size = jpeg_thumbnail_offset = 0;
-
-			rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAM_JPEG_MAIN_SIZE, &jpeg_size);
-			if (rc < 0 || jpeg_size <= 0) {
-				ALOGE("%s: Unable to get jpeg size", __func__);
-				goto error;
-			}
-
-			rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAM_JPEG_MAIN_OFFSET, &jpeg_offset);
-			if (rc < 0) {
-				ALOGE("%s: Unable to get jpeg offset", __func__);
-				goto error;
-			}
-
-			rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAM_JPEG_THUMB_SIZE, &jpeg_thumbnail_size);
-			if (rc < 0 || jpeg_thumbnail_size <= 0) {
-				ALOGE("%s: Unable to get jpeg thumbnail size", __func__);
-				goto error;
-			}
-
-			rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAM_JPEG_THUMB_OFFSET, &jpeg_thumbnail_offset);
-			if (rc < 0) {
-				ALOGE("%s: Unable to get jpeg thumbnail offset", __func__);
-				goto error;
-			}
-
-			buffers_count = 2;
-			buffers = (struct smdk4x12_camera_buffer *) calloc(buffers_count, sizeof(struct smdk4x12_camera_buffer));
-
-			buffer = buffers;
-
-			buffer->pointer = (void *) ((unsigned char *) pointer + jpeg_offset);
-			buffer->address = address + jpeg_offset;
-			buffer->length = jpeg_size;
-			buffer->width = smdk4x12_camera->picture_width;
-			buffer->height = smdk4x12_camera->picture_height;
-			buffer->format = V4L2_PIX_FMT_JPEG;
-
-			buffer = (struct smdk4x12_camera_buffer *) ((unsigned char *) buffer + sizeof(struct smdk4x12_camera_buffer));
-
-			buffer->pointer = (void *) ((unsigned char *) pointer + jpeg_thumbnail_offset);
-			buffer->address = address + jpeg_thumbnail_offset;
-			buffer->length = jpeg_thumbnail_size;
-			buffer->width = smdk4x12_camera->jpeg_thumbnail_width;
-			buffer->height = smdk4x12_camera->jpeg_thumbnail_height;
-			buffer->format = V4L2_PIX_FMT_JPEG;
-			break;
-		default:
-			buffers_count = 1;
-			buffers = (struct smdk4x12_camera_buffer *) calloc(buffers_count, sizeof(struct smdk4x12_camera_buffer));
-
-			buffer = buffers;
-
-			buffer->pointer = pointer;
-			buffer->address = address;
-			buffer->length = buffer_length;
-			buffer->width = width;
-			buffer->height = height;
-			buffer->format = format;
-			break;
-	}
-
-	// Listeners
-
-	list = (struct list_head *) smdk4x12_camera->capture_listeners;
-	while (list != NULL)  {
-		listener = (struct smdk4x12_camera_capture_listener *) list;
-
-		if (listener->callback == NULL)
-			goto list_continue_callback;
-
-		/*
-		 * Callback must never call a capture-locked function or it will
-		 * block. Hence, do not unregister the listener in callback.
-		 */
-
-		listener->callback(smdk4x12_camera, buffers, buffers_count);
-
-list_continue_callback:
-		list = list->next;
-	}
-
-	do {
-		busy = 0;
-
-		list = (struct list_head *) smdk4x12_camera->capture_listeners;
-		while (list != NULL)  {
-			listener = (struct smdk4x12_camera_capture_listener *) list;
-
-			if (listener->callback == NULL)
-				goto list_continue_busy;
-
-			busy |= listener->busy;
-
-list_continue_busy:
-			list = list->next;
-		}
-
-		if (busy)
-			usleep(1000);
-	} while (busy);
-
-	rc = smdk4x12_v4l2_qbuf_cap(smdk4x12_camera, 0, index);
-	if (rc < 0) {
-		ALOGE("%s: Unable to queue buffer", __func__);
-		goto error;
-	}
-
-	rc = 0;
-	goto complete;
-
-error:
-	rc = -1;
-
-complete:
-	if (buffers != NULL)
-		free(buffers);
-
-	return rc;
-}
-
-void *smdk4x12_camera_capture_thread(void *data)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-	int rc;
-
-	if (data == NULL)
-		return NULL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) data;
-
-	ALOGE("%s: Starting thread", __func__);
-	smdk4x12_camera->capture_thread_running = 1;
-
-	while (smdk4x12_camera->capture_thread_enabled) {
-		pthread_mutex_lock(&smdk4x12_camera->capture_lock_mutex);
-
-		while (smdk4x12_camera->capture_enabled) {
-			pthread_mutex_lock(&smdk4x12_camera->capture_mutex);
-
-			if (!smdk4x12_camera->capture_enabled) {
-				pthread_mutex_unlock(&smdk4x12_camera->capture_mutex);
-				break;
-			}
-
-			rc = smdk4x12_camera_capture(smdk4x12_camera);
-			if (rc < 0) {
-				ALOGE("%s: Unable to capture", __func__);
-				pthread_mutex_unlock(&smdk4x12_camera->capture_mutex);
-				break;
-			}
-
-			pthread_mutex_unlock(&smdk4x12_camera->capture_mutex);
-
-			// Wait a bit to let others lock the mutex if they need to
-			usleep(10);
-		}
-	}
-
-	smdk4x12_camera->capture_thread_running = 0;
-	ALOGE("%s: Exiting thread", __func__);
-
-	return NULL;
-}
-
-int smdk4x12_camera_capture_thread_start(struct smdk4x12_camera *smdk4x12_camera)
-{
-	pthread_attr_t thread_attr;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	ALOGD("%s()", __func__);
-
-	if (smdk4x12_camera->capture_thread_enabled) {
-		ALOGE("Capture thread was already started!");
-		return -1;
-	}
-
-	pthread_mutex_init(&smdk4x12_camera->capture_mutex, NULL);
-	pthread_mutex_init(&smdk4x12_camera->capture_lock_mutex, NULL);
-
-	// Initial lock
-	pthread_mutex_lock(&smdk4x12_camera->capture_lock_mutex);
-
-	pthread_attr_init(&thread_attr);
-	pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
-
-	smdk4x12_camera->capture_thread_enabled = 1;
-
-	rc = pthread_create(&smdk4x12_camera->capture_thread, &thread_attr, smdk4x12_camera_capture_thread, (void *) smdk4x12_camera);
-	if (rc < 0) {
-		ALOGE("%s: Unable to create thread", __func__);
-		goto error;
-	}
-
-	rc = 0;
-	goto complete;
-
-error:
-	pthread_mutex_destroy(&smdk4x12_camera->capture_mutex);
-	pthread_mutex_destroy(&smdk4x12_camera->capture_lock_mutex);
-
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-void smdk4x12_camera_capture_thread_stop(struct smdk4x12_camera *smdk4x12_camera)
-{
-	int i;
-
-	if (smdk4x12_camera == NULL)
-		return;
-
-	ALOGD("%s()", __func__);
-
-	if (!smdk4x12_camera->capture_thread_enabled) {
-		ALOGE("Capture thread was already stopped!");
-		return;
-	}
-
-	smdk4x12_camera->capture_enabled = 0;
-	smdk4x12_camera->capture_thread_enabled = 0;
-
-	pthread_mutex_unlock(&smdk4x12_camera->capture_lock_mutex);
-
-	// Wait for the thread to end
-	i = 0;
-	while (smdk4x12_camera->capture_thread_running) {
-		if (i++ > 10000) {
-			ALOGE("Capture thread is taking too long to end, something is going wrong");
-			break;
-		}
-		usleep(100);
-	}
-
-	if (smdk4x12_camera->capture_enabled) {
-		pthread_mutex_lock(&smdk4x12_camera->capture_mutex);
-		smdk4x12_camera_capture_stop(smdk4x12_camera);
-		pthread_mutex_unlock(&smdk4x12_camera->capture_mutex);
-	}
-
-	pthread_mutex_destroy(&smdk4x12_camera->capture_mutex);
-	pthread_mutex_destroy(&smdk4x12_camera->capture_lock_mutex);
-}
-
-int smdk4x12_camera_capture_start(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct v4l2_streamparm fps_param;
-	int width, height, format;
-	int mbus_width, mbus_height;
-	int buffers_count, buffer_length;
-	camera_memory_t *memory = NULL;
-	int value;
-	int fd;
-	int rc;
-	int i;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	ALOGD("%s()", __func__);
-
-	if (smdk4x12_camera->capture_enabled) {
-		ALOGE("Capture was already started!");
-		return -1;
-	}
-
-	width = smdk4x12_camera->capture_width;
-	height = smdk4x12_camera->capture_height;
-	format = smdk4x12_camera->capture_format;
-
-	// V4L2
-
-	if (format == V4L2_PIX_FMT_INTERLEAVED) {
-		ALOGD("Enabling hybrid capture");
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_HYBRID, 1);
-		if (rc < 0) {
-			ALOGE("%s: Unable to set hybrid", __func__);
-			goto error;
-		}
-	}
-
-	if (smdk4x12_camera->camera_fimc_is) {
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_IS_S_FORMAT_SCENARIO, smdk4x12_camera->fimc_is_mode);
-		if (rc < 0) {
-			ALOGE("%s: Unable to set FIMC-IS scenario", __func__);
-			goto error;
-		}
-	}
-
-	rc = smdk4x12_v4l2_enum_fmt_cap(smdk4x12_camera, 0, format);
-	if (rc < 0) {
-		ALOGE("%s: Unable to enumerate formats", __func__);
-		goto error;
-	}
-
-	mbus_width = width;
-	mbus_height = height;
-
-	if (smdk4x12_camera->camera_mbus_resolutions != NULL) {
-		for (i = 0; i < smdk4x12_camera->camera_mbus_resolutions_count; i++) {
-			if (smdk4x12_camera->camera_mbus_resolutions[i].width == width && smdk4x12_camera->camera_mbus_resolutions[i].height == height) {
-				mbus_width = smdk4x12_camera->camera_mbus_resolutions[i].mbus_width;
-				mbus_height = smdk4x12_camera->camera_mbus_resolutions[i].mbus_height;
-				break;
-			}
-		}
-	}
-
-	if (smdk4x12_camera->camera_fimc_is) {
-		// Set MBUS width/height/format
-		rc = smdk4x12_v4l2_s_fmt_pix(smdk4x12_camera, 0, V4L2_BUF_TYPE_PRIVATE, mbus_width, mbus_height, format, smdk4x12_camera->fimc_is_mode, V4L2_PIX_FMT_MODE_PREVIEW);
-		if (rc < 0) {
-			ALOGE("%s: Unable to set MBUS capture pixel format", __func__);
-			goto error;
-		}
-	}
-
-	rc = smdk4x12_v4l2_s_fmt_pix_cap(smdk4x12_camera, 0, width, height, format, V4L2_PIX_FMT_MODE_PREVIEW);
-	if (rc < 0) {
-		ALOGE("%s: Unable to set capture pixel format", __func__);
-		goto error;
-	}
-
-	if (!smdk4x12_camera->camera_fimc_is) {
-		// Set MBUS width/height/format
-		rc = smdk4x12_v4l2_s_fmt_pix(smdk4x12_camera, 0, V4L2_BUF_TYPE_PRIVATE, mbus_width, mbus_height, format, V4L2_FIELD_NONE, V4L2_PIX_FMT_MODE_PREVIEW);
-		if (rc < 0) {
-			ALOGE("%s: Unable to set MBUS capture pixel format", __func__);
-			goto error;
-		}
-	}
-
-	if (format == V4L2_PIX_FMT_INTERLEAVED)
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CACHEABLE, 0);
-	else
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CACHEABLE, 1);
-	if (rc < 0) {
-		ALOGE("%s: Unable to set cacheable", __func__);
-		goto error;
-	}
-
-	if (smdk4x12_camera->camera_fimc_is) {
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_IS_S_SCENARIO_MODE, smdk4x12_camera->fimc_is_mode);
-		if (rc < 0) {
-			ALOGE("%s: Unable to set FIMC-IS scenario mode", __func__);
-			goto error;
-		}
-	}
-
-	if (format == V4L2_PIX_FMT_INTERLEAVED) {
-		// This must be set to 1 for interleaved data decoding
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_EMBEDDEDDATA_ENABLE, 1);
-		if (rc < 0) {
-			ALOGE("%s: Unable to set embdedded data enable", __func__);
-			goto error;
-		}
-	}
-
-	// Let's assume FIMC0 has memory available through mmap
-
-	for (i = SMDK4x12_CAMERA_CAPTURE_BUFFERS_COUNT; i > 0; i--) {
-		rc = smdk4x12_v4l2_reqbufs_cap(smdk4x12_camera, 0, i);
-		if (rc >= 0)
-			break;
-	}
-
-	if (rc < 0) {
-		ALOGE("%s: Unable to request buffers", __func__);
-		goto error;
-	}
-
-	buffers_count = rc;
-	ALOGD("Found %d buffers available for capture!", buffers_count);
-
-	memset(&fps_param, 0, sizeof(fps_param));
-	fps_param.parm.capture.timeperframe.numerator = 1;
-	fps_param.parm.capture.timeperframe.denominator = smdk4x12_camera->preview_fps;
-
-	rc = smdk4x12_v4l2_s_parm_cap(smdk4x12_camera, 0, &fps_param);
-	if (rc < 0) {
-		ALOGE("%s: Unable to set fps", __func__);
-		goto error;
-	}
-
-	for (i = 0; i < buffers_count; i++) {
-		rc = smdk4x12_v4l2_querybuf_cap(smdk4x12_camera, 0, i);
-		if (rc < 0) {
-			ALOGE("%s: Unable to query buffers", __func__);
-			goto error;
-		}
-	}
-
-	buffer_length = rc;
-
-	value = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_PADDR_Y, 0);
-	if (value == 0 || value == (int) 0xffffffff) {
-		ALOGE("%s: Unable to get address", __func__);
-		goto error;
-	}
-
-	smdk4x12_camera->capture_memory_address = value;
-
-	if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) {
-		fd = smdk4x12_v4l2_fd(smdk4x12_camera, 0);
-		if (fd < 0) {
-			ALOGE("%s: Unable to get v4l2 fd for id %d", __func__, 0);
-			goto error;
-		}
-
-		smdk4x12_camera->capture_memory = NULL;
-
-		memory = smdk4x12_camera->callbacks.request_memory(fd, buffer_length, buffers_count, smdk4x12_camera->callbacks.user);
-		if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) {
-			ALOGE("%s: Unable to request memory", __func__);
-			goto error;
-		}
-
-		smdk4x12_camera->capture_memory = memory;
-	} else {
-		ALOGE("%s: No memory request function!", __func__);
-		goto error;
-	}
-
-	if (format == V4L2_PIX_FMT_INTERLEAVED) {
-		smdk4x12_camera->capture_yuv_buffer = malloc(buffer_length);
-		smdk4x12_camera->capture_jpeg_buffer = malloc(buffer_length);
-	}
-
-	for (i = 0; i < buffers_count; i++) {
-		rc = smdk4x12_v4l2_qbuf_cap(smdk4x12_camera, 0, i);
-		if (rc < 0) {
-			ALOGE("%s: Unable to queue buffer", __func__);
-			goto error;
-		}
-	}
-
-	smdk4x12_camera->capture_buffers_count = buffers_count;
-	smdk4x12_camera->capture_buffer_length = buffer_length;
-
-	rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_ROTATION,
-		smdk4x12_camera->camera_rotation);
-	if (rc < 0) {
-		ALOGE("%s: Unable to set rotation", __func__);
-		goto error;
-	}
-
-	rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_HFLIP,
-		smdk4x12_camera->camera_hflip);
-	if (rc < 0) {
-		ALOGE("%s: Unable to set hflip", __func__);
-		goto error;
-	}
-
-	rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_VFLIP,
-		smdk4x12_camera->camera_vflip);
-	if (rc < 0) {
-		ALOGE("%s: Unable to set vflip", __func__);
-		goto error;
-	}
-
-	rc = smdk4x12_v4l2_streamon_cap(smdk4x12_camera, 0);
-	if (rc < 0) {
-		ALOGE("%s: Unable to start stream", __func__);
-		goto error;
-	}
-
-	rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_SCENE_MODE, smdk4x12_camera->scene_mode);
-	if (rc < 0) {
-		ALOGE("%s: Unable to set scene mode", __func__);
-		goto error;
-	}
-
-	smdk4x12_camera->capture_enabled = 1;
-	pthread_mutex_unlock(&smdk4x12_camera->capture_lock_mutex);
-
-	rc = 0;
-	goto complete;
-
-error:
-	if (smdk4x12_camera->capture_memory != NULL && smdk4x12_camera->capture_memory->release != NULL) {
-		smdk4x12_camera->capture_memory->release(smdk4x12_camera->capture_memory);
-		smdk4x12_camera->capture_memory = NULL;
-	}
-
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-void smdk4x12_camera_capture_stop(struct smdk4x12_camera *smdk4x12_camera)
-{
-	int rc;
-	int i;
-
-	if (smdk4x12_camera == NULL)
-		return;
-
-	ALOGD("%s()", __func__);
-
-	if (!smdk4x12_camera->capture_enabled) {
-		ALOGE("Capture was already stopped!");
-		return;
-	}
-
-	if (smdk4x12_camera->capture_format == V4L2_PIX_FMT_INTERLEAVED) {
-		ALOGD("Disabling hybrid capture");
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_HYBRID, 0);
-		if (rc < 0)
-			ALOGE("%s: Unable to set hybrid", __func__);
-	}
-
-	rc = smdk4x12_v4l2_streamoff_cap(smdk4x12_camera, 0);
-	if (rc < 0) {
-		ALOGE("%s: Unable to stop stream", __func__);
-	}
-
-	if (smdk4x12_camera->capture_memory != NULL && smdk4x12_camera->capture_memory->release != NULL) {
-		smdk4x12_camera->capture_memory->release(smdk4x12_camera->capture_memory);
-		smdk4x12_camera->capture_memory = NULL;
-	}
-
-	if (smdk4x12_camera->capture_yuv_buffer != NULL) {
-		free(smdk4x12_camera->capture_yuv_buffer);
-		smdk4x12_camera->capture_yuv_buffer = NULL;
-	}
-
-	if (smdk4x12_camera->capture_jpeg_buffer != NULL) {
-		free(smdk4x12_camera->capture_jpeg_buffer);
-		smdk4x12_camera->capture_jpeg_buffer = NULL;
-	}
-
-	smdk4x12_camera->capture_enabled = 0;
-}
-
-int smdk4x12_camera_capture_setup(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_camera_capture_listener *listener;
-	struct list_head *list;
-	int width, height, format;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	ALOGD("%s()", __func__);
-
-	// No listener left
-	if (smdk4x12_camera->capture_listeners == NULL && smdk4x12_camera->capture_enabled) {
-		smdk4x12_camera_capture_stop(smdk4x12_camera);
-		return 0;
-	}
-
-	width = height = format = 0;
-
-	list = (struct list_head *) smdk4x12_camera->capture_listeners;
-	while (list != NULL) {
-		listener = (struct smdk4x12_camera_capture_listener *) list;
-
-		// Interleaved format already has the correct width and height for picture set through ioctl
-		if (smdk4x12_camera->camera_capture_format == V4L2_PIX_FMT_INTERLEAVED)
-			if (listener->format == V4L2_PIX_FMT_JPEG || listener->format == V4L2_PIX_FMT_INTERLEAVED)
-				goto list_continue;
-
-		if (listener->width >= width && listener->height >= height) {
-			width = listener->width;
-			height = listener->height;
-			format = listener->format;
-		}
-
-list_continue:
-		list = list->next;
-	}
-
-	// Override the capture format
-	if (smdk4x12_camera->camera_capture_format)
-		format = smdk4x12_camera->camera_capture_format;
-
-	// Only picture is listening, but we need some preview size anyway
-	if (format == V4L2_PIX_FMT_INTERLEAVED && (width == 0 || height == 0)) {
-		width = smdk4x12_camera->preview_width;
-		height = smdk4x12_camera->preview_height;
-	}
-
-	ALOGD("%s: Selected width: %d, height: %d, format: 0x%x", __func__, width, height, format);
-
-	if (!smdk4x12_camera->capture_enabled) {
-		smdk4x12_camera->capture_width = width;
-		smdk4x12_camera->capture_height = height;
-		smdk4x12_camera->capture_format = format;
-
-		rc = smdk4x12_camera_capture_start(smdk4x12_camera);
-		if (rc < 0) {
-			ALOGE("%s: Unable to start capture", __func__);
-			return -1;
-		}
-	} else if (smdk4x12_camera->capture_width != width || smdk4x12_camera->capture_height != height || smdk4x12_camera->capture_format != format) {
-		smdk4x12_camera_capture_stop(smdk4x12_camera);
-
-		smdk4x12_camera->capture_width = width;
-		smdk4x12_camera->capture_height = height;
-		smdk4x12_camera->capture_format = format;
-
-		rc = smdk4x12_camera_capture_start(smdk4x12_camera);
-		if (rc < 0) {
-			ALOGE("%s: Unable to start capture", __func__);
-			return -1;
-		}
-	}
-
-	return 0;
-}
-
-struct smdk4x12_camera_capture_listener *smdk4x12_camera_capture_listener_register(
-	struct smdk4x12_camera *smdk4x12_camera, int width, int height, int format,
-	int (*callback)(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_camera_buffer *buffers, int buffers_count))
-{
-	struct smdk4x12_camera_capture_listener *listener = NULL;
-	struct list_head *list_end;
-	struct list_head *list;
-	int rc;
-
-	if (smdk4x12_camera == NULL || callback == NULL)
-		return NULL;
-
-	pthread_mutex_lock(&smdk4x12_camera->capture_mutex);
-
-	listener = calloc(1, sizeof(struct smdk4x12_camera_capture_listener));
-	if (listener == NULL)
-		goto error;
-
-	listener->width = width;
-	listener->height = height;
-	listener->format = format;
-	listener->callback = callback;
-	listener->busy = 0;
-
-	list_end = (struct list_head *) smdk4x12_camera->capture_listeners;
-	while (list_end != NULL && list_end->next != NULL)
-		list_end = list_end->next;
-
-	list = (struct list_head *) listener;
-	list_head_insert(list, list_end, NULL);
-
-	if (smdk4x12_camera->capture_listeners == NULL)
-		smdk4x12_camera->capture_listeners = listener;
-
-	rc = smdk4x12_camera_capture_setup(smdk4x12_camera);
-	if (rc < 0) {
-		ALOGE("%s: Unable to setup capture", __func__);
-		goto error;
-	}
-
-	rc = 0;
-	goto complete;
-
-error:
-	listener = NULL;
-
-complete:
-	pthread_mutex_unlock(&smdk4x12_camera->capture_mutex);
-
-	return listener;
-}
-
-void smdk4x12_camera_capture_listener_unregister(
-	struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_camera_capture_listener *listener)
-{
-	struct list_head *list;
-	int rc;
-
-	if (smdk4x12_camera == NULL || listener == NULL)
-		return;
-
-	pthread_mutex_lock(&smdk4x12_camera->capture_mutex);
-
-	list = (struct list_head *) smdk4x12_camera->capture_listeners;
-	while (list != NULL) {
-		if ((void *) list == (void *) listener) {
-			list_head_remove(list);
-
-			if ((void *) list == (void *) smdk4x12_camera->capture_listeners)
-				smdk4x12_camera->capture_listeners = (struct smdk4x12_camera_capture_listener *) list->next;
-
-			memset(listener, 0, sizeof(struct smdk4x12_camera_capture_listener));
-			free(listener);
-
-			break;
-		}
-list_continue:
-		list = list->next;
-	}
-
-	rc = smdk4x12_camera_capture_setup(smdk4x12_camera);
-	if (rc < 0) {
-		ALOGE("%s: Unable to setup capture", __func__);
-		goto complete;
-	}
-
-complete:
-	pthread_mutex_unlock(&smdk4x12_camera->capture_mutex);
-}
-
-// Preview
-
-int smdk4x12_camera_preview_output_start(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_v4l2_output *output;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	ALOGD("%s()", __func__);
-
-	if (smdk4x12_camera->preview_output_enabled) {
-		ALOGE("Preview was already started!");
-		return -1;
-	}
-
-	output = &smdk4x12_camera->preview_output;
-
-	memset(output, 0, sizeof(struct smdk4x12_v4l2_output));
-	output->v4l2_id = 1;
-	output->width = smdk4x12_camera->preview_width;
-	output->height = smdk4x12_camera->preview_height;
-	output->format = smdk4x12_camera->preview_format;
-	output->buffer_width = smdk4x12_camera->preview_buffer.width;
-	output->buffer_height = smdk4x12_camera->preview_buffer.height;
-	output->buffer_format = smdk4x12_camera->preview_buffer.format;
-	output->buffers_count = SMDK4x12_CAMERA_PREVIEW_BUFFERS_COUNT;
-
-	rc = smdk4x12_v4l2_output_start(smdk4x12_camera, output);
-	if (rc < 0) {
-		ALOGE("%s: Unable to start preview output", __func__);
-		goto error;
-	}
-
-	smdk4x12_camera->preview_output_enabled = 1;
-
-	rc = 0;
-	goto complete;
-
-error:
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-void smdk4x12_camera_preview_output_stop(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_v4l2_output *output;
-
-	if (smdk4x12_camera == NULL)
-		return;
-
-	ALOGD("%s()", __func__);
-
-	if (!smdk4x12_camera->preview_output_enabled) {
-		ALOGE("Preview was already stopped!");
-		return;
-	}
-
-	output = &smdk4x12_camera->preview_output;
-
-	smdk4x12_v4l2_output_stop(smdk4x12_camera, output);
-
-	smdk4x12_camera->preview_output_enabled = 0;
-}
-
-int smdk4x12_camera_preview_callback(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_camera_buffer *buffers, int buffers_count)
-{
-	struct smdk4x12_camera_buffer *buffer = NULL;
-	int width, height, format;
-	int buffer_width, buffer_height, buffer_format;
-	int rc;
-	int i;
-
-	if (smdk4x12_camera == NULL || buffers == NULL || buffers_count <= 0)
-		return -EINVAL;
-
-//	ALOGD("%s()", __func__);
-
-	if (smdk4x12_camera->preview_listener == NULL)
-		return -1;
-
-	if (smdk4x12_camera->preview_listener->busy) {
-		ALOGE("%s: Dropping buffer", __func__);
-		return 0;
-	}
-
-	if (smdk4x12_camera->preview_listener->width != smdk4x12_camera->preview_width || smdk4x12_camera->preview_listener->height != smdk4x12_camera->preview_height || smdk4x12_camera->preview_listener->format != smdk4x12_camera->preview_format) {
-		ALOGD("%s: Waiting for preview listener update", __func__);
-		pthread_mutex_unlock(&smdk4x12_camera->preview_lock_mutex);
-		return 0;
-	}
-
-	smdk4x12_camera->preview_listener->busy = 1;
-
-	width = smdk4x12_camera->preview_width;
-	height = smdk4x12_camera->preview_height;
-	format = smdk4x12_camera->preview_format;
-
-	for (i = 0; i < buffers_count; i++) {
-		if (buffers->format == V4L2_PIX_FMT_JPEG)
-			goto buffers_continue;
-
-		if (buffers->format == V4L2_PIX_FMT_INTERLEAVED)
-			goto buffers_continue;
-
-		// Optimal buffer
-		if (buffers->width == width && buffers->height == height) {
-			buffer = buffers;
-			break;
-		}
-
-		// Might-work buffer, but not optimal
-		buffer = buffers;
-
-buffers_continue:
-		buffers = (struct smdk4x12_camera_buffer *) ((unsigned char *) buffers + sizeof(struct smdk4x12_camera_buffer));
-	}
-
-	if (buffer == NULL) {
-		ALOGE("%s: Unable to find an appropriate buffer for preview", __func__);
-		smdk4x12_camera->preview_listener->busy = 0;
-		return 0;
-	}
-
-	buffer_width = buffer->width;
-	buffer_height = buffer->height;
-	buffer_format = buffer->format;
-
-	pthread_mutex_lock(&smdk4x12_camera->preview_mutex);
-
-	if (buffer_width != width || buffer_height != height || buffer_format != format) {
-		if (!smdk4x12_camera->preview_output_enabled) {
-			memcpy(&smdk4x12_camera->preview_buffer, buffer, sizeof(struct smdk4x12_camera_buffer));
-
-			rc = smdk4x12_camera_preview_output_start(smdk4x12_camera);
-			if (rc < 0) {
-				ALOGE("%s: Unable to start preview", __func__);
-				goto error;
-			}
-		} else if (smdk4x12_camera->preview_buffer.width != buffer_width || smdk4x12_camera->preview_buffer.height != buffer_height || smdk4x12_camera->preview_buffer.format != buffer_format) {
-			smdk4x12_camera_preview_output_stop(smdk4x12_camera);
-
-			memcpy(&smdk4x12_camera->preview_buffer, buffer, sizeof(struct smdk4x12_camera_buffer));
-
-			rc = smdk4x12_camera_preview_output_start(smdk4x12_camera);
-			if (rc < 0) {
-				ALOGE("%s: Unable to start preview", __func__);
-				goto error;
-			}
-		} else {
-			memcpy(&smdk4x12_camera->preview_buffer, buffer, sizeof(struct smdk4x12_camera_buffer));
-		}
-	} else {
-		// The buffer format exactly matches our expectations
-
-		if (smdk4x12_camera->preview_output_enabled)
-			smdk4x12_camera_preview_output_stop(smdk4x12_camera);
-
-		memcpy(&smdk4x12_camera->preview_buffer, buffer, sizeof(struct smdk4x12_camera_buffer));
-	}
-
-	pthread_mutex_unlock(&smdk4x12_camera->preview_lock_mutex);
-
-	pthread_mutex_unlock(&smdk4x12_camera->preview_mutex);
-
-	rc = 0;
-	goto complete;
-
-error:
-	pthread_mutex_unlock(&smdk4x12_camera->preview_mutex);
-
-	smdk4x12_camera->preview_listener->busy = 0;
-
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-int smdk4x12_camera_preview(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_v4l2_output *output;
-	int width, height, format;
-	buffer_handle_t *window_buffer;
-	void *window_data;
-	int window_stride;
-	camera_memory_t *memory;
-	void *memory_pointer;
-	int memory_index;
-	int memory_size;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		goto error;
-
-//	ALOGD("%s()", __func__);
-
-	width = smdk4x12_camera->preview_width;
-	height = smdk4x12_camera->preview_height;
-	format = smdk4x12_camera->preview_format;
-
-	output = &smdk4x12_camera->preview_output;
-
-	if (smdk4x12_camera->preview_output_enabled) {
-		rc = smdk4x12_v4l2_output(smdk4x12_camera, output, smdk4x12_camera->preview_buffer.address);
-		if (rc < 0) {
-			ALOGE("%s: Unable to output preview", __func__);
-			goto error;
-		}
-
-		memory = output->memory;
-		memory_index = output->memory_index;
-		memory_pointer = (void *) ((unsigned char *) memory->data + output->buffer_length * memory_index);
-		memory_size = output->buffer_length;
-	} else {
-		// In that case, we can directly use the capture memory
-		memory = smdk4x12_camera->capture_memory;
-		memory_index = smdk4x12_camera->capture_memory_index;
-		memory_pointer = smdk4x12_camera->preview_buffer.pointer;
-		memory_size = smdk4x12_camera->preview_buffer.length;
-	}
-
-	if (smdk4x12_camera->preview_window != NULL && smdk4x12_camera->gralloc != NULL) {
-		smdk4x12_camera->preview_window->dequeue_buffer(smdk4x12_camera->preview_window, &window_buffer, &window_stride);
-		smdk4x12_camera->gralloc->lock(smdk4x12_camera->gralloc, *window_buffer, GRALLOC_USAGE_SW_WRITE_OFTEN, 0, 0, width, height, &window_data);
-
-		if (window_data == NULL) {
-			ALOGE("%s: Unable to lock gralloc", __func__);
-			goto error;
-		}
-
-		memcpy(window_data, memory_pointer, memory_size);
-
-		smdk4x12_camera->gralloc->unlock(smdk4x12_camera->gralloc, *window_buffer);
-		smdk4x12_camera->preview_window->enqueue_buffer(smdk4x12_camera->preview_window, window_buffer);
-	}
-
-	if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_PREVIEW_FRAME) && SMDK4x12_CAMERA_CALLBACK_DEFINED(data) && !smdk4x12_camera->callback_lock) {
-		smdk4x12_camera->callbacks.data(CAMERA_MSG_PREVIEW_FRAME, memory, memory_index, NULL, smdk4x12_camera->callbacks.user);
-	}
-
-	if (smdk4x12_camera->preview_output_enabled) {
-		rc = smdk4x12_v4l2_output_release(smdk4x12_camera, output);
-		if (rc < 0) {
-			ALOGE("%s: Unable to release preview output", __func__);
-			goto error;
-		}
-	}
-
-	rc = 0;
-	goto complete;
-
-error:
-	rc = -1;
-
-complete:
-	smdk4x12_camera->preview_listener->busy = 0;
-
-	return rc;
-}
-
-void *smdk4x12_camera_preview_thread(void *data)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-	struct smdk4x12_camera_capture_listener *listener;
-	int gralloc_format;
-	int rc;
-
-	if (data == NULL)
-		return NULL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) data;
-
-	ALOGE("%s: Starting thread", __func__);
-	smdk4x12_camera->preview_thread_running = 1;
-
-	while (smdk4x12_camera->preview_thread_enabled) {
-		pthread_mutex_lock(&smdk4x12_camera->preview_lock_mutex);
-
-		pthread_mutex_lock(&smdk4x12_camera->preview_mutex);
-
-		if (smdk4x12_camera->preview_listener == NULL) {
-			pthread_mutex_unlock(&smdk4x12_camera->preview_mutex);
-			break;
-		}
-
-		if (smdk4x12_camera->preview_listener->busy) {
-			rc = smdk4x12_camera_preview(smdk4x12_camera);
-			if (rc < 0) {
-				ALOGE("%s: Unable to preview", __func__);
-				pthread_mutex_unlock(&smdk4x12_camera->preview_mutex);
-				break;
-			}
-		}
-
-		if (smdk4x12_camera->preview_listener->width != smdk4x12_camera->preview_width || smdk4x12_camera->preview_listener->height != smdk4x12_camera->preview_height || smdk4x12_camera->preview_listener->format != smdk4x12_camera->preview_format) {
-			if (smdk4x12_camera->preview_output_enabled)
-				smdk4x12_camera_preview_output_stop(smdk4x12_camera);
-
-			smdk4x12_camera_capture_listener_unregister(smdk4x12_camera, smdk4x12_camera->preview_listener);
-
-			smdk4x12_camera->preview_listener = NULL;
-
-			listener = smdk4x12_camera_capture_listener_register(smdk4x12_camera, smdk4x12_camera->preview_width, smdk4x12_camera->preview_height, smdk4x12_camera->preview_format, smdk4x12_camera_preview_callback);
-			if (listener == NULL) {
-				ALOGE("%s: Unable to register preview capture listener", __func__);
-				pthread_mutex_unlock(&smdk4x12_camera->preview_mutex);
-				break;
-			}
-
-			smdk4x12_camera->preview_listener = listener;
-
-			gralloc_format = smdk4x12_gralloc_format(smdk4x12_camera->preview_format);
-
-			rc = smdk4x12_camera->preview_window->set_buffers_geometry(smdk4x12_camera->preview_window, smdk4x12_camera->preview_width, smdk4x12_camera->preview_height, gralloc_format);
-			if (rc) {
-				ALOGE("%s: Unable to set buffers geometry", __func__);
-				pthread_mutex_unlock(&smdk4x12_camera->preview_mutex);
-				break;
-			}
-		}
-
-		pthread_mutex_unlock(&smdk4x12_camera->preview_mutex);
-	}
-
-	smdk4x12_camera->preview_thread_running = 0;
-	ALOGE("%s: Exiting thread", __func__);
-
-	return NULL;
-}
-
-int smdk4x12_camera_preview_thread_start(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_camera_capture_listener *listener;
-	pthread_attr_t thread_attr;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	ALOGD("%s()", __func__);
-
-	if (smdk4x12_camera->preview_thread_enabled) {
-		ALOGE("Preview thread was already started!");
-		return -1;
-	}
-
-	pthread_mutex_init(&smdk4x12_camera->preview_mutex, NULL);
-	pthread_mutex_init(&smdk4x12_camera->preview_lock_mutex, NULL);
-
-	// Initial lock
-	pthread_mutex_lock(&smdk4x12_camera->preview_lock_mutex);
-
-	pthread_attr_init(&thread_attr);
-	pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
-
-	smdk4x12_camera->preview_thread_enabled = 1;
-
-	rc = pthread_create(&smdk4x12_camera->preview_thread, &thread_attr, smdk4x12_camera_preview_thread, (void *) smdk4x12_camera);
-	if (rc < 0) {
-		ALOGE("%s: Unable to create thread", __func__);
-		goto error;
-	}
-
-	listener = smdk4x12_camera_capture_listener_register(smdk4x12_camera, smdk4x12_camera->preview_width, smdk4x12_camera->preview_height, smdk4x12_camera->preview_format, smdk4x12_camera_preview_callback);
-	if (listener == NULL) {
-		ALOGE("%s: Unable to register preview capture listener", __func__);
-		goto error;
-	}
-
-	smdk4x12_camera->preview_listener = listener;
-
-	rc = 0;
-	goto complete;
-
-error:
-	pthread_mutex_destroy(&smdk4x12_camera->preview_mutex);
-	pthread_mutex_destroy(&smdk4x12_camera->preview_lock_mutex);
-
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-void smdk4x12_camera_preview_thread_stop(struct smdk4x12_camera *smdk4x12_camera)
-{
-	int i;
-
-	if (smdk4x12_camera == NULL)
-		return;
-
-	ALOGD("%s()", __func__);
-
-	if (!smdk4x12_camera->preview_thread_enabled) {
-		ALOGE("Preview thread was already stopped!");
-		return;
-	}
-
-	if (smdk4x12_camera->preview_listener != NULL) {
-		smdk4x12_camera_capture_listener_unregister(smdk4x12_camera, smdk4x12_camera->preview_listener);
-		smdk4x12_camera->preview_listener = NULL;
-	}
-
-	smdk4x12_camera->preview_thread_enabled = 0;
-
-	pthread_mutex_unlock(&smdk4x12_camera->preview_lock_mutex);
-
-	// Wait for the thread to end
-	i = 0;
-	while (smdk4x12_camera->preview_thread_running) {
-		if (i++ > 10000) {
-			ALOGE("Preview thread is taking too long to end, something is going wrong");
-			break;
-		}
-		usleep(100);
-	}
-
-	if (smdk4x12_camera->preview_output_enabled) {
-		pthread_mutex_lock(&smdk4x12_camera->preview_mutex);
-		smdk4x12_camera_preview_output_stop(smdk4x12_camera);
-		pthread_mutex_unlock(&smdk4x12_camera->preview_mutex);
-	}
-
-	pthread_mutex_destroy(&smdk4x12_camera->preview_mutex);
-	pthread_mutex_destroy(&smdk4x12_camera->preview_lock_mutex);
-
-	// Invalidate the preview window
-	smdk4x12_camera->preview_window = NULL;
-}
-
-// Picture
-
-int smdk4x12_camera_picture_callback(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_camera_buffer *buffers, int buffers_count)
-{
-	struct smdk4x12_camera_buffer *jpeg_buffer = NULL;
-	struct smdk4x12_camera_buffer *jpeg_thumbnail_buffer = NULL;
-	struct smdk4x12_camera_buffer *yuv_buffer = NULL;
-	struct smdk4x12_camera_buffer *yuv_thumbnail_buffer = NULL;
-	int width, height;
-	int thumbnail_width, thumbnail_height;
-	time_t timestamp;
-	int rc;
-	int i;
-
-	if (smdk4x12_camera == NULL || buffers == NULL || buffers_count <= 0)
-		return -EINVAL;
-
-	ALOGD("%s()", __func__);
-
-	width = smdk4x12_camera->picture_width;
-	height = smdk4x12_camera->picture_height;
-	thumbnail_width = smdk4x12_camera->jpeg_thumbnail_width;
-	thumbnail_height = smdk4x12_camera->jpeg_thumbnail_height;
-
-	if (smdk4x12_camera->picture_completed)
-		return -1;
-
-	if (smdk4x12_camera->picture_listener == NULL)
-		return -1;
-
-	if (smdk4x12_camera->picture_listener->busy) {
-		ALOGE("%s: Dropping buffer", __func__);
-		return 0;
-	}
-
-	ALOGE("%s: locking picture_mutex", __func__);
-	pthread_mutex_lock(&smdk4x12_camera->picture_mutex);
-	ALOGE("%s: locked picture_mutex", __func__);
-
-	if (!smdk4x12_camera->picture_enabled && !smdk4x12_camera->camera_fimc_is) {
-		if (smdk4x12_camera->camera_capture_format == V4L2_PIX_FMT_INTERLEAVED && smdk4x12_camera->zoom == 0 && smdk4x12_camera->focus_mode == FOCUS_MODE_CONTINOUS_PICTURE) {
-			if (smdk4x12_camera->auto_focus_result == CAMERA_AF_STATUS_FAIL) {
-				// We don't want to take a picture out of focus, so wait a bit
-				timestamp = time(NULL);
-
-				if (smdk4x12_camera->picture_focus_timestamp > 0) {
-					if ((timestamp - smdk4x12_camera->picture_focus_timestamp) > 2) {
-						ALOGE("%s: Picture will be taken out of focus", __func__);
-					} else {
-						pthread_mutex_unlock(&smdk4x12_camera->picture_mutex);
-						return 0;
-					}
-				} else {
-					smdk4x12_camera->picture_focus_timestamp = timestamp;
-					pthread_mutex_unlock(&smdk4x12_camera->picture_mutex);
-					return 0;
-				}
-			} else if (smdk4x12_camera->auto_focus_result == CAMERA_AF_STATUS_IN_PROGRESS) {
-				ALOGD("%s: Not asking for picture until auto focus is done", __func__);
-				pthread_mutex_unlock(&smdk4x12_camera->picture_mutex);
-				return 0;
-			}
-		}
-
-		smdk4x12_camera->picture_focus_timestamp = 0;
-
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_CAPTURE, 0);
-		if (rc < 0) {
-			ALOGE("%s: Unable to set capture", __func__);
-			goto error;
-		}
-
-		if (smdk4x12_camera->camera_capture_format == V4L2_PIX_FMT_INTERLEAVED && !smdk4x12_camera->capture_hybrid) {
-			rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_HYBRID_CAPTURE, 1);
-			if (rc < 0) {
-				ALOGE("%s: Unable to set hybrid capture", __func__);
-				goto error;
-			}
-
-			smdk4x12_camera->capture_hybrid = 1;
-		}
-
-		smdk4x12_camera->picture_enabled = 1;
-
-		pthread_mutex_unlock(&smdk4x12_camera->picture_mutex);
-		return 0;
-	}
-
-	ALOGE("%s: unlocking picture_mutex", __func__);
-	pthread_mutex_unlock(&smdk4x12_camera->picture_mutex);
-	ALOGE("%s: unlocked picture_mutex", __func__);
-
-	smdk4x12_camera->picture_listener->busy = 1;
-
-	// Let's assume the picture format is JPEG
-
-	for (i = 0; i < buffers_count; i++) {
-		if (buffers->format == V4L2_PIX_FMT_JPEG) {
-			if (buffers->width == width && buffers->height == height)
-				jpeg_buffer = buffers;
-			else if (buffers->width == thumbnail_width && buffers->height == thumbnail_height)
-				jpeg_thumbnail_buffer = buffers;
-		} else {
-			if (buffers->width >= width && buffers->height >= height)
-				yuv_buffer = buffers;
-			if (buffers->width >= thumbnail_width && buffers->height >= thumbnail_height)
-				yuv_thumbnail_buffer = buffers;
-		}
-
-buffers_continue:
-		buffers = (struct smdk4x12_camera_buffer *) ((unsigned char *) buffers + sizeof(struct smdk4x12_camera_buffer));
-	}
-
-	if (jpeg_buffer == NULL && yuv_buffer == NULL) {
-		ALOGE("%s: Unable to find an appropriate buffer for picture", __func__);
-		smdk4x12_camera->picture_listener->busy = 0;
-		return 0;
-	}
-
-	// Interleaved must not use a preview frame as picture
-	if (smdk4x12_camera->camera_capture_format == V4L2_PIX_FMT_INTERLEAVED && jpeg_buffer == NULL) {
-		smdk4x12_camera->picture_listener->busy = 0;
-		return 0;
-	}
-
-	pthread_mutex_lock(&smdk4x12_camera->picture_mutex);
-
-	if (jpeg_buffer == NULL)
-		memset(&smdk4x12_camera->picture_jpeg_buffer, 0, sizeof(smdk4x12_camera->picture_jpeg_buffer));
-	else
-		memcpy(&smdk4x12_camera->picture_jpeg_buffer, jpeg_buffer, sizeof(struct smdk4x12_camera_buffer));
-
-	if (jpeg_thumbnail_buffer == NULL)
-		memset(&smdk4x12_camera->picture_jpeg_thumbnail_buffer, 0, sizeof(smdk4x12_camera->picture_jpeg_thumbnail_buffer));
-	else
-		memcpy(&smdk4x12_camera->picture_jpeg_thumbnail_buffer, jpeg_thumbnail_buffer, sizeof(struct smdk4x12_camera_buffer));
-
-	if (yuv_buffer == NULL)
-		memset(&smdk4x12_camera->picture_yuv_buffer, 0, sizeof(smdk4x12_camera->picture_yuv_buffer));
-	else
-		memcpy(&smdk4x12_camera->picture_yuv_buffer, yuv_buffer, sizeof(struct smdk4x12_camera_buffer));
-
-	if (yuv_thumbnail_buffer == NULL)
-		memset(&smdk4x12_camera->picture_yuv_thumbnail_buffer, 0, sizeof(smdk4x12_camera->picture_yuv_thumbnail_buffer));
-	else
-		memcpy(&smdk4x12_camera->picture_yuv_thumbnail_buffer, yuv_thumbnail_buffer, sizeof(struct smdk4x12_camera_buffer));
-
-	pthread_mutex_unlock(&smdk4x12_camera->picture_lock_mutex);
-
-	pthread_mutex_unlock(&smdk4x12_camera->picture_mutex);
-
-	rc = 0;
-	goto complete;
-
-error:
-	pthread_mutex_unlock(&smdk4x12_camera->picture_mutex);
-
-	smdk4x12_camera->picture_listener->busy = 0;
-
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-int smdk4x12_camera_picture(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_camera_buffer *jpeg_buffer;
-	struct smdk4x12_camera_buffer *jpeg_thumbnail_buffer;
-	struct smdk4x12_camera_buffer *yuv_buffer;
-	struct smdk4x12_camera_buffer *yuv_thumbnail_buffer;
-	struct smdk4x12_v4l2_output output;
-	struct smdk4x12_jpeg jpeg;
-	struct smdk4x12_exif exif;
-	int output_enabled = 0;
-	int width, height, format;
-	int buffer_width, buffer_height, buffer_format, buffer_address;
-	camera_memory_t *memory = NULL;
-	int memory_size;
-	unsigned char *p;
-	camera_memory_t *jpeg_memory = NULL;
-	void *jpeg_data = NULL;
-	int jpeg_size = 0;
-	camera_memory_t *jpeg_thumbnail_memory = NULL;
-	void *jpeg_thumbnail_data = NULL;
-	int jpeg_thumbnail_size = 0;
-	void *yuv_data = NULL;
-	int yuv_address;
-	int yuv_size = 0;
-	void *yuv_thumbnail_data = NULL;
-	int yuv_thumbnail_address;
-	int yuv_thumbnail_size = 0;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		goto error;
-
-//	ALOGD("%s()", __func__);
-
-	jpeg_buffer = &smdk4x12_camera->picture_jpeg_buffer;
-	jpeg_thumbnail_buffer = &smdk4x12_camera->picture_jpeg_thumbnail_buffer;
-	yuv_buffer = &smdk4x12_camera->picture_yuv_buffer;
-	yuv_thumbnail_buffer = &smdk4x12_camera->picture_yuv_thumbnail_buffer;
-
-	if (jpeg_buffer->pointer != NULL && jpeg_buffer->length > 0) {
-		jpeg_data = jpeg_buffer->pointer;
-		jpeg_size = jpeg_buffer->length;
-	}
-
-	if (jpeg_thumbnail_buffer->pointer != NULL && jpeg_thumbnail_buffer->length > 0) {
-		jpeg_thumbnail_data = jpeg_thumbnail_buffer->pointer;
-		jpeg_thumbnail_size = jpeg_thumbnail_buffer->length;
-	}
-
-	if (yuv_buffer->pointer != NULL && yuv_buffer->length > 0) {
-		yuv_data = yuv_buffer->pointer;
-		yuv_address = yuv_buffer->address;
-		yuv_size = yuv_buffer->length;
-	}
-
-	if (yuv_thumbnail_buffer->pointer != NULL && yuv_thumbnail_buffer->length > 0) {
-		yuv_thumbnail_data = yuv_thumbnail_buffer->pointer;
-		yuv_thumbnail_address = yuv_thumbnail_buffer->address;
-		yuv_thumbnail_size = yuv_thumbnail_buffer->length;
-	}
-
-	// JPEG
-
-	if (jpeg_data == NULL) {
-		if (yuv_data == NULL || yuv_size <= 0) {
-			ALOGE("%s: Unable to create jpeg without an YUV buffer", __func__);
-			goto error;
-		}
-
-		width = smdk4x12_camera->picture_width;
-		height = smdk4x12_camera->picture_height;
-		format = yuv_buffer->format;
-
-		buffer_width = yuv_buffer->width;
-		buffer_height = yuv_buffer->height;
-		buffer_format = yuv_buffer->format;
-		buffer_address = yuv_buffer->address;
-
-		if (width != buffer_width && height != buffer_height) {
-			format = SMDK4x12_CAMERA_PICTURE_OUTPUT_FORMAT;
-
-			memset(&output, 0, sizeof(output));
-			output.v4l2_id = 2;
-			output.width = width;
-			output.height = height;
-			output.format = format;
-			output.buffer_width = buffer_width;
-			output.buffer_height = buffer_height;
-			output.buffer_format = buffer_format;
-			output.buffers_count = 1;
-
-			rc = smdk4x12_v4l2_output_start(smdk4x12_camera, &output);
-			if (rc < 0) {
-				ALOGE("%s: Unable to start picture output", __func__);
-				goto error;
-			}
-
-			rc = smdk4x12_v4l2_output(smdk4x12_camera, &output, buffer_address);
-			if (rc < 0) {
-				ALOGE("%s: Unable to output picture", __func__);
-				goto error;
-			}
-
-			output_enabled = 1;
-
-			yuv_data = output.memory->data;
-			yuv_address = output.memory_address;
-			yuv_size = output.buffer_length;
-		}
-
-		memset(&jpeg, 0, sizeof(jpeg));
-		jpeg.width = width;
-		jpeg.height = height;
-		jpeg.format = format;
-		jpeg.quality = smdk4x12_camera->jpeg_quality;
-
-		rc = smdk4x12_jpeg_start(smdk4x12_camera, &jpeg);
-		if (rc < 0) {
-			ALOGE("%s: Unable to start jpeg", __func__);
-			goto error;
-		}
-
-		if (jpeg.memory_in_pointer == NULL) {
-			ALOGE("%s: Invalid memory input pointer", __func__);
-			goto error;
-		}
-
-		memcpy(jpeg.memory_in_pointer, yuv_data, yuv_size);
-
-		rc = smdk4x12_jpeg(smdk4x12_camera, &jpeg);
-		if (rc < 0) {
-			ALOGE("%s: Unable to jpeg", __func__);
-			goto error;
-		}
-
-		jpeg_size = jpeg.memory_out_size;
-		if (jpeg_size <= 0) {
-			ALOGE("%s: Invalid jpeg size", __func__);
-			goto error;
-		}
-
-		if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) {
-			jpeg_memory = smdk4x12_camera->callbacks.request_memory(-1, jpeg_size, 1, smdk4x12_camera->callbacks.user);
-			if (jpeg_memory == NULL || jpeg_memory->data == NULL || jpeg_memory->data == MAP_FAILED) {
-				ALOGE("%s: Unable to request memory", __func__);
-				goto error;
-			}
-		} else {
-			ALOGE("%s: No memory request function!", __func__);
-			goto error;
-		}
-
-		jpeg_data = jpeg_memory->data;
-
-		memcpy(jpeg_data, jpeg.memory_out_pointer, jpeg_size);
-
-		smdk4x12_jpeg_stop(smdk4x12_camera, &jpeg);
-
-		if (output_enabled) {
-			smdk4x12_v4l2_output_stop(smdk4x12_camera, &output);
-			output_enabled = 0;
-		}
-	}
-
-	ALOGE("%s: finished jpeg", __func__);
-
-	// Thumbnail
-
-	if (jpeg_thumbnail_data == NULL) {
-		if (yuv_thumbnail_data == NULL || yuv_thumbnail_size <= 0) {
-			ALOGE("%s: Unable to create jpeg thumbnail without an YUV buffer", __func__);
-			goto error;
-		}
-
-		width = smdk4x12_camera->jpeg_thumbnail_width;
-		height = smdk4x12_camera->jpeg_thumbnail_height;
-		format = yuv_thumbnail_buffer->format;
-
-		buffer_width = yuv_thumbnail_buffer->width;
-		buffer_height = yuv_thumbnail_buffer->height;
-		buffer_format = yuv_thumbnail_buffer->format;
-		buffer_address = yuv_thumbnail_buffer->address;
-
-		if (width != buffer_width && height != buffer_height) {
-			format = SMDK4x12_CAMERA_PICTURE_OUTPUT_FORMAT;
-
-			memset(&output, 0, sizeof(output));
-			output.v4l2_id = 2;
-			output.width = width;
-			output.height = height;
-			output.format = format;
-			output.buffer_width = buffer_width;
-			output.buffer_height = buffer_height;
-			output.buffer_format = buffer_format;
-			output.buffers_count = 1;
-
-			rc = smdk4x12_v4l2_output_start(smdk4x12_camera, &output);
-			if (rc < 0) {
-				ALOGE("%s: Unable to start thumbnail picture output", __func__);
-				goto error;
-			}
-
-			output_enabled = 1;
-
-			rc = smdk4x12_v4l2_output(smdk4x12_camera, &output, buffer_address);
-			if (rc < 0) {
-				ALOGE("%s: Unable to output thumbnail picture", __func__);
-				goto error;
-			}
-
-			yuv_thumbnail_data = output.memory->data;
-			yuv_thumbnail_address = output.memory_address;
-			yuv_thumbnail_size = output.buffer_length;
-		}
-
-		memset(&jpeg, 0, sizeof(jpeg));
-		jpeg.width = width;
-		jpeg.height = height;
-		jpeg.format = format;
-		jpeg.quality = smdk4x12_camera->jpeg_thumbnail_quality;
-
-		rc = smdk4x12_jpeg_start(smdk4x12_camera, &jpeg);
-		if (rc < 0) {
-			ALOGE("%s: Unable to start jpeg", __func__);
-			goto error;
-		}
-
-		if (jpeg.memory_in_pointer == NULL) {
-			ALOGE("%s: Invalid memory input pointer", __func__);
-			goto error;
-		}
-
-		memcpy(jpeg.memory_in_pointer, yuv_thumbnail_data, yuv_thumbnail_size);
-
-		rc = smdk4x12_jpeg(smdk4x12_camera, &jpeg);
-		if (rc < 0) {
-			ALOGE("%s: Unable to jpeg", __func__);
-			goto error;
-		}
-
-		jpeg_thumbnail_size = jpeg.memory_out_size;
-		if (jpeg_thumbnail_size <= 0) {
-			ALOGE("%s: Invalid jpeg size", __func__);
-			goto error;
-		}
-
-		if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) {
-			jpeg_thumbnail_memory = smdk4x12_camera->callbacks.request_memory(-1, jpeg_thumbnail_size, 1, smdk4x12_camera->callbacks.user);
-			if (jpeg_thumbnail_memory == NULL || jpeg_thumbnail_memory->data == NULL || jpeg_thumbnail_memory->data == MAP_FAILED) {
-				ALOGE("%s: Unable to request memory", __func__);
-				goto error;
-			}
-		} else {
-			ALOGE("%s: No memory request function!", __func__);
-			goto error;
-		}
-
-		jpeg_thumbnail_data = jpeg_thumbnail_memory->data;
-
-		memcpy(jpeg_thumbnail_data, jpeg.memory_out_pointer, jpeg_thumbnail_size);
-
-		smdk4x12_jpeg_stop(smdk4x12_camera, &jpeg);
-
-		if (output_enabled) {
-			smdk4x12_v4l2_output_stop(smdk4x12_camera, &output);
-			output_enabled = 0;
-		}
-	}
-
-	ALOGE("%s: Thumbnail finished", __func__);
-
-	// EXIF
-
-	memset(&exif, 0, sizeof(exif));
-	exif.jpeg_thumbnail_data = jpeg_thumbnail_data;
-	exif.jpeg_thumbnail_size = jpeg_thumbnail_size;
-
-	rc = smdk4x12_exif_start(smdk4x12_camera, &exif);
-	if (rc < 0) {
-		ALOGE("%s: Unable to start exif", __func__);
-		goto error;
-	}
-
-	rc = smdk4x12_exif(smdk4x12_camera, &exif);
-	if (rc < 0) {
-		ALOGE("%s: Unable to exif", __func__);
-		goto error;
-	}
-
-	memory_size = exif.memory_size + jpeg_size;
-
-	if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) {
-		memory = smdk4x12_camera->callbacks.request_memory(-1, memory_size, 1, smdk4x12_camera->callbacks.user);
-		if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) {
-			ALOGE("%s: Unable to request memory", __func__);
-			goto error;
-		}
-	} else {
-		ALOGE("%s: No memory request function!", __func__);
-		goto error;
-	}
-
-	ALOGE("%s: exif finished", __func__);
-
-	p = (unsigned char *) memory->data;
-
-	// Copy the first two bytes of the JPEG picture
-	memcpy(p, jpeg_data, 2);
-	p += 2;
-
-	// Copy the EXIF data
-	memcpy(p, exif.memory->data, exif.memory_size);
-	p += exif.memory_size;
-
-	// Copy the JPEG picture
-	memcpy(p, (void *) ((unsigned char *) jpeg_data + 2), jpeg_size - 2);
-
-	smdk4x12_exif_stop(smdk4x12_camera, &exif);
-
-	smdk4x12_camera->picture_memory = memory;
-
-	rc = 0;
-	goto complete;
-
-error:
-	if (output_enabled)
-		smdk4x12_v4l2_output_stop(smdk4x12_camera, &output);
-
-	if (memory != NULL && memory->release != NULL) {
-		memory->release(memory);
-		smdk4x12_camera->picture_memory = NULL;
-	}
-
-	if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_ERROR) && SMDK4x12_CAMERA_CALLBACK_DEFINED(notify) && !smdk4x12_camera->callback_lock)
-		smdk4x12_camera->callbacks.notify(CAMERA_MSG_ERROR, -1, 0, smdk4x12_camera->callbacks.user);
-
-	rc = -1;
-
-complete:
-	if (jpeg_memory != NULL && jpeg_memory->release != NULL)
-		jpeg_memory->release(jpeg_memory);
-
-	if (jpeg_thumbnail_memory != NULL && jpeg_thumbnail_memory->release != NULL)
-		jpeg_thumbnail_memory->release(jpeg_thumbnail_memory);
-
-	smdk4x12_camera->picture_completed = 1;
-	smdk4x12_camera->picture_listener->busy = 0;
-
-	return rc;
-}
-
-void *smdk4x12_camera_picture_thread(void *data)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-	int rc;
-
-	if (data == NULL)
-		return NULL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) data;
-
-	ALOGE("%s: Starting thread", __func__);
-	smdk4x12_camera->picture_thread_running = 1;
-
-	while (smdk4x12_camera->picture_thread_enabled) {
-	        ALOGE("%s: in while loop", __func__);
-		pthread_mutex_lock(&smdk4x12_camera->picture_lock_mutex);
-		ALOGE("%s: lock_mutex locked", __func__);
-		pthread_mutex_lock(&smdk4x12_camera->picture_mutex);
-		ALOGE("%s: picture_mutex locked", __func__);
-
-		if (smdk4x12_camera->picture_listener == NULL) {
-		        ALOGE("%s: no listener", __func__);
-			pthread_mutex_unlock(&smdk4x12_camera->picture_mutex);
-			break;
-		}
-
-		if (smdk4x12_camera->picture_listener->busy) {
-		        ALOGE("%s: listener busy", __func__);
-			rc = smdk4x12_camera_picture(smdk4x12_camera);
-			if (rc < 0) {
-				ALOGE("%s: Unable to take picture", __func__);
-				pthread_mutex_unlock(&smdk4x12_camera->picture_mutex);
-				break;
-			}
-		}
-
-		pthread_mutex_unlock(&smdk4x12_camera->picture_mutex);
-		ALOGE("%s: picture_mutex unlocked", __func__);
-
-		if (smdk4x12_camera->picture_completed) {
-		        ALOGE("%s: picture completed", __func__);
-			smdk4x12_camera->picture_thread_running = 0;
-			smdk4x12_camera_picture_thread_stop(smdk4x12_camera);
-			break;
-		}
-		ALOGE("%s: still while loop", __func__);
-	}
-
-	smdk4x12_camera->picture_thread_running = 0;
-	ALOGE("%s: Exiting thread", __func__);
-
-	return NULL;
-}
-
-int smdk4x12_camera_picture_thread_start(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_camera_capture_listener *listener;
-	pthread_attr_t thread_attr;
-	int format;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	ALOGD("%s()", __func__);
-
-	if (smdk4x12_camera->picture_thread_enabled) {
-		ALOGE("Picture thread was already started!");
-		return -1;
-	}
-
-	if (smdk4x12_camera->camera_picture_format)
-		format = smdk4x12_camera->camera_picture_format;
-	else
-		format = smdk4x12_camera->picture_format;
-
-	pthread_mutex_init(&smdk4x12_camera->picture_mutex, NULL);
-	pthread_mutex_init(&smdk4x12_camera->picture_lock_mutex, NULL);
-
-	// Initial lock
-	pthread_mutex_lock(&smdk4x12_camera->picture_lock_mutex);
-
-	pthread_attr_init(&thread_attr);
-	pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
-
-	smdk4x12_camera->picture_thread_enabled = 1;
-
-	rc = pthread_create(&smdk4x12_camera->picture_thread, &thread_attr, smdk4x12_camera_picture_thread, (void *) smdk4x12_camera);
-	if (rc < 0) {
-		ALOGE("%s: Unable to create thread", __func__);
-		goto error;
-	}
-
-	smdk4x12_camera->picture_completed = 0;
-
-	listener = smdk4x12_camera_capture_listener_register(smdk4x12_camera, smdk4x12_camera->picture_width, smdk4x12_camera->picture_height, format, smdk4x12_camera_picture_callback);
-	if (listener == NULL) {
-		ALOGE("%s: Unable to register picture capture listener", __func__);
-		goto error;
-	}
-
-	smdk4x12_camera->picture_listener = listener;
-
-	rc = 0;
-	goto complete;
-
-error:
-	pthread_mutex_destroy(&smdk4x12_camera->picture_mutex);
-	pthread_mutex_destroy(&smdk4x12_camera->picture_lock_mutex);
-
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-void smdk4x12_camera_picture_thread_stop(struct smdk4x12_camera *smdk4x12_camera)
-{
-	camera_memory_t *memory;
-	int i;
-
-	if (smdk4x12_camera == NULL)
-		return;
-
-	ALOGD("%s()", __func__);
-
-	if (!smdk4x12_camera->picture_thread_enabled) {
-		ALOGE("Picture thread was already stopped!");
-		return;
-	}
-
-	memory = smdk4x12_camera->picture_memory;
-
-	if (smdk4x12_camera->picture_listener != NULL) {
-		smdk4x12_camera_capture_listener_unregister(smdk4x12_camera, smdk4x12_camera->picture_listener);
-		smdk4x12_camera->picture_listener = NULL;
-	}
-
-	smdk4x12_camera->picture_thread_enabled = 0;
-
-	pthread_mutex_unlock(&smdk4x12_camera->picture_lock_mutex);
-
-	// Wait for the thread to end
-	i = 0;
-	while (smdk4x12_camera->picture_thread_running) {
-		if (i++ > 10000) {
-			ALOGE("Picture thread is taking too long to end, something is going wrong");
-			break;
-		}
-		usleep(100);
-	}
-
-	if (smdk4x12_camera->picture_enabled) {
-		pthread_mutex_lock(&smdk4x12_camera->picture_mutex);
-		smdk4x12_camera->picture_enabled = 0;
-		pthread_mutex_unlock(&smdk4x12_camera->picture_mutex);
-	}
-
-	pthread_mutex_destroy(&smdk4x12_camera->picture_mutex);
-	pthread_mutex_destroy(&smdk4x12_camera->picture_lock_mutex);
-
-	if (smdk4x12_camera->picture_completed && memory != NULL) {
-		// It is important to return at this point (and not before) for burst
-
-		if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_SHUTTER) && SMDK4x12_CAMERA_CALLBACK_DEFINED(notify) && !smdk4x12_camera->callback_lock)
-			smdk4x12_camera->callbacks.notify(CAMERA_MSG_SHUTTER, 0, 0, smdk4x12_camera->callbacks.user);
-
-		if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_COMPRESSED_IMAGE) && SMDK4x12_CAMERA_CALLBACK_DEFINED(data) && !smdk4x12_camera->callback_lock)
-			smdk4x12_camera->callbacks.data(CAMERA_MSG_COMPRESSED_IMAGE, memory, 0, NULL, smdk4x12_camera->callbacks.user);
-
-		if (memory->release != NULL) {
-			memory->release(memory);
-			smdk4x12_camera->picture_memory = NULL;
-		}
-	}
-}
-
-// Recording
-
-int smdk4x12_camera_recording_output_start(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_v4l2_output *output;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	ALOGD("%s()", __func__);
-
-	if (smdk4x12_camera->recording_output_enabled) {
-		ALOGE("Recording was already started!");
-		return -1;
-	}
-
-	output = &smdk4x12_camera->recording_output;
-
-	memset(output, 0, sizeof(struct smdk4x12_v4l2_output));
-	output->v4l2_id = 3;
-	output->width = smdk4x12_camera->recording_width;
-	output->height = smdk4x12_camera->recording_height;
-	output->format = smdk4x12_camera->recording_format;
-	output->buffer_width = smdk4x12_camera->recording_buffer.width;
-	output->buffer_height = smdk4x12_camera->recording_buffer.height;
-	output->buffer_format = smdk4x12_camera->recording_buffer.format;
-	output->buffers_count = SMDK4x12_CAMERA_RECORDING_BUFFERS_COUNT;
-
-	rc = smdk4x12_v4l2_output_start(smdk4x12_camera, output);
-	if (rc < 0) {
-		ALOGE("%s: Unable to start recording output", __func__);
-		goto error;
-	}
-
-	smdk4x12_camera->recording_output_enabled = 1;
-
-	rc = 0;
-	goto complete;
-
-error:
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-void smdk4x12_camera_recording_output_stop(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_v4l2_output *output;
-
-	if (smdk4x12_camera == NULL)
-		return;
-
-	ALOGD("%s()", __func__);
-
-	if (!smdk4x12_camera->recording_output_enabled) {
-		ALOGE("Recording was already stopped!");
-		return;
-	}
-
-	output = &smdk4x12_camera->recording_output;
-
-	smdk4x12_v4l2_output_stop(smdk4x12_camera, output);
-
-	smdk4x12_camera->recording_output_enabled = 0;
-}
-
-int smdk4x12_camera_recording_callback(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_camera_buffer *buffers, int buffers_count)
-{
-	struct smdk4x12_camera_buffer *buffer = NULL;
-	int width, height, format;
-	int buffer_width, buffer_height, buffer_format;
-	int rc;
-	int i;
-
-	if (smdk4x12_camera == NULL || buffers == NULL || buffers_count <= 0)
-		return -EINVAL;
-
-//	ALOGD("%s()", __func__);
-
-	if (smdk4x12_camera->recording_listener == NULL)
-		return -1;
-
-	if (smdk4x12_camera->recording_listener->busy) {
-		ALOGE("%s: Dropping buffer", __func__);
-		return 0;
-	}
-
-	smdk4x12_camera->recording_listener->busy = 1;
-
-	width = smdk4x12_camera->recording_width;
-	height = smdk4x12_camera->recording_height;
-	format = smdk4x12_camera->recording_format;
-
-	for (i = 0; i < buffers_count; i++) {
-		if (buffers->format == V4L2_PIX_FMT_JPEG)
-			goto buffers_continue;
-
-		if (buffers->format == V4L2_PIX_FMT_INTERLEAVED)
-			goto buffers_continue;
-
-		// Optimal buffer
-		if (buffers->width == width && buffers->height == height) {
-			buffer = buffers;
-			break;
-		}
-
-		// Might-work buffer, but not optimal
-		buffer = buffers;
-
-buffers_continue:
-		buffers = (struct smdk4x12_camera_buffer *) ((unsigned char *) buffers + sizeof(struct smdk4x12_camera_buffer));
-	}
-
-	if (buffer == NULL) {
-		ALOGE("%s: Unable to find an appropriate buffer for recording", __func__);
-		smdk4x12_camera->recording_listener->busy = 0;
-		return 0;
-	}
-
-	buffer_width = buffer->width;
-	buffer_height = buffer->height;
-	buffer_format = buffer->format;
-
-	pthread_mutex_lock(&smdk4x12_camera->recording_mutex);
-
-	if (!smdk4x12_camera->recording_output_enabled) {
-		memcpy(&smdk4x12_camera->recording_buffer, buffer, sizeof(struct smdk4x12_camera_buffer));
-
-		rc = smdk4x12_camera_recording_output_start(smdk4x12_camera);
-		if (rc < 0) {
-			ALOGE("%s: Unable to start recording", __func__);
-			goto error;
-		}
-	} else if (smdk4x12_camera->recording_buffer.width != buffer_width || smdk4x12_camera->recording_buffer.height != buffer_height || smdk4x12_camera->recording_buffer.format != buffer_format) {
-		smdk4x12_camera_recording_output_stop(smdk4x12_camera);
-
-		memcpy(&smdk4x12_camera->recording_buffer, buffer, sizeof(struct smdk4x12_camera_buffer));
-
-		rc = smdk4x12_camera_recording_output_start(smdk4x12_camera);
-		if (rc < 0) {
-			ALOGE("%s: Unable to start recording", __func__);
-			goto error;
-		}
-	} else {
-		memcpy(&smdk4x12_camera->recording_buffer, buffer, sizeof(struct smdk4x12_camera_buffer));
-	}
-
-	pthread_mutex_unlock(&smdk4x12_camera->recording_lock_mutex);
-
-	pthread_mutex_unlock(&smdk4x12_camera->recording_mutex);
-
-	rc = 0;
-	goto complete;
-
-error:
-	pthread_mutex_unlock(&smdk4x12_camera->recording_mutex);
-
-	smdk4x12_camera->recording_listener->busy = 0;
-
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-void smdk4x12_camera_recording_frame_release(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_v4l2_output *output;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return;
-
-//	ALOGD("%s()", __func__);
-
-	output = &smdk4x12_camera->recording_output;
-
-	if (!smdk4x12_camera->recording_output_enabled) {
-		ALOGE("%s: Recording output should always be enabled", __func__);
-		return;
-	}
-
-	rc = smdk4x12_v4l2_output_release(smdk4x12_camera, output);
-	if (rc < 0) {
-		ALOGE("%s: Unable to release recording output", __func__);
-		return;
-	}
-}
-
-int smdk4x12_camera_recording(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_v4l2_output *output;
-	struct smdk4x12_camera_addrs *addrs;
-	int width, height, format;
-	camera_memory_t *memory;
-	int memory_address;
-	int memory_index;
-	int buffer_length;
-	int buffers_count;
-	nsecs_t timestamp;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		goto error;
-
-//	ALOGD("%s()", __func__);
-
-	width = smdk4x12_camera->recording_width;
-	height = smdk4x12_camera->recording_height;
-	format = smdk4x12_camera->recording_format;
-
-	output = &smdk4x12_camera->recording_output;
-
-	buffer_length = smdk4x12_camera->recording_buffer_length;
-	buffers_count = smdk4x12_camera->recording_buffers_count;
-
-	timestamp = systemTime(1);
-
-	if (!smdk4x12_camera->recording_output_enabled) {
-		ALOGE("%s: Recording output should always be enabled", __func__);
-		goto error;
-	}
-
-	rc = smdk4x12_v4l2_output(smdk4x12_camera, output, smdk4x12_camera->recording_buffer.address);
-	if (rc < 0) {
-		ALOGE("%s: Unable to output recording", __func__);
-		goto error;
-	}
-
-	if (smdk4x12_camera->recording_metadata) {
-		memory = smdk4x12_camera->recording_memory;
-		memory_index = smdk4x12_camera->recording_memory_index;
-		memory_address = output->memory_address + output->buffer_length * output->memory_index;
-
-		addrs = (struct smdk4x12_camera_addrs *) ((unsigned char *) memory->data + buffer_length * memory_index);
-		memset(addrs, 0, sizeof(struct smdk4x12_camera_addrs));
-		addrs->type = 0; // kMetadataBufferTypeCameraSource
-		addrs->index = memory_index;
-
-		smdk4x12_camera_yuv_planes(width, height, format, memory_address, (int *) &addrs->y, (int *) &addrs->cbcr, NULL);
-	} else {
-		memory = output->memory;
-		memory_index = output->memory_index;
-	}
-
-	if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_VIDEO_FRAME) && SMDK4x12_CAMERA_CALLBACK_DEFINED(data_timestamp) && !smdk4x12_camera->callback_lock)
-		smdk4x12_camera->callbacks.data_timestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, memory, memory_index, smdk4x12_camera->callbacks.user);
-	else
-		smdk4x12_camera_recording_frame_release(smdk4x12_camera);
-
-	if (smdk4x12_camera->recording_metadata) {
-		memory_index++;
-		smdk4x12_camera->recording_memory_index = memory_index % buffers_count;
-	}
-
-	rc = 0;
-	goto complete;
-
-error:
-	rc = -1;
-
-complete:
-	smdk4x12_camera->recording_listener->busy = 0;
-
-	return rc;
-}
-
-void *smdk4x12_camera_recording_thread(void *data)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-	int rc;
-
-	if (data == NULL)
-		return NULL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) data;
-
-	ALOGE("%s: Starting thread", __func__);
-	smdk4x12_camera->recording_thread_running = 1;
-
-	while (smdk4x12_camera->recording_thread_enabled) {
-		pthread_mutex_lock(&smdk4x12_camera->recording_lock_mutex);
-
-		pthread_mutex_lock(&smdk4x12_camera->recording_mutex);
-
-		if (smdk4x12_camera->recording_listener == NULL) {
-			pthread_mutex_unlock(&smdk4x12_camera->recording_mutex);
-			break;
-		}
-
-		if (smdk4x12_camera->recording_listener->busy) {
-			rc = smdk4x12_camera_recording(smdk4x12_camera);
-			if (rc < 0) {
-				ALOGE("%s: Unable to record", __func__);
-				pthread_mutex_unlock(&smdk4x12_camera->recording_mutex);
-				break;
-			}
-		}
-
-		pthread_mutex_unlock(&smdk4x12_camera->recording_mutex);
-	}
-
-	smdk4x12_camera->recording_thread_running = 0;
-	ALOGE("%s: Exiting thread", __func__);
-
-	return NULL;
-}
-
-int smdk4x12_camera_recording_thread_start(struct smdk4x12_camera *smdk4x12_camera)
-{
-	struct smdk4x12_camera_capture_listener *listener;
-	pthread_attr_t thread_attr;
-	camera_memory_t *memory = NULL;
-	int buffer_length;
-	int buffers_count;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	ALOGD("%s()", __func__);
-
-	if (smdk4x12_camera->recording_thread_enabled) {
-		ALOGE("Recording thread was already started!");
-		return -1;
-	}
-
-	pthread_mutex_init(&smdk4x12_camera->recording_mutex, NULL);
-	pthread_mutex_init(&smdk4x12_camera->recording_lock_mutex, NULL);
-
-	// Initial lock
-	pthread_mutex_lock(&smdk4x12_camera->recording_lock_mutex);
-
-	pthread_attr_init(&thread_attr);
-	pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
-
-	smdk4x12_camera->recording_thread_enabled = 1;
-
-	rc = pthread_create(&smdk4x12_camera->recording_thread, &thread_attr, smdk4x12_camera_recording_thread, (void *) smdk4x12_camera);
-	if (rc < 0) {
-		ALOGE("%s: Unable to create thread", __func__);
-		goto error;
-	}
-
-	if (smdk4x12_camera->recording_metadata) {
-		buffer_length = sizeof(struct smdk4x12_camera_addrs);
-		buffers_count = SMDK4x12_CAMERA_RECORDING_BUFFERS_COUNT;
-
-		if (SMDK4x12_CAMERA_CALLBACK_DEFINED(request_memory)) {
-			memory = smdk4x12_camera->callbacks.request_memory(-1, buffer_length, buffers_count, smdk4x12_camera->callbacks.user);
-			if (memory == NULL || memory->data == NULL || memory->data == MAP_FAILED) {
-				ALOGE("%s: Unable to request memory", __func__);
-				goto error;
-			}
-		} else {
-			ALOGE("%s: No memory request function!", __func__);
-			goto error;
-		}
-
-		smdk4x12_camera->recording_memory = memory;
-		smdk4x12_camera->recording_buffer_length = buffer_length;
-		smdk4x12_camera->recording_buffers_count = buffers_count;
-	}
-
-	listener = smdk4x12_camera_capture_listener_register(smdk4x12_camera, smdk4x12_camera->recording_width, smdk4x12_camera->recording_height, smdk4x12_camera->recording_format, smdk4x12_camera_recording_callback);
-	if (listener == NULL) {
-		ALOGE("%s: Unable to register recording capture listener", __func__);
-		goto error;
-	}
-
-	smdk4x12_camera->recording_listener = listener;
-
-	rc = 0;
-	goto complete;
-
-error:
-	if (memory != NULL && memory->release != NULL) {
-		memory->release(memory);
-		smdk4x12_camera->recording_memory = NULL;
-	}
-
-	pthread_mutex_destroy(&smdk4x12_camera->recording_mutex);
-	pthread_mutex_destroy(&smdk4x12_camera->recording_lock_mutex);
-
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-void smdk4x12_camera_recording_thread_stop(struct smdk4x12_camera *smdk4x12_camera)
-{
-	camera_memory_t *memory;
-	int i;
-
-	if (smdk4x12_camera == NULL)
-		return;
-
-	ALOGD("%s()", __func__);
-
-	if (!smdk4x12_camera->recording_thread_enabled) {
-		ALOGE("Recording thread was already stopped!");
-		return;
-	}
-
-	memory = smdk4x12_camera->recording_memory;
-
-	if (smdk4x12_camera->recording_listener != NULL) {
-		smdk4x12_camera_capture_listener_unregister(smdk4x12_camera, smdk4x12_camera->recording_listener);
-		smdk4x12_camera->recording_listener = NULL;
-	}
-
-	smdk4x12_camera->recording_thread_enabled = 0;
-
-	pthread_mutex_unlock(&smdk4x12_camera->recording_lock_mutex);
-
-	// Wait for the thread to end
-	i = 0;
-	while (smdk4x12_camera->recording_thread_running) {
-		if (i++ > 10000) {
-			ALOGE("Recording thread is taking too long to end, something is going wrong");
-			break;
-		}
-		usleep(100);
-	}
-
-	if (smdk4x12_camera->recording_output_enabled) {
-		pthread_mutex_lock(&smdk4x12_camera->recording_mutex);
-		smdk4x12_camera_recording_output_stop(smdk4x12_camera);
-		pthread_mutex_unlock(&smdk4x12_camera->recording_mutex);
-	}
-
-	pthread_mutex_destroy(&smdk4x12_camera->recording_mutex);
-	pthread_mutex_destroy(&smdk4x12_camera->recording_lock_mutex);
-
-	if (memory != NULL && memory->release != NULL) {
-		memory->release(memory);
-		smdk4x12_camera->recording_memory = NULL;
-	}
-}
-
-// Auto-focus
-
-int smdk4x12_camera_auto_focus(struct smdk4x12_camera *smdk4x12_camera, int auto_focus_status)
-{
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-//	ALOGD("%s()", __func__);
-
-	switch (auto_focus_status) {
-		case CAMERA_AF_STATUS_IN_PROGRESS:
-			if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS_MOVE) && SMDK4x12_CAMERA_CALLBACK_DEFINED(notify) && !smdk4x12_camera->callback_lock)
-				smdk4x12_camera->callbacks.notify(CAMERA_MSG_FOCUS_MOVE, 1, 0, smdk4x12_camera->callbacks.user);
-			break;
-		case CAMERA_AF_STATUS_SUCCESS:
-			if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS) && SMDK4x12_CAMERA_CALLBACK_DEFINED(notify) && !smdk4x12_camera->callback_lock)
-				smdk4x12_camera->callbacks.notify(CAMERA_MSG_FOCUS, 1, 0, smdk4x12_camera->callbacks.user);
-			break;
-		case CAMERA_AF_STATUS_FAIL:
-		default:
-			if (SMDK4x12_CAMERA_MSG_ENABLED(CAMERA_MSG_FOCUS) && SMDK4x12_CAMERA_CALLBACK_DEFINED(notify) && !smdk4x12_camera->callback_lock)
-				smdk4x12_camera->callbacks.notify(CAMERA_MSG_FOCUS, 0, 0, smdk4x12_camera->callbacks.user);
-			break;
-	}
-
-	return 0;
-}
-
-void *smdk4x12_camera_auto_focus_thread(void *data)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-	int auto_focus_result = CAMERA_AF_STATUS_FAIL;
-	int auto_focus_completed = 0;
-	int rc;
-
-	if (data == NULL)
-		return NULL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) data;
-
-	ALOGE("%s: Starting thread", __func__);
-	smdk4x12_camera->auto_focus_thread_running = 1;
-
-	if (smdk4x12_camera->focus_mode == FOCUS_MODE_CONTINOUS_PICTURE) {
-		rc = smdk4x12_camera_auto_focus(smdk4x12_camera, smdk4x12_camera->auto_focus_result);
-		if (rc < 0)
-			ALOGE("%s: Unable to auto-focus", __func__);
-
-		smdk4x12_camera->auto_focus_thread_enabled = 0;
-	}
-
-	while (smdk4x12_camera->auto_focus_thread_enabled) {
-		pthread_mutex_lock(&smdk4x12_camera->auto_focus_mutex);
-
-		rc = smdk4x12_v4l2_g_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT, &auto_focus_result);
-		if (rc < 0) {
-			ALOGE("%s: Unable to get auto-focus result", __func__);
-			auto_focus_result = CAMERA_AF_STATUS_FAIL;
-		}
-
-		smdk4x12_camera->auto_focus_result = auto_focus_result;
-
-		rc = smdk4x12_camera_auto_focus(smdk4x12_camera, auto_focus_result);
-		if (rc < 0) {
-			ALOGE("%s: Unable to auto-focus", __func__);
-			auto_focus_result = CAMERA_AF_STATUS_FAIL;
-		}
-
-		if (auto_focus_result == CAMERA_AF_STATUS_IN_PROGRESS)
-			usleep(10000);
-		else
-			auto_focus_completed = 1;
-
-		pthread_mutex_unlock(&smdk4x12_camera->auto_focus_mutex);
-
-		if (auto_focus_completed) {
-			smdk4x12_camera->auto_focus_thread_running = 0;
-			smdk4x12_camera_auto_focus_thread_stop(smdk4x12_camera);
-		}
-	}
-
-	smdk4x12_camera->auto_focus_thread_running = 0;
-	ALOGE("%s: Exiting thread", __func__);
-
-	return NULL;
-}
-
-int smdk4x12_camera_auto_focus_thread_start(struct smdk4x12_camera *smdk4x12_camera)
-{
-	pthread_attr_t thread_attr;
-	int auto_focus;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	ALOGD("%s()", __func__);
-
-	if (smdk4x12_camera->auto_focus_thread_enabled) {
-		ALOGE("Auto-focus thread was already started!");
-		return -1;
-	}
-
-	pthread_mutex_init(&smdk4x12_camera->auto_focus_mutex, NULL);
-
-	if (smdk4x12_camera->focus_mode != FOCUS_MODE_CONTINOUS_PICTURE) {
-		auto_focus = AUTO_FOCUS_ON | (smdk4x12_camera->preview_width & 0xfff) << 20 | (smdk4x12_camera->preview_height & 0xfff) << 8;
-
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_SET_AUTO_FOCUS, auto_focus);
-		if (rc < 0) {
-			ALOGE("%s: Unable to set auto-focus on", __func__);
-			goto error;
-		}
-	}
-
-	pthread_attr_init(&thread_attr);
-	pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
-
-	smdk4x12_camera->auto_focus_thread_enabled = 1;
-
-	rc = pthread_create(&smdk4x12_camera->auto_focus_thread, &thread_attr, smdk4x12_camera_auto_focus_thread, (void *) smdk4x12_camera);
-	if (rc < 0) {
-		ALOGE("%s: Unable to create thread", __func__);
-		goto error;
-	}
-
-	rc = 0;
-	goto complete;
-
-error:
-	pthread_mutex_destroy(&smdk4x12_camera->auto_focus_mutex);
-
-	rc = -1;
-
-complete:
-	return rc;
-}
-
-void smdk4x12_camera_auto_focus_thread_stop(struct smdk4x12_camera *smdk4x12_camera)
-{
-	int rc;
-	int i;
-
-	if (smdk4x12_camera == NULL)
-		return;
-
-	ALOGD("%s()", __func__);
-
-	if (!smdk4x12_camera->auto_focus_thread_enabled) {
-		ALOGE("Auto-focus thread was already stopped!");
-		return;
-	}
-
-	smdk4x12_camera->auto_focus_thread_enabled = 0;
-
-	// Wait for the thread to end
-	i = 0;
-	while (smdk4x12_camera->auto_focus_thread_running) {
-		if (i++ > 10000) {
-			ALOGE("Auto-focus thread is taking too long to end, something is going wrong");
-			break;
-		}
-		usleep(100);
-	}
-	if (smdk4x12_camera->focus_mode != FOCUS_MODE_CONTINOUS_PICTURE) {
-		rc = smdk4x12_v4l2_s_ctrl(smdk4x12_camera, 0, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF);
-		if (rc < 0)
-			ALOGE("%s: Unable to set auto-focus off", __func__);
-	}
-
-	pthread_mutex_destroy(&smdk4x12_camera->auto_focus_mutex);
-}
-
-/*
- * SMDK4x12 Camera OPS
- */
-
-int smdk4x12_camera_set_preview_window(struct camera_device *device,
-	struct preview_stream_ops *w)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	int width, height, format, gralloc_format;
-
-	buffer_handle_t *buffer;
-	int stride;
-	void *addr = NULL;
-
-	int rc;
-
-	ALOGD("%s(%p, %p)", __func__, device, w);
-
-	if (device == NULL || device->priv == NULL)
-		return -EINVAL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	if (smdk4x12_camera->preview_thread_enabled)
-		pthread_mutex_lock(&smdk4x12_camera->preview_mutex);
-
-	if (w == NULL) {
-		smdk4x12_camera->preview_window = NULL;
-		return 0;
-	}
-
-	if (w->set_buffer_count == NULL || w->set_usage == NULL || w->set_buffers_geometry == NULL)
-		goto error;
-
-	rc = w->set_buffer_count(w, SMDK4x12_CAMERA_GRALLOC_BUFFERS_COUNT);
-	if (rc) {
-		ALOGE("%s: Unable to set buffer count: %d", __func__, SMDK4x12_CAMERA_GRALLOC_BUFFERS_COUNT);
-		goto error;
-	}
-
-	rc = w->set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN);
-	if (rc) {
-		ALOGE("%s: Unable to set usage", __func__);
-		goto error;
-	}
-
-	width = smdk4x12_camera->preview_width;
-	height = smdk4x12_camera->preview_height;
-	format = smdk4x12_camera->preview_format;
-
-	gralloc_format = smdk4x12_gralloc_format(format);
-
-	rc = w->set_buffers_geometry(w, width, height, gralloc_format);
-	if (rc) {
-		ALOGE("%s: Unable to set buffers geometry", __func__);
-		goto error;
-	}
-
-	smdk4x12_camera->preview_window = w;
-
-	rc = 0;
-	goto complete;
-
-error:
-	smdk4x12_camera->preview_window = NULL;
-	rc = -1;
-
-complete:
-	if (smdk4x12_camera->preview_thread_enabled)
-		pthread_mutex_unlock(&smdk4x12_camera->preview_mutex);
-
-	return rc;
-}
-
-void smdk4x12_camera_set_callbacks(struct camera_device *device,
-	camera_notify_callback notify_cb,
-	camera_data_callback data_cb,
-	camera_data_timestamp_callback data_cb_timestamp,
-	camera_request_memory get_memory,
-	void *user)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p, %p)", __func__, device, user);
-
-	if (device == NULL || device->priv == NULL)
-		return;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera->callbacks.notify = notify_cb;
-	smdk4x12_camera->callbacks.data = data_cb;
-	smdk4x12_camera->callbacks.data_timestamp = data_cb_timestamp;
-	smdk4x12_camera->callbacks.request_memory = get_memory;
-	smdk4x12_camera->callbacks.user = user;
-}
-
-void smdk4x12_camera_enable_msg_type(struct camera_device *device,
-	int32_t msg_type)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p, %d)", __func__, device, msg_type);
-
-	if (device == NULL || device->priv == NULL)
-		return;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera->messages_enabled |= msg_type;
-}
-
-void smdk4x12_camera_disable_msg_type(struct camera_device *device,
-	int32_t msg_type)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p, %d)", __func__, device, msg_type);
-
-	if (device == NULL || device->priv == NULL)
-		return;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera->messages_enabled &= ~msg_type;
-}
-
-int smdk4x12_camera_msg_type_enabled(struct camera_device *device,
-	int32_t msg_type)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p, %d)", __func__, device, msg_type);
-
-	if (device == NULL || device->priv == NULL)
-		return -EINVAL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	return smdk4x12_camera->messages_enabled & msg_type;
-}
-
-int smdk4x12_camera_start_preview(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-	int rc;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	if (device == NULL || device->priv == NULL)
-		return -EINVAL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera->callback_lock = 1;
-	rc = smdk4x12_camera_preview_thread_start(smdk4x12_camera);
-	smdk4x12_camera->callback_lock = 0;
-
-	return rc;
-}
-
-void smdk4x12_camera_stop_preview(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	if (device == NULL || device->priv == NULL)
-		return;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera->callback_lock = 1;
-	smdk4x12_camera_preview_thread_stop(smdk4x12_camera);
-	smdk4x12_camera->callback_lock = 0;
-}
-
-int smdk4x12_camera_preview_enabled(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	if (device == NULL || device->priv == NULL)
-		return -EINVAL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	return smdk4x12_camera->preview_thread_enabled;
-}
-
-int smdk4x12_camera_store_meta_data_in_buffers(struct camera_device *device,
-	int enable)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p, %d)", __func__, device, enable);
-
-	if (device == NULL || device->priv == NULL)
-		return -EINVAL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	if (!smdk4x12_camera->recording_thread_enabled)
-		smdk4x12_camera->recording_metadata = enable;
-	else
-		ALOGE("%s: Recording is running!", __func__);
-
-	return 0;
-}
-
-int smdk4x12_camera_start_recording(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-	int rc;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera->callback_lock = 1;
-	rc = smdk4x12_camera_recording_thread_start(smdk4x12_camera);
-	smdk4x12_camera->callback_lock = 0;
-
-	return rc;
-}
-
-void smdk4x12_camera_stop_recording(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera->callback_lock = 1;
-	smdk4x12_camera_recording_thread_stop(smdk4x12_camera);
-	smdk4x12_camera->callback_lock = 0;
-}
-
-int smdk4x12_camera_recording_enabled(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	if (device == NULL || device->priv == NULL)
-		return -EINVAL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	return smdk4x12_camera->recording_thread_enabled;
-}
-
-void smdk4x12_camera_release_recording_frame(struct camera_device *device,
-	const void *opaque)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-//	ALOGD("%s(%p, %p)", __func__, device, opaque);
-
-	if (device == NULL || device->priv == NULL)
-		return;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera_recording_frame_release(smdk4x12_camera);
-}
-
-int smdk4x12_camera_start_auto_focus(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	if (device == NULL || device->priv == NULL)
-		return -EINVAL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	return smdk4x12_camera_auto_focus_thread_start(smdk4x12_camera);
-}
-
-int smdk4x12_camera_cancel_auto_focus(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	if (device == NULL || device->priv == NULL)
-		return -EINVAL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera_auto_focus_thread_stop(smdk4x12_camera);
-
-	return 0;
-}
-
-int smdk4x12_camera_take_picture(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-	int rc;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	if (device == NULL || device->priv == NULL)
-		return -EINVAL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera->callback_lock = 1;
-	rc = smdk4x12_camera_picture_thread_start(smdk4x12_camera);
-	smdk4x12_camera->callback_lock = 0;
-
-	return rc;
-}
-
-int smdk4x12_camera_cancel_picture(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-	int rc;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	if (device == NULL || device->priv == NULL)
-		return -EINVAL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera->callback_lock = 1;
-	smdk4x12_camera_picture_thread_stop(smdk4x12_camera);
-	smdk4x12_camera->callback_lock = 0;
-
-	return 0;
-}
-
-int smdk4x12_camera_set_parameters(struct camera_device *device,
-	const char *params)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-	int rc;
-
-	ALOGD("%s(%p, %s)", __func__, device, params);
-
-	if (device == NULL || device->priv == NULL || params == NULL)
-		return -EINVAL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	rc = smdk4x12_params_string_set(smdk4x12_camera, (char *) params);
-	if (rc < 0) {
-		ALOGE("%s: Unable to set params string", __func__);
-		return -1;
-	}
-
-	rc = smdk4x12_camera_params_apply(smdk4x12_camera, 0);
-	if (rc < 0) {
-		ALOGE("%s: Unable to apply params", __func__);
-		return -1;
-	}
-
-	return 0;
-}
-
-char *smdk4x12_camera_get_parameters(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-	char *params;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	if (device == NULL || device->priv == NULL)
-		return NULL;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	params = smdk4x12_params_string_get(smdk4x12_camera);
-	if (params == NULL) {
-		ALOGE("%s: Couldn't find any param", __func__);
-		return strdup("");
-	}
-
-	return params;
-}
-
-void smdk4x12_camera_put_parameters(struct camera_device *device, char *params)
-{
-	ALOGD("%s(%p)", __func__, device);
-
-	if (params != NULL)
-		free(params);
-}
-
-int smdk4x12_camera_send_command(struct camera_device *device,
-	int32_t cmd, int32_t arg1, int32_t arg2)
-{
-	ALOGD("%s(%p, %d, %d, %d)", __func__, device, cmd, arg1, arg2);
-
-	return 0;
-}
-
-void smdk4x12_camera_release(struct camera_device *device)
-{
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	if (device == NULL || device->priv == NULL)
-		return;
-
-	smdk4x12_camera = (struct smdk4x12_camera *) device->priv;
-
-	smdk4x12_camera_capture_thread_stop(smdk4x12_camera);
-
-	smdk4x12_camera_stop(smdk4x12_camera);
-}
-
-int smdk4x12_camera_dump(struct camera_device *device, int fd)
-{
-	ALOGD("%s(%p, %d)", __func__, device, fd);
-
-	return 0;
-}
-
-/*
- * Interface
- */
-
-struct camera_device_ops smdk4x12_camera_ops = {
-	.set_preview_window = smdk4x12_camera_set_preview_window,
-	.set_callbacks = smdk4x12_camera_set_callbacks,
-	.enable_msg_type = smdk4x12_camera_enable_msg_type,
-	.disable_msg_type = smdk4x12_camera_disable_msg_type,
-	.msg_type_enabled = smdk4x12_camera_msg_type_enabled,
-	.start_preview = smdk4x12_camera_start_preview,
-	.stop_preview = smdk4x12_camera_stop_preview,
-	.preview_enabled = smdk4x12_camera_preview_enabled,
-	.store_meta_data_in_buffers = smdk4x12_camera_store_meta_data_in_buffers,
-	.start_recording = smdk4x12_camera_start_recording,
-	.stop_recording = smdk4x12_camera_stop_recording,
-	.recording_enabled = smdk4x12_camera_recording_enabled,
-	.release_recording_frame = smdk4x12_camera_release_recording_frame,
-	.auto_focus = smdk4x12_camera_start_auto_focus,
-	.cancel_auto_focus = smdk4x12_camera_cancel_auto_focus,
-	.take_picture = smdk4x12_camera_take_picture,
-	.cancel_picture = smdk4x12_camera_cancel_picture,
-	.set_parameters = smdk4x12_camera_set_parameters,
-	.get_parameters = smdk4x12_camera_get_parameters,
-	.put_parameters = smdk4x12_camera_put_parameters,
-	.send_command = smdk4x12_camera_send_command,
-	.release = smdk4x12_camera_release,
-	.dump = smdk4x12_camera_dump,
-};
-
-int smdk4x12_camera_close(hw_device_t *device)
-{
-	struct camera_device *camera_device;
-	struct smdk4x12_camera *smdk4x12_camera;
-
-	ALOGD("%s(%p)", __func__, device);
-
-	if (device == NULL)
-		return -EINVAL;
-
-	camera_device = (struct camera_device *) device;
-
-	if (camera_device->priv != NULL) {
-		free(camera_device->priv);
-	}
-
-	free(camera_device);
-
-	return 0;
-}
-
-int smdk4x12_camera_open(const struct hw_module_t* module, const char *camera_id,
-	struct hw_device_t** device)
-{
-	struct camera_device *camera_device = NULL;
-	struct smdk4x12_camera *smdk4x12_camera = NULL;
-	int id;
-	int rc;
-
-	ALOGD("%s(%p, %s, %p)", __func__, module, camera_id, device);
-
-	if (module == NULL || camera_id == NULL || device == NULL)
-		return -EINVAL;
-
-	id = atoi(camera_id);
-	if (id < 0)
-		return -EINVAL;
-
-	smdk4x12_camera = calloc(1, sizeof(struct smdk4x12_camera));
-	smdk4x12_camera->config = smdk4x12_camera_config;
-
-	if (smdk4x12_camera->config->v4l2_nodes_count > SMDK4x12_CAMERA_MAX_V4L2_NODES_COUNT)
-		goto error_preset;
-
-	if (id >= smdk4x12_camera->config->presets_count)
-		goto error_preset;
-
-	rc = smdk4x12_camera_start(smdk4x12_camera, id);
-	if (rc < 0) {
-		ALOGE("%s: Unable to start camera", __func__);
-		goto error;
-	}
-
-	rc = smdk4x12_camera_capture_thread_start(smdk4x12_camera);
-	if (rc < 0) {
-		ALOGE("%s: Unable to start capture thread", __func__);
-		goto error;
-	}
-
-	camera_device = calloc(1, sizeof(struct camera_device));
-	camera_device->common.tag = HARDWARE_DEVICE_TAG;
-	camera_device->common.version = 0;
-	camera_device->common.module = (struct hw_module_t *) module;
-	camera_device->common.close = smdk4x12_camera_close;
-
-	camera_device->ops = &smdk4x12_camera_ops;
-	camera_device->priv = smdk4x12_camera;
-
-	*device = (struct hw_device_t *) &(camera_device->common);
-
-	return 0;
-
-error:
-	smdk4x12_camera_stop(smdk4x12_camera);
-
-error_device:
-	if (camera_device != NULL)
-		free(camera_device);
-
-error_preset:
-	if (smdk4x12_camera != NULL)
-		free(smdk4x12_camera);
-
-	return -1;
-}
-
-int smdk4x12_camera_get_number_of_cameras(void)
-{
-	ALOGD("%s()", __func__);
-
-	if (smdk4x12_camera_config == NULL || smdk4x12_camera_config->presets == NULL) {
-		ALOGE("%s: Unable to find proper camera config", __func__);
-		return -1;
-	}
-
-	return smdk4x12_camera_config->presets_count;
-}
-
-int smdk4x12_camera_get_camera_info(int id, struct camera_info *info)
-{
-	ALOGD("%s(%d, %p)", __func__, id, info);
-
-	if (id < 0 || info == NULL)
-		return -EINVAL;
-
-	if (smdk4x12_camera_config == NULL || smdk4x12_camera_config->presets == NULL) {
-		ALOGE("%s: Unable to find proper camera config", __func__);
-		return -1;
-	}
-
-	if (id >= smdk4x12_camera_config->presets_count)
-		return -EINVAL;
-
-	ALOGD("Selected camera: %s", smdk4x12_camera_config->presets[id].name);
-
-	info->facing = smdk4x12_camera_config->presets[id].facing;
-	info->orientation = smdk4x12_camera_config->presets[id].orientation;
-
-	return 0;
-}
-
-struct hw_module_methods_t smdk4x12_camera_module_methods = {
-	.open = smdk4x12_camera_open,
-};
-
-struct camera_module HAL_MODULE_INFO_SYM = {
-	.common = {
-		.tag = HARDWARE_MODULE_TAG,
-		.version_major = 1,
-		.version_minor = 0,
-		.id = CAMERA_HARDWARE_MODULE_ID,
-		.name = "SMDK4x12 Camera",
-		.author = "Paul Kocialkowski",
-		.methods = &smdk4x12_camera_module_methods,
-	},
-	.get_number_of_cameras = smdk4x12_camera_get_number_of_cameras,
-	.get_camera_info = smdk4x12_camera_get_camera_info,
-};
diff --git a/camera/smdk4x12_camera.h b/camera/smdk4x12_camera.h
deleted file mode 100644
index d1a3924..0000000
--- a/camera/smdk4x12_camera.h
+++ /dev/null
@@ -1,695 +0,0 @@
-/*
- * Copyright (C) 2013-2014 Paul Kocialkowski <contact@paulk.fr>
- *
- * 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 <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <pthread.h>
-
-#include <videodev2.h>
-#include <videodev2_exynos_camera.h>
-#include <videodev2_exynos_media.h>
-#include <fimc.h>
-
-#include <s5c73m3.h>
-
-#include <jpeg_hal.h>
-#include <Exif.h>
-
-#include <hardware/hardware.h>
-#include <hardware/camera.h>
-
-#ifndef _SMDK4x12_CAMERA_H_
-#define _SMDK4x12_CAMERA_H_
-
-#define SMDK4x12_CAMERA_MAX_V4L2_NODES_COUNT	4
-
-#define SMDK4x12_CAMERA_CAPTURE_BUFFERS_COUNT	6
-#define SMDK4x12_CAMERA_PREVIEW_BUFFERS_COUNT	6
-#define SMDK4x12_CAMERA_RECORDING_BUFFERS_COUNT	6
-#define SMDK4x12_CAMERA_GRALLOC_BUFFERS_COUNT	3
-
-#define SMDK4x12_CAMERA_PICTURE_OUTPUT_FORMAT	V4L2_PIX_FMT_YUYV
-
-#define SMDK4x12_CAMERA_MSG_ENABLED(msg) (smdk4x12_camera->messages_enabled & msg)
-#define SMDK4x12_CAMERA_CALLBACK_DEFINED(cb) (smdk4x12_camera->callbacks.cb != NULL)
-
-#define SMDK4x12_CAMERA_ALIGN(value) ((value + (0x10000 - 1)) & ~(0x10000 - 1))
-
-/*
- * Structures
- */
-
-struct smdk4x12_camera;
-
-struct list_head {
-	struct list_head *next;
-	struct list_head *prev;
-};
-
-enum smdk4x12_param_type {
-	EXYNOS_PARAM_INT,
-	EXYNOS_PARAM_FLOAT,
-	EXYNOS_PARAM_STRING,
-};
-
-union smdk4x12_param_data {
-	int integer;
-	float floating;
-	char *string;
-};
-
-struct smdk4x12_param {
-	struct list_head list;
-
-	char *key;
-	union smdk4x12_param_data data;
-	enum smdk4x12_param_type type;
-};
-
-struct smdk4x12_camera_buffer {
-	void *pointer;
-	int address;
-	int length;
-
-	int width;
-	int height;
-	int format;
-};
-
-struct smdk4x12_camera_capture_listener {
-	struct list_head list;
-
-	int width;
-	int height;
-	int format;
-
-	int (*callback)(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_camera_buffer *buffers, int buffers_count);
-	int busy;
-};
-
-struct smdk4x12_camera_mbus_resolution {
-	int width;
-	int height;
-	int mbus_width;
-	int mbus_height;
-};
-
-struct smdk4x12_camera_params {
-	char *preview_size_values;
-	char *preview_size;
-	char *preview_format_values;
-	char *preview_format;
-	char *preview_frame_rate_values;
-	int preview_frame_rate;
-	char *preview_fps_range_values;
-	char *preview_fps_range;
-
-	char *picture_size_values;
-	char *picture_size;
-	char *picture_format_values;
-	char *picture_format;
-	char *jpeg_thumbnail_size_values;
-	int jpeg_thumbnail_width;
-	int jpeg_thumbnail_height;
-	int jpeg_thumbnail_quality;
-	int jpeg_quality;
-
-	int video_snapshot_supported;
-	int full_video_snap_supported;
-
-	char *recording_size;
-	char *recording_size_values;
-	char *recording_format;
-
-	char *focus_mode;
-	char *focus_mode_values;
-	char *focus_distances;
-	char *focus_areas;
-	int max_num_focus_areas;
-
-	int zoom_supported;
-	int smooth_zoom_supported;
-	char *zoom_ratios;
-	int zoom;
-	int max_zoom;
-
-	int auto_exposure_lock_supported;
-	int auto_exposure_lock;
-
-	int auto_white_balance_lock_supported;
-	int auto_white_balance_lock;
-
-	char *flash_mode;
-	char *flash_mode_values;
-
-	int exposure_compensation;
-	float exposure_compensation_step;
-	int min_exposure_compensation;
-	int max_exposure_compensation;
-
-	char *whitebalance;
-	char *whitebalance_values;
-
-	char *antibanding;
-	char *antibanding_values;
-
-	char *scene_mode;
-	char *scene_mode_values;
-
-	char *effect;
-	char *effect_values;
-
-	char *iso;
-	char *iso_values;
-
-	char *image_stabilization;
-	char *image_stabilization_values;
-};
-
-struct smdk4x12_camera_preset {
-	char *name;
-	int facing;
-	int orientation;
-
-	int rotation;
-	int hflip;
-	int vflip;
-
-	int capture_format;
-	int picture_format;
-	int fimc_is;
-
-	float focal_length;
-	float horizontal_view_angle;
-	float vertical_view_angle;
-
-	int metering;
-
-	struct smdk4x12_camera_params params;
-	struct smdk4x12_camera_mbus_resolution *mbus_resolutions;
-	int mbus_resolutions_count;
-};
-
-struct smdk4x12_v4l2_node {
-	int id;
-	char *node;
-};
-
-struct smdk4x12_v4l2_output {
-	int enabled;
-
-	int v4l2_id;
-
-	int width;
-	int height;
-	int format;
-
-	int buffer_width;
-	int buffer_height;
-	int buffer_format;
-
-	camera_memory_t *memory;
-	int memory_address;
-#ifdef EXYNOS_ION
-	int memory_ion_fd;
-#endif
-	int memory_index;
-	int buffers_count;
-	int buffer_length;
-};
-
-struct smdk4x12_exif {
-	int enabled;
-
-	exif_attribute_t attributes;
-	void *jpeg_thumbnail_data;
-	int jpeg_thumbnail_size;
-
-	camera_memory_t *memory;
-	int memory_size;
-};
-
-struct smdk4x12_jpeg {
-	int enabled;
-
-	int fd;
-	struct jpeg_buf buffer_in;
-	struct jpeg_buf buffer_out;
-	camera_memory_t *memory_in;
-	void *memory_in_pointer;
-#ifdef EXYNOS_ION
-	int memory_in_ion_fd;
-#endif
-	camera_memory_t *memory_out;
-	void *memory_out_pointer;
-	int memory_out_size;
-#ifdef EXYNOS_ION
-	int memory_out_ion_fd;
-#endif
-
-	int width;
-	int height;
-	int format;
-
-	int quality;
-};
-
-struct exynox_camera_config {
-	struct smdk4x12_camera_preset *presets;
-	int presets_count;
-
-	struct smdk4x12_v4l2_node *v4l2_nodes;
-	int v4l2_nodes_count;
-};
-
-struct smdk4x12_camera_callbacks {
-	camera_notify_callback notify;
-	camera_data_callback data;
-	camera_data_timestamp_callback data_timestamp;
-	camera_request_memory request_memory;
-	void *user;
-};
-
-struct smdk4x12_camera {
-	int v4l2_fds[SMDK4x12_CAMERA_MAX_V4L2_NODES_COUNT];
-	int ion_fd;
-
-	struct exynox_camera_config *config;
-	struct smdk4x12_param *params;
-
-	struct smdk4x12_camera_callbacks callbacks;
-	int callback_lock;
-	int messages_enabled;
-
-	gralloc_module_t *gralloc;
-
-	// Capture
-
-	pthread_t capture_thread;
-	pthread_mutex_t capture_mutex;
-	pthread_mutex_t capture_lock_mutex;
-	int capture_thread_running;
-	int capture_thread_enabled;
-
-	int capture_enabled;
-	struct smdk4x12_camera_capture_listener *capture_listeners;
-	camera_memory_t *capture_memory;
-	int capture_memory_address;
-	int capture_memory_index;
-	void *capture_yuv_buffer;
-	void *capture_jpeg_buffer;
-	int capture_exif_flash;
-	int capture_exif_iso;
-	int capture_exif_exposure;
-	int capture_exif_exposure_bias;
-	int capture_exif_exposure_time;
-	int capture_hybrid;
-	int capture_width;
-	int capture_height;
-	int capture_format;
-	int capture_buffers_count;
-	int capture_buffer_length;
-
-	// Preview
-
-	pthread_t preview_thread;
-	pthread_mutex_t preview_mutex;
-	pthread_mutex_t preview_lock_mutex;
-	int preview_thread_running;
-	int preview_thread_enabled;
-
-	int preview_output_enabled;
-	struct smdk4x12_camera_capture_listener *preview_listener;
-	struct preview_stream_ops *preview_window;
-	struct smdk4x12_camera_buffer preview_buffer;
-	struct smdk4x12_v4l2_output preview_output;
-
-	// Picture
-
-	pthread_t picture_thread;
-	pthread_mutex_t picture_mutex;
-	pthread_mutex_t picture_lock_mutex;
-	int picture_thread_running;
-	int picture_thread_enabled;
-
-	int picture_enabled;
-	int picture_completed;
-	struct smdk4x12_camera_capture_listener *picture_listener;
-	camera_memory_t *picture_memory;
-	struct smdk4x12_camera_buffer picture_jpeg_buffer;
-	struct smdk4x12_camera_buffer picture_jpeg_thumbnail_buffer;
-	struct smdk4x12_camera_buffer picture_yuv_buffer;
-	struct smdk4x12_camera_buffer picture_yuv_thumbnail_buffer;
-	time_t picture_focus_timestamp;
-
-	// Recording
-
-	pthread_t recording_thread;
-	pthread_mutex_t recording_mutex;
-	pthread_mutex_t recording_lock_mutex;
-	int recording_thread_running;
-	int recording_thread_enabled;
-
-	int recording_output_enabled;
-	struct smdk4x12_camera_capture_listener *recording_listener;
-	camera_memory_t *recording_memory;
-	int recording_memory_index;
-	struct smdk4x12_camera_buffer recording_buffer;
-	struct smdk4x12_v4l2_output recording_output;
-	int recording_buffers_count;
-	int recording_buffer_length;
-	int recording_metadata;
-
-	// Auto-focus
-
-	pthread_t auto_focus_thread;
-	pthread_mutex_t auto_focus_mutex;
-	int auto_focus_thread_enabled;
-	int auto_focus_thread_running;
-
-	int auto_focus_result;
-
-	// Camera params
-
-	int camera_rotation;
-	int camera_hflip;
-	int camera_vflip;
-	int camera_capture_format;
-	int camera_picture_format;
-	int camera_fimc_is;
-	int camera_focal_length;
-	int camera_metering;
-
-	struct smdk4x12_camera_mbus_resolution *camera_mbus_resolutions;
-	int camera_mbus_resolutions_count;
-
-	int camera_sensor_mode;
-	int fimc_is_mode;
-
-	// Params
-
-	int preview_width;
-	int preview_height;
-	int preview_format;
-	int preview_fps;
-	int picture_width;
-	int picture_height;
-	int picture_format;
-	int jpeg_thumbnail_width;
-	int jpeg_thumbnail_height;
-	int jpeg_thumbnail_quality;
-	int jpeg_quality;
-	int recording_width;
-	int recording_height;
-	int recording_format;
-	int focus_mode;
-	int focus_x;
-	int focus_y;
-	int zoom;
-	int ae_lock;
-	int awb_lock;
-	int flash_mode;
-	int exposure_compensation;
-	int whitebalance;
-	int antibanding;
-	int scene_mode;
-	int effect;
-	int iso;
-	int metering;
-	int image_stabilization;
-};
-
-struct smdk4x12_camera_addrs {
-	unsigned int type;
-	unsigned int y;
-	unsigned int cbcr;
-	unsigned int index;
-	unsigned int reserved;
-};
-
-// This is because the linux header uses anonymous union
-struct smdk4x12_v4l2_ext_control {
-	__u32 id;
-	__u32 size;
-	__u32 reserved2[1];
-	union {
-		__s32 value;
-		__s64 value64;
-		char *string;
-	} data;
-} __attribute__ ((packed));
-
-/*
- * Camera
- */
-
-// Camera
-int smdk4x12_camera_start(struct smdk4x12_camera *smdk4x12_camera, int id);
-void smdk4x12_camera_stop(struct smdk4x12_camera *smdk4x12_camera);
-
-// Params
-int smdk4x12_camera_params_init(struct smdk4x12_camera *smdk4x12_camera, int id);
-int smdk4x12_camera_params_apply(struct smdk4x12_camera *smdk4x12_camera, int force);
-
-// Capture
-int smdk4x12_camera_capture(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_camera_capture_thread_start(struct smdk4x12_camera *smdk4x12_camera);
-void smdk4x12_camera_capture_thread_stop(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_camera_capture_start(struct smdk4x12_camera *smdk4x12_camera);
-void smdk4x12_camera_capture_stop(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_camera_capture_setup(struct smdk4x12_camera *smdk4x12_camera);
-struct smdk4x12_camera_capture_listener *smdk4x12_camera_capture_listener_register(
-	struct smdk4x12_camera *smdk4x12_camera, int width, int height, int format,
-	int (*callback)(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_camera_buffer *buffers, int buffers_count));
-void smdk4x12_camera_capture_listener_unregister(
-	struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_camera_capture_listener *listener);
-
-// Preview
-int smdk4x12_camera_preview_output_start(struct smdk4x12_camera *smdk4x12_camera);
-void smdk4x12_camera_preview_output_stop(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_camera_preview_callback(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_camera_buffer *buffers, int buffers_count);
-int smdk4x12_camera_preview(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_camera_preview_thread_start(struct smdk4x12_camera *smdk4x12_camera);
-void smdk4x12_camera_preview_thread_stop(struct smdk4x12_camera *smdk4x12_camera);
-
-// Picture
-int smdk4x12_camera_picture_callback(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_camera_buffer *buffers, int buffers_count);
-int smdk4x12_camera_picture(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_camera_picture_thread_start(struct smdk4x12_camera *smdk4x12_camera);
-void smdk4x12_camera_picture_thread_stop(struct smdk4x12_camera *smdk4x12_camera);
-
-// Recording
-int smdk4x12_camera_recording_output_start(struct smdk4x12_camera *smdk4x12_camera);
-void smdk4x12_camera_recording_output_stop(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_camera_recording_callback(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_camera_buffer *buffers, int buffers_count);
-void smdk4x12_camera_recording_frame_release(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_camera_recording(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_camera_recording_thread_start(struct smdk4x12_camera *smdk4x12_camera);
-void smdk4x12_camera_recording_thread_stop(struct smdk4x12_camera *smdk4x12_camera);
-
-// Auto-focus
-int smdk4x12_camera_auto_focus(struct smdk4x12_camera *smdk4x12_camera, int auto_focus_status);
-int smdk4x12_camera_auto_focus_thread_start(struct smdk4x12_camera *smdk4x12_camera);
-void smdk4x12_camera_auto_focus_thread_stop(struct smdk4x12_camera *smdk4x12_camera);
-
-/*
- * EXIF
- */
-
-int smdk4x12_exif_start(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif *exif);
-void smdk4x12_exif_stop(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_exif *exif);
-int smdk4x12_exif(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_exif *exif);
-
-/*
- * ION
- */
-
-#ifdef EXYNOS_ION
-int smdk4x12_ion_init(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_ion_open(struct smdk4x12_camera *smdk4x12_camera);
-void smdk4x12_ion_close(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_ion_alloc(struct smdk4x12_camera *smdk4x12_camera, int size);
-int smdk4x12_ion_free(struct smdk4x12_camera *smdk4x12_camera, int fd);
-int smdk4x12_ion_phys(struct smdk4x12_camera *smdk4x12_camera, int fd);
-int smdk4x12_ion_msync(struct smdk4x12_camera *smdk4x12_camera, int fd,
-	int offset, int size);
-#endif
-
-/*
- * Jpeg
- */
-
-int smdk4x12_jpeg_start(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_jpeg *jpeg);
-void smdk4x12_jpeg_stop(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_jpeg *jpeg);
-int smdk4x12_jpeg(struct smdk4x12_camera *smdk4x12_camera, struct smdk4x12_jpeg *jpeg);
-
-/*
- * Param
- */
-
-int smdk4x12_param_int_get(struct smdk4x12_camera *smdk4x12_camera,
-	char *key);
-float smdk4x12_param_float_get(struct smdk4x12_camera *smdk4x12_camera,
-	char *key);
-char *smdk4x12_param_string_get(struct smdk4x12_camera *smdk4x12_camera,
-	char *key);
-int smdk4x12_param_int_set(struct smdk4x12_camera *smdk4x12_camera,
-	char *key, int integer);
-int smdk4x12_param_float_set(struct smdk4x12_camera *smdk4x12_camera,
-	char *key, float floating);
-int smdk4x12_param_string_set(struct smdk4x12_camera *smdk4x12_camera,
-	char *key, char *string);
-char *smdk4x12_params_string_get(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_params_string_set(struct smdk4x12_camera *smdk4x12_camera, char *string);
-
-/*
- * Utils
- */
-
-int list_head_insert(struct list_head *list, struct list_head *prev,
-	struct list_head *next);
-void list_head_remove(struct list_head *list);
-
-int smdk4x12_camera_buffer_length(int width, int height, int format);
-void smdk4x12_camera_yuv_planes(int width, int height, int format, int address, int *address_y, int *address_cb, int *address_cr);
-int smdk4x12_gralloc_format(int format);
-
-/*
- * V4L2
- */
-
-int smdk4x12_v4l2_init(struct smdk4x12_camera *smdk4x12_camera);
-int smdk4x12_v4l2_index(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id);
-int smdk4x12_v4l2_fd(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id);
-
-int smdk4x12_v4l2_open(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id);
-void smdk4x12_v4l2_close(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id);
-int smdk4x12_v4l2_ioctl(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int request, void *data);
-int smdk4x12_v4l2_poll(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id);
-int smdk4x12_v4l2_qbuf(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int type, int memory, int index, unsigned long userptr);
-int smdk4x12_v4l2_qbuf_cap(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int index);
-int smdk4x12_v4l2_qbuf_out(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int index, unsigned long userptr);
-int smdk4x12_v4l2_dqbuf(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int type, int memory);
-int smdk4x12_v4l2_dqbuf_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id);
-int smdk4x12_v4l2_dqbuf_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id);
-int smdk4x12_v4l2_reqbufs(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type, int memory, int count);
-int smdk4x12_v4l2_reqbufs_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int count);
-int smdk4x12_v4l2_reqbufs_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int count);
-int smdk4x12_v4l2_querybuf(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type, int memory, int index);
-int smdk4x12_v4l2_querybuf_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int index);
-int smdk4x12_v4l2_querybuf_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int index);
-int smdk4x12_v4l2_querycap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int flags);
-int smdk4x12_v4l2_querycap_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id);
-int smdk4x12_v4l2_querycap_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id);
-int smdk4x12_v4l2_streamon(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type);
-int smdk4x12_v4l2_streamon_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id);
-int smdk4x12_v4l2_streamon_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id);
-int smdk4x12_v4l2_streamoff(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type);
-int smdk4x12_v4l2_streamoff_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id);
-int smdk4x12_v4l2_streamoff_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id);
-int smdk4x12_v4l2_g_fmt(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int type, int *width, int *height, int *fmt);
-int smdk4x12_v4l2_g_fmt_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int *width, int *height, int *fmt);
-int smdk4x12_v4l2_g_fmt_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int *width, int *height, int *fmt);
-int smdk4x12_v4l2_s_fmt_pix(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type, int width, int height, int fmt, int field,
-	int priv);
-int smdk4x12_v4l2_s_fmt_pix_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int width, int height, int fmt, int priv);
-int smdk4x12_v4l2_s_fmt_pix_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int width, int height, int fmt, int priv);
-int smdk4x12_v4l2_s_fmt_win(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int left, int top, int width, int height);
-int smdk4x12_v4l2_enum_fmt(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type, int fmt);
-int smdk4x12_v4l2_enum_fmt_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int fmt);
-int smdk4x12_v4l2_enum_fmt_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int fmt);
-int smdk4x12_v4l2_enum_input(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int id);
-int smdk4x12_v4l2_s_input(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int id);
-int smdk4x12_v4l2_g_ext_ctrls(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, struct v4l2_ext_control *control, int count);
-int smdk4x12_v4l2_g_ctrl(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int id, int *value);
-int smdk4x12_v4l2_s_ctrl(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int id, int value);
-int smdk4x12_v4l2_s_parm(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int type, struct v4l2_streamparm *streamparm);
-int smdk4x12_v4l2_s_parm_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, struct v4l2_streamparm *streamparm);
-int smdk4x12_v4l2_s_parm_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, struct v4l2_streamparm *streamparm);
-int smdk4x12_v4l2_s_crop(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int type, int left, int top, int width, int height);
-int smdk4x12_v4l2_s_crop_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int left, int top, int width, int height);
-int smdk4x12_v4l2_s_crop_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int left, int top, int width, int height);
-int smdk4x12_v4l2_g_fbuf(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	void **base, int *width, int *height, int *fmt);
-int smdk4x12_v4l2_s_fbuf(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	void *base, int width, int height, int fmt);
-
-/*
- * V4L2 Output
- */
-
-int smdk4x12_v4l2_output_start(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_v4l2_output *output);
-void smdk4x12_v4l2_output_stop(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_v4l2_output *output);
-int smdk4x12_v4l2_output(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_v4l2_output *output, int buffer_address);
-int smdk4x12_v4l2_output_release(struct smdk4x12_camera *smdk4x12_camera,
-	struct smdk4x12_v4l2_output *output);
-
-#endif
diff --git a/camera/smdk4x12_v4l2.c b/camera/smdk4x12_v4l2.c
deleted file mode 100644
index e8b130e..0000000
--- a/camera/smdk4x12_v4l2.c
+++ /dev/null
@@ -1,739 +0,0 @@
-/*
- * Copyright (C) 2013 Paul Kocialkowski <contact@paulk.fr>
- *
- * Based on crespo libcamera and exynos4 hal libcamera:
- * Copyright 2008, The Android Open Source Project
- * Copyright 2010, Samsung Electronics Co. LTD
- *
- * 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 <fcntl.h>
-#include <unistd.h>
-#include <errno.h>
-#include <malloc.h>
-#include <poll.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/mman.h>
-#include <sys/ioctl.h>
-
-#include <asm/types.h>
-
-#define LOG_TAG "smdk4x12_v4l2"
-#include <utils/Log.h>
-
-#include "smdk4x12_camera.h"
-
-int smdk4x12_v4l2_init(struct smdk4x12_camera *smdk4x12_camera)
-{
-	int i;
-
-	for (i = 0; i < SMDK4x12_CAMERA_MAX_V4L2_NODES_COUNT; i++)
-		smdk4x12_camera->v4l2_fds[i] = -1;
-
-	return 0;
-}
-
-int smdk4x12_v4l2_index(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id)
-{
-	int index;
-	int i;
-
-	if (smdk4x12_camera == NULL || smdk4x12_camera->config == NULL ||
-		smdk4x12_camera->config->v4l2_nodes == NULL)
-		return -EINVAL;
-
-	if (smdk4x12_v4l2_id > smdk4x12_camera->config->v4l2_nodes_count)
-		return -1;
-
-	index = -1;
-	for (i = 0; i < smdk4x12_camera->config->v4l2_nodes_count; i++) {
-		if (smdk4x12_camera->config->v4l2_nodes[i].id == smdk4x12_v4l2_id &&
-			smdk4x12_camera->config->v4l2_nodes[i].node != NULL) {
-			index = i;
-		}
-	}
-
-	return index;
-}
-
-int smdk4x12_v4l2_fd(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id)
-{
-	int index;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	index = smdk4x12_v4l2_index(smdk4x12_camera, smdk4x12_v4l2_id);
-	if (index < 0) {
-		ALOGE("%s: Unable to get v4l2 index for id %d", __func__, smdk4x12_v4l2_id);
-		return -1;
-	}
-
-	return smdk4x12_camera->v4l2_fds[index];
-}
-
-int smdk4x12_v4l2_open(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id)
-{
-	char *node;
-	int index;
-	int fd;
-
-	if (smdk4x12_camera == NULL || smdk4x12_camera->config == NULL ||
-		smdk4x12_camera->config->v4l2_nodes == NULL)
-		return -EINVAL;
-
-	index = smdk4x12_v4l2_index(smdk4x12_camera, smdk4x12_v4l2_id);
-	if (index < 0) {
-		ALOGE("%s: Unable to get v4l2 node for id %d", __func__, smdk4x12_v4l2_id);
-		return -1;
-	}
-
-	node = smdk4x12_camera->config->v4l2_nodes[index].node;
-	fd = open(node, O_RDWR);
-	if (fd < 0) {
-		ALOGE("%s: Unable to open v4l2 node for id %d", __func__, smdk4x12_v4l2_id);
-		return -1;
-	}
-
-	smdk4x12_camera->v4l2_fds[index] = fd;
-
-	return 0;
-}
-
-void smdk4x12_v4l2_close(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id)
-{
-	int index;
-
-	if (smdk4x12_camera == NULL || smdk4x12_camera->config == NULL ||
-		smdk4x12_camera->config->v4l2_nodes == NULL)
-		return;
-
-	index = smdk4x12_v4l2_index(smdk4x12_camera, smdk4x12_v4l2_id);
-	if (index < 0) {
-		ALOGE("%s: Unable to get v4l2 node for id %d", __func__, smdk4x12_v4l2_id);
-		return;
-	}
-
-	if (smdk4x12_camera->v4l2_fds[index] >= 0)
-		close(smdk4x12_camera->v4l2_fds[index]);
-
-	smdk4x12_camera->v4l2_fds[index] = -1;
-}
-
-int smdk4x12_v4l2_ioctl(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int request, void *data)
-{
-	int fd;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	fd = smdk4x12_v4l2_fd(smdk4x12_camera, smdk4x12_v4l2_id);
-	if (fd < 0) {
-		ALOGE("%s: Unable to get v4l2 fd for id %d", __func__, smdk4x12_v4l2_id);
-		return -1;
-	}
-
-	return ioctl(fd, request, data);
-}
-
-int smdk4x12_v4l2_poll(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id)
-{
-	struct pollfd events;
-	int fd;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	fd = smdk4x12_v4l2_fd(smdk4x12_camera, smdk4x12_v4l2_id);
-	if (fd < 0) {
-		ALOGE("%s: Unable to get v4l2 fd for id %d", __func__, smdk4x12_v4l2_id);
-		return -1;
-	}
-
-	memset(&events, 0, sizeof(events));
-	events.fd = fd;
-	events.events = POLLIN | POLLERR;
-
-	rc = poll(&events, 1, 1000);
-	if (rc < 0 || events.revents & POLLERR)
-		return -1;
-
-	return rc;
-}
-
-int smdk4x12_v4l2_qbuf(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int type, int memory, int index, unsigned long userptr)
-{
-	struct v4l2_buffer buffer;
-	int rc;
-
-	if (smdk4x12_camera == NULL || index < 0)
-		return -EINVAL;
-
-	memset(&buffer, 0, sizeof(buffer));
-	buffer.type = type;
-	buffer.memory = memory;
-	buffer.index = index;
-
-	if (userptr)
-		buffer.m.userptr = userptr;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_QBUF, &buffer);
-	return rc;
-}
-
-int smdk4x12_v4l2_qbuf_cap(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int index)
-{
-	return smdk4x12_v4l2_qbuf(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-		V4L2_MEMORY_MMAP, index, 0);
-}
-
-int smdk4x12_v4l2_qbuf_out(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int index, unsigned long userptr)
-{
-	return smdk4x12_v4l2_qbuf(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
-		V4L2_MEMORY_USERPTR, index, userptr);
-}
-
-int smdk4x12_v4l2_dqbuf(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int type, int memory)
-{
-	struct v4l2_buffer buffer;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	memset(&buffer, 0, sizeof(buffer));
-	buffer.type = type;
-	buffer.memory = memory;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_DQBUF, &buffer);
-	if (rc < 0)
-		return rc;
-
-	return buffer.index;
-}
-
-int smdk4x12_v4l2_dqbuf_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id)
-{
-	return smdk4x12_v4l2_dqbuf(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-		V4L2_MEMORY_MMAP);
-}
-
-int smdk4x12_v4l2_dqbuf_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id)
-{
-	return smdk4x12_v4l2_dqbuf(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
-		V4L2_MEMORY_USERPTR);
-}
-
-int smdk4x12_v4l2_reqbufs(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type, int memory, int count)
-{
-	struct v4l2_requestbuffers requestbuffers;
-	int rc;
-
-	if (smdk4x12_camera == NULL || count < 0)
-		return -EINVAL;
-
-	requestbuffers.type = type;
-	requestbuffers.count = count;
-	requestbuffers.memory = memory;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_REQBUFS, &requestbuffers);
-	if (rc < 0)
-		return rc;
-
-	return requestbuffers.count;
-}
-
-int smdk4x12_v4l2_reqbufs_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int count)
-{
-	return smdk4x12_v4l2_reqbufs(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-		V4L2_MEMORY_MMAP, count);
-}
-
-int smdk4x12_v4l2_reqbufs_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int count)
-{
-	return smdk4x12_v4l2_reqbufs(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
-		V4L2_MEMORY_USERPTR, count);
-}
-
-int smdk4x12_v4l2_querybuf(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type, int memory, int index)
-{
-	struct v4l2_buffer buffer;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	memset(&buffer, 0, sizeof(buffer));
-	buffer.type = type;
-	buffer.memory = memory;
-	buffer.index = index;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_QUERYBUF, &buffer);
-	if (rc < 0)
-		return rc;
-
-	return buffer.length;
-}
-
-int smdk4x12_v4l2_querybuf_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int index)
-{
-	return smdk4x12_v4l2_querybuf(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-		V4L2_MEMORY_MMAP, index);
-}
-
-int smdk4x12_v4l2_querybuf_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int index)
-{
-	return smdk4x12_v4l2_querybuf(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
-		V4L2_MEMORY_USERPTR, index);
-}
-
-int smdk4x12_v4l2_querycap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int flags)
-{
-	struct v4l2_capability cap;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_QUERYCAP, &cap);
-	if (rc < 0)
-		return rc;
-
-	if (!(cap.capabilities & flags))
-		return -1;
-
-	return 0;
-}
-
-int smdk4x12_v4l2_querycap_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id)
-{
-	return smdk4x12_v4l2_querycap(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_CAP_VIDEO_CAPTURE);
-}
-
-int smdk4x12_v4l2_querycap_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id)
-{
-	return smdk4x12_v4l2_querycap(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_CAP_VIDEO_OUTPUT);
-}
-
-int smdk4x12_v4l2_streamon(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type)
-{
-	enum v4l2_buf_type buf_type;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	buf_type = type;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_STREAMON, &buf_type);
-	return rc;
-}
-
-int smdk4x12_v4l2_streamon_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id)
-{
-	return smdk4x12_v4l2_streamon(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE);
-}
-
-int smdk4x12_v4l2_streamon_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id)
-{
-	return smdk4x12_v4l2_streamon(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT);
-}
-
-int smdk4x12_v4l2_streamoff(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type)
-{
-	enum v4l2_buf_type buf_type;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	buf_type = type;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_STREAMOFF, &buf_type);
-	return rc;
-}
-
-int smdk4x12_v4l2_streamoff_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id)
-{
-	return smdk4x12_v4l2_streamoff(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE);
-}
-
-int smdk4x12_v4l2_streamoff_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id)
-{
-	return smdk4x12_v4l2_streamoff(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT);
-}
-
-int smdk4x12_v4l2_g_fmt(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int type, int *width, int *height, int *fmt)
-{
-	struct v4l2_format format;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	format.type = type;
-	format.fmt.pix.field = V4L2_FIELD_NONE;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_G_FMT, &format);
-	if (rc < 0)
-		return rc;
-
-	if (width != NULL)
-		*width = format.fmt.pix.width;
-	if (height != NULL)
-		*height = format.fmt.pix.height;
-	if (fmt != NULL)
-		*fmt = format.fmt.pix.pixelformat;
-
-	return 0;
-}
-
-int smdk4x12_v4l2_g_fmt_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int *width, int *height, int *fmt)
-{
-	return smdk4x12_v4l2_g_fmt(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-		width, height, fmt);
-}
-
-int smdk4x12_v4l2_g_fmt_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int *width, int *height, int *fmt)
-{
-	return smdk4x12_v4l2_g_fmt(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
-		width, height, fmt);
-}
-
-int smdk4x12_v4l2_s_fmt_pix(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type, int width, int height, int fmt, int field,
-	int priv)
-{
-	struct v4l2_format format;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	memset(&format, 0, sizeof(format));
-	format.type = type;
-	format.fmt.pix.width = width;
-	format.fmt.pix.height = height;
-	format.fmt.pix.pixelformat = fmt;
-	format.fmt.pix.field = field;
-	format.fmt.pix.priv = priv;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_S_FMT, &format);
-	return rc;
-
-	return 0;
-}
-
-int smdk4x12_v4l2_s_fmt_pix_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int width, int height, int fmt, int priv)
-{
-	return smdk4x12_v4l2_s_fmt_pix(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-		width, height, fmt, V4L2_FIELD_NONE, priv);
-}
-
-int smdk4x12_v4l2_s_fmt_pix_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int width, int height, int fmt, int priv)
-{
-	return smdk4x12_v4l2_s_fmt_pix(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
-		width, height, fmt, V4L2_FIELD_NONE, priv);
-}
-
-int smdk4x12_v4l2_s_fmt_win(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int left, int top, int width, int height)
-{
-	struct v4l2_format format;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	memset(&format, 0, sizeof(format));
-	format.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
-	format.fmt.win.w.left = left;
-	format.fmt.win.w.top = top;
-	format.fmt.win.w.width = width;
-	format.fmt.win.w.height = height;
-
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_S_FMT, &format);
-	return rc;
-}
-
-int smdk4x12_v4l2_enum_fmt(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int type, int fmt)
-{
-	struct v4l2_fmtdesc fmtdesc;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	fmtdesc.type = type;
-	fmtdesc.index = 0;
-
-	do {
-		rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_ENUM_FMT, &fmtdesc);
-		if (rc < 0)
-			return rc;
-
-		if (fmtdesc.pixelformat == (unsigned int) fmt)
-			return 0;
-
-		fmtdesc.index++;
-	} while (rc >= 0);
-
-	return -1;
-}
-
-int smdk4x12_v4l2_enum_fmt_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int fmt)
-{
-	return smdk4x12_v4l2_enum_fmt(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-		fmt);
-}
-
-int smdk4x12_v4l2_enum_fmt_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int fmt)
-{
-	return smdk4x12_v4l2_enum_fmt(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
-		fmt);
-}
-
-int smdk4x12_v4l2_enum_input(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int id)
-{
-	struct v4l2_input input;
-	int rc;
-
-	if (smdk4x12_camera == NULL || id < 0)
-		return -EINVAL;
-
-	input.index = id;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_ENUMINPUT, &input);
-	if (rc < 0)
-		return rc;
-
-	if (input.name[0] == '\0')
-		return -1;
-
-	return 0;
-}
-
-int smdk4x12_v4l2_s_input(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int id)
-{
-	struct v4l2_input input;
-	int rc;
-
-	if (smdk4x12_camera == NULL || id < 0)
-		return -EINVAL;
-
-	input.index = id;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_S_INPUT, &input);
-	return rc;
-}
-
-int smdk4x12_v4l2_g_ext_ctrls(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, struct v4l2_ext_control *control, int count)
-{
-	struct v4l2_ext_controls controls;
-	int rc;
-
-	if (smdk4x12_camera == NULL || control == NULL)
-		return -EINVAL;
-
-	memset(&controls, 0, sizeof(controls));
-	controls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
-	controls.count = count;
-	controls.controls = control;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_G_EXT_CTRLS, &controls);
-	return rc;
-}
-
-int smdk4x12_v4l2_g_ctrl(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int id, int *value)
-{
-	struct v4l2_control control;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	control.id = id;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_G_CTRL, &control);
-	if (rc < 0)
-		return rc;
-
-	if (value != NULL)
-		*value = control.value;
-
-	return 0;
-}
-
-int smdk4x12_v4l2_s_ctrl(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int id, int value)
-{
-	struct v4l2_control control;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	control.id = id;
-	control.value = value;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_S_CTRL, &control);
-	if (rc < 0)
-		return rc;
-
-	return control.value;
-}
-
-int smdk4x12_v4l2_s_parm(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int type, struct v4l2_streamparm *streamparm)
-{
-	int rc;
-
-	if (smdk4x12_camera == NULL || streamparm == NULL)
-		return -EINVAL;
-
-	streamparm->type = type;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_S_PARM, streamparm);
-	return rc;
-}
-
-int smdk4x12_v4l2_s_parm_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, struct v4l2_streamparm *streamparm)
-{
-	return smdk4x12_v4l2_s_parm(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-		streamparm);
-}
-
-int smdk4x12_v4l2_s_parm_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, struct v4l2_streamparm *streamparm)
-{
-	return smdk4x12_v4l2_s_parm(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
-		streamparm);
-}
-
-int smdk4x12_v4l2_s_crop(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	int type, int left, int top, int width, int height)
-{
-	struct v4l2_crop crop;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	crop.type = type;
-	crop.c.left = left;
-	crop.c.top = top;
-	crop.c.width = width;
-	crop.c.height = height;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_S_CROP, &crop);
-	return rc;
-}
-
-int smdk4x12_v4l2_s_crop_cap(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int left, int top, int width, int height)
-{
-	return smdk4x12_v4l2_s_crop(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
-		left, top, width, height);
-}
-
-int smdk4x12_v4l2_s_crop_out(struct smdk4x12_camera *smdk4x12_camera,
-	int smdk4x12_v4l2_id, int left, int top, int width, int height)
-{
-	return smdk4x12_v4l2_s_crop(smdk4x12_camera, smdk4x12_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
-		left, top, width, height);
-}
-
-int smdk4x12_v4l2_g_fbuf(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	void **base, int *width, int *height, int *fmt)
-{
-	struct v4l2_framebuffer framebuffer;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_G_FBUF, &framebuffer);
-	if (rc < 0)
-		return rc;
-
-	if (base != NULL)
-		*base = framebuffer.base;
-	if (width != NULL)
-		*width = framebuffer.fmt.width;
-	if (height != NULL)
-		*height = framebuffer.fmt.height;
-	if (fmt != NULL)
-		*fmt = framebuffer.fmt.pixelformat;
-
-	return 0;
-}
-
-int smdk4x12_v4l2_s_fbuf(struct smdk4x12_camera *smdk4x12_camera, int smdk4x12_v4l2_id,
-	void *base, int width, int height, int fmt)
-{
-	struct v4l2_framebuffer framebuffer;
-	int rc;
-
-	if (smdk4x12_camera == NULL)
-		return -EINVAL;
-
-	memset(&framebuffer, 0, sizeof(framebuffer));
-	framebuffer.base = base;
-	framebuffer.fmt.width = width;
-	framebuffer.fmt.height = height;
-	framebuffer.fmt.pixelformat = fmt;
-
-	rc = smdk4x12_v4l2_ioctl(smdk4x12_camera, smdk4x12_v4l2_id, VIDIOC_S_FBUF, &framebuffer);
-	return rc;
-}