drivers/gpio/tca6424.c

   1 /*
   2  * Copyright (C) 2010 ROCKCHIP, Inc.
   3  *
   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.
   7  *
   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.
  12  */
  13 /*******************************************************************/
  14 /*        COPYRIGHT (C)  ROCK-CHIPS FUZHOU . ALL RIGHTS RESERVED.                         */
  15 /*******************************************************************
  16 FILE                    :       tca6424.c
  17 MODIFY          :       sxj
  18 DATE            :       2010-8-11
  19 NOTES           :
  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>
  31 #include <linux/io.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>
  38 #include <asm/gpio.h>
  39 #include <linux/i2c.h>
  40 #include <linux/workqueue.h>
  41 #include <mach/board.h>
  42 #include <linux/delay.h>
  43 #include "../drivers/gpio/tca6424.h"
  44
  45 #if 0
  46 #define TCA6424DEB
  47 #define DBG(x...)       printk(KERN_INFO x)
  48 #else
  49 #define DBG(x...)
  50 #endif
  51
  52 #if 1
  53 #define DBGERR(x...)    printk(KERN_INFO x)
  54 #else
  55 #define DBGERR(x...)
  56 #endif
  57
  58 struct tca6424_chip {
  59         /*  the first extern gpio number in all of gpio groups */
  60         unsigned gpio_start;
  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];
  75
  76         #ifdef TCA6424_OUTREGLOCK
  77                 struct mutex outreglock;
  78         #endif
  79         #ifdef TCA6424_INPUTREGLOCK
  80                 struct mutex inputreglock;
  81         #endif
  82         #ifdef TCA6424_CONFIGREGLOCK
  83                 struct mutex configreglock;
  84         #endif
  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;
  90         char **names;
  91 };
  92
  93 static const struct i2c_device_id tca6424_id[] =
  94 {
  95     {"extend_gpio_tca6424",8,},
  96     { }
  97 };
  98 MODULE_DEVICE_TABLE(i2c, tca6424_id);
  99
 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 ²»½øÐÐ²Ù×÷
 105 } tca6424_access;
 106
 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;
 110
 111 static int tca6424_write_reg(struct i2c_client *client, uint8_t reg, uint8_t val)
 112 {
 113         int ret=-1;
 114         struct i2c_adapter *adap;
 115         struct i2c_msg msg;
 116         char tx_buf[2];
 117         if(!client)
 118                 return ret;
 119         adap = client->adapter;
 120         tx_buf[0] = reg;
 121         tx_buf[1]= val;
 122
 123         msg.addr = client->addr;
 124         msg.buf = tx_buf;
 125         msg.len = 1 +1;
 126         msg.flags = client->flags;
 127         msg.scl_rate = TCA6424_I2C_RATE;
 128
 129         ret = i2c_transfer(adap, &msg, 1);
 130         return ret;
 131 }
 132
 133 static int tca6424_read_reg(struct i2c_client *client, uint8_t reg, uint8_t *val)
 134 {
 135         int ret=-1;
 136     struct i2c_adapter *adap;
 137     struct i2c_msg msgs[2];
 138
 139     if(!client)
 140                 return ret;
 141     adap = client->adapter;
 142     //·¢ËÍ¼Ä´æÆ÷µØÖ·
 143     msgs[0].addr = client->addr;
 144     msgs[0].buf = &reg;
 145     msgs[0].flags = client->flags;
 146     msgs[0].len = 1;
 147     msgs[0].scl_rate = TCA6424_I2C_RATE;
 148     //½ÓÊÕÊý¾Ý
 149     msgs[1].buf = val;
 150     msgs[1].addr = client->addr;
 151     msgs[1].flags = client->flags | I2C_M_RD;
 152     msgs[1].len = 1;
 153     msgs[1].scl_rate = TCA6424_I2C_RATE;
 154
 155     ret = i2c_transfer(adap, msgs, 2);
 156     return ret;
 157
 158 }
 159
 160 static int tca6424_gpio_direction_input(struct gpio_chip *gc, uint8_t pin_num)
 161 {
 162         struct tca6424_chip *chip;
 163         uint8_t gpioPortNum;
 164         uint8_t gpioPortPinNum;
 165         uint8_t reg_val;
 166         uint8_t Regaddr;
 167         int ret = -1;
 168
 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]))
 173                 return ret;
 174         Regaddr = TCA6424_Config_Reg+gpioPortNum;
 175
 176         #ifdef TCA6424_CONFIGREGLOCK
 177         if (!mutex_trylock(&chip->configreglock))
 178         {
 179                 DBGERR("**%s[%d]Did not get the configreglock**\n",__FUNCTION__,__LINE__);
 180                 return ret;
 181         }
 182         #endif
 183
 184         reg_val = tca6424setbit(chip->reg_direction[gpioPortNum], gpioPortPinNum);
 185         ret = tca6424_write_reg(chip->client, Regaddr, reg_val);
 186         if(ret<0)
 187                 goto err;
 188
 189         chip->reg_direction[gpioPortNum] = reg_val;
 190 err:
 191
 192         DBG("**%s[%d],config_reg=%2x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
 193
 194         #ifdef TCA6424_CONFIGREGLOCK
 195         mutex_unlock(&chip->configreglock);
 196         #endif
 197
 198         return (ret<0)?-1:0;
 199 }
 200
 201 static int tca6424_gpio_direction_output(struct gpio_chip *gc,uint8_t pin_num, int val)
 202 {
 203         struct tca6424_chip *chip;
 204         uint8_t gpioPortNum;
 205         uint8_t gpioPortPinNum;
 206         uint8_t reg_val;
 207         uint8_t Regaddr;
 208         int ret = -1;
 209
 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]))
 214                 return ret;
 215         Regaddr = TCA6424_Config_Reg+gpioPortNum;
 216
 217         #ifdef TCA6424_CONFIGREGLOCK
 218         if (!mutex_trylock(&chip->configreglock))
 219         {
 220                 DBGERR("**%s[%d]Did not get the configreglock**\n",__FUNCTION__,__LINE__);
 221                 return -1;
 222         }
 223         #endif
 224         /* then direction */
 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);
 228         if(ret<0)
 229         {
 230                 #ifdef TCA6424_CONFIGREGLOCK
 231                 mutex_unlock(&chip->configreglock);
 232                 #endif
 233                 DBGERR("**%s[%d] set direction reg is error,reg_val=%x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
 234                 return ret;
 235         }
 236         chip->reg_direction[gpioPortNum] = reg_val;
 237         #ifdef TCA6424_CONFIGREGLOCK
 238         mutex_unlock(&chip->configreglock);
 239         #endif
 240     ret=-1;
 241     #ifdef TCA6424_OUTREGLOCK
 242         if (!mutex_trylock(&chip->outreglock))
 243         {
 244                 DBGERR("**%s[%d] Did not get the outreglock**\n",__FUNCTION__,__LINE__);
 245                 return ret;
 246         }
 247         #endif
 248         /* set output level */
 249         if (val)
 250                 reg_val = tca6424setbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
 251         else
 252                 reg_val = tca6424clearbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
 253
 254         Regaddr = TCA6424_OutputLevel_Reg+gpioPortNum;
 255         ret = tca6424_write_reg(chip->client, Regaddr, reg_val);
 256         if (ret<0)
 257         {
 258                 #ifdef TCA6424_OUTREGLOCK
 259                         mutex_unlock(&chip->outreglock);
 260                 #endif
 261                 DBGERR("**%s[%d] set out reg is error,reg_val=%x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
 262                 return ret;
 263         }
 264         chip->reg_output[gpioPortNum] = reg_val;
 265
 266         #ifdef TCA6424_OUTREGLOCK
 267                 mutex_unlock(&chip->outreglock);
 268         #endif
 269
 270         DBG("**%s[%d],output_reg=%2x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
 271     return (ret<0)?-1:0;
 272 }
 273
 274 static int tca6424_gpio_get_value(struct gpio_chip *gc, uint8_t pin_num)
 275 {
 276         struct tca6424_chip *chip;
 277         uint8_t gpioPortNum;
 278         uint8_t gpioPortPinNum;
 279         uint8_t reg_val;
 280         uint8_t Regaddr;
 281         int ret=-1;
 282
 283         chip = container_of(gc, struct tca6424_chip, gpio_chip);
 284         gpioPortNum = pin_num/8;
 285         gpioPortPinNum= pin_num%8;
 286
 287         if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 288                 return -1;
 289
 290         Regaddr = TCA6424_InputLevel_Reg+gpioPortNum;
 291
 292         if(!tca6424getbit(chip->reg_direction[gpioPortNum],gpioPortPinNum))  //ÅÐ¶Ï¸ÃpinÊÇ·ñÉèÖÃ³ÉÊä³ö
 293         {
 294                 DBG("**it is a output pin**\n");
 295                 return -1;
 296         }
 297         #ifdef TCA6424_INPUTREGLOCK
 298         if (!mutex_trylock(&chip->inputreglock))
 299         {
 300                 DBGERR("**%s[%d]Did not get the inputreglock**\n",__FUNCTION__,__LINE__);
 301                 return -1;
 302         }
 303         #endif
 304
 305         ret = tca6424_read_reg(chip->client, Regaddr, &reg_val);
 306         if (ret < 0)
 307                 goto err;
 308         chip->reg_input[gpioPortNum] = reg_val;
 309
 310 err:
 311         #ifdef TCA6424_CONFIGREGLOCK
 312                 mutex_unlock(&chip->inputreglock);
 313         #endif
 314         DBGERR("**%s[%d] input_reg=%2x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
 315
 316         return (ret < 0)?-1:((chip->reg_input[gpioPortNum] >> gpioPortPinNum) & 0x01);
 317 }
 318
 319 static void tca6424_gpio_set_value(struct gpio_chip *gc, uint8_t pin_num, int val)
 320 {
 321         struct tca6424_chip *chip;
 322         uint8_t gpioPortNum;
 323         uint8_t gpioPortPinNum;
 324         uint8_t reg_val;
 325         uint8_t Regaddr;
 326         int ret=-1;
 327         DBG("**run in the %s**\n",__FUNCTION__);
 328
 329         chip = container_of(gc, struct tca6424_chip, gpio_chip);
 330
 331         gpioPortNum = pin_num/8;
 332         gpioPortPinNum= pin_num%8;
 333
 334         if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 335                 return;// -1;
 336
 337         Regaddr = TCA6424_OutputLevel_Reg+gpioPortNum;
 338
 339         if(tca6424getbit(chip->reg_direction[gpioPortNum],gpioPortPinNum)) // input state
 340                 return;// -1;
 341
 342 #ifdef TCA6424_OUTREGLOCK
 343         if (!mutex_trylock(&chip->outreglock))
 344         {
 345                 DBGERR("**%s[%d] Did not get the outreglock**\n",__FUNCTION__,__LINE__);
 346                 return;// -1;
 347         }
 348 #endif
 349         if (val)
 350                 reg_val = tca6424setbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
 351         else
 352                 reg_val = tca6424clearbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
 353
 354         ret = tca6424_write_reg(chip->client, Regaddr, reg_val);
 355         if (ret<0)
 356                 goto err;
 357         chip->reg_output[gpioPortNum] = reg_val;
 358
 359 err:
 360         #ifdef TCA6424_OUTREGLOCK
 361                 mutex_unlock(&chip->outreglock);
 362         #endif
 363
 364         DBG("**%s[%d],output_reg=%2x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
 365         return;// (ret<0)?-1:0;
 366
 367 }
 368 static int tca6424_gpio_to_irq(struct gpio_chip *chip,unsigned offset)
 369 {
 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)))
 372         {
 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);
 376         }
 377         else
 378         {
 379                 return -1;
 380         }
 381 }
 382
 383 int tca6424_checkrange(int start,int num,int val)
 384 {
 385
 386         if((val<(start+num))&&(val>=start))
 387                 return 0;
 388         else return -1;
 389
 390 }
 391
 392 static void tca6424_gpio_irq_enable(unsigned irq)
 393 {
 394         struct irq_desc *desc = irq_to_desc(irq);
 395         //int gpiopinnum;
 396         struct tca6424_chip *pchip=(struct tca6424_chip *)desc->chip_data;
 397         //struct gpio_chip *chip_gpio;
 398         uint8_t gpio_num;
 399         uint8_t gpioPortNum;
 400         uint8_t gpioPortPinNum;
 401         uint8_t tca6424pinnum;
 402
 403
 404         if(!tca6424_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
 405         {
 406                 tca6424pinnum = irq-pchip->gpio_irq_start;
 407         }
 408         else
 409         {
 410                 return;
 411         }
 412         gpioPortNum = tca6424pinnum/8;
 413         gpioPortPinNum= tca6424pinnum%8;
 414         gpio_num=pchip->gpio_start+tca6424pinnum;
 415         if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 416                 return;
 417         DBG("**%s**\n",__FUNCTION__);
 418         pchip->interrupt_en[gpioPortNum]=tca6424setbit(pchip->interrupt_en[gpioPortNum],gpioPortPinNum);
 419 }
 420 static void tca6424_gpio_irq_disable(unsigned irq)
 421 {
 422         struct irq_desc *desc = irq_to_desc(irq);
 423         struct tca6424_chip *pchip=(struct tca6424_chip *)desc->chip_data;
 424         uint8_t gpioPortNum;
 425         uint8_t gpioPortPinNum;
 426         uint8_t tca6424pinnum;
 427
 428         if(!tca6424_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
 429         {
 430                 tca6424pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
 431         }
 432         else
 433         {
 434                 return;
 435         }
 436         gpioPortNum = tca6424pinnum/8;
 437         gpioPortPinNum= tca6424pinnum%8;
 438
 439         if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 440                 return;
 441         DBG("**%s**\n",__FUNCTION__);
 442
 443         pchip->interrupt_en[gpioPortNum]=tca6424clearbit(pchip->interrupt_en[gpioPortNum],gpioPortPinNum);
 444
 445 }
 446
 447
 448 static void tca6424_gpio_irq_mask(unsigned irq)
 449 {
 450         struct irq_desc *desc = irq_to_desc(irq);
 451         struct tca6424_chip *pchip=(struct tca6424_chip *)desc->chip_data;
 452         uint8_t gpioPortNum;
 453         uint8_t gpioPortPinNum;
 454         uint8_t tca6424pinnum;
 455
 456         if(!tca6424_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
 457         {
 458                 tca6424pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
 459         }
 460         else
 461         {
 462                 return;
 463         }
 464         gpioPortNum = tca6424pinnum/8;
 465         gpioPortPinNum= tca6424pinnum%8;
 466
 467         if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 468                 return;
 469
 470         DBG("**%s**\n",__FUNCTION__);
 471
 472         pchip->interrupt_mask[gpioPortNum]=tca6424setbit(pchip->interrupt_mask[gpioPortNum],gpioPortPinNum);
 473
 474 }
 475
 476 static void tca6424_gpio_irq_unmask(unsigned irq)
 477 {
 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;
 481         uint8_t gpioPortNum;
 482         uint8_t gpioPortPinNum;
 483         uint8_t tca6424pinnum;
 484
 485         DBG("**%s**\n",__FUNCTION__);
 486
 487     if(!tca6424_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
 488     {
 489                 tca6424pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
 490         }
 491         else
 492         {
 493                 return;
 494         }
 495         gpioPortNum = tca6424pinnum/8;
 496         gpioPortPinNum= tca6424pinnum%8;
 497
 498         if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 499                 return;
 500         pchip->interrupt_mask[gpioPortNum]=tca6424clearbit(pchip->interrupt_mask[gpioPortNum],gpioPortPinNum);
 501 }
 502
 503 static int tca6424_gpio_irq_type(unsigned int irq, unsigned int type)
 504 {
 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;
 508         int gpio_num;
 509         uint8_t gpioPortNum;
 510         uint8_t gpioPortPinNum;
 511         uint8_t tca6424pinnum;
 512         if(!tca6424_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
 513         {
 514                 tca6424pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
 515                 gpio_num=pchip->gpio_start+tca6424pinnum;
 516         }
 517         else
 518                 return -1;
 519
 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);
 523         switch (type) {
 524                 case IRQ_TYPE_NONE:
 525                         pchip->inttype_set[gpioPortNum]=tca6424clearbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
 526                         DBG("**%s IRQ_TYPE_NONE**\n",__FUNCTION__);
 527                         break;
 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]);
 533
 534                 break;
 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]);
 540
 541                 break;
 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]);
 546                 break;
 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");
 550                 break;
 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");
 554                 break;
 555                 default:
 556                 return -EINVAL;
 557         }
 558 return 0;
 559 }
 560
 561 static int tca6424_gpio_irq_set_wake(unsigned irq, unsigned state)
 562 {
 563     //no irq wake
 564         return 0;
 565
 566 }
 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,
 575 };
 576
 577
 578 static void tca6424_extend_gpio_irq_handler(struct work_struct *work)
 579 {
 580     struct tca6424_chip *pchip = container_of(work, struct tca6424_chip,tca6424_work);
 581         u8 tempintputreg[TCA6424_PortNum]={0,0,0};
 582         u8 tempallowint=0;
 583         u8 levelchg=0;
 584         u8 intbit=0;
 585         u8 tempinttype=0;
 586         int i,j;
 587         struct irq_desc *gpio_irq_desc;
 588         unsigned int irq;
 589         if(tca6424_read_reg(pchip->client,TCA6424_InputLevel_Reg,&tempintputreg[0])<0)
 590         {
 591
 592                 DBG("**%s[%d] reading reg is error\n",__FUNCTION__,__LINE__);
 593                 enable_irq(pchip->irq_chain);
 594                 return;
 595         }
 596         if(tca6424_read_reg(pchip->client,(TCA6424_InputLevel_Reg+1),&tempintputreg[1])<0)
 597         {
 598
 599                 DBG("**%s[%d] reading reg is error\n",__FUNCTION__,__LINE__);
 600                 enable_irq(pchip->irq_chain);
 601                 return;
 602         }
 603         if(tca6424_read_reg(pchip->client,(TCA6424_InputLevel_Reg+2),&tempintputreg[2])<0)
 604         {
 605
 606                 DBG("**%s[%d] reading reg is error\n",__FUNCTION__,__LINE__);
 607                 enable_irq(pchip->irq_chain);
 608                 return;
 609         }
 610         DBG("**has run at %s**\n",__FUNCTION__);
 611         if((pchip->interrupt_en[0]==0)&&(pchip->interrupt_en[1]==0)&&(pchip->interrupt_en[2]==0))
 612         {
 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);
 616                 return;
 617         }
 618
 619         for(i=0;i<TCA6424_PortNum;i++)
 620         {
 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´¥·¢
 624
 625             tempinttype=(~pchip->inttype1[i])&tempinttype;// inttype1 ÎªÕæµÄÎ»¶ÔÓ¦µÄtempinttypeÎ»ÇåÁã£¬ÒòÎª¸ÃÎ»Ö»ÊÜinttype1¿ØÖÆ
 626                 tempinttype|=pchip->inttype1[i];//µçÆ½Ö»ÒªÊÇ±ä»¯¾Í²úÉúÖÐ¶Ï
 627                 tempinttype&=pchip->inttype_set[i];//ÒÑ¾ÉèÖÃÁËtypeÀàÐÍ
 628
 629                 intbit=tempallowint&levelchg&tempinttype;
 630                 DBG(" tempallowint=%x,levelchg=%x,tempinttype=%x,intbit=%d\n",tempallowint,levelchg,tempinttype,intbit);
 631
 632                 if(intbit)
 633                 for(j=0;j<portnum[i];j++)
 634                 {
 635                         if(tca6424getbit(intbit,j))
 636                         {
 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
 643                         }
 644                 }
 645
 646                 pchip->reg_input[i]=tempintputreg[i];
 647
 648         }
 649         enable_irq(pchip->irq_chain);
 650         return;
 651 }
 652
 653 static irqreturn_t tca6424_gpio_irq_handler(int irq, void * dev_id)
 654 {
 655
 656         struct irq_desc *gpio_irq_desc = irq_to_desc(irq);
 657         struct tca6424_chip *pchip=(struct tca6424_chip *)gpio_irq_desc->chip_data;
 658
 659         DBG("******************%s*******************\n",__FUNCTION__);
 660         disable_irq_nosync(pchip->irq_chain);
 661     queue_work(tca6424workqueue,&pchip->tca6424_work);
 662         return IRQ_HANDLED;
 663 }
 664
 665
 666 static void tca6424_setup_gpio(struct tca6424_chip *chip, int gpios)
 667 {
 668     struct gpio_chip *gc;
 669
 670     gc = &chip->gpio_chip;
 671
 672     gc->direction_input  = tca6424_gpio_direction_input;
 673     gc->direction_output = tca6424_gpio_direction_output;
 674     gc->get = tca6424_gpio_get_value;
 675     gc->set = tca6424_gpio_set_value;
 676     gc->to_irq = tca6424_gpio_to_irq;
 677
 678     gc->can_sleep = 1;
 679
 680     gc->base = chip->gpio_start;
 681     gc->ngpio = chip->gpio_pin_num;
 682     gc->label = chip->client->name;
 683     gc->dev = &chip->client->dev;
 684     gc->owner = THIS_MODULE;
 685     gc->names = chip->names;
 686 }
 687
 688 static void tca6424_gpio_irq_setup(struct tca6424_chip *pchip)
 689 {
 690     unsigned        pioc, irq_num;
 691     int ret;
 692         int testprint1 = 0;
 693         int testprint2 = 0;
 694         struct irq_desc *desc;
 695     irq_num = pchip->gpio_irq_start;   //ÖÐ¶ÏºÅ£¬À©Õ¹ioµÄÖÐ¶ÏºÅÓ¦¸Ã½ô¸úÔÚÄÚ²¿ioÖÐ¶ÏºÅµÄºóÃæ¡£ÈçrkÄÚ²¿ÖÐ¶Ï48¸ö£¬¼ÓÉÏÄÚ²¿gpio 16¸öÐéÄâÖÐ¶Ï£¬ÕâÀïpinÓ¦¸Ã´Ó48+16¿ªÊ¼
 696
 697     for (pioc = 0; pioc < pchip->irq_pin_num; pioc++,irq_num++)
 698     {
 699         lockdep_set_class(&irq_desc[irq_num].lock, &gpio_lock_class);
 700          /*
 701          * Can use the "simple" and not "edge" handler since it's
 702          * shorter, and the AIC handles interrupts sanely.
 703         */
 704                 testprint1 = set_irq_chip(irq_num, &tca6424_gpio_irqchip);
 705                 set_irq_handler(irq_num, handle_simple_irq);
 706                 testprint2 =  set_irq_chip_data(irq_num,(void *)pchip);
 707                 desc = irq_to_desc(irq_num);
 708                 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);
 709                 set_irq_flags(irq_num, IRQF_VALID);
 710     }
 711         ret = gpio_request(pchip->irq_gpiopin,NULL);
 712         if(ret!=0)
 713         {
 714                 gpio_free(pchip->irq_gpiopin);
 715                 DBG("tca6424_gpio_irq_setup request gpio is err\n");
 716         }
 717
 718         gpio_pull_updown(pchip->irq_gpiopin, GPIOPullUp);        //gpio ÐèÒªÀ¸ßirq_to_gpio(pchip->irq_chain)
 719
 720 #if 0
 721
 722         set_irq_chip_data(pchip->irq_chain, pchip);
 723         set_irq_chained_handler(pchip->irq_chain, gpio_irq_handlerxxx);
 724         set_irq_type(pchip->irq_chain,IRQ_TYPE_LEVEL_LOW);
 725         enable_irq(pchip->irq_chain);
 726
 727 #else
 728         tca6424workqueue=create_workqueue("tca6424 workqueue");
 729         INIT_WORK(&pchip->tca6424_work,tca6424_extend_gpio_irq_handler);
 730
 731         set_irq_chip_data(pchip->irq_chain, pchip);
 732         if(request_irq(pchip->irq_chain,tca6424_gpio_irq_handler, IRQF_TRIGGER_LOW, "tca6424", pchip)!=0)
 733         {
 734                 DBG("**%s line=%d is err**\n",__FUNCTION__,__LINE__);
 735         }
 736
 737 #endif
 738 }
 739
 740 int tca6424_init_pintype(struct tca6424_chip *chip,struct i2c_client *client)
 741 {
 742     int i;
 743         struct tca6424_platform_data *platform_data=(struct tca6424_platform_data *)client->dev.platform_data;
 744         struct rk2818_gpio_expander_info *tca6424_gpio_settinginfo;
 745         uint8_t reg_output[TCA6424_PortNum]={0,0,0};
 746         uint8_t reg_direction[TCA6424_PortNum]={0,0,0};
 747         uint8_t tca6424_pin_num;
 748         uint8_t gpioPortNum;
 749         uint8_t gpioPortPinNum,tca6424_settingpin_num=0;
 750
 751         if(platform_data)
 752         {
 753                 tca6424_gpio_settinginfo=platform_data->settinginfo;
 754                 if(tca6424_gpio_settinginfo)
 755                 {
 756                         tca6424_settingpin_num=platform_data->settinginfolen;
 757                         for(i=0;i<tca6424_settingpin_num;i++)
 758                         {
 759                                 if(!tca6424_checkrange(chip->gpio_start,chip->gpio_pin_num,tca6424_gpio_settinginfo[i].gpio_num))
 760                                 {
 761                                         tca6424_pin_num=tca6424_gpio_settinginfo[i].gpio_num-chip->gpio_start;
 762                                         gpioPortNum = tca6424_pin_num/ TCA6424_PortPinNum;
 763                                         gpioPortPinNum= tca6424_pin_num% TCA6424_PortPinNum;
 764                                         //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]);
 765                                         if((gpioPortNum>=TCA6424_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 766                                                 continue;
 767                                         if(tca6424_gpio_settinginfo[i].pin_type==GPIO_IN)
 768                                         {
 769                                                 reg_direction[gpioPortNum]=tca6424setbit(reg_direction[gpioPortNum],gpioPortPinNum);
 770                                         }
 771                                         else
 772                                         {
 773                                                 reg_direction[gpioPortNum]=tca6424clearbit(reg_direction[gpioPortNum],gpioPortPinNum);
 774                                                 if(tca6424_gpio_settinginfo[i].pin_value==GPIO_HIGH)
 775                                                 {
 776                                                         reg_output[gpioPortNum]=tca6424setbit(reg_output[gpioPortNum],gpioPortPinNum);
 777                                                 }
 778                                                 else
 779                                                 {
 780                                                         reg_output[gpioPortNum]=tca6424clearbit(reg_output[gpioPortNum],gpioPortPinNum);
 781                                                 }
 782                                         }
 783
 784                                 }
 785                         }
 786                 }
 787         }
 788         #ifdef TCA6424_OUTREGLOCK
 789         mutex_init(&chip->outreglock);
 790     #endif
 791         #ifdef TCA6424_INPUTREGLOCK
 792         mutex_init(&chip->inputreglock);
 793         #endif
 794         #ifdef TCA6424_OUTREGLOCK
 795         mutex_init(&chip->configreglock);
 796         #endif
 797
 798         for(i=0; i<TCA6424_PortNum; i++)
 799         {
 800
 801                 if (tca6424_write_reg(client, (TCA6424_Config_Reg+i), reg_direction[i])<0)
 802                 {
 803                         DBGERR("*%s %d* write reg err\n",__FUNCTION__,__LINE__);
 804                         return -1;
 805                 }
 806                 chip->reg_direction[i]=reg_direction[i];
 807                 if (tca6424_write_reg(client, (TCA6424_OutputLevel_Reg+i), reg_output[i])<0)
 808                 {
 809                         DBGERR("*%s %d  write reg err*\n",__FUNCTION__,__LINE__);
 810                         return -1;
 811                 }
 812                 chip->reg_output[i]=reg_output[i];
 813
 814                 if (tca6424_write_reg(client, (TCA6424_Invert_Reg+i), 0)<0)             //make sure this reg be 0
 815                 {
 816                         DBGERR("*%s %d* write reg err\n",__FUNCTION__,__LINE__);
 817                         return -1;
 818                 }
 819
 820                 if(tca6424_read_reg(client, (TCA6424_InputLevel_Reg+i), &chip->reg_input[i])<0)
 821                 {
 822                         DBGERR("*%s %d  read reg err*\n",__FUNCTION__,__LINE__);
 823                         return -1;
 824                 }
 825                 //DBG("reg_direction=%x,reg_output=%x,reg_input=%x\n",chip->reg_direction[i],chip->reg_output[i],chip->reg_input[i]);
 826
 827         }
 828
 829         return 0;
 830 }
 831 void tca6424_reset_itr(void)
 832 {
 833         // udelay(1);
 834         //if(client->Channel==I2C_CH1)
 835         //{
 836                 //gpio_direction_output(RK2818_PIN_PE6,GPIO_HIGH);
 837                 //gpio_direction_output(RK2818_PIN_PE7,GPIO_LOW);
 838
 839                 //GPIOSetPinDirection(RK2818_PIN_PE6,GPIO_OUT);// data
 840                 //GPIOSetPinDirection(RK2818_PIN_PE7,GPIO_OUT);
 841
 842                 rk2818_mux_api_set(GPIOE_U1IR_I2C1_NAME, IOMUXA_GPIO1_A67);
 843                 udelay(3);
 844                 gpio_set_value(RK2818_PIN_PE7,GPIO_HIGH);
 845                 udelay(1);
 846                 rk2818_mux_api_set(GPIOE_U1IR_I2C1_NAME, IOMUXA_I2C1);
 847         //}
 848         /*else
 849         {
 850                 gpio_direction_output(RK2818_PIN_PE4,GPIO_HIGH);
 851                 gpio_direction_output(RK2818_PIN_PE5,GPIO_LOW);
 852
 853                 //GPIOSetPinDirection(RK2818_PIN_PE4,GPIO_OUT);// data
 854                 //GPIOSetPinDirection(RK2818_PIN_PE5,GPIO_OUT);
 855                 rk2818_mux_api_set(GPIOE_I2C0_SEL_NAME, IOMUXA_GPIO1_A45);
 856
 857                 udelay(3);
 858                 gpio_set_value(RK2818_PIN_PE5,GPIO_HIGH);
 859                 udelay(1);
 860
 861                 rk2818_mux_api_set(GPIOE_I2C0_SEL_NAME, IOMUXA_I2C0);
 862         }*/
 863 }
 864
 865 static int __devinit tca6424_probe(struct i2c_client *client,const struct i2c_device_id *id)
 866 {
 867         struct tca6424_chip *chip;
 868         struct tca6424_platform_data  *pdata;
 869         int ret;
 870         uint8_t val;
 871
 872         DBG(KERN_ALERT"*******gpio %s in %d line,dev adr is %x**\n",__FUNCTION__,__LINE__,client->addr);
 873         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 874                 return -EIO;
 875
 876         chip = kzalloc(sizeof(struct tca6424_chip), GFP_KERNEL);
 877         if (chip == NULL)
 878                 return -ENOMEM;
 879         pdata = client->dev.platform_data;
 880         if (pdata == NULL) {
 881                 DBGERR(" %s no platform data\n",__FUNCTION__);
 882                 ret = -EINVAL;
 883                 goto out_failed;
 884         }
 885
 886         chip->gpio_start = pdata->gpio_base;
 887         chip->gpio_irq_start =pdata->gpio_irq_start;
 888         chip->gpio_pin_num=pdata->gpio_pin_num;
 889         chip->irq_pin_num = pdata->irq_pin_num;
 890         chip->irq_gpiopin=pdata->tca6424_irq_pin;
 891         chip->irq_chain = gpio_to_irq(pdata->tca6424_irq_pin);
 892         chip->names =pdata->names;
 893
 894         //DBG("**%s in %d start=%d,irq_start=%d,pin_num=%d,irq_pin_num=%d,irq_gpiopin=%d,irq_chain=%d,**\n",
 895         //      __FUNCTION__,__LINE__,chip->gpio_start,chip->gpio_irq_start,chip->gpio_pin_num,chip->irq_pin_num,chip->irq_gpiopin
 896         //      ,chip->irq_chain);
 897
 898         /* initialize cached registers from their original values.
 899         * we can't share this chip with another i2c master.
 900         */
 901         tca6424_setup_gpio(chip, id->driver_data);
 902         ret = gpiochip_add(&chip->gpio_chip);
 903         if (ret)
 904         goto out_failed;
 905
 906         if(tca6424_init_pintype(chip,client))
 907                 goto out_failed;
 908
 909         if (pdata->setup) {
 910                 ret = pdata->setup(client, chip->gpio_chip.base,
 911                                 chip->gpio_chip.ngpio, pdata->context);
 912                 if (ret < 0)
 913                         DBGERR(" %s setup failed, %d\n",__FUNCTION__,ret);
 914         }
 915
 916         tca6424_gpio_irq_setup(chip);
 917         i2c_set_clientdata(client, chip);
 918         chip->client = client;
 919         return 0;
 920
 921 out_failed:
 922
 923         kfree(chip);
 924     return 0;
 925 }
 926
 927 static int tca6424_remove(struct i2c_client *client)
 928 {
 929         struct tca6424_platform_data *pdata = client->dev.platform_data;
 930         struct tca6424_chip *chip = i2c_get_clientdata(client);
 931         int ret = 0;
 932
 933         if (pdata->teardown) {
 934                 ret = pdata->teardown(client, chip->gpio_chip.base,
 935                 chip->gpio_chip.ngpio, pdata->context);
 936                 if (ret < 0) {
 937                         DBGERR(" %s failed, %d\n",__FUNCTION__,ret);
 938                         return ret;
 939                 }
 940         }
 941
 942         ret = gpiochip_remove(&chip->gpio_chip);
 943         if (ret) {
 944                 dev_err(&client->dev, "%s failed, %d\n",
 945                 "gpiochip_remove()", ret);
 946                 return ret;
 947         }
 948         kfree(chip);
 949         return 0;
 950 }
 951
 952
 953 static struct i2c_driver tca6424_driver = {
 954     .driver = {
 955                 .owner  = THIS_MODULE,
 956         .name   = "extend_gpio_tca6424",
 957     },
 958     .probe      = tca6424_probe,
 959     .remove     = tca6424_remove,
 960     .id_table   = tca6424_id,
 961 };
 962
 963
 964 static int __init tca6424_init(void)
 965 {
 966         int tmp;
 967         DBG(KERN_ALERT"**********tca6424_init**********\n");
 968         tmp=i2c_add_driver(&tca6424_driver);
 969         return 0;
 970 }
 971 static void __exit tca6424_exit(void)
 972 {
 973     DBG(KERN_ALERT"**********tca6424_exit**********\n");
 974         i2c_del_driver(&tca6424_driver);
 975 }
 976
 977 module_init(tca6424_init);
 978 module_exit(tca6424_exit);
 979
 980 MODULE_AUTHOR(" XXX  XXX@rock-chips.com");
 981 MODULE_DESCRIPTION("Driver for rk2818 tca6424 device");
 982 MODULE_LICENSE("GPL");
 983