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