C180_oyster_driver/batteryled.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/pci.h>
#include <linux/i2c.h>
#include <linux/acpi.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/mutex.h>
#include <linux/delay.h>

#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/workqueue.h>

#include "gpioregs.h"
#include "smart_battery.h"

// blue is charge
// white is health
// Because our LED does not have blue and white. Only red and green. So use red to indicate charging, green to indicate healthy.
enum battery_led_color
{
 BATTERY_LED_OFF = 0x00,
 BATTERY_LED_WHITE = 0x01,
 BATTERY_LED_BLUE = 0x02,
 BATTERY_LED_WHITE_BLINK = 0x03,
 BATTERY_LED_BLUE_BLINK = 0x04
};


extern struct kobject *vfiec_kobj;
static struct kobject *batteryled_kobj;

static unsigned int led_charge_val = 0;
static unsigned int led_health_val = 0;
static struct delayed_work delay_work1;
static struct delayed_work delay_work2;


static int wait_ibf(void)
{
    int i = 0;
    while (inb(EC_CMD_PORT) & EC_IBF)
    {
        if (++i > TIMEOUT_LOOPS)
        {
            return -1;
        }
        udelay(1);
    }
    return 0;
}

static int wait_obf(void)
{
    int i = 0;
    while (!(inb(EC_CMD_PORT) & EC_OBF))
    {
        if (++i > TIMEOUT_LOOPS)
        {
            return -1;
        }
        udelay(1);
    }
    return 0;
}

#if 0
static int ec_read_ram(uint8_t offset, uint8_t *data)
{
    if (wait_ibf() < 0)
        return -1;
    outb(CMD_READ_RAM, EC_CMD_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(offset, EC_DATA_PORT);

    if (wait_obf() < 0)
        return -1;
    *data = inb(EC_DATA_PORT);

    return 0;
}

static int ec_write_ram(uint8_t offset, uint8_t data)
{
    if (wait_ibf() < 0)
        return -1;
    outb(CMD_WRITE_RAM, EC_CMD_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(offset, EC_DATA_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(data, EC_DATA_PORT);

    return 0;
}
#endif

static int oem_ec_read_ram(uint8_t page, uint8_t offset, uint8_t *data)
{
    unsigned char WEC, REC;
    switch(page)
    {
        case 0:
        {
            WEC = 0x96;
            REC = 0x95;
            break;
        }
        
        case 1:
        {
            WEC = 0x98;
            REC = 0x97;
            break;
        }
        
        default:
        {
            WEC = 0x81;
            REC = 0x80;
            break;
        }
    }    
    if (wait_ibf() < 0)
        return -1;
    outb(REC, EC_CMD_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(offset, EC_DATA_PORT);

    if (wait_obf() < 0)
        return -1;
    *data = inb(EC_DATA_PORT);

    return 0;
}

static int oem_ec_write_ram(uint8_t page, uint8_t offset, uint8_t data)
{
    unsigned char WEC, REC;
    switch(page)
    {
        case 0:
        {
            WEC = 0x96;
            REC = 0x95;
            break;
        }
        
        case 1:
        {
            WEC = 0x98;
            REC = 0x97;
            break;
        }
        
        default:
        {
            WEC = 0x81;
            REC = 0x80;
            break;
        }
    }
    if (wait_ibf() < 0)
        return -1;
    outb(WEC, EC_CMD_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(offset, EC_DATA_PORT);

    if (wait_ibf() < 0)
        return -1;
    outb(data, EC_DATA_PORT);

    return 0;
}

/* ==================== max_fade_brightness ==================== */
static ssize_t led_health_show(struct kobject *kobj,
                                        struct kobj_attribute *attr,
                                        char *buf)
{
    uint8_t data = 0;
    int ret = 0;

    ret = oem_ec_read_ram(2, 0x31, &data);

    return sprintf(buf, "%02x\n", led_health_val);
}

static ssize_t led_health_store(struct kobject *kobj,
                                         struct kobj_attribute *attr,
                                         const char *buf, size_t count)
{
    u32 val;
    int ret;
    printk("%s: %s\n", __func__, buf);

    ret = kstrtou32(buf, 10, &val);
    if (ret < 0)
        return ret;

    if(val == 0x0 || val == 0x1 || val == 0x2 || val == 0x3 || val == 0x4)
    {
        led_health_val = val;
    }
    else
    {
        return -EINVAL;
    }
    schedule_delayed_work(&delay_work1, msecs_to_jiffies(10));

    return count;
}

static struct kobj_attribute led_health =
    __ATTR(led_health, 0644, led_health_show, led_health_store);

/* ==================== mode ==================== */
static ssize_t led_charge_show(struct kobject *kobj, struct kobj_attribute *attr,
                         char *buf)
{
    uint8_t data = 0;
    int ret = 0;

    ret = oem_ec_read_ram(2, 0x31, &data);

    return sprintf(buf, "%02x\n", led_charge_val);
}

static ssize_t led_charge_store(struct kobject *kobj, struct kobj_attribute *attr,
                          const char *buf, size_t count)
{
    u32 val;
    int ret;
    printk("%s: %s\n", __func__, buf);

    ret = kstrtou32(buf, 10, &val);
    if (ret < 0)
        return ret;

    if(val == 0x0 || val == 0x1 || val == 0x2 || val == 0x3 || val == 0x4)
    {
        led_charge_val = val;
    }
    else
    {
        return -EINVAL;
    }
    schedule_delayed_work(&delay_work1, msecs_to_jiffies(10));

    return count;
}

static struct kobj_attribute led_charge =
    __ATTR(led_charge, 0644, led_charge_show, led_charge_store);

static struct attribute *batteryled_attrs[] = {
    &led_charge.attr,
    &led_health.attr,
    NULL,
};

static struct attribute_group batteryled_attr_group = {
    .attrs = batteryled_attrs,
};

static void delay_work_func2(struct work_struct *work)
{
    struct smart_battery_info info;
    int ret = 0;
    ret = get_battery_info(&info);
    if(ret == 0)
    {
        if(info.capacity >= 50)
        {
            led_health_val = 0x2;
        }
        else if(info.capacity < 50 && info.capacity >= 20)
        {
            led_health_val = 0x1;
        }
        else
        {
            led_health_val = 0x3;
        }

        if(info.status == 0x00)
        {
            led_charge_val = 0x0;
            led_health_val = 0x0;
        }
        else if(info.status == 0x01)
        {
            led_charge_val = 0x4;
        }
        else if(info.status == 0x02)
        {
            led_charge_val = 0x2;            
        }
    }
    schedule_delayed_work(&delay_work2, msecs_to_jiffies(5000));
}
static void delay_work_func(struct work_struct *work)
{
    static uint8_t blink_flag = 0;
    uint8_t data = 0;
    // val is led state: off; red; green
    // val bit meaning:
    // bit 2-3: health led  bit2-green, bit3-red        blude=green white=red
    // bit 4-5: charge led  bit4-green, bit5-red
    if(blink_flag == 0)
    {
        //Turn off when flickering
        blink_flag = 1;
        if(led_health_val == 0x0)
        {
            data = data & 0xf3;
        }
        else if(led_health_val == 0x1)
        {
            data = data | 0x8;
        }
        else if(led_health_val == 0x2)
        {
            data = data | 0x4;
        }
        else if(led_health_val == 0x3)
        {
            data = data & 0xf3;
        }
        else if(led_health_val == 0x4)
        {
            data = data & 0xf3;
        }
        
        if(led_charge_val == 0x0)
        {
            data = data & 0xcf;
        }
        else if(led_charge_val == 0x1)
        {
            data = data | 0x20;
        }
        else if(led_charge_val == 0x2)
        {
            data = data | 0x10;
        }
        else if(led_charge_val == 0x3)
        {
            data = data & 0xcf;
        }
        else if(led_charge_val == 0x4)
        {
            data = data & 0xcf;
        }

    }
    else if(blink_flag == 1)
    {
        // Bright when flashing
        blink_flag = 0;
        if(led_health_val == 0x0)
        {
            data = data & 0xf3;
        }
        else if(led_health_val == 0x1)
        {
            data = data | 0x08;
        }
        else if(led_health_val == 0x2)
        {
            data = data | 0x04;
        }
        else if(led_health_val == 0x3)
        {
            data = data | 0x08;
        }
        else if(led_health_val == 0x4)
        {
            data = data | 0x04;
        }
        
        if(led_charge_val == 0x0)
        {
            data = data & 0xcf;
        }
        else if(led_charge_val == 0x1)
        {
            data = data | 0x20;
        }
        else if(led_charge_val == 0x2)
        {
            data = data | 0x10;
        }
        else if(led_charge_val == 0x3)
        {
            data = data | 0x20;
        }
        else if(led_charge_val == 0x4)
        {
            data = data | 0x10;
        }
    }
    oem_ec_write_ram(2, 0x31, data);
    oem_ec_write_ram(2, 0x21, 0x3C);
    schedule_delayed_work(&delay_work1, msecs_to_jiffies(500));
}

int batteryled_init(void)
{
    int ret;
    INIT_DELAYED_WORK(&delay_work1, delay_work_func);
    INIT_DELAYED_WORK(&delay_work2, delay_work_func2);

        /* Create /sys/kernel/vfiec/batteryled */
    batteryled_kobj = kobject_create_and_add("batteryled", vfiec_kobj);
    if (!batteryled_kobj)
    {
        ret = -ENOMEM;
        return ret;
    }

    /* Create property file */
    ret = sysfs_create_group(batteryled_kobj, &batteryled_attr_group);
    if (ret)
    {
        pr_err("Failed to create sysfs group: %d\n", ret);
        goto free_batteryled_kobj;
    }
    
    schedule_delayed_work(&delay_work1, msecs_to_jiffies(100));
    schedule_delayed_work(&delay_work2, msecs_to_jiffies(100));
    return 0;

free_batteryled_kobj:
    kobject_put(batteryled_kobj);
    return ret;
}

void batteryled_exit(void)
{
    
    cancel_delayed_work_sync(&delay_work1);
    cancel_delayed_work_sync(&delay_work2);
    sysfs_remove_group(batteryled_kobj, &batteryled_attr_group);
    kobject_put(batteryled_kobj);
}