void rtw_register_early_suspend(struct pwrctrl_priv *pwrpriv) { DBG_871X("%s\n", __FUNCTION__); //jeff: set the early suspend level before blank screen, so we wll do late resume after scree is lit pwrpriv->early_suspend.level = ANDROID_EARLY_SUSPEND_LEVEL_BLANK_SCREEN - 20; pwrpriv->early_suspend.suspend = rtw_early_suspend; pwrpriv->early_suspend.resume = rtw_late_resume; android_register_early_suspend(&pwrpriv->early_suspend); }
static int ft5406_probe(struct i2c_client *client ,const struct i2c_device_id *id) { struct ft5x0x_ts_data *ft5x0x_ts; struct input_dev *input_dev; struct ft5406_platform_data *pdata = pdata = client->dev.platform_data; int err = 0; int ret = 0; u8 buf_w[1]; u8 buf_r[1]; printk("==ft5x0x_ts_probe=\n"); if (!pdata) { dev_err(&client->dev, "platform data is required!\n"); return -EINVAL; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) return -EIO; ft5x0x_ts = kzalloc(sizeof(*ft5x0x_ts), GFP_KERNEL); if (!ft5x0x_ts) { err = -ENOMEM; goto exit_alloc_data_failed; } /* ft5x0x_client.adapter = bus; ft5x0x_client.addr= address; ft5x0x_client.mode = NORMALMODE; //NORMALNOSTOPMODE;// DIRECTMODE; ft5x0x_client.Channel = I2C_CH0; ft5x0x_client.speed = 300; ft5x0x_client.addressBit=I2C_7BIT_ADDRESS_8BIT_REG; ft5x0x_ts->client=&ft5x0x_client; i2c_set_clientdata(&ft5x0x_client, ft5x0x_ts); err = i2c_attach_client(&ft5x0x_client); if (err < 0) { printk("ft5x0x attach client failed!!!!\n"); goto exit_alloc_data_failed; } INIT_WORK(&ft5x0x_ts->pen_event_work, ft5x0x_ts_pen_irq_work); ft5x0x_ts->ts_workqueue = create_singlethread_workqueue("ft5x0x_ts"); if (!ft5x0x_ts->ts_workqueue) { err = -ESRCH; goto exit_create_singlethread; } rockchip_mux_api_set(TOUCH_INT_IOMUX_PINNAME,TOUCH_INT_IOMUX_PINDIR); GPIOSetPinDirection(TOUCH_INT_IOPIN, GPIO_IN); GPIOPullUpDown(TOUCH_INT_IOPIN, GPIOPullUp); err = request_gpio_irq(TOUCH_INT_IOPIN, ft5x0x_ts_interrupt, GPIOEdgelFalling, ft5x0x_ts); if(err < 0) { printk("ft5x0x_probe: request irq failed\n"); goto exit_irq_request_failed; } */ input_dev = input_allocate_device(); if (!input_dev) { err = -ENOMEM; printk("failed to allocate input device\n"); goto exit_input_dev_alloc_failed; } ft5x0x_ts->client = client; ft5x0x_ts->irq = client->irq; ft5x0x_ts->input_dev = input_dev; #ifdef CONFIG_FT5X0X_MULTITOUCH set_bit(ABS_MT_TOUCH_MAJOR, input_dev->absbit); set_bit(ABS_MT_POSITION_X, input_dev->absbit); set_bit(ABS_MT_POSITION_Y, input_dev->absbit); set_bit(ABS_MT_WIDTH_MAJOR, input_dev->absbit); //input_dev->evbit[0] = BIT_MASK(EV_ABS)|BIT_MASK(EV_KEY)|BIT_MASK(EV_SYN); //harry 03.21 // set_bit(KEY_HOME, input_dev->keybit); input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, SCREEN_MAX_X, 0, 0); input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, SCREEN_MAX_Y, 0, 0); input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, PRESS_MAX, 0, 0); input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 200, 0, 0); input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, 10, 0, 0); #else set_bit(ABS_X, input_dev->absbit); set_bit(ABS_Y, input_dev->absbit); set_bit(ABS_PRESSURE, input_dev->absbit); set_bit(BTN_TOUCH, input_dev->keybit); input_set_abs_params(input_dev, ABS_X, 0, SCREEN_MAX_X, 0, 0); input_set_abs_params(input_dev, ABS_Y, 0, SCREEN_MAX_Y, 0, 0); input_set_abs_params(input_dev, ABS_PRESSURE, 0, PRESS_MAX, 0 , 0); #endif set_bit(EV_ABS, input_dev->evbit); set_bit(EV_KEY, input_dev->evbit); //set_bit(EV_SYN, input_dev->evbit); //harry 03.21 input_dev->name = FT5X0X_NAME; //dev_name(&client->dev) err = input_register_device(input_dev); if (err) { printk("ft5x0x_ts_probe: failed to register input device: \n"); goto exit_input_register_device_failed; } #if 0//def CONFIG_HAS_EARLYSUSPEND ts_early_suspend.suspend = ft5x0x_ts_suspend; ts_early_suspend.resume = ft5x0x_ts_resume; android_register_early_suspend(&ts_early_suspend); #endif printk("==probe over =\n"); if (pdata->init_platform_hw) pdata->init_platform_hw(); if (!ft5x0x_ts->irq) { dev_dbg(&ft5x0x_ts->client->dev, "no IRQ?\n"); return -ENODEV; }else{ ft5x0x_ts->irq = gpio_to_irq(ft5x0x_ts->irq); } INIT_WORK(&ft5x0x_ts->pen_event_work, ft5x0x_ts_pen_irq_work); ft5x0x_ts->ts_workqueue = create_singlethread_workqueue("ft5x0x_ts"); if (!ft5x0x_ts->ts_workqueue) { err = -ESRCH; goto exit_create_singlethread; } printk("client->dev.driver->name %s ,%d \n",client->dev.driver->name,ft5x0x_ts->irq); ret = request_irq(ft5x0x_ts->irq, ft5x0x_ts_interrupt, IRQF_TRIGGER_LOW, client->dev.driver->name, ft5x0x_ts); if (ret < 0) { dev_err(&client->dev, "irq %d busy?\n", ft5x0x_ts->irq); goto fail3; } ret = input_register_device(input_dev); if(ret<0) { printk("ft5406 register input device failed!!!!\n"); goto exit_irq_request_failed; } buf_w[0] = 6; err = ft5406_set_regs(client,0x88,buf_w,1); //ft5x0x_i2c_txdata(0x88, buf_w, 1); /* adjust frequency 60Hz */ buf_r[0] = 0; err = ft5406_read_regs(client,0x88,buf_r,1); //ft5x0x_i2c_rxdata(0x88, buf_r, 1); printk("read buf[0x88] = %d\n", buf_r[0]); return 0; fail3: free_irq(ft5x0x_ts->irq,ft5x0x_ts); exit_input_register_device_failed: input_free_device(input_dev); exit_input_dev_alloc_failed: free_irq(7, ft5x0x_ts); exit_irq_request_failed: exit_platform_data_null: cancel_work_sync(&ft5x0x_ts->pen_event_work); destroy_workqueue(ft5x0x_ts->ts_workqueue); exit_create_singlethread: printk("==singlethread error =\n"); kfree(ft5x0x_ts); exit_alloc_data_failed: return err; }
static int rk28_jogball_probe(struct platform_device *pdev) { int error, i; struct rk28_jogball *jogball = NULL; struct input_dev *input_dev = NULL; struct rk2818_jogball_paltform_data *pdata = pdev->dev.platform_data; if(!(pdata->jogball_key)) return -1; jogball = kzalloc(sizeof(struct rk28_jogball), GFP_KERNEL); if (jogball == NULL) { printk("Alloc memory for rk28_jogball failed.\n"); return -ENOMEM; } /* Create and register the input driver. */ input_dev = input_allocate_device(); if (!input_dev || !jogball) { printk("failed to allocate input device.\n"); error = -ENOMEM; goto failed1; } memcpy(jogball->keycodes, initkey_code, sizeof(jogball->keycodes)); input_dev->name = "jogball"; input_dev->dev.parent = &pdev->dev; input_dev->phys = JOGBALL_PHYS_NAME; input_dev->keycode = jogball->keycodes; input_dev->keycodesize = sizeof(unsigned char); input_dev->keycodemax = ARRAY_SIZE(initkey_code); for (i = 0; i < ARRAY_SIZE(initkey_code); i++) set_bit(initkey_code[i], input_dev->keybit); clear_bit(0, input_dev->keybit); input_dev->evbit[0] = BIT_MASK(EV_KEY); jogball->pdata = pdata; jogball->input_dev = input_dev; input_set_drvdata(input_dev, jogball); platform_set_drvdata(pdev, jogball); prockjogball = jogball; /* Register the input device */ error = input_register_device(input_dev); if (error) { printk("failed to register input device.\n"); goto failed2; } printk(" irq register for input device.\n"); #if 1 //ÉêÇëEXTERN GPIO INTERRUPT //JOG_UP_PORT error = gpio_request(pdata->jogball_key->pin_up,"Jog up"); if(error) { printk("unable to request JOG_UP_PORT IRQ err=%d\n", error); goto failed3; } gpio_direction_input(pdata->jogball_key->pin_up); error = request_irq(gpio_to_irq(pdata->jogball_key->pin_up),rk28_jogball_up_ISR,IRQ_TYPE_EDGE_RISING,NULL,jogball); if(error) { printk("unable to request JOG_UP_PORT irq\n"); goto failed4; } //JOG_DOWN_PORT error = gpio_request(pdata->jogball_key->pin_down,"jog down"); if(error) { printk("unable to request JOG_DOWN_PORT IRQ err=%d\n", error); goto failed5; } gpio_direction_input(pdata->jogball_key->pin_down); //gpio_pull_updown(JOG_DOWN_PORT,GPIOPullUp); error = request_irq(gpio_to_irq(pdata->jogball_key->pin_down),rk28_jogball_down_ISR,IRQ_TYPE_EDGE_RISING,NULL,jogball); if(error) { printk("unable to request JOG_DOWN_PORT irq\n"); goto failed6; } //JOG_LEFT_PORT error = gpio_request(pdata->jogball_key->pin_left,"jog left"); if(error) { printk("unable to request JOG_LEFT_PORT IRQ err=%d\n", error); goto failed7; } gpio_direction_input(pdata->jogball_key->pin_left); //gpio_pull_updown(JOG_LEFT_PORT,GPIOPullUp); error = request_irq(gpio_to_irq(pdata->jogball_key->pin_left),rk28_jogball_left_ISR,IRQ_TYPE_EDGE_RISING,NULL,jogball); if(error) { printk("unable to request JOG_LEFT_PORT irq\n"); goto failed8; } //JOG_RIGHT_PORT error = gpio_request(pdata->jogball_key->pin_right,NULL); if(error) { printk("unable to request JOG_RIGHT_PORT IRQ err=%d\n", error); goto failed9; } gpio_direction_input(pdata->jogball_key->pin_right); //gpio_pull_updown(JOG_RIGHT_PORT,GPIOPullUp); error = request_irq(gpio_to_irq(pdata->jogball_key->pin_right),rk28_jogball_right_ISR,IRQ_TYPE_EDGE_RISING,NULL,jogball); if(error) { printk("unable to request JOG_RIGHT_PORT irq\n"); goto failed10; } #endif #ifdef CONFIG_ANDROID_POWER jogball_early_suspend.suspend = rk28_jogball_early_suspend; jogball_early_suspend.resume = rk28_jogball_early_resume; jogball_early_suspend.level = 0x2; android_register_early_suspend(&jogball_early_suspend); #endif printk("JOGBALL:rk28_jogball_probe sucess\n"); return 0; #if 1 failed10: free_irq(gpio_to_irq(pdata->jogball_key->pin_down),NULL); failed9: gpio_free(pdata->jogball_key->pin_down); failed8: free_irq(gpio_to_irq(pdata->jogball_key->pin_left),NULL); failed7: gpio_free(pdata->jogball_key->pin_left); failed6: free_irq(gpio_to_irq(pdata->jogball_key->pin_down),NULL); failed5: gpio_free(pdata->jogball_key->pin_down); failed4: free_irq(gpio_to_irq(pdata->jogball_key->pin_up),NULL); failed3: gpio_free(pdata->jogball_key->pin_up); input_unregister_device(jogball->input_dev); failed2: platform_set_drvdata(pdev, NULL); input_free_device(input_dev); failed1: kfree(jogball); return error; #endif }
static int mma7660_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct mma7660_data *mma7660; int err; dprint("l=%d,%s:\n",__LINE__, __func__); Xaverage = Yaverage = Zaverage = RawDataNum = 0; mma7660 = kzalloc(sizeof(struct mma7660_data), GFP_KERNEL); if (!mma7660) { rk28printk("[mma7660]:alloc data failed.\n"); err = -ENOMEM; goto exit_alloc_data_failed; } INIT_WORK(&mma7660->work, mma7660_work_func); INIT_DELAYED_WORK(&mma7660->delaywork, mma7660_delaywork_func); mma7660->client = client; //mma7660->swap_xy = i2c_set_clientdata(client, mma7660); this_client = client; err = mma7660_init_client(client); if (err < 0) { rk28printk(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; rk28printk(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, -1500, 1500, 0, 0); /* y-axis acceleration */ input_set_abs_params(mma7660->input_dev, ABS_Y, -1500, 1500, 0, 0); /* z-axis acceleration */ input_set_abs_params(mma7660->input_dev, ABS_Z, -1500, 1500, 0, 0); mma7660->input_dev->name = "gsensor"; mma7660->input_dev->dev.parent = &client->dev; err = input_register_device(mma7660->input_dev); if (err < 0) { rk28printk(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) { rk28printk(KERN_ERR "mma7660_probe: mmad_device register failed\n"); goto exit_misc_device_register_mma7660_device_failed; } err = gsensor_sysfs_init(); if (err < 0) { rk28printk(KERN_ERR "mma7660_probe: gsensor sysfs init failed\n"); goto exit_gsensor_sysfs_init_failed; } #ifdef CONFIG_ANDROID_POWER mma7660_early_suspend.suspend = mma7660_suspend; mma7660_early_suspend.resume = mma7660_resume; mma7660_early_suspend.level = 0x2; android_register_early_suspend(&mma7660_early_suspend); #endif rk28printk(KERN_INFO "mma7660 probe ok\n"); mma7660->status = -1; #if 0 mma7660_start(client, MMA7660_RATE_32); #endif dprint("l=%d,%s:loaded successfully.\n",__LINE__, __func__); 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: free_irq(client->irq, mma7660); exit_request_gpio_irq_failed: kfree(mma7660); exit_alloc_data_failed: ; return err; }
static int __devinit xpt2046_ts_proble(struct spi_device *spi) { struct XPT2046_TS_EVENT *ts_dev; struct input_dev *xpt2046_ts_dev; unsigned int err = 0; rk28printk("************>%s.....%s.....%d\n",__FILE__,__FUNCTION__,__LINE__); ts_dev=kzalloc(sizeof(struct XPT2046_TS_EVENT), GFP_KERNEL); if(!ts_dev) { printk("failed to allocate memory!!\n"); goto nomem; } ts_dev->spi = spi; /*ts_dev to spi reference*/ printk("touch device spi speed = %d\n",spi->max_speed_hz); xpt2046_ts_dev = input_allocate_device(); if(!xpt2046_ts_dev) { printk("rk28 xpt2046_ts allocate input device failed!!!\n"); goto fail1; } ts_dev->input = xpt2046_ts_dev; /*init timer to dispose workqueue */ hrtimer_init(&ts_dev->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); ts_dev->timer.function = xpt2046_dostimer; ts_dev->x = 0; ts_dev->y = 0; ts_dev->z1 = 0; ts_dev->z2 = 0; ts_dev->touch_x = 0; ts_dev->touch_y = 0; ts_dev->status = 0; ts_dev->pendown = 0; ts_dev->irq =XPT2046_IRQ; snprintf(ts_dev->phys,sizeof(ts_dev->phys),"%s/input0",spi->dev.bus_id); xpt2046_ts_dev->evbit[0] = BIT_MASK(EV_ABS)|BIT_MASK(EV_KEY); xpt2046_ts_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); //input_set_abs_params(xpt2046_ts_dev,ABS_X,400,3680,0,0); //input_set_abs_params(xpt2046_ts_dev,ABS_Y,550,3350,0,0); input_set_abs_params(xpt2046_ts_dev,ABS_X,0,LCD_MAX_LENGTH,0,0); input_set_abs_params(xpt2046_ts_dev,ABS_Y,0,LCD_MAX_WIDTH,0,0); //input_set_abs_params(xpt2046_ts_dev, ABS_PRESSURE,0,4096, 0, 0); xpt2046_ts_dev->name = XPT2046_NAME; #ifdef CONFIG_ANDROID_POWER ts_early_suspend.suspend = rk28_ts_suspend; ts_early_suspend.resume = rk28_ts_resume; android_register_early_suspend(&ts_early_suspend); #endif xpt2046_ts_dev->phys = ts_dev->phys; dev_set_drvdata(&spi->dev, ts_dev); xpt2046_ts_dev->dev.parent = &spi->dev; //xpt2046_read_values(ts_dev,MAX_SAMPLE_TIMES); xpt2046_read_values(ts_dev); rk28printk("************>%s....x=%d...y=%d...z1=%d...z2=%d\n",__FUNCTION__,ts_dev->x,ts_dev->y,ts_dev->z1,ts_dev->z2); ///__raw_writel(__raw_readl(GPIO1_BASE_ADDR_VA + 0x30)|0x80,(GPIO1_BASE_ADDR_VA + 0x30)); //err = request_irq(ts_dev->irq,xpt2046_ts_interrupt,IRQF_TRIGGER_FALLING,spi->dev.driver->name,ts_dev); GPIOPullUpDown(PT2046_PENIRQ,GPIOPullUp); err = request_gpio_irq(PT2046_PENIRQ,xpt2046_ts_interrupt,GPIOEdgelFalling,ts_dev); if(err<0) { printk("xpt2046 request irq failed !!\n"); err = -EBUSY; goto fail1; } err = input_register_device(xpt2046_ts_dev); if(err) goto fail2; return err; fail2: free_irq(XPT2046_IRQ,NULL); fail1: input_free_device(xpt2046_ts_dev); hrtimer_cancel(&ts_dev->timer); nomem: kfree(ts_dev); return err; }
static int __init rk28_ts_ak4183_init(void) { int ret; struct AK4183_TS_EVENT *ts_dev = NULL; GPIOSetPinDirection(GPIOPortE_Pin3,GPIO_IN); GPIOSetPinLevel(GPIOPortE_Pin3,GPIO_HIGH); ts_dev = kzalloc(sizeof(struct AK4183_TS_EVENT), GFP_KERNEL); if(ts_dev == NULL) { E("ts_dev kzalloc failed!\n"); ret = -ENOMEM; goto err1; } ts_dev->input = input_allocate_device(); if(ts_dev->input == NULL) { E("input_allocate_device err!\n"); ret = -ENOMEM; goto err2; } ts_dev->irq = 7; ts_dev->input->name = "ak4183"; ts_dev->input->phys = "ak4183_TS/input0"; ts_dev->input->evbit[0] = BIT_MASK(EV_ABS)|BIT_MASK(EV_KEY); ts_dev->input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); input_set_abs_params(ts_dev->input, ABS_X, 0, LCD_MAX_LENGTH - 1, 0, 0); input_set_abs_params(ts_dev->input, ABS_Y, 0, LCD_MAX_WIDTH - 1, 0, 0); ret = input_register_device(ts_dev->input); if(ret < 0){ goto err3; } #ifdef CONFIG_ANDROID_POWER ts_early_suspend.suspend = ak4183_suspend; ts_early_suspend.resume = ak4183_resume; android_register_early_suspend(&ts_early_suspend); #endif rockchip_mux_api_set(GPIOB_SPI0_MMC0_NAME, 0); rockchip_mux_api_set(GPIOB4_SPI0CS0_MMC0D4_NAME, IOMUXA_GPIO0_B4); GPIOSetPinDirection(GPIOPortB_Pin4,GPIO_IN); GPIOSetPinLevel(GPIOPortB_Pin4,GPIO_HIGH); GPIOSetPinDirection(GPIOPortB_Pin5,GPIO_IN); GPIOSetPinLevel(GPIOPortB_Pin5,GPIO_HIGH); GPIOSetPinDirection(GPIOPortB_Pin6,GPIO_IN); GPIOSetPinLevel(GPIOPortB_Pin6,GPIO_HIGH); GPIOSetPinDirection(GPIOPortB_Pin7,GPIO_IN); GPIOSetPinLevel(GPIOPortB_Pin7,GPIO_HIGH); INIT_DELAYED_WORK(&ts_dev->work, ak4183_delay_work); ret = request_gpio_irq(GPIOPortE_Pin3, (void *)ak4183_isr, GPIOEdgelFalling, ts_dev); if(ret < 0){ E("ak4183 request irq err, ret = %d\n", ret); goto err4; } ret = i2c_add_driver(&ak4183_i2c_driver); if(ret < 0){ E("i2c_add_driver err, ret = %d\n", ret); goto err5; } g_ts_dev = ts_dev; ret = driver_create_file(&ak4183_i2c_driver.driver, &driver_attr_touchcheck); ret += driver_create_file(&ak4183_i2c_driver.driver, &driver_attr_touchadc); ret += driver_create_file(&ak4183_i2c_driver.driver, &driver_attr_calistatus); ret += driver_create_file(&ak4183_i2c_driver.driver, &driver_attr_debug_ak4183); I("ak4183 init success!\n"); return 0; err5: free_irq(7, NULL); err4: input_unregister_device(ts_dev->input); err3: input_free_device(ts_dev->input); err2: kfree(ts_dev); err1: return ret;