static void xen_net_read_rate(struct xenbus_device *dev,
unsigned long *bytes, unsigned long *usec)
{
char *s, *e;
unsigned long b, u;
char *ratestr;
/* Default to unlimited bandwidth. */
*bytes = ~0UL;
*usec = 0;
ratestr = xenbus_read(XBT_NIL, dev->nodename, "rate", NULL);
if (IS_ERR(ratestr))
return;
s = ratestr;
b = simple_strtoul(s, &e, 10);
if ((s == e) || (*e != ','))
goto fail;
s = e + 1;
u = simple_strtoul(s, &e, 10);
if ((s == e) || (*e != '\0'))
goto fail;
*bytes = b;
*usec = u;
kfree(ratestr);
return;
fail:
WPRINTK("Failed to parse network rate limit. Traffic unlimited.\n");
kfree(ratestr);
}
static int mma7660_early_suspend(struct early_suspend *h)
{
struct i2c_client *client = container_of(mma7660_device.parent, struct i2c_client, dev);
WPRINTK("Gsensor mma7760 enter early suspend\n");
struct mma7660_data *mma7660 = i2c_get_clientdata(client);
hrtimer_cancel(&mma7660->timer);
return mma7660_close_dev(client);
}
static int mma7660_suspend(struct i2c_client *client, pm_message_t mesg)
{
WPRINTK("Gsensor mma7760 enter 2 level suspend\n");
struct mma7660_data *mma7660 = i2c_get_clientdata(client);
hrtimer_cancel(&mma7660->timer);
return mma7660_close_dev(client);
}
static int mma7660_resume(struct i2c_client *client)
{
int ret = 0;
struct mma7660_data *mma7660 = (struct mma7660_data *)i2c_get_clientdata(client);
WPRINTK("Gsensor mma7760 2 level resume!!\n");
ret = mma7660_start_dev(client, mma7660->curr_tate);
hrtimer_start(&mma7660->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
return ret;
}
static void mma7660_late_resume(struct early_suspend *h)
{
int ret = 0;
struct i2c_client *client = container_of(mma7660_device.parent, struct i2c_client, dev);
struct mma7660_data *mma7660 = (struct mma7660_data *)i2c_get_clientdata(client);
WPRINTK("Gsensor mma7760 resume!!\n");
ret = mma7660_start_dev(client, mma7660->curr_tate);
hrtimer_start(&mma7660->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
return ret ;
}
static void mma7660_work_func(struct work_struct *work)
{
struct mma7660_data *mma7660 = container_of(work, struct mma7660_data, work);
struct i2c_client *client = mma7660->client;
if (mma7660_get_data(client) < 0)
WPRINTK(KERN_ERR "MMA7660 mma_work_func: Get data failed\n");
//enable_irq(client->irq);
}
static int rk29_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct snd_soc_dai *codec_dai = rtd->codec_dai;
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
unsigned int pll_out = 0;
int ret;
WPRINTK("Enter::%s----%d\n",__FUNCTION__,__LINE__);
/*by Vincent Hsiung for EQ Vol Change*/
#define HW_PARAMS_FLAG_EQVOL_ON 0x21
#define HW_PARAMS_FLAG_EQVOL_OFF 0x22
if ((params->flags == HW_PARAMS_FLAG_EQVOL_ON)||(params->flags == HW_PARAMS_FLAG_EQVOL_OFF)) {
ret = codec_dai->driver->ops->hw_params(substream, params, codec_dai);
WPRINTK("Enter::%s----%d\n",__FUNCTION__,__LINE__);
} else {
/* set codec DAI configuration */
#if defined (CONFIG_SND_RK29_CODEC_SOC_SLAVE)
ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
#endif
#if defined (CONFIG_SND_RK29_CODEC_SOC_MASTER)
ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM );
#endif
if (ret < 0)
return ret;
/* set cpu DAI configuration */
#if defined (CONFIG_SND_RK29_CODEC_SOC_SLAVE)
ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
#endif
#if defined (CONFIG_SND_RK29_CODEC_SOC_MASTER)
ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
#endif
if (ret < 0)
return ret;
}
return 0;
}
static int __init balloon_init(void)
{
#if defined(CONFIG_X86) && defined(CONFIG_XEN)
unsigned long pfn;
struct page *page;
#endif
if (!is_running_on_xen())
return -ENODEV;
IPRINTK("Initialising balloon driver.\n");
#ifdef CONFIG_XEN
current_pages = min(xen_start_info->nr_pages, max_pfn);
totalram_pages = current_pages;
#else
current_pages = totalram_pages;
#endif
target_pages = current_pages;
balloon_low = 0;
balloon_high = 0;
driver_pages = 0UL;
hard_limit = ~0UL;
init_timer(&balloon_timer);
balloon_timer.data = 0;
balloon_timer.function = balloon_alarm;
/* don't include on bare-metal & FV guest */
#if defined(CONFIG_PROC_FS) && defined(CONFIG_XEN)
if ((balloon_pde = create_xen_proc_entry("balloon", 0644)) == NULL) {
WPRINTK("Unable to create /proc/xen/balloon.\n");
return -1;
}
balloon_pde->read_proc = balloon_read;
balloon_pde->write_proc = balloon_write;
#endif
#if defined(CONFIG_X86) && defined(CONFIG_XEN)
/* Initialise the balloon with excess memory space. */
for (pfn = xen_start_info->nr_pages; pfn < max_pfn; pfn++) {
page = pfn_to_page(pfn);
balloon_append(page);
}
#endif
target_watch.callback = watch_target;
xenstore_notifier.notifier_call = balloon_init_watcher;
register_xenstore_notifier(&xenstore_notifier);
return 0;
}
static int __init audio_card_init(void)
{
int ret =0;
WPRINTK("Enter::%s----%d\n",__FUNCTION__,__LINE__);
rk29_snd_device = platform_device_alloc("soc-audio", -1);
if (!rk29_snd_device) {
printk("platform device allocation failed\n");
ret = -ENOMEM;
return ret;
}
platform_set_drvdata(rk29_snd_device, &snd_soc_card_rk29);
ret = platform_device_add(rk29_snd_device);
if (ret) {
printk("platform device add failed\n");
platform_device_put(rk29_snd_device);
return ret;
}
return ret;
}
static void mma7660_report_value(struct i2c_client *client, struct mma7660_axis *axis)
{
struct mma7660_data *mma7660 = i2c_get_clientdata(client);
//struct mma7660_axis *axis = (struct mma7660_axis *)rbuf;
#ifdef MMA7660_DATA_FILTER
int i = 0, axis_x=0, axis_y=0, axis_z=0;
#endif
#ifdef MMA7660_DATA_FILTER
for(i = 0; i < MMA7660_TEMP_SIZE; i++){
if((MMA7660_TEMP_SIZE-1) == i){
mma7660_adjust.axis_x[i] = axis->x;
mma7660_adjust.axis_y[i] = axis->y;
mma7660_adjust.axis_z[i] = axis->z;
}else{
mma7660_adjust.axis_x[i] = mma7660_adjust.axis_x[i+1];
mma7660_adjust.axis_y[i] = mma7660_adjust.axis_y[i+1];
mma7660_adjust.axis_z[i] = mma7660_adjust.axis_z[i+1];
}
}
for(i = 0; i < MMA7660_TEMP_SIZE; i++){
axis_x += mma7660_adjust.axis_x[i];
axis_y += mma7660_adjust.axis_y[i];
axis_z += mma7660_adjust.axis_z[i];
}
if(++mma7660_adjust.count > MMA7660_TEMP_SIZE){
axis->x = axis_x/MMA7660_TEMP_SIZE;
axis->y = axis_y/MMA7660_TEMP_SIZE;
axis->z = axis_z/MMA7660_TEMP_SIZE;
}
#endif
/* Report acceleration sensor information */
input_report_abs(mma7660->input_dev, ABS_X, axis->x);
input_report_abs(mma7660->input_dev, ABS_Y, axis->y);
input_report_abs(mma7660->input_dev, ABS_Z, axis->z);
input_sync(mma7660->input_dev);
WPRINTK("%s,x=%d,y=%d,z=%d\n",__func__,axis->x,axis->y,axis->z);
}
static int mma7660_init_client(struct i2c_client *client)
{
struct mma7660_data *mma7660;
int ret;
mma7660 = i2c_get_clientdata(client);
WPRINTK("gpio_to_irq(%d) is %d\n",client->irq,gpio_to_irq(client->irq));
if ( !gpio_is_valid(client->irq)) {
WPRINTK("+++++++++++gpio_is_invalid\n");
return -EINVAL;
}
ret = gpio_request(client->irq, "mma7660_int");
if (ret) {
WPRINTK( "failed to request mma7990_trig GPIO%d\n",gpio_to_irq(client->irq));
return ret;
}
ret = gpio_direction_input(client->irq);
if (ret) {
WPRINTK("failed to set mma7990_trig GPIO gpio input\n");
return ret;
}
gpio_pull_updown(client->irq, GPIOPullUp);
client->irq = gpio_to_irq(client->irq);
ret = request_irq(client->irq, mma7660_interrupt, IRQF_TRIGGER_LOW, client->dev.driver->name, mma7660);
WPRINTK("request irq is %d,ret is 0x%x\n",client->irq,ret);
if (ret ) {
WPRINTK(KERN_ERR "mma7660_init_client: request irq failed,ret is %d\n",ret);
return ret;
}
disable_irq(client->irq);
init_waitqueue_head(&data_ready_wq);
return 0;
}
int __init wisky_boot_charge_main(void)
{
#if 0 //for test ...Lee
printk("here... ...wulala... wisky_boot_charge_main\n");
wisky_charger_logo_display(LOGO_BLANK);
wisky_charger_logo_display(LOGO_BOOTUP);
return 0;
#endif
int charge_full_cnt = 0;
int full_display_times = 1;//充电满后提示次数
boot_charge_mode = 0;
if(1 == usb_otg_op_state){
//do not enter charge mode when USB OTG insert
return 0;
}
WPRINTK("--------dc_adaptor_status=%d\n", dc_adaptor_status);
//WPRINTK("--------battery_adc_value=%d\n", battery_adc_value);
pr_info("--------battery_capacity=%d\n", battery_capacity);
if(dc_adaptor_status == 0){
//no DC adaptor insert, do not display charge
//#if defined(WISKY_BATTERY_OZ8806)
//电量低于阀值时显示低电logo
if(battery_capacity < BATT_LEVEL_POOR){
//#else
//电量低于阀值时显示低电logo
//if((battery_adc_value < BAT_DISCHARGE_ADC_MIN) || (battery_adc_value -BATTERY_ADC_ADJUST < BAT_DISCHARGE_ADC_MIN)){
//#endif
//clear lcd before show charge logo
wisky_charger_logo_display(LOGO_BLANK);
msleep(100);
wisky_boot_charge_bl(1);
wisky_charger_logo_display(LOGO_POOR);
mdelay(1000);
wisky_boot_charge_bl(0);
mdelay(500);
pr_info("%s:low battery, shut down...\n", __FUNCTION__);
wisky_boot_charge_poweroff();
while(1);
}else{
wisky_charger_logo_display(LOGO_BLANK);
msleep(100);
//wisky_boot_charge_bl(1);
wisky_charger_logo_display(LOGO_BOOTUP);
return 0;
}
}
pr_info("------>Charge mode enter\n");
//clear lcd before show charge logo
wisky_charger_logo_display(LOGO_BLANK);
printk("wisky_charger_logo_display(LOGO_BLANK);\n");
msleep(100);//延时防止闪白屏
wisky_boot_charge_bl(1);
while(1){
if(battery_capacity == BATT_LEVEL_FULL){
dc_adaptor_check_and_poweroff();
wisky_charger_logo_display(LOGO_BLANK);
if(wisky_boot_charge_show_full_logo() == 1){
goto exit;
}
}else{
dc_adaptor_check_and_poweroff();
wisky_charger_logo_display(LOGO_BLANK);
if(wisky_boot_charge_show_logos(3, battery_capacity) == 1){
goto exit;
}
}
#if defined (CONFIG_AXP_PEKINFO)
if(axp_pwr_pressshort){
axp_pwr_pressshort = 0;
}
#endif
dc_adaptor_check_and_poweroff();
wisky_boot_charge_suspend();
while(1){
if(battery_capacity == BATT_LEVEL_FULL && full_display_times > 0){
if(charge_full_cnt++ > 10/*FULL_SHOW_LOGO_TIME*/){
charge_full_cnt = 0;
full_display_times--;
break;
}
}
dc_adaptor_check_and_poweroff();
if(power_key_check()){
break;
}
dc_adaptor_check_and_poweroff();
mdelay(10);
}
dc_adaptor_check_and_poweroff();
wisky_boot_charge_resume();
}
exit:
pr_info("------>Charge mode exit\n");
rk30_mux_api_set(LCD_BL_PWM_MUX_NAME, LCD_BL_PWM_MUX_MODE);
//lcd backlight off here, will be backlight on in backlihgt driver init
if(LCD_BL_EN_PIN != INVALID_GPIO){
gpio_set_value(LCD_BL_EN_PIN, !LCD_BL_EN_VALUE);
}
//
boot_charge_mode = 1;
wisky_charger_logo_display(LOGO_BLANK);
wisky_charger_logo_display(LOGO_BOOTUP);
gpio_request(KEY_SHUTDOWN_PIN, "poweronpin");
gpio_direction_output(KEY_SHUTDOWN_PIN, GPIO_HIGH);
gpio_set_value(KEY_SHUTDOWN_PIN, GPIO_HIGH);
return 0;
}
int init(void)
{
WPRINTK("------------>%s-%d\n", __FUNCTION__, __LINE__);
return 0;
}
static int mma7660_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct mma7660_data *mma7660;
int err;
mma7660 = kzalloc(sizeof(struct mma7660_data), GFP_KERNEL);
if (!mma7660) {
WPRINTK("[mma7660]:alloc data failed.\n");
err = -ENOMEM;
goto exit_alloc_data_failed;
}
mma7660->mma7660_wq = create_singlethread_workqueue("mma7660_wq");
if (!mma7660->mma7660_wq )
{
err = -ENOMEM;
goto err_create_workqueue_failed;
}
INIT_WORK(&mma7660->work, mma7660_work_func);
// INIT_DELAYED_WORK(&mma7660->delaywork, mma7660_delaywork_func);
mma7660->client = client;
i2c_set_clientdata(client, mma7660);
this_client = client;
/*
err = mma7660_init_client(client);
if (err < 0) {
WPRINTK(KERN_ERR
"mma7660_probe: mma7660_init_client failed\n");
goto exit_request_gpio_irq_failed;
}
*/
mma7660->input_dev = input_allocate_device();
if (!mma7660->input_dev) {
err = -ENOMEM;
WPRINTK(KERN_ERR
"mma7660_probe: Failed to allocate input device\n");
goto exit_input_allocate_device_failed;
}
set_bit(EV_ABS, mma7660->input_dev->evbit);
/* x-axis acceleration */
input_set_abs_params(mma7660->input_dev, ABS_X, -MMA7660_RANGE, MMA7660_RANGE, 0, 0);
/* y-axis acceleration */
input_set_abs_params(mma7660->input_dev, ABS_Y, -MMA7660_RANGE, MMA7660_RANGE, 0, 0);
/* z-axis acceleration */
input_set_abs_params(mma7660->input_dev, ABS_Z, -MMA7660_RANGE, MMA7660_RANGE, 0, 0);
mma7660->input_dev->name = "gsensor";
mma7660->input_dev->dev.parent = &client->dev;
err = input_register_device(mma7660->input_dev);
if (err < 0) {
WPRINTK(KERN_ERR
"mma7660_probe: Unable to register input device: %s\n",
mma7660->input_dev->name);
goto exit_input_register_device_failed;
}
mma7660_device.parent = &client->dev;
err = misc_register(&mma7660_device);
if (err < 0) {
pr_err("mma7660_probe: misc device register failed\n");
goto exit_misc_device_register_mma7660_device_failed;
}
err = gsensor_sysfs_init();
if (err < 0) {
pr_err("mma7660_probe: gsensor sysfs init failed\n");
goto exit_gsensor_sysfs_init_failed;
}
hrtimer_init(&mma7660->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
mma7660->timer.function = mma7660_timer_func;
hrtimer_start(&mma7660->timer, ktime_set(10, 0), HRTIMER_MODE_REL);
#ifdef CONFIG_HAS_EARLYSUSPEND
mma7660->early_suspend.level = 50 + 1;
mma7660->early_suspend.suspend = mma7660_early_suspend;
mma7660->early_suspend.resume = mma7660_late_resume;
register_early_suspend(&mma7660->early_suspend);
#endif
pr_info("mma7660 probe ok\n");
mma7660->status = -1;
#if 0
mma7660_start(client, MMA7660_RATE_32);
#endif
return 0;
exit_gsensor_sysfs_init_failed:
misc_deregister(&mma7660_device);
exit_misc_device_register_mma7660_device_failed:
input_unregister_device(mma7660->input_dev);
exit_input_register_device_failed:
input_free_device(mma7660->input_dev);
exit_input_allocate_device_failed:
destroy_workqueue(mma7660->mma7660_wq);
//free_irq(client->irq, mma7660);
//exit_request_gpio_irq_failed:
// kfree(mma7660);
err_create_workqueue_failed:
kfree(mma7660);
exit_alloc_data_failed:
pr_info("mma7660 probe failed!\n");
return err;
}
static long mma7660_ioctl( struct file *file, unsigned int cmd,unsigned long arg)
{
void __user *argp = (void __user *)arg;
// char msg[RBUFF_SIZE + 1];
int ret = -1;
char rate;
struct i2c_client *client = container_of(mma7660_device.parent, struct i2c_client, dev);
WPRINTK("%s-%d: cmd = %d\n", __FUNCTION__, __LINE__, cmd);
switch (cmd) {
case MMA_IOCTL_APP_SET_RATE:
if (copy_from_user(&rate, argp, sizeof(rate)))
return -EFAULT;
break;
default:
break;
}
switch (cmd) {
case MMA_IOCTL_START:
WPRINTK("%s-%d: start\n", __FUNCTION__, __LINE__);
ret = mma7660_start(client, MMA7660_RATE_32);
if (ret < 0)
return ret;
break;
case MMA_IOCTL_CLOSE:
WPRINTK("%s-%d: close\n", __FUNCTION__, __LINE__);
ret = mma7660_close(client);
if (ret < 0)
return ret;
break;
case MMA_IOCTL_APP_SET_RATE:
WPRINTK("%s-%d: set rate = %d\n", __FUNCTION__, __LINE__, rate);
ret = mma7660_reset_rate(client, rate);
if (ret < 0)
return ret;
break;
/*
case MMA_IOCTL_GETDATA:
ret = mma7660_trans_buff(msg, RBUFF_SIZE);
if (ret < 0)
return ret;
break;
*/
default:
return -ENOTTY;
}
/*
switch (cmd) {
case MMA_IOCTL_GETDATA:
WPRINTK("%s-%d: get data\n", __FUNCTION__, __LINE__);
if (copy_to_user(argp, &msg, sizeof(msg)))
return -EFAULT;
break;
default:
break;
}*/
return 0;
}
static int mma7660_get_data(struct i2c_client *client)
{
char buffer[3];
int ret;
struct mma7660_axis axis;
// struct mma7660_platform_data *pdata = client->dev.platform_data;
do {
memset(buffer, 0, 3);
buffer[0] = MMA7660_REG_X_OUT;
ret = mma7660_rx_data(client, &buffer[0], 3);
if (ret < 0)
return ret;
} while ((buffer[0] & 0x40) || (buffer[1] & 0x40) || (buffer[2] & 0x40));
WPRINTK("raw x=%d,y=%d,z=%d\n",buffer[0],buffer[1],buffer[2]);
#if defined(WISKY_GSENSOR_NX_PY_PZ)
axis.x = -mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.y = mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.z = mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#elif defined(WISKY_GSENSOR_NX_PZ_PY)
axis.x = mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.y = -mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
axis.z = mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
#elif defined(WISKY_GSENSOR_NX_PY_NZ)
axis.x = -mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.y = mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.z = -mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#elif defined(WISKY_GSENSOR_PX_PY_PZ)
axis.x = mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.y = mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.z = mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#elif defined(WISKY_GSENSOR_NX_NY_PZ)
axis.x = -mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.y = -mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.z = mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#elif defined(WISKY_GSENSOR_NX_NY_NZ)
axis.x = -mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.y = -mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.z = -mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#elif defined(WISKY_GSENSOR_NY_NX_NZ)
axis.x = -mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.y = -mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.z = -mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#elif defined(WISKY_GSENSOR_PY_PX_NZ)
axis.x = mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.y = mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.z = -mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#elif defined(WISKY_GSENSOR_PY_PX_PZ)
axis.x = mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.y = mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.z = mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#elif defined(WISKY_GSENSOR_NY_NX_PZ)
axis.x = -mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.y = -mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.z = mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#elif defined(WISKY_GSENSOR_PX_NY_PZ)
axis.x = mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.y = -mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.z = mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#elif defined(WISKY_GSENSOR_PY_NX_PZ)
axis.x = mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.y = -mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.z = mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#elif defined(WISKY_GSENSOR_PX_NY_NZ)
axis.x = mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.y = -mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.z = -mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#else
axis.x = mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
axis.y = mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.z = mma7660_convert_to_int(buffer[MMA7660_REG_Z_OUT]);
#endif
#ifdef MMA7660_DATA_FILTER
axis.x += GSENSOR_ADJUST_X;
axis.y += GSENSOR_ADJUST_Y;
axis.z += GSENSOR_ADJUST_Z;
#endif
WPRINTK("x=%d,y=%d,z=%d\n",axis.x,axis.y,axis.z);
mma7660_report_value(client, &axis);
return 0;
}
/***********************************************************************
[function]:
callback: gather the finger information and calculate the X,Y
coordinate then report them to the input system;
[parameters]:
null;
[return]:
null;
************************************************************************/
static int fts_read_data(void)
{
struct FTS_TS_DATA_T *data = i2c_get_clientdata(this_client);
u8 buf[6*CFG_MAX_POINT_NUM+2] = {0};
int id, i_count, cur_touch_release, i, ret = -1;
int touch_point_num = 0, touch_event, x, y, swap_x, swap_y;
int report_id_index[CFG_MAX_POINT_NUM] = {false};
buf[0] = 2;//ADDR
ret = fts_i2c_rxdata(buf, 1);
if (ret > 0)
touch_point_num = buf[0]&0xf;
else
printk(KERN_ERR "get fingers failed!\n");
//printk("touch_point_num=%d\n", touch_point_num);
if(touch_point_num > CFG_MAX_POINT_NUM) {
//printk("Touch number [%d] readed is larger than max point number\n", touch_point_num);
touch_point_num = 0;
}
i_count = 0;
cur_touch_release = 0;
if(touch_point_num != 0) {
buf[0] = 3;//ADDR
ret=fts_i2c_rxdata(buf, 6*touch_point_num);
if(ret >= 0) {
do {
id = buf[2+i_count*6]>>4;
if(id <0 || id>CFG_MAX_POINT_NUM) {
printk("[ERROR] Touch ID readed is illegal!!\n");
}
_st_finger_infos[i_count].id = id;
touch_event = buf[i_count*6]>>6;
swap_x =((buf[i_count*6]& 0x0f)<<8) |buf[i_count*6+1];
swap_y =( (buf[i_count*6+2]& 0x0f)<<8) | buf[i_count*6+3];
WPRINTK("touch id[%d], raw point(%d, %d), touch_event=%d\n", id, swap_x, swap_y, touch_event);
#if defined(TS_SWAP_PX_PY)
x = swap_x;
y = swap_y;
#elif defined(TS_SWAP_PY_PX)
x = swap_y;
y = swap_x;
#elif defined(TS_SWAP_PX_NY)
x = swap_x;
y = WISKY_TOUCH_HEIGHT-swap_y;
#elif defined(TS_SWAP_NX_PY)
x = WISKY_TOUCH_WIDTH-swap_x;
y = swap_y;
#elif defined(TS_SWAP_NX_NY)
x = WISKY_TOUCH_WIDTH-swap_x;
y = WISKY_TOUCH_HEIGHT-swap_y;
#else
x = swap_x;
y = swap_y;
#endif
//printk("touch id[%d], swap point(%d, %d)\n", id, x, y);
if (touch_event == 0) //down
{
_st_finger_infos[i_count].u2_pressure= 1;//pressure;
_st_finger_infos[i_count].i2_x= (int16_t)x;
_st_finger_infos[i_count].i2_y= (int16_t)y;
}
else if (touch_event == 1) //up event
{
//report up key
input_mt_slot(data->input_dev, id);
input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, false);
_st_finger_infos[i_count].u2_pressure= 0;
_st_finger_infos[i_count].id = -1;
cur_touch_release++;
}
else if (touch_event == 2) //move
{
_st_finger_infos[i_count].u2_pressure= 1;//pressure;
_st_finger_infos[i_count].i2_x= (int16_t)x;
_st_finger_infos[i_count].i2_y= (int16_t)y;
}
else /*bad event, ignore*/
{
printk("Bad event, ignore!!!\n");
i_count++;
continue;
}
i_count++;
} while(i_count < touch_point_num);
if(0 == cur_touch_release) {
for(i = touch_point_num; i < CFG_MAX_POINT_NUM; i++) {
_st_finger_infos[i].id = -1;
_st_finger_infos[i].u2_pressure = 0;
_st_finger_infos[i].i2_x = 0;
_st_finger_infos[i].i2_y = 0;
}
}
for(i = 0; i < CFG_MAX_POINT_NUM; i++) {
//report all down key
if(_st_finger_infos[i].id >= 0 && _st_finger_infos[i].u2_pressure > 0) {
WPRINTK("--->DOWN: id(%d)\n", _st_finger_infos[i].id);
report_id_index[_st_finger_infos[i].id] = true;
input_mt_slot(data->input_dev, _st_finger_infos[i].id);
input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, true);
input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, 1);
#if defined(WISKY_BOARD_U7PLUS_TV10)
input_report_abs(data->input_dev, ABS_MT_POSITION_X, 1280- (_st_finger_infos[i].i2_x));
input_report_abs(data->input_dev, ABS_MT_POSITION_Y, 800 - (_st_finger_infos[i].i2_y));
#else
input_report_abs(data->input_dev, ABS_MT_POSITION_X, _st_finger_infos[i].i2_x);
input_report_abs(data->input_dev, ABS_MT_POSITION_Y, _st_finger_infos[i].i2_y);
#endif
}
}
for(i = 0; i < CFG_MAX_POINT_NUM; i++) {
if(false == report_id_index[i]) {
WPRINTK("--->UP: id(%d)\n", i);
//report all up key
input_mt_slot(data->input_dev, i);
input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, false);
}
}
input_sync(data->input_dev);
cur_touch_release = 0;
/*for(i = 0; i < CFG_MAX_POINT_NUM; i++){
WPRINTK("ID:%d (%d, %d), Presure[%d]", _st_finger_infos[i].id, _st_finger_infos[i].i2_x, _st_finger_infos[i].i2_y, _st_finger_infos[i].u2_pressure);
}*/
} else {
