static ssize_t
client_event_program_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t size)
{
return get_string(to_client(dev),
&to_client(dev)->event_program,
NULL, buf, size);
}
static ssize_t
client_flag_nogrow_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t size)
{
if (to_client(dev)->enabled)
return -EINVAL;
return kstrtoint(buf, 0, &to_client(dev)->flag_nogrow) ? : size;
}
static ssize_t
client_event_program_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
if (!to_client(dev)->event_program)
return 0;
return sprintf(buf, "%s\n", to_client(dev)->event_program);
}
static ssize_t
client_filterpath_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t size)
{
return get_string(to_client(dev),
&to_client(dev)->filterpath,
&to_client(dev)->filterpath_len,
buf, size);
}
static ssize_t
client_filterpath_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
if (!to_client(dev)->filterpath)
return 0;
return sprintf(buf, "%s\n", to_client(dev)->filterpath);
}
void new_server_thread (int con, struct sockaddr_in *cliaddr, int *len)
{
userT *user = (userT *) malloc (sizeof (userT));
user->fd = con;
memcpy (&user->sin_addr, &cliaddr->sin_addr, sizeof (struct in_addr));
if (getpeername (con, (struct sockaddr *) cliaddr, len) < 0)
{
// Couldn't determine remote peer name
syslog (LOG_CRIT, "Couldn't determine remote peer address");
return;
} else
{
strncpy (user->peername, inet_ntoa (cliaddr->sin_addr),
MAX_ARPA_ADDR);
}
if (!to_client (user->fd, GREETING))
{
user->time = time(NULL);
if (new_connection(user))
{
user->errors = 0;
smunge (user);
}
}
return ;
}
static int sensor_sr200_init(struct v4l2_subdev *subdev, u32 val)
{
int ret = 0;
u8 id;
struct sr200_state *state = to_state(subdev);
struct i2c_client *client = to_client(subdev);
cam_info("%s : E \n", __func__);
state->system_clock = 146 * 1000 * 1000;
state->line_length_pck = 146 * 1000 * 1000;
#ifdef CONFIG_LOAD_FILE
ret = sr200_regs_table_init();
CHECK_ERR_MSG(ret, "[CONFIG_LOAD_FILE] init fail \n");
#endif
sensor_sr200_apply_set(subdev, "sr200_Init_Reg", &sr200_regset_table.init);
sensor_sr200_apply_set(subdev, "sr200_stop_stream", &sr200_regset_table.stop_stream);
fimc_is_sr200_read8(client, 0x4, &id);
state->initialized = 1;
state->power_on = SR200_HW_POWER_ON;
state->runmode = RUNMODE_INIT;
state->preview.update_frmsize = 1;
cam_info("%s(id : %X) : X \n", __func__, id);
return ret;
}
static ssize_t
client_enable_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t size)
{
struct l4fdx_client *client = to_client(dev);
void *objmem;
if (client->enabled)
return -EINVAL;
objmem = kmalloc(l4x_fdx_srv_objsize(), GFP_KERNEL);
if (!objmem)
return -ENOMEM;
client->enabled = 1;
INIT_WORK(&client->create_work, create_server);
client->srv_obj = L4XV_FN(l4fdx_srv_obj,
l4x_fdx_srv_create_name(l4x_cpu_thread_get_cap(0),
client->capname,
&b_ops, client,
objmem));
if (IS_ERR(client->srv_obj)) {
kfree(objmem);
return PTR_ERR(client->srv_obj);
}
queue_work(khelper_wq, &client->create_work);
return size;
}
static inline int sr200_get_exif_iso(struct v4l2_subdev *subdev, u16 *iso)
{
struct i2c_client *client = to_client(subdev);
int err = 0;
u8 read_value = 0;
unsigned short gain_value = 0;
err = fimc_is_sr200_write8(client, 0x03, 0x20);
CHECK_ERR_COND(err < 0, -ENODEV);
fimc_is_sr200_read8(client, 0xb0, &read_value);
gain_value = ((read_value * 100) / 32) + 50;
cam_dbg("iso : gain_value=%d, read_value=%d\n", gain_value, read_value);
if (gain_value < 114)
*iso = 50;
else if (gain_value < 214)
*iso = 100;
else if (gain_value < 264)
*iso = 200;
else if (gain_value < 752)
*iso = 400;
else
*iso = 800;
cam_dbg("ISO=%d\n", *iso);
return 0;
}
static inline int sr200_get_exif_exptime(struct v4l2_subdev *subdev, u32 *exp_time)
{
struct i2c_client *client = to_client(subdev);
int err = 0;
u8 read_value1 = 0;
u8 read_value2 = 0;
u8 read_value3 = 0;
int OPCLK = 26000000;
err = fimc_is_sr200_write8(client, 0x03, 0x20);
CHECK_ERR_COND(err < 0, -ENODEV);
fimc_is_sr200_read8(client, 0x80, &read_value1);
fimc_is_sr200_read8(client, 0x81, &read_value2);
fimc_is_sr200_read8(client, 0x82, &read_value3);
cam_dbg("exposure time read_value %d, %d, %d\n",
read_value1, read_value2, read_value3);
if(read_value1 == 0 && read_value2 == 0 && read_value3 == 0)
{
*exp_time = 0;
err = -EFAULT;
} else {
*exp_time = OPCLK / ((read_value1 << 19) + (read_value2 << 11) + (read_value3 << 3));
cam_dbg("exposure time %u\n", *exp_time);
}
return err;
}
static int sr200_write_regs(struct v4l2_subdev *sd, const struct sensor_reg regs[], int size)
{
int err = 0, i;
struct i2c_client *client = to_client(sd);
for (i = 0; i < size; i++) {
err = fimc_is_sr200_write8(client, regs[i].addr, regs[i].data);
CHECK_ERR_MSG(err, "register set failed\n");
}
return 0;
}
static ssize_t
client_flag_nogrow_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
return sprintf(buf, "%d\n", to_client(dev)->flag_nogrow);
}
static ssize_t
client_openflags_mask_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
return sprintf(buf, "0%o\n", to_client(dev)->openflags_mask);
}
static ssize_t
client_enable_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
return sprintf(buf, "%u\n", to_client(dev)->enabled);
}
static int sr200_write_regs_from_sd(struct v4l2_subdev *sd, const char *name)
{
char *start = NULL, *end = NULL, *reg = NULL, *temp_start = NULL;
u8 addr = 0, value = 0;
u8 data = 0;
char data_buf[5] = {0, };
u32 len = 0;
int err = 0;
struct i2c_client *client = to_client(sd);
cam_info("%s : E, sr200_regs_table_size - %d\n", __func__, sr200_regs_table_size);
addr = value = 0;
*(data_buf + 4) = '\0';
start = strnstr(sr200_regs_table, name, sr200_regs_table_size);
CHECK_ERR_COND_MSG(start == NULL, -ENODATA, "start is NULL\n");
end = strnstr(start, "};", sr200_regs_table_size);
CHECK_ERR_COND_MSG(start == NULL, -ENODATA, "end is NULL\n");
while (1) {
len = end -start;
temp_start = strnstr(start, "{", len);
if (!temp_start || (temp_start > end)) {
cam_info("write end of %s\n", name);
break;
}
start = temp_start;
len = end -start;
/* Find Address */
reg = strnstr(start, "0x", len);
if (!reg || (reg > end)) {
cam_info("write end of %s\n", name);
break;
}
start = (reg + 4);
/* Write Value to Address */
memcpy(data_buf, reg, 4);
err = kstrtou8(data_buf, 16, &data);
CHECK_ERR_MSG(err, "kstrtou16 failed\n");
addr = data;
len = end -start;
/* Find Data */
reg = strnstr(start, "0x", len);
if (!reg || (reg > end)) {
cam_info("write end of %s\n", name);
break;
}
/* Write Value to Address */
memcpy(data_buf, reg, 4);
err = kstrtou8(data_buf, 16, &data);
CHECK_ERR_MSG(err, "kstrtou16 failed\n");
value = data;
err = fimc_is_sr200_write8(client, addr, value);
CHECK_ERR_MSG(err, "register set failed\n");
}
cam_info("%s : X\n", __func__);
return err;
}
