arch/arm/cpu/armv7/sc9630/gpio.c

   1 /*
   2  *  linux/arch/arm/mach-sprd/gpio.c
   3  *
   4  *  Generic SPRD GPIO handling
   5  *
   6  *  Author:     Yingchun Li(yingchun.li@spreadtrum.com)
   7  *  Created:    March 10, 2010
   8  *  Copyright:  Spreadtrum Inc.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License version 2 as
  12  *  published by the Free Software Foundation.
  13  */
  14 #include <asm/io.h>
  15 #include <asm/arch/gpio.h>
  16 #include <asm/arch/gpio_phy.h>
  17 #include <asm/arch/sprd_reg.h>
  18 #include <asm/arch/gpio_reg_v0.h>
  19 #include <asm/arch/asm_generic_gpio.h>
  20 #include <asm/arch/chip_drv_common_io.h>
  21
  22 #define KERN_WARNING ""
  23 #define WARN(nmu, fmt...) printf(fmt)
  24 #define WARN_ON(num)
  25 #define BUG_ON(__cond__) if(__cond__) printf("%s line: %d bug on\n", __FUNCTION__, __LINE__)
  26 #define pr_err(fmt...) printf(fmt)
  27 #define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
  28 #define pr_debug(fmt...) printf(fmt)
  29
  30 //#define DEBUG
  31
  32
  33 #ifdef DEBUG
  34 #define GPIO_DBG(fmt...) pr_debug(fmt)
  35 #else
  36 #define GPIO_DBG(fmt...)
  37 #endif
  38
  39 #ifndef GPO_TRI
  40 #define GPO_TRI            0xFFFF
  41 #endif
  42
  43 #ifndef GPO_DATA
  44 #define GPO_DATA           0xFFFF
  45 #endif
  46
  47
  48 struct gpio_info{
  49         enum gpio_section_type gpio_type;
  50         u32 base_addr;
  51         int   die;
  52         u8   bit_num;
  53 };
  54
  55 struct gpio_irq_map {
  56         unsigned int gpio_id;
  57         int irq_num;
  58 };
  59
  60 #define GPIO_INVALID_ID 0xffff
  61 #define INVALID_REG             (~(u32)0)
  62
  63 //static struct gpio_irq_map gpio_irq_table[NR_GPIO_IRQS];
  64
  65
  66 static void __get_gpio_base_info (u32 gpio_id, struct gpio_info *info)
  67 {
  68         int i = 0;
  69         u32 table_size = 0;
  70         struct gpio_section  *section_table;
  71
  72         section_table = gpio_get_section_table (&table_size);
  73         BUG_ON((gpio_id >= GPIO_MAX_PIN_NUM) || (table_size <= 0));
  74
  75
  76         info->base_addr = __get_base_addr (gpio_id);
  77         info->bit_num  = __get_bit_num (gpio_id);
  78         info->die          = __get_gpio_die(gpio_id);
  79
  80         for (i = 0; i < table_size; i++) {
  81                 if (section_table[i].page_base == info->base_addr) {
  82                         if (section_table[i].page_size > info->bit_num) {
  83                                 info->gpio_type = section_table[i].section_type;
  84                                 return;
  85                                 }
  86                         break;
  87                 }
  88         }
  89
  90     info->gpio_type = GPIO_SECTION_INVALID;
  91
  92     return;
  93 }
  94
  95
  96
  97 static void __gpio_set_dir (struct gpio_info * info, int dir)
  98 {
  99         int value = !!dir;
 100         u32 reg_addr = 0;
 101         unsigned long flags;
 102
 103         reg_addr = info->base_addr;
 104
 105         switch (info->gpio_type) {
 106         case GPIO_SECTION_GPI:
 107                 if (dir) {
 108                     WARN(1, "cannot set dir output with GPI");
 109                 }
 110                 return;
 111
 112         case GPIO_SECTION_GPO:
 113                 if (!dir) {
 114                 WARN(1, "cannot set dir input with GPO");
 115                 }
 116                 return;
 117
 118         case GPIO_SECTION_GPIO:
 119                 reg_addr += GPIO_DIR;
 120                 break;
 121         case GPIO_SECTION_INVALID:
 122         default:
 123                     WARN(1, " the GPIO_ID is Invalid in this chip");
 124                     return;
 125         }
 126
 127         //local_irq_save(flags);
 128         value = gpio_reg_get(reg_addr, info->die);
 129
 130         if (dir)
 131                 value |= 1 << info->bit_num;
 132         else
 133                 value &= ~(1 << info->bit_num);
 134        gpio_reg_set(reg_addr, info->die, value);
 135
 136         //local_irq_restore(flags);
 137 }
 138
 139 /*
 140         get data register's offset
 141  */
 142 static u32 __gpio_get_data_reg_offs (struct gpio_info *info)
 143 {
 144         u32 offset_addr;
 145
 146         switch (info->gpio_type) {
 147         case GPIO_SECTION_GPI:
 148             offset_addr = GPI_DATA;
 149             break;
 150         case GPIO_SECTION_GPO:
 151             offset_addr = GPO_DATA;
 152             break;
 153         case GPIO_SECTION_GPIO:
 154             offset_addr = GPIO_DATA;
 155             break;
 156         case GPIO_SECTION_INVALID:
 157         default:
 158             pr_err("the GPIO_ID is Invalid in this chip");
 159             WARN_ON(1);
 160             return INVALID_REG;
 161         }
 162
 163         return offset_addr;
 164 }
 165
 166 static int __gpio_get_pin_data (struct gpio_info *info)
 167 {
 168         u32 offset_addr = 0;
 169         u32 reg_addr = 0;
 170
 171         reg_addr = info->base_addr;
 172
 173         offset_addr = __gpio_get_data_reg_offs (info);
 174
 175         if (offset_addr != INVALID_REG) {
 176                 reg_addr += offset_addr;
 177                 return gpio_reg_get(reg_addr, info->die) & (1<<info->bit_num);
 178         }
 179
 180         return -EINVAL;
 181 }
 182 static u32 __gpio_get_data_mask_reg_offs (struct gpio_info *info)
 183 {
 184         u32 offset_addr;
 185
 186         switch (info->gpio_type) {
 187        case GPIO_SECTION_GPI:
 188             offset_addr = GPI_DMSK;
 189             break;
 190        case GPIO_SECTION_GPO:
 191             offset_addr = GPO_TRI;
 192             break;
 193        case GPIO_SECTION_GPIO:
 194             offset_addr = GPIO_DMSK;
 195             break;
 196        case GPIO_SECTION_INVALID:
 197         default:
 198             pr_err ("the GPIO_ID is Invalid in this chip");
 199             WARN_ON(1);
 200             return INVALID_REG;
 201     }
 202
 203     return offset_addr;
 204 }
 205
 206 /*
 207         if the data register can be access, return ture, else return false;
 208   */
 209 static int __gpio_get_data_mask (struct gpio_info *info)
 210 {
 211         u32 offset_addr = 0;
 212         u32 reg_addr = 0;
 213         int value;
 214
 215         reg_addr = info->base_addr;
 216
 217         offset_addr = __gpio_get_data_mask_reg_offs(info);
 218         if (offset_addr != INVALID_REG) {
 219                 reg_addr += offset_addr;
 220
 221                 GPIO_DBG("gpio_addr %x data mask :%x\r\n", info->base_addr,
 222                         gpio_reg_get(reg_addr, info->die));
 223
 224                 value = gpio_reg_get(reg_addr, info->die);
 225                 return ( value & (1<< info->bit_num)) ? true : false;
 226         }
 227
 228         return false;
 229 }
 230
 231 static int __gpio_get_dir (struct gpio_info *info)
 232 {
 233         u32 reg_addr = 0;
 234         int value;
 235
 236         reg_addr = info->base_addr;
 237
 238         switch (info->gpio_type) {
 239         case GPIO_SECTION_GPI:
 240             return false;
 241
 242         case GPIO_SECTION_GPO:
 243             return true;
 244
 245         case GPIO_SECTION_GPIO:
 246             reg_addr += GPIO_DIR;
 247             break;
 248
 249         case GPIO_SECTION_INVALID:
 250         default:
 251             pr_warning("[GPIO_DRV]the GPIO_ID is Invalid in this chip");
 252             WARN_ON(1);
 253             return -EINVAL;
 254         }
 255
 256         value = gpio_reg_get(reg_addr, info->die) & (1<< info->bit_num);
 257         return value ? true: false;
 258 }
 259
 260 static void __gpio_set_pin_data (struct gpio_info *info ,int b_on)
 261 {
 262         u32 offset_addr;
 263         u32 reg_addr;
 264         int value;
 265         unsigned long flags;
 266
 267         reg_addr = info->base_addr;
 268
 269         offset_addr = __gpio_get_data_reg_offs (info);
 270         if (offset_addr == INVALID_REG)
 271                 return;
 272
 273         reg_addr += offset_addr;
 274
 275         //local_irq_save(flags);
 276
 277         value = gpio_reg_get(reg_addr, info->die);
 278         if (b_on)
 279                 value |= 1 << info->bit_num;
 280         else
 281                 value &= ~(1 << info->bit_num);
 282         gpio_reg_set(reg_addr, info->die, value);
 283         //local_irq_restore(flags);
 284 }
 285
 286 /*
 287         set data mask, the gpio data register can be access
 288  */
 289 static void __gpio_set_data_mask (struct gpio_info *info, int b_on)
 290 {
 291         int value;
 292         u32 reg_addr;
 293         u32 offset_addr;
 294         unsigned long flags;
 295
 296         reg_addr = info->base_addr;
 297         offset_addr = __gpio_get_data_mask_reg_offs(info);
 298         if (offset_addr != INVALID_REG) {
 299                 reg_addr += offset_addr;
 300
 301                 //local_irq_save(flags);
 302                 value = gpio_reg_get(reg_addr, info->die);
 303                 if (b_on)
 304                         value |= 1 << info->bit_num;
 305                 else
 306                         value &= ~(1 << info->bit_num);
 307                 gpio_reg_set(reg_addr, info->die, value);
 308                 //local_irq_restore(flags);
 309
 310                 GPIO_DBG("After setting gpio_addr %x data mask :%x\r\n", reg_addr,
 311                 gpio_reg_get(reg_addr, info->die));
 312         }
 313
 314         return;
 315 }
 316
 317 int sprd_gpio_direction_output(struct gpio_chip *chip,
 318                                         unsigned offset, int value)
 319 {
 320         unsigned gpio_id = offset;
 321         struct gpio_info gpio_info;
 322
 323         __get_gpio_base_info (gpio_id, &gpio_info);
 324         __gpio_set_dir(&gpio_info, 1);
 325         __gpio_set_pin_data(&gpio_info, value);
 326         return 0;
 327 }
 328
 329 int sprd_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 330 {
 331         unsigned gpio_id = offset;
 332         struct gpio_info gpio_info;
 333
 334        __get_gpio_base_info (gpio_id, &gpio_info);
 335         __gpio_set_dir(&gpio_info, 0);
 336         return 0;
 337 }
 338
 339 /*
 340  * Return GPIO level
 341  */
 342 int sprd_gpio_get(struct gpio_chip *chip, unsigned offset)
 343 {
 344         unsigned gpio_id = offset;
 345         struct gpio_info gpio_info;
 346
 347         __get_gpio_base_info (gpio_id, &gpio_info);
 348
 349         if (!__gpio_get_data_mask (&gpio_info)) {
 350                 WARN(1, "GPIO_%d data mask hasn't been opened!\n", gpio_id);
 351         }
 352         /*
 353         if (__gpio_get_dir (&gpio_info))
 354         {
 355         WARN(1, "[GPIO_DRV]GPIO_GetValue: GPIO_%d should be input port!\n", gpio_id);
 356         }
 357         */
 358         return __gpio_get_pin_data (&gpio_info);
 359
 360 }
 361
 362
 363 /*
 364  * Set output GPIO level
 365  */
 366 void sprd_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 367 {
 368         struct gpio_info gpio_info;
 369         u32 gpio_id = offset;
 370
 371         BUG_ON (gpio_id >= GPIO_MAX_PIN_NUM);
 372
 373         __get_gpio_base_info (gpio_id, &gpio_info);
 374
 375 /*
 376         if (!__gpio_get_data_mask (&gpio_info))
 377         {
 378             WARN(1, "GPIO_%d data mask no opened!",  gpio_id);
 379         }
 380 */
 381
 382         if (!__gpio_get_dir (&gpio_info)) {
 383                 WARN(1, "GPIO_%d dir wrong!can't set input value", gpio_id);
 384                 return;
 385         }
 386
 387         __gpio_set_pin_data (&gpio_info, value);
 388
 389         GPIO_DBG("gpio_%d setting :%x \n", gpio_id, value);
 390 }
 391
 392 int sprd_gpio_request(struct gpio_chip *chip, unsigned offset)
 393 {
 394         unsigned gpio_id = offset;
 395         struct gpio_info gpio_info;
 396
 397         GPIO_DBG("request gpio_%d\r\n", gpio_id);
 398         __get_gpio_base_info (gpio_id, &gpio_info);
 399
 400         GPIO_DBG("gpio info, pin is :%d, base addr :%x, bit num :%d, type :%d\r\n", gpio_id,
 401                 gpio_info.base_addr, gpio_info.bit_num, gpio_info.gpio_type);
 402     GPIO_DBG("ture is %d, false is %d\n", true, false);
 403         __gpio_set_data_mask (&gpio_info, true);
 404
 405         return 0;
 406 }
 407
 408 static void sprd_gpio_free(struct gpio_chip *chip, unsigned offset)
 409 {
 410         unsigned gpio_id = offset;
 411         struct gpio_info gpio_info;
 412
 413         if (gpio_id > GPIO_MAX_PIN_NUM) {
 414                 WARN(1, KERN_WARNING"gpio number is too larger:%d\r\n", gpio_id);
 415                 return;
 416         }
 417
 418         __get_gpio_base_info (gpio_id, &gpio_info);
 419         __gpio_set_data_mask (&gpio_info, false);
 420
 421         return;
 422 }
 423
 424 #if 0
 425 static int sprd_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 426 {
 427         int i;
 428
 429         for (i = 0; i < NR_GPIO_IRQS; i++) {
 430                 if (gpio_irq_table[i].gpio_id == offset)
 431                         break;
 432         }
 433
 434         if (i >= NR_GPIO_IRQS)
 435                 return -1;
 436         return gpio_irq_table[i].irq_num;
 437 }
 438
 439 int irq_to_gpio(unsigned long irq)
 440 {
 441          int i;
 442
 443         for (i = 0; i < NR_GPIO_IRQS; i++) {
 444                 if (gpio_irq_table[i].irq_num == irq)
 445                         break;
 446         }
 447
 448         if (i >= NR_GPIO_IRQS)
 449                 return -1;
 450         return gpio_irq_table[i].gpio_id;
 451 }
 452 EXPORT_SYMBOL(irq_to_gpio);
 453
 454 static struct gpio_chip sprd_gpio_chip = {
 455         .label            = "sc8800s-gpio",
 456         .direction_input  = sprd_gpio_direction_input,
 457         .direction_output = sprd_gpio_direction_output,
 458         .get              = sprd_gpio_get,
 459         .set              = sprd_gpio_set,
 460         .request          = sprd_gpio_request,
 461         .free             = sprd_gpio_free,
 462         .to_irq = sprd_gpio_to_irq,
 463         .base             = 0,
 464         .ngpio            = GPIO_MAX_PIN_NUM,
 465 };
 466
 467 static u32 __gpio_get_int_mask_addr (struct gpio_info *info)
 468 {
 469         u32 offset_addr;
 470
 471         switch (info->gpio_type) {
 472         case GPIO_SECTION_GPI:
 473             offset_addr = GPI_IE;
 474             break;
 475         case GPIO_SECTION_GPO:
 476             WARN(1, "this opretion can not belong to GPO");
 477             return INVALID_REG;
 478
 479         case GPIO_SECTION_GPIO:
 480             offset_addr = GPIO_IE;
 481             break;
 482
 483         case GPIO_SECTION_INVALID:
 484         default:
 485             WARN (1, "the GPIO_ID is Invalid in this chip");
 486             return INVALID_REG;
 487         }
 488
 489         return offset_addr;
 490
 491 }
 492
 493
 494 static void __gpio_enable_irq (struct gpio_info *info)
 495 {
 496         int value;
 497         u32 reg_addr;
 498         u32 offset_addr = 0;
 499         unsigned long flags;
 500
 501         reg_addr = info->base_addr;
 502         offset_addr = __gpio_get_int_mask_addr (info);
 503         if (offset_addr != INVALID_REG) {
 504                 reg_addr += offset_addr;
 505                 local_irq_save(flags);
 506                 value = gpio_reg_get(reg_addr, info->die);
 507                 value |= 1 << info->bit_num;
 508                 gpio_reg_set(reg_addr, info->die, value);
 509                 local_irq_restore(flags);
 510         }
 511
 512         return;
 513 }
 514
 515 static void __gpio_disable_irq (struct gpio_info *info)
 516 {
 517         int value;
 518         u32 reg_addr;
 519         u32 offset_addr;
 520         unsigned long flags;
 521
 522         reg_addr = info->base_addr;
 523         offset_addr = __gpio_get_int_mask_addr (info);
 524
 525         if (offset_addr != INVALID_REG) {
 526                 reg_addr += offset_addr;
 527                 local_irq_save(flags);
 528                 value = gpio_reg_get(reg_addr, info->die);
 529                 value &= ~ (1 << info->bit_num);
 530                 gpio_reg_set(reg_addr, info->die, value);
 531                 local_irq_restore(flags);
 532         }
 533
 534         return;
 535
 536 }
 537
 538 static void __gpio_clear_irq_status (struct gpio_info *info)
 539 {
 540         int value;
 541         u32 reg_addr;
 542         unsigned long flags;
 543
 544         reg_addr = info->base_addr;
 545
 546         switch (info->gpio_type) {
 547         case GPIO_SECTION_GPI:
 548             reg_addr += GPI_IC;
 549             break;
 550         case GPIO_SECTION_GPO:
 551             GPIO_DBG("this opretion can not belong to GPO");
 552             return;
 553         case GPIO_SECTION_GPIO:
 554             reg_addr += GPIO_IC;
 555             break;
 556         case GPIO_SECTION_INVALID:
 557         default:
 558             GPIO_DBG("the GPIO_ID is Invalid in this chip");
 559             WARN_ON(1);
 560             return;
 561         }
 562
 563         local_irq_save(flags);
 564         value = gpio_reg_get(reg_addr, info->die);
 565         value &= ~ (1 << info->bit_num);
 566         value |= 1 << info->bit_num;
 567         gpio_reg_set(reg_addr, info->die, value);
 568 }
 569
 570 static int __gpio_get_int_status (struct gpio_info *info)
 571 {
 572         u32 reg_addr = 0;
 573         int value;
 574
 575         reg_addr = info->base_addr;
 576
 577         switch (info->gpio_type) {
 578         case GPIO_SECTION_GPI:
 579                 reg_addr += GPI_MIS;
 580                 break;
 581         case GPIO_SECTION_GPO:
 582                 WARN(1, "The corresponding reg of this GPIO_ID is a GPO! No Intr!");
 583                 return false;
 584
 585         case GPIO_SECTION_GPIO:
 586             reg_addr += GPIO_MIS;
 587             break;
 588         case GPIO_SECTION_INVALID:
 589         default:
 590             WARN(1, "the GPIO_ID is Invalid in this chip");
 591             return false;
 592         }
 593
 594         value  = gpio_reg_get(reg_addr, info->die);
 595
 596         return ( value & (1 << info->bit_num)) ? true : false;
 597 }
 598
 599 static void __gpio_set_int_type (struct gpio_info *info, int type)
 600 {
 601         if (info->gpio_type == GPIO_SECTION_GPI) {
 602                 switch (type) {
 603                 case IRQ_TYPE_LEVEL_HIGH:   // detect high level.
 604                            gpio_reg_or( (info->base_addr + GPI_IEV), info->die,
 605                                                         (0x1 << info->bit_num));
 606                             break;
 607
 608                    case IRQ_TYPE_LEVEL_LOW:    // detect low level.
 609                           gpio_reg_and( (info->base_addr + GPI_IEV), info->die,
 610                                                         ~ (0x1 << info->bit_num));
 611                             break;
 612
 613                     case IRQ_TYPE_EDGE_BOTH:    // detect the rising edges and falling edges.
 614                     case IRQ_TYPE_EDGE_RISING:  // detect the rising edges.
 615                     case IRQ_TYPE_EDGE_FALLING:
 616                     default:
 617                             WARN(1, "The Irq type is invalid for GPI. \n");
 618                          break;
 619                     }
 620         } else if (info->gpio_type == GPIO_SECTION_GPIO) {
 621                         switch (type) {
 622                         case IRQ_TYPE_LEVEL_HIGH:   // detect high level.
 623                                 gpio_reg_or( (info->base_addr + GPIO_IS), info->die, (0x1 << info->bit_num));
 624                                 gpio_reg_and(info->base_addr + GPIO_IBE, info->die, ~ (0x1 << info->bit_num));
 625                                 gpio_reg_or( (info->base_addr + GPIO_IEV), info->die, (0x1 << info->bit_num));
 626                                 break;
 627
 628                         case IRQ_TYPE_LEVEL_LOW:    // detect low level.
 629                                 gpio_reg_or( (info->base_addr + GPIO_IS), info->die, (0x1 << info->bit_num));
 630                                 gpio_reg_and(info->base_addr + GPIO_IBE, info->die, ~ (0x1 << info->bit_num));
 631                                 gpio_reg_and( (info->base_addr + GPIO_IEV), info->die, ~(0x1 << info->bit_num));
 632                                 break;
 633
 634                         case IRQ_TYPE_EDGE_BOTH:    // detect the rising edges and falling edges.
 635                                 gpio_reg_and( (info->base_addr + GPIO_IS), info->die, ~(0x1 << info->bit_num));
 636                                 gpio_reg_or(info->base_addr + GPIO_IBE, info->die, (0x1 << info->bit_num));
 637                                 gpio_reg_and( (info->base_addr + GPIO_IEV), info->die, ~(0x1 << info->bit_num));
 638                                 break;
 639
 640                         case IRQ_TYPE_EDGE_RISING:  // detect the rising edges.
 641                                 gpio_reg_and( (info->base_addr + GPIO_IS), info->die, ~(0x1 << info->bit_num));
 642                                 gpio_reg_and(info->base_addr + GPIO_IBE, info->die, ~ (0x1 << info->bit_num));
 643                                 gpio_reg_or( (info->base_addr + GPIO_IEV), info->die, (0x1 << info->bit_num));
 644                                 break;
 645
 646                         case IRQ_TYPE_EDGE_FALLING:
 647                                 gpio_reg_and( (info->base_addr + GPIO_IS), info->die, ~(0x1 << info->bit_num));
 648                                 gpio_reg_and(info->base_addr + GPIO_IBE, info->die, ~ (0x1 << info->bit_num));
 649                                 gpio_reg_and( (info->base_addr + GPIO_IEV), info->die, ~(0x1 << info->bit_num));
 650                                 break;
 651                         default:
 652                                 WARN(1, "fault irq type \r\n");
 653                                 break;
 654                         }
 655         }      else {
 656                 WARN(1, "the gpio type is Invalid for irq\r\n");
 657                 return;
 658         }
 659 }
 660
 661 /*
 662         The GPI module can do handware debouce, the max period is 255ms,
 663         NOTE:
 664         if your application need debounce time larger than that, please use software
 665         timer.
 666  */
 667 void gpio_set_hw_debounce (unsigned int gpio, u8 period)
 668 {
 669         u32 reg_addr = 0;
 670         int value;
 671         struct gpio_info gpio_info;
 672         unsigned long flags;
 673
 674         __get_gpio_base_info (gpio, &gpio_info);
 675         if (gpio_info.gpio_type != GPIO_SECTION_GPI) {
 676                 WARN(1, "GPIO_%d is not in GPI\r\n", gpio);
 677                 return;
 678         }
 679
 680         reg_addr = gpio_info.base_addr;
 681         reg_addr += (GPI_0CTRL+ (gpio_info.bit_num << 2));
 682
 683         local_irq_save(flags);
 684         if (period >= 1) {
 685                 /*
 686                 GPIO_REG_OR (reg_addr, GPI_DEBOUNCE_BIT);
 687                 GPIO_REG_SET (reg_addr, (GPIO_REG32 (reg_addr) & 0xFF00) +debounce_period);
 688                 */
 689                 gpio_reg_or(reg_addr, gpio_info.die, GPI_DEBOUNCE_BIT);
 690                 value = (gpio_reg_get(reg_addr, gpio_info.die) & 0xFF00) + period;
 691                 gpio_reg_set(reg_addr, gpio_info.die, value);
 692         } else {// not recommend
 693                 //GPIO_REG_AND (reg_addr, ~GPI_DEBOUNCE_BIT); //bypass mode
 694                 gpio_reg_and(reg_addr, gpio_info.die, ~GPI_DEBOUNCE_BIT);
 695         }
 696         local_irq_restore(flags);
 697 }
 698
 699 EXPORT_SYMBOL(gpio_set_hw_debounce);
 700
 701 /*
 702         generate the trig_start pulse for GPI interrupt;
 703  */
 704 static void __gpio_trig_detect (struct gpio_info *info)
 705 {
 706         int value;
 707         u32 reg_addr = 0;
 708         unsigned long flags;
 709
 710         reg_addr = info->base_addr;
 711
 712         switch (info->gpio_type) {
 713         case GPIO_SECTION_GPI:
 714                 reg_addr += GPI_TRIG;
 715                 break;
 716
 717         case GPIO_SECTION_GPO:
 718         case GPIO_SECTION_GPIO:
 719                 GPIO_DBG("[GPIO_DRV]this opretion can not belong to GPO/GPIO");
 720                 WARN_ON(1);
 721                 return;
 722
 723         case GPIO_SECTION_INVALID:
 724         default:
 725                 GPIO_DBG ("[GPIO_DRV]the GPIO_ID is Invalid in this chip");
 726                 WARN_ON(1);
 727                 return;
 728         }
 729
 730         local_irq_save(flags);
 731
 732         value = gpio_reg_get(reg_addr, info->die) & ~(1 << info->bit_num);
 733         value |= 1 << info->bit_num;
 734         gpio_reg_set(reg_addr, info->die, value);
 735
 736         local_irq_restore(flags);
 737         //GPIO_REG_SET (reg_addr, ( (GPIO_REG32 (reg_addr) & ~ (1<<pGpio_info->bit_num)) | (value<<pGpio_info->bit_num)));
 738
 739 }
 740
 741
 742 void gpio_enable_gpi_interupt (struct gpio_info *info)
 743 {
 744
 745         switch (info->gpio_type) {
 746         case GPIO_SECTION_GPI:
 747             __gpio_enable_irq (info);
 748             __gpio_trig_detect (info);
 749             break;
 750         case GPIO_SECTION_GPO:
 751         case GPIO_SECTION_GPIO:
 752             return;
 753
 754         default:
 755            WARN_ON(1);
 756             break;
 757         }
 758 }
 759
 760 //EXPORT_SYMBOL(gpio_enable_gpi_interupt);
 761
 762 static void sprd_ack_gpio_irq(unsigned int irq)
 763 {
 764         int gpio;
 765         struct gpio_irq_map *map= get_irq_chip_data(irq);
 766         struct gpio_info gpio_info;
 767
 768         gpio = map->gpio_id;
 769         if (gpio >= GPIO_MAX_PIN_NUM ) {
 770                 pr_warning(" [%s] error gpio %d\n", __FUNCTION__, gpio);
 771                 return;
 772         }
 773         GPIO_DBG("ack irq gpio %d  irq %d", gpio, irq);
 774
 775         __get_gpio_base_info (gpio, &gpio_info);
 776         __gpio_clear_irq_status(&gpio_info);
 777 }
 778
 779 static void sprd_mask_gpio_irq(unsigned int irq)
 780 {
 781         unsigned gpio;
 782         struct gpio_irq_map *map= get_irq_chip_data(irq);
 783         struct gpio_info gpio_info;
 784
 785         gpio = map->gpio_id;
 786         if (gpio >= GPIO_MAX_PIN_NUM ) {
 787                 pr_warning(" [%s] error gpio %d\n", __func__, gpio);
 788                 return;
 789         }
 790
 791         GPIO_DBG("mask gpio %d  irq %d", gpio, irq);
 792         __get_gpio_base_info (gpio, &gpio_info);
 793         __gpio_disable_irq (&gpio_info);
 794 }
 795
 796
 797 static void sprd_unmask_gpio_irq(unsigned int irq)
 798 {
 799         unsigned gpio;
 800         struct gpio_info gpio_info;
 801         struct gpio_irq_map *map= get_irq_chip_data(irq);
 802
 803         gpio = map->gpio_id;
 804         if (gpio >= GPIO_MAX_PIN_NUM ) {
 805                 pr_warning(" [%s] error gpio %d\n", __FUNCTION__, gpio);
 806                 return;
 807         }
 808
 809         GPIO_DBG("unmask gpio %d  irq %d", gpio, irq);
 810         __get_gpio_base_info (gpio, &gpio_info);
 811         __gpio_enable_irq (&gpio_info);
 812
 813         if(gpio_info.gpio_type == GPIO_SECTION_GPI)
 814                 __gpio_trig_detect (&gpio_info);
 815 }
 816
 817
 818 static int sprd_gpio_irq_type(unsigned int irq, unsigned int type)
 819 {
 820         int gpio;
 821         struct gpio_irq_map *map= get_irq_chip_data(irq);
 822         struct gpio_info gpio_info;
 823
 824         gpio = map->gpio_id;
 825         if (gpio >= GPIO_MAX_PIN_NUM ) {
 826                 pr_warning(" [%s] error gpio %d\n", __FUNCTION__, gpio);
 827                 return -1;
 828         }
 829
 830         __get_gpio_base_info (gpio, &gpio_info);
 831         //set irq type
 832         __gpio_set_int_type(&gpio_info, type);
 833
 834         if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
 835                 __set_irq_handler_unlocked(irq, handle_level_irq);
 836         else if (type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
 837                 __set_irq_handler_unlocked(irq, handle_edge_irq);
 838         return 0;
 839 }
 840
 841 static void sprd_disable_gpio_irq(unsigned int irq)
 842 {
 843         sprd_mask_gpio_irq(irq);
 844 }
 845 static struct irq_chip sprd_muxed_gpio_chip = {
 846         .name           = "GPIO",
 847         .ack            = sprd_ack_gpio_irq,
 848         .mask           = sprd_mask_gpio_irq,
 849         .unmask         = sprd_unmask_gpio_irq,
 850         .set_type       = sprd_gpio_irq_type,
 851         .disable        = sprd_disable_gpio_irq,
 852 };
 853
 854 static  int gpio_get_int_status(unsigned int gpio)
 855 {
 856         struct gpio_info gpio_info;
 857
 858         __get_gpio_base_info (gpio, &gpio_info);
 859         return __gpio_get_int_status (&gpio_info);
 860
 861 }
 862
 863
 864 static void sprd_gpio_demux_handler(unsigned int irq, struct irq_desc *desc)
 865 {
 866         int i;
 867
 868         for (i = 0; i < NR_GPIO_IRQS; i++) {
 869                 if (gpio_irq_table[i].gpio_id == GPIO_INVALID_ID) {
 870                             continue;
 871                 }
 872                 if (gpio_get_int_status(gpio_irq_table[i].gpio_id)) {
 873                         generic_handle_irq(gpio_irq_table[i].irq_num);
 874                 }
 875         }
 876 }
 877 static void sprd_gpio_irq_init(void)
 878 {
 879         int irq;
 880         int i;
 881
 882         for(i = 0; i < NR_GPIO_IRQS; i++) {
 883                 gpio_irq_table[i].gpio_id= GPIO_INVALID_ID;
 884         }
 885         for (irq = GPIO_IRQ_START; irq < (GPIO_IRQ_START + NR_GPIO_IRQS); irq++) {
 886                 set_irq_chip(irq, &sprd_muxed_gpio_chip);
 887                 set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
 888         }
 889
 890         set_irq_chained_handler(IRQ_GPIO_INT, sprd_gpio_demux_handler);
 891         set_irq_chained_handler(IRQ_ANA_GPIO_INT, sprd_gpio_demux_handler);
 892 }
 893
 894 /*
 895         allocate an irq for gpio
 896 */
 897 __must_check int sprd_alloc_gpio_irq(unsigned gpio)
 898 {
 899         int irq;
 900         int i;
 901         struct gpio_info gpio_info;
 902         unsigned long flags;
 903
 904         __get_gpio_base_info (gpio, &gpio_info);
 905
 906         // find a free record
 907         for (i = 0; i< NR_GPIO_IRQS; i++) {
 908                 if (gpio_irq_table[i].gpio_id == gpio) {
 909                         pr_warning("irq for GPIO_%d has been alloc !\n", gpio);
 910                         return -1;
 911                 }
 912         }
 913
 914         for(i = 0; i < NR_GPIO_IRQS; i++) {
 915                 if (gpio_irq_table[i].gpio_id == GPIO_INVALID_ID)
 916                         break;
 917         }
 918
 919         if (i >= NR_GPIO_IRQS) {
 920                 // No free item in the table.
 921                 return -1;
 922         }
 923         local_irq_save(flags);
 924         irq = GPIO_IRQ_START + i;
 925          gpio_irq_table[i].gpio_id = gpio;
 926          gpio_irq_table[i].irq_num = irq;
 927
 928         set_irq_chip_data(irq, &gpio_irq_table[i]);
 929         local_irq_restore(flags);
 930         __gpio_clear_irq_status(&gpio_info);
 931         if (gpio_info.gpio_type == GPIO_SECTION_GPI)
 932                __gpio_trig_detect (&gpio_info);
 933
 934         return irq;
 935 }
 936
 937 EXPORT_SYMBOL(sprd_alloc_gpio_irq);
 938
 939 void sprd_free_gpio_irq(int irq)
 940 {
 941         int i;
 942         unsigned long flags;
 943
 944         local_irq_save(flags);
 945         for (i = 0; i < NR_GPIO_IRQS; i++) {
 946                 if (gpio_irq_table[i].irq_num == irq) {
 947                         set_irq_chip_data(irq, NULL);
 948                         gpio_irq_table[i].gpio_id = GPIO_INVALID_ID;
 949                         break;
 950                 }
 951         }
 952         local_irq_restore(flags);
 953 }
 954 EXPORT_SYMBOL(sprd_free_gpio_irq);
 955
 956 __init void sprd_gpio_init(void)
 957 {
 958         //enable gpio bank 0~10, that is, all 176 gpio
 959         //__raw_writel(0x7fff, GR_GEN2);
 960           //CHIP_REG_OR ( (GR_GEN0), (GEN0_GPIO_EN | GEN0_GPIO_RTC_EN));
 961           __raw_bits_or (GEN0_GPIO_EN | GEN0_GPIO_RTC_EN, GR_GEN0);
 962         ANA_REG_OR (ANA_AGEN,AGEN_RTC_GPIO_EN);
 963         msleep(5);
 964         ANA_REG_OR (ANA_AGEN,AGEN_GPIO_EN);
 965
 966         gpiochip_add(&sprd_gpio_chip);
 967
 968         sprd_gpio_irq_init();
 969 }
 970 #endif
 971 void sprd_gpio_init(void)
 972 {
 973         #if defined(CONFIG_SPX15)
 974         REG32(REG_AON_APB_APB_EB0) |= BIT_AON_GPIO_EB;
 975         #else
 976         REG32(REG_AON_APB_APB_EB0) |= BIT_GPIO_EB;
 977         #if !(defined(CONFIG_ADIE_SC2723S)||defined(CONFIG_ADIE_SC2723))
 978         ANA_REG_OR(ANA_REG_GLB_ARM_MODULE_EN, BIT_ANA_GPIO_EN);
 979         #endif
 980         #endif
 981 }