1509 lines
38 KiB
C
1509 lines
38 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* techpoint v4l2 driver
|
|
*
|
|
* Copyright (C) 2023 Rockchip Electronics Co., Ltd.
|
|
*
|
|
*/
|
|
|
|
#include <sound/core.h>
|
|
#include <sound/pcm.h>
|
|
#include <sound/pcm_params.h>
|
|
#include <sound/soc.h>
|
|
#include <sound/tlv.h>
|
|
#include "techpoint_dev.h"
|
|
|
|
#define TECHPOINT_NAME "techpoint"
|
|
|
|
#define OF_CAMERA_PINCTRL_STATE_DEFAULT "rockchip,camera_default"
|
|
#define OF_CAMERA_PINCTRL_STATE_SLEEP "rockchip,camera_sleep"
|
|
|
|
#define I2S 0
|
|
#define DSP 1
|
|
#define AUDIO_FORMAT I2S
|
|
|
|
#define SAMPLE_8K 0
|
|
#define SAMPLE_16K 1
|
|
#define SAMPLE_RATE SAMPLE_8K
|
|
|
|
#define DATA_16BIT 0
|
|
#define DATA_8BIT 1
|
|
#define DATA_BIT DATA_16BIT
|
|
|
|
#define AUDIO_CHN 8
|
|
#define MAX_CHIPS 4
|
|
#define MAX_SLAVES (MAX_CHIPS - 1)
|
|
|
|
#define TECHPOINT_I2C_CHIP_ADDRESS_0 0x44
|
|
#define TECHPOINT_I2C_CHIP_ADDRESS_1 0x45
|
|
|
|
static int g_idx;
|
|
static struct techpoint *g_techpoints[MAX_CHIPS];
|
|
|
|
static const char *const techpoint_supply_names[] = {
|
|
"dovdd", /* Digital I/O power */
|
|
"avdd", /* Analog power */
|
|
"dvdd", /* Digital power */
|
|
};
|
|
|
|
#define TECHPOINT_NUM_SUPPLIES ARRAY_SIZE(techpoint_supply_names)
|
|
|
|
#define to_techpoint(sd) container_of(sd, struct techpoint, subdev)
|
|
|
|
static int techpoint_get_regulators(struct techpoint *techpoint)
|
|
{
|
|
unsigned int i;
|
|
struct i2c_client *client = techpoint->client;
|
|
struct device *dev = &techpoint->client->dev;
|
|
|
|
if (!techpoint->supplies)
|
|
techpoint->supplies = devm_kzalloc(dev,
|
|
sizeof(struct
|
|
regulator_bulk_data) *
|
|
TECHPOINT_NUM_SUPPLIES,
|
|
GFP_KERNEL);
|
|
|
|
for (i = 0; i < TECHPOINT_NUM_SUPPLIES; i++)
|
|
techpoint->supplies[i].supply = techpoint_supply_names[i];
|
|
return devm_regulator_bulk_get(&client->dev,
|
|
TECHPOINT_NUM_SUPPLIES,
|
|
techpoint->supplies);
|
|
}
|
|
|
|
static int techpoint_analyze_dts(struct techpoint *techpoint)
|
|
{
|
|
int ret;
|
|
struct i2c_client *client = techpoint->client;
|
|
struct device *dev = &client->dev;
|
|
struct device_node *node = dev->of_node;
|
|
struct device_node *endpoint;
|
|
struct fwnode_handle *fwnode;
|
|
int rval;
|
|
|
|
ret = of_property_read_u32(node, RKMODULE_CAMERA_MODULE_INDEX,
|
|
&techpoint->module_index);
|
|
ret |= of_property_read_string(node, RKMODULE_CAMERA_MODULE_FACING,
|
|
&techpoint->module_facing);
|
|
ret |= of_property_read_string(node, RKMODULE_CAMERA_MODULE_NAME,
|
|
&techpoint->module_name);
|
|
ret |= of_property_read_string(node, RKMODULE_CAMERA_LENS_NAME,
|
|
&techpoint->len_name);
|
|
if (ret) {
|
|
dev_err(dev, "could not get %s!\n", RKMODULE_CAMERA_LENS_NAME);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = of_property_read_u32(node, TECHPOINT_CAMERA_XVCLK_FREQ,
|
|
&techpoint->xvclk_freq_value);
|
|
if (ret)
|
|
techpoint->xvclk_freq_value = 27000000;
|
|
|
|
endpoint = of_graph_get_next_endpoint(dev->of_node, NULL);
|
|
if (!endpoint) {
|
|
dev_err(dev, "Failed to get endpoint\n");
|
|
return -EINVAL;
|
|
}
|
|
fwnode = of_fwnode_handle(endpoint);
|
|
rval = fwnode_property_read_u32_array(fwnode, "data-lanes", NULL, 0);
|
|
if (rval <= 0) {
|
|
rval = 4;
|
|
dev_err(dev, " Get mipi lane num failed!, set default 4\n");
|
|
}
|
|
techpoint->data_lanes = rval;
|
|
|
|
techpoint->xvclk = devm_clk_get(dev, "xvclk");
|
|
if (IS_ERR(techpoint->xvclk)) {
|
|
dev_err(dev, "Failed to get xvclk\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
techpoint->power_gpio = devm_gpiod_get(dev, "power", GPIOD_OUT_HIGH);
|
|
if (IS_ERR(techpoint->power_gpio))
|
|
dev_warn(dev, "Failed to get power-gpios\n");
|
|
else
|
|
gpiod_set_value_cansleep(techpoint->power_gpio, 1);
|
|
|
|
techpoint_get_regulators(techpoint);
|
|
ret =
|
|
regulator_bulk_enable(TECHPOINT_NUM_SUPPLIES, techpoint->supplies);
|
|
if (ret < 0)
|
|
dev_warn(dev, "Failed to enable regulators\n");
|
|
|
|
techpoint->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
|
|
if (IS_ERR(techpoint->reset_gpio))
|
|
dev_warn(dev, "Failed to get reset-gpios\n");
|
|
else
|
|
gpiod_set_value_cansleep(techpoint->reset_gpio, 0);
|
|
|
|
techpoint->pinctrl = devm_pinctrl_get(dev);
|
|
if (!IS_ERR(techpoint->pinctrl)) {
|
|
techpoint->pins_default =
|
|
pinctrl_lookup_state(techpoint->pinctrl,
|
|
OF_CAMERA_PINCTRL_STATE_DEFAULT);
|
|
if (IS_ERR(techpoint->pins_default))
|
|
dev_warn(dev, "could not get default pinstate\n");
|
|
|
|
techpoint->pins_sleep =
|
|
pinctrl_lookup_state(techpoint->pinctrl,
|
|
OF_CAMERA_PINCTRL_STATE_SLEEP);
|
|
if (IS_ERR(techpoint->pins_sleep))
|
|
dev_warn(dev, "could not get sleep pinstate\n");
|
|
} else {
|
|
dev_warn(dev, "no pinctrl\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_initialize_controls(struct techpoint *techpoint)
|
|
{
|
|
int ret;
|
|
u64 pixel_rate;
|
|
struct v4l2_ctrl_handler *handler;
|
|
const struct techpoint_video_modes *mode;
|
|
struct device *dev = &techpoint->client->dev;
|
|
|
|
handler = &techpoint->ctrl_handler;
|
|
mode = techpoint->cur_video_mode;
|
|
|
|
if (techpoint->input_type == TECHPOINT_DVP_BT1120) {
|
|
ret = v4l2_ctrl_handler_init(handler, 1);
|
|
if (ret)
|
|
return ret;
|
|
handler->lock = &techpoint->mutex;
|
|
pixel_rate = mode->link_freq_value;
|
|
techpoint->pixel_rate_ctrl = v4l2_ctrl_new_std(handler, NULL,
|
|
V4L2_CID_PIXEL_RATE,
|
|
0, pixel_rate, 1,
|
|
pixel_rate);
|
|
dev_dbg(dev, "initialize pixel_rate %lld\n", pixel_rate);
|
|
} else if (techpoint->input_type == TECHPOINT_MIPI) {
|
|
ret = v4l2_ctrl_handler_init(handler, 2);
|
|
if (ret)
|
|
return ret;
|
|
handler->lock = &techpoint->mutex;
|
|
techpoint->link_freq_ctrl =
|
|
v4l2_ctrl_new_int_menu(handler, NULL, V4L2_CID_LINK_FREQ, 0,
|
|
0, &mode->link_freq_value);
|
|
__v4l2_ctrl_s_ctrl(techpoint->link_freq_ctrl, 0);
|
|
dev_dbg(dev, "initialize link_freq %lld\n",
|
|
mode->link_freq_value);
|
|
|
|
pixel_rate =
|
|
(u32) mode->link_freq_value / mode->bpp * 2 * mode->lane;
|
|
techpoint->pixel_rate_ctrl =
|
|
v4l2_ctrl_new_std(handler, NULL, V4L2_CID_PIXEL_RATE, 0,
|
|
pixel_rate, 1, pixel_rate);
|
|
dev_dbg(dev, "initialize pixel_rate %lld\n", pixel_rate);
|
|
}
|
|
|
|
if (handler->error) {
|
|
ret = handler->error;
|
|
dev_err(dev, "Failed to init controls(%d)\n", ret);
|
|
goto err_free_handler;
|
|
}
|
|
|
|
techpoint->subdev.ctrl_handler = handler;
|
|
|
|
return 0;
|
|
|
|
err_free_handler:
|
|
v4l2_ctrl_handler_free(handler);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int __techpoint_power_on(struct techpoint *techpoint)
|
|
{
|
|
int ret;
|
|
struct device *dev = &techpoint->client->dev;
|
|
|
|
if (!IS_ERR_OR_NULL(techpoint->pins_default)) {
|
|
ret = pinctrl_select_state(techpoint->pinctrl,
|
|
techpoint->pins_default);
|
|
if (ret < 0)
|
|
dev_err(dev, "could not set pins. ret=%d\n", ret);
|
|
}
|
|
|
|
if (!IS_ERR(techpoint->power_gpio)) {
|
|
gpiod_set_value_cansleep(techpoint->power_gpio, 1);
|
|
usleep_range(25 * 1000, 30 * 1000);
|
|
}
|
|
|
|
usleep_range(1500, 2000);
|
|
|
|
if (!IS_ERR(techpoint->xvclk)) {
|
|
ret =
|
|
clk_set_rate(techpoint->xvclk, techpoint->xvclk_freq_value);
|
|
if (ret < 0)
|
|
dev_warn(dev, "Failed to set xvclk rate\n");
|
|
if (clk_get_rate(techpoint->xvclk) !=
|
|
techpoint->xvclk_freq_value)
|
|
dev_warn(dev, "xvclk mismatched\n");
|
|
ret = clk_prepare_enable(techpoint->xvclk);
|
|
if (ret < 0) {
|
|
dev_err(dev, "Failed to enable xvclk\n");
|
|
goto err_clk;
|
|
}
|
|
}
|
|
|
|
if (!IS_ERR(techpoint->reset_gpio)) {
|
|
gpiod_set_value_cansleep(techpoint->reset_gpio, 0);
|
|
usleep_range(10 * 1000, 20 * 1000);
|
|
gpiod_set_value_cansleep(techpoint->reset_gpio, 1);
|
|
usleep_range(10 * 1000, 20 * 1000);
|
|
gpiod_set_value_cansleep(techpoint->reset_gpio, 0);
|
|
}
|
|
|
|
usleep_range(10 * 1000, 20 * 1000);
|
|
|
|
return 0;
|
|
|
|
err_clk:
|
|
if (!IS_ERR(techpoint->reset_gpio))
|
|
gpiod_set_value_cansleep(techpoint->reset_gpio, 0);
|
|
|
|
if (!IS_ERR_OR_NULL(techpoint->pins_sleep))
|
|
pinctrl_select_state(techpoint->pinctrl, techpoint->pins_sleep);
|
|
|
|
if (!IS_ERR(techpoint->power_gpio))
|
|
gpiod_set_value_cansleep(techpoint->power_gpio, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void __techpoint_power_off(struct techpoint *techpoint)
|
|
{
|
|
int ret;
|
|
|
|
#if TECHPOINT_SHARING_POWER
|
|
return;
|
|
#endif
|
|
|
|
if (!IS_ERR(techpoint->reset_gpio))
|
|
gpiod_set_value_cansleep(techpoint->reset_gpio, 1);
|
|
|
|
if (IS_ERR(techpoint->xvclk))
|
|
clk_disable_unprepare(techpoint->xvclk);
|
|
|
|
if (!IS_ERR_OR_NULL(techpoint->pins_sleep)) {
|
|
ret = pinctrl_select_state(techpoint->pinctrl,
|
|
techpoint->pins_sleep);
|
|
if (ret < 0)
|
|
dev_err(&techpoint->client->dev, "could not set pins\n");
|
|
}
|
|
|
|
if (!IS_ERR(techpoint->power_gpio))
|
|
gpiod_set_value_cansleep(techpoint->power_gpio, 0);
|
|
}
|
|
|
|
static int techpoint_runtime_resume(struct device *dev)
|
|
{
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
struct v4l2_subdev *sd = i2c_get_clientdata(client);
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
|
|
return __techpoint_power_on(techpoint);
|
|
}
|
|
|
|
static int techpoint_runtime_suspend(struct device *dev)
|
|
{
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
struct v4l2_subdev *sd = i2c_get_clientdata(client);
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
|
|
__techpoint_power_off(techpoint);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_power(struct v4l2_subdev *sd, int on)
|
|
{
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
struct i2c_client *client = techpoint->client;
|
|
int ret = 0;
|
|
|
|
mutex_lock(&techpoint->mutex);
|
|
|
|
/* If the power state is not modified - no work to do. */
|
|
if (techpoint->power_on == !!on)
|
|
goto exit;
|
|
|
|
dev_dbg(&client->dev, "%s: on %d\n", __func__, on);
|
|
|
|
if (on) {
|
|
ret = pm_runtime_get_sync(&client->dev);
|
|
if (ret < 0) {
|
|
pm_runtime_put_noidle(&client->dev);
|
|
goto exit;
|
|
}
|
|
techpoint->power_on = true;
|
|
} else {
|
|
pm_runtime_put(&client->dev);
|
|
techpoint->power_on = false;
|
|
}
|
|
|
|
exit:
|
|
mutex_unlock(&techpoint->mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int techpoint_get_reso_dist(struct techpoint_video_modes *mode,
|
|
struct v4l2_mbus_framefmt *framefmt)
|
|
{
|
|
return abs(mode->width - framefmt->width) +
|
|
abs(mode->height - framefmt->height);
|
|
}
|
|
|
|
static struct techpoint_video_modes *
|
|
techpoint_find_best_fit(struct techpoint *techpoint,
|
|
struct v4l2_subdev_format *fmt)
|
|
{
|
|
struct v4l2_mbus_framefmt *framefmt = &fmt->format;
|
|
int dist;
|
|
int cur_best_fit = 0;
|
|
int cur_best_fit_dist = -1;
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < techpoint->video_modes_num; i++) {
|
|
dist =
|
|
techpoint_get_reso_dist(&techpoint->video_modes[i],
|
|
framefmt);
|
|
if ((cur_best_fit_dist == -1 || dist <= cur_best_fit_dist) &&
|
|
techpoint->video_modes[i].bus_fmt == framefmt->code) {
|
|
cur_best_fit_dist = dist;
|
|
cur_best_fit = i;
|
|
}
|
|
}
|
|
|
|
return &techpoint->video_modes[cur_best_fit];
|
|
}
|
|
|
|
static int techpoint_set_fmt(struct v4l2_subdev *sd,
|
|
struct v4l2_subdev_state *sd_state,
|
|
struct v4l2_subdev_format *fmt)
|
|
{
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
struct techpoint_video_modes *mode;
|
|
|
|
mutex_lock(&techpoint->mutex);
|
|
|
|
mode = techpoint_find_best_fit(techpoint, fmt);
|
|
techpoint->cur_video_mode = mode;
|
|
fmt->format.code = mode->bus_fmt;
|
|
fmt->format.width = mode->width;
|
|
fmt->format.height = mode->height;
|
|
fmt->format.field = V4L2_FIELD_NONE;
|
|
fmt->format.colorspace = V4L2_COLORSPACE_SRGB;
|
|
|
|
if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
|
|
#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
|
|
*v4l2_subdev_get_try_format(sd, sd_state, fmt->pad) = fmt->format;
|
|
#else
|
|
mutex_unlock(&techpoint->mutex);
|
|
return -ENOTTY;
|
|
#endif
|
|
} else {
|
|
if (techpoint->streaming) {
|
|
mutex_unlock(&techpoint->mutex);
|
|
return -EBUSY;
|
|
}
|
|
}
|
|
|
|
mutex_unlock(&techpoint->mutex);
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_get_fmt(struct v4l2_subdev *sd,
|
|
struct v4l2_subdev_state *sd_state,
|
|
struct v4l2_subdev_format *fmt)
|
|
{
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
struct i2c_client *client = techpoint->client;
|
|
const struct techpoint_video_modes *mode = techpoint->cur_video_mode;
|
|
|
|
mutex_lock(&techpoint->mutex);
|
|
if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
|
|
#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
|
|
fmt->format = *v4l2_subdev_get_try_format(sd, sd_state, fmt->pad);
|
|
#else
|
|
mutex_unlock(&techpoint->mutex);
|
|
return -ENOTTY;
|
|
#endif
|
|
} else {
|
|
fmt->format.width = mode->width;
|
|
fmt->format.height = mode->height;
|
|
fmt->format.code = mode->bus_fmt;
|
|
fmt->format.field = V4L2_FIELD_NONE;
|
|
if (fmt->pad < PAD_MAX) {
|
|
if (mode->channel_reso[fmt->pad] == TECHPOINT_S_RESO_SD)
|
|
fmt->format.field = V4L2_FIELD_INTERLACED;
|
|
fmt->reserved[0] = mode->vc[fmt->pad];
|
|
}
|
|
}
|
|
mutex_unlock(&techpoint->mutex);
|
|
|
|
dev_dbg(&client->dev, "%s: %x %dx%d\n",
|
|
__func__, fmt->format.code,
|
|
fmt->format.width, fmt->format.height);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_enum_mbus_code(struct v4l2_subdev *sd,
|
|
struct v4l2_subdev_state *sd_state,
|
|
struct v4l2_subdev_mbus_code_enum *code)
|
|
{
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
|
|
if (code->index != 0)
|
|
return -EINVAL;
|
|
code->code = techpoint->cur_video_mode->bus_fmt;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_enum_frame_sizes(struct v4l2_subdev *sd,
|
|
struct v4l2_subdev_state *sd_state,
|
|
struct v4l2_subdev_frame_size_enum *fse)
|
|
{
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
|
|
if (fse->index >= techpoint->video_modes_num)
|
|
return -EINVAL;
|
|
|
|
if (fse->code != techpoint->video_modes[fse->index].bus_fmt)
|
|
return -EINVAL;
|
|
|
|
fse->min_width = techpoint->video_modes[fse->index].width;
|
|
fse->max_width = techpoint->video_modes[fse->index].width;
|
|
fse->max_height = techpoint->video_modes[fse->index].height;
|
|
fse->min_height = techpoint->video_modes[fse->index].height;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_g_frame_interval(struct v4l2_subdev *sd,
|
|
struct v4l2_subdev_frame_interval *fi)
|
|
{
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
|
|
mutex_lock(&techpoint->mutex);
|
|
fi->interval = techpoint->cur_video_mode->max_fps;
|
|
mutex_unlock(&techpoint->mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_g_mbus_config(struct v4l2_subdev *sd,
|
|
unsigned int pad_id,
|
|
struct v4l2_mbus_config *cfg)
|
|
{
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
|
|
if (techpoint->input_type == TECHPOINT_DVP_BT1120) {
|
|
cfg->type = V4L2_MBUS_BT656;
|
|
cfg->bus.parallel.flags = RKMODULE_CAMERA_BT656_CHANNELS |
|
|
V4L2_MBUS_PCLK_SAMPLE_RISING |
|
|
V4L2_MBUS_PCLK_SAMPLE_FALLING;
|
|
} else if (techpoint->input_type == TECHPOINT_MIPI) {
|
|
cfg->type = V4L2_MBUS_CSI2_DPHY;
|
|
cfg->bus.mipi_csi2.num_data_lanes = techpoint->data_lanes;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_querystd(struct v4l2_subdev *sd, v4l2_std_id *std)
|
|
{
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
|
|
if (techpoint->input_type == TECHPOINT_DVP_BT1120)
|
|
*std = V4L2_STD_ATSC;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static __maybe_unused void techpoint_get_module_inf(struct techpoint *techpoint,
|
|
struct rkmodule_inf *inf)
|
|
{
|
|
memset(inf, 0, sizeof(*inf));
|
|
strscpy(inf->base.sensor, TECHPOINT_NAME, sizeof(inf->base.sensor));
|
|
strscpy(inf->base.module, techpoint->module_name,
|
|
sizeof(inf->base.module));
|
|
strscpy(inf->base.lens, techpoint->len_name, sizeof(inf->base.lens));
|
|
}
|
|
|
|
static __maybe_unused void
|
|
techpoint_get_bt656_module_inf(struct techpoint *techpoint,
|
|
struct rkmodule_bt656_mbus_info *inf)
|
|
{
|
|
memset(inf, 0, sizeof(*inf));
|
|
if (techpoint->input_type == TECHPOINT_DVP_BT1120) {
|
|
inf->id_en_bits = RKMODULE_CAMERA_BT656_ID_EN_BITS_2;
|
|
inf->flags = RKMODULE_CAMERA_BT656_PARSE_ID_LSB |
|
|
RKMODULE_CAMERA_BT656_CHANNELS;
|
|
}
|
|
}
|
|
|
|
static void techpoint_get_vicap_rst_inf(struct techpoint *techpoint,
|
|
struct rkmodule_vicap_reset_info *rst_info)
|
|
{
|
|
rst_info->is_reset = techpoint->do_reset;
|
|
rst_info->src = RKCIF_RESET_SRC_ERR_HOTPLUG;
|
|
}
|
|
|
|
static void techpoint_set_vicap_rst_inf(struct techpoint *techpoint,
|
|
struct rkmodule_vicap_reset_info *rst_info)
|
|
{
|
|
techpoint->do_reset = rst_info->is_reset;
|
|
}
|
|
|
|
static long techpoint_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
|
|
{
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
long ret = 0;
|
|
|
|
switch (cmd) {
|
|
case RKMODULE_GET_MODULE_INFO:
|
|
techpoint_get_module_inf(techpoint, (struct rkmodule_inf *)arg);
|
|
break;
|
|
case RKMODULE_GET_BT656_MBUS_INFO:
|
|
techpoint_get_bt656_module_inf(techpoint,
|
|
(struct rkmodule_bt656_mbus_info
|
|
*)arg);
|
|
break;
|
|
case RKMODULE_GET_VC_FMT_INFO:
|
|
if (!techpoint->streaming)
|
|
techpoint_get_vc_fmt_inf(techpoint,
|
|
(struct rkmodule_vc_fmt_info *)
|
|
arg);
|
|
else
|
|
__techpoint_get_vc_fmt_inf(techpoint,
|
|
(struct rkmodule_vc_fmt_info
|
|
*)arg);
|
|
break;
|
|
case RKMODULE_GET_VC_HOTPLUG_INFO:
|
|
techpoint_get_vc_hotplug_inf(techpoint,
|
|
(struct rkmodule_vc_hotplug_info *)
|
|
arg);
|
|
break;
|
|
case RKMODULE_GET_START_STREAM_SEQ:
|
|
*(int *)arg = RKMODULE_START_STREAM_FRONT;
|
|
break;
|
|
case RKMODULE_GET_VICAP_RST_INFO:
|
|
techpoint_get_vicap_rst_inf(techpoint,
|
|
(struct rkmodule_vicap_reset_info *)
|
|
arg);
|
|
break;
|
|
case RKMODULE_SET_VICAP_RST_INFO:
|
|
techpoint_set_vicap_rst_inf(techpoint,
|
|
(struct rkmodule_vicap_reset_info *)
|
|
arg);
|
|
break;
|
|
case RKMODULE_SET_QUICK_STREAM:
|
|
techpoint_set_quick_stream(techpoint, *((u32 *)arg));
|
|
break;
|
|
default:
|
|
ret = -ENOTTY;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
static long techpoint_compat_ioctl32(struct v4l2_subdev *sd,
|
|
unsigned int cmd, unsigned long arg)
|
|
{
|
|
void __user *up = compat_ptr(arg);
|
|
struct rkmodule_inf *inf;
|
|
struct rkmodule_bt656_mbus_info *bt565_inf;
|
|
struct rkmodule_awb_cfg *cfg;
|
|
struct rkmodule_vc_fmt_info *vc_fmt_inf;
|
|
struct rkmodule_vc_hotplug_info *vc_hp_inf;
|
|
struct rkmodule_vicap_reset_info *vicap_rst_inf;
|
|
int *stream_seq;
|
|
u32 stream;
|
|
long ret = 0;
|
|
|
|
switch (cmd) {
|
|
case RKMODULE_GET_MODULE_INFO:
|
|
inf = kzalloc(sizeof(*inf), GFP_KERNEL);
|
|
if (!inf) {
|
|
ret = -ENOMEM;
|
|
return ret;
|
|
}
|
|
|
|
ret = techpoint_ioctl(sd, cmd, inf);
|
|
if (!ret) {
|
|
ret = copy_to_user(up, inf, sizeof(*inf));
|
|
if (ret)
|
|
ret = -EFAULT;
|
|
}
|
|
kfree(inf);
|
|
break;
|
|
case RKMODULE_AWB_CFG:
|
|
cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
|
|
if (!cfg) {
|
|
ret = -ENOMEM;
|
|
return ret;
|
|
}
|
|
|
|
if (copy_from_user(cfg, up, sizeof(*cfg))) {
|
|
kfree(cfg);
|
|
return -EFAULT;
|
|
}
|
|
ret = techpoint_ioctl(sd, cmd, cfg);
|
|
kfree(cfg);
|
|
break;
|
|
case RKMODULE_GET_VC_FMT_INFO:
|
|
vc_fmt_inf = kzalloc(sizeof(*vc_fmt_inf), GFP_KERNEL);
|
|
if (!vc_fmt_inf) {
|
|
ret = -ENOMEM;
|
|
return ret;
|
|
}
|
|
|
|
ret = techpoint_ioctl(sd, cmd, vc_fmt_inf);
|
|
if (!ret) {
|
|
ret = copy_to_user(up, vc_fmt_inf, sizeof(*vc_fmt_inf));
|
|
if (ret)
|
|
ret = -EFAULT;
|
|
}
|
|
kfree(vc_fmt_inf);
|
|
break;
|
|
case RKMODULE_GET_VC_HOTPLUG_INFO:
|
|
vc_hp_inf = kzalloc(sizeof(*vc_hp_inf), GFP_KERNEL);
|
|
if (!vc_hp_inf) {
|
|
ret = -ENOMEM;
|
|
return ret;
|
|
}
|
|
|
|
ret = techpoint_ioctl(sd, cmd, vc_hp_inf);
|
|
if (!ret) {
|
|
ret = copy_to_user(up, vc_hp_inf, sizeof(*vc_hp_inf));
|
|
if (ret)
|
|
ret = -EFAULT;
|
|
}
|
|
kfree(vc_hp_inf);
|
|
break;
|
|
case RKMODULE_GET_BT656_MBUS_INFO:
|
|
bt565_inf = kzalloc(sizeof(*bt565_inf), GFP_KERNEL);
|
|
if (!bt565_inf) {
|
|
ret = -ENOMEM;
|
|
return ret;
|
|
}
|
|
|
|
ret = techpoint_ioctl(sd, cmd, bt565_inf);
|
|
if (!ret) {
|
|
ret = copy_to_user(up, bt565_inf, sizeof(*bt565_inf));
|
|
if (ret)
|
|
ret = -EFAULT;
|
|
}
|
|
kfree(bt565_inf);
|
|
break;
|
|
case RKMODULE_GET_VICAP_RST_INFO:
|
|
vicap_rst_inf = kzalloc(sizeof(*vicap_rst_inf), GFP_KERNEL);
|
|
if (!vicap_rst_inf) {
|
|
ret = -ENOMEM;
|
|
return ret;
|
|
}
|
|
|
|
ret = techpoint_ioctl(sd, cmd, vicap_rst_inf);
|
|
if (!ret) {
|
|
ret = copy_to_user(up, vicap_rst_inf,
|
|
sizeof(*vicap_rst_inf));
|
|
if (ret)
|
|
ret = -EFAULT;
|
|
}
|
|
kfree(vicap_rst_inf);
|
|
break;
|
|
case RKMODULE_SET_VICAP_RST_INFO:
|
|
vicap_rst_inf = kzalloc(sizeof(*vicap_rst_inf), GFP_KERNEL);
|
|
if (!vicap_rst_inf) {
|
|
ret = -ENOMEM;
|
|
return ret;
|
|
}
|
|
|
|
if (copy_from_user(vicap_rst_inf, up, sizeof(*vicap_rst_inf))) {
|
|
kfree(vicap_rst_inf);
|
|
return -EFAULT;
|
|
}
|
|
ret = techpoint_ioctl(sd, cmd, vicap_rst_inf);
|
|
kfree(vicap_rst_inf);
|
|
break;
|
|
case RKMODULE_GET_START_STREAM_SEQ:
|
|
stream_seq = kzalloc(sizeof(*stream_seq), GFP_KERNEL);
|
|
if (!stream_seq) {
|
|
ret = -ENOMEM;
|
|
return ret;
|
|
}
|
|
|
|
ret = techpoint_ioctl(sd, cmd, stream_seq);
|
|
if (!ret) {
|
|
ret = copy_to_user(up, stream_seq, sizeof(*stream_seq));
|
|
if (ret)
|
|
return -EFAULT;
|
|
}
|
|
kfree(stream_seq);
|
|
break;
|
|
case RKMODULE_SET_QUICK_STREAM:
|
|
if (copy_from_user(&stream, up, sizeof(u32)))
|
|
return -EFAULT;
|
|
ret = techpoint_ioctl(sd, cmd, &stream);
|
|
if (ret)
|
|
ret = -EFAULT;
|
|
break;
|
|
default:
|
|
ret = -ENOIOCTLCMD;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static __maybe_unused int __techpoint_start_stream(struct techpoint *techpoint)
|
|
{
|
|
techpoint_start_video_stream(techpoint);
|
|
return 0;
|
|
}
|
|
|
|
static __maybe_unused int __techpoint_stop_stream(struct techpoint *techpoint)
|
|
{
|
|
techpoint_stop_video_stream(techpoint);
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_stream(struct v4l2_subdev *sd, int on)
|
|
{
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
struct i2c_client *client = techpoint->client;
|
|
|
|
dev_dbg(&client->dev, "s_stream: %d. %dx%d\n", on,
|
|
techpoint->cur_video_mode->width,
|
|
techpoint->cur_video_mode->height);
|
|
|
|
mutex_lock(&techpoint->mutex);
|
|
on = !!on;
|
|
if (techpoint->streaming == on)
|
|
goto unlock;
|
|
|
|
if (on)
|
|
__techpoint_start_stream(techpoint);
|
|
else
|
|
__techpoint_stop_stream(techpoint);
|
|
|
|
techpoint->streaming = on;
|
|
|
|
unlock:
|
|
mutex_unlock(&techpoint->mutex);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
|
|
static int techpoint_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
|
|
static const struct v4l2_subdev_internal_ops techpoint_internal_ops = {
|
|
.open = techpoint_open,
|
|
};
|
|
#endif
|
|
|
|
static const struct v4l2_subdev_video_ops techpoint_video_ops = {
|
|
.s_stream = techpoint_stream,
|
|
.g_frame_interval = techpoint_g_frame_interval,
|
|
.querystd = techpoint_querystd,
|
|
};
|
|
|
|
static const struct v4l2_subdev_pad_ops techpoint_subdev_pad_ops = {
|
|
.enum_mbus_code = techpoint_enum_mbus_code,
|
|
.enum_frame_size = techpoint_enum_frame_sizes,
|
|
.get_fmt = techpoint_get_fmt,
|
|
.set_fmt = techpoint_set_fmt,
|
|
.get_mbus_config = techpoint_g_mbus_config,
|
|
};
|
|
|
|
static const struct v4l2_subdev_core_ops techpoint_core_ops = {
|
|
.s_power = techpoint_power,
|
|
.ioctl = techpoint_ioctl,
|
|
#ifdef CONFIG_COMPAT
|
|
.compat_ioctl32 = techpoint_compat_ioctl32,
|
|
#endif
|
|
};
|
|
|
|
static const struct v4l2_subdev_ops techpoint_subdev_ops = {
|
|
.core = &techpoint_core_ops,
|
|
.video = &techpoint_video_ops,
|
|
.pad = &techpoint_subdev_pad_ops,
|
|
};
|
|
|
|
static const struct dev_pm_ops techpoint_pm_ops = {
|
|
SET_RUNTIME_PM_OPS(techpoint_runtime_suspend,
|
|
techpoint_runtime_resume, NULL)
|
|
};
|
|
|
|
#if IS_ENABLED(CONFIG_OF)
|
|
static const struct of_device_id techpoint_of_match[] = {
|
|
{ .compatible = "techpoint,tp2855" },
|
|
{ .compatible = "techpoint,tp2815" },
|
|
{ .compatible = "techpoint,tp9930" },
|
|
{ .compatible = "techpoint,tp9950" },
|
|
{ .compatible = "techpoint,tp9951" },
|
|
{ },
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, techpoint_of_match);
|
|
#endif
|
|
|
|
static const struct i2c_device_id techpoint_match_id[] = {
|
|
{ "techpoint", 0 },
|
|
{ },
|
|
};
|
|
|
|
static int techpoint_9930_audio_init(struct techpoint *techpoint);
|
|
|
|
static struct snd_soc_dai_driver techpoint_audio_dai = {
|
|
.name = "techpoint",
|
|
.playback = {
|
|
.stream_name = "Playback",
|
|
.channels_min = 1,
|
|
.channels_max = 16,
|
|
.rates = SNDRV_PCM_RATE_8000_384000,
|
|
.formats = (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE),
|
|
},
|
|
.capture = {
|
|
.stream_name = "Capture",
|
|
.channels_min = 1,
|
|
.channels_max = 16,
|
|
.rates = SNDRV_PCM_RATE_8000_384000,
|
|
.formats = (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE),
|
|
},
|
|
};
|
|
|
|
static ssize_t i2c_rdwr_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct techpoint *techpoint =
|
|
container_of(dev, struct techpoint, dev);
|
|
unsigned char op_type;
|
|
unsigned int reg, v;
|
|
int ret;
|
|
|
|
ret = sscanf(buf, "%c %x %x", &op_type, ®, &v);
|
|
if (ret != 3) {
|
|
dev_err(&techpoint->client->dev, "%s sscanf failed: %d\n",
|
|
__func__, ret);
|
|
return -EFAULT;
|
|
}
|
|
|
|
if (op_type == 'r')
|
|
techpoint_read_reg(techpoint->client, reg, (unsigned char *)&v);
|
|
else if (op_type == 'w')
|
|
techpoint_write_reg(techpoint->client, reg, v);
|
|
else if (op_type == 'd')
|
|
techpoint_9930_audio_init(techpoint);
|
|
|
|
return count;
|
|
}
|
|
|
|
static const struct device_attribute techpoint_attrs[] = {
|
|
__ATTR_WO(i2c_rdwr),
|
|
};
|
|
|
|
static int techpoint_codec_probe(struct snd_soc_component *component)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void techpoint_codec_remove(struct snd_soc_component *component)
|
|
{
|
|
}
|
|
|
|
static const struct snd_soc_component_driver techpoint_codec_driver = {
|
|
.probe = techpoint_codec_probe,
|
|
.remove = techpoint_codec_remove,
|
|
.idle_bias_on = 1,
|
|
.use_pmdown_time = 1,
|
|
.endianness = 1,
|
|
};
|
|
|
|
static int tp2833_audio_config_rmpos(struct i2c_client *client,
|
|
unsigned int chip, unsigned int format, unsigned int chn_num)
|
|
{
|
|
int i = 0;
|
|
unsigned char v;
|
|
|
|
/* clear first */
|
|
for (i = 0; i < 20; i++)
|
|
techpoint_write_reg(client, i, 0x00);
|
|
|
|
switch (chn_num) {
|
|
|
|
case 2:
|
|
if (format == DSP) {
|
|
techpoint_write_reg(client, 0x0, 1);
|
|
techpoint_write_reg(client, 0x1, 2);
|
|
} else {
|
|
techpoint_write_reg(client, 0x0, 1);
|
|
techpoint_write_reg(client, 0x8, 2);
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
if (format == DSP) {
|
|
techpoint_write_reg(client, 0x0, 1);
|
|
techpoint_write_reg(client, 0x1, 2);
|
|
techpoint_write_reg(client, 0x2, 3);
|
|
techpoint_write_reg(client, 0x3, 4);
|
|
} else {
|
|
techpoint_write_reg(client, 0x0, 1);
|
|
techpoint_write_reg(client, 0x1, 3);
|
|
techpoint_write_reg(client, 0x8, 2);
|
|
techpoint_write_reg(client, 0x9, 4);
|
|
}
|
|
break;
|
|
|
|
case 8:
|
|
if (chip % 4 == 0) {
|
|
if (format == DSP) {
|
|
techpoint_write_reg(client, 0x0, 1);
|
|
techpoint_write_reg(client, 0x1, 2);
|
|
techpoint_write_reg(client, 0x2, 3);
|
|
techpoint_write_reg(client, 0x3, 4);
|
|
techpoint_write_reg(client, 0x4, 5);
|
|
techpoint_write_reg(client, 0x5, 6);
|
|
techpoint_write_reg(client, 0x6, 7);
|
|
techpoint_write_reg(client, 0x7, 8);
|
|
} else {
|
|
techpoint_write_reg(client, 0x0, 1);
|
|
techpoint_write_reg(client, 0x1, 2);
|
|
techpoint_write_reg(client, 0x2, 3);
|
|
techpoint_write_reg(client, 0x3, 4);
|
|
techpoint_write_reg(client, 0x8, 5);
|
|
techpoint_write_reg(client, 0x9, 6);
|
|
techpoint_write_reg(client, 0xa, 7);
|
|
techpoint_write_reg(client, 0xb, 8);
|
|
}
|
|
} else if (chip % 4 == 1) {
|
|
if (format == DSP) {
|
|
techpoint_write_reg(client, 0x0, 0);
|
|
techpoint_write_reg(client, 0x1, 0);
|
|
techpoint_write_reg(client, 0x2, 0);
|
|
techpoint_write_reg(client, 0x3, 0);
|
|
techpoint_write_reg(client, 0x4, 1);
|
|
techpoint_write_reg(client, 0x5, 2);
|
|
techpoint_write_reg(client, 0x6, 3);
|
|
techpoint_write_reg(client, 0x7, 4);
|
|
} else {
|
|
techpoint_write_reg(client, 0x0, 0);
|
|
techpoint_write_reg(client, 0x1, 0);
|
|
techpoint_write_reg(client, 0x2, 1);
|
|
techpoint_write_reg(client, 0x3, 2);
|
|
techpoint_write_reg(client, 0x8, 0);
|
|
techpoint_write_reg(client, 0x9, 0);
|
|
techpoint_write_reg(client, 0xa, 3);
|
|
techpoint_write_reg(client, 0xb, 4);
|
|
techpoint_read_reg(client, 0x3, &v);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
if (chip % 4 == 0) {
|
|
for (i = 0; i < 16; i++)
|
|
techpoint_write_reg(client, i, i+1);
|
|
} else if (chip % 4 == 1) {
|
|
for (i = 4; i < 16; i++)
|
|
techpoint_write_reg(client, i, i+1 - 4);
|
|
} else if (chip % 4 == 2) {
|
|
for (i = 8; i < 16; i++)
|
|
techpoint_write_reg(client, i, i+1 - 8);
|
|
} else {
|
|
for (i = 12; i < 16; i++)
|
|
techpoint_write_reg(client, i, i+1 - 12);
|
|
}
|
|
break;
|
|
|
|
case 20:
|
|
for (i = 0; i < 20; i++)
|
|
techpoint_write_reg(client, i, i+1);
|
|
break;
|
|
|
|
default:
|
|
for (i = 0; i < 20; i++)
|
|
techpoint_write_reg(client, i, i+1);
|
|
break;
|
|
}
|
|
|
|
mdelay(10);
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_2855_audio_init(struct techpoint *techpoint)
|
|
{
|
|
struct i2c_client *client = techpoint->client;
|
|
|
|
unsigned char bank;
|
|
unsigned char chip_id_h = 0xFF, chip_id_l = 0xFF;
|
|
|
|
techpoint_read_reg(client, CHIP_ID_H_REG, &chip_id_h);
|
|
techpoint_read_reg(client, CHIP_ID_L_REG, &chip_id_l);
|
|
|
|
techpoint_read_reg(client, 0x40, &bank);
|
|
techpoint_write_reg(client, 0x40, 0x40);
|
|
|
|
tp2833_audio_config_rmpos(client, 0, AUDIO_FORMAT, AUDIO_CHN);
|
|
|
|
techpoint_write_reg(client, 0x17, 0x00|(DATA_BIT<<2));
|
|
techpoint_write_reg(client, 0x1B, 0x01|(DATA_BIT<<6));
|
|
|
|
#if (AUDIO_CHN == 20)
|
|
techpoint_write_reg(client, 0x18, 0x90|(SAMPLE_RATE));
|
|
#else
|
|
techpoint_write_reg(client, 0x18, 0x80|(SAMPLE_RATE));
|
|
#endif
|
|
|
|
#if (AUDIO_CHN >= 8)
|
|
techpoint_write_reg(client, 0x19, 0x1F);
|
|
#else
|
|
techpoint_write_reg(client, 0x19, 0x0F);
|
|
#endif
|
|
|
|
techpoint_write_reg(client, 0x1A, 0x15);
|
|
|
|
techpoint_write_reg(client, 0x37, 0x20);
|
|
techpoint_write_reg(client, 0x38, 0x38);
|
|
techpoint_write_reg(client, 0x3E, 0x00);
|
|
|
|
/* audio reset */
|
|
techpoint_write_reg(client, 0x3d, 0x01);
|
|
|
|
techpoint_write_reg(client, 0x40, bank);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_9930_audio_init(struct techpoint *techpoint)
|
|
{
|
|
struct i2c_client *client = techpoint->client;
|
|
|
|
unsigned char bank;
|
|
unsigned char chip_id_h = 0xFF;
|
|
unsigned char chip_id_l = 0xFF;
|
|
|
|
techpoint_read_reg(client, CHIP_ID_H_REG, &chip_id_h);
|
|
techpoint_read_reg(client, CHIP_ID_L_REG, &chip_id_l);
|
|
|
|
techpoint_read_reg(client, 0x40, &bank);
|
|
techpoint_write_reg(client, 0x40, 0x40);
|
|
|
|
tp2833_audio_config_rmpos(client, 1, AUDIO_FORMAT, AUDIO_CHN);
|
|
|
|
techpoint_write_reg(client, 0x17, 0x00|(DATA_BIT<<2));
|
|
techpoint_write_reg(client, 0x1B, 0x01|(DATA_BIT<<6));
|
|
|
|
#if (AUDIO_CHN == 20)
|
|
techpoint_write_reg(client, 0x18, 0x90|(SAMPLE_RATE));
|
|
#else
|
|
techpoint_write_reg(client, 0x18, 0x80|(SAMPLE_RATE));
|
|
#endif
|
|
|
|
#if (AUDIO_CHN >= 8)
|
|
techpoint_write_reg(client, 0x19, 0x1F);
|
|
#else
|
|
techpoint_write_reg(client, 0x19, 0x0F);
|
|
#endif
|
|
|
|
techpoint_write_reg(client, 0x1A, 0x15);
|
|
techpoint_write_reg(client, 0x37, 0x20);
|
|
techpoint_write_reg(client, 0x38, 0x38);
|
|
techpoint_write_reg(client, 0x3E, 0x00);
|
|
|
|
/* reset audio */
|
|
techpoint_write_reg(client, 0x3d, 0x01);
|
|
|
|
techpoint_write_reg(client, 0x40, bank);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_audio_init(struct techpoint *techpoint)
|
|
{
|
|
if (techpoint)
|
|
techpoint_2855_audio_init(techpoint);
|
|
|
|
if (techpoint && techpoint->audio_in)
|
|
techpoint_9930_audio_init(techpoint->audio_in->slave_tp[0]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_audio_dt_parse(struct techpoint *techpoint)
|
|
{
|
|
struct device *dev = &techpoint->client->dev;
|
|
struct device_node *node = dev->of_node;
|
|
const char *str;
|
|
u32 v;
|
|
|
|
/* Parse audio parts */
|
|
techpoint->audio_in = NULL;
|
|
if (!of_property_read_string(node, "techpoint,audio-in-format", &str)) {
|
|
struct techpoint_audio *audio_stream;
|
|
|
|
techpoint->audio_in = devm_kzalloc(dev, sizeof(struct techpoint_audio),
|
|
GFP_KERNEL);
|
|
if (!techpoint->audio_in)
|
|
return -ENOMEM;
|
|
|
|
audio_stream = techpoint->audio_in;
|
|
|
|
if (strcmp(str, "i2s") == 0)
|
|
audio_stream->audfmt = AUDFMT_I2S;
|
|
else if (strcmp(str, "dsp") == 0)
|
|
audio_stream->audfmt = AUDFMT_DSP;
|
|
else {
|
|
dev_err(dev, "techpoint,audio-in-format invalid\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!of_property_read_u32(node, "techpoint,audio-in-mclk-fs", &v)) {
|
|
switch (v) {
|
|
case 256:
|
|
break;
|
|
default:
|
|
dev_err(dev,
|
|
"techpoint,audio-in-mclk-fs invalid\n");
|
|
return -EINVAL;
|
|
}
|
|
audio_stream->mclk_fs = v;
|
|
}
|
|
|
|
if (!of_property_read_u32(node, "techpoint,audio-in-cascade-num", &v))
|
|
audio_stream->cascade_num = v;
|
|
|
|
if (!of_property_read_u32(node, "techpoint,audio-in-cascade-order", &v)) {
|
|
if (v > 1)
|
|
dev_err(dev,
|
|
"audio-in-cascade-order should be 1st chip, otherwise without cascade (is 0)\n");
|
|
else
|
|
audio_stream->cascade_order = v;
|
|
}
|
|
|
|
if (audio_stream->cascade_order == 1) {
|
|
struct device_node *np;
|
|
int i, count;
|
|
|
|
count = of_count_phandle_with_args(node,
|
|
"techpoint,audio-in-cascade-slaves",
|
|
NULL);
|
|
if (count < 0 || count > MAX_SLAVES)
|
|
return -EINVAL;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
np = of_parse_phandle(node, "techpoint,audio-in-cascade-slaves", i);
|
|
if (!np)
|
|
return -ENODEV;
|
|
}
|
|
|
|
for (i = 0; i < g_idx; i++) {
|
|
struct techpoint *tp = g_techpoints[i];
|
|
|
|
if (tp->i2c_idx != techpoint->i2c_idx) {
|
|
audio_stream->slave_tp[i] = tp;
|
|
audio_stream->slave_num++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
techpoint->audio_out = NULL;
|
|
if (!of_property_read_string(node, "techpoint,audio-out-format", &str)) {
|
|
struct techpoint_audio *audio_stream;
|
|
|
|
techpoint->audio_out = devm_kzalloc(dev, sizeof(struct techpoint_audio),
|
|
GFP_KERNEL);
|
|
if (!techpoint->audio_out)
|
|
return -ENOMEM;
|
|
|
|
audio_stream = techpoint->audio_out;
|
|
|
|
if (strcmp(str, "i2s") == 0)
|
|
audio_stream->audfmt = AUDFMT_I2S;
|
|
else if (strcmp(str, "dsp") == 0)
|
|
audio_stream->audfmt = AUDFMT_DSP;
|
|
else {
|
|
dev_err(dev, "techpoint,audio-out-format invalid\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!of_property_read_u32(node, "techpoint,audio-out-mclk-fs", &v)) {
|
|
switch (v) {
|
|
case 256:
|
|
break;
|
|
default:
|
|
dev_err(dev,
|
|
"techpoint,audio-out-mclk-fs invalid\n");
|
|
return -EINVAL;
|
|
}
|
|
audio_stream->mclk_fs = v;
|
|
}
|
|
|
|
if (!of_property_read_u32(node, "techpoint,audio-out-cascade-num", &v))
|
|
audio_stream->cascade_num = v;
|
|
|
|
if (!of_property_read_u32(node, "techpoint,audio-out-cascade-order", &v)) {
|
|
if (v > 1)
|
|
dev_err(dev,
|
|
"audio-out-cascade-order should be 1st chip, otherwise without cascade (is 0)\n");
|
|
else
|
|
audio_stream->cascade_order = v;
|
|
}
|
|
}
|
|
|
|
if (!techpoint->audio_in && !techpoint->audio_out)
|
|
return -ENODEV;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_audio_probe(struct techpoint *techpoint)
|
|
{
|
|
struct device *dev = &techpoint->client->dev;
|
|
int ret;
|
|
unsigned char i;
|
|
|
|
switch (techpoint->chip_id) {
|
|
case CHIP_TP9930:
|
|
techpoint_9930_audio_init(techpoint);
|
|
break;
|
|
case CHIP_TP2855:
|
|
techpoint_2855_audio_init(techpoint);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (techpoint->chip_id == CHIP_TP9930) {
|
|
techpoint_write_reg(techpoint->client, 0x40, 0x00);
|
|
for (i = 0; i < 0xff; i++)
|
|
techpoint_write_reg(techpoint->client, i, 0xbb);
|
|
}
|
|
|
|
ret = techpoint_audio_dt_parse(techpoint);
|
|
if (ret) {
|
|
dev_info(dev, "hasn't audio DT nodes\n");
|
|
return 0;
|
|
}
|
|
|
|
ret = techpoint_audio_init(techpoint);
|
|
if (ret) {
|
|
dev_info(dev, "audio init failed(%d)\n", ret);
|
|
return 0;
|
|
}
|
|
|
|
ret = devm_snd_soc_register_component(dev,
|
|
&techpoint_codec_driver,
|
|
&techpoint_audio_dai, 1);
|
|
if (ret) {
|
|
dev_err(dev, "register audio codec failed\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
dev_info(dev, "registered audio codec\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void techpoint_device_release(struct device *dev)
|
|
{
|
|
|
|
}
|
|
|
|
static int techpoint_sysfs_init(struct i2c_client *client,
|
|
struct techpoint *techpoint)
|
|
{
|
|
struct device *dev = &techpoint->dev;
|
|
int i;
|
|
|
|
dev->release = techpoint_device_release;
|
|
dev->parent = &client->dev;
|
|
set_dev_node(dev, dev_to_node(&client->dev));
|
|
dev_set_name(dev, "techpoint-dev");
|
|
|
|
if (device_register(dev)) {
|
|
dev_err(&client->dev,
|
|
"Register 'techpoint-dev' failed\n");
|
|
dev->parent = NULL;
|
|
return -ENOMEM;
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(techpoint_attrs); i++) {
|
|
if (device_create_file(dev, &techpoint_attrs[i])) {
|
|
dev_err(&client->dev,
|
|
"Create 'techpoint-dev' attr failed\n");
|
|
device_unregister(dev);
|
|
return -ENOMEM;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int techpoint_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct device *dev = &client->dev;
|
|
struct techpoint *techpoint;
|
|
struct v4l2_subdev *sd;
|
|
__maybe_unused char facing[2];
|
|
int ret = 0, index;
|
|
|
|
dev_info(dev, "driver version: %02x.%02x.%02x",
|
|
DRIVER_VERSION >> 16,
|
|
(DRIVER_VERSION & 0xff00) >> 8, DRIVER_VERSION & 0x00ff);
|
|
|
|
techpoint = devm_kzalloc(dev, sizeof(*techpoint), GFP_KERNEL);
|
|
if (!techpoint)
|
|
return -ENOMEM;
|
|
|
|
techpoint->client = client;
|
|
techpoint->supplies = NULL;
|
|
|
|
techpoint_sysfs_init(client, techpoint);
|
|
|
|
mutex_init(&techpoint->mutex);
|
|
|
|
sd = &techpoint->subdev;
|
|
v4l2_i2c_subdev_init(sd, client, &techpoint_subdev_ops);
|
|
|
|
techpoint_analyze_dts(techpoint);
|
|
|
|
ret = __techpoint_power_on(techpoint);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to power on techpoint\n");
|
|
goto err_destroy_mutex;
|
|
}
|
|
|
|
ret = techpoint_initialize_devices(techpoint);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to initialize techpoint device\n");
|
|
goto err_power_off;
|
|
}
|
|
|
|
ret = techpoint_initialize_controls(techpoint);
|
|
if (ret) {
|
|
dev_err(dev, "Failed to initialize controls techpoint\n");
|
|
goto err_free_handler;
|
|
}
|
|
#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
|
|
sd->internal_ops = &techpoint_internal_ops;
|
|
sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
|
|
#endif
|
|
|
|
#if defined(CONFIG_MEDIA_CONTROLLER)
|
|
for (index = 0; index < PAD_MAX; index++)
|
|
techpoint->pad[index].flags = MEDIA_PAD_FL_SOURCE;
|
|
sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
|
|
ret = media_entity_pads_init(&sd->entity, PAD_MAX, techpoint->pad);
|
|
if (ret < 0)
|
|
goto err_power_off;
|
|
#endif
|
|
|
|
memset(facing, 0, sizeof(facing));
|
|
if (strcmp(techpoint->module_facing, "back") == 0)
|
|
facing[0] = 'b';
|
|
else
|
|
facing[0] = 'f';
|
|
|
|
snprintf(sd->name, sizeof(sd->name), "m%02d_%s_%s %s",
|
|
techpoint->module_index, facing,
|
|
TECHPOINT_NAME, dev_name(sd->dev));
|
|
|
|
ret = v4l2_async_register_subdev_sensor(sd);
|
|
if (ret) {
|
|
dev_err(dev, "v4l2 async register subdev failed\n");
|
|
goto err_clean_entity;
|
|
}
|
|
|
|
techpoint->i2c_idx = g_idx;
|
|
g_techpoints[g_idx++] = techpoint;
|
|
|
|
ret = techpoint_audio_probe(techpoint);
|
|
if (ret) {
|
|
dev_err(dev, "sound audio probe failed\n");
|
|
goto err_clean_entity;
|
|
}
|
|
|
|
pm_runtime_set_active(dev);
|
|
pm_runtime_enable(dev);
|
|
pm_runtime_idle(dev);
|
|
|
|
return 0;
|
|
|
|
err_clean_entity:
|
|
#if defined(CONFIG_MEDIA_CONTROLLER)
|
|
media_entity_cleanup(&sd->entity);
|
|
#endif
|
|
err_free_handler:
|
|
v4l2_ctrl_handler_free(&techpoint->ctrl_handler);
|
|
err_power_off:
|
|
__techpoint_power_off(techpoint);
|
|
err_destroy_mutex:
|
|
mutex_destroy(&techpoint->mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void techpoint_remove(struct i2c_client *client)
|
|
{
|
|
struct v4l2_subdev *sd = i2c_get_clientdata(client);
|
|
struct techpoint *techpoint = to_techpoint(sd);
|
|
|
|
v4l2_async_unregister_subdev(sd);
|
|
#if defined(CONFIG_MEDIA_CONTROLLER)
|
|
media_entity_cleanup(&sd->entity);
|
|
#endif
|
|
v4l2_ctrl_handler_free(&techpoint->ctrl_handler);
|
|
mutex_destroy(&techpoint->mutex);
|
|
|
|
pm_runtime_disable(&client->dev);
|
|
if (!pm_runtime_status_suspended(&client->dev))
|
|
__techpoint_power_off(techpoint);
|
|
pm_runtime_set_suspended(&client->dev);
|
|
}
|
|
|
|
static struct i2c_driver techpoint_i2c_driver = {
|
|
.driver = {
|
|
.name = TECHPOINT_NAME,
|
|
.pm = &techpoint_pm_ops,
|
|
.of_match_table = of_match_ptr(techpoint_of_match),
|
|
},
|
|
.probe = &techpoint_probe,
|
|
.remove = &techpoint_remove,
|
|
.id_table = techpoint_match_id,
|
|
};
|
|
|
|
static int __init sensor_mod_init(void)
|
|
{
|
|
return i2c_add_driver(&techpoint_i2c_driver);
|
|
}
|
|
|
|
static void __exit sensor_mod_exit(void)
|
|
{
|
|
i2c_del_driver(&techpoint_i2c_driver);
|
|
}
|
|
|
|
device_initcall_sync(sensor_mod_init);
|
|
module_exit(sensor_mod_exit);
|
|
|
|
MODULE_AUTHOR("Vicent Chi <vicent.chi@rock-chips.com>");
|
|
MODULE_DESCRIPTION("Techpoint decoder driver");
|
|
MODULE_LICENSE("GPL");
|