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