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