linaro-dev

linaro-dev@lists.linaro.org

4332 discussions

[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

13 years, 1 month

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

13 years, 1 month

[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

13 years, 1 month

[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

13 years, 1 month

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

13 years, 1 month

[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

13 years, 1 month

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).

13 years, 1 month

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 > > > > > > > >

13 years, 1 month

Test Result Summary for Linaro ubuntu 12.09 Release (Calendar Week 39).

by Botao Sun

Calendar Week 39: Here is test result summary for Linaro ubuntu 12.09 Release on following boards: 1) ARM Versatile Express A9; 2) Samsung Origen; 3) TI Panda Board 4430; 4) TI Panda Board 4460. *Synopsis: "DEADLOCK" error has disappeared during boot process, except on TI Panda platform, although it won't affect system running. Both 480p & 1080p videos can be played on Panda board with an extra package installed - "ubuntu-omap4-extras-multimedia". Device Tree feature is still unavailable on vexpress A9. WiFi, Bluetooth and video playback are unavailable on Samsung Origen.* 1. vexpress A9 + ubuntu (Column AB): https://docs.google.com/a/linaro.org/spreadsheet/ccc?key=0AroPySpr4FnEdFNmV… Device Tree blob files have recovered, although this feature is still unavailable due to a UEFI defect, which Ryan is working on that. 480p video playback still doesn't work on this release image. YouTube HTML5 video now can be played, although the frame rate is low, which is as expected. All other features remain the same as last week. 2. Origen + ubuntu (Column W): https://docs.google.com/a/linaro.org/spreadsheet/ccc?key=0AroPySpr4FnEdEowN… "DEADLOCK" error has gone on this image, and kernel version has been upgraded to 3.6.0-1. All other features remain the same as last week. 3. Panda 4430 + ubuntu (Column Y): https://docs.google.com/a/linaro.org/spreadsheet/ccc?key=0AroPySpr4FnEdEwwZ… YouTube HTML5 video now can be played well, but due to Audio over HDMI failure, no sound can be heard. Although file transfer via Bluetooth is still unavailable, Bluetooth headset works well. 480p video on SD card can be played well if package "ubuntu-omap4-extras-multimedia" be installed in advance. 1080p video can be played with a low frame rate. All power management test has passed (or skipped properly) on this image. No significant change on all the other features. 4. Panda 4460 + ubuntu (Column X): https://docs.google.com/a/linaro.org/spreadsheet/ccc?key=0AroPySpr4FnEdEwwZ… Bluetooth headset doesn't work here, it hangs the board during the pair process. Hardware acceleration works well. 3.5mm Audio input is still unavailable and suspend / resume test failed as well. No change on all the other features compare with last week test. For the previous week (Calendar week 38) summary, please refer to attachment. Thank you. Best Regards Botao Sun

13 years, 1 month

ARM gcc vs ARM rvct

by Dechesne, Nicolas

Hi there, Is there any sensible comparison document for gcc vs rvct in terms of speed, code size, feature set? Is there any reason / use case to recommend rvct over gcc for non-Linux s/w? Thx nicolas Texas Instruments France SA, 821 Avenue Jack Kilby, 06270 Villeneuve Loubet. 036 420 040 R.C.S Antibes. Capital de EUR 12.654.784

13 years, 1 month

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

linaro-dev