static ssize_t nvsd_registers_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
struct device *dev = container_of((kobj->parent), struct device, kobj);
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
ssize_t res = 0;
mutex_lock(&dc->lock);
if (!dc->enabled) {
mutex_unlock(&dc->lock);
return -ENODEV;
}
mutex_unlock(&dc->lock);
NVSD_PRINT_REG(DC_DISP_SD_CONTROL);
NVSD_PRINT_REG(DC_DISP_SD_CSC_COEFF);
NVSD_PRINT_REG_ARRAY(DC_DISP_SD_LUT);
NVSD_PRINT_REG(DC_DISP_SD_FLICKER_CONTROL);
NVSD_PRINT_REG(DC_DISP_SD_PIXEL_COUNT);
NVSD_PRINT_REG_ARRAY(DC_DISP_SD_HISTOGRAM);
NVSD_PRINT_REG(DC_DISP_SD_BL_PARAMETERS);
NVSD_PRINT_REG_ARRAY(DC_DISP_SD_BL_TF);
NVSD_PRINT_REG(DC_DISP_SD_BL_CONTROL);
NVSD_PRINT_REG(DC_DISP_SD_HW_K_VALUES);
NVSD_PRINT_REG(DC_DISP_SD_MAN_K_VALUES);
return res;
}
void tegra_dc_create_sysfs(struct device *dev)
{
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
struct tegra_dc_sd_settings *sd_settings = dc->out->sd_settings;
int error = 0;
error |= device_create_file(dev, &dev_attr_mode);
error |= device_create_file(dev, &dev_attr_nvdps);
error |= device_create_file(dev, &dev_attr_enable);
error |= device_create_file(dev, &dev_attr_stats_enable);
error |= device_create_file(dev, &dev_attr_crc_checksum_latched);
if (dc->out->stereo) {
error |= device_create_file(dev, &dev_attr_stereo_orientation);
error |= device_create_file(dev, &dev_attr_stereo_mode);
}
if (sd_settings)
error |= nvsd_create_sysfs(dev);
if (dc->out->flags & TEGRA_DC_OUT_ONE_SHOT_MODE)
error |= device_create_file(dev, &dev_attr_smart_panel);
if (error)
dev_err(&ndev->dev, "Failed to create sysfs attributes!\n");
}
static int tegra_dc_suspend(struct nvhost_device *ndev, pm_message_t state)
{
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
trace_printk("%s:suspend\n", dc->ndev->name);
dev_info(&ndev->dev, "suspend\n");
tegra_dc_ext_disable(dc->ext);
mutex_lock(&dc->lock);
if (dc->out_ops && dc->out_ops->suspend)
dc->out_ops->suspend(dc);
if (dc->enabled) {
_tegra_dc_disable(dc);
dc->suspended = true;
}
if (dc->out && dc->out->postsuspend) {
dc->out->postsuspend();
if (dc->out->type && dc->out->type == TEGRA_DC_OUT_HDMI)
/*
* avoid resume event due to voltage falling
*/
msleep(100);
}
mutex_unlock(&dc->lock);
return 0;
}
static int tegra_dc_remove(struct nvhost_device *ndev)
{
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
if (dc->fb) {
tegra_fb_unregister(dc->fb);
if (dc->fb_mem)
release_resource(dc->fb_mem);
}
tegra_dc_ext_disable(dc->ext);
if (dc->ext)
tegra_dc_ext_unregister(dc->ext);
if (dc->enabled)
_tegra_dc_disable(dc);
free_irq(dc->irq, dc);
clk_put(dc->emc_clk);
clk_put(dc->clk);
iounmap(dc->base);
if (dc->fb_mem)
release_resource(dc->base_res);
kfree(dc);
return 0;
}
static ssize_t crc_checksum_latched_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
unsigned long val = 0;
if (!dc->enabled) {
dev_err(&dc->ndev->dev, "%s: DC not enabled.\n", __func__);
return -EFAULT;
}
if (strict_strtoul(buf, 10, &val) < 0)
return -EINVAL;
if (val == 1) {
tegra_dc_enable_crc(dc);
dev_err(&dc->ndev->dev, "crc is enabled.\n");
} else if (val == 0) {
tegra_dc_disable_crc(dc);
dev_err(&dc->ndev->dev, "crc is disabled.\n");
} else
dev_err(&dc->ndev->dev, "Invalid input.\n");
return count;
}
static int power_off_host(struct nvhost_device *dev)
{
struct nvhost_master *host = nvhost_get_drvdata(dev);
nvhost_syncpt_save(&host->syncpt);
nvhost_intr_stop(&host->intr);
return 0;
}
static ssize_t mode_show(struct device *device,
struct device_attribute *attr, char *buf)
{
struct nvhost_device *ndev = to_nvhost_device(device);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
struct tegra_dc_mode *m;
ssize_t res;
mutex_lock(&dc->lock);
m = &dc->mode;
res = snprintf(buf, PAGE_SIZE,
"pclk: %d\n"
"h_ref_to_sync: %d\n"
"v_ref_to_sync: %d\n"
"h_sync_width: %d\n"
"v_sync_width: %d\n"
"h_back_porch: %d\n"
"v_back_porch: %d\n"
"h_active: %d\n"
"v_active: %d\n"
"h_front_porch: %d\n"
"v_front_porch: %d\n"
"stereo_mode: %d\n",
m->pclk, m->h_ref_to_sync, m->v_ref_to_sync,
m->h_sync_width, m->v_sync_width,
m->h_back_porch, m->v_back_porch,
m->h_active, m->v_active,
m->h_front_porch, m->v_front_porch,
m->stereo_mode);
mutex_unlock(&dc->lock);
return res;
}
static int tegra_dc_remove(struct nvhost_device *ndev)
{
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
tegra_dc_remove_sysfs(&dc->ndev->dev);
tegra_dc_remove_debugfs(dc);
if (dc->fb) {
tegra_fb_unregister(dc->fb);
if (dc->fb_mem)
release_resource(dc->fb_mem);
}
tegra_dc_ext_disable(dc->ext);
if (dc->ext)
tegra_dc_ext_unregister(dc->ext);
if (dc->enabled)
_tegra_dc_disable(dc);
#ifdef CONFIG_SWITCH
switch_dev_unregister(&dc->modeset_switch);
#endif
free_irq(dc->irq, dc);
clk_put(dc->emc_clk);
clk_put(dc->clk);
iounmap(dc->base);
if (dc->fb_mem)
release_resource(dc->base_res);
kfree(dc);
tegra_dc_set(NULL, ndev->id);
return 0;
}
static int __exit nvhost_remove(struct nvhost_device *dev)
{
struct nvhost_master *host = nvhost_get_drvdata(dev);
nvhost_intr_deinit(&host->intr);
nvhost_syncpt_deinit(&host->syncpt);
nvhost_free_resources(host);
return 0;
}
/* Sysfs accessors */
static ssize_t nvsd_settings_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
struct device *dev = container_of((kobj->parent), struct device, kobj);
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
struct tegra_dc_sd_settings *sd_settings = dc->out->sd_settings;
ssize_t res = 0;
if (sd_settings) {
if (IS_NVSD_ATTR(enable))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->enable);
else if (IS_NVSD_ATTR(aggressiveness))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->aggressiveness);
else if (IS_NVSD_ATTR(bin_width))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->bin_width);
else if (IS_NVSD_ATTR(hw_update_delay))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->hw_update_delay);
else if (IS_NVSD_ATTR(use_vid_luma))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->use_vid_luma);
else if (IS_NVSD_ATTR(coeff))
res = snprintf(buf, PAGE_SIZE,
"R: %d / G: %d / B: %d\n",
sd_settings->coeff.r,
sd_settings->coeff.g,
sd_settings->coeff.b);
else if (IS_NVSD_ATTR(blp_time_constant))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->blp.time_constant);
else if (IS_NVSD_ATTR(blp_step))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->blp.step);
else if (IS_NVSD_ATTR(fc_time_limit))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->fc.time_limit);
else if (IS_NVSD_ATTR(fc_threshold))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->fc.threshold);
else if (IS_NVSD_ATTR(lut))
res = nvsd_lut_show(sd_settings, buf, res);
else if (IS_NVSD_ATTR(bltf))
res = nvsd_bltf_show(sd_settings, buf, res);
else
res = -EINVAL;
} else {
/* This shouldn't be reachable. But just in case... */
res = -EINVAL;
}
return res;
}
static ssize_t nvdps_show(struct device *device,
struct device_attribute *attr, char *buf)
{
int refresh_rate;
struct nvhost_device *ndev = to_nvhost_device(device);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
refresh_rate = tegra_fb_get_mode(dc);
return snprintf(buf, PAGE_SIZE, "%d\n", refresh_rate);
}
static int nvhost_suspend(struct nvhost_device *dev, pm_message_t state)
{
struct nvhost_master *host = nvhost_get_drvdata(dev);
int ret = 0;
ret = nvhost_module_suspend(host->dev);
dev_info(&dev->dev, "suspend status: %d\n", ret);
return ret;
}
static void tegra_dc_shutdown(struct nvhost_device *ndev)
{
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
if (!dc || !dc->enabled)
return;
tegra_dc_blank(dc);
tegra_dc_disable(dc);
}
static ssize_t enable_show(struct device *device,
struct device_attribute *attr, char *buf)
{
struct nvhost_device *ndev = to_nvhost_device(device);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
ssize_t res;
mutex_lock(&dc->lock);
res = snprintf(buf, PAGE_SIZE, "%d\n", dc->enabled);
mutex_unlock(&dc->lock);
return res;
}
static ssize_t stats_enable_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
bool enabled;
if (mutex_lock_killable(&dc->lock))
return -EINTR;
enabled = tegra_dc_stats_get(dc);
mutex_unlock(&dc->lock);
return snprintf(buf, PAGE_SIZE, "%d", enabled);
}
static ssize_t nvdps_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
int refresh_rate;
int e;
e = kstrtoint(buf, 10, &refresh_rate);
if (e)
return e;
e = tegra_fb_set_mode(dc, refresh_rate);
return count;
}
static ssize_t crc_checksum_latched_show(struct device *device,
struct device_attribute *attr, char *buf)
{
struct nvhost_device *ndev = to_nvhost_device(device);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
u32 crc;
if (!dc->enabled) {
dev_err(&dc->ndev->dev, "%s: DC not enabled.\n", __func__);
return -EFAULT;
}
crc = tegra_dc_read_checksum_latched(dc);
return snprintf(buf, PAGE_SIZE, "%u", crc);
}
static ssize_t stats_enable_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
unsigned long val = 0;
if (strict_strtoul(buf, 10, &val) < 0)
return -EINVAL;
if (mutex_lock_killable(&dc->lock))
return -EINTR;
tegra_dc_stats_enable(dc, !!val);
mutex_unlock(&dc->lock);
return count;
}
static ssize_t enable_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
unsigned long val = 0;
if (strict_strtoul(buf, 10, &val) < 0)
return -EINVAL;
if (val) {
tegra_dc_enable(dc);
} else {
tegra_dc_disable(dc);
}
return count;
}
static int tegra_dc_resume(struct nvhost_device *ndev)
{
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
dev_info(&ndev->dev, "resume\n");
mutex_lock(&dc->lock);
if (dc->enabled)
_tegra_dc_enable(dc);
if (dc->out && dc->out->hotplug_init)
dc->out->hotplug_init();
if (dc->out_ops && dc->out_ops->resume)
dc->out_ops->resume(dc);
mutex_unlock(&dc->lock);
return 0;
}
static ssize_t nvsd_registers_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
struct device *dev = container_of((kobj->parent), struct device, kobj);
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
ssize_t res = 0;
clk_enable(dc->clk);
tegra_dc_io_start(dc);
mutex_lock(&dc->lock);
if (!dc->enabled) {
mutex_unlock(&dc->lock);
return -ENODEV;
}
mutex_unlock(&dc->lock);
NVSD_PRINT_REG(DC_DISP_SD_CONTROL);
NVSD_PRINT_REG(DC_DISP_SD_CSC_COEFF);
NVSD_PRINT_REG_ARRAY(DC_DISP_SD_LUT);
NVSD_PRINT_REG(DC_DISP_SD_FLICKER_CONTROL);
NVSD_PRINT_REG(DC_DISP_SD_PIXEL_COUNT);
NVSD_PRINT_REG_ARRAY(DC_DISP_SD_HISTOGRAM);
NVSD_PRINT_REG(DC_DISP_SD_BL_PARAMETERS);
NVSD_PRINT_REG_ARRAY(DC_DISP_SD_BL_TF);
NVSD_PRINT_REG(DC_DISP_SD_BL_CONTROL);
NVSD_PRINT_REG(DC_DISP_SD_HW_K_VALUES);
NVSD_PRINT_REG(DC_DISP_SD_MAN_K_VALUES);
#ifdef CONFIG_TEGRA_SD_GEN2
NVSD_PRINT_REG(DC_DISP_SD_K_LIMIT);
NVSD_PRINT_REG(DC_DISP_SD_WINDOW_POSITION);
NVSD_PRINT_REG(DC_DISP_SD_WINDOW_SIZE);
NVSD_PRINT_REG(DC_DISP_SD_SOFT_CLIPPING);
NVSD_PRINT_REG(DC_DISP_SD_SMOOTH_K);
#endif
tegra_dc_io_end(dc);
clk_disable(dc->clk);
return res;
}
static ssize_t orientation_3d_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
struct tegra_dc_out *dc_out = dc->out;
const char *orientation;
switch (dc_out->stereo->orientation) {
case TEGRA_DC_STEREO_LANDSCAPE:
orientation = ORIENTATION_LANDSCAPE;
break;
case TEGRA_DC_STEREO_PORTRAIT:
orientation = ORIENTATION_PORTRAIT;
break;
default:
pr_err("Invalid value is stored for stereo_orientation.\n");
return -EINVAL;
}
return snprintf(buf, PAGE_SIZE, "%s\n", orientation);
}
static ssize_t mode_3d_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
struct tegra_dc_out *dc_out = dc->out;
const char *mode;
switch (dc_out->stereo->mode_2d_3d) {
case TEGRA_DC_STEREO_MODE_2D:
mode = MODE_2D;
break;
case TEGRA_DC_STEREO_MODE_3D:
mode = MODE_3D;
break;
default:
pr_err("Invalid value is stored for stereo_mode.\n");
return -EINVAL;
}
return snprintf(buf, PAGE_SIZE, "%s\n", mode);
}
void __devexit tegra_dc_remove_sysfs(struct device *dev)
{
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
struct tegra_dc_sd_settings *sd_settings = dc->out->sd_settings;
device_remove_file(dev, &dev_attr_mode);
device_remove_file(dev, &dev_attr_nvdps);
device_remove_file(dev, &dev_attr_enable);
device_remove_file(dev, &dev_attr_stats_enable);
device_remove_file(dev, &dev_attr_crc_checksum_latched);
if (dc->out->stereo) {
device_remove_file(dev, &dev_attr_stereo_orientation);
device_remove_file(dev, &dev_attr_stereo_mode);
}
if (sd_settings)
nvsd_remove_sysfs(dev);
}
static ssize_t mode_3d_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t cnt)
{
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
struct tegra_dc_out *dc_out = dc->out;
struct tegra_stereo_out *stereo = dc_out->stereo;
int mode;
if (0 == strncmp(buf, MODE_2D, min(cnt, ARRAY_SIZE(MODE_2D) - 1))) {
mode = TEGRA_DC_STEREO_MODE_2D;
} else if (0 == strncmp(buf, MODE_3D,
min(cnt, ARRAY_SIZE(MODE_3D) - 1))) {
mode = TEGRA_DC_STEREO_MODE_3D;
} else {
pr_err("Invalid property value for stereo_mode.\n");
return -EINVAL;
}
stereo->mode_2d_3d = mode;
stereo->set_mode(mode);
return cnt;
}
static ssize_t orientation_3d_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t cnt)
{
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
struct tegra_dc_out *dc_out = dc->out;
struct tegra_stereo_out *stereo = dc_out->stereo;
int orientation;
if (0 == strncmp(buf, ORIENTATION_PORTRAIT,
min(cnt, ARRAY_SIZE(ORIENTATION_PORTRAIT) - 1))) {
orientation = TEGRA_DC_STEREO_PORTRAIT;
} else if (0 == strncmp(buf, ORIENTATION_LANDSCAPE,
min(cnt, ARRAY_SIZE(ORIENTATION_LANDSCAPE) - 1))) {
orientation = TEGRA_DC_STEREO_LANDSCAPE;
} else {
pr_err("Invalid property value for stereo_orientation.\n");
return -EINVAL;
}
stereo->orientation = orientation;
stereo->set_orientation(orientation);
return cnt;
}
static int tegra_dc_suspend(struct nvhost_device *ndev, pm_message_t state)
{
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
dev_info(&ndev->dev, "suspend\n");
tegra_dc_ext_disable(dc->ext);
mutex_lock(&dc->lock);
if (dc->out_ops && dc->out_ops->suspend)
dc->out_ops->suspend(dc);
if (dc->enabled) {
_tegra_dc_disable(dc);
}
if (dc->out && dc->out->postsuspend)
dc->out->postsuspend();
mutex_unlock(&dc->lock);
return 0;
}
static void power_on_host(struct nvhost_device *dev)
{
struct nvhost_master *host = nvhost_get_drvdata(dev);
nvhost_syncpt_reset(&host->syncpt);
nvhost_intr_start(&host->intr, clk_get_rate(dev->clk[0]));
}
static ssize_t nvsd_settings_store(struct kobject *kobj,
struct kobj_attribute *attr, const char *buf, size_t count)
{
struct device *dev = container_of((kobj->parent), struct device, kobj);
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
struct tegra_dc_sd_settings *sd_settings = dc->out->sd_settings;
ssize_t res = count;
bool settings_updated = false;
long int result;
int err;
if (sd_settings) {
if (IS_NVSD_ATTR(enable)) {
if (sd_settings->phase_in_settings) {
err = strict_strtol(buf, 10, &result);
if (err)
return err;
if (nvsd_update_enable(sd_settings, result))
nvsd_check_and_update(1, 1, enable);
} else {
nvsd_check_and_update(0, 1, enable);
}
} else if (IS_NVSD_ATTR(aggressiveness)) {
err = strict_strtol(buf, 10, &result);
if (err)
return err;
if (nvsd_update_agg(sd_settings, result)
&& !sd_settings->phase_in_settings)
settings_updated = true;
} else if (IS_NVSD_ATTR(phase_in_settings)) {
nvsd_check_and_update(0, 1, phase_in_settings);
} else if (IS_NVSD_ATTR(phase_in_adjustments)) {
nvsd_check_and_update(0, 1, phase_in_adjustments);
} else if (IS_NVSD_ATTR(bin_width)) {
nvsd_check_and_update(0, 8, bin_width);
} else if (IS_NVSD_ATTR(hw_update_delay)) {
nvsd_check_and_update(0, 2, hw_update_delay);
} else if (IS_NVSD_ATTR(use_vid_luma)) {
nvsd_check_and_update(0, 1, use_vid_luma);
} else if (IS_NVSD_ATTR(coeff)) {
int ele[3], i = 0, num = 3;
nvsd_get_multi(ele, num, i, 0, 15);
if (i == num) {
sd_settings->coeff.r = ele[0];
sd_settings->coeff.g = ele[1];
sd_settings->coeff.b = ele[2];
settings_updated = true;
} else {
res = -EINVAL;
}
} else if (IS_NVSD_ATTR(blp_time_constant)) {
nvsd_check_and_update(0, 1024, blp.time_constant);
} else if (IS_NVSD_ATTR(blp_step)) {
nvsd_check_and_update(0, 255, blp.step);
} else if (IS_NVSD_ATTR(fc_time_limit)) {
nvsd_check_and_update(0, 255, fc.time_limit);
} else if (IS_NVSD_ATTR(fc_threshold)) {
nvsd_check_and_update(0, 255, fc.threshold);
#ifdef CONFIG_TEGRA_SD_GEN2
} else if (IS_NVSD_ATTR(k_limit_enable)) {
nvsd_check_and_update(0, 1, k_limit_enable);
} else if (IS_NVSD_ATTR(k_limit)) {
nvsd_check_and_update(128, 255, k_limit);
} else if (IS_NVSD_ATTR(sd_window_enable)) {
nvsd_check_and_update(0, 1, sd_window_enable);
} else if (IS_NVSD_ATTR(sd_window)) {
int ele[4], i = 0, num = 4;
nvsd_get_multi(ele, num, i, 0, LONG_MAX);
if (i == num) {
sd_settings->sd_window.h_position = ele[0];
sd_settings->sd_window.v_position = ele[1];
sd_settings->sd_window.h_size = ele[2];
sd_settings->sd_window.v_size = ele[3];
settings_updated = true;
} else {
res = -EINVAL;
}
} else if (IS_NVSD_ATTR(soft_clipping_enable)) {
nvsd_check_and_update(0, 1, soft_clipping_enable);
} else if (IS_NVSD_ATTR(soft_clipping_threshold)) {
nvsd_check_and_update(0, 255, soft_clipping_threshold);
} else if (IS_NVSD_ATTR(smooth_k_enable)) {
nvsd_check_and_update(0, 1, smooth_k_enable);
} else if (IS_NVSD_ATTR(smooth_k_incr)) {
nvsd_check_and_update(0, 16320, smooth_k_incr);
} else if (IS_NVSD_ATTR(use_vpulse2)) {
nvsd_check_and_update(0, 1, use_vpulse2);
#endif
} else if (IS_NVSD_ATTR(lut)) {
if (nvsd_lut_store(sd_settings, buf))
res = -EINVAL;
else
settings_updated = true;
} else if (IS_NVSD_ATTR(bltf)) {
if (nvsd_bltf_store(sd_settings, buf))
res = -EINVAL;
else
settings_updated = true;
} else {
res = -EINVAL;
}
/* Re-init if our settings were updated. */
if (settings_updated) {
mutex_lock(&dc->lock);
if (!dc->enabled) {
mutex_unlock(&dc->lock);
return -ENODEV;
}
tegra_dc_hold_dc_out(dc);
nvsd_init(dc, sd_settings);
tegra_dc_release_dc_out(dc);
mutex_unlock(&dc->lock);
/* Update backlight state IFF we're disabling! */
if (!sd_settings->enable && sd_settings->bl_device) {
/* Do the actual brightness update outside of
* the mutex */
struct platform_device *pdev =
sd_settings->bl_device;
struct backlight_device *bl =
platform_get_drvdata(pdev);
if (bl)
backlight_update_status(bl);
}
}
} else {
/* This shouldn't be reachable. But just in case... */
res = -EINVAL;
}
return res;
}
/* Sysfs accessors */
static ssize_t nvsd_settings_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
struct device *dev = container_of((kobj->parent), struct device, kobj);
struct nvhost_device *ndev = to_nvhost_device(dev);
struct tegra_dc *dc = nvhost_get_drvdata(ndev);
struct tegra_dc_sd_settings *sd_settings = dc->out->sd_settings;
ssize_t res = 0;
if (sd_settings) {
if (IS_NVSD_ATTR(enable))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->enable);
else if (IS_NVSD_ATTR(aggressiveness))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->aggressiveness);
else if (IS_NVSD_ATTR(phase_in_settings))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->phase_in_settings);
else if (IS_NVSD_ATTR(phase_in_adjustments))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->phase_in_adjustments);
else if (IS_NVSD_ATTR(bin_width))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->bin_width);
else if (IS_NVSD_ATTR(hw_update_delay))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->hw_update_delay);
else if (IS_NVSD_ATTR(use_vid_luma))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->use_vid_luma);
else if (IS_NVSD_ATTR(coeff))
res = snprintf(buf, PAGE_SIZE,
"R: %d / G: %d / B: %d\n",
sd_settings->coeff.r,
sd_settings->coeff.g,
sd_settings->coeff.b);
else if (IS_NVSD_ATTR(blp_time_constant))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->blp.time_constant);
else if (IS_NVSD_ATTR(blp_step))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->blp.step);
else if (IS_NVSD_ATTR(fc_time_limit))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->fc.time_limit);
else if (IS_NVSD_ATTR(fc_threshold))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->fc.threshold);
#ifdef CONFIG_TEGRA_SD_GEN2
else if (IS_NVSD_ATTR(k_limit_enable))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->k_limit_enable);
else if (IS_NVSD_ATTR(k_limit))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->k_limit);
else if (IS_NVSD_ATTR(sd_window_enable))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->sd_window_enable);
else if (IS_NVSD_ATTR(sd_window))
res = snprintf(buf, PAGE_SIZE,
"x: %d, y: %d, w: %d, h: %d\n",
sd_settings->sd_window.h_position,
sd_settings->sd_window.v_position,
sd_settings->sd_window.h_size,
sd_settings->sd_window.v_size);
else if (IS_NVSD_ATTR(soft_clipping_enable))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->soft_clipping_enable);
else if (IS_NVSD_ATTR(soft_clipping_threshold))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->soft_clipping_threshold);
else if (IS_NVSD_ATTR(smooth_k_enable))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->smooth_k_enable);
else if (IS_NVSD_ATTR(smooth_k_incr))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->smooth_k_incr);
else if (IS_NVSD_ATTR(use_vpulse2))
res = snprintf(buf, PAGE_SIZE, "%d\n",
sd_settings->use_vpulse2);
#endif
else if (IS_NVSD_ATTR(lut))
res = nvsd_lut_show(sd_settings, buf, res);
else if (IS_NVSD_ATTR(bltf))
res = nvsd_bltf_show(sd_settings, buf, res);
else
res = -EINVAL;
} else {
/* This shouldn't be reachable. But just in case... */
res = -EINVAL;
}
return res;
}
