2 * Copyright (C) 2010 ROCKCHIP, Inc.
4 * This software is licensed under the terms of the GNU General Public
5 * License version 2, as published by the Free Software Foundation, and
6 * may be copied, distributed, and modified under those terms.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 /*******************************************************************/
14 /* COPYRIGHT (C) ROCK-CHIPS FUZHOU . ALL RIGHTS RESERVED. */
15 /*******************************************************************
20 ********************************************************************/
21 #include <linux/clk.h>
22 #include <linux/errno.h>
23 #include <linux/interrupt.h>
24 #include <asm/mach-types.h>
25 #include <linux/irq.h>
26 #include <linux/debugfs.h>
27 #include <linux/seq_file.h>
28 #include <linux/kernel.h>
29 #include <linux/list.h>
30 #include <linux/module.h>
32 #include <mach/hardware.h>
33 #include <mach/gpio.h>
34 #include <mach/rk2818_iomap.h>
35 #include <mach/iomux.h>
36 #include <linux/device.h>
37 #include <mach/gpio.h>
39 #include <linux/i2c.h>
40 #include <linux/workqueue.h>
41 #include <mach/board.h>
42 #include <linux/delay.h>
43 #include <linux/i2c/tca6424.h>
47 #define DBG(x...) printk(KERN_INFO x)
53 #define DBGERR(x...) printk(KERN_INFO x)
59 /* the first extern gpio number in all of gpio groups */
61 unsigned gpio_pin_num;
62 /* the first gpio irq number in all of irq source */
63 unsigned gpio_irq_start;
64 unsigned irq_pin_num; //ÖжϵĸöÊý
65 unsigned irq_gpiopin; //¸¸ÖжϵÄÖжϺÅ
66 unsigned irq_chain; //¸¸ÖжϵÄÖжϺÅ
67 uint8_t reg_input[TCA6424_PortNum];
68 uint8_t reg_output[TCA6424_PortNum];
69 uint8_t reg_direction[TCA6424_PortNum];
70 uint8_t interrupt_en[TCA6424_PortNum]; // 0 dis
71 uint8_t interrupt_mask[TCA6424_PortNum];// 0 unmask
72 uint8_t inttype_set[TCA6424_PortNum]; // Inttype enable
73 uint8_t inttype[TCA6424_PortNum];
74 uint8_t inttype1[TCA6424_PortNum];
76 #ifdef TCA6424_OUTREGLOCK
77 struct mutex outreglock;
79 #ifdef TCA6424_INPUTREGLOCK
80 struct mutex inputreglock;
82 #ifdef TCA6424_CONFIGREGLOCK
83 struct mutex configreglock;
85 struct i2c_client *client;
86 //struct extgpio_data_s *p;
87 struct tca6424_platform_data *dyn_pdata;
88 struct work_struct tca6424_work;
89 struct gpio_chip gpio_chip;
93 static const struct i2c_device_id tca6424_id[] =
95 {"extend_gpio_tca6424",8,},
98 MODULE_DEVICE_TABLE(i2c, tca6424_id);
100 static short int portnum[TCA6424_PortNum]={ TCA6424_Port0PinNum,
101 TCA6424_Port1PinNum,TCA6424_Port2PinNum};
102 typedef struct _tca6424_access_{
103 u8 portreg[TCA6424_PortNum];
104 u8 accessflag[TCA6424_PortNum];//0 ²»½øÐвÙ×÷
107 extern inline struct gpio_chip *gpio_to_chip(unsigned gpio);
108 extern struct lock_class_key gpio_lock_class;
109 struct workqueue_struct *tca6424workqueue;
111 static int tca6424_write_reg(struct i2c_client *client, uint8_t reg, uint8_t val)
114 struct i2c_adapter *adap;
119 adap = client->adapter;
123 msg.addr = client->addr;
126 msg.flags = client->flags;
127 msg.scl_rate = TCA6424_I2C_RATE;
129 ret = i2c_transfer(adap, &msg, 1);
133 static int tca6424_read_reg(struct i2c_client *client, uint8_t reg, uint8_t *val)
136 struct i2c_adapter *adap;
137 struct i2c_msg msgs[2];
141 adap = client->adapter;
143 msgs[0].addr = client->addr;
145 msgs[0].flags = client->flags;
147 msgs[0].scl_rate = TCA6424_I2C_RATE;
150 msgs[1].addr = client->addr;
151 msgs[1].flags = client->flags | I2C_M_RD;
153 msgs[1].scl_rate = TCA6424_I2C_RATE;
155 ret = i2c_transfer(adap, msgs, 2);
160 static int tca6424_gpio_direction_input(struct gpio_chip *gc, uint8_t pin_num)
162 struct tca6424_chip *chip;
164 uint8_t gpioPortPinNum;
169 chip = container_of(gc, struct tca6424_chip, gpio_chip);
170 gpioPortNum = pin_num/8;
171 gpioPortPinNum= pin_num%8;
172 if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
174 Regaddr = TCA6424_Config_Reg+gpioPortNum;
176 #ifdef TCA6424_CONFIGREGLOCK
177 if (!mutex_trylock(&chip->configreglock))
179 DBGERR("**%s[%d]Did not get the configreglock**\n",__FUNCTION__,__LINE__);
184 reg_val = tca6424setbit(chip->reg_direction[gpioPortNum], gpioPortPinNum);
185 ret = tca6424_write_reg(chip->client, Regaddr, reg_val);
189 chip->reg_direction[gpioPortNum] = reg_val;
192 DBG("**%s[%d],config_reg=%2x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
194 #ifdef TCA6424_CONFIGREGLOCK
195 mutex_unlock(&chip->configreglock);
201 static int tca6424_gpio_direction_output(struct gpio_chip *gc,uint8_t pin_num, int val)
203 struct tca6424_chip *chip;
205 uint8_t gpioPortPinNum;
210 chip = container_of(gc, struct tca6424_chip, gpio_chip);
211 gpioPortNum = pin_num/8;
212 gpioPortPinNum = pin_num%8;
213 if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
215 Regaddr = TCA6424_Config_Reg+gpioPortNum;
217 #ifdef TCA6424_CONFIGREGLOCK
218 if (!mutex_trylock(&chip->configreglock))
220 DBGERR("**%s[%d]Did not get the configreglock**\n",__FUNCTION__,__LINE__);
225 reg_val = tca6424clearbit(chip->reg_direction[gpioPortNum], gpioPortPinNum);
226 DBG("**%s[%d],reg_val=%2x, Regaddr=%2x,**\n",__FUNCTION__,__LINE__,reg_val,Regaddr);
227 ret = tca6424_write_reg(chip->client, Regaddr, reg_val);
230 #ifdef TCA6424_CONFIGREGLOCK
231 mutex_unlock(&chip->configreglock);
233 DBGERR("**%s[%d] set direction reg is error,reg_val=%x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
236 chip->reg_direction[gpioPortNum] = reg_val;
237 #ifdef TCA6424_CONFIGREGLOCK
238 mutex_unlock(&chip->configreglock);
241 #ifdef TCA6424_OUTREGLOCK
242 if (!mutex_trylock(&chip->outreglock))
244 DBGERR("**%s[%d] Did not get the outreglock**\n",__FUNCTION__,__LINE__);
248 /* set output level */
250 reg_val = tca6424setbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
252 reg_val = tca6424clearbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
254 Regaddr = TCA6424_OutputLevel_Reg+gpioPortNum;
255 ret = tca6424_write_reg(chip->client, Regaddr, reg_val);
258 #ifdef TCA6424_OUTREGLOCK
259 mutex_unlock(&chip->outreglock);
261 DBGERR("**%s[%d] set out reg is error,reg_val=%x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
264 chip->reg_output[gpioPortNum] = reg_val;
266 #ifdef TCA6424_OUTREGLOCK
267 mutex_unlock(&chip->outreglock);
270 DBG("**%s[%d],output_reg=%2x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
274 static int tca6424_gpio_get_value(struct gpio_chip *gc, uint8_t pin_num)
276 struct tca6424_chip *chip;
278 uint8_t gpioPortPinNum;
283 chip = container_of(gc, struct tca6424_chip, gpio_chip);
284 gpioPortNum = pin_num/8;
285 gpioPortPinNum= pin_num%8;
287 if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
290 Regaddr = TCA6424_InputLevel_Reg+gpioPortNum;
292 if(!tca6424getbit(chip->reg_direction[gpioPortNum],gpioPortPinNum)) //ÅжϸÃpinÊÇ·ñÉèÖóÉÊä³ö
294 DBG("**it is a output pin**\n");
297 #ifdef TCA6424_INPUTREGLOCK
298 if (!mutex_trylock(&chip->inputreglock))
300 DBGERR("**%s[%d]Did not get the inputreglock**\n",__FUNCTION__,__LINE__);
305 ret = tca6424_read_reg(chip->client, Regaddr, ®_val);
308 chip->reg_input[gpioPortNum] = reg_val;
311 #ifdef TCA6424_CONFIGREGLOCK
312 mutex_unlock(&chip->inputreglock);
314 DBGERR("**%s[%d] input_reg=%2x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
316 return (ret < 0)?-1:((chip->reg_input[gpioPortNum] >> gpioPortPinNum) & 0x01);
319 static void tca6424_gpio_set_value(struct gpio_chip *gc, uint8_t pin_num, int val)
321 struct tca6424_chip *chip;
323 uint8_t gpioPortPinNum;
327 DBG("**run in the %s**\n",__FUNCTION__);
329 chip = container_of(gc, struct tca6424_chip, gpio_chip);
331 gpioPortNum = pin_num/8;
332 gpioPortPinNum= pin_num%8;
334 if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
337 Regaddr = TCA6424_OutputLevel_Reg+gpioPortNum;
339 if(tca6424getbit(chip->reg_direction[gpioPortNum],gpioPortPinNum)) // input state
342 #ifdef TCA6424_OUTREGLOCK
343 if (!mutex_trylock(&chip->outreglock))
345 DBGERR("**%s[%d] Did not get the outreglock**\n",__FUNCTION__,__LINE__);
350 reg_val = tca6424setbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
352 reg_val = tca6424clearbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
354 ret = tca6424_write_reg(chip->client, Regaddr, reg_val);
357 chip->reg_output[gpioPortNum] = reg_val;
360 #ifdef TCA6424_OUTREGLOCK
361 mutex_unlock(&chip->outreglock);
364 DBG("**%s[%d],output_reg=%2x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
365 return;// (ret<0)?-1:0;
368 static int tca6424_gpio_to_irq(struct gpio_chip *chip,unsigned offset)
370 struct tca6424_chip *pca_chip = container_of(chip, struct tca6424_chip, gpio_chip);
371 if(((pca_chip->gpio_start+offset)>=chip->base)&&((pca_chip->gpio_start+offset)<(chip->base+chip->ngpio)))
373 //DBG("**%s,offset=%d,gpio_irq_start=%d,base=%d,ngpio=%d,gpio_irq_start=%d**\n",
374 // __FUNCTION__,offset,pca_chip->gpio_irq_start,chip->base,chip->ngpio,pca_chip->gpio_irq_start);
375 return (offset+pca_chip->gpio_irq_start);
383 int tca6424_checkrange(int start,int num,int val)
386 if((val<(start+num))&&(val>=start))
392 static void tca6424_gpio_irq_enable(unsigned irq)
394 struct irq_desc *desc = irq_to_desc(irq);
396 struct tca6424_chip *pchip=(struct tca6424_chip *)desc->chip_data;
397 //struct gpio_chip *chip_gpio;
400 uint8_t gpioPortPinNum;
401 uint8_t tca6424pinnum;
404 if(!tca6424_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
406 tca6424pinnum = irq-pchip->gpio_irq_start;
412 gpioPortNum = tca6424pinnum/8;
413 gpioPortPinNum= tca6424pinnum%8;
414 gpio_num=pchip->gpio_start+tca6424pinnum;
415 if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
417 DBG("**%s**\n",__FUNCTION__);
418 pchip->interrupt_en[gpioPortNum]=tca6424setbit(pchip->interrupt_en[gpioPortNum],gpioPortPinNum);
420 static void tca6424_gpio_irq_disable(unsigned irq)
422 struct irq_desc *desc = irq_to_desc(irq);
423 struct tca6424_chip *pchip=(struct tca6424_chip *)desc->chip_data;
425 uint8_t gpioPortPinNum;
426 uint8_t tca6424pinnum;
428 if(!tca6424_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
430 tca6424pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
436 gpioPortNum = tca6424pinnum/8;
437 gpioPortPinNum= tca6424pinnum%8;
439 if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
441 DBG("**%s**\n",__FUNCTION__);
443 pchip->interrupt_en[gpioPortNum]=tca6424clearbit(pchip->interrupt_en[gpioPortNum],gpioPortPinNum);
448 static void tca6424_gpio_irq_mask(unsigned irq)
450 struct irq_desc *desc = irq_to_desc(irq);
451 struct tca6424_chip *pchip=(struct tca6424_chip *)desc->chip_data;
453 uint8_t gpioPortPinNum;
454 uint8_t tca6424pinnum;
456 if(!tca6424_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
458 tca6424pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
464 gpioPortNum = tca6424pinnum/8;
465 gpioPortPinNum= tca6424pinnum%8;
467 if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
470 DBG("**%s**\n",__FUNCTION__);
472 pchip->interrupt_mask[gpioPortNum]=tca6424setbit(pchip->interrupt_mask[gpioPortNum],gpioPortPinNum);
476 static void tca6424_gpio_irq_unmask(unsigned irq)
478 struct irq_desc *desc = irq_to_desc(irq);
479 //int gpiopinnum;//=irq_to_gpio(irq);
480 struct tca6424_chip *pchip=(struct tca6424_chip *)desc->chip_data;
482 uint8_t gpioPortPinNum;
483 uint8_t tca6424pinnum;
485 DBG("**%s**\n",__FUNCTION__);
487 if(!tca6424_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
489 tca6424pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
495 gpioPortNum = tca6424pinnum/8;
496 gpioPortPinNum= tca6424pinnum%8;
498 if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
500 pchip->interrupt_mask[gpioPortNum]=tca6424clearbit(pchip->interrupt_mask[gpioPortNum],gpioPortPinNum);
503 static int tca6424_gpio_irq_type(unsigned int irq, unsigned int type)
505 struct irq_desc *desc_irq=irq_to_desc(irq);
506 struct tca6424_chip *pchip=(struct tca6424_chip *)desc_irq->chip_data;
507 //struct gpio_chip *chip_gpio;
510 uint8_t gpioPortPinNum;
511 uint8_t tca6424pinnum;
512 if(!tca6424_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
514 tca6424pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
515 gpio_num=pchip->gpio_start+tca6424pinnum;
520 gpioPortNum = tca6424pinnum/8;
521 gpioPortPinNum= tca6424pinnum%8;
522 //DBG("**%s %d gpio_num=%d,PortNum=%d,PortPinNum=%d**\n",__FUNCTION__,__LINE__,gpio_num,gpioPortNum,gpioPortPinNum);
525 pchip->inttype_set[gpioPortNum]=tca6424clearbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
526 DBG("**%s IRQ_TYPE_NONE**\n",__FUNCTION__);
528 case IRQ_TYPE_EDGE_RISING:
529 pchip->inttype_set[gpioPortNum]=tca6424setbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
530 pchip->inttype[gpioPortNum]=tca6424setbit(pchip->inttype[gpioPortNum],gpioPortPinNum);
531 pchip->inttype1[gpioPortNum]=tca6424clearbit(pchip->inttype1[gpioPortNum],gpioPortPinNum);
532 DBG("**%s IRQ_TYPE_EDGE_RISING,inttype=%x,inttype1=%x**\n",__FUNCTION__,pchip->inttype[gpioPortNum],pchip->inttype1[gpioPortNum]);
535 case IRQ_TYPE_EDGE_FALLING:
536 pchip->inttype_set[gpioPortNum]=tca6424setbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
537 pchip->inttype[gpioPortNum]=tca6424clearbit(pchip->inttype[gpioPortNum],gpioPortPinNum);
538 pchip->inttype1[gpioPortNum]=tca6424clearbit(pchip->inttype1[gpioPortNum],gpioPortPinNum);
539 DBG("**%s IRQ_TYPE_EDGE_RISING,inttype=%x,inttype1=%x**\n",__FUNCTION__,pchip->inttype[gpioPortNum],pchip->inttype1[gpioPortNum]);
542 case IRQ_TYPE_EDGE_BOTH:
543 pchip->inttype_set[gpioPortNum]=tca6424setbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
544 pchip->inttype1[gpioPortNum]=tca6424setbit(pchip->inttype1[gpioPortNum],gpioPortPinNum);
545 DBG("**%s IRQ_TYPE_EDGE_RISING,inttype=%x,inttype1=%x**\n",__FUNCTION__,pchip->inttype[gpioPortNum],pchip->inttype1[gpioPortNum]);
547 case IRQ_TYPE_LEVEL_HIGH:
548 pchip->inttype_set[gpioPortNum]=tca6424clearbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
549 DBG("extern gpios does not support IRQ_TYPE_LEVEL_HIGH irq typ");
551 case IRQ_TYPE_LEVEL_LOW:
552 pchip->inttype_set[gpioPortNum]=tca6424clearbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
553 DBG("extern gpios does not support IRQ_TYPE_LEVEL_LOW irq typ");
561 static int tca6424_gpio_irq_set_wake(unsigned irq, unsigned state)
567 static struct irq_chip tca6424_gpio_irqchip = {
568 .name = "extend_gpio_tca6424",
569 .enable = tca6424_gpio_irq_enable,
570 .disable = tca6424_gpio_irq_disable,
571 .mask = tca6424_gpio_irq_mask,
572 .unmask = tca6424_gpio_irq_unmask,
573 .set_type = tca6424_gpio_irq_type,
574 .set_wake = tca6424_gpio_irq_set_wake,
578 static void tca6424_extend_gpio_irq_handler(struct work_struct *work)
580 struct tca6424_chip *pchip = container_of(work, struct tca6424_chip,tca6424_work);
581 u8 tempintputreg[TCA6424_PortNum]={0,0,0};
587 struct irq_desc *gpio_irq_desc;
589 if(tca6424_read_reg(pchip->client,TCA6424_InputLevel_Reg,&tempintputreg[0])<0)
592 DBG("**%s[%d] reading reg is error\n",__FUNCTION__,__LINE__);
593 enable_irq(pchip->irq_chain);
596 if(tca6424_read_reg(pchip->client,(TCA6424_InputLevel_Reg+1),&tempintputreg[1])<0)
599 DBG("**%s[%d] reading reg is error\n",__FUNCTION__,__LINE__);
600 enable_irq(pchip->irq_chain);
603 if(tca6424_read_reg(pchip->client,(TCA6424_InputLevel_Reg+2),&tempintputreg[2])<0)
606 DBG("**%s[%d] reading reg is error\n",__FUNCTION__,__LINE__);
607 enable_irq(pchip->irq_chain);
610 DBG("**has run at %s**,tempintreg[0] = %x,tempintreg[1] = %x,tempintreg[2] = %x\n",__FUNCTION__,tempintputreg[0],tempintputreg[1],tempintputreg[2]);
611 if((pchip->interrupt_en[0]==0)&&(pchip->interrupt_en[1]==0)&&(pchip->interrupt_en[2]==0))
613 memcpy(&pchip->reg_input[0],&tempintputreg[0],sizeof(tempintputreg));
614 DBGERR("there are no pin reg irq\n");
615 enable_irq(pchip->irq_chain);
619 for(i=0;i<TCA6424_PortNum;i++)
621 tempallowint=pchip->interrupt_en[i]&pchip->reg_direction[i]&(~pchip->interrupt_mask[i]);// Âú×ãÖжÏÌõ¼þ
622 levelchg=pchip->reg_input[i]^tempintputreg[i];// ÕÒ³öÇ°ºó״̬²»Ò»ÑùµÄpin
623 tempinttype=~(tempintputreg[i]^pchip->inttype[i]);// ÕÒ³ö´¥·¢×´Ì¬ºÍµ±Ç°pin״̬һÑùµÄpin£¬×¢ÒâÖ»Ö§³Ölow highÁ½ÖÖpin´¥·¢
625 tempinttype=(~pchip->inttype1[i])&tempinttype;// inttype1 ΪÕæµÄλ¶ÔÓ¦µÄtempinttypeλÇåÁ㣬ÒòΪ¸ÃλֻÊÜinttype1¿ØÖÆ
626 tempinttype|=pchip->inttype1[i];//µçƽֻҪÊDZ仯¾Í²úÉúÖжÏ
627 tempinttype&=pchip->inttype_set[i];//ÒѾÉèÖÃÁËtypeÀàÐÍ
629 intbit=tempallowint&levelchg&tempinttype;
630 DBG(" tempallowint=%x,levelchg=%x,tempinttype=%x,intbit=%d\n",tempallowint,levelchg,tempinttype,intbit);
633 for(j=0;j<portnum[i];j++)
635 if(tca6424getbit(intbit,j))
637 irq=pchip->gpio_irq_start+TCA6424_PortPinNum*i+j;
638 gpio_irq_desc = irq_to_desc(irq);
639 gpio_irq_desc->chip->mask(irq);
640 generic_handle_irq(irq);
641 gpio_irq_desc->chip->unmask(irq);
642 DBG("tca6424_i2c_irq_handler port=%d,pin=%d,pinlevel=%d\n",i,j,tca6424getbit(tempintputreg[i],j));
646 pchip->reg_input[i]=tempintputreg[i];
649 enable_irq(pchip->irq_chain);
653 static irqreturn_t tca6424_gpio_irq_handler(int irq, void * dev_id)
656 struct irq_desc *gpio_irq_desc = irq_to_desc(irq);
657 struct tca6424_chip *pchip=(struct tca6424_chip *)gpio_irq_desc->chip_data;
659 DBG("******************%s*******************\n",__FUNCTION__);
660 disable_irq_nosync(pchip->irq_chain);
661 queue_work(tca6424workqueue,&pchip->tca6424_work);
665 static irqreturn_t test_handler(int irq, void * dev_id)
668 DBG("******************%s*******************\n",__FUNCTION__);
672 static void tca6424_setup_gpio(struct tca6424_chip *chip, int gpios)
674 struct gpio_chip *gc;
676 gc = &chip->gpio_chip;
678 gc->direction_input = tca6424_gpio_direction_input;
679 gc->direction_output = tca6424_gpio_direction_output;
680 gc->get = tca6424_gpio_get_value;
681 gc->set = tca6424_gpio_set_value;
682 gc->to_irq = tca6424_gpio_to_irq;
686 gc->base = chip->gpio_start;
687 gc->ngpio = chip->gpio_pin_num;
688 gc->label = chip->client->name;
689 gc->dev = &chip->client->dev;
690 gc->owner = THIS_MODULE;
691 gc->names = chip->names;
694 static void tca6424_gpio_irq_setup(struct tca6424_chip *pchip)
696 unsigned pioc, irq_num;
700 struct irq_desc *desc;
701 irq_num = pchip->gpio_irq_start; //ÖжϺţ¬À©Õ¹ioµÄÖжϺÅÓ¦¸Ã½ô¸úÔÚÄÚ²¿ioÖжϺŵĺóÃæ¡£ÈçrkÄÚ²¿ÖжÏ48¸ö£¬¼ÓÉÏÄÚ²¿gpio 16¸öÐéÄâÖжϣ¬ÕâÀïpinÓ¦¸Ã´Ó48+16¿ªÊ¼
703 for (pioc = 0; pioc < pchip->irq_pin_num; pioc++,irq_num++)
705 lockdep_set_class(&irq_desc[irq_num].lock, &gpio_lock_class);
707 * Can use the "simple" and not "edge" handler since it's
708 * shorter, and the AIC handles interrupts sanely.
710 testprint1 = set_irq_chip(irq_num, &tca6424_gpio_irqchip);
711 set_irq_handler(irq_num, handle_simple_irq);
712 testprint2 = set_irq_chip_data(irq_num,(void *)pchip);
713 desc = irq_to_desc(irq_num);
714 DBG("**%s line=%d,test1=%d,test2=%d,desc=%x,chipdate=%x,pchip=%x,irq_num=%d**\n",__FUNCTION__,__LINE__,testprint1,testprint2,desc,desc->chip_data,pchip,irq_num);
715 set_irq_flags(irq_num, IRQF_VALID);
717 ret = gpio_request(pchip->irq_gpiopin,NULL);
720 gpio_free(pchip->irq_gpiopin);
721 DBG("tca6424_gpio_irq_setup request gpio is err\n");
724 gpio_pull_updown(pchip->irq_gpiopin, GPIOPullUp); //gpio ÐèÒªÀ¸ßirq_to_gpio(pchip->irq_chain)
728 set_irq_chip_data(pchip->irq_chain, pchip);
729 set_irq_chained_handler(pchip->irq_chain, gpio_irq_handlerxxx);
730 set_irq_type(pchip->irq_chain,IRQ_TYPE_LEVEL_LOW);
731 enable_irq(pchip->irq_chain);
734 tca6424workqueue=create_workqueue("tca6424 workqueue");
735 INIT_WORK(&pchip->tca6424_work,tca6424_extend_gpio_irq_handler);
737 set_irq_chip_data(pchip->irq_chain, pchip);
738 if(request_irq(pchip->irq_chain,tca6424_gpio_irq_handler, IRQF_TRIGGER_LOW, "tca6424", pchip)!=0)
740 DBG("**%s line=%d is err**\n",__FUNCTION__,__LINE__);
746 int tca6424_init_pintype(struct tca6424_chip *chip,struct i2c_client *client)
749 struct tca6424_platform_data *platform_data=(struct tca6424_platform_data *)client->dev.platform_data;
750 struct rk2818_gpio_expander_info *tca6424_gpio_settinginfo;
751 uint8_t reg_output[TCA6424_PortNum]={0,0,0};
752 uint8_t reg_direction[TCA6424_PortNum]={0,0,0};
753 uint8_t tca6424_pin_num;
755 uint8_t gpioPortPinNum,tca6424_settingpin_num=0;
759 tca6424_gpio_settinginfo=platform_data->settinginfo;
760 if(tca6424_gpio_settinginfo)
762 tca6424_settingpin_num=platform_data->settinginfolen;
763 for(i=0;i<tca6424_settingpin_num;i++)
765 if(!tca6424_checkrange(chip->gpio_start,chip->gpio_pin_num,tca6424_gpio_settinginfo[i].gpio_num))
767 tca6424_pin_num=tca6424_gpio_settinginfo[i].gpio_num-chip->gpio_start;
768 gpioPortNum = tca6424_pin_num/ TCA6424_PortPinNum;
769 gpioPortPinNum= tca6424_pin_num% TCA6424_PortPinNum;
770 //DBG("gpioPortNum=%d,gpioPortNum=%d,tca6424_pin_num=%d,reg_direction=%x,reg_output=%x,reg_input=%x\n",gpioPortNum,gpioPortPinNum,tca6424_pin_num,reg_direction[i],reg_output[i]);
771 if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
773 if(tca6424_gpio_settinginfo[i].pin_type==GPIO_IN)
775 reg_direction[gpioPortNum]=tca6424setbit(reg_direction[gpioPortNum],gpioPortPinNum);
779 reg_direction[gpioPortNum]=tca6424clearbit(reg_direction[gpioPortNum],gpioPortPinNum);
780 if(tca6424_gpio_settinginfo[i].pin_value==GPIO_HIGH)
782 reg_output[gpioPortNum]=tca6424setbit(reg_output[gpioPortNum],gpioPortPinNum);
786 reg_output[gpioPortNum]=tca6424clearbit(reg_output[gpioPortNum],gpioPortPinNum);
794 #ifdef TCA6424_OUTREGLOCK
795 mutex_init(&chip->outreglock);
797 #ifdef TCA6424_INPUTREGLOCK
798 mutex_init(&chip->inputreglock);
800 #ifdef TCA6424_OUTREGLOCK
801 mutex_init(&chip->configreglock);
804 for(i=0; i<TCA6424_PortNum; i++)
807 if (tca6424_write_reg(client, (TCA6424_Config_Reg+i), reg_direction[i])<0)
809 DBGERR("*%s %d* write reg err\n",__FUNCTION__,__LINE__);
812 chip->reg_direction[i]=reg_direction[i];
813 if (tca6424_write_reg(client, (TCA6424_OutputLevel_Reg+i), reg_output[i])<0)
815 DBGERR("*%s %d write reg err*\n",__FUNCTION__,__LINE__);
818 chip->reg_output[i]=reg_output[i];
820 if (tca6424_write_reg(client, (TCA6424_Invert_Reg+i), 0)<0) //make sure this reg be 0
822 DBGERR("*%s %d* write reg err\n",__FUNCTION__,__LINE__);
826 if(tca6424_read_reg(client, (TCA6424_InputLevel_Reg+i), &chip->reg_input[i])<0)
828 DBGERR("*%s %d read reg err*\n",__FUNCTION__,__LINE__);
831 //DBG("reg_direction=%x,reg_output=%x,reg_input=%x\n",chip->reg_direction[i],chip->reg_output[i],chip->reg_input[i]);
837 void tca6424_reset_itr(void)
839 gpio_request(RK2818_PIN_PE6,NULL);
840 gpio_request(RK2818_PIN_PE7,NULL);
842 rk2818_mux_api_set(GPIOE_U1IR_I2C1_NAME, IOMUXA_GPIO1_A67);
843 gpio_direction_output(RK2818_PIN_PE6,GPIO_HIGH);
844 gpio_direction_output(RK2818_PIN_PE7,GPIO_LOW);
846 gpio_set_value(RK2818_PIN_PE7,GPIO_HIGH);
848 rk2818_mux_api_set(GPIOE_U1IR_I2C1_NAME, IOMUXA_I2C1);
850 gpio_free(RK2818_PIN_PE6);
851 gpio_free(RK2818_PIN_PE7);
854 static int __devinit tca6424_probe(struct i2c_client *client,const struct i2c_device_id *id)
856 struct tca6424_chip *chip;
857 struct tca6424_platform_data *pdata;
861 DBG(KERN_ALERT"*******gpio %s in %d line,dev adr is %x**\n",__FUNCTION__,__LINE__,client->addr);
862 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
865 chip = kzalloc(sizeof(struct tca6424_chip), GFP_KERNEL);
868 pdata = client->dev.platform_data;
870 DBGERR(" %s no platform data\n",__FUNCTION__);
875 chip->gpio_start = pdata->gpio_base;
876 chip->gpio_irq_start =pdata->gpio_irq_start;
877 chip->gpio_pin_num=pdata->gpio_pin_num;
878 chip->irq_pin_num = pdata->irq_pin_num;
879 chip->irq_gpiopin=pdata->tca6424_irq_pin;
880 chip->irq_chain = gpio_to_irq(pdata->tca6424_irq_pin);
881 chip->names =pdata->names;
883 //DBG("**%s in %d start=%d,irq_start=%d,pin_num=%d,irq_pin_num=%d,irq_gpiopin=%d,irq_chain=%d,**\n",
884 // __FUNCTION__,__LINE__,chip->gpio_start,chip->gpio_irq_start,chip->gpio_pin_num,chip->irq_pin_num,chip->irq_gpiopin
885 // ,chip->irq_chain);
887 /* initialize cached registers from their original values.
888 * we can't share this chip with another i2c master.
890 tca6424_setup_gpio(chip, id->driver_data);
891 ret = gpiochip_add(&chip->gpio_chip);
895 if(tca6424_init_pintype(chip,client))
899 ret = pdata->setup(client, chip->gpio_chip.base,
900 chip->gpio_chip.ngpio, pdata->context);
902 DBGERR(" %s setup failed, %d\n",__FUNCTION__,ret);
905 tca6424_gpio_irq_setup(chip);
906 i2c_set_clientdata(client, chip);
907 chip->client = client;
916 static int tca6424_remove(struct i2c_client *client)
918 struct tca6424_platform_data *pdata = client->dev.platform_data;
919 struct tca6424_chip *chip = i2c_get_clientdata(client);
922 if (pdata->teardown) {
923 ret = pdata->teardown(client, chip->gpio_chip.base,
924 chip->gpio_chip.ngpio, pdata->context);
926 DBGERR(" %s failed, %d\n",__FUNCTION__,ret);
931 ret = gpiochip_remove(&chip->gpio_chip);
933 dev_err(&client->dev, "%s failed, %d\n",
934 "gpiochip_remove()", ret);
942 static struct i2c_driver tca6424_driver = {
944 .owner = THIS_MODULE,
945 .name = "extend_gpio_tca6424",
947 .probe = tca6424_probe,
948 .remove = tca6424_remove,
949 .id_table = tca6424_id,
953 static int __init tca6424_init(void)
956 DBG(KERN_ALERT"**********tca6424_init**********\n");
957 tmp=i2c_add_driver(&tca6424_driver);
960 static void __exit tca6424_exit(void)
962 DBG(KERN_ALERT"**********tca6424_exit**********\n");
963 i2c_del_driver(&tca6424_driver);
966 module_init(tca6424_init);
967 module_exit(tca6424_exit);
969 MODULE_AUTHOR(" XXX XXX@rock-chips.com");
970 MODULE_DESCRIPTION("Driver for rk2818 tca6424 device");
971 MODULE_LICENSE("GPL");