linaro-dev September 2012

linaro-dev@lists.linaro.org

84 participants
100 discussions

by Viresh Kumar

Hi Thomas, I haven't tested it much till now. I am sending this patch just to check if the initial idea looks fine to you guys or not. Till now, we weren't migrating a running timer because with migration del_timer_sync() can't detect that the timer's handler yet has not finished. Now, when can we actually to reach to the code (inside __mod_timer()) where base->running_timer == timer ? i.e. We are trying to migrate current timer I can see only following case: - Timer re-armed itself. i.e. Currently we are running interrupt handler of a timer and it rearmed itself from there. At this time user might have called del_timer_sync() or not. If not, then there is no harm in re-arming the timer? Now, when somebody tries to delete a timer, obviously he doesn't want to run it any more for now. So, why should we ever re-arm a timer, which is scheduled for deletion? This patch tries to fix "migration of running timer", assuming above theory is correct :) So, now when we get a call to del_timer_sync(), we will mark it scheduled for deletion in an additional variable. This would be checked whenever we try to modify/arm it again. If it was currently scheduled for deletion, we must not modify/arm it. And so, whenever we reach to the situation where: base->running_timer == timer We are sure, nobody is waiting in del_timer_sync(). We will clear this flag as soon as the timer is deleted, so that it can be started again after deleting it successfully. Waiting for initial comments on it. Signed-off-by: Viresh Kumar <viresh.kumar(a)linaro.org> --- include/linux/timer.h | 1 + kernel/timer.c | 58 +++++++++++++++++++++++++++++---------------------- 2 files changed, 34 insertions(+), 25 deletions(-) diff --git a/include/linux/timer.h b/include/linux/timer.h index 8c5a197..ea36ce9 100644 --- a/include/linux/timer.h +++ b/include/linux/timer.h @@ -22,6 +22,7 @@ struct timer_list { unsigned long data; int slack; + int sched_del; #ifdef CONFIG_TIMER_STATS int start_pid; diff --git a/kernel/timer.c b/kernel/timer.c index 1cf8a91..536e7a3 100644 --- a/kernel/timer.c +++ b/kernel/timer.c @@ -620,6 +620,7 @@ static void do_init_timer(struct timer_list *timer, unsigned int flags, timer->entry.next = NULL; timer->base = (void *)((unsigned long)base | flags); timer->slack = -1; + timer->sched_del = 0; #ifdef CONFIG_TIMER_STATS timer->start_site = NULL; timer->start_pid = -1; @@ -727,38 +728,35 @@ __mod_timer(struct timer_list *timer, unsigned long expires, base = lock_timer_base(timer, &flags); + if (timer->sched_del) { + /* Don't schedule it again, as it is getting deleted */ + ret = -EBUSY; + goto out_unlock; + } + ret = detach_if_pending(timer, base, false); if (!ret && pending_only) goto out_unlock; debug_activate(timer, expires); - /* - * Should we try to migrate timer? - * However we can't change timer's base while it is running, otherwise - * del_timer_sync() can't detect that the timer's handler yet has not - * finished. This also guarantees that the timer is serialized wrt - * itself. - */ - if (likely(base->running_timer != timer)) { #if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP) - if (!pinned && get_sysctl_timer_migration()) - cpu = get_nohz_timer_target(); - else - cpu = smp_processor_id(); -#else + if (!pinned && get_sysctl_timer_migration()) + cpu = get_nohz_timer_target(); + else cpu = smp_processor_id(); +#else + cpu = smp_processor_id(); #endif - new_base = per_cpu(tvec_bases, cpu); - - if (base != new_base) { - /* See the comment in lock_timer_base() */ - timer_set_base(timer, NULL); - spin_unlock(&base->lock); - base = new_base; - spin_lock(&base->lock); - timer_set_base(timer, base); - } + new_base = per_cpu(tvec_bases, cpu); + + if (base != new_base) { + /* See the comment in lock_timer_base() */ + timer_set_base(timer, NULL); + spin_unlock(&base->lock); + base = new_base; + spin_lock(&base->lock); + timer_set_base(timer, base); } timer->expires = expires; @@ -1037,9 +1035,11 @@ EXPORT_SYMBOL(try_to_del_timer_sync); */ int del_timer_sync(struct timer_list *timer) { -#ifdef CONFIG_LOCKDEP + struct tvec_base *base; unsigned long flags; +#ifdef CONFIG_LOCKDEP + /* * If lockdep gives a backtrace here, please reference * the synchronization rules above. @@ -1049,6 +1049,12 @@ int del_timer_sync(struct timer_list *timer) lock_map_release(&timer->lockdep_map); local_irq_restore(flags); #endif + + /* Timer is scheduled for deletion, don't let it re-arm itself */ + base = lock_timer_base(timer, &flags); + timer->sched_del = 1; + spin_unlock_irqrestore(&base->lock, flags); + /* * don't use it in hardirq context, because it * could lead to deadlock. @@ -1056,8 +1062,10 @@ int del_timer_sync(struct timer_list *timer) WARN_ON(in_irq() && !tbase_get_irqsafe(timer->base)); for (;;) { int ret = try_to_del_timer_sync(timer); - if (ret >= 0) + if (ret >= 0) { + timer->sched_del = 0; return ret; + } cpu_relax(); } } -- 1.7.12.rc2.18.g61b472e

11 years, 7 months

Linaro, Gumstix, and illegal instructions

by Jonathan Kunkee

Hello, I recently acquired a Gumstix Overo Water with a Tobi and decided to put Node.js on it to turn it into a web server of sorts. The build dies with an "Illegal instruction" error, and I am thoroughly confused. In order to set up the build, I did the following: 1. imaged a microSD card with the Linaro binaries indicated by http://wiki.gumstix.org/index.php?title=Installing_Linaro_Image 2. booted 3. dd'd/enabled 200MB of swap on the SD card 4. apt-get update/upgrade everything 5. installed various development dependencies (git, libc6-dev, g++, and many others) 6. cloned Joyent's repo. 7. modified `wscript` in the repo with V8-specific changes for ARM (including enabling hard-float) (modified the scons invocation in v0.8) 8. ./configure 8. make 9. observed 'illegal instruction' death in the make process: /root/node/deps/v8/src/arguments.h: In constructor 'v8::internal::CustomArguments::CustomArguments(v8::internal::Isolate*, v8::internal::Object*, v8::internal::Object*, v8::internal::JSObject*)': /root/node/deps/v8/src/arguments.h:93:65: internal compiler error: Illegal instruction Please submit a full bug report, with preprocessed source if appropriate. See <file:///usr/share/doc/gcc-4.6/README.Bugs> for instructions. The bug is not reproducible, so it is likely a hardware or OS problem. scons: *** [obj/release/runtime-profiler.o] Error 1 scons: building terminated because of errors. If I restart the build, it works fine for a while (including rebuilding the object it died building) then dies again. A different portion of the build is running and it usually receives a segfault: [ 9/35] cxx: src/node_javascript.cc -> out/Release/src/node_javascript_5.o /usr/bin/g++ -pthread -g -O3 -DHAVE_OPENSSL=1 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -DHAVE_FDATASYNC=1 -DARCH="arm" -DPLATFORM="linux" -D__POSIX__=1 -Wno-unused-parameter -D_FORTIFY_SOURCE=2 -IRelease/src -I../src -IRelease/deps/http_parser -I../deps/http_parser -IRelease/deps/uv/include -I../deps/uv/include -IRelease/deps/uv/src/ares -I../deps/uv/src/ares -IRelease/deps/v8/include -I../deps/v8/include -Ideps/v8/include ../src/node_javascript.cc -c -o Release/src/node_javascript_5.o g++: internal compiler error: Segmentation fault (program as) Please submit a full bug report, with preprocessed source if appropriate. See <file:///usr/share/doc/gcc-4.6/README.Bugs> for instructions. Waf: Leaving directory `/root/node/out' I am confused. I've made a few observations about my setup: * Thinking that it might be a thermal problem because it was under heavy load at 600MHz in open air, I dug out a small heat sink, attached it, and pointed a small fan at it. It now runs cool to the touch. I still get the same 'illegal instruction' deaths under load. * Usually three invocations of 'make' are required before it actually finishes, but it does finish. I can run the command-line interpreter and it seems to behave inasmuch as I've used it. * 'make test' fails, but I think that's a Node.js/ARM problem. * I run htop to monitor the build, and sometimes the build system works fine while htop dies with an 'illegal instruction' error. * Node.js on ARM is presently somewhat sticky, so I checked out the v0.6.6 tag. v0.6.18 encounters the same problem. v0.8.9 simply segfaults instead. * I have an Overo Water (GS3503W-R2889) on a Tobi. * MLO version: I haven't the foggiest, but I get the U-Boot version string twice, once being before u-boot.bin is loaded. * U-Boot 2012.04.01 (Jul 19 2012 - 17:31:34) * I moved the SD card to a different Water/Tobi pair and I got the same error (illegal instruction, Node.js v0.8.9) It feels like a task swapping bug in the kernel. Perhaps it's related to errata on the OMAP3530. It could also be read timeouts from the swap file on the SD card, though dmesg doesn't say anything of the sort. I found a kernel patch regarding inconsistent caches on ARM, but it hit in 2.6.33 and I'm running 3.2.1. Has anyone seen something like this? Would anyone be willing to replicate the problem? I'd be happy to share my tweaks to Node.js' build system to get it to build. Thanks for reading! Jon Kunkee

11 years, 7 months

[PATCH v2 0/3] Delay switch to Non-Secure Hyp until kernel entry

by Dave Martin

The bootwrapper is really doubling as firmware, so it doesn't make sense for it to drop out of the Secure World before getting a chance to parse its parameters and configuration. Instead, it should make sense to delay switching to the Normal World for as long as possible so that we have a chance to do any required firmware-level configuration in the Secure World first. This quick hack is ***completely untested***, since I'm not working with any suitable kernel tree right now. If someone with a KVM tree ready to run could give it a try, that would definitely save me some time. Review also welcome (naturally) Changes since v1: * Don't rely on preservation of lr or sp across enter_hyp (this doesn't work because those registers are banked per-mode). I'm still not convinced this series works, due image/model/dtb mismatches in my testing, but execution at least reaches the kernel now. Cheers ---Dave Dave Martin (3): bootwrapper: Fix misaligned Hyp mode vector table bootwrapper: Refactor entry into Hyp mode to be more reusable bootwrapper: Delay switch to Hyp mode until kernel entry boot.S | 58 +++++++++++++++++++++++++++++++++++++------------------- semi_loader.h | 6 +++- 2 files changed, 42 insertions(+), 22 deletions(-) -- 1.7.4.1 @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ Dave Martin (3): bootwrapper: Fix misaligned Hyp mode vector table bootwrapper: Refactor entry into Hyp mode to be more reusable bootwrapper: Delay switch to Hyp mode until kernel entry boot.S | 58 +++++++++++++++++++++++++++++++++++++------------------- semi_loader.h | 6 +++- 2 files changed, 42 insertions(+), 22 deletions(-) -- 1.7.4.1

11 years, 7 months

RT patches and Linaro Linux

by Einar Már Björgvinsson

Hi there I'm looking for the correct RT patch (http://www.kernel.org/pub/linux/kernel/projects/rt/) for a Linaro Linux source. Just for a start I tried with linux-linaro-3.4-2012.05-1 with the RT patch patch-3.4-rc2-rt1.patch.bz2 and got some build errors due to undeclared methods/variables. I would like to ask which of these two (linaro-linux and RT patch) goes together ? ps. I checked out question http://ask.linaro.org/questions/336/do-real-time-patches-work-on-ubuntu-bui… and am wondering if that describes it or what ? Regards Einar M. Bjorgvinsson Embedded Software Engineer Marel ehf. Iceland

11 years, 7 months

[Powertop][PATCH v2 1/2] Updates to support Android platform

by Rajagopal Venkat

This patch adds following minor changes to prepare powertop to support Android platform. - Add missing HAVE_CONFIG_H conditional check. - remove un-used ethtool_cmd_speed_set and ethtool_cmd_speed functions. - Minimize dependency on exception handling in catch blocks. These changes will not affect powertop functionality. Signed-off-by: Rajagopal Venkat <rajagopal.venkat(a)linaro.org> --- src/devices/ahci.cpp | 4 ++-- src/devices/alsa.cpp | 4 ++-- src/devices/network.cpp | 16 ---------------- src/main.cpp | 2 ++ 4 files changed, 6 insertions(+), 20 deletions(-) diff --git a/src/devices/ahci.cpp b/src/devices/ahci.cpp index 1fe39c7..67ce06e 100644 --- a/src/devices/ahci.cpp +++ b/src/devices/ahci.cpp @@ -170,7 +170,7 @@ void ahci::start_measurement(void) file.close(); } catch (std::ios_base::failure &c) { - fprintf(stderr, "%s\n", c.what()); + fprintf(stderr, "Failed to start measurement for ahci device\n"); } } @@ -203,7 +203,7 @@ void ahci::end_measurement(void) file.close(); } catch (std::ios_base::failure &c) { - fprintf(stderr, "%s\n", c.what()); + fprintf(stderr, "Failed to end measurement for ahci device\n"); } if (end_active < start_active) end_active = start_active; diff --git a/src/devices/alsa.cpp b/src/devices/alsa.cpp index 4f5d3f9..a67780c 100644 --- a/src/devices/alsa.cpp +++ b/src/devices/alsa.cpp @@ -104,7 +104,7 @@ void alsa::start_measurement(void) file.close(); } catch (std::ios_base::failure &c) { - fprintf(stderr, "%s\n", c.what()); + fprintf(stderr, "Failed to start measurement for alsa device\n"); } } @@ -130,7 +130,7 @@ void alsa::end_measurement(void) file.close(); } catch (std::ios_base::failure &c) { - fprintf(stderr, "%s\n", c.what()); + fprintf(stderr, "Failed to end measurement for alsa device\n"); } p = (end_active - start_active) / (0.001 + end_active + end_inactive - start_active - start_inactive) * 100.0; diff --git a/src/devices/network.cpp b/src/devices/network.cpp index b8a5c9c..ed9d7aa 100644 --- a/src/devices/network.cpp +++ b/src/devices/network.cpp @@ -55,22 +55,6 @@ extern "C" { static map<string, class network *> nics; -#ifdef DISABLE_TRYCATCH - -static inline void ethtool_cmd_speed_set(struct ethtool_cmd *ep, - __u32 speed) -{ - - ep->speed = (__u16)speed; - ep->speed_hi = (__u16)(speed >> 16); -} - -static inline __u32 ethtool_cmd_speed(struct ethtool_cmd *ep) -{ - return (ep->speed_hi << 16) | ep->speed; -} - -#endif static void do_proc_net_dev(void) { diff --git a/src/main.cpp b/src/main.cpp index 1815075..dc49dba 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -42,7 +42,9 @@ #include "perf/perf.h" #include "perf/perf_bundle.h" #include "lib.h" +#ifdef HAVE_CONFIG_H #include "../config.h" +#endif #include "devices/device.h" -- 1.7.11.3

11 years, 7 months

[PATCH] timers: Avoid finding cpu for migration of running timers in __mod_timer()

by Viresh Kumar

Currently we don't support migration of currently running timers. Current code flow in __mod_timer() is: - Find a cpu where we should migrate the timer - Check if timer is currently running - If yes, don't migrate. In this process, the first step is a unnecessary activiy, if the timer is currently running. This patch tries to avoid it in such cases. Signed-off-by: Viresh Kumar <viresh.kumar(a)linaro.org> --- kernel/timer.c | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/kernel/timer.c b/kernel/timer.c index 8c5e7b9..6e5bf98 100644 --- a/kernel/timer.c +++ b/kernel/timer.c @@ -755,23 +755,23 @@ __mod_timer(struct timer_list *timer, unsigned long expires, debug_activate(timer, expires); - cpu = smp_processor_id(); + /* + * Should we try to migrate timer? + * However we can't change timer's base while it is running, otherwise + * del_timer_sync() can't detect that the timer's handler yet has not + * finished. This also guarantees that the timer is serialized wrt + * itself. + */ + if (likely(base->running_timer != timer)) { + cpu = smp_processor_id(); #if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP) - if (!pinned && get_sysctl_timer_migration() && idle_cpu(cpu)) - cpu = get_nohz_timer_target(); + if (!pinned && get_sysctl_timer_migration() && idle_cpu(cpu)) + cpu = get_nohz_timer_target(); #endif - new_base = per_cpu(tvec_bases, cpu); + new_base = per_cpu(tvec_bases, cpu); - if (base != new_base) { - /* - * We are trying to schedule the timer on the local CPU. - * However we can't change timer's base while it is running, - * otherwise del_timer_sync() can't detect that the timer's - * handler yet has not finished. This also guarantees that - * the timer is serialized wrt itself. - */ - if (likely(base->running_timer != timer)) { + if (base != new_base) { /* See the comment in lock_timer_base() */ timer_set_base(timer, NULL); spin_unlock(&base->lock); -- 1.7.12.rc2.18.g61b472e

11 years, 7 months

Work around for building Linaro Android 12.08

by Zach Pfeffer

For people trying to build Linaro Android 12.08 there's an issue with an unknown reference in powertop2.0. Here's what to do: cd android edit .repo/manifest.xml Find: <project groups="path:external/powertop,name:tools/powertop-2.0" name="tools/powertop-2.0" path="exter\ nal/powertop" remote="linaro-other" revision="c80f55d9d1b823b7f6ff447eefc8a6ba04b939c4"/> ...and remove the line. Then cp .repo/manifest.xml ../ cd .. rm -rf android/ edit linaro_android_build_cmds.sh and change curl -k http://snapshots.linaro.org/android/~linaro-android/vexpress-jb-gcc47-armlt… > .repo/manifest.xml to cp ../manifest.xml .repo/ and rerun linaro_android_build_cmds.sh You can also take a tip build which is not susceptible to this problem. Tip builds that have been booted are listed at: https://docs.google.com/a/linaro.org/spreadsheet/ccc?key=0AnpUtxWjZbP9dGg0d… If you still get errors after this, then its a general git timeout error. Just delete the android/ directory and start again or cd android/; repo ./sync -- Zach Pfeffer Android Platform Team Lead, Linaro Platform Teams Linaro.org | Open source software for ARM SoCs Follow Linaro: http://www.facebook.com/pages/Linaro http://twitter.com/#!/linaroorg - http://www.linaro.org/linaro-blog

11 years, 7 months

[RFC PATCH v8] media: add v4l2 subdev driver for S5K4ECGX sensor

by Sangwook Lee

This patch adds driver for S5K4ECGX sensor with embedded ISP SoC, S5K4ECGX, which is a 5M CMOS Image sensor from Samsung The driver implements preview mode of the S5K4ECGX sensor. capture (snapshot) operation, face detection are missing now. Following controls are supported: contrast/saturation/brightness/sharpness Signed-off-by: Sangwook Lee <sangwook.lee(a)linaro.org> Reviewed-by: Sylwester Nawrocki <s.nawrocki(a)samsung.com> Cc: Francesco Lavra <francescolavra.fl(a)gmail.com> Cc: Scott Bambrough <scott.bambrough(a)linaro.org> Cc: Homin Lee <suapapa(a)insignal.co.kr> --- Changes since v7: - added gpio free function - fixed return value of power function Changes since v6: - fixed alignment issue from Francesco, Sylwester Changes since v5: - deleted dummy lines - fixed pointer errors in handling firmware - updated comments - added le32_to_cpu,le16_to_cpu Changes since v4: - replaced register tables with the function from Sylwester - updated firmware parsing function with CRC32 check firmware generator from user space: git://git.linaro.org/people/sangwook/fimc-v4l2-app.git Changes since v3: - used request_firmware to configure initial settings - added parsing functions to read initial settings - updated regulator API - reduced preview setting tables by experiment Changes since v2: - added GPIO (reset/stby) and regulators - updated I2C read/write, based on s5k6aa datasheet - fixed set_fmt errors - reduced register tables a bit - removed vmalloc Changes since v1: - fixed s_stream(0) when it called twice - changed mutex_X position to be used when strictly necessary - add additional s_power(0) in case that error happens - update more accurate debugging statements - remove dummy else drivers/media/i2c/Kconfig | 7 + drivers/media/i2c/Makefile | 1 + drivers/media/i2c/s5k4ecgx.c | 1017 ++++++++++++++++++++++++++++++++++++++++++ include/media/s5k4ecgx.h | 37 ++ 4 files changed, 1062 insertions(+) create mode 100644 drivers/media/i2c/s5k4ecgx.c create mode 100644 include/media/s5k4ecgx.h diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig index 9a5a059..55b3bbb 100644 --- a/drivers/media/i2c/Kconfig +++ b/drivers/media/i2c/Kconfig @@ -484,6 +484,13 @@ config VIDEO_S5K6AA This is a V4L2 sensor-level driver for Samsung S5K6AA(FX) 1.3M camera sensor with an embedded SoC image signal processor. +config VIDEO_S5K4ECGX + tristate "Samsung S5K4ECGX sensor support" + depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API + ---help--- + This is a V4L2 sensor-level driver for Samsung S5K4ECGX 5M + camera sensor with an embedded SoC image signal processor. + source "drivers/media/i2c/smiapp/Kconfig" comment "Flash devices" diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile index 088a460..a720812 100644 --- a/drivers/media/i2c/Makefile +++ b/drivers/media/i2c/Makefile @@ -55,6 +55,7 @@ obj-$(CONFIG_VIDEO_MT9V032) += mt9v032.o obj-$(CONFIG_VIDEO_SR030PC30) += sr030pc30.o obj-$(CONFIG_VIDEO_NOON010PC30) += noon010pc30.o obj-$(CONFIG_VIDEO_S5K6AA) += s5k6aa.o +obj-$(CONFIG_VIDEO_S5K4ECGX) += s5k4ecgx.o obj-$(CONFIG_VIDEO_ADP1653) += adp1653.o obj-$(CONFIG_VIDEO_AS3645A) += as3645a.o obj-$(CONFIG_VIDEO_SMIAPP_PLL) += smiapp-pll.o diff --git a/drivers/media/i2c/s5k4ecgx.c b/drivers/media/i2c/s5k4ecgx.c new file mode 100644 index 0000000..7b455e1 --- /dev/null +++ b/drivers/media/i2c/s5k4ecgx.c @@ -0,0 +1,1017 @@ +/* + * Driver for s5k4ecgx (5MP Camera) from Samsung + * a quarter-inch optical format 1.4 micron 5 megapixel (Mp) + * CMOS image sensor. + * + * Copyright (C) 2012, Linaro, Sangwook Lee <sangwook.lee(a)linaro.org> + * Copyright (C) 2012, Insignal Co,. Ltd, Homin Lee <suapapa(a)insignal.co.kr> + * + * Based on s5k6aa, noon010pc30 driver + * Copyright (C) 2011, 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 2 of the License, or + * (at your option) any later version. + */ + +#include <linux/clk.h> +#include <linux/crc32.h> +#include <linux/ctype.h> +#include <linux/delay.h> +#include <linux/firmware.h> +#include <linux/gpio.h> +#include <linux/i2c.h> +#include <linux/module.h> +#include <linux/regulator/consumer.h> +#include <linux/slab.h> +#include <asm/unaligned.h> + +#include <media/media-entity.h> +#include <media/s5k4ecgx.h> +#include <media/v4l2-ctrls.h> +#include <media/v4l2-device.h> +#include <media/v4l2-mediabus.h> +#include <media/v4l2-subdev.h> + +static int debug; +module_param(debug, int, 0644); + +#define S5K4ECGX_DRIVER_NAME "s5k4ecgx" +#define S5K4ECGX_FIRMWARE "s5k4ecgx.bin" + +/* Firmware revision information */ +#define REG_FW_REVISION 0x700001a6 +#define REG_FW_VERSION 0x700001a4 +#define S5K4ECGX_REVISION_1_1 0x11 +#define S5K4ECGX_FW_VERSION 0x4ec0 + +/* General purpose parameters */ +#define REG_USER_BRIGHTNESS 0x7000022c +#define REG_USER_CONTRAST 0x7000022e +#define REG_USER_SATURATION 0x70000230 + +#define REG_G_NEW_CFG_SYNC 0x7000024a +#define REG_G_PREV_IN_WIDTH 0x70000250 +#define REG_G_PREV_IN_HEIGHT 0x70000252 +#define REG_G_PREV_IN_XOFFS 0x70000254 +#define REG_G_PREV_IN_YOFFS 0x70000256 +#define REG_G_CAP_IN_WIDTH 0x70000258 +#define REG_G_CAP_IN_HEIGHT 0x7000025a +#define REG_G_CAP_IN_XOFFS 0x7000025c +#define REG_G_CAP_IN_YOFFS 0x7000025e +#define REG_G_INPUTS_CHANGE_REQ 0x70000262 +#define REG_G_ACTIVE_PREV_CFG 0x70000266 +#define REG_G_PREV_CFG_CHG 0x70000268 +#define REG_G_PREV_OPEN_AFTER_CH 0x7000026a + +/* Preview context register sets. n = 0...4. */ +#define PREG(n, x) ((n) * 0x30 + (x)) +#define REG_P_OUT_WIDTH(n) PREG(n, 0x700002a6) +#define REG_P_OUT_HEIGHT(n) PREG(n, 0x700002a8) +#define REG_P_FMT(n) PREG(n, 0x700002aa) +#define REG_P_PVI_MASK(n) PREG(n, 0x700002b4) +#define REG_P_FR_TIME_TYPE(n) PREG(n, 0x700002be) +#define FR_TIME_DYNAMIC 0 +#define FR_TIME_FIXED 1 +#define FR_TIME_FIXED_ACCURATE 2 +#define REG_P_FR_TIME_Q_TYPE(n) PREG(n, 0x700002c0) +#define FR_TIME_Q_DYNAMIC 0 +#define FR_TIME_Q_BEST_FRRATE 1 +#define FR_TIME_Q_BEST_QUALITY 2 + +/* Frame period in 0.1 ms units */ +#define REG_P_MAX_FR_TIME(n) PREG(n, 0x700002c2) +#define REG_P_MIN_FR_TIME(n) PREG(n, 0x700002c4) +#define US_TO_FR_TIME(__t) ((__t) / 100) +#define REG_P_PREV_MIRROR(n) PREG(n, 0x700002d0) +#define REG_P_CAP_MIRROR(n) PREG(n, 0x700002d2) + +#define REG_G_PREVZOOM_IN_WIDTH 0x70000494 +#define REG_G_PREVZOOM_IN_HEIGHT 0x70000496 +#define REG_G_PREVZOOM_IN_XOFFS 0x70000498 +#define REG_G_PREVZOOM_IN_YOFFS 0x7000049a +#define REG_G_CAPZOOM_IN_WIDTH 0x7000049c +#define REG_G_CAPZOOM_IN_HEIGHT 0x7000049e +#define REG_G_CAPZOOM_IN_XOFFS 0x700004a0 +#define REG_G_CAPZOOM_IN_YOFFS 0x700004a2 + +/* n = 0...4 */ +#define REG_USER_SHARPNESS(n) (0x70000a28 + (n) * 0xb6) + +/* Reduce sharpness range for user space API */ +#define SHARPNESS_DIV 8208 +#define TOK_TERM 0xffffffff + +/* + * FIXME: This is copied from s5k6aa, because of no information + * in the S5K4ECGX datasheet. + * H/W register Interface (0xd0000000 - 0xd0000fff) + */ +#define AHB_MSB_ADDR_PTR 0xfcfc +#define GEN_REG_OFFSH 0xd000 +#define REG_CMDWR_ADDRH 0x0028 +#define REG_CMDWR_ADDRL 0x002a +#define REG_CMDRD_ADDRH 0x002c +#define REG_CMDRD_ADDRL 0x002e +#define REG_CMDBUF0_ADDR 0x0f12 + +struct s5k4ecgx_frmsize { + struct v4l2_frmsize_discrete size; + /* Fixed sensor matrix crop rectangle */ + struct v4l2_rect input_window; +}; + +struct regval_list { + u32 addr; + u16 val; +}; + +/* + * TODO: currently only preview is supported and snapshot (capture) + * is not implemented yet + */ +static const struct s5k4ecgx_frmsize s5k4ecgx_prev_sizes[] = { + { + .size = { 176, 144 }, + .input_window = { 0x00, 0x00, 0x928, 0x780 }, + }, { + .size = { 352, 288 }, + .input_window = { 0x00, 0x00, 0x928, 0x780 }, + }, { + .size = { 640, 480 }, + .input_window = { 0x00, 0x00, 0xa00, 0x780 }, + }, { + .size = { 720, 480 }, + .input_window = { 0x00, 0x00, 0xa00, 0x6a8 }, + } +}; + +#define S5K4ECGX_NUM_PREV ARRAY_SIZE(s5k4ecgx_prev_sizes) + +struct s5k4ecgx_pixfmt { + enum v4l2_mbus_pixelcode code; + u32 colorspace; + /* REG_TC_PCFG_Format register value */ + u16 reg_p_format; +}; + +/* By default value, output from sensor will be YUV422 0-255 */ +static const struct s5k4ecgx_pixfmt s5k4ecgx_formats[] = { + { V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG, 5 }, +}; + +static const char * const s5k4ecgx_supply_names[] = { + /* + * Usually 2.8V is used for analog power (vdda) + * and digital IO (vddio, vdddcore) + */ + "vdda", + "vddio", + "vddcore", + "vddreg", /* The internal s5k4ecgx regulator's supply (1.8V) */ +}; + +#define S5K4ECGX_NUM_SUPPLIES ARRAY_SIZE(s5k4ecgx_supply_names) + +enum s5k4ecgx_gpio_id { + STBY, + RST, + GPIO_NUM, +}; + +struct s5k4ecgx { + struct v4l2_subdev sd; + struct media_pad pad; + struct v4l2_ctrl_handler handler; + + struct s5k4ecgx_platform_data *pdata; + const struct s5k4ecgx_pixfmt *curr_pixfmt; + const struct s5k4ecgx_frmsize *curr_frmsize; + struct mutex lock; + u8 streaming; + u8 set_params; + + struct regulator_bulk_data supplies[S5K4ECGX_NUM_SUPPLIES]; + struct s5k4ecgx_gpio gpio[GPIO_NUM]; +}; + +static inline struct s5k4ecgx *to_s5k4ecgx(struct v4l2_subdev *sd) +{ + return container_of(sd, struct s5k4ecgx, sd); +} + +static int s5k4ecgx_i2c_read(struct i2c_client *client, u16 addr, u16 *val) +{ + u8 wbuf[2] = { addr >> 8, addr & 0xff }; + struct i2c_msg msg[2]; + u8 rbuf[2]; + int ret; + + msg[0].addr = client->addr; + msg[0].flags = 0; + msg[0].len = 2; + msg[0].buf = wbuf; + + msg[1].addr = client->addr; + msg[1].flags = I2C_M_RD; + msg[1].len = 2; + msg[1].buf = rbuf; + + ret = i2c_transfer(client->adapter, msg, 2); + *val = be16_to_cpu(*((u16 *)rbuf)); + + v4l2_dbg(4, debug, client, "i2c_read: 0x%04X : 0x%04x\n", addr, *val); + + return ret == 2 ? 0 : ret; +} + +static int s5k4ecgx_i2c_write(struct i2c_client *client, u16 addr, u16 val) +{ + u8 buf[4] = { addr >> 8, addr & 0xff, val >> 8, val & 0xff }; + + int ret = i2c_master_send(client, buf, 4); + v4l2_dbg(4, debug, client, "i2c_write: 0x%04x : 0x%04x\n", addr, val); + + return ret == 4 ? 0 : ret; +} + +static int s5k4ecgx_write(struct i2c_client *client, u32 addr, u16 val) +{ + u16 high = addr >> 16, low = addr & 0xffff; + int ret; + + v4l2_dbg(3, debug, client, "write: 0x%08x : 0x%04x\n", addr, val); + ret = s5k4ecgx_i2c_write(client, REG_CMDWR_ADDRH, high); + if (!ret) + ret = s5k4ecgx_i2c_write(client, REG_CMDWR_ADDRL, low); + if (!ret) + ret = s5k4ecgx_i2c_write(client, REG_CMDBUF0_ADDR, val); + + return ret; +} + +static int s5k4ecgx_read(struct i2c_client *client, u32 addr, u16 *val) +{ + u16 high = addr >> 16, low = addr & 0xffff; + int ret; + + ret = s5k4ecgx_i2c_write(client, REG_CMDRD_ADDRH, high); + if (!ret) + ret = s5k4ecgx_i2c_write(client, REG_CMDRD_ADDRL, low); + if (!ret) + ret = s5k4ecgx_i2c_read(client, REG_CMDBUF0_ADDR, val); + if (!ret) + dev_err(&client->dev, "Failed to execute read command\n"); + + return ret; +} + +static int s5k4ecgx_read_fw_ver(struct v4l2_subdev *sd) +{ + struct i2c_client *client = v4l2_get_subdevdata(sd); + u16 hw_rev, fw_ver = 0; + int ret; + + ret = s5k4ecgx_read(client, REG_FW_VERSION, &fw_ver); + if (ret < 0 || fw_ver != S5K4ECGX_FW_VERSION) { + v4l2_err(sd, "FW version check failed!\n"); + return -ENODEV; + } + + ret = s5k4ecgx_read(client, REG_FW_REVISION, &hw_rev); + if (ret < 0) + return ret; + + v4l2_info(sd, "chip found FW ver: 0x%x, HW rev: 0x%x\n", + fw_ver, hw_rev); + return 0; +} + +static int s5k4ecgx_set_ahb_address(struct v4l2_subdev *sd) +{ + int ret; + struct i2c_client *client = v4l2_get_subdevdata(sd); + + /* Set APB peripherals start address */ + ret = s5k4ecgx_i2c_write(client, AHB_MSB_ADDR_PTR, GEN_REG_OFFSH); + if (ret) + return ret; + /* + * FIXME: This is copied from s5k6aa, because of no information + * in s5k4ecgx's datasheet. + * sw_reset is activated to put device into idle status + */ + ret = s5k4ecgx_i2c_write(client, 0x0010, 0x0001); + if (ret) + return ret; + + ret = s5k4ecgx_i2c_write(client, 0x1030, 0x0000); + if (ret) + return ret; + /* Halt ARM CPU */ + return s5k4ecgx_i2c_write(client, 0x0014, 0x0001); +} + +#define FW_CRC_SIZE 4 +/* Register address, value are 4, 2 bytes */ +#define FW_RECORD_SIZE 6 +/* + * Firmware has the following format: + * <total number of records (4-bytes + 2-bytes padding) N >, < record 0 >, + * < record N - 1 >, < CRC32-CCITT (4-bytes) >, CRC32(4 bytes) + * where "record" is a 4-byte register address followed by 2-byte + * register value (little endian) + */ +static int s5k4ecgx_load_firmware(struct v4l2_subdev *sd) +{ + const struct firmware *fw; + const u8 *ptr; + int err, i, regs_num; + struct i2c_client *client = v4l2_get_subdevdata(sd); + u16 val; + u32 addr, crc, crc_file, addr_inc = 0; + + err = request_firmware(&fw, S5K4ECGX_FIRMWARE, sd->v4l2_dev->dev); + if (err) { + v4l2_err(sd, "Failed to read firmware %s\n", S5K4ECGX_FIRMWARE); + return err; + } + regs_num = le32_to_cpu(get_unaligned_le32(fw->data)); + v4l2_dbg(3, debug, sd, "FW: %s size %d register sets %d\n", + S5K4ECGX_FIRMWARE, fw->size, regs_num); + regs_num++; /* Add header */ + if (fw->size != regs_num * FW_RECORD_SIZE + FW_CRC_SIZE) { + err = -EINVAL; + goto fw_out; + } + crc_file = le32_to_cpu(get_unaligned_le32(fw->data + + regs_num * FW_RECORD_SIZE)); + crc = crc32_le(~0, fw->data, regs_num * FW_RECORD_SIZE); + if (crc != crc_file) { + v4l2_err(sd, "FW: invalid crc (%#x:%#x)\n", crc, crc_file); + err = -EINVAL; + goto fw_out; + } + ptr = fw->data + FW_RECORD_SIZE; + for (i = 1; i < regs_num; i++) { + addr = le32_to_cpu(get_unaligned_le32(ptr)); + ptr += sizeof(u32); + val = le16_to_cpu(get_unaligned_le16(ptr)); + ptr += sizeof(u16); + if (addr - addr_inc != 2) + err = s5k4ecgx_write(client, addr, val); + else + err = s5k4ecgx_i2c_write(client, REG_CMDBUF0_ADDR, val); + if (err) + break; + addr_inc = addr; + } +fw_out: + release_firmware(fw); + + return err; +} + +/* Set preview and capture input window */ +static int s5k4ecgx_set_input_window(struct i2c_client *c, + const struct v4l2_rect *r) +{ + int ret; + + ret = s5k4ecgx_write(c, REG_G_PREV_IN_WIDTH, r->width); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_PREV_IN_HEIGHT, r->height); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_PREV_IN_XOFFS, r->left); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_PREV_IN_YOFFS, r->top); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_CAP_IN_WIDTH, r->width); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_CAP_IN_HEIGHT, r->height); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_CAP_IN_XOFFS, r->left); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_CAP_IN_YOFFS, r->top); + + return ret; +} + +/* Set preview and capture zoom input window */ +static int s5k4ecgx_set_zoom_window(struct i2c_client *c, + const struct v4l2_rect *r) +{ + int ret; + + ret = s5k4ecgx_write(c, REG_G_PREVZOOM_IN_WIDTH, r->width); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_PREVZOOM_IN_HEIGHT, r->height); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_PREVZOOM_IN_XOFFS, r->left); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_PREVZOOM_IN_YOFFS, r->top); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_CAPZOOM_IN_WIDTH, r->width); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_CAPZOOM_IN_HEIGHT, r->height); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_CAPZOOM_IN_XOFFS, r->left); + if (!ret) + ret = s5k4ecgx_write(c, REG_G_CAPZOOM_IN_YOFFS, r->top); + + return ret; +} + +static int s5k4ecgx_set_output_framefmt(struct s5k4ecgx *priv) +{ + struct i2c_client *client = v4l2_get_subdevdata(&priv->sd); + int ret; + + ret = s5k4ecgx_write(client, REG_P_OUT_WIDTH(0), + priv->curr_frmsize->size.width); + if (!ret) + ret = s5k4ecgx_write(client, REG_P_OUT_HEIGHT(0), + priv->curr_frmsize->size.height); + if (!ret) + ret = s5k4ecgx_write(client, REG_P_FMT(0), + priv->curr_pixfmt->reg_p_format); + return ret; +} + +static int s5k4ecgx_init_sensor(struct v4l2_subdev *sd) +{ + int ret; + + ret = s5k4ecgx_set_ahb_address(sd); + /* The delay is from manufacturer's settings */ + msleep(100); + + if (!ret) + ret = s5k4ecgx_load_firmware(sd); + if (ret) + v4l2_err(sd, "Failed to write initial settings\n"); + + return ret; +} + +static int s5k4ecgx_gpio_set_value(struct s5k4ecgx *priv, int id, u32 val) +{ + if (!gpio_is_valid(priv->gpio[id].gpio)) + return 0; + gpio_set_value(priv->gpio[id].gpio, val); + + return 1; +} + +static int __s5k4ecgx_power_on(struct s5k4ecgx *priv) +{ + int ret; + + ret = regulator_bulk_enable(S5K4ECGX_NUM_SUPPLIES, priv->supplies); + if (ret) + return ret; + usleep_range(30, 50); + + /* The polarity of STBY is controlled by TSP */ + if (s5k4ecgx_gpio_set_value(priv, STBY, priv->gpio[STBY].level)) + usleep_range(30, 50); + + if (s5k4ecgx_gpio_set_value(priv, RST, priv->gpio[RST].level)) + usleep_range(30, 50); + + return 0; +} + +static int __s5k4ecgx_power_off(struct s5k4ecgx *priv) +{ + if (s5k4ecgx_gpio_set_value(priv, RST, !priv->gpio[RST].level)) + usleep_range(30, 50); + + if (s5k4ecgx_gpio_set_value(priv, STBY, !priv->gpio[STBY].level)) + usleep_range(30, 50); + + priv->streaming = 0; + + return regulator_bulk_disable(S5K4ECGX_NUM_SUPPLIES, priv->supplies); +} + +/* Find nearest matching image pixel size. */ +static int s5k4ecgx_try_frame_size(struct v4l2_mbus_framefmt *mf, + const struct s5k4ecgx_frmsize **size) +{ + unsigned int min_err = ~0; + int i = ARRAY_SIZE(s5k4ecgx_prev_sizes); + const struct s5k4ecgx_frmsize *fsize = &s5k4ecgx_prev_sizes[0], + *match = NULL; + + while (i--) { + int err = abs(fsize->size.width - mf->width) + + abs(fsize->size.height - mf->height); + if (err < min_err) { + min_err = err; + match = fsize; + } + fsize++; + } + if (match) { + mf->width = match->size.width; + mf->height = match->size.height; + if (size) + *size = match; + return 0; + } + + return -EINVAL; +} + +static int s5k4ecgx_enum_mbus_code(struct v4l2_subdev *sd, + struct v4l2_subdev_fh *fh, + struct v4l2_subdev_mbus_code_enum *code) +{ + if (code->index >= ARRAY_SIZE(s5k4ecgx_formats)) + return -EINVAL; + code->code = s5k4ecgx_formats[code->index].code; + + return 0; +} + +static int s5k4ecgx_get_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh, + struct v4l2_subdev_format *fmt) +{ + struct s5k4ecgx *priv = to_s5k4ecgx(sd); + struct v4l2_mbus_framefmt *mf; + + if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { + if (fh) { + mf = v4l2_subdev_get_try_format(fh, 0); + fmt->format = *mf; + } + return 0; + } + + mf = &fmt->format; + + mutex_lock(&priv->lock); + mf->width = priv->curr_frmsize->size.width; + mf->height = priv->curr_frmsize->size.height; + mf->code = priv->curr_pixfmt->code; + mf->colorspace = priv->curr_pixfmt->colorspace; + mf->field = V4L2_FIELD_NONE; + mutex_unlock(&priv->lock); + + return 0; +} + +static const struct s5k4ecgx_pixfmt *s5k4ecgx_try_fmt(struct v4l2_subdev *sd, + struct v4l2_mbus_framefmt *mf) +{ + int i = ARRAY_SIZE(s5k4ecgx_formats); + + while (--i) + if (mf->code == s5k4ecgx_formats[i].code) + break; + mf->code = s5k4ecgx_formats[i].code; + + return &s5k4ecgx_formats[i]; +} + +static int s5k4ecgx_set_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh, + struct v4l2_subdev_format *fmt) +{ + struct s5k4ecgx *priv = to_s5k4ecgx(sd); + const struct s5k4ecgx_frmsize *fsize = NULL; + const struct s5k4ecgx_pixfmt *pf; + struct v4l2_mbus_framefmt *mf; + int ret = 0; + + pf = s5k4ecgx_try_fmt(sd, &fmt->format); + s5k4ecgx_try_frame_size(&fmt->format, &fsize); + fmt->format.colorspace = V4L2_COLORSPACE_JPEG; + + if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { + if (fh) { + mf = v4l2_subdev_get_try_format(fh, 0); + *mf = fmt->format; + } + return 0; + } + + mutex_lock(&priv->lock); + if (!priv->streaming) { + priv->curr_frmsize = fsize; + priv->curr_pixfmt = pf; + priv->set_params = 1; + } else { + ret = -EBUSY; + } + mutex_unlock(&priv->lock); + + return ret; +} + +static const struct v4l2_subdev_pad_ops s5k4ecgx_pad_ops = { + .enum_mbus_code = s5k4ecgx_enum_mbus_code, + .get_fmt = s5k4ecgx_get_fmt, + .set_fmt = s5k4ecgx_set_fmt, +}; + +/* + * V4L2 subdev controls + */ +static int s5k4ecgx_s_ctrl(struct v4l2_ctrl *ctrl) +{ + struct v4l2_subdev *sd = &container_of(ctrl->handler, struct s5k4ecgx, + handler)->sd; + struct i2c_client *client = v4l2_get_subdevdata(sd); + struct s5k4ecgx *priv = to_s5k4ecgx(sd); + unsigned int i; + int err = 0; + + v4l2_dbg(1, debug, sd, "ctrl: 0x%x, value: %d\n", ctrl->id, ctrl->val); + + mutex_lock(&priv->lock); + switch (ctrl->id) { + case V4L2_CID_CONTRAST: + err = s5k4ecgx_write(client, REG_USER_CONTRAST, ctrl->val); + break; + + case V4L2_CID_SATURATION: + err = s5k4ecgx_write(client, REG_USER_SATURATION, ctrl->val); + break; + + case V4L2_CID_SHARPNESS: + /* TODO: Revisit, is this setting for all presets ? */ + for (i = 0; i < 4 && !err; i++) + err = s5k4ecgx_write(client, REG_USER_SHARPNESS(i), + ctrl->val * SHARPNESS_DIV); + break; + + case V4L2_CID_BRIGHTNESS: + err = s5k4ecgx_write(client, REG_USER_BRIGHTNESS, ctrl->val); + break; + } + mutex_unlock(&priv->lock); + if (err < 0) + v4l2_err(sd, "Failed to write s_ctrl err %d\n", err); + + return err; +} + +static const struct v4l2_ctrl_ops s5k4ecgx_ctrl_ops = { + .s_ctrl = s5k4ecgx_s_ctrl, +}; + +/* + * Reading s5k4ecgx version information + */ +static int s5k4ecgx_registered(struct v4l2_subdev *sd) +{ + int ret; + struct s5k4ecgx *priv = to_s5k4ecgx(sd); + + mutex_lock(&priv->lock); + ret = __s5k4ecgx_power_on(priv); + if (!ret) { + ret = s5k4ecgx_read_fw_ver(sd); + __s5k4ecgx_power_off(priv); + } + mutex_unlock(&priv->lock); + + return ret; +} + +/* + * V4L2 subdev internal operations + */ +static int s5k4ecgx_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) +{ + struct v4l2_mbus_framefmt *mf = v4l2_subdev_get_try_format(fh, 0); + + mf->width = s5k4ecgx_prev_sizes[0].size.width; + mf->height = s5k4ecgx_prev_sizes[0].size.height; + mf->code = s5k4ecgx_formats[0].code; + mf->colorspace = V4L2_COLORSPACE_JPEG; + mf->field = V4L2_FIELD_NONE; + + return 0; +} + +static const struct v4l2_subdev_internal_ops s5k4ecgx_subdev_internal_ops = { + .registered = s5k4ecgx_registered, + .open = s5k4ecgx_open, +}; + +static int s5k4ecgx_s_power(struct v4l2_subdev *sd, int on) +{ + struct s5k4ecgx *priv = to_s5k4ecgx(sd); + int ret; + + v4l2_dbg(1, debug, sd, "Switching %s\n", on ? "on" : "off"); + + if (on) { + ret = __s5k4ecgx_power_on(priv); + if (ret < 0) + return ret; + /* Time to stabilize sensor */ + msleep(100); + ret = s5k4ecgx_init_sensor(sd); + if (ret < 0) + __s5k4ecgx_power_off(priv); + else + priv->set_params = 1; + } else { + ret = __s5k4ecgx_power_off(priv); + } + + return ret; +} + +static int s5k4ecgx_log_status(struct v4l2_subdev *sd) +{ + v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name); + + return 0; +} + +static const struct v4l2_subdev_core_ops s5k4ecgx_core_ops = { + .s_power = s5k4ecgx_s_power, + .log_status = s5k4ecgx_log_status, +}; + +static int __s5k4ecgx_s_stream(struct s5k4ecgx *priv, int on) +{ + struct i2c_client *client = v4l2_get_subdevdata(&priv->sd); + const struct v4l2_rect *crop_rect = &priv->curr_frmsize->input_window; + int ret = 0; + + /* TODO: Add s_stream(0) handling */ + + if (!on || !priv->set_params) + return 0; + + ret = s5k4ecgx_set_input_window(client, crop_rect); + if (!ret) + ret = s5k4ecgx_set_zoom_window(client, crop_rect); + if (!ret) + ret = s5k4ecgx_write(client, REG_G_INPUTS_CHANGE_REQ, 1); + if (!ret) + ret = s5k4ecgx_write(client, 0x70000a1e, 0x28); + if (!ret) + ret = s5k4ecgx_write(client, 0x70000ad4, 0x3c); + if (!ret) + ret = s5k4ecgx_set_output_framefmt(priv); + if (!ret) + ret = s5k4ecgx_write(client, REG_P_PVI_MASK(0), 0x52); + if (!ret) + ret = s5k4ecgx_write(client, REG_P_FR_TIME_TYPE(0), + FR_TIME_DYNAMIC); + if (!ret) + ret = s5k4ecgx_write(client, REG_P_FR_TIME_Q_TYPE(0), + FR_TIME_Q_BEST_FRRATE); + if (!ret) + ret = s5k4ecgx_write(client, REG_P_MIN_FR_TIME(0), + US_TO_FR_TIME(33300)); + if (!ret) + ret = s5k4ecgx_write(client, REG_P_MAX_FR_TIME(0), + US_TO_FR_TIME(66600)); + if (!ret) + ret = s5k4ecgx_write(client, REG_P_PREV_MIRROR(0), 0); + if (!ret) + ret = s5k4ecgx_write(client, REG_P_CAP_MIRROR(0), 0); + if (!ret) + ret = s5k4ecgx_write(client, REG_G_ACTIVE_PREV_CFG, 0); + if (!ret) + ret = s5k4ecgx_write(client, REG_G_PREV_OPEN_AFTER_CH, 1); + if (!ret) + ret = s5k4ecgx_write(client, REG_G_NEW_CFG_SYNC, 1); + if (!ret) + ret = s5k4ecgx_write(client, REG_G_PREV_CFG_CHG, 1); + if (!ret) + priv->set_params = 0; + + return ret; +} + +static int s5k4ecgx_s_stream(struct v4l2_subdev *sd, int on) +{ + struct s5k4ecgx *priv = to_s5k4ecgx(sd); + int ret = 0; + + v4l2_dbg(1, debug, sd, "Turn streaming %s\n", on ? "on" : "off"); + + mutex_lock(&priv->lock); + if (on) { + /* Ignore if s_stream is called twice */ + if (priv->streaming == !on) { + ret = __s5k4ecgx_s_stream(priv, on); + if (!ret) + priv->streaming = on & 1; + } + } + mutex_unlock(&priv->lock); + + return ret; +} + +static const struct v4l2_subdev_video_ops s5k4ecgx_video_ops = { + .s_stream = s5k4ecgx_s_stream, +}; + +static const struct v4l2_subdev_ops s5k4ecgx_ops = { + .core = &s5k4ecgx_core_ops, + .pad = &s5k4ecgx_pad_ops, + .video = &s5k4ecgx_video_ops, +}; + +/* + * GPIO setup + */ +static int s5k4ecgx_config_gpio(int nr, int val, const char *name) +{ + unsigned long flags = val ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW; + int ret; + + if (!gpio_is_valid(nr)) + return 0; + ret = gpio_request_one(nr, flags, name); + if (!ret) + gpio_export(nr, 0); + + return ret; +} + +static void s5k4ecgx_free_gpios(struct s5k4ecgx *priv) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(priv->gpio); i++) { + if (!gpio_is_valid(priv->gpio[i].gpio)) + continue; + gpio_free(priv->gpio[i].gpio); + priv->gpio[i].gpio = -EINVAL; + } +} + +static int s5k4ecgx_config_gpios(struct s5k4ecgx *priv, + const struct s5k4ecgx_platform_data *pdata) +{ + const struct s5k4ecgx_gpio *gpio = &pdata->gpio_stby; + int ret; + + priv->gpio[STBY].gpio = -EINVAL; + priv->gpio[RST].gpio = -EINVAL; + + ret = s5k4ecgx_config_gpio(gpio->gpio, gpio->level, "S5K4ECGX_STBY"); + + if (ret) { + s5k4ecgx_free_gpios(priv); + return ret; + } + priv->gpio[STBY] = *gpio; + if (gpio_is_valid(gpio->gpio)) + gpio_set_value(gpio->gpio, 0); + + gpio = &pdata->gpio_reset; + + ret = s5k4ecgx_config_gpio(gpio->gpio, gpio->level, "S5K4ECGX_RST"); + if (ret) { + s5k4ecgx_free_gpios(priv); + return ret; + } + priv->gpio[RST] = *gpio; + if (gpio_is_valid(gpio->gpio)) + gpio_set_value(gpio->gpio, 0); + + return 0; +} + +static int s5k4ecgx_init_v4l2_ctrls(struct s5k4ecgx *priv) +{ + const struct v4l2_ctrl_ops *ops = &s5k4ecgx_ctrl_ops; + struct v4l2_ctrl_handler *hdl = &priv->handler; + int ret; + + ret = v4l2_ctrl_handler_init(hdl, 4); + if (ret) + return ret; + + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_BRIGHTNESS, -208, 127, 1, 0); + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_CONTRAST, -127, 127, 1, 0); + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_SATURATION, -127, 127, 1, 0); + + /* Sharpness default is 24612, and then (24612/SHARPNESS_DIV) = 2 */ + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_SHARPNESS, -32704/SHARPNESS_DIV, + 24612/SHARPNESS_DIV, 1, 2); + if (hdl->error) { + ret = hdl->error; + v4l2_ctrl_handler_free(hdl); + return ret; + } + priv->sd.ctrl_handler = hdl; + + return 0; +}; + +static int s5k4ecgx_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + int ret, i; + struct v4l2_subdev *sd; + struct s5k4ecgx *priv; + struct s5k4ecgx_platform_data *pdata = client->dev.platform_data; + + if (pdata == NULL) { + dev_err(&client->dev, "platform data is missing!\n"); + return -EINVAL; + } + priv = devm_kzalloc(&client->dev, sizeof(struct s5k4ecgx), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + mutex_init(&priv->lock); + priv->streaming = 0; + + sd = &priv->sd; + /* Registering subdev */ + v4l2_i2c_subdev_init(sd, client, &s5k4ecgx_ops); + strlcpy(sd->name, S5K4ECGX_DRIVER_NAME, sizeof(sd->name)); + + sd->internal_ops = &s5k4ecgx_subdev_internal_ops; + /* Support v4l2 sub-device user space API */ + sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; + + priv->pad.flags = MEDIA_PAD_FL_SOURCE; + sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR; + ret = media_entity_init(&sd->entity, 1, &priv->pad, 0); + if (ret) + return ret; + + ret = s5k4ecgx_config_gpios(priv, pdata); + if (ret) { + dev_err(&client->dev, "Failed to set gpios\n"); + goto out_err1; + } + for (i = 0; i < S5K4ECGX_NUM_SUPPLIES; i++) + priv->supplies[i].supply = s5k4ecgx_supply_names[i]; + + ret = devm_regulator_bulk_get(&client->dev, S5K4ECGX_NUM_SUPPLIES, + priv->supplies); + if (ret) { + dev_err(&client->dev, "Failed to get regulators\n"); + goto out_err2; + } + ret = s5k4ecgx_init_v4l2_ctrls(priv); + if (ret) + goto out_err2; + + priv->curr_pixfmt = &s5k4ecgx_formats[0]; + priv->curr_frmsize = &s5k4ecgx_prev_sizes[0]; + + return 0; + +out_err2: + s5k4ecgx_free_gpios(priv); +out_err1: + media_entity_cleanup(&priv->sd.entity); + + return ret; +} + +static int s5k4ecgx_remove(struct i2c_client *client) +{ + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct s5k4ecgx *priv = to_s5k4ecgx(sd); + + mutex_destroy(&priv->lock); + s5k4ecgx_free_gpios(priv); + v4l2_device_unregister_subdev(sd); + v4l2_ctrl_handler_free(&priv->handler); + media_entity_cleanup(&sd->entity); + + return 0; +} + +static const struct i2c_device_id s5k4ecgx_id[] = { + { S5K4ECGX_DRIVER_NAME, 0 }, + {} +}; +MODULE_DEVICE_TABLE(i2c, s5k4ecgx_id); + +static struct i2c_driver v4l2_i2c_driver = { + .driver = { + .owner = THIS_MODULE, + .name = S5K4ECGX_DRIVER_NAME, + }, + .probe = s5k4ecgx_probe, + .remove = s5k4ecgx_remove, + .id_table = s5k4ecgx_id, +}; + +module_i2c_driver(v4l2_i2c_driver); + +MODULE_DESCRIPTION("Samsung S5K4ECGX 5MP SOC camera"); +MODULE_AUTHOR("Sangwook Lee <sangwook.lee(a)linaro.org>"); +MODULE_AUTHOR("Seok-Young Jang <quartz.jang(a)samsung.com>"); +MODULE_LICENSE("GPL"); +MODULE_FIRMWARE(S5K4ECGX_FIRMWARE); diff --git a/include/media/s5k4ecgx.h b/include/media/s5k4ecgx.h new file mode 100644 index 0000000..90c1be7 --- /dev/null +++ b/include/media/s5k4ecgx.h @@ -0,0 +1,37 @@ +/* + * S5K4ECGX image sensor header file + * + * Copyright (C) 2012, Linaro + * Copyright (C) 2012, 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 2 of the License, or + * (at your option) any later version. + */ + +#ifndef S5K4ECGX_H +#define S5K4ECGX_H + +/** + * struct s5k4ecgx_gpio - data structure describing a GPIO + * @gpio : GPIO number + * @level: indicates active state of the @gpio + */ +struct s5k4ecgx_gpio { + int gpio; + int level; +}; + +/** + * struct ss5k4ecgx_platform_data- s5k4ecgx driver platform data + * @gpio_reset: GPIO driving RESET pin + * @gpio_stby : GPIO driving STBY pin + */ + +struct s5k4ecgx_platform_data { + struct s5k4ecgx_gpio gpio_reset; + struct s5k4ecgx_gpio gpio_stby; +}; + +#endif /* S5K4ECGX_H */ -- 1.7.9.5

11 years, 7 months

Add AArch64 support into OE-Core

by Marcin Juszkiewicz

This patchset adds support for AArch64 in all required classes: - insane - kernel-arch - siteinfo Everything is from public available information (binutils, linux).

11 years, 7 months

Re: [PATCH v3 1/3] devfreq: Core updates to support devices which can idle

by MyungJoo Ham

> Prepare devfreq core framework to support devices which > can idle. When device idleness is detected perhaps through > runtime-pm, need some mechanism to suspend devfreq load > monitoring and resume back when device is online. Present > code continues monitoring unless device is removed from > devfreq core. > > This patch introduces following design changes, > > - use per device work instead of global work to monitor device > load. This enables suspend/resume of device devfreq and > reduces monitoring code complexity. > - decouple delayed work based load monitoring logic from core > by introducing helpers functions to be used by governors. This > provides flexibility for governors either to use delayed work > based monitoring functions or to implement their own mechanism. > - devfreq core interacts with governors via events to perform > specific actions. These events include start/stop devfreq. > This sets ground for adding suspend/resume events. > > The devfreq apis are not modified and are kept intact. > > Signed-off-by: Rajagopal Venkat <rajagopal.venkat(a)linaro.org> Hello, I'll do more through review tomorrow (sorry, I was occuppied by something other than Linux tasks for a while again); however, there are two concerns in this patch. 1. (minor but may bothersome in some rare but not-ignorable cases) Serialization issue between suspend/resume functions; this may happen with some failure or interrupts while entering STR or unexpected usage of the API at drivers. For example, if devfreq_monitor_suspend() and devfreq_montir_resume() are called almost simultaneously, we may execute 1) locked part of suspend, 2) locked part of resume, 3) cancel_delayed_work_sync of suspend. Then, we may have stop_polling = false w/ cancel_delayed_work_sync() in effect. Let's not assume that suspend() and resume() may called almost simultaneously, especially in subsystem core code. 2. What if polling_ms = 0 w/ active governors (such as ondemand)? Users may declare the initial polling_ms = 0 w/ simple-ondemand in order to pause sampling at boot-time and start sampling at run-time some time later. It appears that this patch will start forcibly at boot-time in such a case. > --- > Documentation/ABI/testing/sysfs-class-devfreq | 8 - > drivers/devfreq/devfreq.c | 431 +++++++++++--------------- > drivers/devfreq/governor.h | 11 + > drivers/devfreq/governor_performance.c | 16 +- > drivers/devfreq/governor_powersave.c | 16 +- > drivers/devfreq/governor_simpleondemand.c | 24 ++ > drivers/devfreq/governor_userspace.c | 23 +- > include/linux/devfreq.h | 34 +- > 8 files changed, 267 insertions(+), 296 deletions(-) > > diff --git a/Documentation/ABI/testing/sysfs-class-devfreq b/Documentation/ABI/testing/sysfs-class-devfreq > index 23d78b5..89283b1 100644 > --- a/Documentation/ABI/testing/sysfs-class-devfreq > +++ b/Documentation/ABI/testing/sysfs-class-devfreq > @@ -21,14 +21,6 @@ Description: > The /sys/class/devfreq/.../cur_freq shows the current > frequency of the corresponding devfreq object. > > -What: /sys/class/devfreq/.../central_polling > -Date: September 2011 > -Contact: MyungJoo Ham <myungjoo.ham(a)samsung.com> > -Description: > - The /sys/class/devfreq/.../central_polling shows whether > - the devfreq ojbect is using devfreq-provided central > - polling mechanism or not. > - > What: /sys/class/devfreq/.../polling_interval > Date: September 2011 > Contact: MyungJoo Ham <myungjoo.ham(a)samsung.com> > diff --git a/drivers/devfreq/devfreq.c b/drivers/devfreq/devfreq.c > index b146d76..8e9b5aa 100644 > --- a/drivers/devfreq/devfreq.c > +++ b/drivers/devfreq/devfreq.c > @@ -30,17 +30,11 @@ > struct class *devfreq_class; > > /* > - * devfreq_work periodically monitors every registered device. > - * The minimum polling interval is one jiffy. The polling interval is > - * determined by the minimum polling period among all polling devfreq > - * devices. The resolution of polling interval is one jiffy. > + * devfreq core provides delayed work based load monitoring helper > + * functions. Governors can use these or can implement their own > + * monitoring mechanism. > */ > -static bool polling; > static struct workqueue_struct *devfreq_wq; > -static struct delayed_work devfreq_work; > - > -/* wait removing if this is to be removed */ > -static struct devfreq *wait_remove_device; > > /* The list of all device-devfreq */ > static LIST_HEAD(devfreq_list); > @@ -72,6 +66,8 @@ static struct devfreq *find_device_devfreq(struct device *dev) > return ERR_PTR(-ENODEV); > } > > +/* Load monitoring helper functions for governors use */ > + > /** > * update_devfreq() - Reevaluate the device and configure frequency. > * @devfreq: the devfreq instance. > @@ -121,6 +117,140 @@ int update_devfreq(struct devfreq *devfreq) > } > > /** > + * devfreq_monitor() - Periodically poll devfreq objects. > + * @work: the work struct used to run devfreq_monitor periodically. > + * > + */ > +static void devfreq_monitor(struct work_struct *work) > +{ > + int err; > + struct devfreq *devfreq = container_of(work, > + struct devfreq, work.work); > + > + mutex_lock(&devfreq->lock); > + err = update_devfreq(devfreq); > + if (err) > + dev_err(&devfreq->dev, "dvfs failed with (%d) error\n", err); > + > + queue_delayed_work(devfreq_wq, &devfreq->work, > + msecs_to_jiffies(devfreq->profile->polling_ms)); > + mutex_unlock(&devfreq->lock); > +} > + > +/** > + * devfreq_monitor_start() - Start load monitoring of devfreq instance > + * @devfreq: the devfreq instance. > + * > + * Helper function for starting devfreq device load monitoing. By > + * default delayed work based monitoring is supported. Function > + * to be called from governor in response to DEVFREQ_GOV_START > + * event when device is added to devfreq framework. > + */ > +void devfreq_monitor_start(struct devfreq *devfreq) > +{ > + INIT_DEFERRABLE_WORK(&devfreq->work, devfreq_monitor); > + queue_delayed_work(devfreq_wq, &devfreq->work, > + msecs_to_jiffies(devfreq->profile->polling_ms)); > +} > + > +/** > + * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance > + * @devfreq: the devfreq instance. > + * > + * Helper function to stop devfreq device load monitoing. Function > + * to be called from governor in response to DEVFREQ_GOV_STOP > + * event when device is removed from devfreq framework. > + */ > +void devfreq_monitor_stop(struct devfreq *devfreq) > +{ > + cancel_delayed_work_sync(&devfreq->work); > +} > + > +/** > + * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance > + * @devfreq: the devfreq instance. > + * > + * Helper function to suspend devfreq device load monitoing. Function > + * to be called from governor in response to DEVFREQ_GOV_SUSPEND > + * event or when polling interval is set to zero. > + * > + * Note: Though this function is same as devfreq_monitor_stop(), > + * intentionally kept separate to provide hooks for collecting > + * transition statistics. > + */ > +void devfreq_monitor_suspend(struct devfreq *devfreq) > +{ > + mutex_lock(&devfreq->lock); > + devfreq->stop_polling = true; > + mutex_unlock(&devfreq->lock); > + cancel_delayed_work_sync(&devfreq->work); > +} > + > +/** > + * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance > + * @devfreq: the devfreq instance. > + * > + * Helper function to resume devfreq device load monitoing. Function > + * to be called from governor in response to DEVFREQ_GOV_RESUME > + * event or when polling interval is set to non-zero. > + */ > +void devfreq_monitor_resume(struct devfreq *devfreq) > +{ > + mutex_lock(&devfreq->lock); > + if (!delayed_work_pending(&devfreq->work) && > + devfreq->profile->polling_ms) > + queue_delayed_work(devfreq_wq, &devfreq->work, > + msecs_to_jiffies(devfreq->profile->polling_ms)); > + devfreq->stop_polling = false; > + mutex_unlock(&devfreq->lock); > +} > + > +/** > + * devfreq_interval_update() - Update device devfreq monitoring interval > + * @devfreq: the devfreq instance. > + * @delay: new polling interval to be set. > + * > + * Helper function to set new load monitoring polling interval. Function > + * to be called from governor in response to DEVFREQ_GOV_INTERVAL event. > + */ > +void devfreq_interval_update(struct devfreq *devfreq, unsigned int *delay) > +{ > + unsigned int cur_delay = devfreq->profile->polling_ms; > + unsigned int new_delay = *delay; > + > + mutex_lock(&devfreq->lock); > + devfreq->profile->polling_ms = new_delay; > + > + if (devfreq->stop_polling) > + goto out; > + > + /* if new delay is zero, stop polling */ > + if (!new_delay) { > + mutex_unlock(&devfreq->lock); > + cancel_delayed_work_sync(&devfreq->work); > + return; > + } > + > + /* if current delay is zero, start polling with new delay */ > + if (!cur_delay) { > + queue_delayed_work(devfreq_wq, &devfreq->work, > + msecs_to_jiffies(devfreq->profile->polling_ms)); > + goto out; > + } > + > + /* if current delay is greater than new delay, restart polling */ > + if (cur_delay > new_delay) { > + mutex_unlock(&devfreq->lock); > + cancel_delayed_work_sync(&devfreq->work); > + mutex_lock(&devfreq->lock); > + queue_delayed_work(devfreq_wq, &devfreq->work, > + msecs_to_jiffies(devfreq->profile->polling_ms)); > + } > +out: > + mutex_unlock(&devfreq->lock); > +} > + > +/** > * devfreq_notifier_call() - Notify that the device frequency requirements > * has been changed out of devfreq framework. > * @nb the notifier_block (supposed to be devfreq->nb) > @@ -143,59 +273,33 @@ static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type, > } > > /** > - * _remove_devfreq() - Remove devfreq from the device. > + * _remove_devfreq() - Remove devfreq from the devfreq list and > + release its resources. > * @devfreq: the devfreq struct > * @skip: skip calling device_unregister(). > - * > - * Note that the caller should lock devfreq->lock before calling > - * this. _remove_devfreq() will unlock it and free devfreq > - * internally. devfreq_list_lock should be locked by the caller > - * as well (not relased at return) > - * > - * Lock usage: > - * devfreq->lock: locked before call. > - * unlocked at return (and freed) > - * devfreq_list_lock: locked before call. > - * kept locked at return. > - * if devfreq is centrally polled. > - * > - * Freed memory: > - * devfreq > */ > static void _remove_devfreq(struct devfreq *devfreq, bool skip) > { > - if (!mutex_is_locked(&devfreq->lock)) { > - WARN(true, "devfreq->lock must be locked by the caller.\n"); > - return; > - } > - if (!devfreq->governor->no_central_polling && > - !mutex_is_locked(&devfreq_list_lock)) { > - WARN(true, "devfreq_list_lock must be locked by the caller.\n"); > + mutex_lock(&devfreq_list_lock); > + if (IS_ERR(find_device_devfreq(devfreq->dev.parent))) { > + mutex_unlock(&devfreq_list_lock); > + dev_warn(&devfreq->dev, "releasing devfreq which doesn't exist\n"); > return; > } > + list_del(&devfreq->node); > + mutex_unlock(&devfreq_list_lock); > > - if (devfreq->being_removed) > - return; > - > - devfreq->being_removed = true; > + devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_STOP, NULL); > > if (devfreq->profile->exit) > devfreq->profile->exit(devfreq->dev.parent); > > - if (devfreq->governor->exit) > - devfreq->governor->exit(devfreq); > - > if (!skip && get_device(&devfreq->dev)) { > device_unregister(&devfreq->dev); > put_device(&devfreq->dev); > } > > - if (!devfreq->governor->no_central_polling) > - list_del(&devfreq->node); > - > - mutex_unlock(&devfreq->lock); > mutex_destroy(&devfreq->lock); > - > kfree(devfreq); > } > > @@ -210,130 +314,8 @@ static void _remove_devfreq(struct devfreq *devfreq, bool skip) > static void devfreq_dev_release(struct device *dev) > { > struct devfreq *devfreq = to_devfreq(dev); > - bool central_polling = !devfreq->governor->no_central_polling; > > - /* > - * If devfreq_dev_release() was called by device_unregister() of > - * _remove_devfreq(), we cannot mutex_lock(&devfreq->lock) and > - * being_removed is already set. This also partially checks the case > - * where devfreq_dev_release() is called from a thread other than > - * the one called _remove_devfreq(); however, this case is > - * dealt completely with another following being_removed check. > - * > - * Because being_removed is never being > - * unset, we do not need to worry about race conditions on > - * being_removed. > - */ > - if (devfreq->being_removed) > - return; > - > - if (central_polling) > - mutex_lock(&devfreq_list_lock); > - > - mutex_lock(&devfreq->lock); > - > - /* > - * Check being_removed flag again for the case where > - * devfreq_dev_release() was called in a thread other than the one > - * possibly called _remove_devfreq(). > - */ > - if (devfreq->being_removed) { > - mutex_unlock(&devfreq->lock); > - goto out; > - } > - > - /* devfreq->lock is unlocked and removed in _removed_devfreq() */ > _remove_devfreq(devfreq, true); > - > -out: > - if (central_polling) > - mutex_unlock(&devfreq_list_lock); > -} > - > -/** > - * devfreq_monitor() - Periodically poll devfreq objects. > - * @work: the work struct used to run devfreq_monitor periodically. > - * > - */ > -static void devfreq_monitor(struct work_struct *work) > -{ > - static unsigned long last_polled_at; > - struct devfreq *devfreq, *tmp; > - int error; > - unsigned long jiffies_passed; > - unsigned long next_jiffies = ULONG_MAX, now = jiffies; > - struct device *dev; > - > - /* Initially last_polled_at = 0, polling every device at bootup */ > - jiffies_passed = now - last_polled_at; > - last_polled_at = now; > - if (jiffies_passed == 0) > - jiffies_passed = 1; > - > - mutex_lock(&devfreq_list_lock); > - list_for_each_entry_safe(devfreq, tmp, &devfreq_list, node) { > - mutex_lock(&devfreq->lock); > - dev = devfreq->dev.parent; > - > - /* Do not remove tmp for a while */ > - wait_remove_device = tmp; > - > - if (devfreq->governor->no_central_polling || > - devfreq->next_polling == 0) { > - mutex_unlock(&devfreq->lock); > - continue; > - } > - mutex_unlock(&devfreq_list_lock); > - > - /* > - * Reduce more next_polling if devfreq_wq took an extra > - * delay. (i.e., CPU has been idled.) > - */ > - if (devfreq->next_polling <= jiffies_passed) { > - error = update_devfreq(devfreq); > - > - /* Remove a devfreq with an error. */ > - if (error && error != -EAGAIN) { > - > - dev_err(dev, "Due to update_devfreq error(%d), devfreq(%s) is removed from the device\n", > - error, devfreq->governor->name); > - > - /* > - * Unlock devfreq before locking the list > - * in order to avoid deadlock with > - * find_device_devfreq or others > - */ > - mutex_unlock(&devfreq->lock); > - mutex_lock(&devfreq_list_lock); > - /* Check if devfreq is already removed */ > - if (IS_ERR(find_device_devfreq(dev))) > - continue; > - mutex_lock(&devfreq->lock); > - /* This unlocks devfreq->lock and free it */ > - _remove_devfreq(devfreq, false); > - continue; > - } > - devfreq->next_polling = devfreq->polling_jiffies; > - } else { > - devfreq->next_polling -= jiffies_passed; > - } > - > - if (devfreq->next_polling) > - next_jiffies = (next_jiffies > devfreq->next_polling) ? > - devfreq->next_polling : next_jiffies; > - > - mutex_unlock(&devfreq->lock); > - mutex_lock(&devfreq_list_lock); > - } > - wait_remove_device = NULL; > - mutex_unlock(&devfreq_list_lock); > - > - if (next_jiffies > 0 && next_jiffies < ULONG_MAX) { > - polling = true; > - queue_delayed_work(devfreq_wq, &devfreq_work, next_jiffies); > - } else { > - polling = false; > - } > } > > /** > @@ -357,16 +339,13 @@ struct devfreq *devfreq_add_device(struct device *dev, > return ERR_PTR(-EINVAL); > } > > - > - if (!governor->no_central_polling) { > - mutex_lock(&devfreq_list_lock); > - devfreq = find_device_devfreq(dev); > - mutex_unlock(&devfreq_list_lock); > - if (!IS_ERR(devfreq)) { > - dev_err(dev, "%s: Unable to create devfreq for the device. It already has one.\n", __func__); > - err = -EINVAL; > - goto err_out; > - } > + mutex_lock(&devfreq_list_lock); > + devfreq = find_device_devfreq(dev); > + mutex_unlock(&devfreq_list_lock); > + if (!IS_ERR(devfreq)) { > + dev_err(dev, "%s: Unable to create devfreq for the device. It already has one.\n", __func__); > + err = -EINVAL; > + goto err_out; > } > > devfreq = kzalloc(sizeof(struct devfreq), GFP_KERNEL); > @@ -386,48 +365,41 @@ struct devfreq *devfreq_add_device(struct device *dev, > devfreq->governor = governor; > devfreq->previous_freq = profile->initial_freq; > devfreq->data = data; > - devfreq->next_polling = devfreq->polling_jiffies > - = msecs_to_jiffies(devfreq->profile->polling_ms); > devfreq->nb.notifier_call = devfreq_notifier_call; > > dev_set_name(&devfreq->dev, dev_name(dev)); > err = device_register(&devfreq->dev); > if (err) { > put_device(&devfreq->dev); > + mutex_unlock(&devfreq->lock); > goto err_dev; > } > > - if (governor->init) > - err = governor->init(devfreq); > - if (err) > - goto err_init; > - > mutex_unlock(&devfreq->lock); > > - if (governor->no_central_polling) > - goto out; > - > mutex_lock(&devfreq_list_lock); > - > list_add(&devfreq->node, &devfreq_list); > + mutex_unlock(&devfreq_list_lock); > > - if (devfreq_wq && devfreq->next_polling && !polling) { > - polling = true; > - queue_delayed_work(devfreq_wq, &devfreq_work, > - devfreq->next_polling); > + err = devfreq->governor->event_handler(devfreq, > + DEVFREQ_GOV_START, NULL); > + if (err) { > + dev_err(dev, "%s: Unable to start governor for the device\n", > + __func__); > + goto err_init; > } > - mutex_unlock(&devfreq_list_lock); > -out: > + > return devfreq; > > err_init: > + list_del(&devfreq->node); > device_unregister(&devfreq->dev); > err_dev: > - mutex_unlock(&devfreq->lock); > kfree(devfreq); > err_out: > return ERR_PTR(err); > } > +EXPORT_SYMBOL(devfreq_add_device); > > /** > * devfreq_remove_device() - Remove devfreq feature from a device. > @@ -435,30 +407,14 @@ err_out: > */ > int devfreq_remove_device(struct devfreq *devfreq) > { > - bool central_polling; > - > if (!devfreq) > return -EINVAL; > > - central_polling = !devfreq->governor->no_central_polling; > - > - if (central_polling) { > - mutex_lock(&devfreq_list_lock); > - while (wait_remove_device == devfreq) { > - mutex_unlock(&devfreq_list_lock); > - schedule(); > - mutex_lock(&devfreq_list_lock); > - } > - } > - > - mutex_lock(&devfreq->lock); > - _remove_devfreq(devfreq, false); /* it unlocks devfreq->lock */ > - > - if (central_polling) > - mutex_unlock(&devfreq_list_lock); > + _remove_devfreq(devfreq, false); > > return 0; > } > +EXPORT_SYMBOL(devfreq_remove_device); > > static ssize_t show_governor(struct device *dev, > struct device_attribute *attr, char *buf) > @@ -490,35 +446,13 @@ static ssize_t store_polling_interval(struct device *dev, > if (ret != 1) > goto out; > > - mutex_lock(&df->lock); > - df->profile->polling_ms = value; > - df->next_polling = df->polling_jiffies > - = msecs_to_jiffies(value); > - mutex_unlock(&df->lock); > - > + df->governor->event_handler(df, DEVFREQ_GOV_INTERVAL, &value); > ret = count; > > - if (df->governor->no_central_polling) > - goto out; > - > - mutex_lock(&devfreq_list_lock); > - if (df->next_polling > 0 && !polling) { > - polling = true; > - queue_delayed_work(devfreq_wq, &devfreq_work, > - df->next_polling); > - } > - mutex_unlock(&devfreq_list_lock); > out: > return ret; > } > > -static ssize_t show_central_polling(struct device *dev, > - struct device_attribute *attr, char *buf) > -{ > - return sprintf(buf, "%d\n", > - !to_devfreq(dev)->governor->no_central_polling); > -} > - > static ssize_t store_min_freq(struct device *dev, struct device_attribute *attr, > const char *buf, size_t count) > { > @@ -590,7 +524,6 @@ static ssize_t show_max_freq(struct device *dev, struct device_attribute *attr, > static struct device_attribute devfreq_attrs[] = { > __ATTR(governor, S_IRUGO, show_governor, NULL), > __ATTR(cur_freq, S_IRUGO, show_freq, NULL), > - __ATTR(central_polling, S_IRUGO, show_central_polling, NULL), > __ATTR(polling_interval, S_IRUGO | S_IWUSR, show_polling_interval, > store_polling_interval), > __ATTR(min_freq, S_IRUGO | S_IWUSR, show_min_freq, store_min_freq), > @@ -598,23 +531,6 @@ static struct device_attribute devfreq_attrs[] = { > { }, > }; > > -/** > - * devfreq_start_polling() - Initialize data structure for devfreq framework and > - * start polling registered devfreq devices. > - */ > -static int __init devfreq_start_polling(void) > -{ > - mutex_lock(&devfreq_list_lock); > - polling = false; > - devfreq_wq = create_freezable_workqueue("devfreq_wq"); > - INIT_DEFERRABLE_WORK(&devfreq_work, devfreq_monitor); > - mutex_unlock(&devfreq_list_lock); > - > - devfreq_monitor(&devfreq_work.work); > - return 0; > -} > -late_initcall(devfreq_start_polling); > - > static int __init devfreq_init(void) > { > devfreq_class = class_create(THIS_MODULE, "devfreq"); > @@ -622,7 +538,15 @@ static int __init devfreq_init(void) > pr_err("%s: couldn't create class\n", __FILE__); > return PTR_ERR(devfreq_class); > } > + > + devfreq_wq = create_freezable_workqueue("devfreq_wq"); > + if (IS_ERR(devfreq_wq)) { > + class_destroy(devfreq_class); > + pr_err("%s: couldn't create workqueue\n", __FILE__); > + return PTR_ERR(devfreq_wq); > + } > devfreq_class->dev_attrs = devfreq_attrs; > + > return 0; > } > subsys_initcall(devfreq_init); > @@ -630,6 +554,7 @@ subsys_initcall(devfreq_init); > static void __exit devfreq_exit(void) > { > class_destroy(devfreq_class); > + destroy_workqueue(devfreq_wq); > } > module_exit(devfreq_exit); > > diff --git a/drivers/devfreq/governor.h b/drivers/devfreq/governor.h > index ea7f13c..bb3aff3 100644 > --- a/drivers/devfreq/governor.h > +++ b/drivers/devfreq/governor.h > @@ -18,7 +18,18 @@ > > #define to_devfreq(DEV) container_of((DEV), struct devfreq, dev) > > +/* Devfreq events */ > +#define DEVFREQ_GOV_START 0x1 > +#define DEVFREQ_GOV_STOP 0x2 > +#define DEVFREQ_GOV_INTERVAL 0x3 > + > /* Caution: devfreq->lock must be locked before calling update_devfreq */ > extern int update_devfreq(struct devfreq *devfreq); > > +extern void devfreq_monitor_start(struct devfreq *devfreq); > +extern void devfreq_monitor_stop(struct devfreq *devfreq); > +extern void devfreq_monitor_suspend(struct devfreq *devfreq); > +extern void devfreq_monitor_resume(struct devfreq *devfreq); > +extern void devfreq_interval_update(struct devfreq *devfreq, > + unsigned int *delay); > #endif /* _GOVERNOR_H */ > diff --git a/drivers/devfreq/governor_performance.c b/drivers/devfreq/governor_performance.c > index af75ddd..eea3f9b 100644 > --- a/drivers/devfreq/governor_performance.c > +++ b/drivers/devfreq/governor_performance.c > @@ -26,14 +26,22 @@ static int devfreq_performance_func(struct devfreq *df, > return 0; > } > > -static int performance_init(struct devfreq *devfreq) > +static int devfreq_performance_handler(struct devfreq *devfreq, > + unsigned int event, void *data) > { > - return update_devfreq(devfreq); > + int ret = 0; > + > + if (event == DEVFREQ_GOV_START) { > + mutex_lock(&devfreq->lock); > + ret = update_devfreq(devfreq); > + mutex_unlock(&devfreq->lock); > + } > + > + return ret; > } > > const struct devfreq_governor devfreq_performance = { > .name = "performance", > - .init = performance_init, > .get_target_freq = devfreq_performance_func, > - .no_central_polling = true, > + .event_handler = devfreq_performance_handler, > }; > diff --git a/drivers/devfreq/governor_powersave.c b/drivers/devfreq/governor_powersave.c > index fec0cdb..2868d98 100644 > --- a/drivers/devfreq/governor_powersave.c > +++ b/drivers/devfreq/governor_powersave.c > @@ -23,14 +23,22 @@ static int devfreq_powersave_func(struct devfreq *df, > return 0; > } > > -static int powersave_init(struct devfreq *devfreq) > +static int devfreq_powersave_handler(struct devfreq *devfreq, > + unsigned int event, void *data) > { > - return update_devfreq(devfreq); > + int ret = 0; > + > + if (event == DEVFREQ_GOV_START) { > + mutex_lock(&devfreq->lock); > + ret = update_devfreq(devfreq); > + mutex_unlock(&devfreq->lock); > + } > + > + return ret; > } > > const struct devfreq_governor devfreq_powersave = { > .name = "powersave", > - .init = powersave_init, > .get_target_freq = devfreq_powersave_func, > - .no_central_polling = true, > + .event_handler = devfreq_powersave_handler, > }; > diff --git a/drivers/devfreq/governor_simpleondemand.c b/drivers/devfreq/governor_simpleondemand.c > index a2e3eae..cf94218 100644 > --- a/drivers/devfreq/governor_simpleondemand.c > +++ b/drivers/devfreq/governor_simpleondemand.c > @@ -12,6 +12,7 @@ > #include <linux/errno.h> > #include <linux/devfreq.h> > #include <linux/math64.h> > +#include "governor.h" > > /* Default constants for DevFreq-Simple-Ondemand (DFSO) */ > #define DFSO_UPTHRESHOLD (90) > @@ -88,7 +89,30 @@ static int devfreq_simple_ondemand_func(struct devfreq *df, > return 0; > } > > +int devfreq_simple_ondemand_handler(struct devfreq *devfreq, > + unsigned int event, void *data) > +{ > + switch (event) { > + case DEVFREQ_GOV_START: > + devfreq_monitor_start(devfreq); > + break; > + > + case DEVFREQ_GOV_STOP: > + devfreq_monitor_stop(devfreq); > + break; > + > + case DEVFREQ_GOV_INTERVAL: > + devfreq_interval_update(devfreq, (unsigned int *)data); > + break; > + default: > + break; > + } > + > + return 0; > +} > + > const struct devfreq_governor devfreq_simple_ondemand = { > .name = "simple_ondemand", > .get_target_freq = devfreq_simple_ondemand_func, > + .event_handler = devfreq_simple_ondemand_handler, > }; > diff --git a/drivers/devfreq/governor_userspace.c b/drivers/devfreq/governor_userspace.c > index 0681246..1fddee5 100644 > --- a/drivers/devfreq/governor_userspace.c > +++ b/drivers/devfreq/governor_userspace.c > @@ -116,10 +116,27 @@ static void userspace_exit(struct devfreq *devfreq) > devfreq->data = NULL; > } > > +int devfreq_userspace_handler(struct devfreq *devfreq, > + unsigned int event, void *data) > +{ > + int ret = 0; > + > + switch (event) { > + case DEVFREQ_GOV_START: > + ret = userspace_init(devfreq); > + break; > + case DEVFREQ_GOV_STOP: > + userspace_exit(devfreq); > + break; > + default: > + break; > + } > + > + return ret; > +} > + > const struct devfreq_governor devfreq_userspace = { > .name = "userspace", > .get_target_freq = devfreq_userspace_func, > - .init = userspace_init, > - .exit = userspace_exit, > - .no_central_polling = true, > + .event_handler = devfreq_userspace_handler, > }; > diff --git a/include/linux/devfreq.h b/include/linux/devfreq.h > index 281c72a..2ab70e3 100644 > --- a/include/linux/devfreq.h > +++ b/include/linux/devfreq.h > @@ -91,25 +91,18 @@ struct devfreq_dev_profile { > * status of the device (load = busy_time / total_time). > * If no_central_polling is set, this callback is called > * only with update_devfreq() notified by OPP. > - * @init Called when the devfreq is being attached to a device > - * @exit Called when the devfreq is being removed from a > - * device. Governor should stop any internal routines > - * before return because related data may be > - * freed after exit(). > - * @no_central_polling Do not use devfreq's central polling mechanism. > - * When this is set, devfreq will not call > - * get_target_freq with devfreq_monitor(). However, > - * devfreq will call get_target_freq with > - * devfreq_update() notified by OPP framework. > + * @event_handler Callback for devfreq core framework to notify events > + * to governors. Events include per device governor > + * init and exit, opp changes out of devfreq, suspend > + * and resume of per device devfreq during device idle. > * > * Note that the callbacks are called with devfreq->lock locked by devfreq. > */ > struct devfreq_governor { > const char name[DEVFREQ_NAME_LEN]; > int (*get_target_freq)(struct devfreq *this, unsigned long *freq); > - int (*init)(struct devfreq *this); > - void (*exit)(struct devfreq *this); > - const bool no_central_polling; > + int (*event_handler)(struct devfreq *devfreq, > + unsigned int event, void *data); > }; > > /** > @@ -124,18 +117,13 @@ struct devfreq_governor { > * @nb notifier block used to notify devfreq object that it should > * reevaluate operable frequencies. Devfreq users may use > * devfreq.nb to the corresponding register notifier call chain. > - * @polling_jiffies interval in jiffies. > + * @work delayed work for load monitoring. > * @previous_freq previously configured frequency value. > - * @next_polling the number of remaining jiffies to poll with > - * "devfreq_monitor" executions to reevaluate > - * frequency/voltage of the device. Set by > - * profile's polling_ms interval. > * @data Private data of the governor. The devfreq framework does not > * touch this. > - * @being_removed a flag to mark that this object is being removed in > - * order to prevent trying to remove the object multiple times. > * @min_freq Limit minimum frequency requested by user (0: none) > * @max_freq Limit maximum frequency requested by user (0: none) > + * @stop_polling device load monitoring status. > * > * This structure stores the devfreq information for a give device. > * > @@ -153,17 +141,15 @@ struct devfreq { > struct devfreq_dev_profile *profile; > const struct devfreq_governor *governor; > struct notifier_block nb; > + struct delayed_work work; > > - unsigned long polling_jiffies; > unsigned long previous_freq; > - unsigned int next_polling; > > void *data; /* private data for governors */ > > - bool being_removed; > - > unsigned long min_freq; > unsigned long max_freq; > + bool stop_polling; > }; > > #if defined(CONFIG_PM_DEVFREQ) > -- > 1.7.11.3 > > > > > > > >

11 years, 7 months

← Newer
1
2
3
4
5
6
7
8
9
10
Older →

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

linaro-dev September 2012