static int watch_fontdata_attr_init(struct lg4945_data *d)
{
d->watch.font_written_size = 0;
d->watch.font_width = 0;
d->watch.font_written_comp_size = COMP_FONTM_MAX_SIZE;
d->watch.fontdata_size = MAX_WATCH_DATA_SIZE;
d->watch.fontdata_comp_size = COMP_FONTM_MAX_SIZE;
d->watch.ext_wdata.font_data =
kzalloc(d->watch.fontdata_size, GFP_KERNEL);
d->watch.ext_wdata.comp_buf =
kzalloc(d->watch.fontdata_comp_size, GFP_KERNEL);
if (d->watch.ext_wdata.font_data && d->watch.ext_wdata.comp_buf) {
TOUCH_I("%s font_buffer(%d KB) malloc\n", __func__,
d->watch.fontdata_size/1024);
} else {
TOUCH_E("%s font_buffer(%d KB) malloc failed\n", __func__,
d->watch.fontdata_size/1024);
return 1;
}
sysfs_bin_attr_init(&d->watch.fontdata_attr);
d->watch.fontdata_attr.attr.name = "config_fontdata";
d->watch.fontdata_attr.attr.mode = S_IWUSR | S_IRUSR;
d->watch.fontdata_attr.read = watch_access_read;
d->watch.fontdata_attr.write = watch_access_write;
d->watch.fontdata_attr.size = d->watch.fontdata_size;
if (sysfs_create_bin_file(&d->kobj, &d->watch.fontdata_attr) < 0)
TOUCH_E("Failed to create %s\n",
d->watch.fontdata_attr.attr.name);
return 0;
}
static ssize_t store_extwatch_fontonoff
(struct device *dev, const char *buf, size_t count)
{
struct lg4945_data *d = to_lg4945_data(dev);
u8 value;
u8 zero = '0';
int ret = 0;
if (atomic_read(&d->block_watch_cfg) == SUPPORT)
return count;
memcpy((char *)&value, buf, sizeof(u8));
if (value == POWER_OFF || value == zero)
value = 0x00;
else
value = 0x01;
TOUCH_I("%s : %s\n", __func__,
value ? "On" : "Off");
ret = ext_watch_set_cfg(dev);
if (ret)
TOUCH_E("Fail %d\n", ret);
d->watch.ext_wdata.time.disp_waton = value;
ret = ext_watch_onoff(dev);
if (ret)
TOUCH_E("Fail %d\n", ret);
return count;
}
int ext_watch_check_font_download(struct device *dev)
{
struct touch_core_data *ts = to_touch_core(dev);
struct lg4945_data *d = to_lg4945_data(dev);
int ret = 0;
TOUCH_I("%s:start\n", __func__);
if (atomic_read(&d->watch.state.is_font) != DOWN_LOADED) {
TOUCH_I("%s : font data is not\n", __func__);
return -ENOMEM;
}
if (touch_mfts_mode_check(dev))
return -EBUSY;
if (atomic_read(&d->watch.state.font_mem) == DOWN_LOADING) {
TOUCH_I("%s : doing download..\n", __func__);
return -EBUSY;
}
if (atomic_read(&d->watch.state.font_mem) == DOWN_LOADED) {
TOUCH_I("%s : not need download..\n", __func__);
return -EBUSY;
}
if (d->watch.ext_wdata.font_data == NULL) {
TOUCH_E("%s : font data is not ready\n",
__func__);
return -ENOMEM;
}
queue_delayed_work(ts->wq, &d->font_download_work, 0);
return ret;
}
static ssize_t show_extwatch_current_time
(struct device *dev, char *buf)
{
struct lg4945_data *d = to_lg4945_data(dev);
int ret = 0;
TOUCH_TRACE();
if (d == NULL)
return ret;
ret = lg4945_reg_read(dev, EXT_WATCH_RTC_CTST,
(u8 *)&d->watch.ext_wdata.time.rtc_ctst, sizeof(u32));
if (ret) {
TOUCH_E("lg4945_read error : %d\n", ret);
return ret;
}
ret = snprintf(buf, PAGE_SIZE, "%02d:%02d:%02d:%03d\n",
d->watch.ext_wdata.time.rtc_ctst.hour,
d->watch.ext_wdata.time.rtc_ctst.min,
d->watch.ext_wdata.time.rtc_ctst.sec,
d->watch.ext_wdata.time.rtc_sctcnt);
return ret;
}
static ssize_t store_extwatch_fontposition_config(struct device *dev,
const char *buf, size_t count)
{
struct lg4945_data *d = to_lg4945_data(dev);
struct ExtWatchFontPostionConfig cfg;
if (atomic_read(&d->block_watch_cfg) == SUPPORT)
return count;
memcpy((char *)&cfg, buf, sizeof(struct ExtWatchFontPostionConfig));
d->watch.ext_wdata.mode.watch_area.watstartx = cfg.watstartx;
d->watch.ext_wdata.mode.watch_area.watendx = cfg.watendx;
d->watch.ext_wdata.position.h10x_pos = cfg.h10x_pos;
d->watch.ext_wdata.position.h1x_pos = cfg.h1x_pos;
d->watch.ext_wdata.position.m10x_pos = cfg.m10x_pos;
d->watch.ext_wdata.position.m1x_pos = cfg.m1x_pos;
d->watch.ext_wdata.position.clx_pos = cfg.clx_pos;
if ( cfg.watstartx < 0x190 || cfg.watendx > 0x5A0 )
TOUCH_E("check the position. (invalid range)\n");
TOUCH_I("%s : Watch area [%d , %d] position [%d %d %d %d %d]\n",
__func__, cfg.watstartx, cfg.watendx, cfg.h10x_pos,
cfg.h1x_pos, cfg.clx_pos, cfg.m10x_pos, cfg.m1x_pos);
return count;
}
static ssize_t store_extwatch_timesync_config(struct device *dev,
const char *buf, size_t count)
{
struct lg4945_data *d = to_lg4945_data(dev);
struct ExtWatchTimeSyncConfig cfg;
int ret = 0;
if (atomic_read(&d->block_watch_cfg) == SUPPORT)
return count;
memcpy((char *)&cfg, buf, sizeof(struct ExtWatchTimeSyncConfig));
d->watch.ext_wdata.time.rtc_sct.hour = cfg.rtc_cwhour;
d->watch.ext_wdata.time.rtc_sct.min = cfg.rtc_cwmin;
d->watch.ext_wdata.time.rtc_sct.sec = cfg.rtc_cwsec;
d->watch.ext_wdata.time.rtc_sctcnt = cfg.rtc_cwmilli;
TOUCH_I("%s : %02d:%02d:%02d.%03d\n", __func__,
cfg.rtc_cwhour, cfg.rtc_cwmin, cfg.rtc_cwsec, cfg.rtc_cwmilli);
ret = ext_watch_set_current_time(dev);
if (ret)
TOUCH_E("%s fail\n", __func__);
return count;
}
static int ext_watch_font_dump(struct device *dev, char *font_dump)
{
u32 font_sel = 0;
u32 font_data_offset = 0;
u32 wdata = 0;
u32 size = 0;
int ret = 0;
TOUCH_TRACE();
/* Font memory access enable */
wdata = 1;
ret = lg4945_reg_write(dev, EXT_WATCH_FONT_ACC_EN,
(u8 *)&wdata, sizeof(u32));
if (ret)
goto error;
size = sizeof(u32) * EXT_WATCH_FONT_NUM_SIZE;
for (font_sel = 0; font_sel < 10; font_sel++) {
/* Font select : '0' ~ '9' */
font_data_offset = font_sel * size;
ret = lg4945_reg_write(dev, EXT_WATCH_FONT_SEL,
(u8 *)&font_sel, sizeof(u32));
if (ret)
goto error;
ret = lg4945_reg_read(dev, EXT_WATCH_FONT_OFFSET_ADDR,
(u8 *)&font_dump[font_data_offset], size);
if (ret)
goto error;
}
/* Font select : ':' */
font_data_offset = font_sel * size;
size = sizeof(u32) * EXT_WATCH_FONT_CHAR_SIZE;
ret = lg4945_reg_write(dev, EXT_WATCH_FONT_SEL,
(u8 *)&font_sel, sizeof(u32));
if (ret)
goto error;
ret = lg4945_reg_read(dev, EXT_WATCH_FONT_OFFSET_ADDR,
(u8 *)&font_dump[font_data_offset], size);
if (ret)
goto error;
/* Font memory access disable */
wdata = 0;
ret = lg4945_reg_write(dev, EXT_WATCH_FONT_ACC_EN,
(u8 *)&wdata, sizeof(u32));
if (ret)
goto error;
TOUCH_I("%s done\n", __func__);
return ret;
error:
TOUCH_E("fail %d\n", ret);
return -EIO;
}
static int ext_watch_get_position(struct device *dev)
{
struct lg4945_data *d = to_lg4945_data(dev);
u8 *ptr = (u8 *)(&d->watch.ext_wdata.position);
struct ext_watch_status_cfg status_cfg;
int ret = 0;
TOUCH_I("start\n");
ret = lg4945_reg_read(dev, EXT_WATCH_POSITION_R, ptr,
sizeof(u32) * 3);
if (ret)
goto error;
TOUCH_I("Get Hour Position [%d][%d]\n",
d->watch.ext_wdata.position.h10x_pos,
d->watch.ext_wdata.position.h1x_pos);
TOUCH_I("Get Min Position [%d][%d]\n",
d->watch.ext_wdata.position.m10x_pos,
d->watch.ext_wdata.position.m1x_pos);
TOUCH_I("Get Colon Position [%d]\n",
d->watch.ext_wdata.position.clx_pos);
ret = lg4945_reg_read(dev, EXT_WATCH_SATATE, (u8 *)&status_cfg,
sizeof(u32));
if (ret)
goto error;
d->watch.ext_wdata.position.zero_disp = status_cfg.zero_en;
d->watch.ext_wdata.position.h24_en = status_cfg.en_24;
d->watch.ext_wdata.position.clock_disp_mode = status_cfg.disp_mode;
d->watch.ext_wdata.position.midnight_hour_zero_en
= status_cfg.midnight_hour_zero_en;
d->watch.ext_wdata.position.bhprd = status_cfg.bhprd;
TOUCH_I("Get Zero Display [%d]\n",
d->watch.ext_wdata.position.zero_disp);
TOUCH_I("Get 24H Mode [%d]\n",
d->watch.ext_wdata.position.h24_en);
TOUCH_I("Get Clock Mode [%d]\n",
d->watch.ext_wdata.position.clock_disp_mode);
TOUCH_I("Get Midnight Mode [%d]\n",
d->watch.ext_wdata.position.midnight_hour_zero_en);
TOUCH_I("Get Blink period [%d]\n", d->watch.ext_wdata.position.bhprd);
TOUCH_I("Get Current Watch[%d]\n", status_cfg.step);
TOUCH_I("Get Watch Enable[%d]\n", status_cfg.en);
if (d->watch.ext_wdata.position.clock_disp_mode)
TOUCH_I("Get Current Time[%02d][%02d]\n",
status_cfg.cur_min, status_cfg.cur_sec);
else
TOUCH_I("Get Current Time[%02d][%02d]\n",
status_cfg.cur_hour, status_cfg.cur_min);
return ret;
error:
TOUCH_E("Fail %d\n", ret);
return -EIO;
}
int watch_init(struct device *dev)
{
int ret = 0;
TOUCH_I("%s\n", __func__);
if (touch_mfts_mode_check(dev))
return -EBUSY;
ret = ext_watch_set_cfg(dev);
if (ret)
TOUCH_E("Fail %d\n", ret);
ret = ext_watch_onoff(dev);
if (ret)
TOUCH_E("Fail %d\n", ret);
return ret;
}
void ext_watch_font_download_func(
struct work_struct *font_download_work)
{
struct lg4945_data *d =
container_of(to_delayed_work(font_download_work),
struct lg4945_data, font_download_work);
struct touch_core_data *ts = to_touch_core(d->dev);
u32 wdata = 0;
int ret = 0;
if (d->lcd_mode != LCD_MODE_U3) {
TOUCH_E("skip font download, lcd mode[U%d]\n", d->lcd_mode);
ret = -EBUSY;
goto error;
}
TOUCH_I("%s start\n", __func__);
/* Font memory access enable */
wdata = 1;
ret = lg4945_reg_write(ts->dev, EXT_WATCH_FONT_ACC_EN,
(u8 *)&wdata, sizeof(u32));
if (ret)
goto error;
ret = lg4945_reg_write(ts->dev, EXT_WATCH_FONT_COMP_ADDR,
(u8 *)d->watch.ext_wdata.comp_buf,
COMP_FONTM_MAX_SIZE);
if (ret)
goto error;
wdata = 0;
ret = lg4945_reg_write(ts->dev, EXT_WATCH_FONT_ACC_EN,
(u8 *)&wdata, sizeof(u32));
if (ret)
goto error;
atomic_set(&d->watch.state.font_mem, DOWN_LOADED);
TOUCH_I("%s done\n", __func__);
return;
error:
TOUCH_E("Fail [%d]\n", ret);
}
int touch_bus_device_init(struct touch_hwif *hwif, void *driver)
{
if (hwif->bus_type == HWIF_I2C)
return touch_i2c_device_init(hwif, driver);
else if (hwif->bus_type == HWIF_SPI)
return touch_spi_device_init(hwif, driver);
TOUCH_E("Unknown touch interface : %d\n", hwif->bus_type);
return -ENODEV;
}
/* ext_watch_set_onoff
*
* 'power state' can has only 'ON' or 'OFF'. (not 'SLEEP' or 'WAKE')
*/
static int ext_watch_onoff(struct device *dev)
{
struct lg4945_data *d = to_lg4945_data(dev);
int ret = 0;
ret = lg4945_reg_write(dev, EXT_WATCH_RTC_CTRL,
&d->watch.ext_wdata.time.disp_waton, sizeof(u8));
if (ret)
goto error;
return ret;
error:
TOUCH_E("Fail %d\n", ret);
return -EIO;
}
static int ext_watch_set_current_time(struct device *dev)
{
struct lg4945_data *d = to_lg4945_data(dev);
u32 rtc_ctrl = EXT_WATCH_RTC_STOP;
u16 rtc_count = 305; /* for time, 1 /rtc_ecnt */
int ret = 0;
d->watch.ext_wdata.time.rtc_ecnt = 32764;
d->watch.ext_wdata.time.rtc_sctcnt =
(int)((d->watch.ext_wdata.time.rtc_sctcnt * rtc_count) / 10);
ret = lg4945_reg_write(dev, EXT_WATCH_RTC_RUN,
(u8 *)&rtc_ctrl, sizeof(u32));
if (ret)
goto error;
ret = lg4945_reg_write(dev, EXT_WATCH_RTC_SCT,
(u8 *)&d->watch.ext_wdata.time.rtc_sct, sizeof(u32));
if (ret)
goto error;
ret = lg4945_reg_write(dev, EXT_WATCH_RTC_SCTCNT,
(u8 *)&d->watch.ext_wdata.time.rtc_sctcnt, sizeof(u32));
if (ret)
goto error;
rtc_ctrl = d->watch.ext_wdata.time.rtc_ecnt & 0xFFFF;
ret = lg4945_reg_write(dev, EXT_WATCH_RTC_ECNT,
(u8 *)&rtc_ctrl, sizeof(u32));
if (ret)
goto error;
rtc_ctrl = EXT_WATCH_RTC_START;
ret = lg4945_reg_write(dev, EXT_WATCH_RTC_RUN,
(u8 *)&rtc_ctrl, sizeof(u32));
if (ret)
goto error;
TOUCH_I("%s : %02d:%02d:%02d CLK[%d Hz]\n", __func__,
d->watch.ext_wdata.time.rtc_sct.hour,
d->watch.ext_wdata.time.rtc_sct.min,
d->watch.ext_wdata.time.rtc_sct.sec,
d->watch.ext_wdata.time.rtc_ecnt);
return ret;
error:
TOUCH_E("Fail %d\n", ret);
return -EIO;
}
int touch_bus_xfer(struct device *dev, struct touch_xfer_msg *xfer)
{
struct touch_core_data *ts = to_touch_core(dev);
int ret = 0;
if (ts->bus_type == HWIF_I2C) {
TOUCH_E("Not implemented\n");
ret = -1;
} else if (ts->bus_type == HWIF_SPI) {
ret = touch_spi_xfer(to_spi_device(dev), xfer);
}
return ret;
}
static int ext_watch_set_mcs_ctrl(struct spi_device *spi, u8 enable)
{
u8 mcs_value = 0;
if (enable)
mcs_value = 0xAC;
else
mcs_value = 0xCA;
DO_SAFE(sic_spi_write(spi, EXT_WATCH_MCS_ACCESS, (u8 *)&mcs_value, sizeof(u8)), error);
//TOUCH_I("MCS Access onoff : %X \n", mcs_value);
return NO_ERROR;
error:
TOUCH_E("MCS Access Fail\n");
return ERROR;
}
static int ext_watch_set_mode(struct device *dev)
{
struct lg4945_data *d = to_lg4945_data(dev);
u8 *ptr = NULL;
u16 offset = EXT_WATCH_CTRL;
u32 size = sizeof(u32);
u32 pack[3] = {0, };
int ret = 0;
if (ret < 0)
return ret;
ptr = (u8 *)(&d->watch.ext_wdata.mode.watch_ctrl);
offset = EXT_WATCH_CTRL;
pack[0] = ptr[0];
pack[1] = ptr[1];
ret = lg4945_reg_write(dev, offset, &pack[0], size * 2);
ptr = (u8 *)(&d->watch.ext_wdata.mode.watch_area);
offset = EXT_WATCH_AREA;
pack[0] = ptr[0];
pack[1] = ptr[1];
pack[2] = ptr[2];
ret = lg4945_reg_write(dev, offset, &pack[0], size * 3);
ptr = (u8 *)(&d->watch.ext_wdata.mode.blink_area);
offset = EXT_WATCH_BLINK_AREA;
pack[0] = ptr[0];
pack[1] = ptr[1];
pack[2] = ptr[2];
ret = lg4945_reg_write(dev, offset, &pack[0], size * 3);
ptr = (u8 *)(&d->watch.ext_wdata.mode.grad);
offset = EXT_WATCH_GRAD;
ret = lg4945_reg_write(dev, offset, &ptr[0], size * 6);
offset = EXT_WATCH_LUT;
ptr = (u8 *)(&d->watch.ext_wdata.mode.lut[0]);
ret = lg4945_reg_write(dev, offset, &ptr[0],
size * 3 * EXT_WATCH_LUT_NUM);
if (ret < 0)
TOUCH_E("failed %d\n", ret);
return ret;
}
void touch_power_vio(struct device *dev, int value)
{
struct touch_core_data *ts = to_touch_core(dev);
int ret = 0;
if (gpio_is_valid(ts->vio_pin)) {
ret = gpio_direction_output(ts->vio_pin, value);
} else if (!IS_ERR_OR_NULL(ts->vio)) {
if (value)
ret = regulator_enable((struct regulator *)ts->vio);
else
ret = regulator_disable((struct regulator *)ts->vio);
}
if (ret)
TOUCH_E("ret = %d", ret);
}
/* ext_watch_shutdown
*
* 'power state' can has only 'SLEEP' or 'WAKE' (not 'ON' or 'OFF')
*/
static int ext_watch_shutdown(struct device *dev, u8 onoff)
{
u32 rtc_ctrl = EXT_WATCH_RTC_STOP;
int ret = 0;
if (onoff == EXT_WATCH_RTC_START)
rtc_ctrl = EXT_WATCH_RTC_START;
ret = lg4945_reg_write(dev, EXT_WATCH_RTC_RUN,
(u8 *)&rtc_ctrl, sizeof(u32));
if (ret)
goto error;
return ret;
error:
TOUCH_E("Fail %d\n", ret);
return -EIO;
}
static int ext_watch_set_position(struct device *dev)
{
struct lg4945_data *d = to_lg4945_data(dev);
u8 *ptr = (u8 *)(&d->watch.ext_wdata.position);
int ret = 0;
if (d->lcd_mode != LCD_MODE_U3) {
TOUCH_I("skip %s, lcd mode[U%d]\n", __func__, d->lcd_mode);
} else {
ret = lg4945_reg_write(dev, EXT_WATCH_POSITION,
ptr, sizeof(u32)*5);
if (ret)
goto error;
}
return ret;
error:
TOUCH_E("Fail %d\n", ret);
return -EIO;
}
static int ext_watch_get_current_time(struct device *dev)
{
struct lg4945_data *d = to_lg4945_data(dev);
int ret = 0;
TOUCH_TRACE();
ret = lg4945_reg_read(dev, EXT_WATCH_RTC_CTST,
(u8 *)&d->watch.ext_wdata.time.rtc_ctst, sizeof(u32));
if (ret < 0) {
TOUCH_E("%s Fail\n", __func__);
return ret;
}
TOUCH_I("%s : %02d:%02d:%02d\n", __func__,
d->watch.ext_wdata.time.rtc_ctst.hour,
d->watch.ext_wdata.time.rtc_ctst.min,
d->watch.ext_wdata.time.rtc_ctst.sec);
return ret;
}
static int ext_watch_set_cfg(struct device *dev)
{
struct lg4945_data *d = to_lg4945_data(dev);
int ret = 0;
TOUCH_TRACE();
d->watch.ext_wdata.mode.watch_ctrl.alpha = 1; /* bypass foreground */
ret = ext_watch_set_mode(dev);
if (ret)
goto error;
ret = ext_watch_set_position(dev);
if (ret)
goto error;
return ret;
error:
TOUCH_E("Fail %d\n", ret);
return -ECANCELED;
}
int watch_register_sysfs(struct device *dev)
{
struct touch_core_data *ts = to_touch_core(dev);
struct lg4945_data *d = to_lg4945_data(dev);
int ret;
TOUCH_TRACE();
ret = kobject_init_and_add(&d->kobj, &watch_kobj_type,
ts->input->dev.kobj.parent->parent,
"%s", LGE_EXT_WATCH_NAME);
ret = sysfs_create_group(&d->kobj, &watch_attribute_group);
if (ret < 0) {
TOUCH_E("failed to create sysfs\n");
return ret;
}
watch_fontdata_attr_init(d);
return ret;
}
static ssize_t store_extwatch_onoff(struct device *dev,
const char *buf, size_t count)
{
u8 value;
u8 zero = '0';
int ret = 0;
memcpy(&value, buf, sizeof(u8));
if (value == POWER_OFF || value == zero)
value = 0x00;
else
value = 0x01;
ret = ext_watch_shutdown(dev, value);
if (ret)
TOUCH_E("Fail %d\n", ret);
TOUCH_I("%s : %s\n", __func__,
value ? "START" : "STOP");
return count;
}
static int ext_watch_get_dic_st(struct device *dev)
{
u32 dic_status = 0;
u32 watch_status = 0;
int ret = 0;
TOUCH_TRACE();
ret = lg4945_reg_read(dev, SYS_DISPMODE_STATUS, (u8 *)&dic_status,
sizeof(u32));
if (ret)
goto error;
ret = lg4945_reg_read(dev, EXT_WATCH_RTC_CTRL, (u8 *)&watch_status,
sizeof(u32));
TOUCH_I("DIC_STATUS U%d , Watch %s\n",
(dic_status>>5)&0x3, watch_status ? "ON" : "OFF");
return ret;
error:
TOUCH_E("Fail %d\n", ret);
return -EIO;
}
int touch_spi_xfer(struct spi_device *spi, struct touch_xfer_msg *xfer)
{
struct touch_xfer_data_t *tx = NULL;
struct touch_xfer_data_t *rx = NULL;
struct spi_transfer x[MAX_XFER_COUNT];
struct spi_message m;
int i = 0;
if (xfer->msg_count > MAX_XFER_COUNT) {
TOUCH_E("cout exceed\n");
return -1;
}
spi_message_init(&m);
memset(x, 0, sizeof(x));
for (i = 0; i < xfer->msg_count; i++) {
tx = &xfer->data[i].tx;
rx = &xfer->data[i].rx;
x[i].cs_change = 1;
x[i].bits_per_word = xfer->bits_per_word;
if (rx->size) {
x[i].tx_buf = tx->data;
x[i].rx_buf = rx->data;
x[i].len = rx->size;
} else {
x[i].tx_buf = tx->data;
x[i].rx_buf = NULL;
x[i].len = tx->size;
}
spi_message_add_tail(&x[i], &m);
}
return spi_sync(spi, &m);
}
int touch_bus_init(struct device *dev, int buf_size)
{
struct touch_core_data *ts = to_touch_core(dev);
int ret = 0;
TOUCH_TRACE();
if (buf_size) {
ts->tx_buf = devm_kzalloc(dev, buf_size, GFP_KERNEL);
if (!ts->tx_buf)
TOUCH_E("fail to allocate tx_buf\n");
ts->rx_buf = devm_kzalloc(dev, buf_size, GFP_KERNEL);
if (!ts->rx_buf)
TOUCH_E("fail to allocate rx_buf\n");
}
ts->xfer = devm_kzalloc(dev, sizeof(struct touch_xfer_msg), GFP_KERNEL);
if (!ts->xfer)
TOUCH_E("fail to allocate xfer\n");
ts->pinctrl.ctrl = devm_pinctrl_get(dev);
if (IS_ERR_OR_NULL(ts->pinctrl.ctrl)) {
if (PTR_ERR(ts->pinctrl.ctrl) == -EPROBE_DEFER)
return -EPROBE_DEFER;
TOUCH_I("Target does not use pinctrl\n");
ts->pinctrl.ctrl = NULL;
} else {
ts->pinctrl.active = pinctrl_lookup_state(ts->pinctrl.ctrl,
"touch_pin_active");
if (IS_ERR_OR_NULL(ts->pinctrl.active))
TOUCH_E("cannot get pinctrl.active\n");
ts->pinctrl.suspend = pinctrl_lookup_state(ts->pinctrl.ctrl,
"touch_pin_sleep");
if (IS_ERR_OR_NULL(ts->pinctrl.suspend))
TOUCH_E("cannot get pinctrl.suspend\n");
if (!IS_ERR_OR_NULL(ts->pinctrl.active)) {
ret = pinctrl_select_state(ts->pinctrl.ctrl,
ts->pinctrl.active);
if (ret)
TOUCH_I("cannot set pinctrl.active\n");
else
TOUCH_I("pinctrl set active\n");
}
}
if (ts->bus_type == HWIF_SPI) {
ret = spi_setup(to_spi_device(dev));
if (ret < 0) {
TOUCH_E("Failed to perform SPI setup\n");
return -ENODEV;
}
}
return ret;
}
static int ext_watch_get_mode(struct device *dev)
{
struct lg4945_data *d = to_lg4945_data(dev);
u8 *ptr = NULL;
u16 offset = EXT_WATCH_CTRL;
u16 idx = 0;
u32 size = sizeof(u8);
int ret = 0;
TOUCH_I("start\n");
if (ret)
goto error;
ptr = (u8 *)(&d->watch.ext_wdata.mode.watch_ctrl);
offset = EXT_WATCH_CTRL;
ret = lg4945_reg_read(dev, offset++, &ptr[0], size);
ret = lg4945_reg_read(dev, offset++, &ptr[1], size);
TOUCH_I("Get Offet[%X] watch_ctrl %02X %02X\n",
EXT_WATCH_CTRL, ptr[0], ptr[1]);
ptr = (u8 *)(&d->watch.ext_wdata.mode.watch_area);
offset = EXT_WATCH_AREA;
ret = lg4945_reg_read(dev, offset++, &ptr[0], size);
ret = lg4945_reg_read(dev, offset++, &ptr[1], size);
ret = lg4945_reg_read(dev, offset++, &ptr[2], size);
TOUCH_I("Get Offet[%X] watch_area %02X %02X %02X\n",
EXT_WATCH_AREA, ptr[0], ptr[1], ptr[2]);
ptr = (u8 *)(&d->watch.ext_wdata.mode.blink_area);
offset = EXT_WATCH_BLINK_AREA;
ret = lg4945_reg_read(dev, offset++, &ptr[0], size);
ret = lg4945_reg_read(dev, offset++, &ptr[1], size);
ret = lg4945_reg_read(dev, offset++, &ptr[2], size);
TOUCH_I("Get Offet[%X] blink_area %02X %02X %02X\n",
EXT_WATCH_BLINK_AREA, ptr[0], ptr[1], ptr[2]);
ptr = (u8 *)(&d->watch.ext_wdata.mode.grad);
offset = EXT_WATCH_GRAD;
ret = lg4945_reg_read(dev, offset++, &ptr[0], size);
ret = lg4945_reg_read(dev, offset++, &ptr[1], size);
ret = lg4945_reg_read(dev, offset++, &ptr[2], size);
ret = lg4945_reg_read(dev, offset++, &ptr[3], size);
ret = lg4945_reg_read(dev, offset++, &ptr[4], size);
ret = lg4945_reg_read(dev, offset++, &ptr[5], size);
TOUCH_I("Get Offet[%X] grad %02X %02X %02X %02X %02X %02X\n",
EXT_WATCH_GRAD, ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);
offset = EXT_WATCH_LUT;
for (idx = 0; idx < EXT_WATCH_LUT_NUM; idx++) {
ptr = (u8 *)(&d->watch.ext_wdata.mode.lut[idx]);
ret = lg4945_reg_read(dev, offset++, &ptr[0], size);
ret = lg4945_reg_read(dev, offset++, &ptr[1], size);
ret = lg4945_reg_read(dev, offset++, &ptr[2], size);
TOUCH_I("Get Offet[%X] LUT[%d] : B[%02X] G[%02X] R[%02X]\n",
offset - 3, idx, ptr[0], ptr[1], ptr[2]);
}
if (ret)
goto error;
TOUCH_I("end\n");
return ret;
error:
TOUCH_E("failed %d\n", ret);
return -EIO;
}
int _write_log(char *filename, char *data)
{
struct file *file;
loff_t pos = 0;
int flags;
char *fname = "/mnt/sdcard/touch_self_test.txt";
char *fname_mfts_folder = "/mnt/sdcard/touch_self_test_mfts_folder.txt";
char *fname_mfts_flat = "/mnt/sdcard/touch_self_test_mfts_flat.txt";
char *fname_mfts_curved = "/mnt/sdcard/touch_self_test_mfts_curved.txt";
int cap_file_exist = 0;
if (f54_window_crack || f54_window_crack_check_mode == 0) {
mm_segment_t old_fs = get_fs();
set_fs(KERNEL_DS);
flags = O_WRONLY | O_CREAT;
if (filename == NULL) {
flags |= O_APPEND;
switch (mfts_mode) {
case 0:
filename = fname;
break;
case 1:
filename = fname_mfts_folder;
break;
case 2:
filename = fname_mfts_flat;
break;
case 3:
filename = fname_mfts_curved;
break;
default:
TOUCH_I("%s : not support mfts_mode\n",
__func__);
break;
}
} else {
cap_file_exist = 1;
}
if (filename) {
file = filp_open(filename, flags, 0666);
} else {
TOUCH_E("%s : filename is NULL, can not open FILE\n",
__func__);
return -1;
}
if (IS_ERR(file)) {
TOUCH_I("%s : ERR(%ld) Open file error [%s]\n",
__func__, PTR_ERR(file), filename);
set_fs(old_fs);
return PTR_ERR(file);
}
vfs_write(file, data, strlen(data), &pos);
filp_close(file, 0);
set_fs(old_fs);
}
return cap_file_exist;
}
void _write_time_log(char *filename, char *data, int data_include)
{
struct file *file;
loff_t pos = 0;
char *fname = NULL;
char time_string[64] = {0};
struct timespec my_time;
struct tm my_date;
mm_segment_t old_fs = get_fs();
my_time = __current_kernel_time();
time_to_tm(my_time.tv_sec, sys_tz.tz_minuteswest * 60 * (-1), &my_date);
snprintf(time_string,
sizeof(time_string),
"%02d-%02d %02d:%02d:%02d.%03lu\n\n",
my_date.tm_mon + 1,
my_date.tm_mday,
my_date.tm_hour,
my_date.tm_min,
my_date.tm_sec,
(unsigned long) my_time.tv_nsec / 1000000);
set_fs(KERNEL_DS);
if (filename == NULL) {
switch (mfts_mode) {
case 0:
fname = "/mnt/sdcard/touch_self_test.txt";
break;
case 1:
fname = "/mnt/sdcard/touch_self_test_mfts_folder.txt";
break;
case 2:
fname = "/mnt/sdcard/touch_self_test_mfts_flat.txt";
break;
case 3:
fname = "/mnt/sdcard/touch_self_test_mfts_curved.txt";
break;
default:
TOUCH_I("%s : not support mfts_mode\n", __func__);
break;
}
} else {
fname = filename;
}
if (fname) {
file = filp_open(fname,
O_WRONLY|O_CREAT|O_APPEND, 0666);
} else {
TOUCH_E("%s : fname is NULL, can not open FILE\n", __func__);
return;
}
if (IS_ERR(file)) {
TOUCH_I("%s : Open file error [%s], err = %ld\n",
__func__, fname, PTR_ERR(file));
set_fs(old_fs);
return;
}
vfs_write(file, time_string, strlen(time_string), &pos);
filp_close(file, 0);
set_fs(old_fs);
}
static int ext_watch_font_dump(struct device *dev, char *font_dump)
{
struct touch_core_data *ts = to_touch_core(dev);
u32 font_sel = 0;
u32 font_data_offset = 0;
u32 wdata = 0;
u32 size = 0;
int ret = 0;
if (!ts->xfer) {
TOUCH_I("%s alloc failed\n", __func__);
return -EIO;
}
TOUCH_I("%s start\n", __func__);
ts->xfer->bits_per_word = 8;
ts->xfer->msg_count = 2;
/* Font memory access enable */
wdata = 1;
ret = lg4945_reg_write(dev, EXT_WATCH_FONT_ACC_EN,
(u8 *)&wdata, sizeof(u32));
if (ret)
goto error;
size = sizeof(u32) * EXT_WATCH_FONT_NUM_SIZE;
for (font_sel = 0; font_sel < 10; font_sel++) {
/* Font select : '0' ~ '9' */
font_data_offset = font_sel * size;
ts->xfer->data[0].tx.addr = EXT_WATCH_FONT_SEL;
ts->xfer->data[0].tx.buf = (u8 *)&font_sel;
ts->xfer->data[0].tx.size = sizeof(u32);
ts->xfer->data[1].rx.addr = EXT_WATCH_FONT_OFFSET_ADDR;
ts->xfer->data[1].rx.buf = font_dump + font_data_offset;
ts->xfer->data[1].rx.size = size;
lg4945_xfer_msg(dev, ts->xfer);
}
/* Font select : ':' */
font_data_offset = font_sel * size;
size = sizeof(u32) * EXT_WATCH_FONT_CHAR_SIZE;
ts->xfer->data[0].tx.addr = EXT_WATCH_FONT_SEL;
ts->xfer->data[0].tx.buf = (u8 *)&font_sel;
ts->xfer->data[0].tx.size = sizeof(u32);
ts->xfer->data[1].rx.addr = EXT_WATCH_FONT_OFFSET_ADDR;
ts->xfer->data[1].rx.buf = font_dump + font_data_offset;
ts->xfer->data[1].rx.size = size;
lg4945_xfer_msg(dev, ts->xfer);
/* Font memory access disable */
wdata = 0;
ret = lg4945_reg_write(dev, EXT_WATCH_FONT_ACC_EN,
(u8 *)&wdata, sizeof(u32));
if (ret)
goto error;
TOUCH_I("%s done\n", __func__);
return ret;
error:
TOUCH_E("fail %d\n", ret);
return -EIO;
}
