/* drivers/rtc/rtc-jwwdt.c - driver for jwwdt
|
*
|
* Copyright (C) 2010 ROCKCHIP, Inc.
|
*
|
* This software is licensed under the terms of the GNU General Public
|
* License version 2, as published by the Free Software Foundation, and
|
* may be copied, distributed, and modified under those terms.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*/
|
|
|
#include <linux/module.h>
|
#include <linux/moduleparam.h>
|
#include <linux/init.h>
|
#include <linux/clk.h>
|
#include <linux/delay.h>
|
#include <linux/pm.h>
|
#include <linux/i2c.h>
|
#include <linux/platform_device.h>
|
#include <linux/slab.h>
|
#include <linux/of_gpio.h>
|
#include <sound/core.h>
|
#include <sound/pcm.h>
|
#include <sound/pcm_params.h>
|
#include <sound/tlv.h>
|
#include <sound/soc.h>
|
#include <sound/soc-dapm.h>
|
#include <sound/initval.h>
|
#include <linux/proc_fs.h>
|
#include <linux/gpio.h>
|
#include <linux/interrupt.h>
|
#include <linux/irq.h>
|
#include "jw_mcu.h"
|
#include <linux/reboot.h>
|
|
|
struct i2c_client *gClient = NULL;
|
struct device_node *node_MCU = NULL;
|
struct device *dev_MCU= NULL;
|
unsigned int mcu_watchdog_gpio;
|
struct delayed_work watchdog_delay_work;
|
#define WATCHDOG_FEED_COUNT 2000
|
|
|
|
//ison s
|
#if 0
|
static int Mcu_i2c_writes(const struct i2c_client *client,
|
const char reg, const char *buf, int count)
|
{
|
struct i2c_adapter *adap=client->adapter;
|
struct i2c_msg msg;
|
int ret;
|
char *tx_buf = (char *)kmalloc(count + 1, GFP_KERNEL);
|
if(!tx_buf)
|
return -ENOMEM;
|
tx_buf[0] = reg;
|
memcpy(tx_buf+1, buf, count);
|
|
msg.addr = client->addr;
|
msg.flags = client->flags;
|
msg.len = count + 1;
|
msg.buf = (char *)tx_buf;
|
//msg.scl_rate = 100*1000;
|
|
ret = i2c_transfer(adap, &msg, 1);
|
kfree(tx_buf);
|
return (ret == 1) ? count : ret;
|
|
}
|
|
static int Mcu_i2c_reads(const struct i2c_client *client,
|
const char reg, char *buf, int count)
|
{
|
struct i2c_adapter *adap=client->adapter;
|
struct i2c_msg msgs[2];
|
int ret;
|
char reg_buf = reg;
|
|
msgs[0].addr = client->addr;
|
msgs[0].flags = client->flags;
|
msgs[0].len = 1;
|
msgs[0].buf = ®_buf;
|
//msgs[0].scl_rate = 100*1000;
|
|
msgs[1].addr = client->addr;
|
msgs[1].flags = client->flags | I2C_M_RD;
|
msgs[1].len = count;
|
msgs[1].buf = (char *)buf;
|
//msgs[1].scl_rate = 100*1000;
|
|
ret = i2c_transfer(adap, msgs, 2);
|
|
return (ret == 2)? count : ret;
|
}
|
#endif
|
|
static int Mcu_i2c_writeregister(struct i2c_client *i2c, char reg, int count, const u8 src)
|
{
|
int ret=-1;
|
|
struct i2c_adapter *adap;
|
struct i2c_msg msg;
|
char tx_buf[2];
|
|
if(!i2c)
|
return -EINVAL;
|
if (count != 1)
|
return -EIO;
|
|
adap = i2c->adapter;
|
tx_buf[0] = reg;
|
tx_buf[1] = src;
|
|
msg.addr = i2c->addr;
|
msg.buf = &tx_buf[0];
|
msg.len = 1 +1;
|
msg.flags = i2c->flags;
|
//msg.scl_rate = 100*1000;
|
|
ret = i2c_transfer(adap, &msg, 1);
|
return ret;
|
}
|
|
|
|
static int Mcu_i2c_readregister(struct i2c_client *i2c, char reg, int count, u8 *dest)
|
{
|
int ret;
|
struct i2c_adapter *adap;
|
struct i2c_msg msgs[2];
|
|
if(!i2c)
|
return -EINVAL;
|
|
if (count != 1)
|
return -EIO;
|
|
adap = i2c->adapter;
|
|
msgs[0].addr = i2c->addr;
|
msgs[0].buf = ®
|
msgs[0].flags = i2c->flags;
|
msgs[0].len = 1;
|
//msgs[0].scl_rate = 100*1000;
|
|
msgs[1].buf = (u8 *)dest;
|
msgs[1].addr = i2c->addr;
|
msgs[1].flags = i2c->flags | I2C_M_RD;
|
msgs[1].len = 1;
|
//msgs[1].scl_rate = 100*1000;
|
ret = i2c_transfer(adap, msgs, 2);
|
|
//printk("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
|
|
return ret;
|
}
|
|
//ison e
|
|
uint8_t get_value_func_cfg(uint8_t func, uint8_t value)
|
{
|
uint8_t data = 0;
|
CORE_REG_FUNCTION *value_func;
|
CORE_REG_FUNCTION1 *value_func1;
|
value_func = (CORE_REG_FUNCTION *)&value;
|
value_func1 = (CORE_REG_FUNCTION1 *)&value;
|
if(func < 100 || func > CORE_FUNC_MAX)
|
return 0;
|
switch(func){
|
case CORE_FUNC_ALARM:
|
data = value_func->bit.alarmWakeup;
|
break;
|
case CORE_FUNC_WDT:
|
data = value_func->bit.watchdog;
|
break;
|
case CORE_FUNC_IRDA:
|
data = value_func->bit.irdaWakeup;
|
break;
|
case CORE_FUNC_NET_WK:
|
data = value_func->bit.net_wakeup;
|
break;
|
case CORE_FUNC_CEC:
|
data = value_func->bit.hdmi_cec;
|
break;
|
case CORE_FUNC_POWER_LOSS:
|
data = value_func->bit.powerloss;
|
break;
|
case CORE_FUNC_USB_CHARGER:
|
data = value_func->bit.usbCharger;
|
break;
|
case CORE_FUNC_LAST_STATE:
|
data = value_func1->bit.last_state;
|
break;
|
case CORE_FUNC_PWR_WK_EN:
|
data = value_func1->bit.pwr_wk_en;
|
case CORE_FUNC_PWR_OFF_EN:
|
data = value_func1->bit.pwr_opwer_en;
|
default:
|
break;
|
}
|
return data;
|
}
|
|
uint8_t set_value_func_cfg(uint8_t func, uint8_t value,uint8_t value_data)
|
{
|
uint8_t data = 0;
|
CORE_REG_FUNCTION *value_func;
|
CORE_REG_FUNCTION1 *value_func1;
|
value_func = (CORE_REG_FUNCTION *)&value;
|
value_func1 = (CORE_REG_FUNCTION1 *)&value;
|
if(func < 100 || func > CORE_FUNC_MAX)
|
return 0;
|
switch(func){
|
case CORE_FUNC_POWER_LOSS:
|
value_func->bit.powerloss = value_data;
|
break;
|
case CORE_FUNC_WDT:
|
value_func->bit.watchdog = value_data;
|
break;
|
case CORE_FUNC_ALARM:
|
value_func->bit.alarmWakeup = value_data;
|
break;
|
case CORE_FUNC_PWR_WK_EN:
|
value_func1->bit.pwr_wk_en = value_data;
|
break;
|
case CORE_FUNC_PWR_OFF_EN:
|
value_func1->bit.pwr_opwer_en = value_data;
|
break;
|
default:
|
break;
|
}
|
data = *((uint8_t *)value_func);
|
return data;
|
}
|
|
|
//add spirit class s------------------------
|
#if 1
|
|
static ssize_t mcu_driver_version(struct class *cls,
|
struct class_attribute *attr,
|
char *buf)
|
{
|
u8 newversion=0x04; //if MCU firmware need to update ,set newversion to latest MCU firmware version
|
|
return snprintf(buf, 4, "%02x\n",newversion);
|
}
|
|
static ssize_t spirit_version(struct class *cls,
|
struct class_attribute *attr,
|
char *buf)
|
{
|
int ret = 0;
|
u8 read_mcu_id = 0;
|
ret = Mcu_i2c_readregister(gClient, CORE_FW_VERSION, 1,&read_mcu_id);
|
if (ret < 0) {
|
printk("jw_mcu read fail\n");
|
return -EINVAL;
|
}
|
printk("spirit_version = %d ------------ison\n",read_mcu_id);
|
|
return snprintf(buf, 4, "%02x\n",read_mcu_id);
|
}
|
|
static void MCU_UPDATE(void){
|
int ret = 0;
|
u8 tmp ;
|
|
tmp=1;
|
ret = Mcu_i2c_writeregister(gClient, CORE_FW_UPDATE, 1, tmp);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return;
|
}
|
msleep(100);
|
kernel_restart(NULL);
|
printk("CORE_FW_UPDATE ret = %d ------------ison\n",ret);
|
|
}
|
|
static ssize_t set_mcu_update(struct class *cls,
|
struct class_attribute *attr,
|
const char *buf, size_t size)
|
{
|
u32 enable;
|
sscanf(buf, "%d", &enable);
|
printk("Spirit UPDATE enable =%d----ison\n",enable);
|
if (enable)
|
{
|
printk("Spirit UPDATE------ISON\n");
|
MCU_UPDATE();
|
}
|
return size;
|
}
|
#endif
|
static ssize_t get_mcu_state_autopower(struct class *class,struct class_attribute *attr, char *buf)
|
{
|
int ret = 0;
|
u8 autopower_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1, &autopower_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return -1;
|
}
|
printk("get_autopower autopower_reg = %d ------------ison\n",autopower_state);
|
if(get_value_func_cfg(CORE_FUNC_POWER_LOSS,autopower_state)){
|
autopower_state = 1;
|
}else{
|
autopower_state = 0;
|
}
|
printk("get_autopower autopower_state = %d ------------ison\n",autopower_state);
|
return snprintf(buf, 3, "%02x\n",autopower_state);
|
}
|
|
static void MCU_EnableAutopower(void){
|
int ret = 0;
|
u8 tmp ;
|
u8 autopower_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1, &autopower_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return;
|
}
|
tmp = set_value_func_cfg(CORE_FUNC_POWER_LOSS,autopower_state,1);
|
ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return;
|
}
|
msleep(10);
|
printk("EnableAutopower ret = %d ------------ison\n",ret);
|
|
}
|
|
static void MCU_disableAutopower(void){
|
int ret = 0;
|
u8 tmp ;
|
u8 autopower_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1, &autopower_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return;
|
}
|
tmp = set_value_func_cfg(CORE_FUNC_POWER_LOSS,autopower_state,0);
|
ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return;
|
}
|
msleep(10);
|
printk("disableAutopower ret = %d ------------ison\n",ret);
|
|
}
|
|
static ssize_t set_mcu_enable_autopower(struct class *cls,
|
struct class_attribute *attr,
|
const char *buf, size_t size)
|
{
|
u32 enable;
|
sscanf(buf, "%d", &enable);
|
printk("set_autopower enable =%d----ison\n",enable);
|
if (enable)
|
{
|
//printk("set_mcu_enable_autopower ENABLE------ISON\n");
|
MCU_EnableAutopower();
|
}
|
else {
|
MCU_disableAutopower();
|
//printk("set_mcu_enable_autopower DISABLE------ISON\n");
|
}
|
return size;
|
}
|
|
static ssize_t get_mcu_state_watchdog(struct class *class,struct class_attribute *attr, char *buf)
|
{
|
int ret = 0;
|
u8 watchdog_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1, &watchdog_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return -1;
|
}
|
printk("get_watchdog watchdog_state = %d ------------ison\n",watchdog_state);
|
if(get_value_func_cfg(CORE_FUNC_WDT,watchdog_state)){
|
watchdog_state = 1;
|
}else{
|
watchdog_state = 0;
|
}
|
printk("get_watchdog watchdog_state = %d ------------ison\n",watchdog_state);
|
return snprintf(buf, 3, "%02x\n",watchdog_state);
|
}
|
|
static void MCU_EnableWatchdog(void){
|
int ret = 0;
|
u8 tmp ;
|
u8 watchdog_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1, &watchdog_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return;
|
}
|
tmp = set_value_func_cfg(CORE_FUNC_WDT,watchdog_state,1);
|
ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return;
|
}
|
msleep(10);
|
printk("EnableWatchdog ret = %d ------------ison\n",ret);
|
|
}
|
|
static void MCU_disableWatchdog(void){
|
int ret = 0;
|
u8 tmp ;
|
u8 watchdog_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1, &watchdog_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return;
|
}
|
tmp = set_value_func_cfg(CORE_FUNC_WDT,watchdog_state,0);
|
ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return;
|
}
|
msleep(10);
|
printk("disableWatchdog ret = %d ------------ison\n",ret);
|
|
}
|
|
static void watchdog_work(void){
|
int ret;
|
|
ret = gpio_direction_output(mcu_watchdog_gpio, 1);
|
if(ret < 0){
|
printk("%s() gpio_direction_input mcu_watchdog_gpio set ERROR\n", __FUNCTION__);
|
}
|
ret = gpio_direction_output(mcu_watchdog_gpio, 0);
|
if(ret < 0){
|
printk("%s() gpio_direction_input mcu_watchdog_gpio set ERROR\n", __FUNCTION__);
|
}
|
ret = gpio_direction_output(mcu_watchdog_gpio, 1);
|
if(ret < 0){
|
printk("%s() gpio_direction_input mcu_watchdog_gpio set ERROR\n", __FUNCTION__);
|
}
|
|
}
|
|
static void watchdog_timer_work(struct work_struct *work)
|
{
|
watchdog_work();
|
schedule_delayed_work(&watchdog_delay_work, msecs_to_jiffies(WATCHDOG_FEED_COUNT));
|
}
|
|
|
void watchdog_init(void){
|
int ret = 0;
|
enum of_gpio_flags flags;
|
ret = of_get_named_gpio_flags(node_MCU, "mcu_watchdog_gpio", 0, &flags);
|
if (ret < 0) {
|
printk("%s() Can not read property mcu_watchdog_gpio\n", __FUNCTION__);
|
} else {
|
mcu_watchdog_gpio = ret;
|
ret = devm_gpio_request(dev_MCU, mcu_watchdog_gpio, "mcu_watchdog_gpio");
|
if(ret < 0){
|
printk("%s() devm_gpio_request mcu_watchdog_gpio request ERROR\n", __FUNCTION__);
|
}
|
ret = gpio_direction_output(mcu_watchdog_gpio,1);
|
if(ret < 0){
|
printk("%s() gpio_direction_input mcu_watchdog_gpio set ERROR\n", __FUNCTION__);
|
}
|
}
|
|
INIT_DELAYED_WORK(&watchdog_delay_work, watchdog_timer_work);
|
schedule_delayed_work(&watchdog_delay_work, msecs_to_jiffies(WATCHDOG_FEED_COUNT));
|
}
|
|
static ssize_t set_mcu_enable_watchdog(struct class *cls,
|
struct class_attribute *attr,
|
const char *buf, size_t size)
|
{
|
u32 enable;
|
sscanf(buf, "%d", &enable);
|
printk("set_autopower enable =%d----\n",enable);
|
if (enable)
|
{
|
printk("set_mcu_enable_autopower ENABLE------\n");
|
MCU_EnableWatchdog();
|
|
|
schedule_delayed_work(&watchdog_delay_work, msecs_to_jiffies(WATCHDOG_FEED_COUNT));
|
|
}
|
else {
|
MCU_disableWatchdog();
|
schedule_delayed_work(&watchdog_delay_work, msecs_to_jiffies(0));
|
|
|
printk("set_mcu_enable_autopower DISABLE------\n");
|
}
|
return size;
|
}
|
|
static ssize_t set_watchdog_test(struct class *cls,
|
struct class_attribute *attr,
|
const char *buf, size_t size)
|
{
|
u32 enable;
|
sscanf(buf, "%d", &enable);
|
printk("set_watchdog_test enable =%d----ison\n",enable);
|
if (enable)
|
{
|
//printk("set_mcu_enable_autopower ENABLE------ISON\n");
|
schedule_delayed_work(&watchdog_delay_work, msecs_to_jiffies(WATCHDOG_FEED_COUNT));
|
}
|
else {
|
cancel_delayed_work(&watchdog_delay_work);
|
//printk("set_mcu_enable_autopower DISABLE------ISON\n");
|
}
|
return size;
|
}
|
|
static ssize_t get_mcu_state_rtcpower(struct class *class,struct class_attribute *attr, char *buf)
|
{
|
int ret = 0;
|
u8 rtcpower_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1, &rtcpower_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return -1;
|
}
|
printk("get_rtcpower rtcpower_state = %d ------------ison\n",rtcpower_state);
|
if(get_value_func_cfg(CORE_FUNC_ALARM,rtcpower_state)){
|
rtcpower_state = 1;
|
}else{
|
rtcpower_state = 0;
|
}
|
printk("get_rtcpower rtcpower_state = %d ------------ison\n",rtcpower_state);
|
return snprintf(buf, 3, "%02x\n",rtcpower_state);
|
}
|
|
static void MCU_EnableRtcpower(void){
|
int ret = 0;
|
u8 tmp ;
|
u8 rtcpower_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1, &rtcpower_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return;
|
}
|
tmp = set_value_func_cfg(CORE_FUNC_ALARM,rtcpower_state,1);
|
ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return;
|
}
|
msleep(10);
|
printk("EnableRtcpower ret = %d ------------ison\n",ret);
|
|
}
|
|
static void MCU_disableRtcpower(void){
|
int ret = 0;
|
u8 tmp ;
|
u8 rtcpower_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG0, 1, &rtcpower_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return;
|
}
|
tmp = set_value_func_cfg(CORE_FUNC_ALARM,rtcpower_state,0);
|
ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG0, 1, tmp);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return;
|
}
|
msleep(10);
|
printk("disableRtcpower ret = %d ------------ison\n",ret);
|
|
}
|
|
static ssize_t set_mcu_enable_rtcpower(struct class *cls,
|
struct class_attribute *attr,
|
const char *buf, size_t size)
|
{
|
u32 enable;
|
sscanf(buf, "%d", &enable);
|
printk("set_rtcpower enable =%d----ison\n",enable);
|
if (enable)
|
{
|
//printk("set_mcu_enable_autopower ENABLE------ISON\n");
|
MCU_EnableRtcpower();
|
}
|
else {
|
MCU_disableRtcpower();
|
//printk("set_mcu_enable_autopower DISABLE------ISON\n");
|
}
|
return size;
|
}
|
|
static ssize_t get_mcu_state_ethwol(struct class *class,struct class_attribute *attr, char *buf)
|
{
|
int ret = 0;
|
u8 ethwol_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG1, 1, ðwol_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return -1;
|
}
|
printk("get_ethwol ethwol_state = %d ------------ison\n",ethwol_state);
|
if(get_value_func_cfg(CORE_FUNC_PWR_WK_EN,ethwol_state)){
|
ethwol_state = 1;
|
}else{
|
ethwol_state = 0;
|
}
|
printk("get_ethwol ethwol_state = %d ------------ison\n",ethwol_state);
|
return snprintf(buf, 3, "%02x\n",ethwol_state);
|
}
|
|
static void MCU_EnableEthwol(void){
|
int ret = 0;
|
u8 tmp ;
|
u8 ethwol_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG1, 1, ðwol_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return;
|
}
|
tmp = set_value_func_cfg(CORE_FUNC_PWR_WK_EN,ethwol_state,1);
|
ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG1, 1, tmp);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return;
|
}
|
msleep(10);
|
printk("EnableEthwol ret = %d ------------ison\n",ret);
|
|
}
|
|
static void MCU_disableEthwol(void){
|
int ret = 0;
|
u8 tmp ;
|
u8 ethwol_state=0;
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG1, 1, ðwol_state);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return;
|
}
|
tmp = set_value_func_cfg(CORE_FUNC_PWR_WK_EN,ethwol_state,0);
|
ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG1, 1, tmp);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return;
|
}
|
msleep(10);
|
printk("disableEthwol ret = %d ------------ison\n",ret);
|
|
}
|
|
static ssize_t set_mcu_enable_ethwol(struct class *cls,
|
struct class_attribute *attr,
|
const char *buf, size_t size)
|
{
|
u32 enable;
|
sscanf(buf, "%d", &enable);
|
printk("set_ethwol enable =%d----ison\n",enable);
|
if (enable)
|
{
|
//printk("set_mcu_enable_autopower ENABLE------ISON\n");
|
MCU_EnableEthwol();
|
}
|
else {
|
MCU_disableEthwol();
|
//printk("set_mcu_enable_autopower DISABLE------ISON\n");
|
}
|
return size;
|
}
|
|
|
static struct class *spirit_class;
|
static CLASS_ATTR(Update, 0666, NULL, set_mcu_update);
|
static CLASS_ATTR(SpiritEnableAutopower, 0666, get_mcu_state_autopower, set_mcu_enable_autopower);
|
static CLASS_ATTR(Verison, 0666, mcu_driver_version, NULL);
|
static CLASS_ATTR(SpiritVerison, 0666, spirit_version, NULL);
|
static CLASS_ATTR(Watchdog, 0666, get_mcu_state_watchdog, set_mcu_enable_watchdog);
|
static CLASS_ATTR(Watchdog_test, 0666, NULL, set_watchdog_test);
|
static CLASS_ATTR(Rtcpower, 0666, get_mcu_state_rtcpower, set_mcu_enable_rtcpower);
|
static CLASS_ATTR(EthWol, 0666, get_mcu_state_ethwol, set_mcu_enable_ethwol);
|
|
|
//add spirit class e------------------------
|
|
int jw_mcu_get_cc_status(u8 *role, u8 *direction){
|
u8 ret_role,ret_direction;
|
int ret;
|
ret = Mcu_i2c_readregister(gClient, CORE_ANX7411_CC_ROLE, 1,&ret_role);
|
if (ret < 0) {
|
printk("jw_mcu_get_cc_status read fail\n");
|
return -EINVAL;
|
}
|
ret = Mcu_i2c_readregister(gClient, CORE_ANX7411_CC_DIRECTION, 1,&ret_direction);
|
if (ret < 0) {
|
printk("jw_mcu_get_cc_status read fail\n");
|
return -EINVAL;
|
}
|
printk("jw_mcu_get_cc_status ret_role=%d,ret_direction=%d---ison\n",ret_role,ret_direction);
|
*role = ret_role;
|
*direction = ret_direction;
|
return ret;
|
}
|
|
|
void MCU_Set_EthPhyAddr(char *addr){
|
int ret = 0,i;
|
//u8 tmp =0;
|
char *addr_l = addr;
|
for(i = 0;i < 6;i++){
|
printk("MCU_Set_EthPhyAddr %d------------ison\n",addr_l[i]);
|
ret = Mcu_i2c_writeregister(gClient, CORE_ETH_PHY_ADDR0 + i, 1, addr_l[i]);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return;
|
}
|
}
|
}
|
///////////////andy add
|
|
static int rtl8211_phy_power_off(struct notifier_block *this,
|
unsigned long code, void *unused)
|
{
|
u8 ethwol_power=0,tmp;
|
int ret = 0;
|
|
if (code == SYS_POWER_OFF){
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG1, 1,ðwol_power);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return -1;
|
}
|
tmp = set_value_func_cfg(CORE_FUNC_PWR_OFF_EN,ethwol_power,0);
|
ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG1, 1, tmp);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return -1;
|
}
|
printk("write power off message to mcu ------------andy\n");
|
}
|
return NOTIFY_OK;
|
}
|
////////////////andy end
|
static struct notifier_block rtl8211_phy_notifier = {
|
.notifier_call = rtl8211_phy_power_off,
|
};
|
|
|
static int jw_mcu_probe(struct i2c_client *client, const struct i2c_device_id *id)
|
|
{
|
int ret = 0, err;
|
u8 read_mcu_id=0,ethwol_power=0,tmp;
|
//char tmp1[2];
|
//enum of_gpio_flags flags;
|
node_MCU = client->dev.of_node;
|
dev_MCU = &client->dev;
|
gClient = client;
|
printk("%s \n",__FUNCTION__);
|
|
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
|
printk(KERN_ERR "jw_mcu_probe: need I2C_FUNC_I2C\n");
|
ret = -ENODEV;
|
}
|
//ison s
|
#if 1
|
ret=Mcu_i2c_readregister(client, CORE_FW_VERSION, 1,&read_mcu_id);
|
if (ret < 0) {
|
printk("jw_mcu read fail\n");
|
return -EINVAL;
|
}
|
printk("Mcu_i2c_readregister 1 read1 = %d ------------ison\n",read_mcu_id);
|
#endif
|
//ison e
|
|
|
|
spirit_class = class_create(THIS_MODULE, "spirit_class");
|
if (IS_ERR(spirit_class)) {
|
printk(KERN_ERR "Failed to create spirit_class\n");
|
spirit_class = NULL;
|
return -EINVAL;
|
}
|
|
ret = class_create_file(spirit_class, &class_attr_Update);
|
ret = class_create_file(spirit_class, &class_attr_SpiritEnableAutopower);
|
ret = class_create_file(spirit_class, &class_attr_Verison);
|
ret = class_create_file(spirit_class, &class_attr_SpiritVerison);
|
ret = class_create_file(spirit_class, &class_attr_Watchdog);
|
ret = class_create_file(spirit_class, &class_attr_Watchdog_test);
|
ret = class_create_file(spirit_class, &class_attr_Rtcpower);
|
ret = class_create_file(spirit_class, &class_attr_EthWol);
|
|
watchdog_init();
|
|
err = register_reboot_notifier(&rtl8211_phy_notifier);
|
if (err) {
|
printk("unable to register jw_mcu_probe reboot notifier\n");
|
}
|
|
///////////////andy add
|
ret=Mcu_i2c_readregister(gClient, CORE_FUNC_CFG1, 1,ðwol_power);
|
if (ret < 0) {
|
printk("Mcu_i2c_readregister fail\n");
|
return -1;
|
}
|
tmp = set_value_func_cfg(CORE_FUNC_PWR_OFF_EN,ethwol_power,1);
|
|
ret = Mcu_i2c_writeregister(gClient, CORE_FUNC_CFG1, 1, tmp);
|
if (ret < 0) {
|
printk("Mcu_i2c_writeregister fail\n");
|
return -1;
|
}
|
|
/////////////andy end
|
|
printk("%s: probe ok!!\n", __FUNCTION__);
|
|
|
|
return 0;
|
|
}
|
|
|
static const struct i2c_device_id jw_mcu_id[] = {
|
{ "jw_mcu", 0 },
|
{ }
|
};
|
|
static const struct of_device_id jw_mcu_of_match[] = {
|
{ .compatible = "everest,jw_mcu", },
|
{ }
|
};
|
MODULE_DEVICE_TABLE(of, jw_mcu_of_match);
|
|
|
static struct i2c_driver jw_mcu_driver = {
|
.driver = {
|
.name = "jw_mcu",
|
.of_match_table = of_match_ptr(jw_mcu_of_match),
|
},
|
.probe = jw_mcu_probe,
|
.id_table = jw_mcu_id,
|
//.remove = __devexit_p(cec_input_control_remove),
|
};
|
|
module_i2c_driver(jw_mcu_driver);
|
MODULE_AUTHOR("ison@jwele.com.cn");
|
MODULE_DESCRIPTION("jw mcu driver");
|
MODULE_LICENSE("GPL");
|
