/*
 * viatel_cbp_sync.c
 *
 * VIA CBP driver for Linux
 *
 * Copyright (C) 2011 VIA TELECOM Corporation, Inc.
 * Author: VIA TELECOM Corporation, Inc.
 *
 * This package 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 PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/time.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/irq.h>
#include <linux/sched.h>
#include <linux/wakelock.h>
#include <linux/delay.h>
#include <linux/wait.h>
#include <linux/platform_device.h>
#include <mach/viatel.h>
#include "core.h"

//define in oem.c
extern int isviatelcom;
extern int ap_ready_always;

static int asc_debug = 0;
#define ASCDPRT(fmt, arg...)  do{ \
    if(asc_debug) \
        printk("[ASC] " fmt, ##arg); \
    }while(0)
#define ASCPRT(fmt, arg...)  printk("[ASC] " fmt, ##arg)

/*mS*/
#define ASC_RX_WAIT_IDLE_TIME (1000)
#define ASC_TX_WAIT_READY_TIME (1000)
#define ASC_TX_WAIT_IDLE_TIME (2000)
#define ASC_TX_AUTO_DELAY_TIME (2000)
#define ASC_TX_WAIT_SLEEP_TIME (500)
#define ASC_TX_TRY_TIMES (3)
#define ASC_TX_DEBOUNCE_TIME (10)

#define ASC_TX_SYSFS_USER "AscApp"
#define ASC_TX_AUTO_USER "AscAuto"

/* asc_list contains all registered struct struct asc_handle*/
static DEFINE_SPINLOCK(hdlock);
static LIST_HEAD(asc_tx_handle_list);
static LIST_HEAD(asc_rx_handle_list);
static struct workqueue_struct *asc_work_queue;
static struct kobject *asc_kobj;

typedef enum{
    ASC_TX_HD = 0,
    ASC_RX_HD
}asc_handle_type;

#define ASC_EVENT_POOL_MAX (60)
typedef enum{
    ASC_EVENT_UNUSE = 0,
    ASC_EVENT_STATIC,
    ASC_EVENT_DYNAMIC
}asc_event_type;

struct asc_event{
    int id;
    struct list_head list;
    char usage;
};

static struct asc_event event_pool[ASC_EVENT_POOL_MAX];

struct asc_user{
    struct asc_infor infor;
    atomic_t count;
    struct list_head  node;
};

struct asc_state_dsp{
    char name[ASC_NAME_LEN];
    /*state callback handle for events*/
    int (*handle)(void * hd, int event);
};

/* TX STATUS and TX EVENT*/
typedef enum{
    AP_TX_EVENT_REQUEST = 0, /*internal*/ 
    AP_TX_EVENT_CP_READY,
    AP_TX_EVENT_CP_UNREADY,
    AP_TX_EVENT_WAIT_TIMEOUT,
    AP_TX_EVENT_IDLE_TIMEOUT,
    AP_TX_EVENT_STOP,
    AP_TX_EVENT_RESET,
    AP_TX_EVENT_NUM
} ap_tx_event;

typedef enum{
    AP_TX_ST_SLEEP = 0,
    AP_TX_ST_WAIT_READY,
    AP_TX_ST_READY, /*wait All Tx channel finished*/
    AP_TX_ST_IDLE,
    AP_TX_ST_NUM
} ap_tx_state;

struct asc_tx_handle{
    struct asc_config cfg;
    atomic_t state;
    atomic_t count;
    struct list_head user_list;
    struct asc_state_dsp *table;
    /*process the event to switch different states*/
    struct task_struct  *thread;
    int ntf;
    int wait_try;
    int auto_delay;
    spinlock_t slock;
    wait_queue_head_t wait;
    wait_queue_head_t wait_tx_state;
    struct mutex mlock;
    struct wake_lock wlock;
    struct timer_list timer_wait_ready;
    struct timer_list timer_wait_idle;
    struct timer_list timer_wait_sleep;
    struct work_struct ntf_work;
    struct list_head event_q;
    struct list_head node;
    struct kobject *kobj;
};

static int asc_tx_handle_sleep(void *, int );
static int asc_tx_handle_wait_ready(void *, int );
static int asc_tx_handle_ready(void *, int );
static int asc_tx_handle_idle(void *, int );

/*the table used to discribe all tx states*/
static struct asc_state_dsp asc_tx_table[AP_TX_ST_NUM] = {
    [AP_TX_ST_SLEEP] = {
        .name = "AP_TX_ST_SLEEP",
        .handle = asc_tx_handle_sleep,    
    },
    [AP_TX_ST_WAIT_READY] = {
        .name = "AP_TX_ST_WAIT_READY",
        .handle = asc_tx_handle_wait_ready,    
    },
    [AP_TX_ST_READY] = {
        .name = "AP_TX_ST_READY",
        .handle = asc_tx_handle_ready,    
    },
    [AP_TX_ST_IDLE] = {
        .name = "AP_TX_ST_IDLE",
        .handle = asc_tx_handle_idle,    
    },
};

/* RX STATUS and RX EVENT*/
typedef enum{
    AP_RX_EVENT_REQUEST = 0,
    AP_RX_EVENT_AP_READY,
    AP_RX_EVENT_AP_UNREADY,
    AP_RX_EVENT_STOP,
    AP_RX_EVENT_IDLE_TIMEOUT,
    AP_RX_EVENT_RESET,
    AP_RX_EVENT_NUM
} ap_rx_event;

typedef enum{
    AP_RX_ST_SLEEP = 0,
    AP_RX_ST_WAIT_READY,    
    AP_RX_ST_READY,
    AP_RX_ST_IDLE,
    AP_RX_ST_NUM
} ap_rx_state;

struct asc_rx_handle{
    struct asc_config cfg;
    atomic_t state;
    struct list_head user_list;
    struct asc_state_dsp *table;
    int ntf;
    /*process the event to switch different states*/
    struct task_struct  *thread;
    spinlock_t slock;
    wait_queue_head_t wait;
    struct mutex mlock;
    struct wake_lock wlock;
    struct timer_list timer;
    struct list_head event_q;
    struct list_head node;
    struct work_struct ntf_work;
};

static struct asc_config tx_cfg,rx_cfg;
static int asc_rx_handle_sleep(void *, int );
static int asc_rx_handle_wait_ready(void *, int );
static int asc_rx_handle_ready(void *, int );
static int asc_rx_handle_idle(void *, int );

/*the table used to discribe all rx states*/
static struct asc_state_dsp asc_rx_table[AP_RX_ST_NUM] = {
    [AP_RX_ST_SLEEP] = {
        .name = "AP_RX_ST_SLEEP",
        .handle = asc_rx_handle_sleep,    
    },
    [AP_RX_ST_WAIT_READY] = {
        .name = "AP_RX_ST_WAIT_READY",
        .handle = asc_rx_handle_wait_ready,    
    },
    [AP_RX_ST_READY] = {
        .name = "AP_RX_ST_READY",
        .handle = asc_rx_handle_ready,    
    },
    [AP_RX_ST_IDLE] = {
        .name = "AP_RX_ST_IDLE",
        .handle = asc_rx_handle_idle,    
    },
};

static int asc_tx_event_send(struct asc_tx_handle *tx, int id);
static void asc_tx_handle_reset(struct asc_tx_handle *tx);
static int asc_rx_event_send(struct asc_rx_handle *rx, int id);
static void asc_rx_handle_reset(struct asc_rx_handle *rx);

static struct asc_event * asc_event_malloc(void)
{
    int i = 0;
    unsigned long flags = 0;
    struct asc_event *event = NULL;
    
    spin_lock_irqsave(&hdlock, flags);
    for(i = 0; i < ASC_EVENT_POOL_MAX; i++){
        if(ASC_EVENT_UNUSE == event_pool[i].usage){
            event = &(event_pool[i]);
            event->usage = ASC_EVENT_STATIC;
        }
    }

    if(NULL == event){
        event = kmalloc(sizeof(struct asc_event), GFP_ATOMIC);
        if(event){
            event->usage = ASC_EVENT_DYNAMIC;
        }
    }
    spin_unlock_irqrestore(&hdlock, flags);
    return event;
}

static void asc_event_free(struct asc_event * event)
{
    unsigned long flags = 0;

    if(!event)
        return ;
    spin_lock_irqsave(&hdlock, flags);
    if(ASC_EVENT_STATIC == event->usage){
       memset(event, 0, sizeof(struct asc_event));
    }else{
       kfree(event);
    }
    spin_unlock_irqrestore(&hdlock, flags);
}
static irqreturn_t asc_irq_cp_indicate_state(int irq, void *data)
{
    int level;
    struct asc_tx_handle *tx = (struct asc_tx_handle *)data;
    struct asc_config *cfg = &tx->cfg;

    if (!oem_gpio_irq_isenable(cfg->gpio_ready) ||
        !oem_gpio_irq_isint(cfg->gpio_ready)){

		return IRQ_NONE;

    	}
	oem_gpio_irq_clear(cfg->gpio_ready);
    level = !!oem_gpio_get_value(cfg->gpio_ready);
    oem_gpio_set_irq_type(cfg->gpio_ready, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING);
    ASCDPRT("Irq %s cp_indicate_ap %s.\n", cfg->name, (level == cfg->polar)?"WAKEN":"SLEEP");
    if(level == cfg->polar){
        asc_tx_event_send(tx, AP_TX_EVENT_CP_READY);
    }else{
        /*do not care*/
        //asc_tx_event_send(tx, AP_TX_EVENT_CP_UNREADY);
    }
    oem_gpio_irq_unmask(cfg->gpio_ready);
    return IRQ_HANDLED;
}



static irqreturn_t asc_irq_cp_wake_ap(int irq, void *data)
{
    int level;
    struct asc_rx_handle *rx = (struct asc_rx_handle *)data;
    struct asc_config *cfg = &rx->cfg;

	if(!cfg||cfg->gpio_wake<=0){
		return IRQ_NONE;
	}
	
    if (!oem_gpio_irq_isenable(cfg->gpio_wake) ||
        !oem_gpio_irq_isint(cfg->gpio_wake)){
		return IRQ_NONE;
    }
	
	oem_gpio_irq_clear(cfg->gpio_wake);

    level = !!oem_gpio_get_value(cfg->gpio_wake);
    oem_gpio_set_irq_type(cfg->gpio_wake, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING);
    ASCDPRT("Irq %s cp_wake_ap, requset ap to be %s.\n", cfg->name, (level == cfg->polar)?"WAKEN":"SLEEP");

    if(level == cfg->polar){
        /*Cp requset Ap wake*/
        wake_lock(&rx->wlock);
        /*FIXME: jump to ready as soon as possible to avoid the AP_READY error indication to CBP */
        if(AP_RX_ST_IDLE == atomic_read(&rx->state)){
            ASCDPRT("Rx(%s): process event(%d) in state(%s).\n", cfg->name, AP_RX_EVENT_REQUEST, rx->table[AP_RX_ST_IDLE].name);
            asc_rx_handle_idle(rx, AP_RX_EVENT_REQUEST);
            ASCDPRT("Rx(%s): go into state(%s).\n", cfg->name, rx->table[atomic_read(&rx->state)].name);
        }else{
            asc_rx_event_send(rx, AP_RX_EVENT_REQUEST);
        }
    }else{
        /*Cp allow Ap sleep*/
        asc_rx_event_send(rx, AP_RX_EVENT_STOP);
    }

    oem_gpio_irq_unmask(cfg->gpio_wake);
    return IRQ_HANDLED;
}




static struct asc_tx_handle *asc_tx_handle_lookup(const char *name)
{
    unsigned long flags;
    struct asc_tx_handle *hd, *tmp, *t;

    if (!name)
        return NULL;

    hd = NULL;

    spin_lock_irqsave(&hdlock, flags);
    list_for_each_entry_safe(tmp, t, &asc_tx_handle_list, node) {
        if (!strncmp(name, tmp->cfg.name, ASC_NAME_LEN - 1)) {
            hd = tmp;
            break;
        }
    }
    spin_unlock_irqrestore(&hdlock, flags);
    return hd;
}

static struct asc_rx_handle *asc_rx_handle_lookup(const char *name)
{
    unsigned long flags;
    struct asc_rx_handle *hd, *tmp, *t;

    if (!name)
        return NULL;

    hd = NULL;
    spin_lock_irqsave(&hdlock, flags);
    list_for_each_entry_safe(tmp, t, &asc_rx_handle_list, node) {
        if (!strncmp(name, tmp->cfg.name, ASC_NAME_LEN - 1)) {
            hd = tmp;
            break;
        }
    }
    spin_unlock_irqrestore(&hdlock, flags);
    return hd;
}

irqreturn_t viatelcom_irq_cp_wake_ap(int irq, void *data){
    struct asc_rx_handle *rx;
	if(!isviatelcom||ap_ready_always)
		return IRQ_HANDLED;
	rx = asc_rx_handle_lookup(USB_RX_HD_NAME);
		return asc_irq_cp_wake_ap(irq,rx);
}

static struct asc_user *asc_tx_user_lookup(struct asc_tx_handle *tx, const char *name)
{
    unsigned long flags = 0;
    struct asc_user *user = NULL, *tmp = NULL, *t = NULL;

    if (!name)
        return NULL;

    spin_lock_irqsave(&tx->slock, flags);
    list_for_each_entry_safe(tmp, t, &tx->user_list, node) {
        if (!strncmp(name, tmp->infor.name, ASC_NAME_LEN - 1)) {
            user = tmp;
            break;
        }
    }
    spin_unlock_irqrestore(&tx->slock, flags);

    return user;
}

static struct asc_user *asc_rx_user_lookup(struct asc_rx_handle *rx, const char *name)
{
    unsigned long flags = 0;
    struct asc_user *user = NULL, *tmp = NULL, *t = NULL;

    if (!name)
        return NULL;

    spin_lock_irqsave(&rx->slock, flags);
    list_for_each_entry_safe(tmp, t, &rx->user_list, node) {
        if (!strncmp(name, tmp->infor.name, ASC_NAME_LEN - 1)) {
            user = tmp;
            break;
        }
    }
    spin_unlock_irqrestore(&rx->slock, flags);

    return user;
}

static inline void asc_rx_indicate_wake(struct asc_rx_handle *rx)
{
    if(rx->cfg.gpio_ready >= 0)
        oem_gpio_direction_output(rx->cfg.gpio_ready, rx->cfg.polar);
}

static inline void asc_rx_indicate_sleep(struct asc_rx_handle *rx)
{
    if(rx->cfg.gpio_ready >= 0)
        oem_gpio_direction_output(rx->cfg.gpio_ready, !rx->cfg.polar);
}

static int asc_rx_event_send(struct asc_rx_handle *rx, int id)
{
    unsigned long flags = 0;
    struct asc_event *event = NULL;
    int ret = -ENODEV;

    if(rx->thread == NULL){
        ASCPRT("%s:no thread for event\n", __FUNCTION__);
        return ret;
    }

    /*check whether the event is cared by current charge state*/
    if(id >= 0){
        event = asc_event_malloc();
        if(!event){
            ASCPRT("No memory to create new event.\n");
            ret = -ENOMEM;
            goto send_event_error;
        }
        /*insert a new event to the list tail and wakeup the process thread*/
        //ASCDPRT("Rx(%s):send event(%d)  to state(%s).\n", rx->name, id, rx->table[atomic_read(&rx->state)].name);
        event->id = id;
        spin_lock_irqsave(&rx->slock, flags);
        if(AP_RX_EVENT_RESET == id){
            list_add(&event->list, &rx->event_q);
        }else{
            list_add_tail(&event->list, &rx->event_q);
        }
        spin_unlock_irqrestore(&rx->slock, flags);
        wake_up(&rx->wait);
    }
    ret = 0;
send_event_error:
    return ret;
}

static int asc_rx_event_recv(struct asc_rx_handle *rx)
{
    unsigned long flags = 0;
    struct asc_event *event = NULL;
    int ret = -ENODEV;

    if(rx->thread == NULL){
        ASCPRT("%s:no thread for event\n", __FUNCTION__);
        return ret;
    }

    spin_lock_irqsave(&rx->slock, flags);
    if(!list_empty(&rx->event_q)){
        event = list_first_entry(&rx->event_q, struct asc_event, list);
        list_del(&event->list);
    }
    spin_unlock_irqrestore(&rx->slock, flags);

    if(event){
         ret = event->id;
         asc_event_free(event);
    }
    return ret;
}

static int asc_rx_event_thread(void *data)
{
    struct asc_rx_handle *rx = (struct asc_rx_handle *)data; 
    int id = 0, index;
    char name[ASC_NAME_LEN] = {0};
    struct asc_state_dsp *dsp = NULL;

    rx->thread = current;
    snprintf(name, ASC_NAME_LEN, "asc_rx_%s", rx->cfg.name);
    daemonize(name);
    ASCDPRT("%s thread start now.\n", name);

    while(1){        
        /*sleep until receive an evnet or thread exist*/
        wait_event(rx->wait, ((id=asc_rx_event_recv(rx)) >= 0) || (!rx->thread));
        /*thread is existed*/
        if(!rx->thread){
		break;
        }

        mutex_lock(&rx->mlock);
        if(AP_RX_EVENT_RESET == id){
            asc_rx_handle_reset(rx);
        }else{
            index = atomic_read(&rx->state);
            dsp = rx->table + index;
            if(dsp->handle){
                ASCDPRT("Rx(%s): process event(%d) in state(%s).\n", rx->cfg.name, id, dsp->name);
                dsp->handle(rx, id);
                ASCDPRT("Rx(%s): go into state(%s).\n", rx->cfg.name, rx->table[atomic_read(&rx->state)].name);
            }
        }
        mutex_unlock(&rx->mlock);
    }

    ASCDPRT("%s thread exit.\n", name);
    kfree(rx);
    return 0;
}

static void asc_rx_event_timer(unsigned long data)
{
    struct asc_rx_handle *rx = (struct asc_rx_handle *)data; 
    //ASCDPRT("%s timer is  time out.\n", rx->name);
    asc_rx_event_send(rx, AP_RX_EVENT_IDLE_TIMEOUT);
}

static void asc_tx_notifier_work(struct work_struct *work)
{
    struct asc_infor *infor;
    struct asc_user *user = NULL, *t = NULL;
	struct asc_tx_handle *tx = container_of(work, struct asc_tx_handle,
					       ntf_work);

    list_for_each_entry_safe(user, t, &tx->user_list, node){
        infor = &user->infor;
        if(infor->notifier){
            infor->notifier(tx->ntf, infor->data);
        }
    }
}

static void asc_rx_notifier_work(struct work_struct *work)
{
    struct asc_infor *infor;
    struct asc_user *user = NULL, *t = NULL;
	struct asc_rx_handle *rx = container_of(work, struct asc_rx_handle,
					       ntf_work);

    list_for_each_entry_safe(user, t, &rx->user_list, node){
        infor = &user->infor;
        if(infor->notifier){
            infor->notifier(rx->ntf, infor->data);
        }
    }
}

static void asc_tx_notifier(struct asc_tx_handle *tx, int ntf)
{
    tx->ntf = ntf;
    queue_work(asc_work_queue, &tx->ntf_work);
}

static void asc_rx_notifier(struct asc_rx_handle *rx, int ntf)
{
    rx->ntf = ntf;
    queue_work(asc_work_queue, &rx->ntf_work);
}

static int asc_rx_handle_init(struct asc_rx_handle *rx)
{
    int ret = 0;
    char *name = NULL;
    struct asc_config *cfg = &rx->cfg;

    if(cfg->gpio_ready >= 0){
        ret = oem_gpio_request(cfg->gpio_ready, "ap_ready");
        if(ret < 0){
            ASCPRT("Fail to requset ap_ready gpio %d for %s.\n", cfg->gpio_ready, cfg->name);
            goto err_request_gpio_ap_ready;
        }
        if(ap_ready_always)
            oem_gpio_output(cfg->gpio_ready, cfg->polar);
        else
            asc_rx_indicate_sleep(rx);
    }

    if(cfg->gpio_wake >= 0){
        ret = oem_gpio_request(cfg->gpio_wake, "cp_wake_ap");
        if(ret < 0){
            ASCPRT("Fail to requset cp_wake_ap gpio %d for %s.\n", cfg->gpio_wake, cfg->name);
            goto err_request_gpio_cp_wake_ap;
        }
        
        oem_gpio_irq_mask(cfg->gpio_wake);
        oem_gpio_direction_input_for_irq(cfg->gpio_wake);
        oem_gpio_set_irq_type(cfg->gpio_wake, IRQF_TRIGGER_RISING);
        ret = oem_gpio_request_irq(cfg->gpio_wake, asc_irq_cp_wake_ap, IRQF_SHARED | IRQF_NO_SUSPEND, "cp_wake_ap", rx);
		printk("asc_rx_handle_init call oem_gpio_irq_unmask %d\n",cfg->gpio_wake);
        oem_gpio_irq_unmask(cfg->gpio_wake);
        if (ret < 0) {
            ASCPRT("fail to request cp_wake_ap irq for %s\n", cfg->name);
            goto err_req_irq_cp_wake_ap;
        }
    }

    rx->table = asc_rx_table;
    mutex_init(&rx->mlock);
    INIT_LIST_HEAD(&rx->event_q);
    INIT_LIST_HEAD(&rx->user_list);
    spin_lock_init(&rx->slock);
    setup_timer(&rx->timer, asc_rx_event_timer, (unsigned long)rx);
    name = kzalloc(ASC_NAME_LEN, GFP_KERNEL);
    if(!name){
        ret = -ENOMEM;
        ASCPRT("%s: no memory to malloc for wake lock name\n", __FUNCTION__);
        goto err_malloc_name;
    }
    snprintf(name, ASC_NAME_LEN, "asc_rx_%s", rx->cfg.name);
    wake_lock_init(&rx->wlock, WAKE_LOCK_SUSPEND, name);
    init_waitqueue_head(&rx->wait);
    INIT_WORK(&rx->ntf_work, asc_rx_notifier_work);
    if(ap_ready_always)
        atomic_set(&rx->state, AP_RX_ST_READY);
    else
        atomic_set(&rx->state, AP_RX_ST_SLEEP);
    ret = kernel_thread(asc_rx_event_thread, rx, 0);
    if(ret < 0){
        ASCPRT("Fail to create %s rx thread.\n", rx->cfg.name);
        goto err_create_rx_thread;
    }

    if(!!oem_gpio_get_value(cfg->gpio_wake) == cfg->polar){
        asc_rx_event_send(rx, AP_RX_EVENT_REQUEST);
    }
    
    return 0;

err_create_rx_thread:
    if(name)
        kfree(name);
err_malloc_name:
    if(cfg->gpio_wake >= 0)
        free_irq(oem_gpio_to_irq(cfg->gpio_wake), rx);
err_req_irq_cp_wake_ap:
    if(cfg->gpio_wake)
        oem_gpio_free(cfg->gpio_wake);
err_request_gpio_cp_wake_ap:
    if(cfg->gpio_ready >= 0)
        oem_gpio_free(cfg->gpio_ready);
err_request_gpio_ap_ready:
    return ret;
}

static int asc_rx_handle_sleep(void *data, int event)
{
    int ret = 0;
    struct asc_rx_handle *rx = (struct asc_rx_handle *)data;

    //ASCDPRT("Rx(%s): process event(%d) in state(%s).\n", rx->name, event, rx->table[atomic_read(&rx->state)].name);

    if(AP_RX_ST_SLEEP != atomic_read(&rx->state)){
        return 0;
    }

    switch(event){
        case AP_RX_EVENT_REQUEST:
            wake_lock(&rx->wlock);
            atomic_set(&rx->state, AP_RX_ST_WAIT_READY);
            asc_rx_notifier(rx, ASC_NTF_RX_PREPARE);
            break;
         default:
            ASCDPRT("ignore the rx event %d in state(%s)", event, rx->table[atomic_read(&rx->state)].name);
    }

    //ASCDPRT("Rx(%s): go into state(%s).\n", rx->name, rx->table[atomic_read(&rx->state)].name);
    return ret;
}

static int asc_rx_handle_wait_ready(void *data, int event)
{
    int ret = 0;
    struct asc_rx_handle *rx = (struct asc_rx_handle *)data;

    //ASCDPRT("Rx(%s): process event(%d) in state(%s).\n", rx->name, event, rx->table[atomic_read(&rx->state)].name);

    if(AP_RX_ST_WAIT_READY != atomic_read(&rx->state)){
        return 0;
    }

    switch(event){
        case AP_RX_EVENT_AP_READY:
            /*need ack ready to cp, do nothing if no gpio for ap_ready*/
            asc_rx_indicate_wake(rx);
            atomic_set(&rx->state, AP_RX_ST_READY);
            break;
         case AP_RX_EVENT_AP_UNREADY:
         case AP_RX_EVENT_STOP:
            atomic_set(&rx->state, AP_RX_ST_SLEEP);
            asc_rx_notifier(rx, ASC_NTF_RX_POST);
            /*need ack ready to cp, do nothing if no gpio for ap_ready*/
            asc_rx_indicate_sleep(rx);
            wake_unlock(&rx->wlock);
            break;
         default:
            ASCDPRT("ignore the rx event %d in state(%s)", event, rx->table[atomic_read(&rx->state)].name);
    }

    //ASCDPRT("Rx(%s): go into state(%s).\n", rx->name, rx->table[atomic_read(&rx->state)].name);
    return ret;
}

static int asc_rx_handle_ready(void *data, int event)
{
    int ret = 0;
    struct asc_rx_handle *rx = (struct asc_rx_handle *)data;

    //ASCDPRT("Rx(%s): process event(%d) in state(%s).\n", rx->name, event, rx->table[atomic_read(&rx->state)].name);

    if(AP_RX_ST_READY != atomic_read(&rx->state)){
        return 0;
    }

    switch(event){
        case AP_RX_EVENT_STOP:
            atomic_set(&rx->state, AP_RX_ST_IDLE);
            mod_timer(&rx->timer, jiffies + msecs_to_jiffies(ASC_RX_WAIT_IDLE_TIME));
            break;
         default:
            ASCDPRT("ignore the rx event %d in state(%s)", event, rx->table[atomic_read(&rx->state)].name);
    }

    //ASCDPRT("Rx(%s): go into state(%s).\n", rx->name, rx->table[atomic_read(&rx->state)].name);
    return ret;
}

static int asc_rx_handle_idle(void *data, int event)
{
    int ret = 0;
    unsigned long flags = 0; 
    struct asc_rx_handle *rx = (struct asc_rx_handle *)data;

    //ASCDPRT("Rx(%s): process event(%d) in state(%s).\n", rx->name, event, rx->table[atomic_read(&rx->state)].name);
    
    if(AP_RX_ST_IDLE != atomic_read(&rx->state)){
        return 0;
    }

    /*FIXME: prevent from scheduled and interrupted to avoid error indication to CBP*/
    spin_lock_irqsave(&rx->slock, flags);

    switch(event){
        case AP_RX_EVENT_REQUEST:
            del_timer(&rx->timer);
            atomic_set(&rx->state, AP_RX_ST_READY);
            break;
 
         case AP_RX_EVENT_IDLE_TIMEOUT:
            asc_rx_notifier(rx, ASC_NTF_RX_POST);
            atomic_set(&rx->state, AP_RX_ST_SLEEP);
            /*need ack ready to cp, do nothing if no gpio for ap_ready*/
            asc_rx_indicate_sleep(rx);
            wake_unlock(&rx->wlock);
            break;

         default:
            ASCDPRT("ignore the rx event %d in state(%s)", event, rx->table[atomic_read(&rx->state)].name);
    }

    spin_unlock_irqrestore(&rx->slock, flags);

    //ASCDPRT("Rx(%s): go into state(%s).\n", rx->name, rx->table[atomic_read(&rx->state)].name);
    return ret;
}

static void asc_tx_trig_busy(struct asc_tx_handle *tx)
{
    mod_timer(&tx->timer_wait_idle, jiffies +  msecs_to_jiffies(tx->auto_delay));
}

static inline void asc_tx_wake_cp(struct asc_tx_handle *tx)
{
    if(tx->cfg.gpio_wake >= 0)
        oem_gpio_direction_output(tx->cfg.gpio_wake, tx->cfg.polar);
}

static inline void asc_tx_sleep_cp(struct asc_tx_handle *tx)
{
    if(tx->cfg.gpio_wake >= 0)
        oem_gpio_direction_output(tx->cfg.gpio_wake, !tx->cfg.polar);
}

static inline int asc_tx_cp_be_ready(struct asc_tx_handle *tx)
{
    int ret = 0;

    if(tx->cfg.gpio_ready >= 0)
        ret = ((!!oem_gpio_get_value(tx->cfg.gpio_ready)) == (tx->cfg.polar));

    return ret;
}


static int asc_tx_event_send(struct asc_tx_handle *tx, int id)
{
    unsigned long flags = 0;
    struct asc_event *event = NULL;
    int ret = -ENODEV;

    if(tx->thread == NULL){
        ASCPRT("%s:no thread for event\n", __FUNCTION__);
        return ret;
    }

    /*check whether the event is cared by current charge state*/
    if(id >= 0){
        event = asc_event_malloc();
        if(!event){
            ASCPRT("No memory to create new event.\n");
            ret = -ENOMEM;
            goto send_event_error;
        }
        /*insert a new event to the list tail and wakeup the process thread*/
        //ASCDPRT("Send tx event(%d)  to state(%s).\n", id, tx->table[atomic_read(&tx->state)].name);
        event->id = id;
        spin_lock_irqsave(&tx->slock, flags);
        if(AP_TX_EVENT_RESET == id){
            list_add(&event->list, &tx->event_q);
        }else{
            list_add_tail(&event->list, &tx->event_q);
        }
        spin_unlock_irqrestore(&tx->slock, flags);
        wake_up(&tx->wait);
    }
send_event_error:
    return ret;
}

static int asc_tx_event_recv(struct asc_tx_handle *tx)
{
    unsigned long flags = 0;
    struct asc_event *event = NULL;
    int ret = -ENODEV;

    if(tx->thread == NULL){
        ASCPRT("%s:no thread for event\n", __FUNCTION__);
        return ret;
    }
     
    spin_lock_irqsave(&tx->slock, flags);
    if(!list_empty(&tx->event_q)){
        event = list_first_entry(&tx->event_q, struct asc_event, list);
        list_del(&event->list);
    }
    spin_unlock_irqrestore(&tx->slock, flags);

    if(event){
        ret = event->id;
        asc_event_free(event);
    }
    return ret;
}

static int asc_tx_get_user(struct asc_tx_handle *tx, const char *name)
{
    int ret = 0;
    struct asc_user *user = NULL;

    user = asc_tx_user_lookup(tx, name);
    if(user){
        atomic_inc(&user->count);
    }else{
        ret = -ENODEV;
    }

    return ret;
}
static int asc_tx_put_user(struct asc_tx_handle *tx, const char *name)
{
    struct asc_user *user = NULL;
    int ret = 0;

    user = asc_tx_user_lookup(tx, name);

    if(user){
        if(atomic_read(&user->count) >= 1){
            atomic_dec(&user->count);
        }
    }else{
        ret = -ENODEV;
    }
    
    return ret;
}

static int asc_tx_refer(struct asc_tx_handle *tx, const char *name)
{    
    unsigned long flags = 0;
    struct asc_user *user = NULL, *t = NULL;
    int count = 0;

    if(name){
        /*get the reference count of the user*/
        user = asc_tx_user_lookup(tx, name);
        if(user){
            count = atomic_read(&user->count);
        }
    }else{
        spin_lock_irqsave(&tx->slock, flags);
        list_for_each_entry_safe(user, t, &tx->user_list, node) {
            count += atomic_read(&user->count);
        }
        spin_unlock_irqrestore(&tx->slock, flags);
    }

    return count;
}

static int asc_rx_refer(struct asc_rx_handle *rx, const char *name)
{    
    unsigned long flags = 0;
    struct asc_user *user = NULL, *t = NULL;
    int count = 0;

    if(name){
        /*get the reference count of the user*/
        user = asc_rx_user_lookup(rx, name);
        if(user){
            count = atomic_read(&user->count);
        }
    }else{
        spin_lock_irqsave(&rx->slock, flags);
        list_for_each_entry_safe(user, t, &rx->user_list, node) {
            count += atomic_read(&user->count);
        }
        spin_unlock_irqrestore(&rx->slock, flags);
    }

    return count;
}

static void asc_tx_refer_clear(struct asc_tx_handle *tx)
{    
    unsigned long flags = 0;
    struct asc_user *user = NULL, *t = NULL;

    spin_lock_irqsave(&tx->slock, flags);
    list_for_each_entry_safe(user, t, &tx->user_list, node) {
        atomic_set(&user->count, 0);
    }
    spin_unlock_irqrestore(&tx->slock, flags);
}

static int asc_tx_event_thread(void *data)
{
    struct asc_tx_handle *tx = (struct asc_tx_handle *)data; 
    int id = 0, index;
    char name[ASC_NAME_LEN] = {0};
    struct asc_state_dsp *dsp = NULL;

    snprintf(name, ASC_NAME_LEN, "asc_tx_%s", tx->cfg.name);
    tx->thread = current;
    daemonize(name);
    ASCDPRT("%s thread start now.\n", name);

    while(1){        
        /*sleep until receive an evnet or thread exist*/
        wait_event(tx->wait, ((id=asc_tx_event_recv(tx)) >= 0) || (!tx->thread) );
        /*thread is existed*/
        if(!tx->thread){
		break;
        }

        mutex_lock(&tx->mlock);
        if(AP_TX_EVENT_RESET == id){
            asc_tx_handle_reset(tx);
        }else{
            index = atomic_read(&tx->state);
            dsp = tx->table + index;
            if(dsp->handle){
                ASCDPRT("Tx(%s): process event(%d) in state(%s).\n", tx->cfg.name, id, dsp->name);
                dsp->handle(tx, id);
                ASCDPRT("Tx(%s): go into state(%s) .\n", tx->cfg.name, tx->table[atomic_read(&tx->state)].name);
            }
        }
        mutex_unlock(&tx->mlock);
    }

    ASCDPRT("%s thread exit.\n", name);
    kfree(tx);
    return 0;
}

static void asc_tx_wait_ready_timer(unsigned long data)
{
    struct asc_tx_handle *tx = (struct asc_tx_handle *)data; 
    //ASCDPRT("%s tx wait ready timer is timeout.\n", tx->name);
    asc_tx_event_send(tx, AP_TX_EVENT_WAIT_TIMEOUT);
}

static void asc_tx_wait_idle_timer(unsigned long data)
{
    char path[ASC_NAME_LEN] = {0};
    struct asc_tx_handle *tx = (struct asc_tx_handle *)data; 
    //ASCDPRT("%s tx wait idle timer is timeout.\n", tx->name);
    snprintf(path, ASC_NAME_LEN, "%s.%s", tx->cfg.name, ASC_TX_AUTO_USER);
    asc_tx_put_ready(path, 0);
}

static void asc_tx_wait_sleep_timer(unsigned long data)
{
    struct asc_tx_handle *tx = (struct asc_tx_handle *)data; 
    //ASCDPRT("%s tx wait sleep timer is timeout.\n", tx->name);
    asc_tx_event_send(tx, AP_TX_EVENT_IDLE_TIMEOUT);
}

static int asc_tx_handle_init(struct asc_tx_handle *tx)
{
    int ret = 0;
    char *name = NULL;
    struct asc_config *cfg = &tx->cfg;

    ret = oem_gpio_request(cfg->gpio_wake, "ap_wake_cp");
    if(ret < 0){
        ASCPRT("Fail to requset ap_wake_cp gpio %d for %s.\n", cfg->gpio_wake, cfg->name);
        goto err_request_gpio_ap_wake_cp;
    }

    if(cfg->gpio_ready >= 0){
        ret = oem_gpio_request(cfg->gpio_ready, "cp_ready");
        if(ret < 0){
            ASCPRT("Fail to requset cp_ready gpio %d for %s.\n", cfg->gpio_ready, cfg->name);
            goto err_request_gpio_cp_ready;
        }

        oem_gpio_irq_mask(cfg->gpio_ready);
        oem_gpio_direction_input_for_irq(cfg->gpio_ready);
        oem_gpio_set_irq_type(cfg->gpio_ready, IRQF_TRIGGER_RISING);
        ret = oem_gpio_request_irq(cfg->gpio_ready, asc_irq_cp_indicate_state, 
                        IRQF_SHARED, "cp_indicate_state", tx);
        oem_gpio_irq_unmask(cfg->gpio_ready);
        if (ret < 0) {
            ASCPRT("fail to request irq for %s:cp_ready\n", cfg->name);
            goto err_req_irq_cp_indicate_state;
        }
    }
    asc_tx_sleep_cp(tx);

    tx->auto_delay = ASC_TX_AUTO_DELAY_TIME;
    tx->table = asc_tx_table;
    mutex_init(&tx->mlock);
    INIT_LIST_HEAD(&tx->event_q);
    INIT_LIST_HEAD(&tx->user_list);
    spin_lock_init(&tx->slock);
    name = kzalloc(ASC_NAME_LEN, GFP_KERNEL);
    if(!name){
        ret = -ENOMEM;
        ASCPRT("%s: no memory to malloc for wake lock name\n", __FUNCTION__);
        goto err_malloc_name;
    }
    snprintf(name, ASC_NAME_LEN, "asc_tx_%s", tx->cfg.name);
    wake_lock_init(&tx->wlock, WAKE_LOCK_SUSPEND, name);
    init_waitqueue_head(&tx->wait);
    init_waitqueue_head(&tx->wait_tx_state);
    setup_timer(&tx->timer_wait_ready, asc_tx_wait_ready_timer, (unsigned long)tx);
    setup_timer(&tx->timer_wait_idle, asc_tx_wait_idle_timer, (unsigned long)tx);
    setup_timer(&tx->timer_wait_sleep, asc_tx_wait_sleep_timer, (unsigned long)tx);
    atomic_set(&tx->state, AP_TX_ST_SLEEP);
    atomic_set(&tx->count, 0);
    INIT_WORK(&tx->ntf_work, asc_tx_notifier_work);
    ret = kernel_thread(asc_tx_event_thread, tx, 0);
    if(ret < 0){
        ASCPRT("Fail to create %s tx thread.\n", tx->cfg.name);
        goto err_create_tx_event_thread;
    }

    return 0;
err_create_tx_event_thread:
    if(cfg->gpio_ready >= 0)
        free_irq(oem_gpio_to_irq(cfg->gpio_ready), tx);
err_malloc_name:
    if(name)
        kfree(name);
err_req_irq_cp_indicate_state:
    if(cfg->gpio_ready >= 0)
        oem_gpio_free(cfg->gpio_ready);
err_request_gpio_cp_ready:
    if(cfg->gpio_wake >= 0)
        oem_gpio_free(cfg->gpio_wake);
err_request_gpio_ap_wake_cp:
    return ret;
}

static int asc_tx_handle_sleep(void *data, int event)
{
    int ret = 0;
    struct asc_tx_handle *tx = (struct asc_tx_handle *)data;

    //ASCDPRT("Tx(%s): process event(%d) in state(%s).\n", tx->name, event, tx->table[atomic_read(&tx->state)].name);
    
    if(AP_TX_ST_SLEEP != atomic_read(&tx->state)){
        return 0;
    }

    switch(event){
        case AP_TX_EVENT_REQUEST:
            wake_lock(&tx->wlock);
            asc_tx_wake_cp(tx);
            if(tx->cfg.gpio_ready >= 0){
                mod_timer(&tx->timer_wait_ready, jiffies + msecs_to_jiffies(ASC_TX_WAIT_READY_TIME));
                atomic_set(&tx->state, AP_TX_ST_WAIT_READY);
                if(asc_tx_cp_be_ready(tx)){
                    mdelay(ASC_TX_DEBOUNCE_TIME);//debounce wait, make sure CBP has already be ready
                    if(asc_tx_cp_be_ready(tx)){
                        ASCDPRT("Tx:cp %s was ready now.\n", tx->cfg.name);
                        asc_tx_handle_wait_ready(tx, AP_TX_EVENT_CP_READY);
                    }
                }
            }else{
                mdelay(ASC_TX_DEBOUNCE_TIME);
                atomic_set(&tx->state, AP_TX_ST_WAIT_READY);
                asc_tx_handle_wait_ready(tx, AP_TX_EVENT_CP_READY);
            }
            break;
         default:
            ASCDPRT("Tx: ignore event %d in state(%s)", event, tx->table[atomic_read(&tx->state)].name);
    }

    //ASCDPRT("Tx(%s): go into state(%s).\n", tx->name, tx->table[atomic_read(&tx->state)].name);
    return ret;
}

static int asc_tx_handle_wait_ready(void *data, int event)
{
    int ret = 0;
    struct asc_tx_handle *tx = (struct asc_tx_handle *)data;

    if(AP_TX_ST_WAIT_READY != atomic_read(&tx->state)){
        return 0;
    }
    //ASCDPRT("Tx(%s): process event(%d) in state(%s).\n", tx->name, event, tx->table[atomic_read(&tx->state)].name);
    switch(event){
        case AP_TX_EVENT_CP_READY:
            del_timer(&tx->timer_wait_ready);
            tx->wait_try = 0;
            atomic_set(&tx->state, AP_TX_ST_READY);
            wake_up_interruptible_all(&tx->wait_tx_state);
            if(asc_tx_refer(tx, ASC_TX_AUTO_USER) > 0){
                asc_tx_trig_busy(tx);
            }
            asc_tx_notifier(tx, ASC_NTF_TX_READY);
            break;
       case AP_TX_EVENT_WAIT_TIMEOUT:
            ASCPRT("Tx: %s wait cp ready timeout,  try=%d.\n", tx->cfg.name, tx->wait_try);
			
			{
				//kevin add .i dont know who disable irq after resume,so i reeanble it
				oem_gpio_direction_input_for_irq(GPIO_VIATEL_USB_MDM_RDY);
				oem_gpio_set_irq_type(GPIO_VIATEL_USB_MDM_RDY,(IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING));
				oem_gpio_irq_unmask(GPIO_VIATEL_USB_MDM_RDY);
				
			}
			
            asc_tx_sleep_cp(tx);
            mdelay(ASC_TX_DEBOUNCE_TIME);//delay to create a implus
            atomic_set(&tx->state, AP_TX_ST_SLEEP);
            if(tx->wait_try++ <= ASC_TX_TRY_TIMES){
                asc_tx_event_send(tx, AP_TX_EVENT_REQUEST);
            }else{
                tx->wait_try = 0;
                atomic_set(&tx->state, AP_TX_ST_SLEEP);
                asc_tx_refer_clear(tx);
                wake_up_interruptible_all(&tx->wait_tx_state);
                wake_unlock(&tx->wlock);
                asc_tx_notifier(tx, ASC_NTF_TX_UNREADY);
                ASCPRT("try out to wake %s.\n", tx->cfg.name);
            }
            break;
       case AP_TX_EVENT_STOP:
            asc_tx_sleep_cp(tx);
            del_timer(&tx->timer_wait_ready);
            tx->wait_try = 0;
            atomic_set(&tx->state, AP_TX_ST_SLEEP);
            wake_unlock(&tx->wlock);
            wake_up_interruptible_all(&tx->wait_tx_state);
            break;
       default:
            ASCDPRT("Tx: ignore event %d in state(%s)", event, tx->table[atomic_read(&tx->state)].name);
    }

    //ASCDPRT("Tx(%s): go into state(%s).\n", tx->name, tx->table[atomic_read(&tx->state)].name);
    return ret;
}

static int asc_tx_handle_ready(void *data, int event)
{
    int ret = 0;
    struct asc_tx_handle *tx = (struct asc_tx_handle *)data;

    if(AP_TX_ST_READY != atomic_read(&tx->state)){
        return 0;
    }
    //ASCDPRT("Tx(%s): process event(%d) in state(%s).\n", tx->name, event, tx->table[atomic_read(&tx->state)].name);
    switch(event){
        case AP_TX_EVENT_STOP:
            del_timer(&tx->timer_wait_idle);
            asc_tx_sleep_cp(tx);
            atomic_set(&tx->state, AP_TX_ST_SLEEP);
            wake_unlock(&tx->wlock);
            //mod_timer(&tx->timer_wait_sleep, jiffies + msecs_to_jiffies(ASC_TX_WAIT_IDLE_TIME));
            break;
        default:
            ASCDPRT("Tx: ignore event %d in state(%s)", event, tx->table[atomic_read(&tx->state)].name);
    }

    //ASCDPRT("Tx(%s): go into state(%s).\n", tx->name, tx->table[atomic_read(&tx->state)].name);
    return ret;
}

/*Ignore the idle state, wait for a while to let CBP go to sleep*/
static int asc_tx_handle_idle(void *data, int event)
{
    int ret = 0;
    struct asc_tx_handle *tx = (struct asc_tx_handle *)data;

    if(AP_TX_ST_IDLE != atomic_read(&tx->state)){
        return 0;
    }

    //ASCDPRT("Tx(%s): process event(%d) in state(%s).\n", tx->name, event, tx->table[atomic_read(&tx->state)].name);
    switch(event){
        case AP_TX_EVENT_IDLE_TIMEOUT:
            atomic_set(&tx->state, AP_TX_ST_SLEEP);
            wake_unlock(&tx->wlock);
            break;
        case AP_TX_EVENT_REQUEST:
            del_timer(&tx->timer_wait_sleep);
            atomic_set(&tx->state, AP_TX_ST_SLEEP);
            /*loop back to SLEEP handle*/
            asc_tx_event_send(tx, AP_TX_EVENT_REQUEST);
            break;
        default:
            ASCDPRT("Tx: ignore event %d in state(%s)", event, tx->table[atomic_read(&tx->state)].name);
    }

    //ASCDPRT("Tx(%s): go into state(%s).\n", tx->name, tx->table[atomic_read(&tx->state)].name);
    return ret;
}

static void asc_tx_handle_reset(struct asc_tx_handle *tx)
{
    unsigned long flags;
 
    ASCDPRT("%s %s\n", __FUNCTION__, tx->cfg.name);
    del_timer(&tx->timer_wait_ready);
    del_timer(&tx->timer_wait_idle);
    del_timer(&tx->timer_wait_sleep);
    spin_lock_irqsave(&tx->slock, flags);
    INIT_LIST_HEAD(&tx->event_q);
    spin_unlock_irqrestore(&tx->slock, flags);
    asc_tx_sleep_cp(tx);
    atomic_set(&tx->state, AP_TX_ST_SLEEP);
    wake_unlock(&tx->wlock);
}

/**
 * asc_tx_reset - reset the tx handle 
 * @name: the config name for the handle
 *
 * return 0 ok, others be error
 */
void asc_tx_reset(const char *name)
{
    struct asc_tx_handle *tx = NULL;

    tx = asc_tx_handle_lookup(name);
    if(tx){
        asc_tx_event_send(tx, AP_TX_EVENT_RESET);
    }
}
EXPORT_SYMBOL(asc_tx_reset);

/**
 * asc_tx_set_auto_delay - change the delay time for auto ready
 * @name: the config name for the handle
 * @delay: the time for auto ready which is valid while more than default value
 * return 0 ok,others be error
 */
int asc_tx_set_auto_delay(const char *name, int delay)
{
    int ret = 0;
    unsigned long flags;
    struct asc_tx_handle *tx;

    tx = asc_tx_handle_lookup(name);
    if(!tx){
        ret = -ENODEV;
        goto end;
    }
    if(delay > 0){
        spin_lock_irqsave(&tx->slock, flags);
        tx->auto_delay = delay;
        spin_unlock_irqrestore(&tx->slock, flags);
    }
    
end:
    return ret;
}
EXPORT_SYMBOL(asc_tx_set_auto_delay);

/**
 * asc_tx_check_ready - check whether tx tanslation has alreay be ready
 * @name: the config name for the handle
 *
 * return 1 waken, 0 not, others be error
 */
int asc_tx_check_ready(const char *name)
{
    int ret = 0;
    struct asc_tx_handle *tx;

    tx = asc_tx_handle_lookup(name);
    if(NULL == tx)
        return -ENODEV;

    ret = atomic_read(&tx->state);

    if(ret == AP_TX_ST_READY){
        ret = 1;
    }else{
        ret = 0;
    }

    return ret;
}
EXPORT_SYMBOL(asc_tx_check_ready);

/**
 * asc_tx_user_counts - get the refernce count of the user or the handle
 * @path: (handle name).[user name]
 * If user name is NULL, return the count of tx handle.
 * others return the count of the tx user
 */
int asc_tx_user_count(const char *path)
{
    const char *name;
    char hname[ASC_NAME_LEN] = {0};
    struct asc_tx_handle *tx = NULL;

    name = strchr(path, '.');
    if (name){ 
        memcpy(hname, path, min(name - path, ASC_NAME_LEN - 1));
        name++;
    }else {
        strncpy(hname, path, ASC_NAME_LEN - 1);
    }

    tx = asc_tx_handle_lookup(hname);
    
    if(NULL == tx)
        return -ENODEV;

    return asc_tx_refer(tx, name);
}
EXPORT_SYMBOL(asc_tx_user_count);

/**
 * asc_tx_add_user - add a user for tx handle
 * @name: the config name for the handle
 * @infor: the user information
 *
 * return 0,  others be error
 */
int asc_tx_add_user(const char *name, struct asc_infor *infor)
{
    int ret = 0;
    unsigned long flags = 0;
    struct asc_tx_handle *tx;
    struct asc_user *user;

    tx = asc_tx_handle_lookup(name);
    if(NULL == tx)
        return -ENODEV;

    user = asc_tx_user_lookup(tx, infor->name);
    if(NULL == user){
        user = kzalloc(sizeof(*user), GFP_KERNEL);
        if(!user){
            ASCPRT("No memory to create new user reference.\n");
            ret = -ENOMEM;
            goto error;
        }
        user->infor.data = infor->data;
        user->infor.notifier = infor->notifier;
        strncpy(user->infor.name, infor->name, ASC_NAME_LEN - 1);
        atomic_set(&user->count, 0);
        spin_lock_irqsave(&tx->slock, flags);
        list_add_tail(&user->node, &tx->user_list);
        spin_unlock_irqrestore(&tx->slock, flags);
    }else{
        ASCPRT("%s error: user %s already exist!!\n", __FUNCTION__, infor->name);
        ret = -EINVAL;
    }
error:
    return ret;
}
EXPORT_SYMBOL(asc_tx_add_user);

/**
 * asc_tx_del_user - delete a user for tx handle
 * @path: (handle name).(user name)
 *
 * no return
 */
void asc_tx_del_user(const char *path)
{
    unsigned long flags = 0;
    char hname[ASC_NAME_LEN] = {0};
    const char *name;
    struct asc_user *user = NULL;
    struct asc_tx_handle *tx = NULL;

    name = strchr(path, '.');
    if (name) {
        memcpy(hname, path, min(name - path, ASC_NAME_LEN - 1));
        name++;
    }else{
        ASCPRT("%s: invalid path %s\n", __FUNCTION__, path);
        return ;
    }

    /*if reserve user, do nothing*/
    if (!strncmp(name, ASC_TX_SYSFS_USER, ASC_NAME_LEN - 1) || \
         !strncmp(name, ASC_TX_AUTO_USER, ASC_NAME_LEN - 1) ) {
         ASCPRT("Can not delete reserve user %s\n", path);
         return ;
    }

    tx = asc_tx_handle_lookup(hname);
    
    if(NULL == tx)
        return ;

    user = asc_tx_user_lookup(tx, name);
    if(user){
        /*put ready if the user had operated Tx handle*/
        if(atomic_read(&user->count) > 0){
            atomic_set(&user->count, 1);
            asc_tx_put_ready(path, 0);
        }
        spin_lock_irqsave(&tx->slock, flags);
        list_del(&user->node);
        spin_unlock_irqrestore(&tx->slock, flags);
        kfree(user);
    }

    return ;
}
EXPORT_SYMBOL(asc_tx_del_user);

/**
 * asc_tx_get_ready - lock CBP to work
 * @path: (handle name).(user name)
 * @block: whether block wait for CBP has already waken
 *
 * This function try to wake the CBP and add the reference count. 
 * It will block wait for CBP has already be waken if set sync parameter, 
 * otherwise it just trig the action to wake CBP, which can not make sure 
 * that CBP has be waken after return. 
 * return 0 is ok, otherwise something error
 */
int asc_tx_get_ready(const char *path, int sync)
{
    int ret = 0;
    char hname[ASC_NAME_LEN] = {0};
    const char *name;
    struct asc_tx_handle *tx = NULL;

    name = strchr(path, '.');
    if (name) {
        memcpy(hname, path, min(name - path, ASC_NAME_LEN - 1));
        name++;
    } else {
        ASCPRT("Invalid path %s\n", path);
        return -EINVAL;
    }
    tx = asc_tx_handle_lookup(hname);
    if(NULL == tx)
        return -ENODEV;

    if(asc_tx_get_user(tx, name) < 0){
        ASCPRT("%s:tx user name %s is unknow\n", __FUNCTION__, name);
        return -ENODEV;
    }
    ASCDPRT("%s: %s=%d, %s=%d\n", __FUNCTION__,\
                         tx->cfg.name, asc_tx_refer(tx, NULL), path, asc_tx_refer(tx, name));
    switch(atomic_read(&tx->state)){
        case AP_TX_ST_SLEEP:
            //To make CP wake ASAP,call the funtion directly
            if(!list_empty(&tx->event_q)){
                asc_tx_handle_sleep(tx, AP_TX_EVENT_REQUEST);
            }else{
                asc_tx_event_send(tx, AP_TX_EVENT_REQUEST);
            }
            break;
        case AP_TX_ST_IDLE:
            asc_tx_event_send(tx, AP_TX_EVENT_REQUEST);
            break;
        case AP_TX_ST_WAIT_READY:
        case AP_TX_ST_READY:
            if(!strncmp(name, ASC_TX_AUTO_USER, strlen(ASC_TX_AUTO_USER))){
                asc_tx_trig_busy(tx);
            }
            break;
        default:
            ASCPRT("Unknow tx state %d\n", atomic_read(&tx->state));
            return -EINVAL;
    }

    if(sync){
        if(AP_TX_ST_READY != atomic_read(&tx->state)){
             interruptible_sleep_on(&tx->wait_tx_state);
             if(AP_TX_ST_READY != atomic_read(&tx->state)){
                ret = -EBUSY;
            }
        }
    }

    return ret;
}
EXPORT_SYMBOL(asc_tx_get_ready);

/**
 * asc_tx_put_ready - lock CBP to work if not set auto sleep
 * @path: (config name).[user name]
 * @block: whether block wait for CBP has already waken
 *
 * This function try to wake the CBP. It will block wait for CBP 
 * has already be sleep if set sync parameter, otherwise it just 
 * trig the action to sleep CBP, which can not make sure that 
 * CBP has be sleep after return. If the reference count is not 1. it 
 * do nothing but sub one. 
 * return 0 is ok, otherwise something error
 */
int asc_tx_put_ready(const char *path, int sync)
{
    int ret = 0;
    char hname[ASC_NAME_LEN] = {0};
    const char *name;
    struct asc_tx_handle *tx = NULL;

    name = strchr(path, '.');
    if (name) {
        memcpy(hname, path, min(name - path, ASC_NAME_LEN - 1));
        name++;
    } else {
        ASCPRT("Invalid path %s\n", path);
        return -EINVAL;
    }

    tx = asc_tx_handle_lookup(hname);
    if(NULL == tx)
        return -ENODEV;

    if(asc_tx_put_user(tx, name) < 0){
        ASCPRT("%s:tx user name %s is unknow\n", __FUNCTION__, name);
        return -ENODEV;
    }
    ASCDPRT("%s: %s=%d, %s=%d\n", __FUNCTION__,\
                        tx->cfg.name, asc_tx_refer(tx, NULL), path, asc_tx_refer(tx, name));
    /*count is not 0, so do nothing*/
    if(asc_tx_refer(tx, NULL) != 0){
        return 0;
    }
    
    switch(atomic_read(&tx->state)){
        case AP_TX_ST_SLEEP:
            break;
        case AP_TX_ST_WAIT_READY:
        case AP_TX_ST_READY:
            asc_tx_event_send(tx, AP_TX_EVENT_STOP);
            break;
        case AP_TX_ST_IDLE:
            asc_tx_event_send(tx, AP_TX_EVENT_IDLE_TIMEOUT);
            break;
        default:
            ASCPRT("Unknow tx state %d\n", atomic_read(&tx->state));
            return -EINVAL;
    }

    if(sync){
        if(AP_TX_ST_SLEEP != atomic_read(&tx->state)){
             interruptible_sleep_on(&tx->wait_tx_state);
             if(AP_TX_ST_SLEEP != atomic_read(&tx->state)){
                ret = -EBUSY;
            }
        }
    }

    return ret;
}
EXPORT_SYMBOL(asc_tx_put_ready);

/**
 * asc_tx_auto_ready - call each time before operate for CBP if set auto sleep
 * @name: the cofnig name for the handle
 * @sync: whether block wait for CBP has already waken
 *
 * This function try to wake the CBP and trig the tx state. It will
 * block wait for CBP has already be waken if set sync parameter, 
 * otherwise it just trig the action to wake CBP, which can not make
 * sure that CBP has be waken after return.
 * return 0 is ok, otherwise something error
 */
int asc_tx_auto_ready(const char *name, int sync)
{
    int ret = 0;
    struct asc_user *user;
    struct asc_tx_handle *tx;
    
    if (!name) {
        ASCPRT("%s:Invalid name\n", __FUNCTION__);
        return -EINVAL;
    }
    
    tx = asc_tx_handle_lookup(name);
    if(NULL == tx)
        return -ENODEV;

    user = asc_tx_user_lookup(tx, ASC_TX_AUTO_USER);
    if(!user){
        return  -ENODEV;
    }
    
    if(atomic_read(&user->count) == 0){
        ASCDPRT("%s: %s=%d, %s=%d\n", __FUNCTION__,\
                         tx->cfg.name, asc_tx_refer(tx, NULL), ASC_TX_AUTO_USER, asc_tx_refer(tx, ASC_TX_AUTO_USER));
        atomic_inc(&user->count);
    }

    switch(atomic_read(&tx->state)){
        case AP_TX_ST_SLEEP:
            //To make CP wake ASAP,call the funtion directly
            if(!list_empty(&tx->event_q)){
                asc_tx_handle_sleep(tx, AP_TX_EVENT_REQUEST);
            }else{
                asc_tx_event_send(tx, AP_TX_EVENT_REQUEST);
            }
            break;
        case AP_TX_ST_IDLE:
            asc_tx_event_send(tx, AP_TX_EVENT_REQUEST);
            break;
        case AP_TX_ST_WAIT_READY:
        case AP_TX_ST_READY:
                asc_tx_trig_busy(tx);
            break;
        default:
            ASCPRT("Unknow tx state %d\n", atomic_read(&tx->state));
            return -EINVAL;
    }

    if(sync){
        if(AP_TX_ST_READY != atomic_read(&tx->state)){
             interruptible_sleep_on(&tx->wait_tx_state);
             if(AP_TX_ST_READY != atomic_read(&tx->state)){
                ret = -EBUSY;
            }
        }
    }

    return ret;

}
EXPORT_SYMBOL(asc_tx_auto_ready);

static void asc_rx_handle_reset(struct asc_rx_handle *rx)
{
    unsigned long flags;

    ASCDPRT("%s %s\n", __FUNCTION__, rx->cfg.name);
    del_timer(&rx->timer);
    wake_unlock(&rx->wlock);
    asc_rx_indicate_sleep(rx);
    atomic_set(&rx->state, AP_RX_ST_SLEEP);
    spin_lock_irqsave(&rx->slock, flags);
    INIT_LIST_HEAD(&rx->event_q);
    spin_unlock_irqrestore(&rx->slock, flags);
 
}

/**
 * asc_rx_reset - reset the rx handle 
 * @name: the config name for the handle
 *
 * return 0 ok, others be error
 */
void asc_rx_reset(const char *name)
{
    struct asc_rx_handle *rx = NULL;

    rx = asc_rx_handle_lookup(name);
    if(rx){
        asc_rx_event_send(rx, AP_RX_EVENT_RESET);
    }
}
EXPORT_SYMBOL(asc_rx_reset);

/**
 * asc_rx_add_user - add a user for rx handle
 * @name: the config name for the handle
 * @infor: the user information
 *
 * return 0,  others be error
 */
int asc_rx_add_user(const char *name, struct asc_infor *infor)
{
    int ret = 0;
    unsigned long flags = 0;
    struct asc_rx_handle *rx;
    struct asc_user *user;

    rx = asc_rx_handle_lookup(name);
    if(NULL == rx)
        return -ENODEV;

    user = asc_rx_user_lookup(rx, infor->name);
    if(NULL == user){
        user = kzalloc(sizeof(*user), GFP_KERNEL);
        if(!user){
            ASCPRT("No memory to create new user reference.\n");
            ret = -ENOMEM;
            goto error;
        }
        user->infor.data = infor->data;
        user->infor.notifier = infor->notifier;
        strncpy(user->infor.name, infor->name, ASC_NAME_LEN - 1);
        atomic_set(&user->count, 0);
        spin_lock_irqsave(&rx->slock, flags);
        list_add_tail(&user->node, &rx->user_list);
        spin_unlock_irqrestore(&rx->slock, flags);
        if(AP_RX_ST_WAIT_READY == atomic_read(&rx->state)){
            if(infor->notifier){
                infor->notifier(ASC_NTF_RX_PREPARE, infor->data);
            }
        }
    }else{
        ASCPRT("%s error: user %s already exist!!\n", __FUNCTION__, infor->name);
        ret = -EINVAL;
    }
error:
    return ret;
}
EXPORT_SYMBOL(asc_rx_add_user);

/**
 * asc_rx_del_user - add a user for rx handle
 * @path: (config name).[user name]
 *
 * no return
 */
void asc_rx_del_user(const char *path)
{
    unsigned long flags = 0;
    const char *name;
    char hname[ASC_NAME_LEN] = {0}; 
    struct asc_user *user;
    struct asc_rx_handle *rx;


    name = strchr(path, '.');
    if (name) {
        memcpy(hname, path, min(name - path, ASC_NAME_LEN - 1));
        name++;
    }else{
        ASCPRT("%s: Invalid path %s\n",__FUNCTION__, path);
        return ;
    }

    rx = asc_rx_handle_lookup(hname);
    if(NULL == rx)
        return ;

    user = asc_rx_user_lookup(rx, name);
    if(user){
        atomic_set(&user->count, 0);
        spin_lock_irqsave(&rx->slock, flags);
        list_del(&user->node);
        spin_unlock_irqrestore(&rx->slock, flags);
        kfree(user);
        if(list_empty(&rx->user_list)){
            asc_rx_handle_reset(rx);
        }
    }
    return ;
}
EXPORT_SYMBOL(asc_rx_del_user);

/**
 * asc_rx_confirm_ready - echo AP state to rx CBP data
 * @name: the config name to  rx handle
 * @ready: whether AP has been ready to rx data
 *
 * After CBP request AP to rx data, the function can be used to
 * tell CBP whether AP has been ready to receive.
 * return 0 is ok, otherwise something error
 */
int asc_rx_confirm_ready(const char *name, int ready)
{
    struct asc_rx_handle *rx = NULL;

    rx = asc_rx_handle_lookup(name);
    if(!rx){
        ASCDPRT("%s: name %s is unknow\n", __FUNCTION__, name);
        return -ENODEV;
    }

    ASCDPRT("Rx(%s) cnofirm ready=%d\n", rx->cfg.name, ready);
    return asc_rx_event_send(rx, ready ? AP_RX_EVENT_AP_READY : AP_RX_EVENT_AP_UNREADY);
}
EXPORT_SYMBOL(asc_rx_confirm_ready);

/**
 * check_on_start - prevent from missing cp waking
 * @name: the name of rx handle
 *
 * Before the rx user is registed,CP may wake up AP.Usually AP will ignore  
 * the waking.Because the interrupt don't be register at that time.So the 
 * signal will be missed.When opening the tty device, we should check whether CP
 * has waken up AP or not.If CP did that,we should send the signal "AP READY"
 * to CP.
 */

int asc_rx_check_on_start(const char *name)
{
	int level;
	struct asc_config *cfg = NULL;
	struct asc_rx_handle *rx = NULL;
	int ret = 1;
	
	rx = asc_rx_handle_lookup(name);
	if(!rx){
        ASCPRT("config %s has not already exist.\n", name);
        return -EINVAL;
    }

	cfg = &(rx->cfg);
	level = !!oem_gpio_get_value(cfg->gpio_wake);
	if(level == cfg->polar){
        /*Cp has requested Ap wake*/
		if(AP_RX_ST_SLEEP == atomic_read(&rx->state)){
            ASCDPRT("Rx(%s):check_on_start--send event AP_RX_EVENT_REQUEST.\n", cfg->name);
            ret = asc_rx_event_send(rx, AP_RX_EVENT_REQUEST);            
        }else{
        	ASCDPRT("Rx(%s): check_on_start--send event AP_RX_EVENT_AP_READY.\n", cfg->name);
            ret = asc_rx_event_send(rx, AP_RX_EVENT_AP_READY);
        }		
    }
	
	return ret;
}
EXPORT_SYMBOL(asc_rx_check_on_start);

static ssize_t asc_debug_show(struct kobject *kobj, struct kobj_attribute *attr,
			     char *buf)
{
    char *s = buf;
    s += sprintf(s, "%d\n", asc_debug);

    return (s - buf);
}

static ssize_t asc_debug_store(struct kobject *kobj, struct kobj_attribute *attr,
			   const char *buf, size_t n)
{	
    unsigned long val;

    if (strict_strtoul(buf, 10, &val))
        return -EINVAL;

    if (val < 0)
	return -EINVAL;

    asc_debug = val;

    return n;
}



static ssize_t asc_infor_show(struct kobject *kobj, struct kobj_attribute *attr,
			     char *buf)
{
    char *s = buf;
    int val1, val2;
    struct asc_config *cfg;
    struct asc_infor *infor;
    struct asc_user *user = NULL, *tuser = NULL;
    struct asc_tx_handle *tx = NULL, *ttmp = NULL;
    struct asc_rx_handle *rx = NULL, *rtmp = NULL;

    list_for_each_entry_safe(tx, ttmp, &asc_tx_handle_list, node){
        cfg = &tx->cfg;
        val1 = val2 = -1;
        if(cfg->gpio_wake >= 0)
            val1 = !!oem_gpio_get_value(cfg->gpio_wake);
        if(cfg->gpio_ready >= 0)
            val2 = !!oem_gpio_get_value(cfg->gpio_ready);
   
        s += sprintf(s, "Tx %s: ref=%d, ap_wake_cp(%d)=%d, cp_ready(%d)=%d, polar=%d, auto_delay=%d mS\n",
                                cfg->name, asc_tx_refer(tx, NULL), cfg->gpio_wake, val1, cfg->gpio_ready, val2, cfg->polar, tx->auto_delay);

        list_for_each_entry_safe(user, tuser, &tx->user_list, node) {
            infor = &user->infor;
            s += sprintf(s, "       user %s: ref=%d\n", infor->name, atomic_read(&user->count));
        }
    }

    s += sprintf(s, "\n");

    list_for_each_entry_safe(rx, rtmp, &asc_rx_handle_list, node){
        cfg = &rx->cfg;
        val1 = val2 = -1;
        if(cfg->gpio_wake >= 0)
            val1 = !!oem_gpio_get_value(cfg->gpio_wake);
        if(cfg->gpio_ready >= 0)
            val2 = !!oem_gpio_get_value(cfg->gpio_ready);
 
        s += sprintf(s, "Rx %s: ref=%d, cp_wake_ap(%d)=%d, ap_ready(%d)=%d, polar=%d\n", \
                                cfg->name, asc_rx_refer(rx, NULL), cfg->gpio_wake, val1, cfg->gpio_ready, val2, cfg->polar);
        list_for_each_entry_safe(user, tuser, &rx->user_list, node) {
            infor = &user->infor;
            s += sprintf(s, "       user %s: ref=%d\n", infor->name, atomic_read(&user->count));
        }
    }

    return (s - buf);
}
static ssize_t asc_infor_store(struct kobject *kobj, struct kobj_attribute *attr,
			   const char *buf, size_t n)
{
    return n;
}

static ssize_t asc_refer_show(struct kobject *kobj, struct kobj_attribute *attr,
			     char *buf)
{
    unsigned long flags;
    char *s = buf;
    struct asc_tx_handle *tx, *tmp, *t;

    tx = tmp = NULL;
    spin_lock_irqsave(&hdlock, flags);
    list_for_each_entry_safe(tmp, t, &asc_tx_handle_list, node){
        if(tmp->kobj == kobj){
            tx = tmp;
            break;
        }
    }
    spin_unlock_irqrestore(&hdlock, flags);

    if(tx){
        s += sprintf(s, "%d\n", asc_tx_refer(tx, ASC_TX_SYSFS_USER));
        return s - buf;
    }else{
        ASCPRT("%s read error\n", __FUNCTION__);
        return -EINVAL;
    }

}


static ssize_t asc_setcpmode_show(struct kobject *kobj, struct kobj_attribute *attr,
			     char *buf)
{
    char *s = buf;
    s += sprintf(s, "nothing\n");

    return (s - buf);
}

static ssize_t asc_setcpmode_store(struct kobject *kobj, struct kobj_attribute *attr,
			   const char *buf, size_t n)
{	
    unsigned long val;

    if (strict_strtoul(buf, 10, &val))
        return -EINVAL;

    if (val < 0)
	return -EINVAL;

    if(val>0)
        oem_gpio_output(GPIO_VIATEL_USB_AP_WAKE_MDM,1);
    else
        oem_gpio_output(GPIO_VIATEL_USB_AP_WAKE_MDM,0);

    
    //asc_debug = val;

    return n;
}


static ssize_t asc_refer_store(struct kobject *kobj, struct kobj_attribute *attr,
			   const char *buf, size_t n)
{ 
    unsigned long flags;
    char *p;
    int error = 0, len;
    char path[ASC_NAME_LEN] = {0};
    struct asc_tx_handle *tx, *tmp, *t;

    tx = tmp = NULL;
    spin_lock_irqsave(&hdlock, flags);
    list_for_each_entry_safe(tmp, t, &asc_tx_handle_list, node){
        if(tmp->kobj == kobj){
            tx = tmp;
            break;
        }
    }
    spin_unlock_irqrestore(&hdlock, flags);

    if(tx){
        p = memchr(buf, '\n', n);
        len = p ? p - buf : n;
        snprintf(path, ASC_NAME_LEN, "%s.%s", tx->cfg.name, ASC_TX_SYSFS_USER);

        if (len == 3 && !strncmp(buf, "get", len)) {
            error = asc_tx_get_ready(path, 1);
        }else if (len == 3 && !strncmp(buf, "put", len)) {
            error= asc_tx_put_ready(path, 1);
        }
    }
    
    return error ? error : n;
}

static ssize_t asc_state_show(struct kobject *kobj, struct kobj_attribute *attr,
			     char *buf)
{
    unsigned long flags;
    char *s = buf;
    struct asc_tx_handle *tx, *tmp, *t;

    tx = tmp = NULL;
    spin_lock_irqsave(&hdlock, flags);
    list_for_each_entry_safe(tmp, t, &asc_tx_handle_list, node){
        if(tmp->kobj == kobj){
            tx = tmp;
            break;
        }
    }
    spin_unlock_irqrestore(&hdlock, flags);

    if(tx){
        s += sprintf(s, "%s\n", tx->table[atomic_read(&tx->state)].name);
        return s - buf;
    }else{
        ASCPRT("%s read error\n", __FUNCTION__);
        return -EINVAL;
    }

}

static ssize_t asc_state_store(struct kobject *kobj, struct kobj_attribute *attr,
			   const char *buf, size_t n)
{	
    return n;
}

static ssize_t asc_auto_ready_show(struct kobject *kobj, struct kobj_attribute *attr,
			     char *buf)
{
    unsigned long flags;
    char *s = buf;
    struct asc_tx_handle *tx, *tmp, *t;

    tx = tmp = NULL;
    spin_lock_irqsave(&hdlock, flags);
    list_for_each_entry_safe(tmp, t, &asc_tx_handle_list, node){
        if(tmp->kobj == kobj){
            tx = tmp;
            break;
        }
    }
    spin_unlock_irqrestore(&hdlock, flags);

    if(tx){
        s += sprintf(s, "%d\n", tx->auto_delay);
        return s - buf;
    }else{
        ASCPRT("%s read error\n", __FUNCTION__);
        return -EINVAL;
    }

}

static ssize_t asc_auto_ready_store(struct kobject *kobj, struct kobj_attribute *attr,
			   const char *buf, size_t n)
{
    int error = 0;
    long val;
    unsigned long flags;
    struct asc_tx_handle *tx, *tmp, *t;

    tx = tmp = NULL;
    spin_lock_irqsave(&hdlock, flags);
    list_for_each_entry_safe(tmp, t, &asc_tx_handle_list, node){
        if(tmp->kobj == kobj){
            tx = tmp;
            break;
        }
    }
    spin_unlock_irqrestore(&hdlock, flags);

    if(tx){
        error = strict_strtol(buf, 10, &val);
        if(error || (val < 0)){
           error = -EINVAL;
           goto end;
        }

        if(val > 0){
            spin_lock_irqsave(&tx->slock, flags);
            tx->auto_delay = val;
            spin_unlock_irqrestore(&tx->slock, flags);
        }
        error = asc_tx_auto_ready(tx->cfg.name, 1);
    }else{
        ASCPRT("%s read error\n", __FUNCTION__);
        error = -EINVAL;
    }

end:
    return error ? error : n;
}

#define asc_attr(_name) \
static struct kobj_attribute _name##_attr = {	\
	.attr	= {				\
		.name = __stringify(_name),	\
		.mode = 0644,			\
	},					\
	.show	= asc_##_name##_show,			\
	.store	= asc_##_name##_store,		\
}

asc_attr(debug);
asc_attr(infor);
asc_attr(setcpmode);

static struct attribute * g_attr[] = {
	&debug_attr.attr,
    &infor_attr.attr,
    &setcpmode_attr.attr,
	NULL,
};

static struct attribute_group g_attr_group = {
	.attrs = g_attr,
};

asc_attr(refer);
asc_attr(state);
asc_attr(auto_ready);

static struct attribute * tx_hd_attr[] = {
    &refer_attr.attr,
    &state_attr.attr,
    &auto_ready_attr.attr,
    NULL,
};

int asc_suspend(struct platform_device *pdev, pm_message_t state)
{
    oem_gpio_irq_mask(tx_cfg.gpio_ready);
    oem_gpio_irq_mask(rx_cfg.gpio_wake);
    if(ap_ready_always)
        oem_gpio_output(rx_cfg.gpio_ready,!rx_cfg.polar);

    return 0;
}


int asc_resume(struct platform_device *pdev)
{

    msleep(500);
    printk("asc_resume\n");
    oem_gpio_direction_output(tx_cfg.gpio_wake, tx_cfg.polar);
    oem_gpio_direction_input_for_irq(tx_cfg.gpio_ready);    
    oem_gpio_set_irq_type(tx_cfg.gpio_ready, IRQF_TRIGGER_RISING);
    oem_gpio_irq_unmask(tx_cfg.gpio_ready);

    oem_gpio_output(rx_cfg.gpio_ready, rx_cfg.polar);
    oem_gpio_direction_input_for_irq(rx_cfg.gpio_wake);    
    oem_gpio_set_irq_type(rx_cfg.gpio_wake, IRQF_TRIGGER_RISING);
    oem_gpio_irq_unmask(rx_cfg.gpio_wake);

    return 0;
}

static struct attribute_group tx_hd_attr_group = {
	.attrs = tx_hd_attr,
};


static struct platform_driver asc_driver = {
	.driver.name = "asc",
    .suspend    = asc_suspend,
    .resume     = asc_resume,
};

static struct platform_device asc_device = {
	.name = "asc",
};


/**
 * asc_rx_register_handle - register the rx handle
 * @cfg: the config for the handle
 *
 * the device which receive data from CBP can register a notifier to
 * listen the event according to the changes from CBP.
 * ASC_PREPARE_RX_DATA event will be send when CBP start tx data 
 * to the device which must be ready to work; 
 * ASC_POST_RX_DATA event will be send when CBP stop tx data to 
 * the device which can go to sleep.
 * The gpio for ap_ready can be -1 which be ignored when the device 
 * can receive the data from CBP correctly any time.
 * return index according to the notifier in handle, otherwise something error
 */
int asc_rx_register_handle(struct asc_config *cfg)
{
    int ret = 0;
    unsigned long flags;
    struct asc_rx_handle *rx = NULL;

    if(NULL == asc_work_queue){
        ASCPRT("%s: error Asc has not been init\n", __FUNCTION__);
        return -EINVAL;
    }
    
    if(NULL == cfg){
        return -EINVAL;
    }
    
    if(cfg->gpio_wake < 0){
        ASCPRT("%s: config %s gpio is invalid.\n", __FUNCTION__, cfg->name);
        return -EINVAL;
    }
    
    rx = asc_rx_handle_lookup(cfg->name);
    if(rx){
        ASCPRT("config %s has already exist.\n", cfg->name);
        return -EINVAL;
    }

    rx = kzalloc(sizeof(struct asc_rx_handle), GFP_KERNEL);
    if(NULL == rx){
        ASCPRT("No memory to alloc rx handle.\n");
        return -ENOMEM;
    }

    rx->cfg.gpio_ready = cfg->gpio_ready;
    rx->cfg.gpio_wake = cfg->gpio_wake;
    rx->cfg.polar = !!cfg->polar;
    strncpy(rx->cfg.name, cfg->name, ASC_NAME_LEN - 1);
    memcpy(&rx_cfg, &rx->cfg, sizeof(struct asc_config));
  
    ret = asc_rx_handle_init(rx);
    if(ret < 0){
        kfree(rx);
        ASCPRT("fail to init rx handle %s\n", rx->cfg.name);
        return -EINVAL;
    }

    /* Add the handle to the asc list */
    spin_lock_irqsave(&hdlock, flags);
    list_add(&rx->node, &asc_rx_handle_list);
    spin_unlock_irqrestore(&hdlock, flags);
    ASCDPRT("Register rx handle %s\n", rx->cfg.name);
    return ret;
}
EXPORT_SYMBOL(asc_rx_register_handle);

/**
 * asc_tx_register_handle - register the tx handle for state change
 * @cfg: the config for the handle 
 *
 * the chip which exchanged data with CBP must create a handle.
 * There is only one tx state handle between the AP and CBP because 
 * all devices in CBP will be ready to receive data after CBP has been 
 * waken. But servial rx state handles can be exist because different 
 * devices in AP maybe waken indivially. Each rx state handle must be 
 * registed a notifier to listen the evnets.
 * return 0 is ok, otherwise something error
 */
int asc_tx_register_handle(struct asc_config *cfg)
{
    int ret=0;
    unsigned long flags;
    struct asc_infor infor;
    struct asc_tx_handle *tx = NULL;
   
    if(NULL == asc_work_queue){
        ASCPRT("%s: error Asc has not been init\n", __FUNCTION__);
        return -EINVAL;
    }

    if(NULL == cfg){
        return -EINVAL;
    }
    
    if(cfg->gpio_wake < 0){
        ASCPRT("%s: config %s gpio is invalid.\n", __FUNCTION__, cfg->name);
        return -EINVAL;
    }
    
    tx = asc_tx_handle_lookup(cfg->name);
    if(tx){
        ASCPRT("config %s has already exist.\n", cfg->name);
        return -EINVAL;
    }

    tx = kzalloc(sizeof(struct asc_tx_handle), GFP_KERNEL);
    if(NULL == tx){
        ASCPRT("Fail to alloc memory for tx handle.\n");
        return -ENOMEM;
    }

    tx->cfg.gpio_ready = cfg->gpio_ready;
    tx->cfg.gpio_wake = cfg->gpio_wake;
    tx->cfg.polar = !!cfg->polar;
    strncpy(tx->cfg.name, cfg->name, ASC_NAME_LEN - 1);
    memcpy(&tx_cfg, &tx->cfg, sizeof(struct asc_config));
    ret = asc_tx_handle_init(tx);
    if(ret < 0){
        ASCPRT("Fail to init tx handle %s.\n", tx->cfg.name);
        goto err_tx_handle_init;
    }

    /* Add the handle to the asc list */
    spin_lock_irqsave(&hdlock, flags);
    list_add(&tx->node, &asc_tx_handle_list);
    spin_unlock_irqrestore(&hdlock, flags);
    ASCDPRT("Register tx handle %s.\n", tx->cfg.name);

    tx->kobj = kobject_create_and_add(cfg->name, asc_kobj);
    if(!tx->kobj){
        ret = -ENOMEM;
        goto err_create_kobj;
    }

    /*add default user for application*/
    memset(&infor, 0, sizeof(infor));
    strncpy(infor.name, ASC_TX_SYSFS_USER, ASC_NAME_LEN);
    asc_tx_add_user(tx->cfg.name, &infor);
    memset(&infor, 0, sizeof(infor));
    strncpy(infor.name, ASC_TX_AUTO_USER, ASC_NAME_LEN);
    asc_tx_add_user(tx->cfg.name, &infor);
    return sysfs_create_group(tx->kobj, &tx_hd_attr_group);
    
err_create_kobj:
   list_del(&tx->node);
err_tx_handle_init:
    if(tx){
        kfree(tx);
    }

    return ret;
}
EXPORT_SYMBOL(asc_tx_register_handle);

static int __init asc_init(void)
{
    int ret;
	ret = oem_gpio_convert_init();
    if(ret){
        printk("Warnning:viatel gpio not set.\n");        
        return -EIO;
    }

    ret = platform_device_register(&asc_device);
    if (ret) {
        ASCPRT("platform_device_register failed\n");
        goto err_platform_device_register;
    }
    ret = platform_driver_register(&asc_driver);
    if (ret) {
        ASCPRT("platform_driver_register failed\n");
        goto err_platform_driver_register;
    }

    asc_work_queue = create_singlethread_workqueue("asc_work");
    if (asc_work_queue == NULL) {
        ret = -ENOMEM;
        goto err_create_work_queue;
    }

    asc_kobj = viatel_kobject_add("asc");
    if (!asc_kobj){
        ret = -ENOMEM;
        goto err_create_kobj;
    }

    return sysfs_create_group(asc_kobj, &g_attr_group);
    
err_create_kobj:
    destroy_workqueue(asc_work_queue);
err_create_work_queue:
    platform_driver_unregister(&asc_driver);
err_platform_driver_register:
	platform_device_unregister(&asc_device);
err_platform_device_register:
	return ret;
}

device_initcall(asc_init);