Re: [alsa-devel] [PATCH v2 1/3] ECI: input: introduce ECI accessory input driver

Hi Tapio,

On Thu, Dec 30, 2010 at 03:36:57PM +0200, tapio.vihuri@nokia.com wrote:

From: Tapio Vihuri tapio.vihuri@nokia.com

ECI stands for (Enhancement Control Interface).

ECI is better known as Multimedia Headset for Nokia phones. If headset has many buttons, like play, vol+, vol- etc. then it is propably ECI accessory. Among several buttons ECI accessory contains memory for storing several parameters.

ECI input driver provides the following features:

• reading ECI configuration memory
• ECI buttons as input events

Signed-off-by: Tapio Vihuri tapio.vihuri@nokia.com

drivers/input/misc/Kconfig | 18 + drivers/input/misc/Makefile | 2 +- drivers/input/misc/eci.c | 1002 +++++++++++++++++++++++++++++++++++++++++++ include/linux/input/eci.h | 157 +++++++ 4 files changed, 1178 insertions(+), 1 deletions(-) create mode 100644 drivers/input/misc/eci.c create mode 100644 include/linux/input/eci.h

diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig index b99b8cb..7a15bc6 100644 --- a/drivers/input/misc/Kconfig +++ b/drivers/input/misc/Kconfig @@ -448,4 +448,22 @@ config INPUT_ADXL34X_SPI To compile this driver as a module, choose M here: the module will be called adxl34x-spi.

+config INPUT_ECI

• tristate "AV ECI (Enhancement Control Interface) input driver"
• help
• The Enhancement Control Interface functionality

•  ECI is better known as Multimedia Headset for Nokia phones.
  

•  If headset has many buttons, like play, vol+, vol- etc. then
  

•  it is propably ECI accessory.
  

•  Among several buttons ECI accessory contains memory for storing
  

•  several parameters.
  

•  ECI input driver provides the following features:
  

•  - reading ECI configuration memory
  

•  - ECI buttons as input events
  

•  Say 'y' here to statically link this module into the kernel or 'm'
  

•  to build it as a dynamically loadable module. The module will be
  

•  called eci.ko
  

endif diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile index 1fe1f6c..99d2289 100644 --- a/drivers/input/misc/Makefile +++ b/drivers/input/misc/Makefile @@ -42,4 +42,4 @@ obj-$(CONFIG_INPUT_WINBOND_CIR) += winbond-cir.o obj-$(CONFIG_INPUT_WISTRON_BTNS) += wistron_btns.o obj-$(CONFIG_INPUT_WM831X_ON) += wm831x-on.o obj-$(CONFIG_INPUT_YEALINK) += yealink.o

+obj-$(CONFIG_INPUT_ECI) += eci.o

Please keep Makefile and Kconfig sorted alphabetically.

diff --git a/drivers/input/misc/eci.c b/drivers/input/misc/eci.c new file mode 100644 index 0000000..72efccf --- /dev/null +++ b/drivers/input/misc/eci.c @@ -0,0 +1,1002 @@ +/*

• • This file is part of ECI (Enhancement Control Interface) accessory input
• • driver
• • Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
• • Contact: Tapio Vihuri tapio.vihuri@nokia.com
• • This program is free software; you can redistribute it and/or
• • modify it under the terms of the GNU General Public License
• • version 2 as published by the Free Software Foundation.
• • This program is distributed in the hope that it will be useful, but
• • WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
• • General Public License for more details.
• • You should have received a copy of the GNU General Public License
• • along with this program; if not, write to the Free Software
• • Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
• • 02110-1301 USA
• */

+/*

• • ECI stands for (Enhancement Control Interface).
• • ECI is better known as Multimedia Headset for Nokia phones.
• • If headset has many buttons, like play, vol+, vol- etc. then it is propably
• • ECI accessory.
• • Among several buttons ECI accessory contains memory for storing several
• • parameters.
• • ECI input driver provides the following features:
• • • reading ECI configuration memory
• • • ECI buttons as input events
• */

+#include <linux/init.h> +#include <linux/device.h> +#include <linux/platform_device.h> +#include <linux/interrupt.h> +#include <linux/slab.h> +#include <linux/i2c.h> +#include <linux/debugfs.h>

+#include <linux/input.h> +#include <linux/input/eci.h> +#include <linux/miscdevice.h>

+#define ECI_DRIVERNAME "ECI_accessory"

+#define ECI_WAIT_SEND_BUTTON 5 /* ms */ +#define ECI_WAIT_BUS_SETTLE 40 /* ms */ +#define ECI_TRY_GET_MEMORY 2000 /* ms */ +#define ECI_TRY_INIT_IO 200 /* ms */ +#define ECI_TRY_SET_MIC 200 /* ms */ +#define ECI_KEY_REPEAT_INTERVAL 400 /* ms */

+#define ECI_EKEY_BLOCK_ID 0xb3 +#define ECI_ENHANCEMENT_FEATURE_BLOCK_ID 0x02

+/* ECI Inputs */ +#define ECI_NIL_FEATURE 0x00 /* No feature */ +#define ECI_IGNS 0x01 /* Ignition Sense */ +#define ECI_CK_HANDSET_HOOK 0x02 /* Car-Kit Handset Hook */ +#define ECI_POWER_SUPPLY 0x03 /* Power Supply/Car Battery Det */ +#define ECI_EXT_AUD_IN 0x06 /* External audio In */ +#define ECI_SEND_END_VR 0x07 /* Send, End, and Voice Recogn */ +#define ECI_HD_PLUG 0x08 /* Headphone plug */ +#define ECI_DEV_POWER_REQ 0x0a /* Device Power Request */ +#define ECI_VOL_UP 0x0b /* Volume Up */ +#define ECI_VOL_DOWN 0x0c /* Volume Down */ +#define ECI_PLAY_PAUSE_CTRL 0x0d /* Play / Pause */ +#define ECI_STOP 0x0e /* Stop */ +#define ECI_NEXT_FF_AUTOSRC_UP 0x0f /* Next/Fast Fward/Autosearch up */ +#define ECI_PREV_REW_AUTOSEARCH_DOWN 0x10 /* Prev/Rewind/Autosearch down */ +#define ECI_POC 0x11 /* Push to Talk over Cellular */ +#define ECI_SYNC_BTN 0x14 /* Synchronization Button */ +#define ECI_MUSIC_RADIO_OFF_SELECTOR 0x15 /* Music/Radio/Off Selector */ +#define ECI_REDIAL 0x16 /* Redial */ +#define ECI_LEFT_SOFT_KEY 0x17 /* Left Soft Key */ +#define ECI_RIGHT_SOFT_KEY 0x18 /* Right Soft key */ +#define ECI_SEND_KEY 0x19 /* Send key */ +#define ECI_END_KEY 0x1a /* End key */ +#define ECI_MIDDLE_SOFT_KEY 0x1b /* Middle Soft key */ +#define ECI_UP 0x1c /* UP key/joystick direction */ +#define ECI_DOWN 0x1d /* DOWN key/joystick direction */ +#define ECI_RIGHT 0x1e /* RIGHT key/joystick direction */ +#define ECI_LEFT 0x1f /* LEFT key/joystick direction */ +#define ECI_SYMBIAN_NAVY_KEY 0x20 /* Symbian Application key */ +#define ECI_TERMINAL_APP_CTRL_IN 0x21 /* Terminal Applicat Ctrl Input */ +#define ECI_USB_CLASS_SWITCHING 0x23 /* USB Class Switching */ +#define ECI_MUTE 0x24 /* Mute */ +/* ECI Outputs */ +#define ECI_CRM 0x82 /* Car Radio Mute */ +#define ECI_PWR 0x83 /* Power */ +#define ECI_AUD_AMP 0x85 /* Audio Amplifier */ +#define ECI_EXT_AUD_SWITCH 0x86 /* External Audio Switch */ +#define ECI_HANDSET_AUDIO 0x87 /* Handset Audio */ +#define ECI_RING_INDICATOR 0x88 /* Ringing Indicator */ +#define ECI_CALL_ACTIVE 0x89 /* Call Active */ +#define ECI_ENHANCEMENT_DETECTED 0x8b /* Enhancement Detected */ +#define ECI_AUDIO_BLOCK_IN_USE 0x8e /* Audio Block In Use */ +#define ECI_STEREO_AUDIO_ACTIVE 0x8f /* stereo audio used in terminal */ +#define ECI_MONO_AUDIO_ACTIVE 0x90 /* mono audio used in terminal */ +#define ECI_TERMINAL_APP_CTRL_OUT 0x91 /* Terminal Applicat Ctrl Output */

+/*

• • Most of these are key events.
• • Switch event codes are put on top of keys (KEY_MAX ->)
• */

+static int eci_codes[] = {

• KEY_UNKNOWN, /* 0 ECI_NIL_FEATURE */
• KEY_UNKNOWN, /* 1 ECI_IGNS */
• KEY_UNKNOWN, /* 2 ECI_CK_HANDSET_HOOK */
• KEY_BATTERY, /* 3 ECI_POWER_SUPPLY */
• KEY_RESERVED, /* 4 ECI feature not defined */
• KEY_RESERVED, /* 5 ECI feature not defined */
• KEY_AUDIO, /* 6 ECI_EXT_AUD_IN */
• KEY_PHONE, /* 7 ECI_SEND_END_VR */
• KEY_MAX + SW_HEADPHONE_INSERT, /* 8 ECI_HD_PLUG, type switchs */
• KEY_RESERVED, /* 9 ECI feature not defined */
• KEY_UNKNOWN, /* 10 ECI_DEV_POWER_REQ */
• KEY_VOLUMEUP, /* 11 ECI_VOL_UP */
• KEY_VOLUMEDOWN, /* 12 ECI_VOL_DOWN */
• KEY_PLAYPAUSE, /* 13 ECI_PLAY_PAUSE_CTRL */
• KEY_STOP, /* 14 ECI_STOP */
• KEY_FORWARD, /* 15 ECI_NEXT_FF_AUTOSRC_UP */
• KEY_REWIND, /* 16 ECI_PREV_REW_AUTOSEARCH_DOWN */
• KEY_UNKNOWN, /* 17 ECI_POC */
• KEY_RESERVED, /* 18 ECI feature not defined */
• KEY_RESERVED, /* 19 ECI feature not defined */
• KEY_UNKNOWN, /* 20 ECI_SYNC_BTN */
• KEY_RADIO, /* 21 ECI_MUSIC_RADIO_OFF_SELECTOR */
• KEY_UNKNOWN, /* 22 ECI_REDIAL */
• KEY_UNKNOWN, /* 23 ECI_LEFT_SOFT_KEY */
• KEY_UNKNOWN, /* 24 ECI_RIGHT_SOFT_KEY */
• KEY_SEND, /* 25 ECI_SEND_KEY */
• KEY_END, /* 26 ECI_END_KEY */
• KEY_UNKNOWN, /* 27 ECI_MIDDLE_SOFT_KEY */
• KEY_UP, /* 28 ECI_UP */
• KEY_DOWN, /* 29 ECI_DOWN */
• KEY_RIGHT, /* 30 ECI_RIGHT */
• KEY_LEFT, /* 31 ECI_LEFT */
• KEY_UNKNOWN, /* 32 ECI_SYMBIAN_NAVY_KEY */
• KEY_UNKNOWN, /* 33 ECI_TERMINAL_APP_CTRL_IN */
• KEY_RESERVED, /* 34 ECI feature not defined */
• KEY_UNKNOWN, /* 35 ECI_USB_CLASS_SWITCHING */
• KEY_MUTE, /* 36 ECI_MUTE */

+};

Consider switching to sparse keymap library. You won't be needing ugly KEY_MAX + SW_XXX hacks and it will also support remapping keys from userspace.

+/* ECI accessory register's bits */ +#define ECI_MIC_AUTO 0x00 +#define ECI_MIC_OFF 0x5a +#define ECI_MIC_ON 0xff

+#define ECI_INT_ENABLE 1 +#define ECI_INT_DELAY_ENABLE (1<<1) +#define ECI_INT_LEN_76MS 0 +#define ECI_INT_LEN_82MS (1<<5) +#define ECI_INT_LEN_37MS (2<<5) +#define ECI_INT_LEN_19MS (3<<5) +#define ECI_INT_LEN_10MS (4<<5) +#define ECI_INT_LEN_5MS (5<<5) +#define ECI_INT_LEN_2MS (6<<5) +#define ECI_INT_LEN_120US (7<<5)

+struct eci_mem_block {

• u8 id;
• u8 len;
• u16 size;

+};

+static struct eci_cb eci_callback; +static struct audio_hsmic_event hsmic_event;

+static struct eci_data *the_eci;

+#ifdef CONFIG_DEBUG_FS +static void eci_accessory_event(int event, void *priv); +static void eci_hsmic_event(void *priv, bool on);

+static struct dentry *eci_debugfs_dir;

+static ssize_t mic_read(struct file *file, char __user *user_buf,

• size_t count, loff_t *ppos)
  

+{

• /* Assosiated in default_open() */
• struct eci_data *eci = file->private_data;
• char buf[80], *state;
• int len = 0;
• int ret;
• /* Do not run twice */
• if (*ppos == 0) {

• ret = eci->eci_hw_ops->acc_read_reg(ECICMD_MIC_CTRL, buf, 1);
  

• if (ret)
  

• 	return ret;
  

• eci->mic_state = buf[0];
  

• switch (eci->mic_state) {
  

• case ECI_MIC_AUTO:
  

• 	state = "auto";
  

• 	break;
  

• case ECI_MIC_OFF:
  

• 	state = "off";
  

• 	break;
  

• case ECI_MIC_ON:
  

• 	state = "on";
  

• 	break;
  

• default:
  

• 	state = "unknown";
  

• 	break;
  

• }
  

• len = snprintf(buf, sizeof(buf), "microphone %s\n", state);
  

• }
• ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
• return ret;

+}

+static ssize_t mic_write(struct file *file, const char __user *user_buf,

• size_t count, loff_t *ppos)
  

+{

• /* Assosiated in default_open() */
• struct eci_data *eci = file->private_data;
• char buf[80];
• int buf_size;
• buf_size = min(count, (sizeof(buf) - 1));
• if (copy_from_user(buf, user_buf, buf_size))

• return -EFAULT;
  

• if (!memcmp(buf, "auto", 4))

• eci_hsmic_event(eci, true);
  

• else if (!memcmp(buf, "off", 3))

• eci_hsmic_event(eci, false);
  

• else if (!memcmp(buf, "on", 2)) {

• eci->mic_state = ECI_MIC_ON;
  

• if (eci->eci_hw_ops->acc_write_reg(ECICMD_MIC_CTRL,
  

• 			eci->mic_state))
  

• 	dev_err(eci->dev, "Unable to control headset"
  

• 			"microphone\n");
  

Do not break strings on 80 column boundaries, wither align the arguments differently or just go past 80 columns, like this:

dev_err(eci->dev, "Unable to control headset microphone\n");

• }
• return count;

+}

+static int default_open(struct inode *inode, struct file *file) +{

• /* Assosiated in debugfs_create_file() */
• if (inode->i_private)

• file->private_data = inode->i_private;
  

• return 0;

+}

+static const struct file_operations mic_fops = {

• .open = default_open,
• .read = mic_read,
• .write = mic_write,

+};

+static void eci_uninitialize_debugfs(void) +{

• if (eci_debugfs_dir)

• debugfs_remove_recursive(eci_debugfs_dir);
  

+}

+static long eci_initialize_debugfs(struct eci_data *eci) +{

• void *ok;
• /* /sys/kernel/debug/ECI_accessory.# */
• eci_debugfs_dir = debugfs_create_dir(dev_name(eci->dev), NULL);
• if (!eci_debugfs_dir)

• return -ENOENT;
  

• /* Struct eci assosiated to inode->i_private */
• ok = debugfs_create_file("mic", S_IRUGO | S_IWUSR,

• 	eci_debugfs_dir, eci, &mic_fops);
  

• if (!ok)

• goto fail;
  

• return 0;

+fail:

• eci_uninitialize_debugfs();
• return -ENOENT;

+} +#else +#define eci_initialize_debugfs(eci) 1

Should be 0 I think, and not have a parameter, preferably

static inline int eci_initialize_debugfs(void) { return 0; }

+#define eci_uninitialize_debugfs() +#endif

+/* Returns size of accessory memory or error */ +static int eci_get_ekey(struct eci_data *eci, int *key) +{

• u8 buf[4];
• struct eci_mem_block *ekey = (void *)buf;
• int ret;
• /* Read always four bytes */
• ret = eci->eci_hw_ops->acc_read_direct(0, buf);
• if (ret)

• return ret;
  

• if (ekey->id != ECI_EKEY_BLOCK_ID)

• return -ENODEV;
  

• *key = cpu_to_be16(ekey->size);

cpu_to_be16()??? This looks really wierd.

• return 0;

+}

+static ssize_t show_eci_memory(struct device *dev,

• struct device_attribute *attr, char *buf)
  

+{

• if (!the_eci->mem_ok)

• return -ENXIO;
  

• memcpy(buf, the_eci->memory, the_eci->mem_size);
• return the_eci->mem_size;

+}

+static ssize_t show_cable_plugged(struct device *dev,

• struct device_attribute *attr, char *buf)
  

+{

• struct eci_data *eci = dev_get_drvdata(dev);
• return snprintf(buf, sizeof(buf), "Cable plugged %s\n",

• 		eci->plugged ? "in" : "out");
  

Should it be dsimple 0/1? How is this attribute supposed to be used?

+}

+static ssize_t store_cable_plugged(struct device *dev,

• struct device_attribute *attr,
  

• const char *buf, size_t len)
  

+{

• struct eci_data *eci = dev_get_drvdata(dev);
• if (!memcmp(buf, "in", 2)) {

• eci->plugged = true;
  

• eci_accessory_event(ECI_EVENT_PLUG_IN, eci);
  

• } else if (!memcmp(buf, "out", 3)) {

• eci->plugged = false;
  

• eci_accessory_event(ECI_EVENT_PLUG_OUT, eci);
  

• }

Same here. Should it be in debugfs probably?

• return len;

+}

+static DEVICE_ATTR(memory, S_IRUGO, show_eci_memory, NULL); +static DEVICE_ATTR(cable, S_IRUGO | S_IWUSR , show_cable_plugged,

• store_cable_plugged);
  

+static struct attribute *eci_attributes[] = {

• &dev_attr_memory.attr,
• &dev_attr_cable.attr,
• NULL

+};

+static struct attribute_group eci_attr_group = {

• .attrs = eci_attributes

+};

+/* Read ECI device memory into buffer */ +static int eci_get_memory(struct eci_data *eci, int *restart) +{

• int i, ret;
• for (i = *restart; i < eci->mem_size; i += 4) {

• ret = eci->eci_hw_ops->acc_read_direct(i, eci->memory + i);
  

• *restart = i;
  

• if (ret)
  

• 	return ret;
  

• }
• return ret;

+}

+/*

• • This should be really init_features, but most oftens these are just buttons
• */

+static int eci_init_buttons(struct eci_data *eci) +{

• struct enchancement_features_fixed *eff = eci->e_features_fix;
• u8 n, mireg;
• int ret;
• u8 buf[4];
• n = eff->number_of_features;
• if (n > ECI_MAX_FEATURE_COUNT)

• return -EINVAL;
  

• ret = eci->eci_hw_ops->acc_write_reg(ECICMD_MIC_CTRL, ECI_MIC_OFF);
• if (ret)

• return ret;
  

• ret = eci->eci_hw_ops->acc_read_reg(ECICMD_MASTER_INT_REG, buf, 1);
• if (ret)

• return ret;
  

• mireg = buf[0];
• mireg &= ~ECI_INT_ENABLE;
• mireg |= ECI_INT_LEN_120US | ECI_INT_DELAY_ENABLE;
• ret = eci->eci_hw_ops->acc_write_reg(ECICMD_MASTER_INT_REG, mireg);
• if (ret)

• return ret;
  

• msleep(ECI_WAIT_BUS_SETTLE);
• mireg |= ECI_INT_ENABLE;
• ret = eci->eci_hw_ops->acc_write_reg(ECICMD_MASTER_INT_REG, mireg);
• if (ret)

• return ret;
  

• msleep(ECI_WAIT_BUS_SETTLE);
• return ret;

+}

+/* Find "enchangement features" block from buffer */ +static int eci_get_enchancement_features(struct eci_data *eci) +{

• u8 *mem = (void *)eci->memory;
• struct eci_mem_block *b = (void *)mem;
• struct eci_mem_block *mem_end = (void *)(eci->memory + eci->mem_size);
• if (b->id != ECI_EKEY_BLOCK_ID)

• return -ENODEV;
  

• do {

• dev_dbg(eci->dev, "skip BLOCK 0x%02x, LEN 0x%02x\n",
  

• 		b->id, b->len);
  

• if (!b->len)
  

• 	return -EINVAL;
  

• mem += b->len;
  

• b = (void *)mem;
  

• eci->e_features_fix = (void *)b;
  

• dev_dbg(eci->dev, "found BLOCK 0x%02x, LEN 0x%02x\n",
  

• 		b->id, b->len);
  

• if (b->id == ECI_ENHANCEMENT_FEATURE_BLOCK_ID)
  

• 	return 0;
  

• } while (b < mem_end);
• return -ENFILE;

+}

+/*

• • Find out ECI features.
• • All ECI memory block parsing are done here, be carefull as
• • pointers to memory tend to go wrong easily.
• • ECI "Enhancement Features block has variable size, so we try to
• • catch pointers out of block due memory reading errors etc.
• • I/O support field is not implemented.
• • Data direction field is not implemented, nor writing to the ECI I/O
• */

+static int eci_parse_enchancement_features(struct eci_data *eci) +{

• struct enchancement_features_fixed *eff = eci->e_features_fix;
• struct enchancement_features_variable *efv = &eci->e_features_var;
• int i;
• u8 n, k;
• void *mem_end = (void *)((u8 *)eff + eff->length);
• dev_dbg(eci->dev, "block id 0x%02x length 0x%02x connector "

• 	"configuration 0x%02x\n", eff->block_id, eff->length,
  

• 	eff->connector_conf);
  

• n = eff->number_of_features;
• dev_dbg(eci->dev, "number of features %d\n", n);
• if (n > ECI_MAX_FEATURE_COUNT)

• return -EINVAL;
  

• k = DIV_ROUND_UP(n, 8);
• dev_dbg(eci->dev, "I/O support bytes count %d\n", k);
• efv->io_support = &eff->number_of_features + 1;
• /* efv->io_functionality[0] is not used! pins are in 1..31 range */
• efv->io_functionality = efv->io_support + k - 1;
• efv->active_state = efv->io_functionality + n + 1;
• if ((void *)&efv->active_state[k] > mem_end)

• return -EINVAL;
  

• /* Last part of block */
• for (i = 0; i < k; i++)

• dev_dbg(eci->dev, "active_state[%d] 0x%02x\n", i,
  

• 		efv->active_state[i]);
  

• eci->buttons_data.buttons_up_mask =

• ~(u32)(cpu_to_le32(*(u32 *)efv->active_state));
  

• /*

• * ECI accessory responces as many bytes needed for used I/O pins
  

• * up to four bytes, when lines 24..31 are used
  

• * all tested ECI accessories how ever return two data bytes
  

• * event though there are less than eight I/O pins
  

• *
  

• * so we get alway reading error if there are less than eight I/Os
  

• * meanwhile just use this kludge, FIXME
  

• */
  

• k = DIV_ROUND_UP(n + 1, 8);
• if (k == 1)

• k = 2;
  

• eci->port_reg_count = k;
• return 0;

+}

+static int eci_init_accessory(struct eci_data *eci) +{

• int ret, key = 0, restart = 0;
• unsigned long future;
• eci->mem_ok = false;
• if (!eci->eci_hw_ops)

• return -ENXIO;
  

• ret = eci->eci_hw_ops->acc_reset();
• if (ret)

• return ret;
  

• msleep(ECI_WAIT_BUS_SETTLE);
• ret = eci->eci_hw_ops->acc_write_reg(ECICMD_MIC_CTRL, ECI_MIC_OFF);
• if (ret)

• return ret;
  

• /* Get ECI ekey block to determine memory size */
• future = jiffies + msecs_to_jiffies(ECI_TRY_GET_MEMORY);
• do {

• ret = eci_get_ekey(eci, &key);
  

• if (time_is_before_jiffies(future))
  

• 	break;
  

• } while (ret);
• if (ret)

• return ret;
  

• eci->mem_size = key;
• if (eci->mem_size > ECI_MAX_MEM_SIZE)

• return -EINVAL;
  

• /* Get ECI memory */
• future = jiffies + msecs_to_jiffies(ECI_TRY_GET_MEMORY);
• do {

• ret = eci_get_memory(eci, &restart);
  

• if (time_is_before_jiffies(future))
  

• 	break;
  

• } while (ret);
• if (ret)

• return ret;
  

• if (eci_get_enchancement_features(eci))

• return -EIO;
  

• if (eci_parse_enchancement_features(eci))

• return -EIO;
  

• /*

• * Configure ECI buttons now as we have after parsed
  

• * enchancement features table
  

• */
  

I do not understand this comment.

• msleep(ECI_WAIT_BUS_SETTLE);
• future = jiffies + msecs_to_jiffies(ECI_TRY_INIT_IO);
• do {

• ret = eci_init_buttons(eci);
  

• if (time_is_before_jiffies(future))
  

• 	break;
  

• } while (ret);
• if (ret)

• return ret;
  

• eci->mem_ok = true;
• msleep(ECI_WAIT_BUS_SETTLE);
• if (eci->eci_hw_ops->acc_write_reg(ECICMD_MIC_CTRL, eci->mic_state))

• dev_err(eci->dev, "Unable to control headset microphone\n");
  

• return 0;

+}

+static int init_accessory_input(struct eci_data *eci) +{

• int err, i, code;
• eci->acc_input = input_allocate_device();
• if (!eci->acc_input) {

• dev_err(eci->dev, "Error allocating input device: %d\n",
  

• 		__LINE__);
  

• return -ENOMEM;
  

• }
• eci->acc_input->name = "ECI Accessory";
• /* Codes on top of KEY_MAX are switch events */
• for (i = 0; i < ARRAY_SIZE(eci_codes); i++) {

• code = eci_codes[i];
  

• if (code >= KEY_MAX) {
  

• 	code -= KEY_MAX;
  

• 	set_bit(code, eci->acc_input->swbit);
  

• } else {
  

• 	set_bit(code, eci->acc_input->keybit);
  

• }
  

• }
• set_bit(EV_KEY, eci->acc_input->evbit);
• set_bit(EV_SW, eci->acc_input->evbit);
• set_bit(EV_REP, eci->acc_input->evbit);

__set_bit(), no neded to lock bus.

• err = input_register_device(eci->acc_input);
• if (err) {

• dev_err(eci->dev, "Error registering input device: %d\n",
  

• 		__LINE__);
  

• goto err_free_dev;
  

• }
• /* Must set after input_register_device() to take effect */
• eci->acc_input->rep[REP_PERIOD] = ECI_KEY_REPEAT_INTERVAL;
• return 0;

+err_free_dev:

• input_free_device(eci->acc_input);
• return err;

+}

+static void remove_accessory_input(struct eci_data *eci) +{

• input_unregister_device(eci->acc_input);

+}

+/* Press/release ccessory button(s) */ +static int eci_get_button(struct eci_data *eci) +{

• struct enchancement_features_fixed *eff = eci->e_features_fix;
• struct eci_buttons_data *b = &eci->buttons_data;
• if (!eci->mem_ok)

• return -ENXIO;
  

• if (((b->buttons & 0x0000ffff) == 0) && (eff->number_of_features > 2)) {

• dev_err(eci->dev, "ECI report all buttons down, rejected %d\n",
  

• 	       __LINE__);
  

• return -EINVAL;
  

• }
• if (b->windex < ECI_BUTTON_BUF_SIZE) {

• if (b->buttons_buf[b->windex] == 0)
  

• 	b->buttons_buf[b->windex] = b->buttons;
  

• else
  

• 	dev_err(eci->dev, "ECI button queue owerflow %d\n",
  

• 	       __LINE__);
  

• }
• b->windex++;
• if (b->windex == ECI_BUTTON_BUF_SIZE)

• b->windex = 0;
  

• return 0;

+}

+/* Intended to use ONLY inside eci_parse_button() ! */ +#define ACTIVE_STATE(x) (u32)(cpu_to_le32(*(u32 *)efv->active_state) & BIT(x-1)) +#define BUTTON_STATE(x) ((buttons & BIT(x))>>1)

+static int eci_parse_button(struct eci_data *eci, u32 buttons) +{

• int pin, code, state;
• u8 n, io_fun;
• struct enchancement_features_variable *efv = &eci->e_features_var;
• struct enchancement_features_fixed *eff = eci->e_features_fix;
• if (!eci->mem_ok)

• return -ENXIO;
  

• n = eff->number_of_features;
• for (pin = 1; pin <= n; pin++) {

• io_fun = efv->io_functionality[pin] & ~BIT(7);
  

• if (io_fun > ECI_MUTE)
  

• 	break;
  

• code = eci_codes[io_fun];
  

• state = (BUTTON_STATE(pin) == ACTIVE_STATE(pin));
  

• if (state)
  

• 	dev_dbg(eci->dev, "I/O functionality 0x%02x\n", io_fun);
  

• if (code >= KEY_MAX)
  

• 	input_report_switch(eci->acc_input, code - KEY_MAX,
  

• 			state);
  

• else
  

• 	input_report_key(eci->acc_input, code, state);
  

• }
• input_sync(eci->acc_input);
• return 0;

+}

+static int eci_send_button(struct eci_data *eci) +{

• int i;
• struct enchancement_features_fixed *eff = eci->e_features_fix;
• struct eci_buttons_data *b = &eci->buttons_data;
• u8 n;
• if (!eci->mem_ok)

• return -ENXIO;
  

• n = eff->number_of_features;
• if (n > ECI_MAX_FEATURE_COUNT)

• return -EINVAL;
  

• /*

• * Codes on top of KEY_MAX are switch events.
  

• * Let input system take care multiple key events
  

• */
  

• for (i = 0; i < ECI_BUTTON_BUF_SIZE; i++) {

• if (b->buttons_buf[b->rindex] == 0)
  

• 	break;
  

• if (eci_parse_button(eci, b->buttons_buf[b->rindex]))
  

• 	return -ENXIO;
  

• b->buttons_buf[b->rindex] = 0;
  

• b->rindex++;
  

• if (b->rindex == ECI_BUTTON_BUF_SIZE)
  

• 	b->rindex = 0;
  

• }
• return 0;

+}

+/*

• • Other driver(s) can call this after registering themselves using
• • eci_register()
• */

+static void eci_accessory_event(int event, void *priv) +{

• struct eci_data *eci = priv;
• struct eci_buttons_data *b = &eci->buttons_data;
• int delay = 0;
• int ret = 0;
• eci->event = event;
• switch (event) {
• case ECI_EVENT_IS_ECI:

• eci->is_eci = true;
  

• ret = eci->eci_hw_ops->acc_reset();
  

• if (ret)
  

• 	eci->is_eci = false;
  

• break;
  

• case ECI_EVENT_PLUG_IN:

• eci->first_event = true;
  

• ret = eci_init_accessory(eci);
  

• if (ret < 0)
  

• 	ret = eci_init_accessory(eci);
  

• if (ret) {
  

• 	dev_err(eci->dev, "Accessory init %s%s%s%sat: %d\n",
  

• 			ret & ACI_COMMERR ? "COMMERR " : "",
  

• 			ret & ACI_FRAERR ? "FRAERR " : "",
  

• 			ret & ACI_RESERR ? "RESERR " : "",
  

• 			ret & ACI_COLL ? "COLLERR " : "",
  

• 			__LINE__);
  

• 	break;
  

• }
  

• break;
  

• case ECI_EVENT_PLUG_OUT:

• eci->mem_ok = false;
  

• break;
  

• case ECI_EVENT_BUTTON:

• /*
  

•  * First event might not be valid due plug insertion
  

•  * so we filter it out if it seems garbage
  

•  */
  

• if (eci->first_event) {
  

• 	eci->first_event = false;
  

• 	if ((b->buttons & 0xff) == 0)
  

• 		break;
  

• }
  

• eci_get_button(eci);
  

• delay = msecs_to_jiffies(ECI_WAIT_SEND_BUTTON);
  

• schedule_delayed_work(&eci->eci_ws, delay);
  

• break;
  

• default:

• dev_err(eci->dev, "unknown event %d: %d\n", event, __LINE__);
  

• break;
  

• }
• return;

+}

+static void eci_hsmic_event(void *priv, bool on) +{

• struct eci_data *eci = priv;
• unsigned long future;
• int ret;
• if (!eci)

• return;
  

• if (on)

• eci->mic_state = ECI_MIC_AUTO;
  

• else

• eci->mic_state = ECI_MIC_OFF;
  

• future = jiffies + msecs_to_jiffies(ECI_TRY_SET_MIC);
• do {

• ret = eci->eci_hw_ops->acc_write_reg(ECICMD_MIC_CTRL,
  

• 		eci->mic_state);
  

• if (time_is_before_jiffies(future))
  

• 	break;
  

• } while (ret);
• if (ret)

• dev_err(eci->dev, "Unable to control headset microphone\n");
  

+}

+/* General work func (eci_ws) for several tasks */ +static void eci_work(struct work_struct *ws) +{

• struct eci_data *eci;
• int ret;
• eci = container_of((struct delayed_work *)ws, struct eci_data,

• 	eci_ws);
  

• ret = eci_send_button(eci);
• if (ret)

• dev_err(eci->dev, "Error sending event: %d\n", __LINE__);
  

+}

+static struct miscdevice eci_device = {

• .minor = MISC_DYNAMIC_MINOR,
• .name = ECI_DRIVERNAME,

+};

What does this device do?

+struct eci_cb *eci_register(struct eci_hw_ops *eci_ops) +{

• if (!the_eci)

• return ERR_PTR(-EBUSY);
  

• if (!eci_ops || !eci_ops->acc_read_direct ||

• 	!eci_ops->acc_read_reg || !eci_ops->acc_write_reg ||
  

• 	!eci_ops->acc_reset)
  

• return ERR_PTR(-EINVAL);
  

• the_eci->eci_hw_ops = eci_ops;
• return &eci_callback;

+} +EXPORT_SYMBOL(eci_register);

+static int __init eci_probe(struct platform_device *pdev) +{

• struct eci_data *eci;
• struct eci_platform_data *pdata = pdev->dev.platform_data;
• int ret;
• eci = kzalloc(sizeof(*eci), GFP_KERNEL);
• if (!eci)

• return -ENOMEM;
  

• platform_set_drvdata(pdev, eci);
• eci->dev = &pdev->dev;
• ret = misc_register(&eci_device);
• if (ret) {

• dev_err(eci->dev, "could not register misc_device: %d\n",
  

• 		__LINE__);
  

• goto err_misc;
  

• }
• the_eci = eci;
• eci_callback.event = eci_accessory_event;
• eci_callback.priv = eci;
• ret = sysfs_create_group(&pdev->dev.kobj, &eci_attr_group);
• if (ret) {

• dev_err(eci->dev, "could not create sysfs entries: %d\n",
  

• 		__LINE__);
  

• goto err_sysfs;
  

• }
• ret = eci_initialize_debugfs(eci);
• if (ret)

• dev_err(eci->dev, "could not create debugfs entries: %d\n",
  

• 		__LINE__);
  

• ret = init_accessory_input(eci);
• if (ret) {

• dev_err(eci->dev, "ERROR initializing accessory input: %d\n",
  

• 		__LINE__);
  

• goto err_input;
  

• }
• /*

• * If platform machine has audio driver providing
  

• * register_hsmic_event_cb, we should give accessory microphone control,
  

• * ie. eci_hsmic_event to it.
  

• * This way audio driver get control to ECI accessory microphone and
  

• * we can save power
  

• */
  

• if (pdata) {

• if (pdata->register_hsmic_event_cb) {
  

• 	hsmic_event.private	= eci;
  

• 	hsmic_event.event	= eci_hsmic_event;
  

• 	pdata->register_hsmic_event_cb(&hsmic_event);
  

• }
  

• }
• init_waitqueue_head(&eci->wait);
• INIT_DELAYED_WORK(&eci->eci_ws, eci_work);
• eci->mem_ok = false;
• /*

• * By default ECI driver leaves microphone off, to save power.
  

• * Audio driver can set microphone on by using
  

• * hsmic_event.event
  

• */
  

• eci->mic_state = ECI_MIC_OFF;
• /* Init buttons_data indexes and buffer */
• memset(&eci->buttons_data, 0, sizeof(struct eci_buttons_data));
• eci->buttons_data.buttons = 0xffffffff;
• return 0;

+err_input:

• eci_uninitialize_debugfs();
• sysfs_remove_group(&pdev->dev.kobj, &eci_attr_group);

+err_sysfs:

• misc_deregister(&eci_device);

+err_misc:

• kfree(eci);
• return ret;

+}

+static int __exit eci_remove(struct platform_device *pdev) +{

• struct eci_data *eci = platform_get_drvdata(pdev);
• struct eci_platform_data *pdata = pdev->dev.platform_data;
• pdata->register_hsmic_event_cb(NULL);
• cancel_delayed_work_sync(&eci->eci_ws);
• eci_uninitialize_debugfs();
• sysfs_remove_group(&pdev->dev.kobj, &eci_attr_group);
• remove_accessory_input(eci);
• kfree(eci);
• misc_deregister(&eci_device);
• return 0;

+}

+#ifdef CONFIG_PM

+static int eci_suspend(struct platform_device *pdev, pm_message_t mesg) +{

• return -ENOSYS;

+} +#else +#define eci_suspend NULL +#endif

+static struct platform_driver eci_driver = {

• .probe = eci_probe,
• .remove = __exit_p(eci_remove),
• .suspend = eci_suspend,
• .driver = {

• .name	= ECI_DRIVERNAME,
  

• .owner	= THIS_MODULE,
  

• },

+};

+static int __init eci_init(void) +{

• return platform_driver_register(&eci_driver);

+} +device_initcall(eci_init);

+static void __exit eci_exit(void) +{

• platform_driver_unregister(&eci_driver);

+} +module_exit(eci_exit);

+MODULE_ALIAS("platform:" ECI_DRIVERNAME); +MODULE_AUTHOR("Nokia Corporation"); +MODULE_DESCRIPTION("ECI accessory driver"); +MODULE_LICENSE("GPL"); diff --git a/include/linux/input/eci.h b/include/linux/input/eci.h new file mode 100644 index 0000000..b8be99c --- /dev/null +++ b/include/linux/input/eci.h @@ -0,0 +1,157 @@ +/*

• • This file is part of ECI (Enhancement Control Interface) driver
• • Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
• • Contact: Tapio Vihuri tapio.vihuri@nokia.com
• • This program is free software; you can redistribute it and/or
• • modify it under the terms of the GNU General Public License
• • version 2 as published by the Free Software Foundation.
• • This program is distributed in the hope that it will be useful, but
• • WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
• • General Public License for more details.
• • You should have received a copy of the GNU General Public License
• • along with this program; if not, write to the Free Software
• • Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
• • 02110-1301 USA
• */

+#ifndef __ECI_H__ +#define __ECI_H__

+#define ECI_MAX_MEM_SIZE 0x7c +#define ECI_BUTTON_BUF_SIZE 32 +#define ECI_MAX_FEATURE_COUNT 31

+#define ACI_COMMERR 0x010 +#define ACI_FRAERR 0x020 +#define ACI_RESERR 0x040 +#define ACI_COLL 0x080

+#define ECI_REAL_BUTTONS 0 +#define ECI_FORCE_BUTTONS_UP 1

+/* fixed in ECI HW, do not change */ +enum {

• ECICMD_HWID,
• ECICMD_SWID,
• ECICMD_ECI_BUS_SPEED,
• ECICMD_MIC_CTRL,
• ECICMD_MASTER_INT_REG,
• ECICMD_HW_CONF_MEM_ACCESS,
• ECICMD_EXTENDED_MEM_ACCESS,
• ECICMD_INDIRECT_MEM_ACCESS,
• ECICMD_PORT_DATA_0,
• ECICMD_PORT_DATA_1,
• ECICMD_PORT_DATA_2,
• ECICMD_PORT_DATA_3,
• ECICMD_LATCHED_PORT_DATA_0,
• ECICMD_LATCHED_PORT_DATA_1,
• ECICMD_LATCHED_PORT_DATA_2,
• ECICMD_LATCHED_PORT_DATA_3,
• ECICMD_DATA_DIR_0,
• ECICMD_DATA_DIR_1,
• ECICMD_DATA_DIR_2,
• ECICMD_DATA_DIR_3,
• ECICMD_INT_CONFIG_0_LOW,
• ECICMD_INT_CONFIG_0_HIGH,
• ECICMD_INT_CONFIG_1_LOW,
• ECICMD_INT_CONFIG_1_HIGH,
• ECICMD_INT_CONFIG_2_LOW,
• ECICMD_INT_CONFIG_2_HIGH,
• ECICMD_INT_CONFIG_3_LOW,
• ECICMD_INT_CONFIG_3_HIGH,
• /*

• * 0x1c - 0x2f reserved for future
  

• * 0x30 - 0x3d reserved
  

• */
  

• ECICMD_EEPROM_LOCK = 0x3e,
• ECICMD_RESERVED, /* 0x3f */
• ECIREG_STATUS, /* 0x40 */
• ECIREG_READ_COUNT, /* 0x41 */
• ECIREG_BUF_COUNT, /* 0x42 */
• ECIREG_RST_LEARN, /* 0x43 */
• /* 0x44 - 0xdf as data buffer */
• ECIREG_READ_DIRECT, /* 0x44 */
• ECIREG_HW_ID = 0xe0, /* 0xe0 */
• ECIREG_FW_ID, /* 0xe1 */
• ECIREG_TEST_IN, /* 0xe2 */
• ECIREG_TEST_OUT, /* 0xe3 */

+};

+enum {

• ECI_EVENT_IS_ECI,
• ECI_EVENT_PLUG_IN,
• ECI_EVENT_PLUG_OUT,
• ECI_EVENT_BUTTON,
• ECI_EVENT_NO,

+};

+struct eci_hw_ops {

• int (*acc_reset)(void);
• int (*acc_read_direct)(u8 addr, char *buf);
• int (*acc_read_reg)(u8 reg, u8 *buf, int count);
• int (*acc_write_reg)(u8 reg, u8 param);

+};

+struct eci_cb {

• void *priv;
• void (*event)(int event, void *priv);

+};

+struct audio_hsmic_event {

• void *private;
• void (*event)(void *priv, bool on);

+};

+struct eci_platform_data {

• void (*register_hsmic_event_cb)(struct audio_hsmic_event *);

+};

+struct enchancement_features_fixed {

• u8 block_id;
• u8 length;
• u8 connector_conf;
• u8 number_of_features;

+};

+struct enchancement_features_variable {

• u8 *io_support;
• u8 *io_functionality;
• u8 *active_state;

+};

+struct eci_buttons_data {

• u32 buttons;
• int windex;
• int rindex;
• u32 buttons_up_mask;
• u32 buttons_buf[ECI_BUTTON_BUF_SIZE];

+};

+struct eci_data {

• struct device *dev;
• struct delayed_work eci_ws;
• wait_queue_head_t wait;
• struct input_dev *acc_input;
• int event;
• bool first_event;
• bool mem_ok;
• u16 mem_size;
• u8 memory[ECI_MAX_MEM_SIZE];
• struct enchancement_features_fixed *e_features_fix;
• struct enchancement_features_variable e_features_var;
• u8 port_reg_count;
• struct eci_buttons_data buttons_data;
• struct eci_hw_ops *eci_hw_ops;
• u8 mic_state;
• bool plugged;
• bool is_eci;

+};

+struct eci_cb *eci_register(struct eci_hw_ops *eci_ops);

+#endif

1.6.5

Thank you.