.type = "rtc-s35392a",
.addr = 0x30,
.flags = 0,
+ .irq = RK2818_PIN_PE2,
},
#endif
#if defined (CONFIG_FM_QN8006)
* camera devices
* author: ddl@rock-chips.com
*****************************************************************************************/
-#ifdef CONFIG_VIDEO_RK2818
#define RK2818_CAM_POWER_PIN FPGA_PIO1_05//SPI_GPIO_P1_05
-#define RK2818_CAM_RESET_PIN FPGA_PIO1_14//SPI_GPIO_P1_14
+#define RK2818_CAM_RESET_PIN FPGA_PIO1_14//SPI_GPIO_P1_14
static int rk28_sensor_io_init(void);
static int rk28_sensor_io_deinit(void);
{
.gpio_reset = RK2818_CAM_RESET_PIN,
.gpio_power = RK2818_CAM_POWER_PIN,
- .gpio_flag = (RK28_CAM_POWERACTIVE_L|RK28_CAM_RESETACTIVE_L),
.dev_name = "ov2655"
}, {
.gpio_reset = INVALID_GPIO,
{
int ret = 0, i;
unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;
- unsigned int camera_ioflag;
-
- //printk("\n%s....%d ******** ddl *********\n",__FUNCTION__,__LINE__);
- for (i=0; i<2; i++) {
+ printk("\n%s....%d ******** ddl *********\n",__FUNCTION__,__LINE__);
+
+ for (i=0; i<2; i++) {
camera_reset = rk28_camera_platform_data.gpio_res[i].gpio_reset;
- camera_power = rk28_camera_platform_data.gpio_res[i].gpio_power;
- camera_ioflag = rk28_camera_platform_data.gpio_res[i].gpio_flag;
-
- if (camera_power != INVALID_GPIO) {
+ camera_power = rk28_camera_platform_data.gpio_res[i].gpio_power;
+
+ if (camera_power != INVALID_GPIO) {
ret = gpio_request(camera_power, "camera power");
if (ret)
continue;
-
- gpio_set_value(camera_reset, (((~camera_ioflag)&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
- gpio_direction_output(camera_power, (((~camera_ioflag)&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
-
- //printk("\n%s....%d %x ******** ddl *********\n",__FUNCTION__,__LINE__,(((~camera_ioflag)&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
+
+ gpio_set_value(camera_reset, 1);
+ gpio_direction_output(camera_power, 0);
}
-
+
if (camera_reset != INVALID_GPIO) {
ret = gpio_request(camera_reset, "camera reset");
if (ret) {
- if (camera_power != INVALID_GPIO)
- gpio_free(camera_power);
+ if (camera_power != INVALID_GPIO)
+ gpio_free(camera_power);
continue;
}
- gpio_set_value(camera_reset, ((camera_ioflag&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
- gpio_direction_output(camera_reset, ((camera_ioflag&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
-
- //printk("\n%s....%d %x ******** ddl *********\n",__FUNCTION__,__LINE__,((camera_ioflag&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
+ gpio_set_value(camera_reset, 0);
+ gpio_direction_output(camera_reset, 0);
}
}
-
+
return 0;
}
unsigned int i;
unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;
- //printk("\n%s....%d ******** ddl *********\n",__FUNCTION__,__LINE__);
-
- for (i=0; i<2; i++) {
+ printk("\n%s....%d ******** ddl *********\n",__FUNCTION__,__LINE__);
+
+ for (i=0; i<2; i++) {
camera_reset = rk28_camera_platform_data.gpio_res[i].gpio_reset;
- camera_power = rk28_camera_platform_data.gpio_res[i].gpio_power;
-
+ camera_power = rk28_camera_platform_data.gpio_res[i].gpio_power;
+
if (camera_power != INVALID_GPIO){
gpio_direction_input(camera_power);
- gpio_free(camera_power);
+ gpio_free(camera_power);
}
-
+
if (camera_reset != INVALID_GPIO) {
gpio_direction_input(camera_reset);
- gpio_free(camera_reset);
+ gpio_free(camera_reset);
}
}
static int rk28_sensor_power(struct device *dev, int on)
{
unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;
- unsigned int camera_ioflag;
-
+
if(rk28_camera_platform_data.gpio_res[0].dev_name && (strcmp(rk28_camera_platform_data.gpio_res[0].dev_name, dev_name(dev)) == 0)) {
camera_reset = rk28_camera_platform_data.gpio_res[0].gpio_reset;
camera_power = rk28_camera_platform_data.gpio_res[0].gpio_power;
- camera_ioflag = rk28_camera_platform_data.gpio_res[0].gpio_flag;
} else if (rk28_camera_platform_data.gpio_res[1].dev_name && (strcmp(rk28_camera_platform_data.gpio_res[1].dev_name, dev_name(dev)) == 0)) {
camera_reset = rk28_camera_platform_data.gpio_res[1].gpio_reset;
camera_power = rk28_camera_platform_data.gpio_res[1].gpio_power;
- camera_ioflag = rk28_camera_platform_data.gpio_res[1].gpio_flag;
}
if (camera_reset != INVALID_GPIO) {
- gpio_set_value(camera_reset, ((camera_ioflag&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
- //printk("\n%s..%s..ResetPin=%d ..PinLevel = %x ******** ddl *********\n",__FUNCTION__,dev_name(dev),camera_reset, ((camera_ioflag&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
+ gpio_set_value(camera_reset, !on);
+ //printk("\n%s..%s..ResetPin=%d ..PinLevel = %x ******** ddl *********\n",__FUNCTION__,dev_name(dev),camera_reset, on);
}
- if (camera_power != INVALID_GPIO) {
- if (on) {
- gpio_set_value(camera_power, ((camera_ioflag&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
- //printk("\n%s..%s..PowerPin=%d ..PinLevel = %x ******** ddl *********\n",__FUNCTION__,dev_name(dev), camera_power, ((camera_ioflag&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
- } else {
- gpio_set_value(camera_power, (((~camera_ioflag)&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
- //printk("\n%s..%s..PowerPin=%d ..PinLevel = %x ******** ddl *********\n",__FUNCTION__,dev_name(dev), camera_power, (((~camera_ioflag)&RK28_CAM_POWERACTIVE_MASK)>>RK28_CAM_POWERACTIVE_BITPOS));
- }
-
+ if (camera_power != INVALID_GPIO) {
+ gpio_set_value(camera_power, !on);
+ printk("\n%s..%s..PowerPin=%d ..PinLevel = %x ******** ddl *********\n",__FUNCTION__,dev_name(dev), camera_power, !on);
}
if (camera_reset != INVALID_GPIO) {
msleep(3); /* delay 3 ms */
- gpio_set_value(camera_reset,(((~camera_ioflag)&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
- //printk("\n%s..%s..ResetPin= %d..PinLevel = %x ******** ddl *********\n",__FUNCTION__,dev_name(dev), camera_reset, (((~camera_ioflag)&RK28_CAM_RESETACTIVE_MASK)>>RK28_CAM_RESETACTIVE_BITPOS));
- }
+ gpio_set_value(camera_reset,on);
+ printk("\n%s..%s..ResetPin= %d..PinLevel = %x ******** ddl *********\n",__FUNCTION__,dev_name(dev), camera_reset, on);
+ }
return 0;
}
.module_name = "ov2655",
#endif
};
-#endif
/*****************************************************************************************
* battery devices
#endif
#ifdef CONFIG_INPUT_LPSENSOR_CM3602
+static int capella_cm3602_power(int on);
+
+static struct capella_cm3602_platform_data capella_cm3602_pdata = {
+ .power = capella_cm3602_power,
+ .irq_pin = FPGA_PIO0_04,
+ .pwd_out_pin = FPGA_PIO4_07,
+ .ps_shutdown_pin = FPGA_PIO5_00,
+ //.p_out = MAHIMAHI_GPIO_PROXIMITY_INT_N
+ };
+
static int capella_cm3602_power(int on)
{ /* TODO eolsen Add Voltage reg control */
if (on) {
- // gpio_direction_output(MAHIMAHI_GPIO_PROXIMITY_EN, 0);
+ printk("[%s]:on---\n",__FUNCTION__);
+ gpio_direction_output(capella_cm3602_pdata.pwd_out_pin, SPI_GPIO_OUT);
+ gpio_set_value(capella_cm3602_pdata.pwd_out_pin, SPI_GPIO_LOW); //CM3605_PWD output
+ gpio_direction_output(capella_cm3602_pdata.ps_shutdown_pin, SPI_GPIO_OUT);
+ gpio_set_value(capella_cm3602_pdata.ps_shutdown_pin, SPI_GPIO_LOW); //CM3605_PS_SHUTDOWN
}
- else {
- // gpio_direction_output(MAHIMAHI_GPIO_PROXIMITY_EN, 1);
+ else {
+ printk("[%s]:off---\n",__FUNCTION__);
+ gpio_set_value(capella_cm3602_pdata.pwd_out_pin, SPI_GPIO_HIGH);
+ gpio_set_value(capella_cm3602_pdata.ps_shutdown_pin, SPI_GPIO_HIGH);
}
return 0;
}
-static struct capella_cm3602_platform_data capella_cm3602_pdata = {
- .power = capella_cm3602_power,
- .irq_pin = SPI_GPIO_P6_04,
- .pwd_out_pin = SPI_GPIO_P4_07,
- .ps_shutdown_pin = SPI_GPIO_P4_08,
- //.p_out = MAHIMAHI_GPIO_PROXIMITY_INT_N
- };
-
struct platform_device rk2818_device_cm3605 = {
.name = CAPELLA_CM3602,
.id = -1,
break;\r
\r
case CMMB_GET_AUDIO_TYPE:{\r
- return cmmbmemo->videotype;\r
+ return cmmbmemo->audiotype;\r
}\r
break;\r
\r
#endif
// to enable log
-int sms_debug =7;
-//int sms_debug =0; //hzb 0526
+//int sms_debug =7;
+int sms_debug =0; //hzb 0526
// for loopback
char g_LbResBuf[256]={0};
//
//sms_debug("client=0x %x\n", client);
rc = client->onresponse_handler(client->context, cb);
}
- sms_debug("onresponse_handler ret = 0x%x\n", rc);
- sms_debug("phdr->msgType %d\n", phdr->msgType);
+ //sms_debug("onresponse_handler ret = 0x%x\n", rc);
+ // sms_debug("phdr->msgType %d\n", phdr->msgType);
#include <mach/gpio.h>
#include "smscoreapi.h"
-
+#include <mach/iomux.h>
#define SSP_PORT 1
u_irq_count ++;
// PDEBUG("INT counter = %d\n", u_irq_count);
- printk("cmmb siano 1186 int\n");
+ //printk("cmmb siano 1186 int\n");
sms_info("spibus_interrupt %d\n", u_irq_count);
if (spiphy_dev->interruptHandler)
if(txbuf)
{
- sms_debug("tx_buf:%x,%x,%x,%x,%x,%x", txbuf[0], txbuf[1], txbuf[2], txbuf[3], txbuf[4],txbuf[5]);
+ // sms_debug("tx_buf:%x,%x,%x,%x,%x,%x", txbuf[0], txbuf[1], txbuf[2], txbuf[3], txbuf[4],txbuf[5]);
ret = spi_write(spiphy_dev->Smsdevice, txbuf, len);
if ((rxbuf)&&(len != 16))
ret = spi_read(spiphy_dev->Smsdevice, rxbuf, len);
- sms_debug("rxbuf 4, 5,6,7,8,9=%x,%x,%x,%x,%x,%x\n",rxbuf[4],rxbuf[5],rxbuf[6],rxbuf[7],rxbuf[8],rxbuf[9]);
+ // sms_debug("rxbuf 4, 5,6,7,8,9=%x,%x,%x,%x,%x,%x\n",rxbuf[4],rxbuf[5],rxbuf[6],rxbuf[7],rxbuf[8],rxbuf[9]);
//sms_debug("sms spi read buf=0x%x\n",rxbuf[5]);
}
//ssp_disable(&(spiphy_dev->sspdev));
//ssp_exit(&spiphy_dev->sspdev);
free_irq(gpio_to_irq(CMMB_1186_SPIIRQ), spiphy_dev);
-
+//zyc
+ gpio_direction_output(CMMB_1186_SPIIRQ,0);
/* release DMA resources */
//if (spiphy_dev->rx_dma_channel >= 0)
//pxa_free_dma(spiphy_dev->rx_dma_channel);
#endif
//1186 cmmb power on
-
+//set the SPI CS mode , zyc
+ //rk2818_mux_api_set(GPIOB4_SPI0CS0_MMC0D4_NAME,1);
gpio_direction_output(CMMB_1186_POWER_RESET,0);
gpio_direction_output(CMMB_1186_POWER_DOWN,0);
//1186 cmmb power down
#if 1
gpio_direction_output(CMMB_1186_POWER_ENABLE,0);
+//set the CS0 as gpio mode
+
+// rk2818_mux_api_set(GPIOB4_SPI0CS0_MMC0D4_NAME,0);
+// gpio_direction_output(GPIOB4_SPI0CS0_MMC0D4_NAME,0);
printk("cmmb chip_powerdown !!!!\n");
chip_poweron();
free_irq(gpio_to_irq(CMMB_1186_SPIIRQ), spiphy_dev);
//printk("siano 1186 request irq\n");
- gpio_pull_updown(CMMB_1186_SPIIRQ,GPIOPullDown);
+// spiirqgpio low , PULLUP , zyc
+ gpio_direction_output(CMMB_1186_SPIIRQ,0);
+ gpio_pull_updown(CMMB_1186_SPIIRQ,GPIOPullUp);
+
//ret = request_gpio_irq(CMMB_1186_SPIIRQ, (pFunc)spibus_interrupt, GPIOEdgelRising, spiphy_dev);
request_irq(gpio_to_irq(CMMB_1186_SPIIRQ),spibus_interrupt,IRQF_TRIGGER_RISING,NULL,spiphy_dev);
if(ret<0){
spiphy_dev->Smsdevice = (struct spi_device*)context;
//gpio_pull_updown(CMMB_1186_SPIIRQ, IRQT_FALLING);
+//set IRO GPIO as gpio mode ,zyc
+ //rk2818_mux_api_set(GPIOA6_FLASHCS2_SEL_NAME,0);
error = gpio_request(CMMB_1186_SPIIRQ,"cmmb irq");
if (error) {
//dev_err(&pdev->dev, "failed to request play key gpio\n");
#endif
//ret = request_gpio_irq(CMMB_1186_SPIIRQ, spibus_interrupt, GPIOEdgelRising, spiphy_dev);//
+
+//zyc
+ gpio_direction_output(CMMB_1186_SPIIRQ,0);
gpio_pull_updown(CMMB_1186_SPIIRQ,GPIOPullUp);
+
//ret = request_gpio_irq(CMMB_1186_SPIIRQ, (pFunc)spibus_interrupt, GPIOEdgelRising, spiphy_dev);
request_irq(gpio_to_irq(CMMB_1186_SPIIRQ),spibus_interrupt,IRQF_TRIGGER_RISING,NULL,spiphy_dev);
INIT_LIST_HEAD(&port->trans_queue);\r
#endif\r
\r
- spi_fpga_rst();\r
+ //spi_fpga_rst();\r
sprintf(b, "fpga_irq_workqueue");\r
port->fpga_irq_workqueue = create_freezeable_workqueue(b);\r
if (!port->fpga_irq_workqueue) {\r
#define MMA7660_SPEED 200 * 1000
/* Addresses to scan -- protected by sense_data_mutex */
-static char sense_data[RBUFF_SIZE + 1];
+//static char sense_data[RBUFF_SIZE + 1];
static struct i2c_client *this_client;
+static struct miscdevice mma7660_device;
static DECLARE_WAIT_QUEUE_HEAD(data_ready_wq);
-static atomic_t data_ready;
+
#ifdef CONFIG_ANDROID_POWER
static android_early_suspend_t mma7660_early_suspend;
#endif
return ret ;
}
-static int mma7660_rx_data(char *rxData, int length)
+static int mma7660_rx_data(struct i2c_client *client, char *rxData, int length)
{
int ret = 0;
char reg = rxData[0];
- ret = i2c_master_reg8_recv(this_client, reg, rxData, length, MMA7660_SPEED);
+ ret = i2c_master_reg8_recv(client, reg, rxData, length, MMA7660_SPEED);
return (ret > 0)? 0 : ret;
}
-static int mma7660_tx_data(char *txData, int length)
+static int mma7660_tx_data(struct i2c_client *client, char *txData, int length)
{
int ret = 0;
char reg = txData[0];
- ret = i2c_master_reg8_send(this_client, reg, &txData[1], length-1, MMA7660_SPEED);
+ ret = i2c_master_reg8_send(client, reg, &txData[1], length-1, MMA7660_SPEED);
return (ret > 0)? 0 : ret;
}
-static int mma7660_set_rate(char rate)
+static int mma7660_set_rate(struct i2c_client *client, char rate)
{
char buffer[2];
int ret = 0;
buffer[0] = MMA7660_REG_SR;
buffer[1] = 0xf8 | (0x07 & (~i));
- ret = mma7660_tx_data(&(buffer[0]), 2);
- ret = mma7660_rx_data(&(buffer[0]), 1);
+ ret = mma7660_tx_data(client, &(buffer[0]), 2);
+ ret = mma7660_rx_data(client, &(buffer[0]), 1);
return ret;
}
-static int mma7660_start_dev(char rate)
+static int mma7660_start_dev(struct i2c_client *client, char rate)
{
char buffer[MMA7660_REG_LEN];
int ret = 0;
buffer[0] = MMA7660_REG_INTSU;
buffer[1] = 0x10; //0x10; modify by zhao
- ret = mma7660_tx_data(&buffer[0], 2);
- ret = mma7660_rx_data(&buffer[0], 1);
+ ret = mma7660_tx_data(client, &buffer[0], 2);
+ ret = mma7660_rx_data(client, &buffer[0], 1);
- ret = mma7660_set_rate(rate);
+ ret = mma7660_set_rate(client, rate);
buffer[0] = MMA7660_REG_MODE;
- buffer[1] = 0x81;
- ret = mma7660_tx_data(&buffer[0], 2);
- ret = mma7660_rx_data(&buffer[0], 1);
+ buffer[1] = 0x01;
+ ret = mma7660_tx_data(client, &buffer[0], 2);
+ ret = mma7660_rx_data(client, &buffer[0], 1);
- enable_irq(this_client->irq);
+ enable_irq(client->irq);
rk28printk("\n----------------------------mma7660_start------------------------\n");
return ret;
}
-static int mma7660_start(char rate)
+static int mma7660_start(struct i2c_client *client, char rate)
{
- struct mma7660_data *mma = (struct mma7660_data *)i2c_get_clientdata(this_client);
+ struct mma7660_data *mma7660 = (struct mma7660_data *)i2c_get_clientdata(client);
- if (mma->status == MMA7660_OPEN) {
+ if (mma7660->status == MMA7660_OPEN) {
return 0;
}
- mma->status = MMA7660_OPEN;
- return mma7660_start_dev(rate);
+ mma7660->status = MMA7660_OPEN;
+ return mma7660_start_dev(client, rate);
}
-static int mma7660_close_dev(void)
+static int mma7660_close_dev(struct i2c_client *client)
{
char buffer[2];
-
+
+ disable_irq_nosync(client->irq);
+
buffer[0] = MMA7660_REG_MODE;
buffer[1] = 0x00;
- return mma7660_tx_data(buffer, 2);
+ return mma7660_tx_data(client, buffer, 2);
}
-static int mma7660_close(void)
+static int mma7660_close(struct i2c_client *client)
{
- struct mma7660_data *mma = (struct mma7660_data *)i2c_get_clientdata(this_client);
+ struct mma7660_data *mma7660 = (struct mma7660_data *)i2c_get_clientdata(client);
- mma->status = MMA7660_CLOSE;
+ mma7660->status = MMA7660_CLOSE;
- return mma7660_close_dev();
+ return mma7660_close_dev(client);
}
-static int mma7660_reset_rate(char rate)
+static int mma7660_reset_rate(struct i2c_client *client, char rate)
{
int ret = 0;
- ret = mma7660_close_dev();
- ret = mma7660_start_dev(rate);
+ rk28printk("\n----------------------------mma7660_reset_rate------------------------\n");
+
+ ret = mma7660_close_dev(client);
+ ret = mma7660_start_dev(client, rate);
return ret ;
}
return result;
}
-static void mma7660_report_value(short *rbuf)
+static void mma7660_report_value(struct i2c_client *client, struct mma7660_axis *axis)
{
- struct mma7660_data *data = i2c_get_clientdata(this_client);
- struct mma7660_axis *axis = (struct mma7660_axis *)rbuf;
+ struct mma7660_data *mma7660 = i2c_get_clientdata(client);
+ //struct mma7660_axis *axis = (struct mma7660_axis *)rbuf;
/* Report acceleration sensor information */
- input_report_abs(data->input_dev, ABS_X, axis->x);
- input_report_abs(data->input_dev, ABS_Y, axis->y);
- input_report_abs(data->input_dev, ABS_Z, axis->z);
- input_sync(data->input_dev);
+ input_report_abs(mma7660->input_dev, ABS_X, axis->x);
+ input_report_abs(mma7660->input_dev, ABS_Y, axis->y);
+ input_report_abs(mma7660->input_dev, ABS_Z, axis->z);
+ input_sync(mma7660->input_dev);
rk28printk("Gsensor x==%d y==%d z==%d\n",axis->x,axis->y,axis->z);
}
-static int mma7660_get_data(void)
+static int mma7660_get_data(struct i2c_client *client)
{
char buffer[3];
int ret;
struct mma7660_axis axis;
- memset(buffer, 0, 3);
- buffer[0] = MMA7660_REG_X_OUT;
- ret = mma7660_rx_data(&buffer[0], 3);
- //while(mma7660_rx_data(&buffer[0], 3));
- /*
- if (!ret) {
- rk28printk( "%s: -------------------------------------------gsensor device register = [0]:%d [1]:%d [2]:%d [3]:0x%x [4]:0x%x [5]:0x%x [6]:0x%x [7]:0x%x-----------------------------------------------\n",
- __func__, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7]);
- }
- */
- if (ret < 0)
- return ret;
+ do {
+ memset(buffer, 0, 3);
+ buffer[0] = MMA7660_REG_X_OUT;
+ ret = mma7660_rx_data(client, &buffer[0], 3);
+ if (ret < 0)
+ return ret;
+ } while ((buffer[0] & 0x40) || (buffer[1] & 0x40) || (buffer[2] & 0x40));
axis.x = mma7660_convert_to_int(buffer[MMA7660_REG_X_OUT]);
axis.y = -mma7660_convert_to_int(buffer[MMA7660_REG_Y_OUT]);
//rk28printk( "%s: ------------------mma7660_GetData axis = %d %d %d--------------\n",
// __func__, axis.x, axis.y, axis.z);
- memcpy(sense_data, &axis, sizeof(axis));
- mma7660_report_value(sense_data);
+ //memcpy(sense_data, &axis, sizeof(axis));
+ mma7660_report_value(client, &axis);
//atomic_set(&data_ready, 0);
//wake_up(&data_ready_wq);
return 0;
}
+/*
static int mma7660_trans_buff(char *rbuf, int size)
{
//wait_event_interruptible_timeout(data_ready_wq,
return 0;
}
+*/
static int mma7660_open(struct inode *inode, struct file *file)
{
- rk28printk("----------------------------mma7660_open------------------------\n");
return 0;//nonseekable_open(inode, file);
}
char msg[RBUFF_SIZE + 1];
int ret = -1;
char rate;
-
- rk28printk("----------------------------mma7660_ioctl------------------------cmd: %d\n", cmd);
+ struct i2c_client *client = container_of(mma7660_device.parent, struct i2c_client, dev);
switch (cmd) {
case ECS_IOCTL_APP_SET_RATE:
switch (cmd) {
case ECS_IOCTL_START:
- ret = mma7660_start(MMA7660_RATE_32);
+ ret = mma7660_start(client, MMA7660_RATE_32);
if (ret < 0)
return ret;
break;
case ECS_IOCTL_CLOSE:
- ret = mma7660_close();
+ ret = mma7660_close(client);
if (ret < 0)
return ret;
break;
case ECS_IOCTL_APP_SET_RATE:
- ret = mma7660_reset_rate(rate);
+ ret = mma7660_reset_rate(client, rate);
if (ret < 0)
return ret;
break;
+ /*
case ECS_IOCTL_GETDATA:
ret = mma7660_trans_buff(msg, RBUFF_SIZE);
if (ret < 0)
return ret;
break;
+ */
default:
return -ENOTTY;
}
static void mma7660_work_func(struct work_struct *work)
{
- if (mma7660_get_data() < 0)
+ struct mma7660_data *mma7660 = container_of(work, struct mma7660_data, work);
+ struct i2c_client *client = mma7660->client;
+
+ if (mma7660_get_data(client) < 0)
rk28printk(KERN_ERR "MMA7660 mma_work_func: Get data failed\n");
- enable_irq(this_client->irq);
- rk28printk("---------------------------------------mma7660_work_func----------------------------------\n");
+ enable_irq(client->irq);
}
-static void mma7660_delaywork_func(struct work_struct *work)
+static void mma7660_delaywork_func(struct work_struct *work)
{
-
- if (mma7660_get_data() < 0)
- rk28printk(KERN_ERR "MMA7660 mma_work_func: Get data failed\n");
- enable_irq(this_client->irq);
- //rk28printk("---------------------------------------mma7660_delaywork_func------------------------------\n");
+ struct delayed_work *delaywork = container_of(work, struct delayed_work, work);
+ struct mma7660_data *mma7660 = container_of(delaywork, struct mma7660_data, delaywork);
+ struct i2c_client *client = mma7660->client;
+ if (mma7660_get_data(client) < 0)
+ rk28printk(KERN_ERR "MMA7660 mma_work_func: Get data failed\n");
+
+ enable_irq(client->irq);
}
static irqreturn_t mma7660_interrupt(int irq, void *dev_id)
{
- struct mma7660_data *data = dev_id;
- disable_irq_nosync(this_client->irq);
- schedule_delayed_work(&data->delaywork,msecs_to_jiffies(30));
- //rk28printk("--------------------------------------mma7660_interrupt---------------------------------------\n");
+ struct mma7660_data *mma7660 = (struct mma7660_data *)dev_id;
+
+ disable_irq_nosync(irq);
+ schedule_delayed_work(&mma7660->delaywork, msecs_to_jiffies(30));
return IRQ_HANDLED;
}
static int mma7660_remove(struct i2c_client *client)
{
- struct mma7660_data *mma = i2c_get_clientdata(client);
+ struct mma7660_data *mma7660 = i2c_get_clientdata(client);
misc_deregister(&mma7660_device);
- input_unregister_device(mma->input_dev);
- input_free_device(mma->input_dev);
- free_irq(client->irq, mma);
- kfree(mma);
+ input_unregister_device(mma7660->input_dev);
+ input_free_device(mma7660->input_dev);
+ free_irq(client->irq, mma7660);
+ kfree(mma7660);
#ifdef CONFIG_ANDROID_POWER
android_unregister_early_suspend(&mma7660_early_suspend);
#endif
#ifdef CONFIG_ANDROID_POWER
static int mma7660_suspend(android_early_suspend_t *h)
{
+ struct i2c_client *client = container_of(mma7660_device.parent, struct i2c_client, dev);
rk28printk("Gsensor mma7760 enter suspend\n");
- return mma7660_close_dev();
+ return mma7660_close_dev(client);
}
static int mma7660_resume(android_early_suspend_t *h)
{
- struct mma7660_data *mma = (struct mma7660_data *)i2c_get_clientdata(this_client);
+ struct i2c_client *client = container_of(mma7660_device.parent, struct i2c_client, dev);
+ struct mma7660_data *mma7660 = (struct mma7660_data *)i2c_get_clientdata(client);
rk28printk("Gsensor mma7760 resume!!\n");
- return mma7660_start_dev(mma->curr_tate);
+ return mma7660_start_dev(mma7660->curr_tate);
}
-/*
-static int suspend(struct i2c_client *client, pm_message_t mesg)
+#else
+static int mma7660_suspend(struct i2c_client *client, pm_message_t mesg)
{
rk28printk("Gsensor mma7760 enter 2 level suspend\n");
- return mma7660_close_dev();
+ return mma7660_close_dev(client);
}
-static int resume(struct i2c_client *client)
+static int mma7660_resume(struct i2c_client *client)
{
- struct mma7660_data *mma = (struct mma7660_data *)i2c_get_clientdata(this_client);
+ struct mma7660_data *mma7660 = (struct mma7660_data *)i2c_get_clientdata(client);
rk28printk("Gsensor mma7760 2 level resume!!\n");
- return mma7660_start_dev(mma->curr_tate);
+ return mma7660_start_dev(client, mma7660->curr_tate);
}
-*/
-#else
-#define mma7660_suspend NULL
-#define mma7660_resume NULL
#endif
static const struct i2c_device_id mma7660_id[] = {
.id_table = mma7660_id,
.probe = mma7660_probe,
.remove = __devexit_p(mma7660_remove),
- //.suspend = &suspend,
- //.resume = &resume,
+#ifndef CONFIG_ANDROID_POWER
+ .suspend = &mma7660_suspend,
+ .resume = &mma7660_resume,
+#endif
};
static int mma7660_init_client(struct i2c_client *client)
{
- struct mma7660_data *data;
+ struct mma7660_data *mma7660;
int ret;
- data = i2c_get_clientdata(client);
+ mma7660 = i2c_get_clientdata(client);
rk28printk("gpio_to_irq(%d) is %d\n",client->irq,gpio_to_irq(client->irq));
if ( !gpio_is_valid(client->irq)) {
rk28printk("+++++++++++gpio_is_invalid\n");
rk28printk( "failed to request mma7990_trig GPIO%d\n",gpio_to_irq(client->irq));
return ret;
}
+ ret = gpio_direction_input(client->irq);
+ if (ret) {
+ rk28printk("failed to set mma7990_trig GPIO gpio input\n");
+ return ret;
+ }
+ gpio_pull_updown(client->irq, GPIOPullUp);
client->irq = gpio_to_irq(client->irq);
- ret = request_irq(client->irq, mma7660_interrupt, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, client->dev.driver->name, data);
+ ret = request_irq(client->irq, mma7660_interrupt, IRQF_TRIGGER_LOW, client->dev.driver->name, mma7660);
rk28printk("request irq is %d,ret is 0x%x\n",client->irq,ret);
if (ret ) {
rk28printk(KERN_ERR "mma7660_init_client: request irq failed,ret is %d\n",ret);
static int mma7660_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
- struct mma7660_data *mma;
+ struct mma7660_data *mma7660;
int err;
- mma = kzalloc(sizeof(struct mma7660_data), GFP_KERNEL);
- if (!mma) {
+ mma7660 = kzalloc(sizeof(struct mma7660_data), GFP_KERNEL);
+ if (!mma7660) {
rk28printk("[mma7660]:alloc data failed.\n");
err = -ENOMEM;
goto exit_alloc_data_failed;
}
+
+ INIT_WORK(&mma7660->work, mma7660_work_func);
+ INIT_DELAYED_WORK(&mma7660->delaywork, mma7660_delaywork_func);
- INIT_WORK(&mma->work, mma7660_work_func);
- INIT_DELAYED_WORK(&mma->delaywork, mma7660_delaywork_func);
-
- mma->client = client;
- i2c_set_clientdata(client, mma);
+ mma7660->client = client;
+ i2c_set_clientdata(client, mma7660);
this_client = client;
goto exit_request_gpio_irq_failed;
}
- mma->input_dev = input_allocate_device();
- if (!mma->input_dev) {
+ mma7660->input_dev = input_allocate_device();
+ if (!mma7660->input_dev) {
err = -ENOMEM;
rk28printk(KERN_ERR
"mma7660_probe: Failed to allocate input device\n");
goto exit_input_allocate_device_failed;
}
- set_bit(EV_ABS, mma->input_dev->evbit);
+ set_bit(EV_ABS, mma7660->input_dev->evbit);
/* x-axis acceleration */
- input_set_abs_params(mma->input_dev, ABS_X, -1500, 1500, 0, 0);
+ input_set_abs_params(mma7660->input_dev, ABS_X, -1500, 1500, 0, 0);
/* y-axis acceleration */
- input_set_abs_params(mma->input_dev, ABS_Y, -1500, 1500, 0, 0);
+ input_set_abs_params(mma7660->input_dev, ABS_Y, -1500, 1500, 0, 0);
/* z-axis acceleration */
- input_set_abs_params(mma->input_dev, ABS_Z, -1500, 1500, 0, 0);
+ input_set_abs_params(mma7660->input_dev, ABS_Z, -1500, 1500, 0, 0);
- mma->input_dev->name = "compass";
+ mma7660->input_dev->name = "compass";
- err = input_register_device(mma->input_dev);
+ err = input_register_device(mma7660->input_dev);
if (err < 0) {
rk28printk(KERN_ERR
"mma7660_probe: Unable to register input device: %s\n",
- mma->input_dev->name);
+ mma7660->input_dev->name);
goto exit_input_register_device_failed;
}
+ mma7660_device.parent = &client->dev;
err = misc_register(&mma7660_device);
if (err < 0) {
rk28printk(KERN_ERR
android_register_early_suspend(&mma7660_early_suspend);
#endif
rk28printk(KERN_INFO "mma7660 probe ok\n");
- mma->status = -1;
- //mma7660_start(MMA7660_RATE_32);
+ mma7660->status = -1;
+#if 0
+ mma7660_start(client, MMA7660_RATE_32);
+#endif
return 0;
exit_gsensor_sysfs_init_failed:
misc_deregister(&mma7660_device);
exit_misc_device_register_mma7660_device_failed:
- input_unregister_device(mma->input_dev);
+ input_unregister_device(mma7660->input_dev);
exit_input_register_device_failed:
- input_free_device(mma->input_dev);
+ input_free_device(mma7660->input_dev);
exit_input_allocate_device_failed:
- free_irq(client->irq, mma);
+ free_irq(client->irq, mma7660);
exit_request_gpio_irq_failed:
- kfree(mma);
+ kfree(mma7660);
exit_alloc_data_failed:
;
return err;
#include <linux/interrupt.h>
#include <mach/spi_fpga.h>
+#if 0
#define D(x...) printk(x)
+#else
+#define D(x...)
+#endif
static struct capella_cm3602_data {
struct input_dev *input_dev;
static int misc_opened;
-static bool time_enable = true;
+static bool time_enable = false;
static int capella_cm3602_report(struct capella_cm3602_data *data)
{
static irqreturn_t capella_cm3602_irq_handler(int irq, void *data)
{
struct capella_cm3602_data *ip = data;
- printk("------------------capella_cm3602_irq_handler------------\n");
+ printk("---capella_cm3602_irq_handler----\n");
//int val = capella_cm3602_report(ip);
input_report_abs(ip->input_dev, ABS_DISTANCE, 0);
input_sync(ip->input_dev);
- add_timer(&ip->cm3602_timer);
+ //printk("input_report_abs=0\n");
+ //add_timer(&ip->cm3602_timer);
time_enable = true;
return IRQ_HANDLED;
}
{
int rc;
D("%s\n", __func__);
- time_enable = true;
+ //time_enable = true;
if (data->enabled) {
D("%s: already enabled\n", __func__);
return 0;
}
- gpio_set_value(data->pdata->pwd_out_pin, SPI_GPIO_LOW); //CM3605_PWD output
- gpio_set_value(data->pdata->ps_shutdown_pin, SPI_GPIO_LOW); //CM3605_PS_SHUTDOWN
+/* gpio_direction_output(pdata->pwd_out_pin, SPI_GPIO_OUT);
+ gpio_set_value(pdata->pwd_out_pin, SPI_GPIO_LOW); //CM3605_PWD output
+ gpio_direction_output(pdata->ps_shutdown_pin, SPI_GPIO_OUT);
+ gpio_set_value(pdata->ps_shutdown_pin, SPI_GPIO_LOW); //CM3605_PS_SHUTDOWN
+*/
data->pdata->power(1);
data->enabled = !rc;
if (!rc)
D("%s: already disabled\n", __func__);
return 0;
}
- gpio_set_value(data->pdata->pwd_out_pin, GPIO_HIGH); //CM3605_PWD output
- gpio_set_value(data->pdata->ps_shutdown_pin, GPIO_HIGH); //CM3605_PS_SHUTDOWN
+// gpio_set_value(data->pdata->pwd_out_pin, GPIO_HIGH); //CM3605_PWD output
+// gpio_set_value(data->pdata->ps_shutdown_pin, GPIO_HIGH); //CM3605_PS_SHUTDOWN
data->pdata->power(0);
data->enabled = 0;
return rc;
time_enable = false;
input_report_abs(pdata->input_dev, ABS_DISTANCE, val);
input_sync(pdata->input_dev);
+ printk("input_report_abs=%d\n",val);
}
}
static void cm3602_timer(unsigned long data)
{
struct capella_cm3602_data *ip = data;
- printk("------------------cm3602_timer,%d------------\n",time_enable);
-
+ //printk("------------------cm3602_timer,%d------------\n",time_enable);
+ ip->cm3602_timer.expires = jiffies + HZ;
+ add_timer(&ip->cm3602_timer);
if(time_enable)
{
- ip->cm3602_timer.expires = jiffies + HZ;
- add_timer(&ip->cm3602_timer);
+ printk("------------------cm3602_timer,%d------------\n",time_enable);
queue_work(ip->cm3602_workqueue, &ip->cm3602_work);
}
struct capella_cm3602_platform_data *pdata = ip->pdata;
//int irq = gpio_to_irq(pdata->p_out);
char b[20];
-
- D("%s\n", __func__);
-/*
- rc = gpio_request(pdata->p_out, "gpio_proximity_out");
- if (rc < 0) {
- pr_err("%s: gpio %d request failed (%d)\n",
- __func__, pdata->p_out, rc);
- goto done;
- }
- rc = gpio_direction_input(pdata->p_out);
- if (rc < 0) {
- pr_err("%s: failed to set gpio %d as input (%d)\n",
- __func__, pdata->p_out, rc);
- goto fail_free_p_out;
- }
-*/
+ D("%s\n", __func__);
rc = gpio_request(pdata->pwd_out_pin, "cm3602 out");
if (rc) {
pr_err("%s: request gpio %d failed \n", __func__, pdata->irq_pin);
return rc;
}
- rc = gpio_direction_input(pdata->irq_pin);
- rc = request_irq(gpio_to_irq(pdata->irq_pin),capella_cm3602_irq_handler,SPI_GPIO_EDGE_FALLING,NULL, NULL);
+ //rc = gpio_direction_input(pdata->irq_pin);
+ rc = request_irq(gpio_to_irq(pdata->irq_pin),capella_cm3602_irq_handler,SPI_GPIO_EDGE_FALLING,NULL, ip);
if (rc < 0) {
pr_err("%s: request_irq failed for gpio %d (%d)\n",
__func__,
goto fail_free_p_out;
}
- //spi_gpio_set_pindirection(SPI_GPIO_P6_04, SPI_GPIO_IN);
- //spi_gpio_get_pinlevel(SPI_GPIO_P6_04);
-
sprintf(b,"cm3602_workqueue");
ip->cm3602_workqueue = create_freezeable_workqueue(b);
if(!ip->cm3602_workqueue)
INIT_WORK(&ip->cm3602_work, cm3602_work_handler);
setup_timer(&ip->cm3602_timer,cm3602_timer,(unsigned long)ip);
ip->cm3602_timer.expires = jiffies + HZ;
- //add_timer(&ip->cm3602_timer);
+ add_timer(&ip->cm3602_timer);
/*
rc = set_irq_wake(irq, 1);
if (rc < 0) {
struct capella_cm3602_platform_data *pdata;
D("%s: probe\n", __func__);
- printk("%s: probe]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\n", __func__);
+ //printk("%s: probe]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]\n", __func__);
pdata = pdev->dev.platform_data;
if (!pdata) {
pr_err("%s: missing pdata!\n", __func__);
};\r
static struct i2c_client *Ctp_it7250_client;\r
\r
+#define Ctp_it7250_GPIO_INT RK2818_PIN_PE1\r
+\r
#if 0\r
#define rk28printk(x...) printk(x)\r
#else\r
static u8 gpucPointBuffer[14];\r
static u32 gpdwSampleX[3],gpdwSampleY[3],gpdwPressure[1];\r
\r
-static int Ctp_it7250_rx_data( u8 reg,u8* rxData, int length)\r
+static int Ctp_it7250_rx_data(struct i2c_client *client, u8 reg,u8* rxData, int length)\r
{\r
#if 0\r
\r
int ret;\r
struct i2c_adapter *adap;int i;\r
struct i2c_msg msgs[2];
- if(!Ctp_it7250_client)\r
+ if(!client)\r
return ret;
- adap = Ctp_it7250_client->adapter;\r
+ adap = client->adapter;\r
\r
//·¢ËͼĴæÆ÷µØÖ·
- msgs[0].addr = Ctp_it7250_client->addr;\r
+ msgs[0].addr = client->addr;\r
msgs[0].buf = ®\r
- msgs[0].flags = Ctp_it7250_client->flags;\r
+ msgs[0].flags = client->flags;\r
msgs[0].len =1;\r
msgs[0].scl_rate = 400*1000;\r
//½ÓÊÕÊý¾Ý
// rk28printk("msgs[0].buf = 0x%x rxData=0x%x\n",*(msgs[0].buf),*rxData);\r
\r
msgs[1].buf = rxData;\r
- msgs[1].addr = Ctp_it7250_client->addr;\r
- msgs[1].flags = Ctp_it7250_client->flags | I2C_M_RD;\r
+ msgs[1].addr = client->addr;\r
+ msgs[1].flags = client->flags | I2C_M_RD;\r
msgs[1].len = length;\r
msgs[1].scl_rate = 400*1000;\r
\r
#else\r
//int i;\r
-return i2c_master_reg8_recv(Ctp_it7250_client, reg, rxData, length, 400 * 1000);\r
+return i2c_master_reg8_recv(client, reg, rxData, length, 400 * 1000);\r
//for (i=0;i<length;i++)\r
// rk28printk("rxData[%d]=%d \r\n",i,rxData[i]);\r
#endif\r
\r
}
\r
-static int Ctp_it7250_tx_data(u8 reg,char *txData, int length)\r
+static int Ctp_it7250_tx_data(struct i2c_client *client, u8 reg,char *txData, int length)\r
{
#if 0\r
int ret,i;\r
- struct i2c_adapter *adap = Ctp_it7250_client->adapter;\r
+ struct i2c_adapter *adap = client->adapter;\r
struct i2c_msg msg;\r
\r
u8 buf[128];//128\r
}\r
rk28printk("\r\n");\r
// rk28printk("buf[0]=0x%x buf[1]=0x%x",buf[0],buf[1]);\r
- msg.addr = Ctp_it7250_client->addr;\r
+ msg.addr = client->addr;\r
//rk28printk("i2c addr=0x%x",msg.addr);\r
msg.buf =&buf[0];\r
msg.len = length+1;//+1 means add the reg length;by roberts\r
- msg.flags = Ctp_it7250_client->flags;\r
+ msg.flags = client->flags;\r
msg.scl_rate = 400*1000;\r
ret = i2c_transfer(adap, &msg, 1);
return ret;\r
#else\r
- return i2c_master_reg8_send(Ctp_it7250_client, reg, txData, length, 400 * 1000);\r
+ return i2c_master_reg8_send(client, reg, txData, length, 400 * 1000);\r
#endif\r
\r
\r
\r
\r
\r
-bool ReadQueryBuffer(u8* pucData)\r
+bool ReadQueryBuffer(struct i2c_client *client, u8* pucData)\r
{\r
- return Ctp_it7250_rx_data( QUERY_BUFFER_INDEX, pucData, 1);\r
+ return Ctp_it7250_rx_data(client, QUERY_BUFFER_INDEX, pucData, 1);\r
}\r
\r
-bool ReadCommandResponseBuffer(u8* pucData, unsigned int unDataLength)\r
+bool ReadCommandResponseBuffer(struct i2c_client *client, u8* pucData, unsigned int unDataLength)\r
{\r
- return Ctp_it7250_rx_data( COMMAND_RESPONSE_BUFFER_INDEX, pucData, unDataLength);\r
+ return Ctp_it7250_rx_data(client, COMMAND_RESPONSE_BUFFER_INDEX, pucData, unDataLength);\r
}\r
\r
-bool ReadPointBuffer(u8* pucData)\r
+bool ReadPointBuffer(struct i2c_client *client, u8* pucData)\r
{\r
- return Ctp_it7250_rx_data( POINT_BUFFER_INDEX, pucData, 14);\r
+ return Ctp_it7250_rx_data(client, POINT_BUFFER_INDEX, pucData, 14);\r
}\r
\r
-bool WriteCommandBuffer(u8* pucData, unsigned int unDataLength)\r
+bool WriteCommandBuffer(struct i2c_client *client, u8* pucData, unsigned int unDataLength)\r
{\r
- return Ctp_it7250_tx_data(COMMAND_BUFFER_INDEX, pucData, unDataLength);\r
+ return Ctp_it7250_tx_data(client, COMMAND_BUFFER_INDEX, pucData, unDataLength);\r
}\r
\r
static int Ctp_it7250_touch_open(struct input_dev *idev)\r
{\r
\r
-struct Ctp_it7250_data *Ctp_it7250 = (struct Ctp_it7250_data *)i2c_get_clientdata(Ctp_it7250_client);\r
+//struct Ctp_it7250_data *Ctp_it7250 = (struct Ctp_it7250_data *)i2c_get_clientdata(client);\r
\r
\r
//BTN_TOUCH =0 means no touch ;by robert\r
- input_report_key(Ctp_it7250->input_dev,BTN_TOUCH, 0);\r
- input_sync(Ctp_it7250->input_dev);\r
+ input_report_key(idev,BTN_TOUCH, 0);\r
+ input_sync(idev);\r
\r
return 0;\r
}\r
}
ret = gpio_request(client->irq, "Ctp_it7250_int");\r
if (ret) {
- rk28printk( "failed to request Ctp_it7250_init_irq GPIO%d\n",gpio_to_irq(client->irq));\r
+ rk28printk( "failed to request Ctp_it7250_init_irq GPIO%d\n",client->irq);\r
return ret;
}\r
#if 1\r
}\r
gpio_pull_updown(client->irq,GPIOPullUp);\r
#endif\r
-\r
- rk28printk("%s gpio_to_irq(%d) is %d\n",__FUNCTION__,client->irq,gpio_to_irq(client->irq));\r
\r
- client->irq = gpio_to_irq(client->irq);\r
+ Ctp_it7250->irq = gpio_to_irq(client->irq);\r
#endif\r
- ret = request_irq(client->irq, Ctp_it7250_touch_irq, IRQF_TRIGGER_LOW, client->dev.driver->name, Ctp_it7250);\r
- Ctp_it7250->irq=client->irq;\r
+ ret = request_irq(Ctp_it7250->irq, Ctp_it7250_touch_irq, IRQF_TRIGGER_LOW, client->dev.driver->name, Ctp_it7250);\r
rk28printk("%s request irq is %d,irq1 is %d,ret is 0x%x\n",__FUNCTION__,client->irq,Ctp_it7250->irq,ret);\r
if (ret ) {
rk28printk(KERN_ERR "Ctp_it7250_init_irq: request irq failed,ret is %d\n",ret);\r
// Input --- NULL\r
//Output --- return true if the command execute successfully, otherwuse return false.\r
// ================================================================================\r
-bool GetFirmwareInformation()\r
+bool GetFirmwareInformation(struct i2c_client *client)\r
{\r
u8 ucWriteLength, ucReadLength;\r
u8 pucData[128];\r
// Query\r
do\r
{\r
- if(!ReadQueryBuffer(&ucQuery))\r
+ if(!ReadQueryBuffer(client, &ucQuery))\r
{\r
ucQuery = QUERY_BUSY;\r
}\r
}while(ucQuery & QUERY_BUSY);\r
\r
// Write Command\r
- if(!WriteCommandBuffer(pucData, ucWriteLength))\r
+ if(!WriteCommandBuffer(client, pucData, ucWriteLength))\r
{\r
return false;\r
}\r
// Query\r
do\r
{\r
- if(!ReadQueryBuffer(&ucQuery))\r
+ if(!ReadQueryBuffer(client, &ucQuery))\r
{\r
ucQuery = QUERY_BUSY;\r
}\r
pucData[7] == 0 ;\r
pucData[8] == 0;\r
// Read Command Response\r
- if(!ReadCommandResponseBuffer(pucData, ucReadLength))\r
+ if(!ReadCommandResponseBuffer(client, pucData, ucReadLength))\r
{\r
return false;\r
}\r
// ucType- the interrupt type\r
//Output --- return true if the command execute successfully, otherwuse return false.\r
// ================================================================================\r
-bool SetInterruptNotification(u8 ucStatus, u8 ucType)\r
+bool SetInterruptNotification(struct i2c_client *client, u8 ucStatus, u8 ucType)\r
{\r
u8 ucWriteLength, ucReadLength;\r
u8 pucData[128];\r
// Query\r
do\r
{\r
- if(!ReadQueryBuffer(&ucQuery))\r
+ if(!ReadQueryBuffer(client, &ucQuery))\r
{\r
ucQuery = QUERY_BUSY;\r
}\r
}while(ucQuery & QUERY_BUSY);\r
\r
// Write Command\r
- if(!WriteCommandBuffer(pucData, ucWriteLength))\r
+ if(!WriteCommandBuffer(client, pucData, ucWriteLength))\r
{\r
return false;\r
}\r
// Query\r
do\r
{\r
- if(!ReadQueryBuffer(&ucQuery))\r
+ if(!ReadQueryBuffer(client, &ucQuery))\r
{\r
ucQuery = QUERY_BUSY;\r
}\r
}while(ucQuery & QUERY_BUSY);\r
\r
// Read Command Response\r
- if(!ReadCommandResponseBuffer(pucData, ucReadLength))\r
+ if(!ReadCommandResponseBuffer(client, pucData, ucReadLength))\r
{\r
return false;\r
}\r
// Input --- NULL\r
//Output --- return true if the command execute successfully, otherwuse return false.\r
// ================================================================================\r
-bool IdentifyCapSensor()\r
+bool IdentifyCapSensor(struct i2c_client *client)\r
{\r
u8 ucWriteLength, ucReadLength;\r
u8 pucData[128];\r
// Query\r
do\r
{//printk("first wait 111\r\n");\r
- if(!ReadQueryBuffer(&ucQuery))\r
+ if(!ReadQueryBuffer(client, &ucQuery))\r
{\r
+ \r
rk28printk("first wait \r\n");\r
+ //means we use resister touchscreen\r
+ goto error_out;\r
ucQuery = QUERY_BUSY;\r
}\r
- rk28printk("%s ucQuery=0x%x \r\n",__FUNCTION__,ucQuery);\r
+ rk28printk("%s ucQuery!!!!=0x%x \r\n",__FUNCTION__,ucQuery);\r
+ if (0xff == ucQuery)\r
+ goto error_out;\r
mdelay(500);\r
}while(ucQuery & QUERY_BUSY);\r
\r
+\r
// Write Command\r
//rk28printk("%s11\r\n",__FUNCTION__);\r
pucData[0] = 0x00;ucWriteLength = 1;\r
- if(!WriteCommandBuffer(pucData, ucWriteLength))\r
+ if(!WriteCommandBuffer(client, pucData, ucWriteLength))\r
{\r
rk28printk("WriteCommandBuffer false \r\n");\r
// return false;\r
// Query\r
do\r
{\r
- if(!ReadQueryBuffer(&ucQuery))\r
+ if(!ReadQueryBuffer(client, &ucQuery))\r
{\r
rk28printk("second wait \r\n");\r
ucQuery = QUERY_BUSY;\r
{pucData[i]=0x0;\r
rk28printk("pucData[%d]=%d \r\n",i,pucData[i]);\r
}\r
- if(!ReadCommandResponseBuffer(pucData, ucReadLength))\r
+ if(!ReadCommandResponseBuffer(client, pucData, ucReadLength))\r
{\r
rk28printk("ReadCommandResponseBuffer false \r\n");\r
// return false;\r
rk28printk("pucData=%c %c %c %c %c %c %c \r\n",pucData[1],pucData[2],pucData[3],pucData[4],pucData[5],pucData[6],pucData[7]);\r
\r
return true;\r
+\r
+\r
+error_out:\r
+ return false;\r
}\r
\r
// ================================================================================\r
// pucStep - the step\r
//Output --- return true if the command execute successfully, otherwuse return false.\r
// ================================================================================\r
-bool Get2DResolutions(u32 *pwXResolution, u32*pwYResolution, u8 *pucStep)\r
+bool Get2DResolutions(struct i2c_client *client, u32 *pwXResolution, u32*pwYResolution, u8 *pucStep)\r
{\r
u8 ucWriteLength, ucReadLength;\r
u8 pucData[128];\r
// Query\r
do\r
{\r
- if(!ReadQueryBuffer(&ucQuery))\r
+ if(!ReadQueryBuffer(client, &ucQuery))\r
{\r
ucQuery = QUERY_BUSY;\r
}\r
\r
// Write Command\r
rk28printk("%s WriteCommandBuffer\r\n",__FUNCTION__);\r
- if(!WriteCommandBuffer(pucData, ucWriteLength))\r
+ if(!WriteCommandBuffer(client, pucData, ucWriteLength))\r
{\r
return false;\r
}\r
// Query\r
do\r
{\r
- if(!ReadQueryBuffer(&ucQuery))\r
+ if(!ReadQueryBuffer(client, &ucQuery))\r
{\r
ucQuery = QUERY_BUSY;\r
}\r
}while(ucQuery & QUERY_BUSY);\r
rk28printk("%s ReadCommandResponseBuffer\r\n",__FUNCTION__);\r
// Read Command Response\r
- if(!ReadCommandResponseBuffer(pucData, ucReadLength))\r
+ if(!ReadCommandResponseBuffer(client, pucData, ucReadLength))\r
{\r
return false;\r
}\r
// Return value: \r
// return zero if success, otherwise return non zero value\r
// *******************************************************************************************\r
-int CaptouchMode(u8 dwMode)\r
+int CaptouchMode(struct i2c_client *client, u8 dwMode)\r
{\r
u8 ucQueryResponse;\r
u8 pucCommandBuffer[128];\r
\r
do\r
{\r
- ReadQueryBuffer(&ucQueryResponse);\r
+ ReadQueryBuffer(client, &ucQueryResponse);\r
}\r
while(ucQueryResponse & QUERY_BUSY);\r
\r
return -1;\r
}\r
\r
- if(!WriteCommandBuffer( pucCommandBuffer,3))\r
+ if(!WriteCommandBuffer(client, pucCommandBuffer,3))\r
{\r
return -1;\r
}\r
// Return value: \r
// return TRUE if success, otherwise return FALSE\r
// *******************************************************************************************\r
-int CaptouchReset()\r
+int CaptouchReset(struct i2c_client *client)\r
{\r
u8 ucQueryResponse;\r
u8 pucCommandBuffer[128];\r
\r
do\r
{\r
- ReadQueryBuffer(&ucQueryResponse);\r
+ ReadQueryBuffer(client, &ucQueryResponse);\r
}\r
while(ucQueryResponse & QUERY_BUSY);\r
\r
pucCommandBuffer[0] = 0x6F;\r
- if(!WriteCommandBuffer(pucCommandBuffer,1))\r
+ if(!WriteCommandBuffer(client, pucCommandBuffer,1))\r
{\r
return -1;\r
}\r
\r
do\r
{\r
- ReadQueryBuffer(&ucQueryResponse);\r
+ ReadQueryBuffer(client, &ucQueryResponse);\r
}\r
while(ucQueryResponse & QUERY_BUSY);\r
\r
\r
- if(!ReadCommandResponseBuffer(pucCommandBuffer,2))\r
+ if(!ReadCommandResponseBuffer(client, pucCommandBuffer,2))\r
{\r
return -1;\r
}\r
// Return value: \r
// return zero if success, otherwise return non zero value\r
// *******************************************************************************************\r
-int CaptouchHWInitial()\r
+int CaptouchHWInitial(struct i2c_client *client)\r
{\r
u32 wXResolution=0,wYResolution=0;\r
u8 ucStep=0;\r
- if (!IdentifyCapSensor())\r
+ if (!IdentifyCapSensor(client))\r
{\r
rk28printk("%s IdentifyCapSensor error \r\n",__FUNCTION__);\r
- // goto resetagin;\r
+ return false;\r
+ //goto resetagin;\r
}\r
#if 1\r
-if (!GetFirmwareInformation ())\r
+if (!GetFirmwareInformation (client))\r
{\r
rk28printk("%s GetFirmwareInformation error \r\n",__FUNCTION__);\r
// goto resetagin;\r
}\r
\r
- if (!Get2DResolutions(&wXResolution, &wYResolution, &ucStep))\r
+ if (!Get2DResolutions(client, &wXResolution, &wYResolution, &ucStep))\r
{\r
rk28printk("%s Get2DResolutions error \r\n",__FUNCTION__);\r
// goto resetagin;\r
\r
//no need to set interrupt mode because firmware has done that;note by robert\r
#if 0\r
- if (!SetInterruptNotification(0x01, 0x00))\r
+ if (!SetInterruptNotification(client, 0x01, 0x00))\r
{\r
rk28printk("%s SetInterruptNotification error \r\n",__FUNCTION__);\r
goto resetagin;\r
#endif\r
//note end\r
#endif\r
- return 0;\r
+ return true;\r
\r
resetagin:\r
- if (!CaptouchReset())\r
+ if (!CaptouchReset(client))\r
rk28printk("CaptouchReset success \r\n");\r
mdelay(100);\r
-// if (!CaptouchMode(0x00))\r
+// if (!CaptouchMode(client, 0x00))\r
// rk28printk("CaptouchMode success \r\n");\r
}\r
\r
u8 ucQueryResponse;\r
u32 dwTouchEvent;\r
- struct Ctp_it7250_data *Ctp_it7250 = (struct Ctp_it7250_data *)i2c_get_clientdata(Ctp_it7250_client);\r
+ struct delayed_work *delaywork = container_of(work, struct delayed_work, work);\r
+ struct Ctp_it7250_data *Ctp_it7250 = container_of(delaywork, struct Ctp_it7250_data, delaywork); \r
+ struct i2c_client *client = Ctp_it7250->client;\r
+ \r
int PE1status = 0;\r
\r
// rk28printk("%s++++ %d \r\n",__FUNCTION__,__LINE__);\r
\r
\r
- PE1status = gpio_get_value(Ctp_it7250->client->irq);\r
+ //PE1status = gpio_get_value(Ctp_it7250_GPIO_INT);\r
+ PE1status = gpio_get_value(client->irq);\r
// PE1status ΪµÍ£¬±íʾµÍµçƽÖжÏÓÐЧ \r
if (!PE1status)\r
{\r
// rk28printk("%s PE1status low!! \r\n",__FUNCTION__);\r
- if(!ReadQueryBuffer(&ucQueryResponse))\r
+ if(!ReadQueryBuffer(client, &ucQueryResponse))\r
{rk28printk("%s++++ %d ucQueryResponse=0x%x \r\n",__FUNCTION__,__LINE__,ucQueryResponse);\r
return false;\r
}\r
// Touch Event\r
if(ucQueryResponse & QUERY_POINT)\r
{//rk28printk("%s++++ %d \r\n",__FUNCTION__,__LINE__);\r
- if(!ReadPointBuffer(gpucPointBuffer))\r
+ if(!ReadPointBuffer(client, gpucPointBuffer))\r
{rk28printk("%s++++ %d \r\n",__FUNCTION__,__LINE__);\r
return false;\r
}\r
switch(gpucPointBuffer[0] & 0xF0)\r
{\r
case 0x00:\r
- dwTouchEvent = CaptouchGetSampleValue(gpdwSampleX, gpdwSampleY, \r
-gpdwPressure);\r
+ dwTouchEvent = CaptouchGetSampleValue(gpdwSampleX, gpdwSampleY, gpdwPressure);\r
if(dwTouchEvent == 0)\r
{\r
//SynchroSystemEvent(SYSTEM_TOUCH_EVENT_FINGER_RELEASE);\r
input_report_abs(Ctp_it7250->input_dev, ABS_X, gpdwSampleX[0]);// & 0xfff\r
input_report_abs(Ctp_it7250->input_dev, ABS_Y, gpdwSampleY[0]); //& 0xfff\r
input_report_key(Ctp_it7250->input_dev,BTN_TOUCH, 1);\r
- input_sync(Ctp_it7250->input_dev);rk28printk("x=%d y=%d \r\n",gpdwSampleX[0],gpdwSampleY[0]);\r
+ input_sync(Ctp_it7250->input_dev);\r
+ rk28printk("x=%d y=%d \r\n",gpdwSampleX[0],gpdwSampleY[0]);\r
}\r
else\r
{\r
}\r
else if (ucQueryResponse & QUERY_ERROR)\r
{\r
- if (!CaptouchReset())\r
+ if (!CaptouchReset(client))\r
rk28printk("!! CaptouchReset success \r\n");\r
mdelay(100);\r
- //if (!CaptouchMode(0x00))\r
+ //if (!CaptouchMode(client, 0x00))\r
//rk28printk("!! CaptouchMode success \r\n");\r
}\r
}\r
i2c_set_clientdata(client, Ctp_it7250);\r
\r
\r
- \r
+if (!CaptouchHWInitial(client))\r
+ goto err_free_mem;\r
+Ctp_it7250_init_irq(client); \r
ts_input_init(client);\r
// CTS_configure_pin(client);\r
\r
#endif\r
\r
}\r
-CaptouchHWInitial();\r
-Ctp_it7250_init_irq(client);\r
+\r
\r
\r
//²»ÊDzéѯģʽ£¬²»ÐèÒªÂÖѯ\r
\r
rk28printk("+++++++ %s+++++++\n", __FUNCTION__);\r
return 0;\r
+err_free_mem:\r
+ kfree(Ctp_it7250);\r
+ return false;\r
\r
}\r
\r
// Query\r
do\r
{\r
- if(!ReadQueryBuffer(&ucQuery))\r
+ if(!ReadQueryBuffer(client, &ucQuery))\r
{\r
ucQuery = QUERY_BUSY;\r
}\r
\r
// Write Command\r
rk28printk("%s WriteCommandBuffer\r\n",__FUNCTION__);\r
- if(!WriteCommandBuffer(pucData, ucWriteLength))\r
+ if(!WriteCommandBuffer(client, pucData, ucWriteLength))\r
{\r
return false;\r
}\r
//read command to wakeup ctp\r
#if 1\r
u8 ucQuery;\r
-ReadQueryBuffer(&ucQuery);\r
+ReadQueryBuffer(client, &ucQuery);\r
#endif\r
//wakeup end\r
enable_irq(Ctp_it7250->irq);\r
{
return spi_register_driver(&xpt2046_driver);
}
-module_init(xpt2046_init);
+late_initcall_sync(xpt2046_init);
static void __exit xpt2046_exit(void)
{
#include <linux/kernel.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/rk2818_lp8725.h>
+#include <mach/gpio.h>
+#include <linux/delay.h>
+
+//add by robert for reboot notifier
+#include <linux/notifier.h>
+#include <linux/reboot.h>
+
+//end add
+
#if 0
}
+//add by robert for power on bp
+#define AP_TD_UNDEFINED_GBIN5 FPGA_PIO2_02
+#define AP_RESET_TD FPGA_PIO2_04
+#define AP_SHUTDOWN_TD_PMU FPGA_PIO2_05
+#define AP_PW_EN_TD FPGA_PIO2_03
+
+static int bp_power_on(void)
+{
+ int ret=0;
+
+ ret = gpio_request(AP_TD_UNDEFINED_GBIN5, NULL);
+ if (ret) {
+ printk("%s:failed to request fpga s %d\n",__FUNCTION__,__LINE__);
+ goto err;
+ }
+ ret = gpio_request(AP_RESET_TD, NULL);
+ if (ret) {
+ printk("%s:failed to request fpga s %d\n",__FUNCTION__,__LINE__);
+ goto err0;
+ }
+
+
+ ret = gpio_request(AP_SHUTDOWN_TD_PMU, NULL);
+ if (ret) {
+ printk("%s:failed to request fpga %d\n",__FUNCTION__,__LINE__);
+ goto err1;
+ }
+
+ ret = gpio_request(AP_PW_EN_TD, NULL);
+ if (ret) {
+ printk("%s:failed to request fpga %d\n",__FUNCTION__,__LINE__);
+ goto err2;
+ }
+
+ gpio_set_value(AP_TD_UNDEFINED_GBIN5, 1);
+ gpio_direction_output(AP_TD_UNDEFINED_GBIN5, 1);
+ gpio_direction_input(AP_RESET_TD);
+
+ gpio_set_value(AP_SHUTDOWN_TD_PMU, 0);
+ gpio_direction_output(AP_SHUTDOWN_TD_PMU, 0);
+
+ gpio_set_value(AP_PW_EN_TD, 0);
+ gpio_direction_output(AP_PW_EN_TD, 0);
+ mdelay(1);
+ gpio_set_value(AP_PW_EN_TD, 1);
+ mdelay(1200);
+ gpio_set_value(AP_PW_EN_TD, 0);
+
+ return true;
+err2:
+ gpio_free(AP_SHUTDOWN_TD_PMU);
+err1:
+ gpio_free(AP_RESET_TD);
+err0:
+ gpio_free(AP_TD_UNDEFINED_GBIN5);
+err:
+ return false;
+}
+
+
+
+static int bp_power_off(struct notifier_block *this,
+ unsigned long code, void *unused)
+{
+ printk("+++--++++++%s_________%d \r\n",__FUNCTION__,code);
+
+ gpio_set_value(AP_TD_UNDEFINED_GBIN5, 0);
+
+ gpio_set_value(AP_PW_EN_TD, 0);
+ //gpio_direction_output(AP_PW_EN_TD, 0);
+ mdelay(1);
+ gpio_set_value(AP_PW_EN_TD, 1);
+ mdelay(1200);
+ gpio_set_value(AP_PW_EN_TD, 0);
+
+ mdelay(5000);
+ gpio_set_value(AP_SHUTDOWN_TD_PMU, 1);
+ mdelay(1200);
+ // gpio_free(AP_PW_EN_TD);
+printk("++++--+++++%s ok_________\r\n",__FUNCTION__);
+ return NOTIFY_DONE;
+}
+//add end
+
static int lp8725_set_init(void)
{
int tmp = 0;
tmp = regulator_get_voltage(buck2);
DBG_INFO("***regulator_set_init: buck2 vcc =%d\n",tmp);
+
+//add by robert for power on bp
+ bp_power_on();
+//end add
+
return(0);
}
{
struct lp8725 *lp8725 = i2c_get_clientdata(i2c);
int i;
+
for (i = 0; i < lp8725->num_regulators; i++)
if (lp8725->rdev[i])
regulator_unregister(lp8725->rdev[i]);
.id_table = lp8725_i2c_id,
};
+
+//add by robert for bp powerdown register
+static struct notifier_block BP_powerdown_notifier = {
+ .notifier_call = bp_power_off,
+};
+//end add
+
+
+
static int __init lp8725_module_init(void)
{
int ret;
if (ret != 0)
pr_err("Failed to register I2C driver: %d\n", ret);
+ //add by robert for bp powerdown register
+ ret = register_reboot_notifier(&BP_powerdown_notifier);
+ if (ret != 0)
+ {
+ printk("cannot register reboot notifier (err=%d), %s\n", ret,__FUNCTION__);
+ }
+ //end add
+
+
return ret;
}
module_init(lp8725_module_init);
static void __exit lp8725_module_exit(void)
{
+//add by robert for bp power down
+ unregister_reboot_notifier(&BP_powerdown_notifier);
+//end add
+
i2c_del_driver(&lp8725_i2c_driver);
}
module_exit(lp8725_module_exit);
cpu_relax();
}
}
+int rtc_change_time(struct timespec new_time)
+{
+ int i;
+ int ret;
+ unsigned long flags;
+ struct rtc_time rtc_new_rtc_time;
+ struct timespec tmp_time;
+
+ rtc_time_to_tm(new_time.tv_sec, &rtc_new_rtc_time);
+
+ printk("set rtc %ld %ld - rtc %02d:%02d:%02d %02d/%02d/%04d\n",
+ new_time.tv_sec, new_time.tv_nsec,
+ rtc_new_rtc_time.tm_hour, rtc_new_rtc_time.tm_min,
+ rtc_new_rtc_time.tm_sec, rtc_new_rtc_time.tm_mon + 1,
+ rtc_new_rtc_time.tm_mday,
+ rtc_new_rtc_time.tm_year + 1900);
+}
/**
* alarm_set_rtc - set the kernel and rtc walltime
rtc_time_to_tm(new_time.tv_sec, &rtc_new_rtc_time);
- pr_alarm(TSET, "set rtc %ld %ld - rtc %02d:%02d:%02d %02d/%02d/%04d\n",
+ printk("set rtc %ld %ld - rtc %02d:%02d:%02d %02d/%02d/%04d\n",
new_time.tv_sec, new_time.tv_nsec,
rtc_new_rtc_time.tm_hour, rtc_new_rtc_time.tm_min,
rtc_new_rtc_time.tm_sec, rtc_new_rtc_time.tm_mon + 1,
struct alarm *alarm;
unsigned long flags;
ktime_t now;
-
+ printk("alarm_timer_triggered\n");
spin_lock_irqsave(&alarm_slock, flags);
base = container_of(timer, struct alarm_queue, timer);
now = base->stopped ? base->stopped_time : hrtimer_cb_get_time(timer);
now = ktime_sub(now, base->delta);
- pr_alarm(INT, "alarm_timer_triggered type %d at %lld\n",
+ printk( "alarm_timer_triggered type %d at %lld\n",
base - alarms, ktime_to_ns(now));
while (base->first) {
alarm = container_of(base->first, struct alarm, node);
if (alarm->softexpires.tv64 > now.tv64) {
- pr_alarm(FLOW, "don't call alarm, %pF, %lld (s %lld)\n",
+ printk( "don't call alarm, %pF, %lld (s %lld)\n",
alarm->function, ktime_to_ns(alarm->expires),
ktime_to_ns(alarm->softexpires));
break;
base->first = rb_next(&alarm->node);
rb_erase(&alarm->node, &base->alarms);
RB_CLEAR_NODE(&alarm->node);
- pr_alarm(CALL, "call alarm, type %d, func %pF, %lld (s %lld)\n",
+ printk("call alarm, type %d, func %pF, %lld (s %lld)\n",
alarm->type, alarm->function,
ktime_to_ns(alarm->expires),
ktime_to_ns(alarm->softexpires));
spin_lock_irqsave(&alarm_slock, flags);
}
if (!base->first)
- pr_alarm(FLOW, "no more alarms of type %d\n", base - alarms);
+ printk( "no more alarms of type %d\n", base - alarms);
update_timer_locked(base, true);
spin_unlock_irqrestore(&alarm_slock, flags);
+ printk("---alarm_timer_triggered---\n");
return HRTIMER_NORESTART;
}
struct alarm_queue *wakeup_queue = NULL;
struct alarm_queue *tmp_queue = NULL;
- pr_alarm(SUSPEND, "alarm_suspend(%p, %d)\n", pdev, state.event);
+ printk( "alarm_suspend(%p, %d)\n", pdev, state.event);
spin_lock_irqsave(&alarm_slock, flags);
suspended = true;
rtc_time_to_tm(rtc_alarm_time, &rtc_alarm.time);
rtc_alarm.enabled = 1;
+ //rtc_alarm.time.tm_min +=4;
rtc_set_alarm(alarm_rtc_dev, &rtc_alarm);
rtc_read_time(alarm_rtc_dev, &rtc_current_rtc_time);
rtc_tm_to_time(&rtc_current_rtc_time, &rtc_current_time);
- pr_alarm(SUSPEND,
+ printk(
"rtc alarm set at %ld, now %ld, rtc delta %ld.%09ld\n",
rtc_alarm_time, rtc_current_time,
rtc_delta.tv_sec, rtc_delta.tv_nsec);
spin_unlock_irqrestore(&alarm_slock, flags);
}
}
+ printk( "alarm_suspend over\n");
return err;
}
+static int alarm_shutdown(struct platform_device *pdev, pm_message_t state)
+{
+ int err = 0;
+ unsigned long flags;
+ struct rtc_wkalrm rtc_alarm;
+ struct rtc_time rtc_current_rtc_time;
+ unsigned long rtc_current_time;
+ unsigned long rtc_alarm_time;
+ struct timespec rtc_current_timespec;
+ struct timespec rtc_delta;
+ struct alarm_queue *wakeup_queue = NULL;
+ struct alarm_queue *tmp_queue = NULL;
+
+ printk( "alarm_suspend(%p, %d)\n", pdev, state.event);
+
+ spin_lock_irqsave(&alarm_slock, flags);
+ suspended = true;
+ spin_unlock_irqrestore(&alarm_slock, flags);
+
+ hrtimer_cancel(&alarms[ANDROID_ALARM_RTC_WAKEUP].timer);
+ hrtimer_cancel(&alarms[
+ ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP_MASK].timer);
+
+ tmp_queue = &alarms[ANDROID_ALARM_RTC_WAKEUP];
+ if (tmp_queue->first)
+ wakeup_queue = tmp_queue;
+ tmp_queue = &alarms[ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP];
+ if (tmp_queue->first && (!wakeup_queue ||
+ hrtimer_get_expires(&tmp_queue->timer).tv64 <
+ hrtimer_get_expires(&wakeup_queue->timer).tv64))
+ wakeup_queue = tmp_queue;
+ if (wakeup_queue) {
+ rtc_read_time(alarm_rtc_dev, &rtc_current_rtc_time);
+ rtc_current_timespec.tv_nsec = 0;
+ rtc_tm_to_time(&rtc_current_rtc_time,
+ &rtc_current_timespec.tv_sec);
+ save_time_delta(&rtc_delta, &rtc_current_timespec);
+
+ rtc_alarm_time = timespec_sub(ktime_to_timespec(
+ hrtimer_get_expires(&wakeup_queue->timer)),
+ rtc_delta).tv_sec;
+
+ rtc_time_to_tm(rtc_alarm_time, &rtc_alarm.time);
+ rtc_alarm.enabled = 1;
+ rtc_set_alarm(alarm_rtc_dev, &rtc_alarm);
+ rtc_read_time(alarm_rtc_dev, &rtc_current_rtc_time);
+ rtc_tm_to_time(&rtc_current_rtc_time, &rtc_current_time);
+ printk(
+ "rtc alarm set at %ld, now %ld, rtc delta %ld.%09ld\n",
+ rtc_alarm_time, rtc_current_time,
+ rtc_delta.tv_sec, rtc_delta.tv_nsec);
+ if (rtc_current_time + 1 >= rtc_alarm_time) {
+ pr_alarm(SUSPEND, "alarm about to go off\n");
+ memset(&rtc_alarm, 0, sizeof(rtc_alarm));
+ rtc_alarm.enabled = 0;
+ rtc_set_alarm(alarm_rtc_dev, &rtc_alarm);
+
+ spin_lock_irqsave(&alarm_slock, flags);
+ suspended = false;
+ wake_lock_timeout(&alarm_rtc_wake_lock, 2 * HZ);
+ update_timer_locked(&alarms[ANDROID_ALARM_RTC_WAKEUP],
+ false);
+ update_timer_locked(&alarms[
+ ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP], false);
+ err = -EBUSY;
+ spin_unlock_irqrestore(&alarm_slock, flags);
+ }
+ }
+ printk( "alarm_suspend over\n");
+ return err;
+}
static int alarm_resume(struct platform_device *pdev)
{
struct rtc_wkalrm alarm;
unsigned long flags;
- pr_alarm(SUSPEND, "alarm_resume(%p)\n", pdev);
+ printk( "alarm_resume(%p)\n", pdev);
memset(&alarm, 0, sizeof(alarm));
alarm.enabled = 0;
static struct platform_driver alarm_driver = {
.suspend = alarm_suspend,
.resume = alarm_resume,
+ .shutdown = alarm_shutdown,
.driver = {
.name = "alarm"
}
{
unsigned long flags;
struct timespec tmp_time, system_time;
-
+ printk("alarm_late_init\n");
/* this needs to run after the rtc is read at boot */
spin_lock_irqsave(&alarm_slock, flags);
/* We read the current rtc and system time so we can later calulate
timespec_to_ktime(timespec_sub(tmp_time, system_time));
spin_unlock_irqrestore(&alarm_slock, flags);
+ printk("---alarm_late_init----\n");
return 0;
}
{
int err;
int i;
-
+ printk("alarm_driver_init\n");
for (i = 0; i < ANDROID_ALARM_SYSTEMTIME; i++) {
hrtimer_init(&alarms[i].timer,
CLOCK_REALTIME, HRTIMER_MODE_ABS);
err = class_interface_register(&rtc_alarm_interface);
if (err < 0)
goto err2;
-
+ printk("---alarm_driver_init---\n");
return 0;
err2:
#include <linux/bcd.h>\r
#include <linux/slab.h>\r
#include <linux/delay.h>\r
+#include <mach/gpio.h>\r
#include "rtc-s35392a.h"\r
\r
-\r
+#define RTC_S35392A_INT RK2818_PIN_PE2 //\r
#define RTC_RATE 100 * 1000\r
-#define S35392_TEST 1\r
+#define S35392_TEST 0\r
+\r
+#if 1\r
+#define DBG(x...) printk(x)\r
+#else\r
+#define DBG(x...)\r
+#endif\r
\r
struct s35392a {\r
struct i2c_client *client;\r
struct rtc_device *rtc;\r
int twentyfourhour;\r
+ struct work_struct work;\r
};\r
\r
+\r
+\r
static int s35392a_set_reg(struct s35392a *s35392a, const char reg, char *buf, int len)\r
{\r
struct i2c_client *client = s35392a->client;\r
struct i2c_msg msg;\r
int ret;\r
- \r
+ int i;\r
char *buff = buf;\r
msg.addr = client->addr | reg;\r
msg.flags = client->flags;\r
msg.scl_rate = RTC_RATE;\r
\r
ret = i2c_transfer(client->adapter,&msg,1);\r
+ for(i=0;i<len;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
return ret; \r
\r
}\r
\r
s35392a_get_reg(s35392a, S35392A_CMD_STATUS1, buf, sizeof(buf)); \r
s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, buf, sizeof(buf)); \r
- s35392a_get_reg(s35392a, 4, buf, sizeof(buf));\r
- s35392a_get_reg(s35392a, 5, buf, sizeof(buf));\r
- s35392a_get_reg(s35392a, 6, buf, sizeof(buf));\r
- s35392a_get_reg(s35392a, 7, buf, sizeof(buf));\r
+ s35392a_get_reg(s35392a, S35392A_CMD_INT1, buf, sizeof(buf));\r
+ s35392a_get_reg(s35392a, S35392A_CMD_INT2, buf, sizeof(buf));\r
+ s35392a_get_reg(s35392a, S35392A_CMD_CHECK, buf, sizeof(buf));\r
+ s35392a_get_reg(s35392a, S35392A_CMD_FREE, buf, sizeof(buf));\r
\r
buf[0] |= (S35392A_FLAG_RESET | S35392A_FLAG_24H);\r
buf[0] &= 0xf0;\r
\r
}\r
\r
-static int s35392a_reset(struct s35392a *s35392a)\r
-{\r
- char buf[1];\r
-\r
- if (s35392a_get_reg(s35392a, S35392A_CMD_STATUS1, buf, sizeof(buf)) < 0)\r
- return -EIO; \r
- if (!(buf[0] & (S35392A_FLAG_POC | S35392A_FLAG_BLD)))\r
- return 0;\r
-\r
- buf[0] |= (S35392A_FLAG_RESET | S35392A_FLAG_24H);\r
- buf[0] &= 0xf0;\r
- return s35392a_set_reg(s35392a, S35392A_CMD_STATUS1, buf, sizeof(buf));\r
-}\r
-\r
-\r
-static int s35392a_disable_test_mode(struct s35392a *s35392a)\r
-{\r
- char buf[1];\r
-\r
- if (s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, buf, sizeof(buf)) < 0)\r
- return -EIO;\r
-\r
- if (!(buf[0] & S35392A_FLAG_TEST))\r
- return 0;\r
-\r
- buf[0] &= ~S35392A_FLAG_TEST;\r
- return s35392a_set_reg(s35392a, S35392A_CMD_STATUS2, buf, sizeof(buf));\r
-}\r
\r
static char s35392a_hr2reg(struct s35392a *s35392a, int hour)\r
{\r
return hour;\r
}\r
\r
+static char s35392a_hour2reg(struct s35392a *s35392a, int hour)\r
+{\r
+ if (s35392a->twentyfourhour)\r
+ {\r
+ if(hour<12)\r
+ return 0x80 | bin2bcd(hour) ;\r
+ else\r
+ return 0xc0| bin2bcd(hour) ;\r
+ } \r
+ else\r
+ {\r
+ if(hour<12)\r
+ return 0x80 | bin2bcd(hour) ;\r
+ else\r
+ return 0xc0 | bin2bcd(hour - 12);\r
+ }\r
+ \r
+}\r
+\r
static int s35392a_set_datetime(struct i2c_client *client, struct rtc_time *tm)\r
{\r
struct s35392a *s35392a = i2c_get_clientdata(client);\r
int i, err;\r
char buf[7];\r
\r
- printk("%s: tm is secs=%d, mins=%d, hours=%d mday=%d, "\r
+ DBG("%s: tm is secs=%d, mins=%d, hours=%d mday=%d, "\r
"mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec,\r
tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year,\r
tm->tm_wday);\r
buf[S35392A_BYTE_SECS] = bin2bcd(tm->tm_sec);\r
\r
/* This chip expects the bits of each byte to be in reverse order */\r
+ for(i=0;i<7;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
for (i = 0; i < 7; ++i)\r
buf[i] = bitrev8(buf[i]);\r
-\r
+ for(i=0;i<7;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
err = s35392a_set_reg(s35392a, S35392A_CMD_TIME1, buf, sizeof(buf));\r
\r
return err;\r
err = s35392a_get_reg(s35392a, S35392A_CMD_TIME1, buf, sizeof(buf));\r
if (err < 0)\r
return err;\r
-\r
+ for(i=0;i<7;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
/* This chip returns the bits of each byte in reverse order */\r
for (i = 0; i < 7; ++i)\r
buf[i] = bitrev8(buf[i]);\r
-\r
+ for(i=0;i<7;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
tm->tm_sec = bcd2bin(buf[S35392A_BYTE_SECS]);\r
tm->tm_min = bcd2bin(buf[S35392A_BYTE_MINS]);\r
tm->tm_hour = s35392a_reg2hr(s35392a, buf[S35392A_BYTE_HOURS]);\r
tm->tm_year = bcd2bin(buf[S35392A_BYTE_YEAR]) + 100;\r
//tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, tm->tm_year); \r
\r
- printk( "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "\r
+ DBG( "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "\r
"mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec,\r
tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year,\r
tm->tm_wday);\r
\r
return rtc_valid_tm(tm);\r
}\r
-static int s35392a_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm const *tm)\r
+static int s35392a_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *tm)\r
{\r
- struct s35392a *s35392a = i2c_get_clientdata(client);\r
+ struct s35392a *s35392a = i2c_get_clientdata(client);\r
+ char buf[3];\r
+ int i,err;\r
+ char data;\r
+ DBG("%s:%d\n",__FUNCTION__,__LINE__); \r
+ err = s35392a_get_reg(s35392a, S35392A_CMD_INT2, buf, sizeof(buf));\r
+ if(err < 0)\r
+ return err;\r
+ for(i=0;i<3;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
+ for(i = 0;i < 3;++i)\r
+ buf[i] = bitrev8(buf[i]);\r
+ for(i=0;i<3;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
+ tm->time.tm_wday = -1; \r
+ tm->time.tm_hour = -1;\r
+ tm->time.tm_min = -1; \r
+\r
+ if(buf[S35392A_ALARM_WDAYS] & S35392A_ALARM_ENABLE )\r
+ tm->time.tm_wday = bcd2bin(buf[S35392A_ALARM_WDAYS] & S35392A_ALARM_DISABLE) ;\r
\r
+ if(buf[S35392A_ALARM_HOURS] & S35392A_ALARM_ENABLE)\r
+ tm->time.tm_hour = s35392a_reg2hr(s35392a, buf[S35392A_ALARM_HOURS]);\r
+ \r
+ if(buf[S35392A_ALARM_MINS] & S35392A_ALARM_ENABLE)\r
+ tm->time.tm_min = bcd2bin(buf[S35392A_ALARM_MINS] & S35392A_ALARM_DISABLE) ;\r
+ \r
+\r
+ tm->time.tm_year = -1;\r
+ tm->time.tm_mon = -1;\r
+ tm->time.tm_mday = -1;\r
+ tm->time.tm_yday = -1;\r
+ tm->time.tm_sec = -1;\r
+ \r
+ DBG( "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "\r
+ "mon=%d, year=%d, wday=%d\n", __func__, tm->time.tm_sec,\r
+ tm->time.tm_min, tm->time.tm_hour, tm->time.tm_mday, tm->time.tm_mon, tm->time.tm_year,\r
+ tm->time.tm_wday);\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ tm->enabled = ((data & S35392A_MASK_INT2) == S35392A_INT2_ENABLE);\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS1, &data, 1);\r
+ tm->pending = !!(data & S35392A_FLAG_INT2); \r
+ \r
+ DBG("%s:%d\n",__FUNCTION__,__LINE__);\r
+ return data;\r
}\r
-static int s35392a_i2c_set_alarm(struct i2c_client *client, struct rtc_wkalrm const *tm)\r
+\r
+static int s35392a_i2c_set_alarm(struct i2c_client *client, struct rtc_wkalrm *tm)\r
{\r
- struct s35392a *s35392a = i2c_get_clientdata(client);\r
+ struct s35392a *s35392a = i2c_get_clientdata(client);\r
+ char buf[3];\r
+ char data;\r
+ int i,err;\r
+ DBG("%s:%d\n",__FUNCTION__,__LINE__);\r
+ DBG( "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "\r
+ "mon=%d, year=%d, wday=%d\n", __func__, tm->time.tm_sec,\r
+ tm->time.tm_min, tm->time.tm_hour, tm->time.tm_mday, tm->time.tm_mon, tm->time.tm_year,\r
+ tm->time.tm_wday);\r
+ \r
+ buf[S35392A_ALARM_WDAYS] = tm->time.tm_wday>= 0 ? \r
+ (bin2bcd(tm->time.tm_wday) |S35392A_ALARM_ENABLE) : 0; \r
+ buf[S35392A_ALARM_WDAYS]=0;\r
+ buf[S35392A_ALARM_HOURS] = tm->time.tm_hour >=0 ?\r
+ s35392a_hour2reg(s35392a, tm->time.tm_hour) : 0;\r
+ buf[S35392A_ALARM_MINS] = tm->time.tm_min >= 0?\r
+ bin2bcd(tm->time.tm_min) | S35392A_ALARM_ENABLE:0; \r
+ for(i=0;i<3;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
+ for(i = 0;i < 3;++i)\r
+ buf[i] = bitrev8(buf[i]);\r
+ for(i=0;i<3;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
+ if(tm->enabled)\r
+ {\r
+ data = 0x00;\r
+ s35392a_set_reg(s35392a, S35392A_CMD_STATUS2, &data, 1); \r
+ s35392a_set_reg(s35392a, S35392A_CMD_INT2, &data, 1);\r
+\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ //data = (data |S35392A_FLAG_INT2AE) & 0x2;\r
+ data = 0x02;\r
+ s35392a_set_reg(s35392a, S35392A_CMD_STATUS2, &data, 1); \r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ printk("data = 0x%x\n",data);\r
+ err = s35392a_set_reg(s35392a, S35392A_CMD_INT2, buf, sizeof(buf));\r
+ return err;\r
+ }\r
+ else\r
+ {\r
+ //s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ //data &= ~S35392A_FLAG_INT1AE;\r
+ //s35392a_set_reg( s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ }\r
+ return -1; \r
+ \r
+}\r
+static int s35392a_i2c_read_alarm0(struct i2c_client *client, struct rtc_wkalrm *tm)\r
+{\r
+ struct s35392a *s35392a = i2c_get_clientdata(client);\r
+ char buf[3];\r
+ int i,err;\r
+ char data;\r
+ DBG("%s:%d\n",__FUNCTION__,__LINE__); \r
+ err = s35392a_get_reg(s35392a, S35392A_CMD_INT1, buf, sizeof(buf));\r
+ if(err < 0)\r
+ return err;\r
+ for(i=0;i<3;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
+ for(i = 0;i < 3;++i)\r
+ buf[i] = bitrev8(buf[i]);\r
+ for(i=0;i<3;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
+ tm->time.tm_wday = -1; \r
+ tm->time.tm_hour = -1;\r
+ tm->time.tm_min = -1; \r
+\r
+ if(buf[S35392A_ALARM_WDAYS] & S35392A_ALARM_ENABLE )\r
+ tm->time.tm_wday = bcd2bin(buf[S35392A_ALARM_WDAYS] & S35392A_ALARM_DISABLE) ;\r
+ \r
+ if(buf[S35392A_ALARM_HOURS] & S35392A_ALARM_ENABLE)\r
+ tm->time.tm_hour = s35392a_reg2hr(s35392a, buf[S35392A_ALARM_HOURS]);\r
+ \r
+ if(buf[S35392A_ALARM_MINS] & S35392A_ALARM_ENABLE)\r
+ tm->time.tm_min = bcd2bin(buf[S35392A_ALARM_MINS] & S35392A_ALARM_DISABLE) ;\r
+ \r
+\r
+ tm->time.tm_year = -1;\r
+ tm->time.tm_mon = -1;\r
+ tm->time.tm_mday = -1;\r
+ tm->time.tm_yday = -1;\r
+ tm->time.tm_sec = -1;\r
+ \r
+ DBG( "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "\r
+ "mon=%d, year=%d, wday=%d\n", __func__, tm->time.tm_sec,\r
+ tm->time.tm_min, tm->time.tm_hour, tm->time.tm_mday, tm->time.tm_mon, tm->time.tm_year,\r
+ tm->time.tm_wday);\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ tm->enabled = ((data & S35392A_MASK_INT1) == S35392A_INT1_ENABLE);\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS1, &data, 1);\r
+ tm->pending = !!(data & S35392A_FLAG_INT1); \r
+ \r
+ DBG("%s:%d\n",__FUNCTION__,__LINE__);\r
+ return data;\r
+}\r
+\r
+static int s35392a_i2c_set_alarm0(struct i2c_client *client, struct rtc_wkalrm *tm)\r
+{\r
+ struct s35392a *s35392a = i2c_get_clientdata(client);\r
+ char buf[3];\r
+ char data;\r
+ int i,err;\r
+ DBG("%s:%d\n",__FUNCTION__,__LINE__);\r
+ DBG( "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "\r
+ "mon=%d, year=%d, wday=%d\n", __func__, tm->time.tm_sec,\r
+ tm->time.tm_min, tm->time.tm_hour, tm->time.tm_mday, tm->time.tm_mon, tm->time.tm_year,\r
+ tm->time.tm_wday);\r
+ \r
+ //buf[S35392A_ALARM_WDAYS] = tm->time.tm_wday>= 0 ? \r
+ // (bin2bcd(tm->time.tm_wday) |S35392A_ALARM_ENABLE) : 0; \r
+ buf[S35392A_ALARM_WDAYS]=0;\r
+ buf[S35392A_ALARM_HOURS] = tm->time.tm_hour >=0 ?\r
+ s35392a_hour2reg(s35392a, tm->time.tm_hour) : 0;\r
+ buf[S35392A_ALARM_MINS] = tm->time.tm_min >= 0?\r
+ bin2bcd(tm->time.tm_min) | S35392A_ALARM_ENABLE:0; \r
+ for(i=0;i<3;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
+ for(i = 0;i < 3;++i)\r
+ buf[i] = bitrev8(buf[i]);\r
+ for(i=0;i<3;i++)\r
+ printk("buf[%d]=0x%x\n",i,buf[i]);\r
+ if(tm->enabled)\r
+ {\r
+ data = 0x00;\r
+ s35392a_set_reg(s35392a, S35392A_CMD_STATUS2, &data, 1); \r
+ s35392a_set_reg(s35392a, S35392A_CMD_INT2, &data, 1);\r
+\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ //ta = (data |S35392A_FLAG_INT1AE) & 0x20;\r
+ data = 0x02;\r
+ s35392a_set_reg(s35392a, S35392A_CMD_STATUS2, &data, 1); \r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ printk("data = 0x%x\n",data);\r
+ err = s35392a_set_reg(s35392a, S35392A_CMD_INT1, buf, sizeof(buf));\r
+ return err;\r
+ }\r
+ else\r
+ {\r
+ //s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ //data &= ~S35392A_FLAG_INT1AE;\r
+ //s35392a_set_reg( s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ }\r
+ return -1; \r
+ \r
+}\r
+static void s35392a_alarm_test(struct i2c_client *client ,struct rtc_time rtc_alarm_rtc_time)\r
+{\r
+ struct rtc_wkalrm rtc_alarm,tm; \r
+ char data;\r
+ struct s35392a *s35392a = i2c_get_clientdata(client);\r
+ DBG("%s:%d\n",__FUNCTION__,__LINE__); \r
+ \r
+ rtc_alarm.time.tm_sec = rtc_alarm_rtc_time.tm_sec;\r
+ rtc_alarm.time.tm_min = (rtc_alarm_rtc_time.tm_min + 1) % 60;\r
+ if((rtc_alarm.time.tm_min + 2)/60 > 0)\r
+ rtc_alarm.time.tm_hour = rtc_alarm_rtc_time.tm_hour+1;\r
+ else \r
+ rtc_alarm.time.tm_hour = rtc_alarm_rtc_time.tm_hour;\r
+ if(rtc_alarm.time.tm_hour >24)\r
+ rtc_alarm.time.tm_hour =24;\r
+ rtc_alarm.time.tm_mday = rtc_alarm_rtc_time.tm_mday;\r
+ rtc_alarm.time.tm_mon = rtc_alarm_rtc_time.tm_mon;\r
+ rtc_alarm.time.tm_year = rtc_alarm_rtc_time.tm_year;\r
+ rtc_alarm.time.tm_wday = rtc_alarm_rtc_time.tm_wday;\r
+ rtc_alarm.time.tm_yday = rtc_alarm_rtc_time.tm_yday;\r
+ rtc_alarm.enabled = 1; \r
+ DBG("set alarm - rtc %02d:%02d:%02d %02d/%02d/%04d week=%02d\n",\r
+ rtc_alarm.time.tm_hour, rtc_alarm.time.tm_min,\r
+ rtc_alarm.time.tm_sec, rtc_alarm.time.tm_mon + 1,\r
+ rtc_alarm.time.tm_mday, rtc_alarm.time.tm_year + 1900,rtc_alarm.time.tm_wday);\r
+ s35392a_i2c_set_alarm(client,&rtc_alarm); \r
+ data = s35392a_i2c_read_alarm(client,&tm);\r
+ DBG("set alarm - rtc %02d:%02d:%02d %02d/%02d/%04d week=%02d\n",\r
+ tm.time.tm_hour, tm.time.tm_min,\r
+ tm.time.tm_sec, tm.time.tm_mon + 1,\r
+ tm.time.tm_mday, tm.time.tm_year + 1900,tm.time.tm_wday);\r
+ \r
+ DBG("------------------first-------------------------0x%0x, 0x%0x\n",data, data&S35392A_FLAG_INT2);\r
+ do\r
+ { \r
+ msleep(10000);\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ DBG("-----------------------------------------------0x%0x\n",data); \r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS1, &data, 1);\r
+ DBG("-----------------------------------------------0x%0x\n",data);\r
+ }while((data & S35392A_FLAG_INT2) == 0);\r
+ \r
+ msleep(20000);\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS1, &data, 1);\r
+ DBG("--------------------last-------------------------0x%0x\n",data);\r
+ data=0x00;\r
+ s35392a_set_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS1, &data, 1);\r
+}\r
+\r
+static void s35392a_alarm_test0(struct i2c_client *client ,struct rtc_time rtc_alarm_rtc_time)\r
+{\r
+ struct rtc_wkalrm rtc_alarm,tm; \r
+ char data;\r
+ struct s35392a *s35392a = i2c_get_clientdata(client);\r
+ DBG("%s:%d\n",__FUNCTION__,__LINE__); \r
+ \r
+ rtc_alarm.time.tm_sec = rtc_alarm_rtc_time.tm_sec;\r
+ rtc_alarm.time.tm_min = (rtc_alarm_rtc_time.tm_min + 3) % 60;\r
+ if((rtc_alarm.time.tm_min + 3)/60 > 0)\r
+ rtc_alarm.time.tm_hour = rtc_alarm_rtc_time.tm_hour+1; \r
+ else \r
+ rtc_alarm.time.tm_hour = rtc_alarm_rtc_time.tm_hour;\r
+ if(rtc_alarm.time.tm_hour >24)\r
+ rtc_alarm.time.tm_hour =24;\r
+ rtc_alarm.time.tm_mday = rtc_alarm_rtc_time.tm_mday;\r
+ rtc_alarm.time.tm_mon = rtc_alarm_rtc_time.tm_mon;\r
+ rtc_alarm.time.tm_year = rtc_alarm_rtc_time.tm_year;\r
+ rtc_alarm.time.tm_wday = rtc_alarm_rtc_time.tm_wday;\r
+ rtc_alarm.time.tm_yday = rtc_alarm_rtc_time.tm_yday;\r
+ rtc_alarm.enabled = 1; \r
+ DBG("set alarm - rtc %02d:%02d:%02d %02d/%02d/%04d week=%02d\n",\r
+ rtc_alarm.time.tm_hour, rtc_alarm.time.tm_min,\r
+ rtc_alarm.time.tm_sec, rtc_alarm.time.tm_mon + 1,\r
+ rtc_alarm.time.tm_mday, rtc_alarm.time.tm_year + 1900,rtc_alarm.time.tm_wday);\r
+ s35392a_i2c_set_alarm0(client,&rtc_alarm); \r
+ data = s35392a_i2c_read_alarm0(client,&tm);\r
+ DBG("set alarm - rtc %02d:%02d:%02d %02d/%02d/%04d week=%02d\n",\r
+ tm.time.tm_hour, tm.time.tm_min,\r
+ tm.time.tm_sec, tm.time.tm_mon + 1,\r
+ tm.time.tm_mday, tm.time.tm_year + 1900,tm.time.tm_wday);\r
+ \r
+ DBG("------------------first-------------------------0x%0x, 0x%0x\n",data, data&S35392A_FLAG_INT1);\r
+ do\r
+ { \r
+ msleep(10000);\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ DBG("-----------------------------------------------0x%0x\n",data); \r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS1, &data, 1);\r
+ DBG("-----------------------------------------------0x%0x\n",data);\r
+ \r
+ }while((data & S35392A_FLAG_INT1) == 0);\r
+ msleep(10000);\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS1, &data, 1);\r
+ DBG("--------------------last-------------------------0x%0x\n",data);\r
+ data=0x00;\r
+ s35392a_set_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS1, &data, 1);\r
+ \r
+}\r
+\r
+static int s35392a_set_init_time(struct s35392a *s35392a)\r
+{ \r
+ struct rtc_time *tm;\r
+ struct i2c_client *client = s35392a->client;\r
+ tm->tm_year = 110;\r
+ tm->tm_mon = 8;\r
+ tm->tm_mday = 8;\r
+ tm->tm_wday = 0;\r
+ tm->tm_hour = 8;\r
+ tm->tm_min = 8;\r
+ tm->tm_sec = 8; \r
+ s35392a_set_datetime(client, tm);\r
+ return 0;\r
+}\r
+static int s35392a_reset(struct s35392a *s35392a)\r
+{\r
+ char buf[1];\r
\r
+ if (s35392a_get_reg(s35392a, S35392A_CMD_STATUS1, buf, sizeof(buf)) < 0)\r
+ return -EIO; \r
+ if (!(buf[0] & (S35392A_FLAG_POC | S35392A_FLAG_BLD)))\r
+ return 0;\r
+\r
+ buf[0] |= (S35392A_FLAG_RESET | S35392A_FLAG_24H);\r
+ buf[0] &= 0xf0;\r
+ s35392a_set_reg(s35392a, S35392A_CMD_STATUS1, buf, sizeof(buf));\r
+ //s35392a_set_init_time( s35392a); \r
+ return 0; \r
+}\r
+\r
+static int s35392a_disable_test_mode(struct s35392a *s35392a)\r
+{\r
+ char buf[1];\r
+\r
+ if (s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, buf, sizeof(buf)) < 0)\r
+ return -EIO;\r
+\r
+ if (!(buf[0] & S35392A_FLAG_TEST))\r
+ return 0;\r
+\r
+ buf[0] &= ~S35392A_FLAG_TEST;\r
+ return s35392a_set_reg(s35392a, S35392A_CMD_STATUS2, buf, sizeof(buf));\r
}\r
static int s35392a_rtc_read_time(struct device *dev, struct rtc_time *tm)\r
{\r
{\r
u8 data;\r
struct s35392a *s35392a = i2c_get_clientdata(client);\r
- \r
+ DBG("@@@@@%s:%d@@@@@\n",__FUNCTION__,__LINE__);\r
s35392a_get_reg( s35392a, S35392A_CMD_STATUS2, &data, 1);\r
- data = (data |S35392A_FLAG_INT1AE) & 0x3F;\r
+ data = (data |S35392A_FLAG_INT2AE) & 0x02;\r
s35392a_set_reg( s35392a, S35392A_CMD_STATUS2, &data, 1);\r
-\r
+ DBG("@@@@@%s:%d@@@@@\n",__FUNCTION__,__LINE__);\r
return 0;\r
}\r
static int s35392a_i2c_close_alarm(struct i2c_client *client )\r
{\r
u8 data;\r
struct s35392a *s35392a = i2c_get_clientdata(client);\r
- \r
+ DBG("@@@@@%s:%d@@@@@\n",__FUNCTION__,__LINE__);\r
s35392a_get_reg( s35392a, S35392A_CMD_STATUS2, &data, 1);\r
- data &= ~S35392A_FLAG_INT1AE;\r
+ data &= ~S35392A_FLAG_INT2AE;\r
s35392a_set_reg( s35392a, S35392A_CMD_STATUS2, &data, 1);\r
-\r
+ DBG("@@@@@%s:%d@@@@@\n",__FUNCTION__,__LINE__);\r
return 0;\r
}\r
\r
static int s35392a_rtc_ioctl(struct device *dev,unsigned int cmd,unsigned long arg)\r
{\r
struct i2c_client *client = to_i2c_client(dev);\r
- \r
+ DBG("@@@@@%s:%d@@@@@\n",__FUNCTION__,__LINE__);\r
switch(cmd)\r
{\r
case RTC_AIE_OFF:\r
err:\r
return -EIO;\r
}\r
-static int s35392_rtc_proc(struct device *dev, unsigned int cmd, unsigned long arg)\r
+static int s35392a_rtc_proc(struct device *dev, unsigned int cmd, unsigned long arg)\r
{\r
return 0;\r
}\r
.read_alarm = s35392a_rtc_read_alarm,\r
.set_alarm = s35392a_rtc_set_alarm,\r
.ioctl = s35392a_rtc_ioctl,\r
- .proc = s35392_rtc_proc\r
+ .proc = s35392a_rtc_proc\r
+};\r
+\r
+\r
+\r
+#if defined(CONFIG_RTC_INTF_SYSFS) || defined(CONFIG_RTC_INTF_SYSFS_MODULE)\r
+static ssize_t s35392a_sysfs_show_flags(struct device *dev,\r
+ struct device_attribute *attr, char *buf)\r
+{\r
+ DBG("\n@@@@@@@@@@@s35392a_sysfs_show_flags@@@@@@@@@@@@@\n");\r
+ \r
+ return -EIO;\r
+\r
+}\r
+static DEVICE_ATTR(flags, S_IRUGO, s35392a_sysfs_show_flags, NULL);\r
+\r
+static ssize_t s35392a_sysfs_show_sqwfreq(struct device *dev,\r
+ struct device_attribute *attr, char *buf)\r
+{\r
+ DBG("\n@@@@@@@@@@@ s35392a_sysfs_show_sqwfreq@@@@@@@@@@@@@\n");\r
+ struct i2c_client *client = to_i2c_client(dev);\r
+ return 0;\r
+}\r
+static ssize_t s35392a_sysfs_set_sqwfreq(struct device *dev,\r
+ struct device_attribute *attr,\r
+ const char *buf, size_t count)\r
+{\r
+ DBG("\n@@@@@@@@@@@s35392a_sysfs_set_sqwfreq@@@@@@@@@@@@@\n");\r
+ \r
+ return count;\r
+}\r
+static DEVICE_ATTR(sqwfreq, S_IRUGO | S_IWUSR,\r
+ s35392a_sysfs_show_sqwfreq, s35392a_sysfs_set_sqwfreq);\r
+\r
+static struct attribute *attrs[] = {\r
+ &dev_attr_flags.attr,\r
+ &dev_attr_sqwfreq.attr,\r
+ NULL,\r
+};\r
+static struct attribute_group attr_group = {\r
+ .attrs = attrs,\r
};\r
+static int s35392a_sysfs_register(struct device *dev)\r
+{\r
+ DBG("\n@@@@@@@@@@@s35392a_sysfs_register@@@@@@@@@@@@@\n");\r
+ return sysfs_create_group(&dev->kobj, &attr_group);\r
+ \r
+}\r
+#else\r
+static int s35392a_sysfs_register(struct device *dev)\r
+{\r
+ DBG("\n@@@@@@@@@@@s35392a_sysfs_register@@@@@@@@@@@@@\n");\r
+ return 0;\r
+ \r
+}\r
+#endif \r
\r
static struct i2c_driver s35392a_driver;\r
\r
+static void s35392a_work_func(struct work_struct *work)\r
+{\r
+ struct s35392a *s35392a = container_of(work, struct s35392a, work);\r
+ struct i2c_client *client = s35392a->client;\r
+ \r
+ printk("\n@@@@@@@@@@@rtc_wakeup_irq@@@@@@@@@@@@@\n");\r
+ \r
+ char data = 0x00;\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ data = 0x00;\r
+ s35392a_set_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ s35392a_get_reg(s35392a, S35392A_CMD_STATUS2, &data, 1);\r
+ \r
+ printk("\n@@@@@@@@@@@rtc_wakeup_irq@@@@@@@@@@@@@\n"); \r
+ \r
+ enable_irq(client->irq); \r
+}\r
+\r
+static void s35392a_wakeup_irq(int irq, void *dev_id)\r
+{ \r
+ struct s35392a *s35392a = (struct s35392a *)dev_id;\r
+\r
+ disable_irq_nosync(irq);\r
+ schedule_work(&s35392a->work);\r
+}\r
+\r
static int s35392a_probe(struct i2c_client *client,\r
const struct i2c_device_id *id)\r
{\r
struct s35392a *s35392a;\r
struct rtc_time tm;\r
char buf[1];\r
+ \r
printk("@@@@@%s:%d@@@@@\n",__FUNCTION__,__LINE__);\r
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {\r
err = -ENODEV;\r
\r
if (s35392a_get_datetime(client, &tm) < 0)\r
dev_warn(&client->dev, "clock needs to be set\n");\r
-\r
+ \r
s35392a->rtc = rtc_device_register(s35392a_driver.driver.name,\r
&client->dev, &s35392a_rtc_ops, THIS_MODULE);\r
-\r
+ \r
if (IS_ERR(s35392a->rtc)) {\r
err = PTR_ERR(s35392a->rtc);\r
goto exit_dummy;\r
}\r
+ err = s35392a_sysfs_register(&client->dev);\r
+ if(err)\r
+ {\r
+ dev_err(&client->dev, "error sysfs register\n");\r
+ goto exit_dummy;\r
+ }\r
+ \r
+ if(err = gpio_request(RTC_S35392A_INT, "rtc gpio"))\r
+ {\r
+ dev_err(&client->dev, "gpio request fail\n");\r
+ gpio_free(RTC_S35392A_INT);\r
+ goto exit_dummy;\r
+ }\r
+\r
+ gpio_pull_updown(RTC_S35392A_INT,GPIOPullDown);\r
+ \r
+ if(err = request_irq(gpio_to_irq(RTC_S35392A_INT),s35392a_wakeup_irq,IRQF_TRIGGER_HIGH,NULL,s35392a) <0) \r
+ {\r
+ printk("unable to request rtc irq\n");\r
+ goto exit_dummy;\r
+ } \r
+ \r
+ INIT_WORK(&s35392a->work, s35392a_work_func);\r
+ \r
+#if 0 //S35392_TEST\r
+ //i=2;\r
+ while(1)\r
+ {\r
+ s35392a_get_datetime(client, &tm);\r
+ s35392a_alarm_test(client, tm);\r
+ //sleep(200);\r
+ }\r
+#endif\r
+ \r
printk("@@@@@%s:%d@@@@@\n",__FUNCTION__,__LINE__);\r
return 0;\r
\r
#define S35392A_BYTE_MINS 5\r
#define S35392A_BYTE_SECS 6\r
\r
+#define S35392A_ALARM_WDAYS 0\r
+#define S35392A_ALARM_HOURS 1\r
+#define S35392A_ALARM_MINS 2\r
+\r
#define S35392A_FLAG_POC 0x01\r
#define S35392A_FLAG_BLD 0x02\r
-#define S35392A_FLAG_INT2 0x04\r
-#define S35392A_FLAG_INT1 0x08\r
+#define S35392A_FLAG_INT2 0x04\r
+#define S35392A_FLAG_INT1 0x08\r
#define S35392A_FLAG_24H 0x40\r
\r
#define S35392A_FLAG_TEST 0x01\r
#define S35392A_FLAG_INT1AE 0x20\r
#define S35392A_FLAG_RESET 0x80\r
+#define S35392A_FLAG_INT2AE 0x2\r
\r
-\r
+#define S35392A_ALARM_ENABLE 0X80\r
+#define S35392A_ALARM_DISABLE 0X7F\r
+#define S35392A_MASK_INT1 0XE0\r
+#define S35392A_INT1_ENABLE 0X20\r
+#define S35392A_MASK_INT2 0X0E\r
+#define S35392A_INT2_ENABLE 0X02\r
\r
//#define S35392_STATUS_INT1 (~(0x3<<5))\r
//#define S35392_STATUS_INT2 (~(0x3<<1))\r
projects / firefly-linux-kernel-4.4.55.git / commitdiff