/*
   * Keypad driver for Cottonwood Creek Technologies Hook Switch
   *
   * Copyright 2014 Boundary Devices
   *
   * Licensed under the BSD or GPL-2 or later.
   */
  
  #include <linux/init.h>
  #include <linux/module.h>
  #include <linux/kernel.h>
  #include <linux/i2c.h>
  #include <linux/kthread.h>
  #include <linux/delay.h>
  #include <linux/input.h>
  
  #define CWC_HOOKSWITCH_I2C_BUS         2
  #define CWC_HOOKSWITCH_I2C_ADDR        0x20
  #define CWC_HOOKSWITCH_I2C_BITMASK     0x40
  #define CWC_HOOKSWITCH_POLL_INTERVAL   250
  #define CWC_HOOKSWITCH_KEY_INTERVAL    50
  
  static struct task_struct *thread;
  static int previous_offhook_state;
  static int previous_led_state;
  struct i2c_client *myclient;
  static struct input_dev *fake_keyboard_dev;
  
  static const char fake_input_name[] = "cwc_hookswitch";
  
  MODULE_DEVICE_TABLE(i2c, cwc_hookswitch_id);
  
  /*
   * ATTRIBUTES:
   *
   * /sys/devices/platform/cwc_hookswitch/offhook [ro]
   * /sys/devices/platform/cwc_hookswitch/leds [rw]
   */
  static ssize_t hookswitch_show_offhook
  	(struct device *dev,
  	 struct device_attribute *attr,
  	 char *buf)
  {
  	return sprintf(buf, "%d
  ", previous_offhook_state);
  }
  
  static ssize_t hookswitch_store_offhook
  	(struct device *dev,
  	 struct device_attribute *attr,
  	 const char *buf,
  	 size_t count)
  {
  	return -EINVAL;
  }
  
  static DEVICE_ATTR(offhook, S_IRUGO,
  		   hookswitch_show_offhook,
  		   hookswitch_store_offhook);
  
  static ssize_t hookswitch_show_leds
  	(struct device *dev,
  	 struct device_attribute *attr,
  	 char *buf)
  {
  	return sprintf(buf, "%d
  ", previous_led_state);
  }
  
  static ssize_t hookswitch_store_leds
          (struct device *dev,
           struct device_attribute *attr,
           const char *buf,
           size_t count)
  {
  	int state;
  	if (sscanf(buf, "%u", &state) == 1) {
  		if (2 > (unsigned)state) {
  			if (state != previous_led_state) {
  				i2c_smbus_write_byte_data
  					(myclient, 1, state ? 0x20 : 0);
  				previous_led_state = state;
  			}
  			return count;
  		}
  	}
  	return -EINVAL;
  }
  
  static DEVICE_ATTR(leds, S_IWUGO | S_IRUGO,
  		   hookswitch_show_leds,
  		   hookswitch_store_leds);
  
  static struct attribute *hookswitch_attrs[] = {
  	&dev_attr_offhook.attr,
  	&dev_attr_leds.attr,
  	NULL,
  };
  
  static struct attribute_group hookswitch_attr_group = {
  	.attrs = hookswitch_attrs,
  };
  
  static void cwc_read_hookstate(void)
  {
  	int data;
  	int offhook;
  	unsigned int key;
  
  	if (myclient != NULL) {
  		data = i2c_smbus_read_byte_data(myclient, 0);
  		offhook = ((data & CWC_HOOKSWITCH_I2C_BITMASK) == 0) ? 0 : 1;
  		if (previous_offhook_state >= 0) {
  			if (offhook != previous_offhook_state) {
  				pr_debug("hookswitch: raw: 0x%02x  offhook: %d
  ",
  					 data, offhook);
  
  				if (offhook)
  					key = KEY_KPLEFTPAREN;
  				else
  					key = KEY_KPRIGHTPAREN;
  
  				input_report_key(fake_keyboard_dev,
  						 KEY_LEFTCTRL, 1);
  				input_report_key(fake_keyboard_dev,
  						 KEY_LEFTALT, 1);
  				input_report_key(fake_keyboard_dev,
  						 key, 1);
  				input_sync(fake_keyboard_dev);
  				msleep(CWC_HOOKSWITCH_KEY_INTERVAL);
  				input_report_key(fake_keyboard_dev,
  						 KEY_LEFTCTRL, 0);
  				input_report_key(fake_keyboard_dev,
  						 KEY_LEFTALT, 0);
  				input_report_key(fake_keyboard_dev,
  						 key, 0);
  				input_sync(fake_keyboard_dev);
  			}
  		}
  		previous_offhook_state = offhook;
  	}
  }
  
  static int cwc_poll_thread(void *data)
  {
  	int ret = 0;
  
  	allow_signal(SIGINT);
  	while (!kthread_should_stop()) {
  		if (ret == -ERESTARTSYS) {
  			pr_info("%s: interrupted
  ", __func__);
  			return -EINTR;
  		}
  
  		cwc_read_hookstate();
  		msleep(CWC_HOOKSWITCH_POLL_INTERVAL);
  	}
  	return ret;
  }
  
  static int cwc_hookswitch_probe(struct i2c_client *client,
  				const struct i2c_device_id *id)
  {
  	int ret = 0;
  
  	myclient = client;
  	previous_offhook_state = -1;
  
  	i2c_smbus_write_byte_data(myclient, 3, 0xd0);
  	i2c_smbus_write_byte_data(myclient, 1, 0x0);
  	fake_keyboard_dev = input_allocate_device();
  	if (!fake_keyboard_dev) {
  		pr_err("%s() : cannot allocate fake keyboard: ", __func__);
  		return -ENOMEM;
  	}
  
  	set_bit(EV_KEY, fake_keyboard_dev->evbit);
  	set_bit(KEY_LEFTCTRL, fake_keyboard_dev->keybit);
  	set_bit(KEY_LEFTALT, fake_keyboard_dev->keybit);
  	set_bit(KEY_KPLEFTPAREN, fake_keyboard_dev->keybit);
  	set_bit(KEY_KPRIGHTPAREN, fake_keyboard_dev->keybit);
  
  	fake_keyboard_dev->name = fake_input_name;
  	fake_keyboard_dev->id.bustype = BUS_USB;
  	fake_keyboard_dev->id.vendor = 0x0525;
  	fake_keyboard_dev->id.product = 0xa4a0;
  	fake_keyboard_dev->id.version = 0x0001;
  
  	ret = input_register_device(fake_keyboard_dev);
  	if (ret)
  		pr_err(KERN_ERR "%s() : failed to register device
  ", __func__);
  
  	thread = kthread_run(cwc_poll_thread, NULL, "%s", KBUILD_MODNAME);
  	if (IS_ERR(thread))
  		ret = PTR_ERR(thread);
  
  	ret = sysfs_create_group(&fake_keyboard_dev->dev.kobj, &hookswitch_attr_group);
  	if (ret)
  		dev_err(&fake_keyboard_dev->dev, "sysfs export error: %d
  ", ret);
  
  	return ret;
  }
  
  static int cwc_hookswitch_remove(struct i2c_client *client)
  {
  	sysfs_remove_group(&fake_keyboard_dev->dev.kobj, &hookswitch_attr_group);
  	input_unregister_device(fake_keyboard_dev);
  
  	if (!IS_ERR_OR_NULL(thread))
  		kthread_stop(thread);
  
  	return 0;
  }
  
  static const struct i2c_device_id cwc_hookswitch_id[] = {
  	{"cwc_hookswitch", 0},
  	{"cwc_xx", 0},
  	{},
  };
  
  static struct i2c_driver cwc_hookswitch_i2c_driver = {
  	.driver = {
  		.owner = THIS_MODULE,
  		.name  = "cwc_hookswitch",
  	},
  	.probe  = cwc_hookswitch_probe,
  	.remove = cwc_hookswitch_remove,
  	.id_table = cwc_hookswitch_id,
  };
  
  static int cwc_hookswitch_init(void)
  {
  	return i2c_add_driver(&cwc_hookswitch_i2c_driver);
  }
  
  static void cwc_hookswitch_exit(void)
  {
  	i2c_del_driver(&cwc_hookswitch_i2c_driver);
  }
  
  module_init(cwc_hookswitch_init);
  module_exit(cwc_hookswitch_exit);
  
  MODULE_DESCRIPTION("CWC Tech Hook Switch");
  MODULE_LICENSE("Dual BSD/GPL");
  MODULE_ALIAS("platform:cwctech-keys");