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