static int headsetdet_probe(struct platform_device *pdev)
{
struct gpio_switch_platform_data *pdata = pdev->dev.platform_data;
struct headset_switch_data *switch_data;
int ret = 0;
struct input_dev *ip_dev;
if (!pdata)
return -EBUSY;
switch_data = kzalloc(sizeof(struct headset_switch_data), GFP_KERNEL);
if (!switch_data)
return -ENOMEM;
// 20110425 [email protected] detect headset during sleep [START]
/* wake lock for headset detection */
wake_lock_init(&headset_wlock.wake_lock, WAKE_LOCK_SUSPEND, "headset_det");
set_wakelock(0);
// 20110425 [email protected] detect headset during sleep [END]
switch_data->sdev.name = pdata->name;
switch_data->gpio = pdata->gpio;
switch_data->name_on = pdata->name_on;
switch_data->name_off = pdata->name_off;
switch_data->state_on = pdata->state_on;
switch_data->state_off = pdata->state_off;
switch_data->sdev.print_state = switch_gpio_print_state;
switch_data->hook_gpio = HOOK_ADC_GPIO;
#if defined(CONFIG_PRODUCT_LGE_KU5900)||defined(CONFIG_PRODUCT_LGE_P970) || defined(CONFIG_PRODUCT_LGE_LU6800) // 20100814 [email protected], dmb ant detect [START_LGE]
//nothing
#elif defined(CONFIG_PRODUCT_LGE_HUB) // [email protected] : Mach_Hub use external ant for dmb
switch_data->dmb_ant_gpio = 164;
switch_data->dmb_ant_detected = 0;
#endif // 20100814 [email protected], dmb ant detect [END_LGE]
ret = switch_dev_register(&switch_data->sdev);
if (ret < 0)
goto err_switch_dev_register;
omap_mux_init_gpio(switch_data->gpio, OMAP_PIN_INPUT_PULLDOWN | OMAP_PIN_OFF_WAKEUPENABLE); //20101004 [email protected], ear sense wakable setting
#if 1 //20101109 [email protected], hook key wakable setting
omap_mux_init_gpio(switch_data->hook_gpio, OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE);
#endif
ret = gpio_request(switch_data->gpio, pdev->name);
ret = gpio_request(switch_data->hook_gpio, pdev->name);
#if defined(CONFIG_PRODUCT_LGE_KU5900)||defined(CONFIG_PRODUCT_LGE_P970) || defined(CONFIG_PRODUCT_LGE_LU6800) // 20100814 [email protected], dmb ant detect [START_LGE]
//nothing
#else
ret = gpio_request(switch_data->dmb_ant_gpio, pdev->name);
#endif // 20100814 [email protected], dmb ant detect [END_LGE]
if (ret < 0)
goto err_request_gpio;
ret = gpio_direction_input(switch_data->gpio);
ret = gpio_direction_input(switch_data->hook_gpio);
#if defined(CONFIG_PRODUCT_LGE_KU5900)||defined(CONFIG_PRODUCT_LGE_P970) || defined(CONFIG_PRODUCT_LGE_HUB)// 20100814 [email protected], dmb ant detect [START_LGE]
//nothing
#else
//--[[ LGE_UBIQUIX_MODIFIED_START : [email protected] [2011.08.11] - GPIO direction input error fixed.
ret = gpio_request(switch_data->dmb_ant_gpio, pdev->name);
if (ret < 0)
goto err_request_gpio;
//--]] LGE_UBIQUIX_MODIFIED_END : [email protected] [2011.08.11]- GPIO direction input error fixed.
ret = gpio_direction_input(switch_data->dmb_ant_gpio);
#endif // 20100814 [email protected], dmb ant detect [END_LGE]
if (ret < 0)
goto err_set_gpio_input;
ip_dev = input_allocate_device();
switch_data->ip_dev = ip_dev;
switch_data->ip_dev->name = "Hookkey"; //20100830, [email protected], define the input dev name
set_bit(EV_SYN, switch_data->ip_dev->evbit);
set_bit(EV_KEY, switch_data->ip_dev->evbit);
set_bit(KEY_HOOK, switch_data->ip_dev->keybit); //for short pressed hook key
ret = input_register_device(switch_data->ip_dev);
INIT_WORK(&switch_data->work, headset_det_work);
INIT_DELAYED_WORK(&switch_data->delayed_work, type_det_work);
INIT_DELAYED_WORK(&switch_data->hook_delayed_work, hook_det_work);
switch_data->irq = gpio_to_irq(switch_data->gpio);
switch_data->hook_irq = gpio_to_irq(switch_data->hook_gpio);
// 20100814 [email protected], dmb ant detect [START_LGE]
#if defined(CONFIG_PRODUCT_LGE_KU5900) ||defined(CONFIG_PRODUCT_LGE_P970)
//nothing
#else
switch_data->dmb_ant_irq = gpio_to_irq(switch_data->dmb_ant_gpio); // 20100814 [email protected], dmb ant gpio [START_LGE]
#endif
// 20100814 [email protected], dmb ant detect [END_LGE]
if (switch_data->irq < 0) {
ret = switch_data->irq;
goto err_detect_irq_num_failed;
}
#if 1 //20101004 [email protected], ear sense wakable setting
/* Make the interrupt on wake up OMAP which is in suspend mode */
ret = enable_irq_wake(switch_data->irq);
if(ret < 0){
DBG(KERN_INFO "[LUCKYJUN77] EAR SENSE 170 wake up source setting failed!\n");
disable_irq_wake(switch_data->irq);
return -ENOSYS;
}
#endif
#if 1 //20101109 [email protected], hook key wakable setting
/* Make the interrupt on wake up OMAP which is in suspend mode */
ret = enable_irq_wake(switch_data->hook_irq);
if(ret < 0){
DBG(KERN_INFO "[LUCKYJUN77] Hook key 163 wake up source setting failed!\n");
disable_irq_wake(switch_data->hook_irq);
return -ENOSYS;
}
#endif
ret = request_irq(switch_data->irq, headset_int_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, pdev->name, switch_data);
if (ret < 0)
goto err_request_irq;
ret = request_irq(switch_data->hook_irq, headset_hook_int_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "headset_hook", switch_data);
if (ret < 0)
goto err_request_irq;
// 20100825 [email protected], mic bias LDO control test [START_LGE]
#if 1
omap_mux_init_gpio(MIC_BIAS_LDO, OMAP_PIN_OUTPUT);
ret = gpio_request(MIC_BIAS_LDO, pdev->name);
if(ret < 0) {
DBG("can't get hub Mic bias LDO enable GPIO\n");
goto err_request_gpio;
}
#endif
// 20100825 [email protected], mic bias LDO control test [END_LGE]
// 20100814 [email protected], dmb ant detect [START_LGE]
#if defined(CONFIG_PRODUCT_LGE_KU5900) || defined(CONFIG_PRODUCT_LGE_LU6800)||defined(CONFIG_PRODUCT_LGE_P970)
//nothing
#else
ret = request_irq(switch_data->dmb_ant_irq, dmb_ant_int_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "dmb_ant", switch_data);
#endif
// 20100814 [email protected], dmb ant detect [END_LGE]
/* Perform initial detection */
headset_sw_data = switch_data;
headset_sw_data->is_suspend = 0; //resume
headset_det_work(&switch_data->work);
// 20100603 [email protected], headset suspend/resume [START_LGE]
#ifdef CONFIG_HAS_EARLYSUSPEND
switch_data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 2;
switch_data->early_suspend.suspend = headsetdet_early_suspend;
switch_data->early_suspend.resume = headsetdet_late_resume;
register_early_suspend(&switch_data->early_suspend);
#endif
// 20100603 [email protected], headset suspend/resume [END_LGE]
return 0;
err_request_irq:
err_detect_irq_num_failed:
err_set_gpio_input:
gpio_free(switch_data->gpio);
err_request_gpio:
switch_dev_unregister(&switch_data->sdev);
err_switch_dev_register:
kfree(switch_data);
return ret;
}
/*
* The functions for inserting/removing us as a module.
*/
static int __init s3c_ts_probe(struct platform_device *pdev)
{
struct device *dev;
struct input_dev *input_dev;
struct s3c_ts_mach_info * s3c_ts_cfg;
int ret;
int err;
dev = &pdev->dev;
s3c_ts_cfg = (struct s3c_ts_mach_info *) dev->platform_data;
if (s3c_ts_cfg == NULL)
return -EINVAL;
ts = kzalloc(sizeof(struct s3c_ts_mach_info), GFP_KERNEL);
data = kzalloc(sizeof(struct s3c_ts_data), GFP_KERNEL);
memcpy (ts, s3c_ts_cfg, sizeof(struct s3c_ts_mach_info));
input_dev = input_allocate_device();
if (!input_dev) {
ret = -ENOMEM;
goto input_dev_fail;
}
data->dev = input_dev;
data->xp_old = data->yp_old = -1;
data->dev->evbit[0] = data->dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
data->dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
input_set_abs_params(data->dev, ABS_X, 0, ts->screen_size_x, 0, 0);
input_set_abs_params(data->dev, ABS_Y, 0, ts->screen_size_y, 0, 0);
// [SEC_BSP.khLEE 2009.08.24 : Intialize variables for calibration mode
#ifdef CONFIG_SAMSUNG_CALIBRATION_MODE
ret = init_samsung_cal_mode(ts->screen_size_x, ts->screen_size_y, ts->tscal);
if(ret)
{
dev_err(dev, "s3c_ts.c: Could not initialization(touchscreen)!\n");
goto s3c_adcts_register_fail;
}
#endif
// ]
set_bit(0,data->dev->evbit);
set_bit(1,data->dev->evbit);
set_bit(2,data->dev->evbit);
set_bit(3,data->dev->evbit);
set_bit(5,data->dev->evbit);
set_bit(0,data->dev->relbit);
set_bit(1,data->dev->relbit);
set_bit(0,data->dev->absbit);
set_bit(1,data->dev->absbit);
set_bit(2,data->dev->absbit);
set_bit(0,data->dev->swbit);
for(err=0;err<512;err++) set_bit(err,data->dev->keybit);
input_event(data->dev,5,0,1);
input_set_abs_params(data->dev, ABS_PRESSURE, 0, 1, 0, 0);
data->dev->name = s3c_ts_name;
data->dev->id.bustype = BUS_RS232;
data->dev->id.vendor = 0xDEAD;
data->dev->id.product = 0xBEEF;
data->dev->id.version = S3C_TSVERSION;
ret = s3c_adcts_register_ts (ts, s3c_ts_done_callback);
if(ret) {
dev_err(dev, "s3c_ts.c: Could not register adcts device(touchscreen)!\n");
ret = -EIO;
goto s3c_adcts_register_fail;
}
/* All went ok, so register to the input system */
ret = input_register_device(data->dev);
if(ret) {
dev_err(dev, "s3c_ts.c: Could not register input device(touchscreen)!\n");
ret = -EIO;
goto input_register_fail;
}
return 0;
input_register_fail:
s3c_adcts_unregister_ts();
s3c_adcts_register_fail:
input_free_device (data->dev);
input_dev_fail:
kfree (ts);
kfree (data);
return ret;
}
static int usb_mouse_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
struct usb_device *dev = interface_to_usbdev(intf);
struct usb_host_interface *interface;
struct usb_endpoint_descriptor *endpoint;
struct usb_mouse *mouse;
struct input_dev *input_dev;
int pipe, maxp;
int error = -ENOMEM;
interface = intf->cur_altsetting;
if (interface->desc.bNumEndpoints != 1)
return -ENODEV;
endpoint = &interface->endpoint[0].desc;
if (!usb_endpoint_is_int_in(endpoint))
return -ENODEV;
pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
mouse = kzalloc(sizeof(struct usb_mouse), GFP_KERNEL);
input_dev = input_allocate_device();
if (!mouse || !input_dev)
goto fail1;
mouse->data = usb_buffer_alloc(dev, 8, GFP_ATOMIC, &mouse->data_dma);
if (!mouse->data)
goto fail1;
mouse->irq = usb_alloc_urb(0, GFP_KERNEL);
if (!mouse->irq)
goto fail2;
mouse->usbdev = dev;
mouse->dev = input_dev;
if (dev->manufacturer)
strlcpy(mouse->name, dev->manufacturer, sizeof(mouse->name));
if (dev->product) {
if (dev->manufacturer)
strlcat(mouse->name, " ", sizeof(mouse->name));
strlcat(mouse->name, dev->product, sizeof(mouse->name));
}
if (!strlen(mouse->name))
snprintf(mouse->name, sizeof(mouse->name),
"USB HIDBP Mouse %04x:%04x",
le16_to_cpu(dev->descriptor.idVendor),
le16_to_cpu(dev->descriptor.idProduct));
usb_make_path(dev, mouse->phys, sizeof(mouse->phys));
strlcat(mouse->phys, "/input0", sizeof(mouse->phys));
input_dev->name = mouse->name;
input_dev->phys = mouse->phys;
usb_to_input_id(dev, &input_dev->id);
input_dev->dev.parent = &intf->dev;
input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |
BIT_MASK(BTN_EXTRA);
input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);
input_set_drvdata(input_dev, mouse);
input_dev->open = usb_mouse_open;
input_dev->close = usb_mouse_close;
usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,
(maxp > 8 ? 8 : maxp),
usb_mouse_irq, mouse, endpoint->bInterval);
mouse->irq->transfer_dma = mouse->data_dma;
mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
error = input_register_device(mouse->dev);
if (error)
goto fail3;
usb_set_intfdata(intf, mouse);
return 0;
fail3:
usb_free_urb(mouse->irq);
fail2:
usb_buffer_free(dev, 8, mouse->data, mouse->data_dma);
fail1:
input_free_device(input_dev);
kfree(mouse);
return error;
}
static int omap4_keypad_probe(struct platform_device *pdev)
{
struct omap4_keypad *keypad_data;
struct input_dev *input_dev;
struct resource *res;
unsigned int max_keys;
int rev;
int irq;
int error;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "no base address specified\n");
return -EINVAL;
}
irq = platform_get_irq(pdev, 0);
if (!irq) {
dev_err(&pdev->dev, "no keyboard irq assigned\n");
return -EINVAL;
}
keypad_data = kzalloc(sizeof(struct omap4_keypad), GFP_KERNEL);
if (!keypad_data) {
dev_err(&pdev->dev, "keypad_data memory allocation failed\n");
return -ENOMEM;
}
keypad_data->irq = irq;
error = omap4_keypad_parse_dt(&pdev->dev, keypad_data);
if (error)
return error;
res = request_mem_region(res->start, resource_size(res), pdev->name);
if (!res) {
dev_err(&pdev->dev, "can't request mem region\n");
error = -EBUSY;
goto err_free_keypad;
}
keypad_data->base = ioremap(res->start, resource_size(res));
if (!keypad_data->base) {
dev_err(&pdev->dev, "can't ioremap mem resource\n");
error = -ENOMEM;
goto err_release_mem;
}
/*
* Enable clocks for the keypad module so that we can read
* revision register.
*/
pm_runtime_enable(&pdev->dev);
error = pm_runtime_get_sync(&pdev->dev);
if (error) {
dev_err(&pdev->dev, "pm_runtime_get_sync() failed\n");
goto err_unmap;
}
rev = __raw_readl(keypad_data->base + OMAP4_KBD_REVISION);
rev &= 0x03 << 30;
rev >>= 30;
switch (rev) {
case KBD_REVISION_OMAP4:
keypad_data->reg_offset = 0x00;
keypad_data->irqreg_offset = 0x00;
break;
case KBD_REVISION_OMAP5:
keypad_data->reg_offset = 0x10;
keypad_data->irqreg_offset = 0x0c;
break;
default:
dev_err(&pdev->dev,
"Keypad reports unsupported revision %d", rev);
error = -EINVAL;
goto err_pm_put_sync;
}
/* input device allocation */
keypad_data->input = input_dev = input_allocate_device();
if (!input_dev) {
error = -ENOMEM;
goto err_pm_put_sync;
}
input_dev->name = pdev->name;
input_dev->dev.parent = &pdev->dev;
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0001;
input_dev->open = omap4_keypad_open;
input_dev->close = omap4_keypad_close;
input_set_capability(input_dev, EV_MSC, MSC_SCAN);
if (!keypad_data->no_autorepeat)
__set_bit(EV_REP, input_dev->evbit);
input_set_drvdata(input_dev, keypad_data);
keypad_data->row_shift = get_count_order(keypad_data->cols);
max_keys = keypad_data->rows << keypad_data->row_shift;
keypad_data->keymap = kzalloc(max_keys * sizeof(keypad_data->keymap[0]),
GFP_KERNEL);
if (!keypad_data->keymap) {
dev_err(&pdev->dev, "Not enough memory for keymap\n");
error = -ENOMEM;
goto err_free_input;
}
error = matrix_keypad_build_keymap(NULL, NULL,
keypad_data->rows, keypad_data->cols,
keypad_data->keymap, input_dev);
if (error) {
dev_err(&pdev->dev, "failed to build keymap\n");
goto err_free_keymap;
}
error = request_threaded_irq(keypad_data->irq, omap4_keypad_irq_handler,
omap4_keypad_irq_thread_fn, 0,
"omap4-keypad", keypad_data);
if (error) {
dev_err(&pdev->dev, "failed to register interrupt\n");
goto err_free_input;
}
device_init_wakeup(&pdev->dev, true);
pm_runtime_put_sync(&pdev->dev);
error = input_register_device(keypad_data->input);
if (error < 0) {
dev_err(&pdev->dev, "failed to register input device\n");
goto err_pm_disable;
}
platform_set_drvdata(pdev, keypad_data);
return 0;
err_pm_disable:
pm_runtime_disable(&pdev->dev);
device_init_wakeup(&pdev->dev, false);
free_irq(keypad_data->irq, keypad_data);
err_free_keymap:
kfree(keypad_data->keymap);
err_free_input:
input_free_device(input_dev);
err_pm_put_sync:
pm_runtime_put_sync(&pdev->dev);
err_unmap:
iounmap(keypad_data->base);
err_release_mem:
release_mem_region(res->start, resource_size(res));
err_free_keypad:
kfree(keypad_data);
return error;
}
static int pm8058_kp_config_drv(int gpio_start, int num_gpios)
{
int rc;
struct pm8058_gpio kypd_drv = {
.direction = PM_GPIO_DIR_OUT,
.output_buffer = PM_GPIO_OUT_BUF_OPEN_DRAIN,
.output_value = 0,
.pull = PM_GPIO_PULL_NO,
.vin_sel = 2,
.out_strength = PM_GPIO_STRENGTH_LOW,
.function = PM_GPIO_FUNC_1,
.inv_int_pol = 1,
};
if (gpio_start < 0 || num_gpios < 0 || num_gpios > PM8058_GPIOS)
return -EINVAL;
while (num_gpios--) {
rc = pm8058_gpio_config(gpio_start++, &kypd_drv);
if (rc) {
pr_err("%s: FAIL pm8058_gpio_config(): rc=%d.\n",
__func__, rc);
return rc;
}
}
return 0;
}
static int pm8058_kp_config_sns(int gpio_start, int num_gpios)
{
int rc;
struct pm8058_gpio kypd_sns = {
.direction = PM_GPIO_DIR_IN,
.pull = PM_GPIO_PULL_UP_31P5,
.vin_sel = 2,
.out_strength = PM_GPIO_STRENGTH_NO,
.function = PM_GPIO_FUNC_NORMAL,
.inv_int_pol = 1,
};
if (gpio_start < 0 || num_gpios < 0 || num_gpios > PM8058_GPIOS)
return -EINVAL;
while (num_gpios--) {
rc = pm8058_gpio_config(gpio_start++, &kypd_sns);
if (rc) {
pr_err("%s: FAIL pm8058_gpio_config(): rc=%d.\n",
__func__, rc);
return rc;
}
}
return 0;
}
/*
* keypad controller should be initialized in the following sequence
* only, otherwise it might get into FSM stuck state.
*
* - Initialize keypad control parameters, like no. of rows, columns,
* timing values etc.,
* - configure rows and column gpios pull up/down.
* - set irq edge type.
* - enable the keypad controller.
*/
static int __devinit pmic8058_kp_probe(struct platform_device *pdev)
{
struct pmic8058_keypad_data *pdata = pdev->dev.platform_data;
const struct matrix_keymap_data *keymap_data;
struct pmic8058_kp *kp;
int rc;
unsigned short *keycodes;
u8 ctrl_val;
struct pm8058_chip *pm_chip;
pm_chip = dev_get_drvdata(pdev->dev.parent);
if (pm_chip == NULL) {
dev_err(&pdev->dev, "no parent data passed in\n");
return -EFAULT;
}
if (!pdata || !pdata->num_cols || !pdata->num_rows ||
pdata->num_cols > PM8058_MAX_COLS ||
pdata->num_rows > PM8058_MAX_ROWS ||
pdata->num_cols < PM8058_MIN_COLS ||
pdata->num_rows < PM8058_MIN_ROWS) {
dev_err(&pdev->dev, "invalid platform data\n");
return -EINVAL;
}
if (pdata->rows_gpio_start < 0 || pdata->cols_gpio_start < 0) {
dev_err(&pdev->dev, "invalid gpio_start platform data\n");
return -EINVAL;
}
if (!pdata->scan_delay_ms || pdata->scan_delay_ms > MAX_SCAN_DELAY
|| pdata->scan_delay_ms < MIN_SCAN_DELAY ||
!is_power_of_2(pdata->scan_delay_ms)) {
dev_err(&pdev->dev, "invalid keypad scan time supplied\n");
return -EINVAL;
}
if (!pdata->row_hold_ns || pdata->row_hold_ns > MAX_ROW_HOLD_DELAY
|| pdata->row_hold_ns < MIN_ROW_HOLD_DELAY ||
((pdata->row_hold_ns % MIN_ROW_HOLD_DELAY) != 0)) {
dev_err(&pdev->dev, "invalid keypad row hold time supplied\n");
return -EINVAL;
}
if (pm8058_rev(pm_chip) == PM_8058_REV_1p0) {
if (!pdata->debounce_ms
|| !is_power_of_2(pdata->debounce_ms[0])
|| pdata->debounce_ms[0] > MAX_DEBOUNCE_A0_TIME
|| pdata->debounce_ms[0] < MIN_DEBOUNCE_A0_TIME) {
dev_err(&pdev->dev, "invalid debounce time supplied\n");
return -EINVAL;
}
} else {
if (!pdata->debounce_ms
|| ((pdata->debounce_ms[1] % 5) != 0)
|| pdata->debounce_ms[1] > MAX_DEBOUNCE_B0_TIME
|| pdata->debounce_ms[1] < MIN_DEBOUNCE_B0_TIME) {
dev_err(&pdev->dev, "invalid debounce time supplied\n");
return -EINVAL;
}
}
keymap_data = pdata->keymap_data;
if (!keymap_data) {
dev_err(&pdev->dev, "no keymap data supplied\n");
return -EINVAL;
}
kp = kzalloc(sizeof(*kp), GFP_KERNEL);
if (!kp)
return -ENOMEM;
keycodes = kzalloc(PM8058_MATRIX_MAX_SIZE * sizeof(*keycodes),
GFP_KERNEL);
if (!keycodes) {
rc = -ENOMEM;
goto err_alloc_mem;
}
platform_set_drvdata(pdev, kp);
mutex_init(&kp->mutex);
kp->pdata = pdata;
kp->dev = &pdev->dev;
kp->keycodes = keycodes;
kp->pm_chip = pm_chip;
if (pm8058_rev(pm_chip) == PM_8058_REV_1p0)
kp->flags |= KEYF_FIX_LAST_ROW;
kp->input = input_allocate_device();
if (!kp->input) {
dev_err(&pdev->dev, "unable to allocate input device\n");
rc = -ENOMEM;
goto err_alloc_device;
}
/* Enable runtime PM ops, start in ACTIVE mode */
rc = pm_runtime_set_active(&pdev->dev);
if (rc < 0)
dev_dbg(&pdev->dev, "unable to set runtime pm state\n");
pm_runtime_enable(&pdev->dev);
kp->key_sense_irq = platform_get_irq(pdev, 0);
if (kp->key_sense_irq < 0) {
dev_err(&pdev->dev, "unable to get keypad sense irq\n");
rc = -ENXIO;
goto err_get_irq;
}
kp->key_stuck_irq = platform_get_irq(pdev, 1);
if (kp->key_stuck_irq < 0) {
dev_err(&pdev->dev, "unable to get keypad stuck irq\n");
rc = -ENXIO;
goto err_get_irq;
}
if (pdata->input_name)
kp->input->name = pdata->input_name;
else
kp->input->name = "PMIC8058 keypad";
if (pdata->input_phys_device)
kp->input->phys = pdata->input_phys_device;
else
kp->input->phys = "pmic8058_keypad/input0";
kp->input->dev.parent = &pdev->dev;
kp->input->id.bustype = BUS_HOST;
kp->input->id.version = 0x0001;
kp->input->id.product = 0x0001;
kp->input->id.vendor = 0x0001;
kp->input->evbit[0] = BIT_MASK(EV_KEY);
if (pdata->rep)
__set_bit(EV_REP, kp->input->evbit);
kp->input->keycode = keycodes;
kp->input->keycodemax = PM8058_MATRIX_MAX_SIZE;
kp->input->keycodesize = sizeof(*keycodes);
matrix_keypad_build_keymap(keymap_data, PM8058_ROW_SHIFT,
kp->input->keycode, kp->input->keybit);
input_set_capability(kp->input, EV_MSC, MSC_SCAN);
input_set_drvdata(kp->input, kp);
rc = input_register_device(kp->input);
if (rc < 0) {
dev_err(&pdev->dev, "unable to register keypad input device\n");
goto err_get_irq;
}
/* initialize keypad state */
memset(kp->keystate, 0xff, sizeof(kp->keystate));
memset(kp->stuckstate, 0xff, sizeof(kp->stuckstate));
rc = pmic8058_kpd_init(kp);
if (rc < 0) {
dev_err(&pdev->dev, "unable to initialize keypad controller\n");
goto err_kpd_init;
}
rc = pm8058_kp_config_sns(pdata->cols_gpio_start,
pdata->num_cols);
if (rc < 0) {
dev_err(&pdev->dev, "unable to configure keypad sense lines\n");
goto err_gpio_config;
}
rc = pm8058_kp_config_drv(pdata->rows_gpio_start,
pdata->num_rows);
if (rc < 0) {
dev_err(&pdev->dev, "unable to configure keypad drive lines\n");
goto err_gpio_config;
}
rc = request_threaded_irq(kp->key_sense_irq, NULL, pmic8058_kp_irq,
IRQF_TRIGGER_RISING, "pmic-keypad", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request keypad sense irq\n");
goto err_req_sense_irq;
}
rc = request_threaded_irq(kp->key_stuck_irq, NULL,
pmic8058_kp_stuck_irq, IRQF_TRIGGER_RISING,
"pmic-keypad-stuck", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request keypad stuck irq\n");
goto err_req_stuck_irq;
}
rc = pmic8058_kp_read_u8(kp, &ctrl_val, KEYP_CTRL);
ctrl_val |= KEYP_CTRL_KEYP_EN;
rc = pmic8058_kp_write_u8(kp, ctrl_val, KEYP_CTRL);
kp->ctrl_reg = ctrl_val;
__dump_kp_regs(kp, "probe");
rc = device_create_file(&pdev->dev, &dev_attr_disable_kp);
if (rc < 0)
goto err_create_file;
device_init_wakeup(&pdev->dev, pdata->wakeup);
return 0;
err_create_file:
free_irq(kp->key_stuck_irq, NULL);
err_req_stuck_irq:
free_irq(kp->key_sense_irq, NULL);
err_req_sense_irq:
err_gpio_config:
err_kpd_init:
input_unregister_device(kp->input);
kp->input = NULL;
err_get_irq:
pm_runtime_set_suspended(&pdev->dev);
pm_runtime_disable(&pdev->dev);
input_free_device(kp->input);
err_alloc_device:
kfree(keycodes);
err_alloc_mem:
kfree(kp);
return rc;
}
static int __devexit pmic8058_kp_remove(struct platform_device *pdev)
{
struct pmic8058_kp *kp = platform_get_drvdata(pdev);
pm_runtime_set_suspended(&pdev->dev);
pm_runtime_disable(&pdev->dev);
device_remove_file(&pdev->dev, &dev_attr_disable_kp);
device_init_wakeup(&pdev->dev, 0);
free_irq(kp->key_stuck_irq, NULL);
free_irq(kp->key_sense_irq, NULL);
input_unregister_device(kp->input);
platform_set_drvdata(pdev, NULL);
kfree(kp->input->keycode);
kfree(kp);
return 0;
}
#ifdef CONFIG_PM
static int pmic8058_kp_suspend(struct device *dev)
{
struct pmic8058_kp *kp = dev_get_drvdata(dev);
if (device_may_wakeup(dev) && !pmic8058_kp_disabled(kp)) {
enable_irq_wake(kp->key_sense_irq);
} else {
mutex_lock(&kp->mutex);
pmic8058_kp_disable(kp);
mutex_unlock(&kp->mutex);
}
return 0;
}
static int pmic8058_kp_resume(struct device *dev)
{
struct pmic8058_kp *kp = dev_get_drvdata(dev);
if (device_may_wakeup(dev) && !pmic8058_kp_disabled(kp)) {
disable_irq_wake(kp->key_sense_irq);
} else {
mutex_lock(&kp->mutex);
pmic8058_kp_enable(kp);
mutex_unlock(&kp->mutex);
}
return 0;
}
static struct dev_pm_ops pm8058_kp_pm_ops = {
.suspend = pmic8058_kp_suspend,
.resume = pmic8058_kp_resume,
};
#endif
static struct platform_driver pmic8058_kp_driver = {
.probe = pmic8058_kp_probe,
.remove = __devexit_p(pmic8058_kp_remove),
.driver = {
.name = "pm8058-keypad",
.owner = THIS_MODULE,
#ifdef CONFIG_PM
.pm = &pm8058_kp_pm_ops,
#endif
},
};
static int __init pmic8058_kp_init(void)
{
return platform_driver_register(&pmic8058_kp_driver);
}
module_init(pmic8058_kp_init);
static void __exit pmic8058_kp_exit(void)
{
platform_driver_unregister(&pmic8058_kp_driver);
}
static int mlx90615_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = -ENODEV;
struct mlx90615_data *mlx90615 = NULL;
pr_info("[BODYTEMP] %s is called.\n", __func__);
/* Check i2c functionality */
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("[BODYTEMP] %s: i2c functionality check failed!\n",
__func__);
return ret;
}
mlx90615 = kzalloc(sizeof(struct mlx90615_data), GFP_KERNEL);
if (!mlx90615) {
pr_err("[BODYTEMP] %s: failed to alloc memory mlx90615_data\n",
__func__);
return -ENOMEM;
}
if (client-> dev.of_node)
pr_info("[BODYTEMP] %s : of node\n", __func__);
else {
pr_err("[BODYTEMP] %s : no of node\n", __func__);
goto err_setup_reg;
}
ret = mlx90615_parse_dt(&client->dev, mlx90615);
if (ret) {
pr_err("[BODYTEMP] %s : parse dt error\n", __func__);
//goto err_parse_dt;
}
mlx90615->i2c_client = client;
mlx90615->always_on = 0;
i2c_set_clientdata(client, mlx90615);
mutex_init(&mlx90615->power_lock);
mutex_init(&mlx90615->read_lock);
#if 0
/* Check if the device is there or not. */
ret = i2c_master_send(mlx90615->i2c_client,
CMD_READ_ID_REG, MLX90615_CMD_LENGTH);
if (ret < 0) {
pr_err("[BODYTEMP] %s: failed i2c_master_send (err = %d)\n",
__func__, ret);
/* goto err_i2c_master_send;*/
}
#endif
/* allocate mlx90615 input_device */
mlx90615->input = input_allocate_device();
if (!mlx90615->input) {
pr_err("[BODYTEMP] %s: could not allocate input device\n",
__func__);
goto err_input_allocate_device;
}
mlx90615->input->name = "bodytemp_sensor";
input_set_capability(mlx90615->input, EV_REL, EVENT_TYPE_AMBIENT_TEMP);
input_set_capability(mlx90615->input, EV_REL, EVENT_TYPE_OBJECT_TEMP);
input_set_drvdata(mlx90615->input, mlx90615);
ret = input_register_device(mlx90615->input);
if (ret < 0) {
input_free_device(mlx90615->input);
pr_err("[BODYTEMP] %s: could not register input device\n",
__func__);
goto err_input_register_device;
}
ret = sensors_create_symlink(&mlx90615->input->dev.kobj,
mlx90615->input->name);
if (ret < 0) {
input_unregister_device(mlx90615->input);
goto err_sysfs_create_symlink;
}
ret = sysfs_create_group(&mlx90615->input->dev.kobj,
&mlx90615_attribute_group);
if (ret) {
pr_err("[BODYTEMP] %s: could not create sysfs group\n",
__func__);
goto err_sysfs_create_group;
}
ret = sensors_register(mlx90615->mlx90615_dev,
mlx90615, bodytemp_sensor_attrs, "bodytemp_sensor");
if (ret) {
pr_err("[BODYTEMP] %s: cound not register sensor device(%d).\n",
__func__, ret);
goto err_sysfs_create_symlink;
}
/* Timer settings. We poll for mlx90615 values using a timer. */
hrtimer_init(&mlx90615->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
mlx90615->poll_delay = ns_to_ktime(DEFAULT_DELAY * NSEC_PER_MSEC);
mlx90615->timer.function = timer_func;
/* Timer just fires off a work queue request. We need a thread
to read the i2c (can be slow and blocking). */
mlx90615->mlx90615_wq =
create_singlethread_workqueue("mlx90615_bidytemp_wq");
if (!mlx90615->mlx90615_wq) {
ret = -ENOMEM;
pr_err("[BODYTEMP] %s: could not create mlx90615 workqueue\n", __func__);
goto err_create_workqueue;
}
/* This is the thread function we run on the work queue */
INIT_WORK(&mlx90615->work_mlx90615, mlx90615_work_func);
pr_info("[BODYTEMP] %s is success.\n", __func__);
goto done;
err_create_workqueue:
sysfs_remove_group(&mlx90615->input->dev.kobj,
&mlx90615_attribute_group);
/* sensors_classdev_unregister(mlx90615->mlx90615_dev);*/
destroy_workqueue(mlx90615->mlx90615_wq);
err_sysfs_create_group:
input_unregister_device(mlx90615->input);
err_sysfs_create_symlink:
sensors_remove_symlink(&mlx90615->input->dev.kobj,
mlx90615->input->name);
err_input_register_device:
err_input_allocate_device:
mutex_destroy(&mlx90615->read_lock);
mutex_destroy(&mlx90615->power_lock);
err_setup_reg:
//err_parse_dt:
kfree(mlx90615);
done:
return ret;
}
int cx231xx_ir_init(struct cx231xx *dev)
{
struct cx231xx_IR *ir;
struct input_dev *input_dev;
u8 ir_config;
int err = -ENOMEM;
if (dev->board.ir_codes == NULL) {
/* No remote control support */
return 0;
}
ir = kzalloc(sizeof(*ir), GFP_KERNEL);
input_dev = input_allocate_device();
if (!ir || !input_dev)
goto err_out_free;
ir->input = input_dev;
/* Setup the proper handler based on the chip */
switch (dev->chip_id) {
default:
printk("Unrecognized cx231xx chip id: IR not supported\n");
goto err_out_free;
}
/* This is how often we ask the chip for IR information */
ir->polling = 100; /* ms */
/* init input device */
snprintf(ir->name, sizeof(ir->name), "cx231xx IR (%s)", dev->name);
usb_make_path(dev->udev, ir->phys, sizeof(ir->phys));
strlcat(ir->phys, "/input0", sizeof(ir->phys));
err = ir_input_init(input_dev, &ir->ir, IR_TYPE_OTHER);
if (err < 0)
goto err_out_free;
input_dev->name = ir->name;
input_dev->phys = ir->phys;
input_dev->id.bustype = BUS_USB;
input_dev->id.version = 1;
input_dev->id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
input_dev->id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
input_dev->dev.parent = &dev->udev->dev;
/* record handles to ourself */
ir->dev = dev;
dev->ir = ir;
cx231xx_ir_start(ir);
/* all done */
err = ir_input_register(ir->input, dev->board.ir_codes, NULL);
if (err)
goto err_out_stop;
return 0;
err_out_stop:
cx231xx_ir_stop(ir);
dev->ir = NULL;
err_out_free:
kfree(ir);
return err;
}
int cx23885_input_init(struct cx23885_dev *dev)
{
struct card_ir *ir;
struct input_dev *input_dev;
struct ir_scancode_table *ir_codes = NULL;
int ir_type, ir_addr, ir_start;
int ret;
/*
* If the IR device (hardware registers, chip, GPIO lines, etc.) isn't
* encapsulated in a v4l2_subdev, then I'm not going to deal with it.
*/
if (dev->sd_ir == NULL)
return -ENODEV;
switch (dev->board) {
case CX23885_BOARD_HAUPPAUGE_HVR1850:
case CX23885_BOARD_HAUPPAUGE_HVR1290:
/* Parameters for the grey Hauppauge remote for the HVR-1850 */
ir_codes = &ir_codes_hauppauge_new_table;
ir_type = IR_TYPE_RC5;
ir_addr = 0x1e; /* RC-5 system bits emitted by the remote */
ir_start = RC5_START_BITS_NORMAL; /* A basic RC-5 remote */
break;
}
if (ir_codes == NULL)
return -ENODEV;
ir = kzalloc(sizeof(*ir), GFP_KERNEL);
input_dev = input_allocate_device();
if (!ir || !input_dev) {
ret = -ENOMEM;
goto err_out_free;
}
ir->dev = input_dev;
ir->addr = ir_addr;
ir->start = ir_start;
/* init input device */
snprintf(ir->name, sizeof(ir->name), "cx23885 IR (%s)",
cx23885_boards[dev->board].name);
snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0", pci_name(dev->pci));
ret = ir_input_init(input_dev, &ir->ir, ir_type);
if (ret < 0)
goto err_out_free;
input_dev->name = ir->name;
input_dev->phys = ir->phys;
input_dev->id.bustype = BUS_PCI;
input_dev->id.version = 1;
if (dev->pci->subsystem_vendor) {
input_dev->id.vendor = dev->pci->subsystem_vendor;
input_dev->id.product = dev->pci->subsystem_device;
} else {
input_dev->id.vendor = dev->pci->vendor;
input_dev->id.product = dev->pci->device;
}
input_dev->dev.parent = &dev->pci->dev;
dev->ir_input = ir;
cx23885_input_ir_start(dev);
ret = ir_input_register(ir->dev, ir_codes);
if (ret)
goto err_out_stop;
return 0;
err_out_stop:
cx23885_input_ir_stop(dev);
dev->ir_input = NULL;
err_out_free:
kfree(ir);
return ret;
}
static int __devinit matrix_keypad_probe(struct platform_device *pdev)
{
const struct matrix_keypad_platform_data *pdata;
const struct matrix_keymap_data *keymap_data;
struct matrix_keypad *keypad;
struct input_dev *input_dev;
unsigned short *keycodes;
unsigned int row_shift;
int err;
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "no platform data defined\n");
return -EINVAL;
}
keymap_data = pdata->keymap_data;
if (!keymap_data) {
dev_err(&pdev->dev, "no keymap data defined\n");
return -EINVAL;
}
row_shift = get_count_order(pdata->num_col_gpios);
keypad = kzalloc(sizeof(struct matrix_keypad), GFP_KERNEL);
keycodes = kzalloc((pdata->num_row_gpios << row_shift) *
sizeof(*keycodes),
GFP_KERNEL);
input_dev = input_allocate_device();
if (!keypad || !keycodes || !input_dev) {
err = -ENOMEM;
goto err_free_mem;
}
keypad->input_dev = input_dev;
keypad->pdata = pdata;
keypad->keycodes = keycodes;
keypad->row_shift = row_shift;
keypad->stopped = true;
INIT_DELAYED_WORK(&keypad->work, matrix_keypad_scan);
spin_lock_init(&keypad->lock);
input_dev->name = pdev->name;
input_dev->id.bustype = BUS_HOST;
input_dev->dev.parent = &pdev->dev;
input_dev->evbit[0] = BIT_MASK(EV_KEY);
if (!pdata->no_autorepeat)
input_dev->evbit[0] |= BIT_MASK(EV_REP);
input_dev->open = matrix_keypad_start;
input_dev->close = matrix_keypad_stop;
input_dev->keycode = keycodes;
input_dev->keycodesize = sizeof(*keycodes);
input_dev->keycodemax = pdata->num_row_gpios << row_shift;
matrix_keypad_build_keymap(keymap_data, row_shift,
input_dev->keycode, input_dev->keybit);
input_set_capability(input_dev, EV_MSC, MSC_SCAN);
input_set_drvdata(input_dev, keypad);
err = init_matrix_gpio(pdev, keypad);
if (err)
goto err_free_mem;
err = input_register_device(keypad->input_dev);
if (err)
goto err_free_mem;
device_init_wakeup(&pdev->dev, pdata->wakeup);
platform_set_drvdata(pdev, keypad);
return 0;
err_free_mem:
input_free_device(input_dev);
kfree(keycodes);
kfree(keypad);
return err;
}
static int __devinit hs_probe(struct platform_device *pdev)
{
int rc = 0;
struct input_dev *ipdev;
hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
if (!hs)
return -ENOMEM;
hs->sdev.name = "h2w";
hs->sdev.print_name = msm_headset_print_name;
rc = switch_dev_register(&hs->sdev);
if (rc)
goto err_switch_dev_register;
ipdev = input_allocate_device();
if (!ipdev) {
rc = -ENOMEM;
goto err_alloc_input_dev;
}
input_set_drvdata(ipdev, hs);
hs->ipdev = ipdev;
if (pdev->dev.platform_data)
hs->hs_pdata = pdev->dev.platform_data;
if (hs->hs_pdata->hs_name)
ipdev->name = hs->hs_pdata->hs_name;
else
ipdev->name = DRIVER_NAME;
ipdev->id.vendor = 0x0001;
ipdev->id.product = 1;
ipdev->id.version = 1;
input_set_capability(ipdev, EV_KEY, KEY_WAKEUP);//ZTE_HS_ZHENGCHAO_01
input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
input_set_capability(ipdev, EV_SW, SW_MICROPHONE_INSERT);
input_set_capability(ipdev, EV_KEY, KEY_POWER);
/*ZTE_HS_ZHUYF_002*/
//disable KEY_END, enable KEY_SLEEP
//input_set_capability(ipdev, EV_KEY, KEY_END);
input_set_capability(ipdev, EV_KEY, KEY_SLEEP);
/*end, ZTE_HS_ZHUYF_002*/
rc = input_register_device(ipdev);
if (rc) {
dev_err(&ipdev->dev,
"hs_probe: input_register_device rc=%d\n", rc);
goto err_reg_input_dev;
}
platform_set_drvdata(pdev, hs);
rc = hs_rpc_init();
if (rc) {
dev_err(&ipdev->dev, "rpc init failure\n");
goto err_hs_rpc_init;
}
return 0;
err_hs_rpc_init:
input_unregister_device(ipdev);
ipdev = NULL;
err_reg_input_dev:
input_free_device(ipdev);
err_alloc_input_dev:
switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
kfree(hs);
return rc;
}
static int __init ecompass_init(void)
{
int res = 0;
pr_info("ecompass driver: init\n");
ecs_data_device = input_allocate_device();
if (!ecs_data_device) {
res = -ENOMEM;
pr_err("%s: failed to allocate input device\n", __FUNCTION__);
goto out;
}
set_bit(EV_ABS, ecs_data_device->evbit);
/* 32768 == 1g, range -4g ~ +4g */
/* acceleration x-axis */
input_set_abs_params(ecs_data_device, ABS_X,
-32768*4, 32768*4, 0, 0);
/* acceleration y-axis */
input_set_abs_params(ecs_data_device, ABS_Y,
-32768*4, 32768*4, 0, 0);
/* acceleration z-axis */
input_set_abs_params(ecs_data_device, ABS_Z,
-32768*4, 32768*4, 0, 0);
/* 32768 == 1gauss, range -4gauss ~ +4gauss */
/* magnetic raw x-axis */
input_set_abs_params(ecs_data_device, ABS_HAT0X,
-32768*4, 32768*4, 0, 0);
/* magnetic raw y-axis */
input_set_abs_params(ecs_data_device, ABS_HAT0Y,
-32768*4, 32768*4, 0, 0);
/* magnetic raw z-axis */
input_set_abs_params(ecs_data_device, ABS_BRAKE,
-32768*4, 32768*4, 0, 0);
/* 65536 == 360degree */
/* orientation yaw, 0 ~ 360 */
input_set_abs_params(ecs_data_device, ABS_RX,
0, 65536, 0, 0);
/* orientation pitch, -180 ~ 180 */
input_set_abs_params(ecs_data_device, ABS_RY,
-65536/2, 65536/2, 0, 0);
/* orientation roll, -90 ~ 90 */
input_set_abs_params(ecs_data_device, ABS_RZ,
-65536/4, 65536/4, 0, 0);
ecs_data_device->name = ECS_DATA_DEV_NAME;
res = input_register_device(ecs_data_device);
if (res) {
pr_err("%s: unable to register input device: %s\n",
__FUNCTION__, ecs_data_device->name);
goto out_free_input;
}
res = misc_register(&ecs_ctrl_device);
if (res) {
pr_err("%s: ecs_ctrl_device register failed\n", __FUNCTION__);
goto out_free_input;
}
res = device_create_file(ecs_ctrl_device.this_device, &dev_attr_ecs_ctrl);
if (res) {
pr_err("%s: device_create_file failed\n", __FUNCTION__);
goto out_deregister_misc;
}
return 0;
out_deregister_misc:
misc_deregister(&ecs_ctrl_device);
out_free_input:
input_free_device(ecs_data_device);
out:
return res;
}
/**
* Creates a new Xen Virtrual Pointer Device.
*
* @param info The information structure for the combined input device
* for which this device should belong to.
* @param name The new device's name, as reported to the user.
*/
static struct input_dev * __allocate_pointer_device(struct openxt_kbd_info *info,
char * name, int is_absolute, int is_multitouch)
{
int i, ret;
struct input_dev *ptr = input_allocate_device();
//If we weren't able to allocate a new input device, fail out!
if (!ptr)
return NULL;
//Otherwise, set up some of the device's defaults.
ptr->name = name;
ptr->phys = info->phys;
ptr->id.bustype = BUS_PCI;
ptr->id.vendor = 0x5853;
ptr->id.product = 0xfffe;
//If we're creating an absolute device, register it as a provider
//of absolute events.
if (is_absolute) {
__set_bit(EV_ABS, ptr->evbit);
input_set_abs_params(ptr, ABS_X, 0, default_max_x, 0, 0);
input_set_abs_params(ptr, ABS_Y, 0, default_max_y, 0, 0);
if (is_multitouch) {
input_set_abs_params(ptr, ABS_MT_POSITION_X, 0, default_max_x, 0, 0);
input_set_abs_params(ptr, ABS_MT_POSITION_Y, 0, default_max_y, 0, 0);
//Accept touches, as well.
input_set_capability(ptr, EV_KEY, BTN_TOUCH);
//And allow up to ten fingers of touch.
input_mt_init_slots(ptr, 10, INPUT_MT_DIRECT);
}
}
//Otherwise, register it as providing relative ones.
else {
input_set_capability(ptr, EV_REL, REL_X);
input_set_capability(ptr, EV_REL, REL_Y);
}
//Enable scroll events on non-multitouch displays.
if (!is_multitouch)
input_set_capability(ptr, EV_REL, REL_WHEEL);
//Mark this device as providing the typical mouse keys.
if (!is_multitouch) {
__set_bit(EV_KEY, ptr->evbit);
for (i = BTN_LEFT; i <= BTN_TASK; i++)
__set_bit(i, ptr->keybit);
}
//Finally, register the new input device with evdev.
ret = input_register_device(ptr);
if (ret) {
input_free_device(ptr);
return NULL;
}
return ptr;
}
static int accfix_probe(struct platform_device *xxx)
{
int ret = 0;
#ifdef SW_WORK_AROUND_ACCDET_REMOTE_BUTTON_ISSUE
struct task_struct *keyEvent_thread = NULL;
int error=0;
#endif
ACCFIX_DEBUG("[accfix]accfix_probe begin!\n");
//------------------------------------------------------------------
// below register accdet as switch class
//------------------------------------------------------------------
//------------------------------------------------------------------
// Create normal device for auido use
//------------------------------------------------------------------
ret = alloc_chrdev_region(&accfix_devno, 0, 1, ACCFIX_DEVNAME);
if (ret)
{
ACCFIX_DEBUG("[accfix]alloc_chrdev_region: Get Major number error!\n");
return -1;
}
accfix_cdev = cdev_alloc();
accfix_cdev->owner = THIS_MODULE;
accfix_cdev->ops = &accfix_fops;
ret = cdev_add(accfix_cdev, accfix_devno, 1);
if(ret)
{
ACCFIX_DEBUG("[accfix]accfix error: cdev_add\n");
return -1;
}
ACCFIX_DEBUG("[accfix]try create classd\n");
accfix_class = class_create(THIS_MODULE, ACCFIX_DEVNAME);
if (accfix_class == NULL){
ACCFIX_DEBUG("[accfix]class_create failed\n");
return -1;
} else {
ACCFIX_DEBUG("[accfix]class_create success\n");
}
//ACCFIX_DEBUG("[accfix]try destroy device\n");
//device_destroy(accfix_class, accfix_devno);
//ACCFIX_DEBUG("[accfix]destroy device success\n");
// if we want auto creat device node, we must call this
accfix_nor_device = device_create(accfix_class, NULL, accfix_devno, NULL, ACCFIX_DEVNAME);
if (accfix_nor_device == NULL){
ACCFIX_DEBUG("[accfix]device_create failed\n");
return -1;
} else {
ACCFIX_DEBUG("[accfix]device_create success\n");
}
//sys_chmod("/dev/accfix", 777);
/*ACCFIX_DEBUG("[accfix]try device_rename \n");
ret= device_rename(accfix_nor_device, "accdet");
if(ret)
{
ACCFIX_DEBUG("[accfix]device_rename returned:%d!\n", ret);
return -1;
} else {
ACCFIX_DEBUG("[accfix]device_rename success\n");
}
//zzzzz
ACCFIX_DEBUG("[accfix] DEBUG EXIT\n");
return -1;
*/
//switch dev
accfix_data.name = "h2w_test"; //zzz
accfix_data.index = 0;
accfix_data.state = NO_DEVICE;
//zzz
//ACCFIX_DEBUG("[accfix]try switch_dev_unregister returned:%d!\n", ret);
//switch_dev_unregister(&accfix_data);
ret = switch_dev_register(&accfix_data);
if(ret)
{
ACCFIX_DEBUG("[accfix]switch_dev_register returned:%d!\n", ret);
return -1; //switch doesnt matter - just an icon in taskbar
}
//------------------------------------------------------------------make: *** [_module_../med
// Create input device
//------------------------------------------------------------------
kpd_accfix_dev = input_allocate_device();
if (!kpd_accfix_dev)
{
ACCFIX_DEBUG("[accfix]kpd_accfix_dev : fail!\n");
return -ENOMEM;
}
__set_bit(EV_KEY, kpd_accfix_dev->evbit);
__set_bit(KEY_CALL, kpd_accfix_dev->keybit);
__set_bit(KEY_ENDCALL, kpd_accfix_dev->keybit);
//longxuewei add
__set_bit(KEY_F24, kpd_accfix_dev->keybit);
__set_bit(114, kpd_accfix_dev->keybit);
__set_bit(115, kpd_accfix_dev->keybit);
__set_bit(163, kpd_accfix_dev->keybit);
__set_bit(165, kpd_accfix_dev->keybit);
__set_bit(226, kpd_accfix_dev->keybit);
//longxuewei add end
kpd_accfix_dev->id.bustype = BUS_HOST;
kpd_accfix_dev->name = "ACCFIX";
if(input_register_device(kpd_accfix_dev))
{
ACCFIX_DEBUG("[accfix]kpd_accfix_dev register : fail!\n");
}else
{
ACCFIX_DEBUG("[accfix]kpd_accfix_dev register : success!!\n");
}
//------------------------------------------------------------------
// Create workqueue
//------------------------------------------------------------------
accfix_workqueue = create_singlethread_workqueue("accfix");
INIT_WORK(&accfix_work, accfix_work_callback);
#ifdef ACCFIX_EINT
accfix_eint_workqueue = create_singlethread_workqueue("accfix_eint");
INIT_WORK(&accfix_eint_work, accfix_eint_work_callback);
accfix_setup_eint();
#endif
/* #if defined(SUPPORT_CALLINGLIGHT)
hrtimer_init(&accfix_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
accfix_timer.function = calling_light_decate;
#endif */
//------------------------------------------------------------------
// wake lock
//------------------------------------------------------------------
wake_lock_init(&accfix_suspend_lock, WAKE_LOCK_SUSPEND, "accfix wakelock");
#ifdef SW_WORK_AROUND_ACCDET_REMOTE_BUTTON_ISSUE
init_waitqueue_head(&send_event_wq);
//start send key event thread
keyEvent_thread = kthread_run(sendKeyEvent, 0, "keyEvent_send");
if (IS_ERR(keyEvent_thread))
{
error = PTR_ERR(keyEvent_thread);
ACCFIX_DEBUG( " failed to create kernel thread: %d\n", error);
}
#endif
#if DEBUG_THREAD
if((ret = accfix_create_attr(&accfix_driver.driver)))
{
ACCFIX_DEBUG("create attribute err = %d\n", ret);
}
#endif
/* For early porting before audio driver add */
//temp_func();
ACCFIX_DEBUG("[accfix]accfix_probe : ACCFIX_INIT\n");
if (g_accfix_first == 1)
{
long_press_time_ns = (s64)long_press_time * NSEC_PER_MSEC;
//Accdet Hardware Init
accfix_init();
//mt6575_irq_set_sens(MT6575_ACCDET_IRQ_ID, MT65xx_EDGE_SENSITIVE);
mt6575_irq_set_sens(MT6575_ACCDET_IRQ_ID, MT65xx_LEVEL_SENSITIVE);
mt6575_irq_set_polarity(MT6575_ACCDET_IRQ_ID, MT65xx_POLARITY_LOW);
//register accdet interrupt
ret = request_irq(MT6575_ACCDET_IRQ_ID, accfix_irq_handler, 0, "ACCFIX", NULL);
if(ret)
{
ACCFIX_DEBUG("[accfix]accfix register interrupt error\n");
ACCFIX_DEBUG("[accfix]try free IRQ\n");
free_irq(MT6575_ACCDET_IRQ_ID,NULL);
ACCFIX_DEBUG("[accfix]IRQ freed success\n");
ret = request_irq(MT6575_ACCDET_IRQ_ID, accfix_irq_handler, 0, "ACCFIX", NULL);
if(ret){
ACCFIX_DEBUG("[accfix]accfix register interrupt error twice\n");
}
}
queue_work(accfix_workqueue, &accfix_work); //schedule a work for the first detection
g_accfix_first = 0;
}
ACCFIX_DEBUG("[accfix]accfix_probe done!\n");
return 0;
}
/* touch panel probe */
static int tpd_probe(struct platform_device *pdev)
{
int touch_type = 1; /* 0:R-touch, 1: Cap-touch */
int i = 0;
TPD_DMESG("enter %s, %d\n", __func__, __LINE__);
/* Select R-Touch */
/* if(g_tpd_drv == NULL||tpd_load_status == 0) */
#if 0
if (g_tpd_drv == NULL) {
g_tpd_drv = &tpd_driver_list[0];
/* touch_type:0: r-touch, 1: C-touch */
touch_type = 0;
TPD_DMESG("Generic touch panel driver\n");
}
#ifdef CONFIG_HAS_EARLYSUSPEND
MTK_TS_early_suspend_handler.suspend = g_tpd_drv->suspend;
MTK_TS_early_suspend_handler.resume = g_tpd_drv->resume;
register_early_suspend(&MTK_TS_early_suspend_handler);
#endif
#endif
if (misc_register(&tpd_misc_device)) {
printk("mtk_tpd: tpd_misc_device register failed\n");
}
if ((tpd = (struct tpd_device *)kmalloc(sizeof(struct tpd_device), GFP_KERNEL)) == NULL)
return -ENOMEM;
memset(tpd, 0, sizeof(struct tpd_device));
/* allocate input device */
if ((tpd->dev = input_allocate_device()) == NULL) {
kfree(tpd);
return -ENOMEM;
}
/* TPD_RES_X = simple_strtoul(LCM_WIDTH, NULL, 0); */
/* TPD_RES_Y = simple_strtoul(LCM_HEIGHT, NULL, 0); */
#ifdef CONFIG_MTK_LCM_PHYSICAL_ROTATION
if(0 == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "90", 2) || 0 == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "270", 3))
{
TPD_RES_Y = DISP_GetScreenWidth();
TPD_RES_X = DISP_GetScreenHeight();
}
else
#endif
{
#ifdef CONFIG_CUSTOM_LCM_X
#ifndef CONFIG_MTK_FPGA
TPD_RES_X = DISP_GetScreenWidth();
TPD_RES_Y = DISP_GetScreenHeight();
#endif
#else
TPD_RES_X = simple_strtoul(CONFIG_LCM_WIDTH, NULL, 0);
TPD_RES_Y = simple_strtoul(CONFIG_LCM_HEIGHT, NULL, 0);
#endif
}
printk("mtk_tpd: TPD_RES_X = %d, TPD_RES_Y = %d\n", TPD_RES_X, TPD_RES_Y);
tpd_mode = TPD_MODE_NORMAL;
tpd_mode_axis = 0;
tpd_mode_min = TPD_RES_Y / 2;
tpd_mode_max = TPD_RES_Y;
tpd_mode_keypad_tolerance = TPD_RES_X * TPD_RES_X / 1600;
/* struct input_dev dev initialization and registration */
tpd->dev->name = TPD_DEVICE;
set_bit(EV_ABS, tpd->dev->evbit);
set_bit(EV_KEY, tpd->dev->evbit);
set_bit(ABS_X, tpd->dev->absbit);
set_bit(ABS_Y, tpd->dev->absbit);
set_bit(ABS_PRESSURE, tpd->dev->absbit);
#if !defined(CONFIG_MTK_S3320) && !defined(CONFIG_MTK_S3320_47) && !defined(CONFIG_MTK_S3320_50) && !defined(CONFIG_MTK_MIT200) && !defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S3528) && !defined(CONFIG_MTK_S7020)
set_bit(BTN_TOUCH, tpd->dev->keybit);
#endif /* CONFIG_MTK_S3320 */
set_bit(INPUT_PROP_DIRECT, tpd->dev->propbit);
/* save dev for regulator_get() before tpd_local_init() */
tpd->tpd_dev = &pdev->dev;
#if 1
for (i = 1; i < TP_DRV_MAX_COUNT; i++) {
/* add tpd driver into list */
if (tpd_driver_list[i].tpd_device_name != NULL) {
tpd_driver_list[i].tpd_local_init();
/* msleep(1); */
if (tpd_load_status == 1) {
TPD_DMESG("[mtk-tpd]tpd_probe, tpd_driver_name=%s\n",
tpd_driver_list[i].tpd_device_name);
g_tpd_drv = &tpd_driver_list[i];
break;
}
}
}
if (g_tpd_drv == NULL) {
if (tpd_driver_list[0].tpd_device_name != NULL) {
g_tpd_drv = &tpd_driver_list[0];
/* touch_type:0: r-touch, 1: C-touch */
touch_type = 0;
g_tpd_drv->tpd_local_init();
TPD_DMESG("[mtk-tpd]Generic touch panel driver\n");
} else {
TPD_DMESG("[mtk-tpd]cap touch and Generic touch both are not loaded!!\n");
return 0;
}
}
#ifdef CONFIG_HAS_EARLYSUSPEND
#ifndef CONFIG_MTK_FPGA
MTK_TS_early_suspend_handler.suspend = g_tpd_drv->suspend;
MTK_TS_early_suspend_handler.resume = g_tpd_drv->resume;
#ifdef CONFIG_EARLYSUSPEND
register_early_suspend(&MTK_TS_early_suspend_handler);
#endif
#endif
#endif
#endif
/* #ifdef TPD_TYPE_CAPACITIVE */
/* TPD_TYPE_CAPACITIVE handle */
if (touch_type == 1) {
set_bit(ABS_MT_TRACKING_ID, tpd->dev->absbit);
set_bit(ABS_MT_TOUCH_MAJOR, tpd->dev->absbit);
set_bit(ABS_MT_TOUCH_MINOR, tpd->dev->absbit);
set_bit(ABS_MT_POSITION_X, tpd->dev->absbit);
set_bit(ABS_MT_POSITION_Y, tpd->dev->absbit);
#if 0 /* linux kernel update from 2.6.35 --> 3.0 */
tpd->dev->absmax[ABS_MT_POSITION_X] = TPD_RES_X;
tpd->dev->absmin[ABS_MT_POSITION_X] = 0;
tpd->dev->absmax[ABS_MT_POSITION_Y] = TPD_RES_Y;
tpd->dev->absmin[ABS_MT_POSITION_Y] = 0;
tpd->dev->absmax[ABS_MT_TOUCH_MAJOR] = 100;
tpd->dev->absmin[ABS_MT_TOUCH_MINOR] = 0;
#else
input_set_abs_params(tpd->dev, ABS_MT_POSITION_X, 0, TPD_RES_X, 0, 0);
input_set_abs_params(tpd->dev, ABS_MT_POSITION_Y, 0, TPD_RES_Y, 0, 0);
#if defined(CONFIG_MTK_S3320) || defined(CONFIG_MTK_S3320_47) || defined(CONFIG_MTK_S3320_50) || defined(CONFIG_MTK_MIT200) || defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S3528) || defined(CONFIG_MTK_S7020)
input_set_abs_params(tpd->dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
input_set_abs_params(tpd->dev, ABS_MT_WIDTH_MAJOR, 0, 15, 0, 0);
input_set_abs_params(tpd->dev, ABS_MT_WIDTH_MINOR, 0, 15, 0, 0);
input_mt_init_slots(tpd->dev, 10, 0);
#else
input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MAJOR, 0, 100, 0, 0);
input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MINOR, 0, 100, 0, 0);
#endif /* CONFIG_MTK_S3320 */
#endif
TPD_DMESG("Cap touch panel driver\n");
}
/* #endif */
#if 0 /* linux kernel update from 2.6.35 --> 3.0 */
tpd->dev->absmax[ABS_X] = TPD_RES_X;
tpd->dev->absmin[ABS_X] = 0;
tpd->dev->absmax[ABS_Y] = TPD_RES_Y;
tpd->dev->absmin[ABS_Y] = 0;
tpd->dev->absmax[ABS_PRESSURE] = 255;
tpd->dev->absmin[ABS_PRESSURE] = 0;
#else
input_set_abs_params(tpd->dev, ABS_X, 0, TPD_RES_X, 0, 0);
input_set_abs_params(tpd->dev, ABS_Y, 0, TPD_RES_Y, 0, 0);
input_abs_set_res(tpd->dev, ABS_X, TPD_RES_X);
input_abs_set_res(tpd->dev, ABS_Y, TPD_RES_Y);
input_set_abs_params(tpd->dev, ABS_PRESSURE, 0, 255, 0, 0);
input_set_abs_params(tpd->dev, ABS_MT_TRACKING_ID, 0, 10, 0, 0);
#endif
if (input_register_device(tpd->dev))
TPD_DMESG("input_register_device failed.(tpd)\n");
else
tpd_register_flag = 1;
/* init R-Touch */
#if 0
if (touch_type == 0) {
g_tpd_drv->tpd_local_init();
}
#endif
if (g_tpd_drv->tpd_have_button) {
tpd_button_init();
}
if (g_tpd_drv->attrs.num)
tpd_create_attributes(&pdev->dev, &g_tpd_drv->attrs);
return 0;
}
static int sh_keysc_probe(struct platform_device *pdev)
{
struct sh_keysc_priv *priv;
struct sh_keysc_info *pdata;
struct resource *res;
struct input_dev *input;
int i;
int irq, error;
if (!pdev->dev.platform_data) {
dev_err(&pdev->dev, "no platform data defined\n");
error = -EINVAL;
goto err0;
}
error = -ENXIO;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&pdev->dev, "failed to get I/O memory\n");
goto err0;
}
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(&pdev->dev, "failed to get irq\n");
goto err0;
}
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
if (priv == NULL) {
dev_err(&pdev->dev, "failed to allocate driver data\n");
error = -ENOMEM;
goto err0;
}
platform_set_drvdata(pdev, priv);
memcpy(&priv->pdata, pdev->dev.platform_data, sizeof(priv->pdata));
pdata = &priv->pdata;
priv->iomem_base = ioremap_nocache(res->start, resource_size(res));
if (priv->iomem_base == NULL) {
dev_err(&pdev->dev, "failed to remap I/O memory\n");
error = -ENXIO;
goto err1;
}
priv->input = input_allocate_device();
if (!priv->input) {
dev_err(&pdev->dev, "failed to allocate input device\n");
error = -ENOMEM;
goto err2;
}
input = priv->input;
input->evbit[0] = BIT_MASK(EV_KEY);
input->name = pdev->name;
input->phys = "sh-keysc-keys/input0";
input->dev.parent = &pdev->dev;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
input->keycode = pdata->keycodes;
input->keycodesize = sizeof(pdata->keycodes[0]);
input->keycodemax = ARRAY_SIZE(pdata->keycodes);
error = request_threaded_irq(irq, NULL, sh_keysc_isr, IRQF_ONESHOT,
dev_name(&pdev->dev), pdev);
if (error) {
dev_err(&pdev->dev, "failed to request IRQ\n");
goto err3;
}
for (i = 0; i < SH_KEYSC_MAXKEYS; i++)
__set_bit(pdata->keycodes[i], input->keybit);
__clear_bit(KEY_RESERVED, input->keybit);
error = input_register_device(input);
if (error) {
dev_err(&pdev->dev, "failed to register input device\n");
goto err4;
}
pm_runtime_enable(&pdev->dev);
pm_runtime_get_sync(&pdev->dev);
sh_keysc_write(priv, KYCR1, (sh_keysc_mode[pdata->mode].kymd << 8) |
pdata->scan_timing);
sh_keysc_level_mode(priv, 0);
device_init_wakeup(&pdev->dev, 1);
return 0;
err4:
free_irq(irq, pdev);
err3:
input_free_device(input);
err2:
iounmap(priv->iomem_base);
err1:
kfree(priv);
err0:
return error;
}
static int __init amikbd_init(void)
{
int i, j, err;
if (!AMIGAHW_PRESENT(AMI_KEYBOARD))
return -ENODEV;
if (!request_mem_region(CIAA_PHYSADDR-1+0xb00, 0x100, "amikeyb"))
return -EBUSY;
amikbd_dev = input_allocate_device();
if (!amikbd_dev) {
printk(KERN_ERR "amikbd: not enough memory for input device\n");
err = -ENOMEM;
goto fail1;
}
amikbd_dev->name = "Amiga Keyboard";
amikbd_dev->phys = "amikbd/input0";
amikbd_dev->id.bustype = BUS_AMIGA;
amikbd_dev->id.vendor = 0x0001;
amikbd_dev->id.product = 0x0001;
amikbd_dev->id.version = 0x0100;
amikbd_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
for (i = 0; i < 0x78; i++)
set_bit(i, amikbd_dev->keybit);
for (i = 0; i < MAX_NR_KEYMAPS; i++) {
static u_short temp_map[NR_KEYS] __initdata;
if (!key_maps[i])
continue;
memset(temp_map, 0, sizeof(temp_map));
for (j = 0; j < 0x78; j++) {
if (!amikbd_keycode[j])
continue;
temp_map[j] = key_maps[i][amikbd_keycode[j]];
}
for (j = 0; j < NR_KEYS; j++) {
if (!temp_map[j])
temp_map[j] = 0xf200;
}
memcpy(key_maps[i], temp_map, sizeof(temp_map));
}
ciaa.cra &= ~0x41; /* serial data in, turn off TA */
if (request_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt, 0, "amikbd",
amikbd_interrupt)) {
err = -EBUSY;
goto fail2;
}
err = input_register_device(amikbd_dev);
if (err)
goto fail3;
return 0;
fail3: free_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt);
fail2: input_free_device(amikbd_dev);
fail1: release_mem_region(CIAA_PHYSADDR - 1 + 0xb00, 0x100);
return err;
}
/**
* bu21013_probe() - initializes the i2c-client touchscreen driver
* @client: i2c client structure pointer
* @id: i2c device id pointer
*
* This function used to initializes the i2c-client touchscreen
* driver and returns integer.
*/
static int __devinit bu21013_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct bu21013_ts_data *bu21013_data;
struct input_dev *in_dev;
const struct bu21013_platform_device *pdata =
client->dev.platform_data;
int error;
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_BYTE_DATA)) {
dev_err(&client->dev, "i2c smbus byte data not supported\n");
return -EIO;
}
if (!pdata) {
dev_err(&client->dev, "platform data not defined\n");
return -EINVAL;
}
bu21013_data = kzalloc(sizeof(struct bu21013_ts_data), GFP_KERNEL);
in_dev = input_allocate_device();
if (!bu21013_data || !in_dev) {
dev_err(&client->dev, "device memory alloc failed\n");
error = -ENOMEM;
goto err_free_mem;
}
bu21013_data->in_dev = in_dev;
bu21013_data->chip = pdata;
bu21013_data->client = client;
bu21013_data->touch_stopped = false;
init_waitqueue_head(&bu21013_data->wait);
/* configure the gpio pins */
if (pdata->cs_en) {
error = pdata->cs_en(pdata->cs_pin);
if (error < 0) {
dev_err(&client->dev, "chip init failed\n");
goto err_free_mem;
}
}
/* configure the touch panel controller */
error = bu21013_init_chip(bu21013_data);
if (error) {
dev_err(&client->dev, "error in bu21013 config\n");
goto err_cs_disable;
}
/* register the device to input subsystem */
in_dev->name = DRIVER_TP;
in_dev->id.bustype = BUS_I2C;
in_dev->dev.parent = &client->dev;
__set_bit(EV_SYN, in_dev->evbit);
__set_bit(EV_KEY, in_dev->evbit);
__set_bit(EV_ABS, in_dev->evbit);
input_set_abs_params(in_dev, ABS_MT_POSITION_X, 0,
pdata->x_max_res, 0, 0);
input_set_abs_params(in_dev, ABS_MT_POSITION_Y, 0,
pdata->y_max_res, 0, 0);
input_set_drvdata(in_dev, bu21013_data);
error = request_threaded_irq(pdata->irq, NULL, bu21013_gpio_irq,
IRQF_TRIGGER_FALLING | IRQF_SHARED,
DRIVER_TP, bu21013_data);
if (error) {
dev_err(&client->dev, "request irq %d failed\n", pdata->irq);
goto err_cs_disable;
}
error = input_register_device(in_dev);
if (error) {
dev_err(&client->dev, "failed to register input device\n");
goto err_free_irq;
}
device_init_wakeup(&client->dev, pdata->wakeup);
i2c_set_clientdata(client, bu21013_data);
return 0;
err_free_irq:
bu21013_free_irq(bu21013_data);
err_cs_disable:
pdata->cs_dis(pdata->cs_pin);
err_free_mem:
input_free_device(in_dev);
kfree(bu21013_data);
return error;
}
static int __init hub_proxi_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret;
struct hub_proxi_data *data;
struct device *dev = &client->dev;
// 20100827 [email protected] [START_LGE]
hub_proximity_client = client;
// 20100827 [email protected] [END_LGE]
//Event_to_application(client);
data = kzalloc(sizeof(struct hub_proxi_data), GFP_KERNEL);
if (!data) {
return -ENOMEM;
}
// 20100810 [email protected] GPIO Initialization [START_LGE]
omap_mux_init_gpio(PROXI_LDO_EN, OMAP_PIN_OUTPUT);
omap_mux_init_gpio(PROXI_OUT, OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE);
ret = gpio_request(PROXI_LDO_EN, "proximity enable gpio");
if(ret < 0) {
printk("can't get hub proximity enable GPIO\n");
kzfree(data);
return -ENOSYS;
}
data->use_int_mode = true; //interrupt mode
// gpio_request(proxi_output_1, "proxi int gpio");
// gpio_direction_input(proxi_output_1);
// request_irq(client->irq, hub_proxi_sleep_int_handler, IRQF_DISABLED | IRQF_TRIGGER_FALLING, "proxi_driver", data);
// enable_irq_wake(client->irq); //wake up irq
if (data->use_int_mode) {
/* LGE_CHANGE_S, [email protected], 2011-04-06, Disable Proximity Log */
//printk(KERN_WARNING"%s() : interrupt mode. START\n", __func__);
/* LGE_CHANGE_E, [email protected], 2011-04-06, Disable Proximity Log */
if (gpio_request(PROXI_OUT, "proxi interrupt gpio") < 0) {
printk("can't get hub proxi irq GPIO\n");
kzfree(data);
return -ENOSYS;
}
ret = gpio_direction_input(PROXI_OUT);
ret = request_irq(gpio_to_irq(PROXI_OUT), hub_proxi_int_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "proximity_interrupt", data);
if (ret < 0){
printk(KERN_INFO "[Proximity INT] GPIO 14 IRQ line set up failed!\n");
free_irq(gpio_to_irq(PROXI_OUT), data);
return -ENOSYS;
}
/* Make the interrupt on wake up OMAP which is in suspend mode */
ret = enable_irq_wake(gpio_to_irq(PROXI_OUT));
if(ret < 0){
printk(KERN_INFO "[Proximity INT] GPIO 14 wake up source setting failed!\n");
disable_irq_wake(gpio_to_irq(PROXI_OUT));
return -ENOSYS;
}
/* LGE_CHANGE_S, [email protected], 2011-04-06, Disable Proximity Log */
//printk(KERN_WARNING"%s() : interrupt mode. END\n", __func__);
/* LGE_CHANGE_E, [email protected], 2011-04-06, Disable Proximity Log */
// ret = request_irq(client->irq, hub_proxi_int_handler, IRQF_DISABLED | IRQF_TRIGGER_FALLING, "proxi_driver", data);
}
else {
hrtimer_init(&data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
data->timer.function = hub_proxi_timer_func;
data->delay = PROXI_DEFAULT_DELAY_NS;
//hrtimer_start(&data->timer, ktime_set(0, data->delay), HRTIMER_MODE_REL);
}
INIT_WORK(&data->work, hub_proxi_det_work);
/*LGE_CHANGE_S [[email protected]] 2010-01-04, ldoc control*/
#if defined(CONFIG_MACH_LGE_HEAVEN_REV_A)
reg = regulator_get(dev, "vaux3");
if (reg == NULL) {
printk(KERN_ERR": Failed to get PROXI power resources !! \n");
return -ENODEV;
}
#elif defined(CONFIG_MACH_LGE_HUB)
reg = regulator_get(dev, "vaux2");
if (reg == NULL) {
printk(KERN_ERR": Failed to get PROXI power resources !! \n");
return -ENODEV;
}
#endif
/*LGE_CHANGE_S [[email protected]] 2010-01-04, ldoc control*/
//hub_proxi_power_onoff(1);
//hub_proxi_i2c_init(client);
data->client = client;
i2c_set_clientdata(client, data);
data->input_dev = input_allocate_device();
if (data->input_dev == NULL) {
printk(KERN_ERR "%s: input_allocate: not enough memory\n",
__FUNCTION__);
return -ENOMEM;
}
set_bit(EV_KEY, data->input_dev->evbit);
set_bit(KEY_POWER, data->input_dev->keybit);
set_bit(EV_ABS, data->input_dev->evbit);
input_set_abs_params(data->input_dev, ABS_DISTANCE, 0, 1, 0, 0);
data->input_dev->name = "proximity";
// 20101004 [email protected], fix initial operation of proximity sensor [START_LGE]
data->input_dev->abs[ABS_DISTANCE] = -1;
// 20101004 [email protected], fix initial operation of proximity sensor [END_LGE]
ret = input_register_device(data->input_dev);
if (ret) {
printk(KERN_ERR "%s: Fail to register device\n", __FUNCTION__);
goto ERROR1;
}
if ((ret = sysfs_create_group(&dev->kobj, &hub_proxi_group)))
goto ERROR3;
/* LGE_CHANGE_S, [email protected], 2011-04-13, Sync with P970 */
#ifdef CONFIG_HAS_EARLYSUSPEND /* 20110304 [email protected] late_resume_lcd [START] */
data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN - 1;
data->early_suspend.suspend = hub_proxi_early_suspend;
data->early_suspend.resume = hub_proxi_late_resume;
register_early_suspend(&data->early_suspend);
#endif /* 20110304 [email protected] late_resume_lcd [END] */
/* LGE_CHANGE_E, [email protected], 2011-04-13, Sync with P970 */
return 0;
ERROR3:
input_unregister_device(data->input_dev);
ERROR1:
kfree(data);
return ret;
}
static int cyttsp4_proximity_probe(struct cyttsp4_device *ttsp)
{
struct cyttsp4_proximity_data *pd;
struct device *dev = &ttsp->dev;
struct cyttsp4_proximity_platform_data *pdata = dev_get_platdata(dev);
int rc = 0;
dev_info(dev, "%s\n", __func__);
dev_dbg(dev, "%s: debug on\n", __func__);
dev_vdbg(dev, "%s: verbose debug on\n", __func__);
if (pdata == NULL) {
dev_err(dev, "%s: Missing platform data\n", __func__);
rc = -ENODEV;
goto error_no_pdata;
}
pd = kzalloc(sizeof(*pd), GFP_KERNEL);
if (pd == NULL) {
dev_err(dev, "%s: Error, kzalloc\n", __func__);
rc = -ENOMEM;
goto error_alloc_data_failed;
}
mutex_init(&pd->report_lock);
mutex_init(&pd->sysfs_lock);
pd->ttsp = ttsp;
pd->pdata = pdata;
dev_set_drvdata(dev, pd);
/* Create the input device and register it. */
dev_vdbg(dev, "%s: Create the input device and register it\n",
__func__);
pd->input = input_allocate_device();
if (pd->input == NULL) {
dev_err(dev, "%s: Error, failed to allocate input device\n",
__func__);
rc = -ENOSYS;
goto error_alloc_failed;
}
pd->input->name = ttsp->name;
scnprintf(pd->phys, sizeof(pd->phys)-1, "%s", dev_name(dev));
pd->input->phys = pd->phys;
pd->input->dev.parent = &pd->ttsp->dev;
input_set_drvdata(pd->input, pd);
pm_runtime_enable(dev);
/* get sysinfo */
pd->si = cyttsp4_request_sysinfo(ttsp);
if (pd->si) {
rc = cyttsp4_setup_input_device_and_sysfs(ttsp);
if (rc)
goto error_init_input;
} else {
dev_err(dev, "%s: Fail get sysinfo pointer from core p=%p\n",
__func__, pd->si);
cyttsp4_subscribe_attention(ttsp, CY_ATTEN_STARTUP,
cyttsp4_setup_input_attention, 0);
}
dev_dbg(dev, "%s: ok\n", __func__);
return 0;
error_init_input:
pm_runtime_suspend(dev);
pm_runtime_disable(dev);
input_free_device(pd->input);
error_alloc_failed:
dev_set_drvdata(dev, NULL);
kfree(pd);
error_alloc_data_failed:
error_no_pdata:
dev_err(dev, "%s failed.\n", __func__);
return rc;
}
static int __devinit twl6040_vibra_probe(struct platform_device *pdev)
{
struct twl6040_vibra_data *pdata = pdev->dev.platform_data;
struct vibra_info *info;
int ret;
if (!pdata) {
dev_err(&pdev->dev, "platform_data not available\n");
return -EINVAL;
}
info = kzalloc(sizeof(*info), GFP_KERNEL);
if (!info) {
dev_err(&pdev->dev, "couldn't allocate memory\n");
return -ENOMEM;
}
info->dev = &pdev->dev;
info->twl6040 = dev_get_drvdata(pdev->dev.parent);
info->vibldrv_res = pdata->vibldrv_res;
info->vibrdrv_res = pdata->vibrdrv_res;
info->viblmotor_res = pdata->viblmotor_res;
info->vibrmotor_res = pdata->vibrmotor_res;
if ((!info->vibldrv_res && !info->viblmotor_res) ||
(!info->vibrdrv_res && !info->vibrmotor_res)) {
dev_err(info->dev, "invalid vibra driver/motor resistance\n");
ret = -EINVAL;
goto err_kzalloc;
}
info->irq = platform_get_irq(pdev, 0);
if (info->irq < 0) {
dev_err(info->dev, "invalid irq\n");
ret = -EINVAL;
goto err_kzalloc;
}
mutex_init(&info->mutex);
info->input_dev = input_allocate_device();
if (info->input_dev == NULL) {
dev_err(info->dev, "couldn't allocate input device\n");
ret = -ENOMEM;
goto err_kzalloc;
}
input_set_drvdata(info->input_dev, info);
info->input_dev->name = "twl6040:vibrator";
info->input_dev->id.version = 1;
info->input_dev->dev.parent = pdev->dev.parent;
info->input_dev->close = twl6040_vibra_close;
__set_bit(FF_RUMBLE, info->input_dev->ffbit);
ret = input_ff_create_memless(info->input_dev, NULL, vibra_play);
if (ret < 0) {
dev_err(info->dev, "couldn't register vibrator to FF\n");
goto err_ialloc;
}
ret = input_register_device(info->input_dev);
if (ret < 0) {
dev_err(info->dev, "couldn't register input device\n");
goto err_iff;
}
platform_set_drvdata(pdev, info);
ret = request_threaded_irq(info->irq, NULL, twl6040_vib_irq_handler, 0,
"twl6040_irq_vib", info);
if (ret) {
dev_err(info->dev, "VIB IRQ request failed: %d\n", ret);
goto err_irq;
}
info->supplies[0].supply = "vddvibl";
info->supplies[1].supply = "vddvibr";
ret = regulator_bulk_get(info->dev, ARRAY_SIZE(info->supplies),
info->supplies);
if (ret) {
dev_err(info->dev, "couldn't get regulators %d\n", ret);
goto err_regulator;
}
if (pdata->vddvibl_uV) {
ret = regulator_set_voltage(info->supplies[0].consumer,
pdata->vddvibl_uV,
pdata->vddvibl_uV);
if (ret) {
dev_err(info->dev, "failed to set VDDVIBL volt %d\n",
ret);
goto err_voltage;
}
}
if (pdata->vddvibr_uV) {
ret = regulator_set_voltage(info->supplies[1].consumer,
pdata->vddvibr_uV,
pdata->vddvibr_uV);
if (ret) {
dev_err(info->dev, "failed to set VDDVIBR volt %d\n",
ret);
goto err_voltage;
}
}
info->workqueue = alloc_workqueue("twl6040-vibra", 0, 0);
if (info->workqueue == NULL) {
dev_err(info->dev, "couldn't create workqueue\n");
ret = -ENOMEM;
goto err_voltage;
}
INIT_WORK(&info->play_work, vibra_play_work);
return 0;
err_voltage:
regulator_bulk_free(ARRAY_SIZE(info->supplies), info->supplies);
err_regulator:
free_irq(info->irq, info);
err_irq:
input_unregister_device(info->input_dev);
info->input_dev = NULL;
err_iff:
if (info->input_dev)
input_ff_destroy(info->input_dev);
err_ialloc:
input_free_device(info->input_dev);
err_kzalloc:
kfree(info);
return ret;
}
static int __init wake_gestures_init(void)
{
int rc = 0;
rc = input_register_handler(&wg_input_handler);
if (rc)
pr_err("%s: Failed to register wg_input_handler\n", __func__);
s2w_input_wq = create_workqueue("s2wiwq");
if (!s2w_input_wq) {
pr_err("%s: Failed to create s2wiwq workqueue\n", __func__);
return -EFAULT;
}
INIT_WORK(&s2w_input_work, s2w_input_callback);
dt2w_input_wq = create_workqueue("dt2wiwq");
if (!dt2w_input_wq) {
pr_err("%s: Failed to create dt2wiwq workqueue\n", __func__);
return -EFAULT;
}
INIT_WORK(&dt2w_input_work, dt2w_input_callback);
wake_lock_init(&dt2w_wakelock, WAKE_LOCK_SUSPEND, "dt2w_wakelock");
#if (WAKE_GESTURES_ENABLED)
gesture_dev = input_allocate_device();
if (!gesture_dev) {
pr_err("Can't allocate gesture device\n");
goto err_alloc_dev;
}
gesture_dev->name = "wake_gesture";
gesture_dev->phys = "wake_gesture/input0";
input_set_capability(gesture_dev, EV_REL, WAKE_GESTURE);
rc = input_register_device(gesture_dev);
if (rc) {
pr_err("%s: input_register_device err=%d\n", __func__, rc);
goto err_gesture_dev;
}
#endif
android_touch_kobj = kobject_create_and_add("android_touch", NULL) ;
if (android_touch_kobj == NULL) {
pr_warn("%s: android_touch_kobj create_and_add failed\n", __func__);
}
rc = sysfs_create_file(android_touch_kobj, &dev_attr_sweep2wake.attr);
if (rc) {
pr_warn("%s: sysfs_create_file failed for sweep2wake\n", __func__);
}
rc = sysfs_create_file(android_touch_kobj, &dev_attr_sweep2sleep.attr);
if (rc) {
pr_warn("%s: sysfs_create_file failed for sweep2sleep\n", __func__);
}
rc = sysfs_create_file(android_touch_kobj, &dev_attr_doubletap2wake.attr);
if (rc) {
pr_warn("%s: sysfs_create_file failed for doubletap2wake\n", __func__);
}
rc = sysfs_create_file(android_touch_kobj, &dev_attr_vib_strength.attr);
if (rc) {
pr_warn("%s: sysfs_create_file failed for vib_strength\n", __func__);
}
rc = sysfs_create_file(android_touch_kobj, &dev_attr_camera_gesture.attr);
if (rc) {
pr_warn("%s: sysfs_create_file failed for camera_gesture\n", __func__);
}
#if (WAKE_GESTURES_ENABLED)
rc = sysfs_create_file(android_touch_kobj, &dev_attr_wake_gestures.attr);
if (rc) {
pr_warn("%s: sysfs_create_file failed for wake_gestures\n", __func__);
}
return 0;
err_gesture_dev:
input_free_device(gesture_dev);
err_alloc_dev:
#endif
return 0;
}
static int __devinit omap4_keypad_probe(struct platform_device *pdev)
{
const struct omap4_keypad_platform_data *pdata;
struct omap4_keypad *keypad_data;
struct input_dev *input_dev;
struct resource *res;
resource_size_t size;
unsigned int row_shift, max_keys;
int irq;
int error;
/* platform data */
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "no platform data defined\n");
return -EINVAL;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "no base address specified\n");
return -EINVAL;
}
irq = platform_get_irq(pdev, 0);
if (!irq) {
dev_err(&pdev->dev, "no keyboard irq assigned\n");
return -EINVAL;
}
if (!pdata->keymap_data) {
dev_err(&pdev->dev, "no keymap data defined\n");
return -EINVAL;
}
row_shift = get_count_order(pdata->cols);
max_keys = pdata->rows << row_shift;
keypad_data = kzalloc(sizeof(struct omap4_keypad) +
max_keys * sizeof(keypad_data->keymap[0]),
GFP_KERNEL);
if (!keypad_data) {
dev_err(&pdev->dev, "keypad_data memory allocation failed\n");
return -ENOMEM;
}
size = resource_size(res);
res = request_mem_region(res->start, size, pdev->name);
if (!res) {
dev_err(&pdev->dev, "can't request mem region\n");
error = -EBUSY;
goto err_free_keypad;
}
keypad_data->base = ioremap(res->start, resource_size(res));
if (!keypad_data->base) {
dev_err(&pdev->dev, "can't ioremap mem resource\n");
error = -ENOMEM;
goto err_release_mem;
}
keypad_data->irq = irq;
keypad_data->row_shift = row_shift;
keypad_data->rows = pdata->rows;
keypad_data->cols = pdata->cols;
/* input device allocation */
keypad_data->input = input_dev = input_allocate_device();
if (!input_dev) {
error = -ENOMEM;
goto err_unmap;
}
input_dev->name = pdev->name;
input_dev->dev.parent = &pdev->dev;
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0001;
input_dev->open = omap4_keypad_open;
input_dev->close = omap4_keypad_close;
input_dev->keycode = keypad_data->keymap;
input_dev->keycodesize = sizeof(keypad_data->keymap[0]);
input_dev->keycodemax = max_keys;
__set_bit(EV_KEY, input_dev->evbit);
__set_bit(EV_REP, input_dev->evbit);
input_set_capability(input_dev, EV_MSC, MSC_SCAN);
input_set_drvdata(input_dev, keypad_data);
matrix_keypad_build_keymap(pdata->keymap_data, row_shift,
input_dev->keycode, input_dev->keybit);
error = request_irq(keypad_data->irq, omap4_keypad_interrupt,
IRQF_TRIGGER_RISING,
"omap4-keypad", keypad_data);
if (error) {
dev_err(&pdev->dev, "failed to register interrupt\n");
goto err_free_input;
}
pm_runtime_enable(&pdev->dev);
error = input_register_device(keypad_data->input);
if (error < 0) {
dev_err(&pdev->dev, "failed to register input device\n");
goto err_pm_disable;
}
platform_set_drvdata(pdev, keypad_data);
return 0;
err_pm_disable:
pm_runtime_disable(&pdev->dev);
free_irq(keypad_data->irq, keypad_data);
err_free_input:
input_free_device(input_dev);
err_unmap:
iounmap(keypad_data->base);
err_release_mem:
release_mem_region(res->start, size);
err_free_keypad:
kfree(keypad_data);
return error;
}
/**
* snd_jack_new - Create a new jack
* @card: the card instance
* @id: an identifying string for this jack
* @type: a bitmask of enum snd_jack_type values that can be detected by
* this jack
* @jjack: Used to provide the allocated jack object to the caller.
*
* Creates a new jack object.
*
* Returns zero if successful, or a negative error code on failure.
* On success jjack will be initialised.
*/
int snd_jack_new(struct snd_card *card, const char *id, int type,
struct snd_jack **jjack)
{
struct snd_jack *jack;
int err;
int i;
static struct snd_device_ops ops = {
.dev_free = snd_jack_dev_free,
.dev_register = snd_jack_dev_register,
};
jack = kzalloc(sizeof(struct snd_jack), GFP_KERNEL);
if (jack == NULL)
return -ENOMEM;
jack->id = kstrdup(id, GFP_KERNEL);
// AUD_MOD start
if( !strcmp(jack->id, "Headset Jack"))
{
printk("Headset Jack swdev register\n");
jack->swdev.name = "h2w";
jack->swdev.print_name = simple_remote_print_name;
err = switch_dev_register(&jack->swdev);
if (err < 0) {
printk("switch_dev_register failed:%d\n", err);
}
}
else if( !strcmp(jack->id, "Button Jack"))
{
printk("Button Jack swdev register\n");
jack->swdev.name = "h2w_Bt";
jack->swdev.print_name = simple_remote_print_name;
err = switch_dev_register(&jack->swdev);
if (err < 0) {
printk("switch_dev_register failed:%d\n", err);
}
}
// SoMC Uevent End
// SoMC Input Event Start
jack->indev_appkey = input_allocate_device();
if (jack->indev_appkey == NULL) {
err = -ENOMEM;
goto fail_input;
}
jack->indev_appkey->phys = "ALSA";
jack->type = type;
for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++)
if (type & (1 << i))
input_set_capability(jack->indev_appkey, EV_SW,
jack_switch_types[i]);
// AUD_MOD end
jack->input_dev = input_allocate_device();
if (jack->input_dev == NULL) {
err = -ENOMEM;
goto fail_input;
}
jack->input_dev->phys = "ALSA";
jack->type = type;
for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++)
if (type & (1 << i))
input_set_capability(jack->input_dev, EV_SW,
jack_switch_types[i]);
err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
if (err < 0)
goto fail_input;
*jjack = jack;
return 0;
fail_input:
input_free_device(jack->indev_appkey); // AUD_MOD
input_free_device(jack->input_dev);
kfree(jack->id);
kfree(jack);
return err;
}
static int lge_hsd_probe(struct platform_device *pdev)
{
int ret = 0;
struct max1462x_platform_data *pdata = pdev->dev.platform_data;
struct hsd_info *hi;
HSD_DBG("lge_hsd_probe\n");
hi = kzalloc(sizeof(struct hsd_info), GFP_KERNEL);
if ( hi == NULL) {
HSD_ERR("Failed to allloate headset per device info\n");
return -ENOMEM;
}
if(pdev->dev.of_node){
pdata = devm_kzalloc(&pdev->dev,sizeof(struct max1462x_platform_data),GFP_KERNEL);
if(!pdata){
HSD_ERR("Failed to allocate memory\n");
return -ENOMEM;
}
pdev->dev.platform_data = pdata;
max1462x_parse_dt(&pdev->dev,pdata);
} else {
pdata = devm_kzalloc(&pdev->dev,sizeof(struct max1462x_platform_data),GFP_KERNEL);
if(!pdata){
HSD_ERR("Failed to allocate memory\n");
return -ENOMEM;
}
else
pdata = pdev->dev.platform_data;
}
hi->key_code = pdata->key_code;
platform_set_drvdata(pdev, hi);
atomic_set(&hi->btn_state, 0);
atomic_set(&hi->is_3_pole_or_not, 1);
atomic_set(&hi->irq_key_enabled, FALSE);
hi->gpio_mic_en = pdata->gpio_mic_en;
hi->gpio_detect = pdata->gpio_detect;
hi->gpio_key = pdata->gpio_key;
hi->gpio_set_value_func = pdata->gpio_set_value_func;
hi->gpio_get_value_func = pdata->gpio_get_value_func;
#ifdef CONFIG_SWITCH_MAX1462X_WA
hi->latency_for_key = msecs_to_jiffies(50);
#else
hi->latency_for_key = msecs_to_jiffies(50); /* convert milli to jiffies */
#endif
mutex_init(&hi->mutex_lock);
INIT_WORK(&hi->work, detect_work);
INIT_DELAYED_WORK(&hi->work_for_key_pressed, button_pressed);
INIT_DELAYED_WORK(&hi->work_for_key_released, button_released);
ret = gpio_request(hi->gpio_mic_en, "gpio_mic_en");
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_mic_en) gpio_request\n", hi->gpio_mic_en);
goto error_02;
}
ret = gpio_direction_output(hi->gpio_mic_en, 0);
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_mic_en) gpio_direction_input\n", hi->gpio_mic_en);
goto error_02;
}
HSD_DBG("gpio_get_value_cansleep(hi->gpio_mic_en) = %d\n", gpio_get_value_cansleep(hi->gpio_mic_en));
/* init gpio_detect */
ret = gpio_request(hi->gpio_detect, "gpio_detect");
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_det) gpio_request\n", hi->gpio_detect);
goto error_03;
}
ret = gpio_direction_input(hi->gpio_detect);
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_det) gpio_direction_input\n", hi->gpio_detect);
goto error_03;
}
/*init gpio_key */
ret = gpio_request(hi->gpio_key, "gpio_key");
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_key) gpio_request\n", hi->gpio_key);
goto error_04;
}
ret = gpio_direction_input(hi->gpio_key);
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_key) gpio_direction_input\n", hi->gpio_key);
goto error_04;
}
/* initialize irq of gpio_key */
hi->irq_key = gpio_to_irq(hi->gpio_key);
HSD_DBG("hi->irq_key = %d\n", hi->irq_key);
if (hi->irq_key < 0) {
HSD_ERR("Failed to get interrupt number\n");
ret = hi->irq_key;
goto error_06;
}
ret = request_threaded_irq(hi->irq_key, NULL, button_irq_handler,
IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, pdev->name, hi);
if (ret) {
HSD_ERR("failed to request button irq\n");
goto error_06;
}
ret = irq_set_irq_wake(hi->irq_key, 1);
if (ret < 0) {
HSD_ERR("Failed to set irq_key interrupt wake\n");
goto error_06;
}
enable_irq(hi->irq_key);
hi->irq_detect = gpio_to_irq(hi->gpio_detect);
HSD_DBG("hi->irq_detect = %d\n", hi->irq_detect);
if (hi->irq_detect < 0) {
HSD_ERR("Failed to get interrupt number\n");
ret = hi->irq_detect;
goto error_07;
}
ret = request_threaded_irq(hi->irq_detect, NULL, earjack_det_irq_handler,
IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, pdev->name, hi);
if (ret) {
HSD_ERR("failed to request button irq\n");
goto error_07;
}
ret = irq_set_irq_wake(hi->irq_detect, 1);
if (ret < 0) {
HSD_ERR("Failed to set gpio_detect interrupt wake\n");
goto error_07;
}
/* initialize switch device */
hi->sdev.name = pdata->switch_name;
hi->sdev.print_state = lge_hsd_print_state;
hi->sdev.print_name = lge_hsd_print_name;
ret = switch_dev_register(&hi->sdev);
if (ret < 0) {
HSD_ERR("Failed to register switch device\n");
goto error_08;
}
/* initialize input device */
hi->input = input_allocate_device();
if (!hi->input) {
HSD_ERR("Failed to allocate input device\n");
ret = -ENOMEM;
goto error_09;
}
hi->input->name = pdata->keypad_name;
hi->input->id.vendor = 0x0001;
hi->input->id.product = 1;
hi->input->id.version = 1;
#ifdef CONFIG_SWITCH_MAX1462X_WA
setup_timer( &hi->hook_disable_timer, hook_disable_timer_func, 0 );
hook_disable = 0;
#endif
/* headset tx noise */
{
struct qpnp_vadc_result result;
int acc_read_value = 0;
int i, rc;
int count = 3;
for (i = 0; i < count; i++)
{
rc = qpnp_vadc_read(P_MUX6_1_1,&result);
if (rc < 0)
{
if (rc == -ETIMEDOUT) {
pr_err("[DEBUG]adc read timeout \n");
} else {
pr_err("[DEBUG]adc read error - %d\n", rc);
}
}
else
{
acc_read_value = (int)result.physical;
pr_info("%s: acc_read_value - %d\n", __func__, (int)result.physical);
break;
}
}
}
set_bit(EV_SYN, hi->input->evbit);
set_bit(EV_KEY, hi->input->evbit);
set_bit(EV_SW, hi->input->evbit);
set_bit(hi->key_code, hi->input->keybit);
set_bit(SW_HEADPHONE_INSERT, hi->input->swbit);
set_bit(SW_MICROPHONE_INSERT, hi->input->swbit);
input_set_capability(hi->input, EV_KEY, KEY_MEDIA);
input_set_capability(hi->input, EV_KEY, KEY_VOLUMEUP);
input_set_capability(hi->input, EV_KEY, KEY_VOLUMEDOWN);
ret = input_register_device(hi->input);
if (ret) {
HSD_ERR("Failed to register input device\n");
goto error_09;
}
if (!(hi->gpio_get_value_func(hi->gpio_detect)))
#ifdef CONFIG_MAX1462X_USE_LOCAL_WORK_QUEUE
/* to detect in initialization with eacjack insertion */
queue_work(local_max1462x_workqueue, &(hi->work));
#else
/* to detect in initialization with eacjack insertion */
schedule_work(&(hi->work));
#endif
zw_irqs_info_register(hi->irq_key, 1);
zw_irqs_info_register(hi->irq_detect, 1);
return ret;
error_09:
input_free_device(hi->input);
error_08:
switch_dev_unregister(&hi->sdev);
error_07:
free_irq(hi->irq_detect, 0);
error_06:
free_irq(hi->irq_key, 0);
error_04:
gpio_free(hi->gpio_key);
error_03:
gpio_free(hi->gpio_detect);
error_02:
gpio_free(hi->gpio_mic_en);
kfree(hi);
return ret;
}
static int synaptics_rmi4_prox_init(struct synaptics_rmi4_data *rmi4_data)
{
int retval;
unsigned char attr_count;
prox = kzalloc(sizeof(*prox), GFP_KERNEL);
if (!prox) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to alloc mem for prox\n",
__func__);
retval = -ENOMEM;
goto exit;
}
prox->finger_data = kzalloc(sizeof(*(prox->finger_data)), GFP_KERNEL);
if (!prox->finger_data) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to alloc mem for finger_data\n",
__func__);
retval = -ENOMEM;
goto exit_free_prox;
}
prox->rmi4_data = rmi4_data;
retval = prox_scan_pdt();
if (retval < 0)
goto exit_free_finger_data;
prox->hover_finger_en = true;
retval = prox_set_hover_finger_en();
if (retval < 0)
return retval;
prox->prox_dev = input_allocate_device();
if (prox->prox_dev == NULL) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to allocate proximity device\n",
__func__);
retval = -ENOMEM;
goto exit_free_finger_data;
}
prox->prox_dev->name = PLATFORM_DRIVER_NAME;
prox->prox_dev->phys = PROX_PHYS_NAME;
prox->prox_dev->id.product = SYNAPTICS_DSX_DRIVER_PRODUCT;
prox->prox_dev->id.version = SYNAPTICS_DSX_DRIVER_VERSION;
prox->prox_dev->dev.parent = rmi4_data->pdev->dev.parent;
input_set_drvdata(prox->prox_dev, rmi4_data);
set_bit(EV_KEY, prox->prox_dev->evbit);
set_bit(EV_ABS, prox->prox_dev->evbit);
set_bit(BTN_TOUCH, prox->prox_dev->keybit);
set_bit(BTN_TOOL_FINGER, prox->prox_dev->keybit);
#ifdef INPUT_PROP_DIRECT
set_bit(INPUT_PROP_DIRECT, prox->prox_dev->propbit);
#endif
prox_set_params();
retval = input_register_device(prox->prox_dev);
if (retval) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to register proximity device\n",
__func__);
goto exit_free_input_device;
}
for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) {
retval = sysfs_create_file(&rmi4_data->input_dev->dev.kobj,
&attrs[attr_count].attr);
if (retval < 0) {
dev_err(rmi4_data->pdev->dev.parent,
"%s: Failed to create sysfs attributes\n",
__func__);
goto exit_free_sysfs;
}
}
return 0;
exit_free_sysfs:
for (attr_count--; attr_count >= 0; attr_count--) {
sysfs_remove_file(&rmi4_data->input_dev->dev.kobj,
&attrs[attr_count].attr);
}
input_unregister_device(prox->prox_dev);
prox->prox_dev = NULL;
exit_free_input_device:
if (prox->prox_dev)
input_free_device(prox->prox_dev);
exit_free_finger_data:
kfree(prox->finger_data);
exit_free_prox:
kfree(prox);
prox = NULL;
exit:
return retval;
}
static int rockchip_headsetobserve_probe(struct platform_device *pdev)
{
int ret;
struct headset_priv *headset;
struct rk_headset_pdata *pdata;
headset = kzalloc(sizeof(struct headset_priv), GFP_KERNEL);
if (headset == NULL) {
dev_err(&pdev->dev, "failed to allocate driver data\n");
return -ENOMEM;
}
headset_info = headset;
headset->pdata = pdev->dev.platform_data;
pdata = headset->pdata;
headset->headset_status = HEADSET_OUT;
headset->heatset_irq_working = IDLE;
headset->hook_status = HOOK_UP;
headset->hook_time = HOOK_ADC_SAMPLE_TIME;
headset->cur_headset_status = 0;
headset->sdev.name = "h2w";
headset->sdev.print_name = h2w_print_name;
ret = switch_dev_register(&headset->sdev);
if (ret < 0)
goto failed_free;
// mutex_init(&headset->mutex_lock[HEADSET]);
// mutex_init(&headset->mutex_lock[HOOK]);
wake_lock_init(&headset->headset_on_wake, WAKE_LOCK_SUSPEND, "headset_on_wake");
INIT_DELAYED_WORK(&headset->h_delayed_work[HEADSET], headsetobserve_work);
headset->isMic = 0;
//------------------------------------------------------------------
// Create and register the input driver.
headset->input_dev = input_allocate_device();
if (!headset->input_dev) {
dev_err(&pdev->dev, "failed to allocate input device\n");
ret = -ENOMEM;
goto failed_free;
}
headset->input_dev->name = pdev->name;
headset->input_dev->open = rk_Hskey_open;
headset->input_dev->close = rk_Hskey_close;
headset->input_dev->dev.parent = &pdev->dev;
//input_dev->phys = KEY_PHYS_NAME;
headset->input_dev->id.vendor = 0x0001;
headset->input_dev->id.product = 0x0001;
headset->input_dev->id.version = 0x0100;
// Register the input device
ret = input_register_device(headset->input_dev);
if (ret) {
dev_err(&pdev->dev, "failed to register input device\n");
goto failed_free_dev;
}
input_set_capability(headset->input_dev, EV_KEY, pdata->hook_key_code);
//------------------------------------------------------------------
if (pdata->Headset_gpio) {
if(pdata->Headset_gpio == NULL){
dev_err(&pdev->dev,"failed init headset,please full hook_io_init function in board\n");
goto failed_free_dev;
}
ret = pdata->headset_io_init(pdata->Headset_gpio);
if (ret)
goto failed_free_dev;
headset->irq[HEADSET] = gpio_to_irq(pdata->Headset_gpio);
if(pdata->headset_in_type == HEADSET_IN_HIGH)
headset->irq_type[HEADSET] = IRQF_TRIGGER_HIGH|IRQF_ONESHOT;
else
headset->irq_type[HEADSET] = IRQF_TRIGGER_LOW|IRQF_ONESHOT;
ret = request_threaded_irq(headset->irq[HEADSET], NULL,headset_interrupt, headset->irq_type[HEADSET]|IRQF_NO_SUSPEND, "headset_input", NULL);
if (ret)
goto failed_free_dev;
enable_irq_wake(headset->irq[HEADSET]);
}
else
goto failed_free_dev;
//------------------------------------------------------------------
if(pdata->Hook_adc_chn>=0 && 3>=pdata->Hook_adc_chn)
{
headset->client = adc_register(pdata->Hook_adc_chn, hook_adc_callback, (void *)headset);
if(!headset->client) {
printk("hook adc register error\n");
ret = -EINVAL;
goto failed_free_dev;
}
setup_timer(&headset->hook_timer,hook_timer_callback, (unsigned long)headset);
printk("headset adc default value = %d\n",adc_sync_read(headset->client));
}
#ifdef CONFIG_HAS_EARLYSUSPEND
hs_early_suspend.suspend = NULL;
hs_early_suspend.resume = headset_early_resume;
hs_early_suspend.level = ~0x0;
register_early_suspend(&hs_early_suspend);
#endif
return 0;
failed_free_dev:
platform_set_drvdata(pdev, NULL);
input_free_device(headset->input_dev);
failed_free:
dev_err(&pdev->dev, "failed to headset probe\n");
kfree(headset);
return ret;
}
static int opencores_kbd_probe(struct platform_device *pdev)
{
struct input_dev *input;
struct opencores_kbd *opencores_kbd;
struct resource *res;
int irq, i, error;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "missing board memory resource\n");
return -EINVAL;
}
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(&pdev->dev, "missing board IRQ resource\n");
return -EINVAL;
}
opencores_kbd = kzalloc(sizeof(*opencores_kbd), GFP_KERNEL);
input = input_allocate_device();
if (!opencores_kbd || !input) {
dev_err(&pdev->dev, "failed to allocate device structures\n");
error = -ENOMEM;
goto err_free_mem;
}
opencores_kbd->addr_res = res;
res = request_mem_region(res->start, resource_size(res), pdev->name);
if (!res) {
dev_err(&pdev->dev, "failed to request I/O memory\n");
error = -EBUSY;
goto err_free_mem;
}
opencores_kbd->addr = ioremap(res->start, resource_size(res));
if (!opencores_kbd->addr) {
dev_err(&pdev->dev, "failed to remap I/O memory\n");
error = -ENXIO;
goto err_rel_mem;
}
opencores_kbd->input = input;
opencores_kbd->irq = irq;
input->name = pdev->name;
input->phys = "opencores-kbd/input0";
input->dev.parent = &pdev->dev;
input_set_drvdata(input, opencores_kbd);
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
input->keycode = opencores_kbd->keycodes;
input->keycodesize = sizeof(opencores_kbd->keycodes[0]);
input->keycodemax = ARRAY_SIZE(opencores_kbd->keycodes);
__set_bit(EV_KEY, input->evbit);
for (i = 0; i < ARRAY_SIZE(opencores_kbd->keycodes); i++) {
/*
* OpenCores controller happens to have scancodes match
* our KEY_* definitions.
*/
opencores_kbd->keycodes[i] = i;
__set_bit(opencores_kbd->keycodes[i], input->keybit);
}
__clear_bit(KEY_RESERVED, input->keybit);
error = request_irq(irq, &opencores_kbd_isr,
IRQF_TRIGGER_RISING, pdev->name, opencores_kbd);
if (error) {
dev_err(&pdev->dev, "unable to claim irq %d\n", irq);
goto err_unmap_mem;
}
error = input_register_device(input);
if (error) {
dev_err(&pdev->dev, "unable to register input device\n");
goto err_free_irq;
}
platform_set_drvdata(pdev, opencores_kbd);
return 0;
err_free_irq:
free_irq(irq, opencores_kbd);
err_unmap_mem:
iounmap(opencores_kbd->addr);
err_rel_mem:
release_mem_region(res->start, resource_size(res));
err_free_mem:
input_free_device(input);
kfree(opencores_kbd);
return error;
}
static int __init hdaps_init(void)
{
int ret;
/* Determine axis orientation orientation */
if (hdaps_invert == HDAPS_ORIENT_UNDEFINED) /* set by module param? */
if (dmi_check_system(hdaps_whitelist) < 1) /* in whitelist? */
hdaps_invert = 0; /* default */
/* Init timer before platform_driver_register, in case of suspend */
init_timer(&hdaps_timer);
hdaps_timer.function = hdaps_mousedev_poll;
ret = platform_driver_register(&hdaps_driver);
if (ret)
goto out;
pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
if (IS_ERR(pdev)) {
ret = PTR_ERR(pdev);
goto out_driver;
}
ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
if (ret)
goto out_device;
hdaps_idev = input_allocate_device();
if (!hdaps_idev) {
ret = -ENOMEM;
goto out_group;
}
hdaps_idev_raw = input_allocate_device();
if (!hdaps_idev_raw) {
ret = -ENOMEM;
goto out_idev_first;
}
/* calibration for the input device (deferred to avoid delay) */
needs_calibration = 1;
/* initialize the joystick-like fuzzed input device */
hdaps_idev->name = "hdaps";
hdaps_idev->phys = "hdaps/input0";
hdaps_idev->id.bustype = BUS_HOST;
hdaps_idev->id.vendor = HDAPS_INPUT_VENDOR;
hdaps_idev->id.product = HDAPS_INPUT_PRODUCT;
hdaps_idev->id.version = HDAPS_INPUT_JS_VERSION;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
hdaps_idev->cdev.dev = &pdev->dev;
#endif
hdaps_idev->evbit[0] = BIT(EV_ABS);
hdaps_idev->open = hdaps_mousedev_open;
hdaps_idev->close = hdaps_mousedev_close;
input_set_abs_params(hdaps_idev, ABS_X,
-256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
input_set_abs_params(hdaps_idev, ABS_Y,
-256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
ret = input_register_device(hdaps_idev);
if (ret)
goto out_idev;
/* initialize the raw data input device */
hdaps_idev_raw->name = "raw_hdaps_data";
hdaps_idev_raw->phys = "hdaps/input1";
hdaps_idev_raw->id.bustype = BUS_HOST;
hdaps_idev_raw->id.vendor = HDAPS_INPUT_VENDOR;
hdaps_idev_raw->id.product = HDAPS_INPUT_PRODUCT;
hdaps_idev_raw->id.version = HDAPS_INPUT_RAW_VERSION;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
hdaps_idev_raw->cdev.dev = &pdev->dev;
#endif
hdaps_idev_raw->evbit[0] = BIT(EV_ABS);
hdaps_idev_raw->open = hdaps_mousedev_open;
hdaps_idev_raw->close = hdaps_mousedev_close;
input_set_abs_params(hdaps_idev_raw, ABS_X, -32768, 32767, 0, 0);
input_set_abs_params(hdaps_idev_raw, ABS_Y, -32768, 32767, 0, 0);
ret = input_register_device(hdaps_idev_raw);
if (ret)
goto out_idev_reg_first;
printk(KERN_INFO "hdaps: driver successfully loaded.\n");
return 0;
out_idev_reg_first:
input_unregister_device(hdaps_idev);
out_idev:
input_free_device(hdaps_idev_raw);
out_idev_first:
input_free_device(hdaps_idev);
out_group:
sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
out_device:
platform_device_unregister(pdev);
out_driver:
platform_driver_unregister(&hdaps_driver);
hdaps_device_shutdown();
out:
printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
return ret;
}
static int hv_keypad_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct input_dev *input_dev;
int err = 0;
int i;
printk("======================================hv_keypad_probe Begin=============================================\n");
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
err = -ENODEV;
goto exit_check_functionality_failed;
}
hv_keypad = kzalloc(sizeof(*hv_keypad), GFP_KERNEL);
if (!hv_keypad) {
err = -ENOMEM;
goto exit_alloc_data_failed;
}
this_client = client;
i2c_set_clientdata(client, hv_keypad);
hv_init();
INIT_DELAYED_WORK(&hv_keypad->work, hv_read_loop);
hv_keypad->queue = create_singlethread_workqueue(dev_name(&client->dev));
if (!hv_keypad->queue) {
err = -ESRCH;
goto exit_create_singlethread;
}
input_dev = input_allocate_device();
if (!input_dev) {
err = -ENOMEM;
dev_err(&client->dev, "failed to allocate input device\n");
goto exit_input_dev_alloc_failed;
}
hv_keypad->input_dev = input_dev;
input_dev->name = HV_NAME;
input_dev->phys = "sun4ikbd/inputx";
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0100;
input_dev->evbit[0] = BIT_MASK(EV_KEY);
for (i = 1; i < 6; i++)
set_bit(i, input_dev->keybit);
err = input_register_device(input_dev);
if (err) {
dev_err(&client->dev,
"hv_ts_probe: failed to register input device: %s\n",
dev_name(&client->dev));
goto exit_input_register_device_failed;
}
queue_delayed_work(hv_keypad->queue, &hv_keypad->work, DELAY_PERIOD);
#ifdef CONFIG_HAS_EARLYSUSPEND
printk("==register_early_suspend =\n");
keyboard_data = kzalloc(sizeof(*keyboard_data), GFP_KERNEL);
if (keyboard_data == NULL) {
err = -ENOMEM;
goto err_alloc_data_failed;
}
keyboard_data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
keyboard_data->early_suspend.suspend = hv2605_keyboard_suspend;
keyboard_data->early_suspend.resume = hv2605_keyboard_resume;
register_early_suspend(&keyboard_data->early_suspend);
#endif
printk("==probe ======over =\n");
return 0;
exit_input_register_device_failed:
input_free_device(input_dev);
exit_input_dev_alloc_failed:
exit_create_singlethread:
printk("==singlethread error =\n");
i2c_set_clientdata(client, NULL);
kfree(hv_keypad);
exit_alloc_data_failed:
exit_check_functionality_failed:
#ifdef CONFIG_HAS_EARLYSUSPEND
err_alloc_data_failed:
#endif
return err;
}
static int __devinit hs_probe(struct platform_device *pdev)
{
int rc = 0;
struct input_dev *ipdev;
hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
if (!hs)
return -ENOMEM;
#ifndef CONFIG_LGE_HEADSET
hs->sdev.name = "h2w";
hs->sdev.print_name = msm_headset_print_name;
rc = switch_dev_register(&hs->sdev);
if (rc)
goto err_switch_dev_register;
#endif
ipdev = input_allocate_device();
if (!ipdev) {
rc = -ENOMEM;
goto err_alloc_input_dev;
}
input_set_drvdata(ipdev, hs);
hs->ipdev = ipdev;
if (pdev->dev.platform_data)
hs->hs_pdata = pdev->dev.platform_data;
if (hs->hs_pdata->hs_name)
ipdev->name = hs->hs_pdata->hs_name;
else
ipdev->name = DRIVER_NAME;
ipdev->id.vendor = 0x0001;
ipdev->id.product = 1;
ipdev->id.version = 1;
input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
#ifdef CONFIG_MACH_MSM7X27_ALOHAV
input_set_capability(ipdev, EV_SW, SW_MICROPHONE_INSERT);
#endif
input_set_capability(ipdev, EV_KEY, KEY_POWER);
input_set_capability(ipdev, EV_KEY, KEY_END);
rc = input_register_device(ipdev);
if (rc) {
dev_err(&ipdev->dev,
"hs_probe: input_register_device rc=%d\n", rc);
goto err_reg_input_dev;
}
platform_set_drvdata(pdev, hs);
rc = hs_rpc_init();
if (rc) {
dev_err(&ipdev->dev, "rpc init failure\n");
goto err_hs_rpc_init;
}
return 0;
err_hs_rpc_init:
input_unregister_device(ipdev);
ipdev = NULL;
err_reg_input_dev:
input_free_device(ipdev);
err_alloc_input_dev:
#ifndef CONFIG_LGE_HEADSET
switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
#endif
kfree(hs);
return rc;
}
