drivers/gpio/pca9554.c

   1 /* arch/arm/mach-rk2818/example.c
   2  *
   3  * Copyright (C) 2010 ROCKCHIP, Inc.
   4  *
   5  * This software is licensed under the terms of the GNU General Public
   6  * License version 2, as published by the Free Software Foundation, and
   7  * may be copied, distributed, and modified under those terms.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  */
  15 /*******************************************************************/
  16 /*        COPYRIGHT (C)  ROCK-CHIPS FUZHOU . ALL RIGHTS RESERVED.                         */
  17 /*******************************************************************
  18 FILE            :         PCA9554.C
  19 DESC            :         À©Õ¹GPIO µÄÇý¶¯Ïà¹Ø³ÌÐò
  20 AUTHOR          :         ZHONGYW
  21 DATE            :         2009-4-26
  22 NOTES           :
  23 $LOG: GPIO.C,V $
  24 REVISION 0.01
  25 ********************************************************************/
  26 #include <linux/clk.h>
  27 #include <linux/errno.h>
  28 #include <linux/interrupt.h>
  29 #include <asm/mach-types.h>
  30 #include <linux/irq.h>
  31 #include <linux/debugfs.h>
  32 #include <linux/seq_file.h>
  33 #include <linux/kernel.h>
  34 #include <linux/list.h>
  35 #include <linux/module.h>
  36 #include <linux/io.h>
  37 #include <mach/hardware.h>
  38 #include <mach/gpio.h>
  39 #include <mach/rk2818_iomap.h>
  40 #include <mach/iomux.h>
  41 #include <linux/device.h>
  42 #include <mach/gpio.h>
  43 #include <asm/gpio.h>
  44 #include <linux/i2c.h>
  45 #include <linux/workqueue.h>
  46 #include <mach/board.h>
  47 #define PCA9554_GPIO_IRQNum 8
  48 #define PCA9554_PortNum 1
  49 #define PCA9554_PortPinNum 8
  50 #define PCA9554_TotalPortPinNum (PCA9554_PortNum*PCA9554_PortPinNum)
  51
  52 #define PCA9554_InputLevel_Reg 0x0   //r only
  53 #define PCA9554_OutputLevel_Reg 0x1 // r/w  default ffff
  54 #define PCA9554_Invert_Reg 0x2  // r/w  default 0
  55 #define PCA9554_Config_Reg 0x3 // r/w  default ffff
  56
  57 //#define PCA9554_INPUT_REG_IRQ_PIN  RK2818_PIN_PE2
  58
  59 #define PCA9554_OUTREGLOCK
  60 #define PCA9554_INPUTREGLOCK
  61 #define PCA9554_CONFIGREGLOCK
  62
  63 struct pca9554_chip {
  64         /*  the first extern gpio number in all of gpio groups */
  65         unsigned gpio_start;
  66         unsigned        gpio_pin_num;
  67                 /*  the first gpio irq  number in all of irq source */
  68
  69         unsigned gpio_irq_start;
  70         unsigned irq_pin_num;        //ÖÐ¶ÏµÄ¸öÊý
  71         unsigned irq_gpiopin;            //¸¸ÖÐ¶ÏµÄÖÐ¶ÏºÅ
  72         unsigned irq_chain;            //¸¸ÖÐ¶ÏµÄÖÐ¶ÏºÅ
  73         uint8_t reg_input[PCA9554_PortNum];
  74         uint8_t reg_output[PCA9554_PortNum];
  75         uint8_t reg_direction[PCA9554_PortNum];
  76         uint8_t interrupt_en[PCA9554_PortNum];// 0 dis
  77         uint8_t interrupt_mask[PCA9554_PortNum];// 0 unmask
  78         uint8_t inttype_set[PCA9554_PortNum]; // Inttype  enable
  79         uint8_t inttype[PCA9554_PortNum]; //
  80         uint8_t inttype1[PCA9554_PortNum];
  81
  82
  83 #ifdef PCA9554_OUTREGLOCK
  84         struct mutex outreglock;
  85 #endif
  86 #ifdef PCA9554_INPUTREGLOCK
  87         struct mutex inputreglock;
  88 #endif
  89 #ifdef PCA9554_CONFIGREGLOCK
  90         struct mutex configreglock;
  91 #endif
  92
  93         struct i2c_client *client;
  94         struct pca9554_platform_data *dyn_pdata;
  95         struct work_struct pca9554_work;
  96
  97         struct gpio_chip gpio_chip;
  98
  99         char **names;
 100 };
 101
 102
 103 #if 0
 104 #define DBG(x...)       printk(KERN_INFO x)
 105 #else
 106 #define DBG(x...)
 107 #endif
 108
 109 #if 1
 110 #define DBGERR(x...)    printk(KERN_INFO x)
 111 #else
 112 #define DBGERR(x...)
 113 #endif
 114
 115
 116 struct i2c_client *pca9554_client;
 117 #define pca9554getbit(a,num) (((a)>>(num))&0x01)
 118 #define pca9554setbit(a,num) ((a)|(0x01<<(num)))
 119 #define pca9554clearbit(a,num) ((a)&(~(0x01<<(num))))
 120
 121 static short int portnum[PCA9554_PortNum]={PCA9554_PortPinNum};
 122 extern inline struct gpio_chip *gpio_to_chip(unsigned gpio);
 123 extern struct lock_class_key gpio_lock_class;
 124 extern struct lock_class_key gpio_lock_class;
 125 struct workqueue_struct *pca9554workqueue;
 126
 127 static const struct i2c_device_id pca9554_id[] =
 128 {
 129      { "extend_gpio_pca9554", 8, },
 130     { }
 131 };
 132
 133 MODULE_DEVICE_TABLE(i2c, pca9554_id);
 134
 135
 136 static int pca9554_write_reg(struct i2c_client *client, uint8_t reg, uint8_t val)
 137 {
 138         int ret=-1;
 139
 140         struct i2c_adapter *adap;
 141         struct i2c_msg msg;
 142         char tx_buf[2];
 143         if(!client)
 144                 return ret;
 145         adap = client->adapter;
 146         tx_buf[0] = reg;
 147         tx_buf[1]=val;
 148
 149         msg.addr = client->addr;
 150         msg.buf = &tx_buf[0];
 151         msg.len = 1 +1;
 152         msg.flags = client->flags;
 153         msg.scl_rate = 200*1000;
 154
 155         ret = i2c_transfer(adap, &msg, 1);
 156         return ret;
 157 }
 158
 159 static int pca9554_read_reg(struct i2c_client *client, uint8_t reg, uint8_t *val)
 160 {
 161
 162   int ret;
 163     struct i2c_adapter *adap;
 164     struct i2c_msg msgs[2];
 165     if(!client)
 166         return ret;
 167     adap = client->adapter;
 168     //·¢ËÍ¼Ä´æÆ÷µØÖ·
 169     msgs[0].addr = client->addr;
 170     msgs[0].buf = &reg;
 171     msgs[0].flags = client->flags;
 172     msgs[0].len = 1;
 173     msgs[0].scl_rate = 200*1000;
 174     //½ÓÊÕÊý¾Ý
 175     msgs[1].buf = val;
 176     msgs[1].addr = client->addr;
 177     msgs[1].flags = client->flags | I2C_M_RD;
 178     msgs[1].len = 1;
 179     msgs[1].scl_rate = 200*1000;
 180
 181     ret = i2c_transfer(adap, msgs, 2);
 182     //DBG("**has run at %s %d ret=%d**\n",__FUNCTION__,__LINE__,ret);
 183
 184     return ret;
 185 }
 186
 187 static int pca9554_gpio_direction_input(struct gpio_chip *gc, unsigned off)
 188 {
 189         struct pca9554_chip *chip;
 190
 191         uint8_t gpioPortNum;
 192         uint8_t gpioPortPinNum;
 193         uint8_t reg_val;
 194         int ret=-1;
 195         DBG("**run in the %s**\n",__FUNCTION__);
 196         chip = container_of(gc, struct pca9554_chip, gpio_chip);
 197
 198         gpioPortNum = off/8;
 199         gpioPortPinNum= off%8;
 200         if((gpioPortNum>=PCA9554_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 201                 return ret;
 202
 203 #ifdef PCA9554_CONFIGREGLOCK
 204         if (!mutex_trylock(&chip->configreglock))
 205         {
 206                 DBGERR("**%s[%d]Did not get the configreglock**\n",__FUNCTION__,__LINE__);
 207                 return ret;
 208         }
 209 #endif
 210
 211         reg_val = pca9554setbit(chip->reg_direction[gpioPortNum], gpioPortPinNum);
 212         ret = pca9554_write_reg(chip->client, PCA9554_Config_Reg, reg_val);
 213         if(ret<0)
 214                 goto err;
 215
 216         chip->reg_direction[gpioPortNum] = reg_val;
 217 err:
 218
 219         DBG("**%s[%d],reg_val=%x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
 220
 221         #ifdef PCA9554_CONFIGREGLOCK
 222         mutex_unlock(&chip->configreglock);
 223         #endif
 224
 225         return (ret<0)?-1:0;
 226 }
 227
 228 static int pca9554_gpio_direction_output(struct gpio_chip *gc,unsigned off, int val)
 229 {
 230         struct pca9554_chip *chip;
 231         uint8_t gpioPortNum;
 232         uint8_t gpioPortPinNum;
 233         uint8_t reg_val;
 234         int ret=-1;
 235         DBG("**run in the %s**\n",__FUNCTION__);
 236
 237         chip = container_of(gc, struct pca9554_chip, gpio_chip);
 238
 239         gpioPortNum = off/8;
 240         gpioPortPinNum= off%8;
 241         if((gpioPortNum>=PCA9554_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 242         return ret;
 243
 244         #ifdef PCA9554_CONFIGREGLOCK
 245         if (!mutex_trylock(&chip->configreglock))
 246         {
 247                 DBGERR("**%s[%d]Did not get the configreglock**\n",__FUNCTION__,__LINE__);
 248                 return -1;
 249         }
 250         #endif
 251         /* then direction */
 252         reg_val = pca9554clearbit(chip->reg_direction[gpioPortNum], gpioPortPinNum);
 253         ret = pca9554_write_reg(chip->client, PCA9554_Config_Reg, reg_val);
 254         if(ret<0)
 255         {
 256                 #ifdef PCA9554_CONFIGREGLOCK
 257                 mutex_unlock(&chip->configreglock);
 258                 #endif
 259                 DBGERR("**%s[%d] set direction reg is error,reg_val=%x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
 260                 return ret;
 261         }
 262         chip->reg_direction[gpioPortNum] = reg_val;
 263 #ifdef PCA9554_CONFIGREGLOCK
 264         mutex_unlock(&chip->configreglock);
 265 #endif
 266     ret=-1;
 267     #ifdef PCA9554_OUTREGLOCK
 268         if (!mutex_trylock(&chip->outreglock))
 269         {
 270                 DBGERR("**%s[%d] Did not get the outreglock**\n",__FUNCTION__,__LINE__);
 271                 return ret;
 272         }
 273         #endif
 274         /* set output level */
 275         if (val)
 276                 reg_val = pca9554setbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
 277         else
 278                 reg_val = pca9554clearbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
 279
 280         ret = pca9554_write_reg(chip->client, PCA9554_OutputLevel_Reg, reg_val);
 281         if (ret<0)
 282         {
 283         #ifdef PCA9554_OUTREGLOCK
 284                 mutex_unlock(&chip->outreglock);
 285         #endif
 286                 DBGERR("**%s[%d] set out reg is error,reg_val=%x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
 287                 return ret;
 288         }
 289         chip->reg_output[gpioPortNum] = reg_val;
 290
 291         #ifdef PCA9554_OUTREGLOCK
 292                 mutex_unlock(&chip->outreglock);
 293         #endif
 294     return (ret<0)?-1:0;
 295 }
 296
 297 static int pca9554_gpio_get_value(struct gpio_chip *gc, unsigned off)
 298 {
 299         struct pca9554_chip *chip;
 300         uint8_t gpioPortNum;
 301         uint8_t gpioPortPinNum;
 302         uint8_t reg_val;
 303         int ret=-1;
 304         DBG("**run in the %s**\n",__FUNCTION__);
 305
 306         chip = container_of(gc, struct pca9554_chip, gpio_chip);
 307         gpioPortNum = off/8;
 308         gpioPortPinNum= off%8;
 309
 310         if((gpioPortNum>=PCA9554_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 311                 return -1;
 312
 313         if(!pca9554getbit(chip->reg_direction[gpioPortNum],gpioPortPinNum))  //ÅÐ¶Ï¸ÃpinÊÇ·ñÉèÖÃ³Éinput
 314                 return -1;
 315 #ifdef PCA9554_INPUTREGLOCK
 316         if (!mutex_trylock(&chip->inputreglock))
 317         {
 318                 DBGERR("**%s[%d]Did not get the inputreglock**\n",__FUNCTION__,__LINE__);
 319                 return -1;
 320         }
 321 #endif
 322
 323         ret = pca9554_read_reg(chip->client, PCA9554_InputLevel_Reg, &reg_val);
 324         if (ret < 0)
 325                 goto err;
 326         chip->reg_input[gpioPortNum] = reg_val;
 327 err:
 328 #ifdef PCA9554_CONFIGREGLOCK
 329         mutex_unlock(&chip->inputreglock);
 330 #endif
 331         DBGERR("**%s[%d]reg_val=%x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
 332
 333         return (ret < 0)?-1:((chip->reg_input[gpioPortNum] >> gpioPortPinNum) & 0x01);
 334 }
 335
 336 static void pca9554_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
 337 {
 338         struct pca9554_chip *chip;
 339         uint8_t gpioPortNum;
 340         uint8_t gpioPortPinNum;
 341         uint8_t reg_val;
 342         int ret=-1;
 343         DBG("**run in the %s**\n",__FUNCTION__);
 344
 345         chip = container_of(gc, struct pca9554_chip, gpio_chip);
 346
 347         gpioPortNum = off/8;
 348         gpioPortPinNum= off%8;
 349
 350         if((gpioPortNum>=PCA9554_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 351         return;// -1;
 352
 353         if(pca9554getbit(chip->reg_direction[gpioPortNum],gpioPortPinNum)) // input state
 354                 return;// -1;
 355
 356 #ifdef PCA9554_OUTREGLOCK
 357         if (!mutex_trylock(&chip->outreglock))
 358         {
 359                 DBGERR("**%s[%d] Did not get the outreglock**\n",__FUNCTION__,__LINE__);
 360                 return;// -1;
 361         }
 362 #endif
 363         if (val)
 364                 reg_val = pca9554setbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
 365         else
 366                 reg_val = pca9554clearbit(chip->reg_output[gpioPortNum], gpioPortPinNum);
 367
 368         ret = pca9554_write_reg(chip->client, PCA9554_OutputLevel_Reg, reg_val);
 369         if (ret<0)
 370                 goto err;
 371         chip->reg_output[gpioPortNum] = reg_val;
 372 err:
 373         #ifdef PCA9554_OUTREGLOCK
 374                 mutex_unlock(&chip->outreglock);
 375         #endif
 376
 377         DBG("**%s[%d],reg_val=%x,ret=%d**\n",__FUNCTION__,__LINE__,reg_val,ret);
 378
 379         return;// (ret<0)?-1:0;
 380
 381 }
 382 static int pca9554_gpio_to_irq(struct gpio_chip *chip,unsigned offset)
 383 {
 384         struct pca9554_chip *pca_chip = container_of(chip, struct pca9554_chip, gpio_chip);
 385         if(((pca_chip->gpio_start+offset)>=chip->base)&&((pca_chip->gpio_start+offset)<(chip->base+chip->ngpio)))
 386         {
 387         //DBG("**%s,offset=%d,gpio_irq_start=%d,base=%d,ngpio=%d,gpio_irq_start=%d**\n",
 388         //      __FUNCTION__,offset,pca_chip->gpio_irq_start,chip->base,chip->ngpio,pca_chip->gpio_irq_start);
 389         return (offset+pca_chip->gpio_irq_start);
 390         }
 391         else
 392                 return -1;
 393 }
 394 static void pca9554_setup_gpio(struct pca9554_chip *chip, int gpios)
 395 {
 396     struct gpio_chip *gc;
 397
 398     gc = &chip->gpio_chip;
 399
 400     gc->direction_input  = pca9554_gpio_direction_input;
 401     gc->direction_output = pca9554_gpio_direction_output;
 402     gc->get = pca9554_gpio_get_value;
 403     gc->set = pca9554_gpio_set_value;
 404     gc->to_irq =pca9554_gpio_to_irq;
 405
 406     gc->can_sleep = 1;
 407
 408     gc->base = chip->gpio_start;
 409     gc->ngpio = chip->gpio_pin_num;
 410     gc->label = chip->client->name;
 411     gc->dev = &chip->client->dev;
 412     gc->owner = THIS_MODULE;
 413     gc->names = chip->names;
 414 }
 415
 416 int pca9554_checkrange(int start,int num,int val)
 417 {
 418
 419         if((val<(start+num))&&(val>=start))
 420                 return 0;
 421         else return -1;
 422
 423 }
 424 static void pca9554_gpio_irq_enable(unsigned irq)
 425 {
 426         struct irq_desc *desc = irq_to_desc(irq);
 427         //int gpiopinnum;
 428         struct pca9554_chip *pchip=(struct pca9554_chip *)desc->chip_data;
 429         //struct gpio_chip *chip_gpio;
 430         unsigned gpio_num;
 431
 432         uint8_t gpioPortNum;
 433         uint8_t gpioPortPinNum;
 434         uint8_t pca9554pinnum;
 435
 436
 437         if(!pca9554_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
 438         {
 439                 pca9554pinnum=irq-pchip->gpio_irq_start;
 440         }
 441          else return;
 442         gpioPortNum = pca9554pinnum/8;
 443         gpioPortPinNum= pca9554pinnum%8;
 444         gpio_num=pchip->gpio_start+pca9554pinnum;
 445         if((gpioPortNum>=PCA9554_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 446                 return;
 447         DBG("**%s**\n",__FUNCTION__);
 448         pchip->interrupt_en[gpioPortNum]=pca9554setbit(pchip->interrupt_en[gpioPortNum],gpioPortPinNum);
 449 }
 450 static void pca9554_gpio_irq_disable(unsigned irq)
 451 {
 452         struct irq_desc *desc = irq_to_desc(irq);
 453         struct pca9554_chip *pchip=(struct pca9554_chip *)desc->chip_data;
 454         uint8_t gpioPortNum;
 455         uint8_t gpioPortPinNum;
 456         uint8_t pca9554pinnum;
 457
 458
 459         if(!pca9554_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
 460         {
 461                 pca9554pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
 462         }
 463         else return;
 464         gpioPortNum = pca9554pinnum/8;
 465         gpioPortPinNum= pca9554pinnum%8;
 466
 467         if((gpioPortNum>=PCA9554_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 468                 return;
 469         DBG("**%s**\n",__FUNCTION__);
 470
 471         pchip->interrupt_en[gpioPortNum]=pca9554clearbit(pchip->interrupt_en[gpioPortNum],gpioPortPinNum);
 472
 473 }
 474
 475
 476 static void pca9554_gpio_irq_mask(unsigned irq)
 477 {
 478         struct irq_desc *desc = irq_to_desc(irq);
 479         struct pca9554_chip *pchip=(struct pca9554_chip *)desc->chip_data;
 480         uint8_t gpioPortNum;
 481         uint8_t gpioPortPinNum;
 482         uint8_t pca9554pinnum;
 483
 484
 485         if(!pca9554_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
 486         {
 487                 pca9554pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
 488         }
 489         else return;
 490         gpioPortNum = pca9554pinnum/8;
 491         gpioPortPinNum= pca9554pinnum%8;
 492
 493         if((gpioPortNum>=PCA9554_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 494                 return;
 495
 496         DBG("**%s**\n",__FUNCTION__);
 497
 498         pchip->interrupt_mask[gpioPortNum]=pca9554setbit(pchip->interrupt_mask[gpioPortNum],gpioPortPinNum);
 499
 500 }
 501
 502 static void pca9554_gpio_irq_unmask(unsigned irq)
 503 {
 504         struct irq_desc *desc = irq_to_desc(irq);
 505         //int gpiopinnum;//=irq_to_gpio(irq);
 506         struct pca9554_chip *pchip=(struct pca9554_chip *)desc->chip_data;
 507         uint8_t gpioPortNum;
 508         uint8_t gpioPortPinNum;
 509         uint8_t pca9554pinnum;
 510
 511         DBG("**%s**\n",__FUNCTION__);
 512
 513      if(!pca9554_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
 514         {
 515                 pca9554pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
 516         }
 517          else return;
 518         gpioPortNum = pca9554pinnum/8;
 519         gpioPortPinNum= pca9554pinnum%8;
 520
 521         if((gpioPortNum>=PCA9554_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 522                 return;
 523
 524
 525         pchip->interrupt_mask[gpioPortNum]=pca9554clearbit(pchip->interrupt_mask[gpioPortNum],gpioPortPinNum);
 526 }
 527
 528 static int pca9554_gpio_irq_type(unsigned int irq, unsigned int type)
 529 {
 530         struct irq_desc *desc_irq=irq_to_desc(irq);
 531         struct pca9554_chip *pchip=(struct pca9554_chip *)desc_irq->chip_data;
 532         //struct gpio_chip *chip_gpio;
 533         int gpio_num;
 534         uint8_t gpioPortNum;
 535         uint8_t gpioPortPinNum;
 536         uint8_t pca9554pinnum;
 537         if(!pca9554_checkrange(pchip->gpio_irq_start,pchip->irq_pin_num,irq))
 538         {
 539                 pca9554pinnum=irq-pchip->gpio_irq_start;//irq_to_gpio(irq)
 540                 gpio_num=pchip->gpio_start+pca9554pinnum;
 541         }
 542         else
 543                 return -1;
 544
 545         gpioPortNum = pca9554pinnum/8;
 546         gpioPortPinNum= pca9554pinnum%8;
 547          //DBG("**%s %d gpio_num=%d,PortNum=%d,PortPinNum=%d**\n",__FUNCTION__,__LINE__,gpio_num,gpioPortNum,gpioPortPinNum);
 548         switch (type) {
 549                 case IRQ_TYPE_NONE:
 550                         pchip->inttype_set[gpioPortNum]=pca9554clearbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
 551                         DBG("**%s IRQ_TYPE_NONE**\n",__FUNCTION__);
 552                         break;
 553                 case IRQ_TYPE_EDGE_RISING:
 554                         pchip->inttype_set[gpioPortNum]=pca9554setbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
 555                         pchip->inttype[gpioPortNum]=pca9554setbit(pchip->inttype[gpioPortNum],gpioPortPinNum);
 556                         pchip->inttype1[gpioPortNum]=pca9554clearbit(pchip->inttype1[gpioPortNum],gpioPortPinNum);
 557                         DBG("**%s IRQ_TYPE_EDGE_RISING,inttype=%x,inttype1=%x**\n",__FUNCTION__,pchip->inttype[gpioPortNum],pchip->inttype1[gpioPortNum]);
 558
 559                 break;
 560                 case IRQ_TYPE_EDGE_FALLING:
 561                         pchip->inttype_set[gpioPortNum]=pca9554setbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
 562                         pchip->inttype[gpioPortNum]=pca9554clearbit(pchip->inttype[gpioPortNum],gpioPortPinNum);
 563                         pchip->inttype1[gpioPortNum]=pca9554clearbit(pchip->inttype1[gpioPortNum],gpioPortPinNum);
 564                         DBG("**%s IRQ_TYPE_EDGE_RISING,inttype=%x,inttype1=%x**\n",__FUNCTION__,pchip->inttype[gpioPortNum],pchip->inttype1[gpioPortNum]);
 565
 566                 break;
 567                 case IRQ_TYPE_EDGE_BOTH:
 568                         pchip->inttype_set[gpioPortNum]=pca9554setbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
 569                         pchip->inttype1[gpioPortNum]=pca9554setbit(pchip->inttype1[gpioPortNum],gpioPortPinNum);
 570                         DBG("**%s IRQ_TYPE_EDGE_RISING,inttype=%x,inttype1=%x**\n",__FUNCTION__,pchip->inttype[gpioPortNum],pchip->inttype1[gpioPortNum]);
 571                 break;
 572                 case IRQ_TYPE_LEVEL_HIGH:
 573                         pchip->inttype_set[gpioPortNum]=pca9554clearbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
 574                         DBG("extern gpios does not support IRQ_TYPE_LEVEL_HIGH irq typ");
 575                 break;
 576                 case IRQ_TYPE_LEVEL_LOW:
 577                         pchip->inttype_set[gpioPortNum]=pca9554clearbit(pchip->inttype_set[gpioPortNum],gpioPortPinNum);
 578                         DBG("extern gpios does not support IRQ_TYPE_LEVEL_LOW irq typ");
 579                 break;
 580                 default:
 581                 return -EINVAL;
 582         }
 583 return 0;
 584 }
 585
 586 static int pca9554_gpio_irq_set_wake(unsigned irq, unsigned state)
 587 {
 588        //no irq wake
 589         return 0;
 590
 591 }
 592 static struct irq_chip pca9554_gpio_irqchip = {
 593         .name           = "GPIO_EXT",
 594         .enable                 = pca9554_gpio_irq_enable,
 595         .disable                = pca9554_gpio_irq_disable,
 596         .mask           = pca9554_gpio_irq_mask,
 597         .unmask         = pca9554_gpio_irq_unmask,
 598         .set_type       = pca9554_gpio_irq_type,
 599         .set_wake       = pca9554_gpio_irq_set_wake,
 600 };
 601
 602 static void pca9554_extend_gpio_irq_handler(struct work_struct *work)
 603 {
 604         struct pca9554_chip *pchip=container_of(work, struct pca9554_chip,pca9554_work);
 605         u8 tempintputreg[PCA9554_PortNum]={0};
 606         u8 tempallowint=0;
 607         u8 levelchg=0;
 608         u8 intbit=0;
 609         u8 tempinttype=0;
 610         int i,j;
 611         struct irq_desc *gpio_irq_desc;
 612         unsigned int irq;
 613         if(pca9554_read_reg(pchip->client,PCA9554_InputLevel_Reg,&tempintputreg[0])<0)
 614         {
 615
 616                 DBG("**%s[%d] reading reg is error\n",__FUNCTION__,__LINE__);
 617                 enable_irq(pchip->irq_chain);
 618                 return;
 619         }
 620
 621         DBG("**has run at %s,intputreg=%x**\n",__FUNCTION__,tempintputreg[0]);
 622         if((pchip->interrupt_en[0]==0))
 623         {
 624                 memcpy(&pchip->reg_input[0],&tempintputreg[0],sizeof(tempintputreg));
 625                 DBGERR("there are no pin reg irq\n");
 626                 enable_irq(pchip->irq_chain);
 627                 return;
 628         }
 629
 630         for(i=0;i<PCA9554_PortNum;i++)
 631         {
 632                 tempallowint=pchip->interrupt_en[i]&pchip->reg_direction[i]&(~pchip->interrupt_mask[i]);// Âú×ãÖÐ¶ÏÌõ¼þ
 633                 levelchg=pchip->reg_input[i]^tempintputreg[i];// ÕÒ³öÇ°ºó×´Ì¬²»Ò»ÑùµÄpin
 634                 tempinttype=~(tempintputreg[i]^pchip->inttype[i]);// ÕÒ³ö´¥·¢×´Ì¬ºÍµ±Ç°pin×´Ì¬Ò»ÑùµÄpin£¬×¢ÒâÖ»Ö§³Ölow highÁ½ÖÖpin´¥·¢
 635
 636                tempinttype=(~pchip->inttype1[i])&tempinttype;// inttype1 ÎªÕæµÄÎ»¶ÔÓ¦µÄtempinttypeÎ»ÇåÁã£¬ÒòÎª¸ÃÎ»Ö»ÊÜinttype1¿ØÖÆ
 637                 tempinttype|=pchip->inttype1[i];//µçÆ½Ö»ÒªÊÇ±ä»¯¾Í²úÉúÖÐ¶Ï
 638                 tempinttype&=pchip->inttype_set[i];//ÒÑ¾ÉèÖÃÁËtypeÀàÐÍ
 639
 640                 intbit=tempallowint&levelchg&tempinttype;
 641                 //DBG(" tempallowint=%x,levelchg=%x,tempinttype=%x,intbit=%d\n",tempallowint,levelchg,tempinttype,intbit);
 642
 643                 if(intbit)
 644                 for(j=0;j<portnum[i];j++)
 645                 {
 646                         if(pca9554getbit(intbit,j))
 647                         {
 648                                 irq=pchip->gpio_irq_start+PCA9554_PortPinNum*i+j;
 649                                 gpio_irq_desc = irq_to_desc(irq);
 650                                 gpio_irq_desc->chip->mask(irq);
 651                                 generic_handle_irq(irq);
 652                                 gpio_irq_desc->chip->unmask(irq);
 653
 654                         }
 655                 }
 656
 657                 pchip->reg_input[i]=tempintputreg[i];
 658
 659         }
 660         enable_irq(pchip->irq_chain);
 661         return;
 662 }
 663
 664 static irqreturn_t pca9554_gpio_irq_handler(int irq, void * dev_id)
 665 {
 666
 667         struct irq_desc *gpio_irq_desc = irq_to_desc(irq);
 668         struct pca9554_chip *pchip=(struct pca9554_chip *)gpio_irq_desc->chip_data;
 669
 670         //DBG("**%s**\n",__FUNCTION__);
 671         disable_irq_nosync(pchip->irq_chain);
 672         queue_work(pca9554workqueue,&pchip->pca9554_work);
 673         return IRQ_HANDLED;
 674 }
 675 static void pca9554_gpio_irq_setup(struct pca9554_chip *pchip)
 676 {
 677     unsigned        pioc, irq_num;
 678     int ret;
 679         struct irq_desc *desc;
 680     irq_num = pchip->gpio_irq_start;   //ÖÐ¶ÏºÅ£¬À©Õ¹ioµÄÖÐ¶ÏºÅÓ¦¸Ã½ô¸úÔÚÄÚ²¿ioÖÐ¶ÏºÅµÄºóÃæ¡£ÈçrkÄÚ²¿ÖÐ¶Ï48¸ö£¬¼ÓÉÏÄÚ²¿gpio 16¸öÐéÄâÖÐ¶Ï£¬ÕâÀïpinÓ¦¸Ã´Ó48+16¿ªÊ¼
 681
 682     for (pioc = 0; pioc < pchip->irq_pin_num; pioc++,irq_num++)
 683     {
 684         lockdep_set_class(&irq_desc[irq_num].lock, &gpio_lock_class);
 685          /*
 686          * Can use the "simple" and not "edge" handler since it's
 687          * shorter, and the AIC handles interrupts sanely.
 688          */
 689         set_irq_chip(irq_num, &pca9554_gpio_irqchip);
 690         set_irq_handler(irq_num, handle_simple_irq);
 691         set_irq_chip_data(irq_num,(void *)pchip);
 692         desc = irq_to_desc(irq_num);
 693         //DBG("**%s line=%d,desc=%x,chipdate=%x,pchip=%x,irq_num=%d**\n",__FUNCTION__,__LINE__,desc,desc->chip_data,pchip,irq_num);
 694
 695         set_irq_flags(irq_num, IRQF_VALID);
 696      }
 697         ret=gpio_request(pchip->irq_gpiopin,NULL);
 698         if(ret!=0)
 699         {
 700                 gpio_free(pchip->irq_gpiopin);
 701                 DBG("pca9554_gpio_irq_setup request gpio is err\n");
 702         }
 703
 704         gpio_pull_updown(pchip->irq_gpiopin, GPIOPullUp);        //gpio ÐèÒªÀ¸ßirq_to_gpio(pchip->irq_chain)
 705
 706 #if 0
 707
 708         set_irq_chip_data(pchip->irq_chain, pchip);
 709         set_irq_chained_handler(pchip->irq_chain, gpio_irq_handlerxxx);
 710         set_irq_type(pchip->irq_chain,IRQ_TYPE_LEVEL_LOW);
 711         enable_irq(pchip->irq_chain);
 712
 713 #else
 714         pca9554workqueue=create_workqueue("pca9554 workqueue");
 715         INIT_WORK(&pchip->pca9554_work,pca9554_extend_gpio_irq_handler);
 716
 717         set_irq_chip_data(pchip->irq_chain, pchip);
 718         if(request_irq(pchip->irq_chain,pca9554_gpio_irq_handler, IRQF_TRIGGER_LOW, "pca6424", pchip)!=0)
 719         {
 720                 DBG("**%s line=%d is err**\n",__FUNCTION__,__LINE__);
 721         }
 722
 723 #endif
 724 }
 725 static irqreturn_t pca9554_gpio_irq_handler_test1(int irq, void * dev_id)
 726 {
 727
 728         DBG("***************************%s irq=%d***\n",__FUNCTION__,irq);
 729         return IRQ_HANDLED;
 730 }
 731 static irqreturn_t pca9554_gpio_irq_handler_test2(int irq, void * dev_id)
 732 {
 733         DBG("**************************%s irq=%d***\n",__FUNCTION__,irq);
 734         return IRQ_HANDLED;
 735 }
 736
 737 void pca9554_test(struct pca9554_chip *chip)
 738 {
 739         struct i2c_client *client=chip->client;
 740         int ret;
 741         int irq1,irq2;
 742
 743
 744
 745
 746         ret=gpio_request(RK2818_PIN_PI4,NULL);
 747         if(ret!=0)
 748                 DBG("*gpio_request in %d ret=%d*\n",__LINE__,ret);
 749
 750         ret=gpio_request(RK2818_PIN_PI5,NULL);
 751         if(ret!=0)
 752                 DBG("*gpio_request in %d ret=%d*\n",__LINE__,ret);
 753         ret=gpio_request(RK2818_PIN_PI6,NULL);
 754         if(ret!=0)
 755                 DBG("*gpio_request in %d ret=%d*\n",__LINE__,ret);
 756         ret=gpio_request(RK2818_PIN_PI7,NULL);
 757         if(ret!=0)
 758                 DBG("*gpio_request in %d ret=%d*\n",__LINE__,ret);
 759
 760         irq1=gpio_to_irq(RK2818_PIN_PI4);
 761         request_irq(irq1, pca9554_gpio_irq_handler_test1, IRQF_TRIGGER_LOW,"xxx1", chip);
 762
 763         irq2=gpio_to_irq(RK2818_PIN_PI5);
 764         request_irq(irq2, pca9554_gpio_irq_handler_test2, IRQF_TRIGGER_HIGH, "xxx2", chip);
 765
 766         ret=gpio_direction_output(RK2818_PIN_PI6,GPIO_HIGH);
 767         ret=gpio_direction_output(RK2818_PIN_PI7,GPIO_LOW);
 768
 769
 770 }
 771
 772 int pca9554_init_pintype(struct pca9554_chip *chip,struct i2c_client *client)
 773 {
 774         int i;
 775         struct pca9554_platform_data *platform_data=(struct pca9554_platform_data *)client->dev.platform_data;
 776         struct rk2818_gpio_expander_info *pca9554_gpio_settinginfo;
 777         uint8_t reg_output[PCA9554_PortNum]={0};
 778         uint8_t reg_direction[PCA9554_PortNum]={0};
 779         uint8_t pca9554_pin_num;
 780         uint8_t gpioPortNum;
 781         uint8_t gpioPortPinNum,pca9554_settingpin_num=0;
 782
 783         if(platform_data)
 784         {
 785                 pca9554_gpio_settinginfo=platform_data->settinginfo;
 786                 if(pca9554_gpio_settinginfo)
 787                 {
 788                         pca9554_settingpin_num=platform_data->settinginfolen;
 789                         for(i=0;i<pca9554_settingpin_num;i++)
 790                         {
 791                                 if(!pca9554_checkrange(chip->gpio_start,chip->gpio_pin_num,pca9554_gpio_settinginfo[i].gpio_num))
 792                                 {
 793                                         pca9554_pin_num=pca9554_gpio_settinginfo[i].gpio_num-chip->gpio_start;
 794                                         gpioPortNum = pca9554_pin_num/PCA9554_PortPinNum;
 795                                         gpioPortPinNum= pca9554_pin_num%PCA9554_PortPinNum;
 796                                         //DBG("gpioPortNum=%d,gpioPortNum=%d,pca9554_pin_num=%d,reg_direction=%x,reg_output=%x,reg_input=%x\n",gpioPortNum,gpioPortPinNum,pca9554_pin_num,reg_direction[i],reg_output[i]);
 797                                         if((gpioPortNum>=PCA9554_PortNum)||(gpioPortPinNum>=portnum[gpioPortNum]))
 798                                                 continue;
 799                                         if(pca9554_gpio_settinginfo[i].pin_type==GPIO_IN)
 800                                                 reg_direction[gpioPortNum]=pca9554setbit(reg_direction[gpioPortNum],gpioPortPinNum);
 801                                         else
 802                                         {
 803                                                 if(pca9554_gpio_settinginfo[i].pin_value==GPIO_HIGH)
 804                                                 reg_output[gpioPortNum]=pca9554setbit(reg_output[gpioPortNum],gpioPortPinNum);
 805                                         }
 806
 807
 808                                 }
 809                         }
 810                 }
 811         }
 812         #ifdef PCA9554_OUTREGLOCK
 813         mutex_init(&chip->outreglock);
 814        #endif
 815         #ifdef PCA9554_INPUTREGLOCK
 816         mutex_init(&chip->inputreglock);
 817         #endif
 818         #ifdef PCA9554_OUTREGLOCK
 819         mutex_init(&chip->configreglock);
 820         #endif
 821
 822         for(i=0; i<PCA9554_PortNum; i++)
 823         {
 824
 825                 if (pca9554_write_reg(client, PCA9554_Config_Reg, reg_direction[i])<0)
 826                 {
 827                         DBGERR("*%s %d* write reg err\n",__FUNCTION__,__LINE__);
 828                         return -1;
 829                 }
 830                 chip->reg_direction[i]=reg_direction[i];
 831                 if (pca9554_write_reg(client, PCA9554_OutputLevel_Reg, reg_output[i])<0)
 832                 {
 833                         DBGERR("*%s %d  write reg err*\n",__FUNCTION__,__LINE__);
 834                         return -1;
 835                 }
 836                 chip->reg_output[i]=reg_output[i];
 837
 838                 if(pca9554_read_reg(client, PCA9554_InputLevel_Reg, &chip->reg_input[i])<0)
 839                 {
 840                         DBGERR("*%s %d  read reg err*\n",__FUNCTION__,__LINE__);
 841                         return -1;
 842                 }
 843                 //DBG("reg_direction=%x,reg_output=%x,reg_input=%x\n",chip->reg_direction[i],chip->reg_output[i],chip->reg_input[i]);
 844
 845         }
 846
 847         return 0;
 848 }
 849 static int __devinit pca9554_probe(struct i2c_client *client,const struct i2c_device_id *id)
 850 {
 851         struct pca9554_chip *chip;
 852         struct pca9554_platform_data  *pdata;
 853         int ret;
 854
 855         DBG("**gpio %s in %d line,dev adr is %x**\n",__FUNCTION__,__LINE__,client->addr);
 856         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 857                 return -EIO;
 858
 859         chip = kzalloc(sizeof(struct pca9554_chip), GFP_KERNEL);
 860         if (chip == NULL)
 861                 return -ENOMEM;
 862         pdata = client->dev.platform_data;
 863         if (pdata == NULL) {
 864                 DBGERR(" %s no platform data\n",__FUNCTION__);
 865                 ret = -EINVAL;
 866                 goto out_failed;
 867         }
 868
 869         chip->gpio_start = pdata->gpio_base;
 870         chip->gpio_irq_start =pdata->gpio_irq_start;
 871         chip->gpio_pin_num=pdata->gpio_pin_num;
 872         chip->irq_pin_num = pdata->irq_pin_num;
 873         chip->irq_gpiopin=pdata->pca9954_irq_pin;
 874         chip->irq_chain = gpio_to_irq(pdata->pca9954_irq_pin);
 875         chip->names =pdata->names;
 876
 877         //DBG("**%s in %d start=%d,irq_start=%d,pin_num=%d,irq_pin_num=%d,irq_gpiopin=%d,irq_chain=%d,**\n",
 878         //      __FUNCTION__,__LINE__,chip->gpio_start,chip->gpio_irq_start,chip->gpio_pin_num,chip->irq_pin_num,chip->irq_gpiopin
 879         //      ,chip->irq_chain);
 880
 881         /* initialize cached registers from their original values.
 882         * we can't share this chip with another i2c master.
 883         */
 884         pca9554_setup_gpio(chip, id->driver_data);
 885
 886         ret = gpiochip_add(&chip->gpio_chip);
 887         if (ret)
 888         goto out_failed;
 889
 890         if(pca9554_init_pintype(chip,client))
 891                 goto out_failed;
 892
 893         if (pdata->setup) {
 894                 ret = pdata->setup(client, chip->gpio_chip.base,
 895                                 chip->gpio_chip.ngpio, pdata->context);
 896                 if (ret < 0)
 897                         DBGERR(" %s setup failed, %d\n",__FUNCTION__,ret);
 898         }
 899
 900
 901         pca9554_gpio_irq_setup(chip);
 902
 903         i2c_set_clientdata(client, chip);
 904
 905
 906
 907         chip->client = client;
 908
 909         //pca9554_test(chip);
 910
 911         return 0;
 912
 913         out_failed:
 914
 915         kfree(chip);
 916     return 0;
 917 }
 918
 919 static int pca9554_remove(struct i2c_client *client)
 920 {
 921         struct pca9554_platform_data *pdata = client->dev.platform_data;
 922         struct pca9554_chip *chip = i2c_get_clientdata(client);
 923         int ret = 0;
 924
 925         if (pdata->teardown) {
 926                 ret = pdata->teardown(client, chip->gpio_chip.base,
 927                 chip->gpio_chip.ngpio, pdata->context);
 928                 if (ret < 0) {
 929                         DBGERR(" %s failed, %d\n",__FUNCTION__,ret);
 930                         return ret;
 931                 }
 932         }
 933
 934         ret = gpiochip_remove(&chip->gpio_chip);
 935         if (ret) {
 936                 dev_err(&client->dev, "%s failed, %d\n",
 937                 "gpiochip_remove()", ret);
 938                 return ret;
 939         }
 940         kfree(chip);
 941         return 0;
 942 }
 943
 944 static struct i2c_driver pca9554_driver = {
 945     .driver = {
 946                   .owner  = THIS_MODULE,
 947         .name   = "extend_gpio_pca9554",
 948     },
 949     .probe      = pca9554_probe,
 950     .remove     = pca9554_remove,
 951     .id_table   = pca9554_id,
 952 };
 953
 954 static int __init pca9554_init(void)
 955 {
 956         DBG("**pca9554_init**\n");
 957         return i2c_add_driver(&pca9554_driver);
 958 }
 959 static void __exit pca9554_exit(void)
 960 {
 961         i2c_del_driver(&pca9554_driver);
 962 }
 963
 964 module_init(pca9554_init);
 965 module_exit(pca9554_exit);
 966 MODULE_AUTHOR(" XXX  XXX@rock-chips.com");
 967 MODULE_DESCRIPTION("Driver for rk2818 extend gpio device");
 968 MODULE_LICENSE("GPL");
 969
 970