fsa9480.c

Go to the documentation of this file.

/*
 * fsa9480.c - FSA9480 micro USB switch device driver
 *
 * Copyright (C) 2010 Samsung Electronics
 * Minkyu Kang <[email protected]>
 * Wonguk Jeong <[email protected]>
 *
 * 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.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/platform_data/fsa9480.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/pm_runtime.h>

/* FSA9480 I2C registers */
#define FSA9480_REG_DEVID       0x01
#define FSA9480_REG_CTRL        0x02
#define FSA9480_REG_INT1        0x03
#define FSA9480_REG_INT2        0x04
#define FSA9480_REG_INT1_MASK       0x05
#define FSA9480_REG_INT2_MASK       0x06
#define FSA9480_REG_ADC         0x07
#define FSA9480_REG_TIMING1     0x08
#define FSA9480_REG_TIMING2     0x09
#define FSA9480_REG_DEV_T1      0x0a
#define FSA9480_REG_DEV_T2      0x0b
#define FSA9480_REG_BTN1        0x0c
#define FSA9480_REG_BTN2        0x0d
#define FSA9480_REG_CK          0x0e
#define FSA9480_REG_CK_INT1     0x0f
#define FSA9480_REG_CK_INT2     0x10
#define FSA9480_REG_CK_INTMASK1     0x11
#define FSA9480_REG_CK_INTMASK2     0x12
#define FSA9480_REG_MANSW1      0x13
#define FSA9480_REG_MANSW2      0x14

/* Control */
#define CON_SWITCH_OPEN     (1 << 4)
#define CON_RAW_DATA        (1 << 3)
#define CON_MANUAL_SW       (1 << 2)
#define CON_WAIT        (1 << 1)
#define CON_INT_MASK        (1 << 0)
#define CON_MASK        (CON_SWITCH_OPEN | CON_RAW_DATA | \
                CON_MANUAL_SW | CON_WAIT)

/* Device Type 1 */
#define DEV_USB_OTG     (1 << 7)
#define DEV_DEDICATED_CHG   (1 << 6)
#define DEV_USB_CHG     (1 << 5)
#define DEV_CAR_KIT     (1 << 4)
#define DEV_UART        (1 << 3)
#define DEV_USB         (1 << 2)
#define DEV_AUDIO_2     (1 << 1)
#define DEV_AUDIO_1     (1 << 0)

#define DEV_T1_USB_MASK     (DEV_USB_OTG | DEV_USB)
#define DEV_T1_UART_MASK    (DEV_UART)
#define DEV_T1_CHARGER_MASK (DEV_DEDICATED_CHG | DEV_USB_CHG)

/* Device Type 2 */
#define DEV_AV          (1 << 6)
#define DEV_TTY         (1 << 5)
#define DEV_PPD         (1 << 4)
#define DEV_JIG_UART_OFF    (1 << 3)
#define DEV_JIG_UART_ON     (1 << 2)
#define DEV_JIG_USB_OFF     (1 << 1)
#define DEV_JIG_USB_ON      (1 << 0)

#define DEV_T2_USB_MASK     (DEV_JIG_USB_OFF | DEV_JIG_USB_ON)
#define DEV_T2_UART_MASK    (DEV_JIG_UART_OFF | DEV_JIG_UART_ON)
#define DEV_T2_JIG_MASK     (DEV_JIG_USB_OFF | DEV_JIG_USB_ON | \
                DEV_JIG_UART_OFF | DEV_JIG_UART_ON)

/*
 * Manual Switch
 * D- [7:5] / D+ [4:2]
 * 000: Open all / 001: USB / 010: AUDIO / 011: UART / 100: V_AUDIO
 */
#define SW_VAUDIO       ((4 << 5) | (4 << 2))
#define SW_UART         ((3 << 5) | (3 << 2))
#define SW_AUDIO        ((2 << 5) | (2 << 2))
#define SW_DHOST        ((1 << 5) | (1 << 2))
#define SW_AUTO         ((0 << 5) | (0 << 2))

/* Interrupt 1 */
#define INT_DETACH      (1 << 1)
#define INT_ATTACH      (1 << 0)

struct fsa9480_usbsw {
    struct i2c_client       *client;
    struct fsa9480_platform_data    *pdata;
    int             dev1;
    int             dev2;
    int             mansw;
};

static struct fsa9480_usbsw *chip;

static int fsa9480_write_reg(struct i2c_client *client,
        int reg, int value)
{
    int ret;

    ret = i2c_smbus_write_byte_data(client, reg, value);

    if (ret < 0)
        dev_err(&client->dev, "%s: err %d\n", __func__, ret);

    return ret;
}

static int fsa9480_read_reg(struct i2c_client *client, int reg)
{
    int ret;

    ret = i2c_smbus_read_byte_data(client, reg);

    if (ret < 0)
        dev_err(&client->dev, "%s: err %d\n", __func__, ret);

    return ret;
}

static int fsa9480_read_irq(struct i2c_client *client, int *value)
{
    int ret;

    ret = i2c_smbus_read_i2c_block_data(client,
            FSA9480_REG_INT1, 2, (u8 *)value);
    *value &= 0xffff;

    if (ret < 0)
        dev_err(&client->dev, "%s: err %d\n", __func__, ret);

    return ret;
}

static void fsa9480_set_switch(const char *buf)
{
    struct fsa9480_usbsw *usbsw = chip;
    struct i2c_client *client = usbsw->client;
    unsigned int value;
    unsigned int path = 0;

    value = fsa9480_read_reg(client, FSA9480_REG_CTRL);

    if (!strncmp(buf, "VAUDIO", 6)) {
        path = SW_VAUDIO;
        value &= ~CON_MANUAL_SW;
    } else if (!strncmp(buf, "UART", 4)) {
        path = SW_UART;
        value &= ~CON_MANUAL_SW;
    } else if (!strncmp(buf, "AUDIO", 5)) {
        path = SW_AUDIO;
        value &= ~CON_MANUAL_SW;
    } else if (!strncmp(buf, "DHOST", 5)) {
        path = SW_DHOST;
        value &= ~CON_MANUAL_SW;
    } else if (!strncmp(buf, "AUTO", 4)) {
        path = SW_AUTO;
        value |= CON_MANUAL_SW;
    } else {
        printk(KERN_ERR "Wrong command\n");
        return;
    }

    usbsw->mansw = path;
    fsa9480_write_reg(client, FSA9480_REG_MANSW1, path);
    fsa9480_write_reg(client, FSA9480_REG_CTRL, value);
}

static ssize_t fsa9480_get_switch(char *buf)
{
    struct fsa9480_usbsw *usbsw = chip;
    struct i2c_client *client = usbsw->client;
    unsigned int value;

    value = fsa9480_read_reg(client, FSA9480_REG_MANSW1);

    if (value == SW_VAUDIO)
        return sprintf(buf, "VAUDIO\n");
    else if (value == SW_UART)
        return sprintf(buf, "UART\n");
    else if (value == SW_AUDIO)
        return sprintf(buf, "AUDIO\n");
    else if (value == SW_DHOST)
        return sprintf(buf, "DHOST\n");
    else if (value == SW_AUTO)
        return sprintf(buf, "AUTO\n");
    else
        return sprintf(buf, "%x", value);
}

static ssize_t fsa9480_show_device(struct device *dev,
                   struct device_attribute *attr,
                   char *buf)
{
    struct fsa9480_usbsw *usbsw = dev_get_drvdata(dev);
    struct i2c_client *client = usbsw->client;
    int dev1, dev2;

    dev1 = fsa9480_read_reg(client, FSA9480_REG_DEV_T1);
    dev2 = fsa9480_read_reg(client, FSA9480_REG_DEV_T2);

    if (!dev1 && !dev2)
        return sprintf(buf, "NONE\n");

    /* USB */
    if (dev1 & DEV_T1_USB_MASK || dev2 & DEV_T2_USB_MASK)
        return sprintf(buf, "USB\n");

    /* UART */
    if (dev1 & DEV_T1_UART_MASK || dev2 & DEV_T2_UART_MASK)
        return sprintf(buf, "UART\n");

    /* CHARGER */
    if (dev1 & DEV_T1_CHARGER_MASK)
        return sprintf(buf, "CHARGER\n");

    /* JIG */
    if (dev2 & DEV_T2_JIG_MASK)
        return sprintf(buf, "JIG\n");

    return sprintf(buf, "UNKNOWN\n");
}

static ssize_t fsa9480_show_manualsw(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    return fsa9480_get_switch(buf);

}

static ssize_t fsa9480_set_manualsw(struct device *dev,
                    struct device_attribute *attr,
                    const char *buf, size_t count)
{
    fsa9480_set_switch(buf);

    return count;
}

static DEVICE_ATTR(device, S_IRUGO, fsa9480_show_device, NULL);
static DEVICE_ATTR(switch, S_IRUGO | S_IWUSR,
        fsa9480_show_manualsw, fsa9480_set_manualsw);

static struct attribute *fsa9480_attributes[] = {
    &dev_attr_device.attr,
    &dev_attr_switch.attr,
    NULL
};

static const struct attribute_group fsa9480_group = {
    .attrs = fsa9480_attributes,
};

static void fsa9480_detect_dev(struct fsa9480_usbsw *usbsw, int intr)
{
    int val1, val2, ctrl;
    struct fsa9480_platform_data *pdata = usbsw->pdata;
    struct i2c_client *client = usbsw->client;

    val1 = fsa9480_read_reg(client, FSA9480_REG_DEV_T1);
    val2 = fsa9480_read_reg(client, FSA9480_REG_DEV_T2);
    ctrl = fsa9480_read_reg(client, FSA9480_REG_CTRL);

    dev_info(&client->dev, "intr: 0x%x, dev1: 0x%x, dev2: 0x%x\n",
            intr, val1, val2);

    if (!intr)
        goto out;

    if (intr & INT_ATTACH) {    /* Attached */
        /* USB */
        if (val1 & DEV_T1_USB_MASK || val2 & DEV_T2_USB_MASK) {
            if (pdata->usb_cb)
                pdata->usb_cb(FSA9480_ATTACHED);

            if (usbsw->mansw) {
                fsa9480_write_reg(client,
                    FSA9480_REG_MANSW1, usbsw->mansw);
            }
        }

        /* UART */
        if (val1 & DEV_T1_UART_MASK || val2 & DEV_T2_UART_MASK) {
            if (pdata->uart_cb)
                pdata->uart_cb(FSA9480_ATTACHED);

            if (!(ctrl & CON_MANUAL_SW)) {
                fsa9480_write_reg(client,
                    FSA9480_REG_MANSW1, SW_UART);
            }
        }

        /* CHARGER */
        if (val1 & DEV_T1_CHARGER_MASK) {
            if (pdata->charger_cb)
                pdata->charger_cb(FSA9480_ATTACHED);
        }

        /* JIG */
        if (val2 & DEV_T2_JIG_MASK) {
            if (pdata->jig_cb)
                pdata->jig_cb(FSA9480_ATTACHED);
        }
    } else if (intr & INT_DETACH) { /* Detached */
        /* USB */
        if (usbsw->dev1 & DEV_T1_USB_MASK ||
            usbsw->dev2 & DEV_T2_USB_MASK) {
            if (pdata->usb_cb)
                pdata->usb_cb(FSA9480_DETACHED);
        }

        /* UART */
        if (usbsw->dev1 & DEV_T1_UART_MASK ||
            usbsw->dev2 & DEV_T2_UART_MASK) {
            if (pdata->uart_cb)
                pdata->uart_cb(FSA9480_DETACHED);
        }

        /* CHARGER */
        if (usbsw->dev1 & DEV_T1_CHARGER_MASK) {
            if (pdata->charger_cb)
                pdata->charger_cb(FSA9480_DETACHED);
        }

        /* JIG */
        if (usbsw->dev2 & DEV_T2_JIG_MASK) {
            if (pdata->jig_cb)
                pdata->jig_cb(FSA9480_DETACHED);
        }
    }

    usbsw->dev1 = val1;
    usbsw->dev2 = val2;

out:
    ctrl &= ~CON_INT_MASK;
    fsa9480_write_reg(client, FSA9480_REG_CTRL, ctrl);
}

static irqreturn_t fsa9480_irq_handler(int irq, void *data)
{
    struct fsa9480_usbsw *usbsw = data;
    struct i2c_client *client = usbsw->client;
    int intr;

    /* clear interrupt */
    fsa9480_read_irq(client, &intr);

    /* device detection */
    fsa9480_detect_dev(usbsw, intr);

    return IRQ_HANDLED;
}

static int fsa9480_irq_init(struct fsa9480_usbsw *usbsw)
{
    struct fsa9480_platform_data *pdata = usbsw->pdata;
    struct i2c_client *client = usbsw->client;
    int ret;
    int intr;
    unsigned int ctrl = CON_MASK;

    /* clear interrupt */
    fsa9480_read_irq(client, &intr);

    /* unmask interrupt (attach/detach only) */
    fsa9480_write_reg(client, FSA9480_REG_INT1_MASK, 0xfc);
    fsa9480_write_reg(client, FSA9480_REG_INT2_MASK, 0x1f);

    usbsw->mansw = fsa9480_read_reg(client, FSA9480_REG_MANSW1);

    if (usbsw->mansw)
        ctrl &= ~CON_MANUAL_SW; /* Manual Switching Mode */

    fsa9480_write_reg(client, FSA9480_REG_CTRL, ctrl);

    if (pdata && pdata->cfg_gpio)
        pdata->cfg_gpio();

    if (client->irq) {
        ret = request_threaded_irq(client->irq, NULL,
                fsa9480_irq_handler,
                IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                "fsa9480 micro USB", usbsw);
        if (ret) {
            dev_err(&client->dev, "failed to reqeust IRQ\n");
            return ret;
        }

        if (pdata)
            device_init_wakeup(&client->dev, pdata->wakeup);
    }

    return 0;
}

static int __devinit fsa9480_probe(struct i2c_client *client,
             const struct i2c_device_id *id)
{
    struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
    struct fsa9480_usbsw *usbsw;
    int ret = 0;

    if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
        return -EIO;

    usbsw = kzalloc(sizeof(struct fsa9480_usbsw), GFP_KERNEL);
    if (!usbsw) {
        dev_err(&client->dev, "failed to allocate driver data\n");
        return -ENOMEM;
    }

    usbsw->client = client;
    usbsw->pdata = client->dev.platform_data;

    chip = usbsw;

    i2c_set_clientdata(client, usbsw);

    ret = fsa9480_irq_init(usbsw);
    if (ret)
        goto fail1;

    ret = sysfs_create_group(&client->dev.kobj, &fsa9480_group);
    if (ret) {
        dev_err(&client->dev,
                "failed to create fsa9480 attribute group\n");
        goto fail2;
    }

    /* ADC Detect Time: 500ms */
    fsa9480_write_reg(client, FSA9480_REG_TIMING1, 0x6);

    if (chip->pdata->reset_cb)
        chip->pdata->reset_cb();

    /* device detection */
    fsa9480_detect_dev(usbsw, INT_ATTACH);

    pm_runtime_set_active(&client->dev);

    return 0;

fail2:
    if (client->irq)
        free_irq(client->irq, usbsw);
fail1:
    kfree(usbsw);
    return ret;
}

static int __devexit fsa9480_remove(struct i2c_client *client)
{
    struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client);
    if (client->irq)
        free_irq(client->irq, usbsw);

    sysfs_remove_group(&client->dev.kobj, &fsa9480_group);
    device_init_wakeup(&client->dev, 0);
    kfree(usbsw);
    return 0;
}

#ifdef CONFIG_PM

static int fsa9480_suspend(struct i2c_client *client, pm_message_t state)
{
    struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client);
    struct fsa9480_platform_data *pdata = usbsw->pdata;

    if (device_may_wakeup(&client->dev) && client->irq)
        enable_irq_wake(client->irq);

    if (pdata->usb_power)
        pdata->usb_power(0);

    return 0;
}

static int fsa9480_resume(struct i2c_client *client)
{
    struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client);
    int dev1, dev2;

    if (device_may_wakeup(&client->dev) && client->irq)
        disable_irq_wake(client->irq);

    /*
     * Clear Pending interrupt. Note that detect_dev does what
     * the interrupt handler does. So, we don't miss pending and
     * we reenable interrupt if there is one.
     */
    fsa9480_read_reg(client, FSA9480_REG_INT1);
    fsa9480_read_reg(client, FSA9480_REG_INT2);

    dev1 = fsa9480_read_reg(client, FSA9480_REG_DEV_T1);
    dev2 = fsa9480_read_reg(client, FSA9480_REG_DEV_T2);

    /* device detection */
    fsa9480_detect_dev(usbsw, (dev1 || dev2) ? INT_ATTACH : INT_DETACH);

    return 0;
}

#else

#define fsa9480_suspend NULL
#define fsa9480_resume NULL

#endif /* CONFIG_PM */

static const struct i2c_device_id fsa9480_id[] = {
    {"fsa9480", 0},
    {}
};
MODULE_DEVICE_TABLE(i2c, fsa9480_id);

static struct i2c_driver fsa9480_i2c_driver = {
    .driver = {
        .name = "fsa9480",
    },
    .probe = fsa9480_probe,
    .remove = __devexit_p(fsa9480_remove),
    .resume = fsa9480_resume,
    .suspend = fsa9480_suspend,
    .id_table = fsa9480_id,
};

module_i2c_driver(fsa9480_i2c_driver);

MODULE_AUTHOR("Minkyu Kang <[email protected]>");
MODULE_DESCRIPTION("FSA9480 USB Switch driver");
MODULE_LICENSE("GPL");