drivers/misc/mediatek/cirq/mt8127/mt_cirq.c

   1 #include <linux/kernel.h>
   2 #include <linux/device.h>
   3 #include <linux/platform_device.h>
   4 #include <linux/module.h>
   5 #include <linux/interrupt.h>
   6 #include <mach/mt_cirq.h>
   7 #include <mach/mt_reg_base.h>
   8 #include <asm/system.h>
   9 #include <linux/module.h>
  10 #include <linux/uaccess.h>
  11 #include <linux/slab.h>
  12 #include <linux/cpu.h>
  13 #include <linux/smp.h>
  14 #include <linux/types.h>
  15 #include <mach/mt_sleep.h>
  16 #include "mach/sync_write.h"
  17 #include "mach/irqs.h"
  18 #include <asm/mach/irq.h>
  19
  20 #include <linux/version.h>
  21 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
  22 #include <asm/hardware/gic.h>
  23 #else
  24 #include <linux/irqchip/arm-gic.h>
  25 #endif
  26
  27
  28 #define INT_POL_CTL0 (MCUSYS_CFGREG_BASE + 0x100)
  29
  30 int mt_cirq_test(void);
  31 void mt_cirq_dump_reg(void);
  32 #define CIRQ_DEBUG   0
  33 #define CIRQ_LOG_LEVEL KERN_DEBUG
  34 #define LDVT
  35
  36 #if(CIRQ_DEBUG == 1)
  37 #ifdef CTP
  38 #define dbgmsg dbg_print
  39 #else
  40 #define dbgmsg printk
  41 #define print_func() do { \
  42     printk("in %s\n",__func__); \
  43 } while(0)
  44 #endif
  45 #else
  46 #define dbgmsg(...)
  47 #define print_func() do { }while(0)
  48 #endif
  49
  50
  51 #define cirq_num_validate(x) do{\
  52     if (x > (MT_NR_CIRQ) || x < 0){\
  53         dbgmsg(CIRQ_LOG_LEVEL "Error in %s [CIRQ] wrong cirq, num %d is larger then 155 or less then 0\n",__func__,x); \
  54         return -1; \
  55     }\
  56 }while(0)
  57
  58
  59 struct mt_cirq_driver{
  60     struct device_driver driver;
  61     const struct platform_device_id *id_table;
  62 };
  63
  64 static struct mt_cirq_driver mt_cirq_drv = {
  65     .driver = {
  66         .name = "cirq",
  67         .bus = &platform_bus_type,
  68         .owner = THIS_MODULE,
  69     },
  70     .id_table= NULL,
  71 };
  72
  73 /* 1: this cirq is masked
  74  * 0: this cirq is umasked
  75  * -1:cirq num is out of range
  76  * */
  77 static unsigned int mt_cirq_get_mask(unsigned int cirq_num)
  78 {
  79     unsigned int base;
  80     unsigned int bit = 1 << (cirq_num % 32);
  81     volatile unsigned int val;
  82     print_func();
  83     cirq_num_validate(cirq_num);
  84     base = (cirq_num / 32) * 4 + CIRQ_MASK0;
  85     val = readl(IOMEM(base));
  86     if (val & bit)
  87         return 1;
  88     else
  89         return 0;
  90 }
  91
  92 void mt_cirq_mask_all(void)
  93 {
  94     int i;
  95
  96     for(i = 0; i < 5; i++)
  97         mt65xx_reg_sync_writel(0xFFFFFFFF, CIRQ_MASK_SET0 + i * 4);
  98 }
  99
 100 void mt_cirq_unmask_all(void)
 101 {
 102     int i;
 103
 104     for(i = 0; i < 5; i++)
 105         mt65xx_reg_sync_writel(0xFFFFFFFF, CIRQ_MASK_CLR0 + i * 4);
 106 }
 107
 108 void mt_cirq_ack_all(void)
 109 {
 110     int i;
 111
 112     for(i = 0; i < 5; i++)
 113         mt65xx_reg_sync_writel(0xFFFFFFFF, CIRQ_ACK0 + i * 4);
 114 }
 115
 116 /*
 117  * 0: mask success
 118  * -1:cirq num is out of range
 119  * */
 120 static int mt_cirq_mask(unsigned int cirq_num)
 121 {
 122     unsigned int base;
 123     unsigned int bit = 1 << (cirq_num % 32);
 124     print_func();
 125
 126     cirq_num_validate(cirq_num);
 127     base = (cirq_num / 32) * 4 + CIRQ_ACK0;
 128     mt65xx_reg_sync_writel(bit, base);
 129
 130     base = (cirq_num / 32) * 4 + CIRQ_MASK_SET0;
 131     mt65xx_reg_sync_writel(bit, base);
 132
 133     dbgmsg(CIRQ_LOG_LEVEL "[CIRQ] mask addr:%x = %x, after set:0x%x\n", base, bit,readl(IOMEM((cirq_num / 32) * 4 + CIRQ_MASK0)));
 134     return 0;
 135
 136 }
 137
 138 /*
 139  * 0: umask success
 140  * -1:cirq num is out of range
 141  * */
 142 static int mt_cirq_unmask(unsigned int cirq_num)
 143 {
 144     unsigned int base;
 145     unsigned int bit = 1 << (cirq_num % 32);
 146
 147     print_func();
 148
 149     cirq_num_validate(cirq_num);
 150     base = (cirq_num / 32) * 4 + CIRQ_ACK0;
 151     mt65xx_reg_sync_writel(bit, base);
 152     dbgmsg(CIRQ_LOG_LEVEL "[CIRQ] ack :%x, bit: %x\n",  base, bit);
 153
 154     base = (cirq_num / 32) * 4 + CIRQ_MASK_CLR0;
 155     mt65xx_reg_sync_writel(bit, base);
 156
 157     dbgmsg(CIRQ_LOG_LEVEL "[CIRQ] unmask addr:%x = %x, after set:0x%x\n", base, bit,readl(IOMEM((cirq_num / 32) * 4 + CIRQ_MASK0)));
 158     return 0;
 159
 160 }
 161
 162 /*
 163  * 0: set pol success
 164  * -1:cirq num is out of range
 165  * */
 166 static int mt_cirq_set_pol(unsigned int cirq_num, unsigned int pol)
 167 {
 168     unsigned int base;
 169     unsigned int bit = 1 << (cirq_num % 32);
 170
 171     print_func();
 172
 173     cirq_num_validate(cirq_num);
 174     if (pol == MT_CIRQ_POL_NEG) {
 175         base = (cirq_num / 32) * 4 + CIRQ_POL_CLR0;
 176     } else if (pol == MT_CIRQ_POL_POS){
 177         base = (cirq_num / 32) * 4 + CIRQ_POL_SET0;
 178     } else {
 179         dbgmsg(KERN_CRIT"%s invalid polarity value\n", __func__);
 180         return -1 ;
 181     }
 182     mt65xx_reg_sync_writel(bit, base);
 183     dbgmsg(CIRQ_LOG_LEVEL "[CIRQ] set pol:%d :%x, bit: %x, after set:0x%x\n",pol, base, bit,readl(IOMEM((cirq_num / 32) * 4 + CIRQ_POL0)));
 184     return 0;
 185
 186 }
 187
 188 /*
 189  * 0: set sens success
 190  * -1:cirq num is out of range
 191  * */
 192 static int  mt_cirq_set_sens(unsigned int cirq_num, unsigned int sens)
 193 {
 194     unsigned int base;
 195     unsigned int bit = 1 << (cirq_num % 32);
 196
 197     print_func();
 198     cirq_num_validate(cirq_num);
 199     if (sens == MT_EDGE_SENSITIVE) {
 200         base = (cirq_num / 32) * 4 + CIRQ_SENS_CLR0;
 201     } else if (sens == MT_LEVEL_SENSITIVE) {
 202         base = (cirq_num / 32) * 4 + CIRQ_SENS_SET0;
 203     } else {
 204         dbgmsg(KERN_CRIT"%s invalid sensitivity value\n", __func__);
 205         return -1;
 206     }
 207     mt65xx_reg_sync_writel(bit, base);
 208     dbgmsg(CIRQ_LOG_LEVEL "[CIRQ] %s,sens:%d :%x, bit: %x, after set:0x%x\n", __func__,sens, base, bit,readl(IOMEM((cirq_num / 32) * 4 + CIRQ_SENS0)));
 209     return 0;
 210 }
 211
 212 /* 1: this cirq is MT_LEVEL_SENSITIVE
 213  * 0: this cirq is MT_EDGE_SENSITIVE
 214  * -1:cirq num is out of range
 215  * */
 216 static unsigned int mt_cirq_get_sens(unsigned int cirq_num)
 217 {
 218
 219     unsigned int base;
 220     unsigned int bit = 1 << (cirq_num % 32);
 221     volatile unsigned int val;
 222     print_func();
 223     cirq_num_validate(cirq_num);
 224     base = (cirq_num / 32) * 4 + CIRQ_SENS0;
 225     val = readl(IOMEM(base));
 226     if (val & bit)
 227     {
 228         return MT_LEVEL_SENSITIVE;
 229     }
 230     else
 231     {
 232         return MT_EDGE_SENSITIVE;
 233     }
 234
 235 }
 236
 237 /* 1: this cirq is MT_CIRQ_POL_POS
 238  * 0: this cirq is MT_CIRQ_POL_NEG
 239  * -1:cirq num is out of range
 240  * */
 241 static unsigned int mt_cirq_get_pol(unsigned int cirq_num)
 242 {
 243     unsigned int base;
 244     unsigned int bit = 1 << (cirq_num % 32);
 245     volatile unsigned int val;
 246     print_func();
 247     cirq_num_validate(cirq_num);
 248     base = (cirq_num / 32) * 4 + CIRQ_POL0;
 249     val = readl(IOMEM(base));
 250     if (val & bit)
 251     {
 252         return MT_CIRQ_POL_POS;
 253     }
 254     else
 255     {
 256         return MT_CIRQ_POL_NEG;
 257     }
 258 }
 259 #if 0
 260 /*
 261  * 0: ack success
 262  * -1:cirq num is out of range
 263  * */
 264 static unsigned int mt_cirq_ack(unsigned int cirq_num)
 265 {
 266     unsigned int base;
 267     unsigned int bit = 1 << (cirq_num % 32);
 268     print_func();
 269
 270     cirq_num_validate(cirq_num);
 271     base = (cirq_num / 32) * 4 + CIRQ_ACK0;
 272     mt65xx_reg_sync_writel(bit, base);
 273
 274
 275     dbgmsg(CIRQ_LOG_LEVEL "[CIRQ] ack addr:%x = %x\n", base, bit);
 276
 277     return 0;
 278 }
 279 #endif
 280 #if 0
 281 /*
 282  * 0: get sta success
 283  * -1:cirq num is out of range
 284  * */
 285 unsigned int mt_cirq_read_status(unsigned int cirq_num)
 286 {
 287     unsigned int sta;
 288     unsigned int base;
 289     unsigned int bit = 1 << (cirq_num % 32);
 290     volatile unsigned int val;
 291     print_func();
 292     cirq_num_validate(cirq_num);
 293
 294     base = (cirq_num / 32) * 4 + CIRQ_STA0;
 295     val = readl(IOMEM(base));
 296     sta = (val & bit);
 297     return sta;
 298
 299 }
 300 #endif
 301 void mt_cirq_enable(void){
 302     unsigned int base=CIRQ_CON;
 303     volatile unsigned int val;
 304     val = readl(IOMEM(CIRQ_CON));
 305     val |= (0x3); //enable edge only mode
 306     mt65xx_reg_sync_writel(val,base);
 307 }
 308 void mt_cirq_disable(void){
 309     unsigned int base=CIRQ_CON;
 310     volatile unsigned int val;
 311     val = readl(IOMEM(CIRQ_CON));
 312     val &= (~0x1);
 313     mt65xx_reg_sync_writel(val,base);
 314 }
 315 void mt_cirq_flush(void){
 316
 317     unsigned int irq;
 318     volatile unsigned int val;
 319     print_func();
 320
 321     /*make edge interrupt shows in the STA*/
 322     mt_cirq_unmask_all();
 323     for (irq = 64; irq < (NR_MT_IRQ_LINE); irq+=32)
 324     {
 325         val = readl(IOMEM(((irq-64) / 32) * 4 + CIRQ_STA0));
 326         //printk("irq:%d,pending bit:%x\n",irq,val);
 327
 328         mt65xx_reg_sync_writel(val,(GIC_DIST_BASE + GIC_DIST_PENDING_SET + irq / 32 * 4));
 329         dsb();
 330         //printk("irq:%d,pending bit:%x,%x\n",irq,val,readl(GIC_DIST_BASE + GIC_DIST_PENDING_SET + irq / 32 * 4));
 331     }
 332     mt_cirq_mask_all();
 333     dsb();
 334 }
 335 static void mt_cirq_clone_pol(void)
 336 {
 337     unsigned int irq,irq_offset;
 338     volatile unsigned int value;
 339     volatile unsigned int value_cirq;
 340     int ix;
 341     print_func();
 342     for (irq = 64; irq < (NR_MT_IRQ_LINE); irq+=32)
 343     {
 344         value = readl(IOMEM(INT_POL_CTL0 + ((irq-GIC_PRIVATE_SIGNALS) / 32 * 4)));
 345         irq_offset = (irq-64) / 32;
 346         dbgmsg(CIRQ_LOG_LEVEL "irq:%d,gic_pol_address:0x%8x,gic_pol_value:0x%08x\n",irq,INT_POL_CTL0 + ((irq-GIC_PRIVATE_SIGNALS) / 32 * 4),value);
 347         for (ix = 0; ix < 32; ix++)
 348         {
 349             if (value & (0x1)) //high trigger
 350                 mt_cirq_set_pol(irq+ix-64,MT_CIRQ_POL_NEG);
 351             else//low trigger
 352                 mt_cirq_set_pol(irq+ix-64,MT_CIRQ_POL_POS);
 353
 354             value >>= 1;
 355         }
 356         value_cirq = readl(IOMEM(CIRQ_POL0 + irq_offset*4));
 357         dbgmsg(CIRQ_LOG_LEVEL "irq:%d,cirq_value:0x%08x\n",irq,value_cirq);
 358     }
 359 }
 360
 361 static void mt_cirq_clone_sens(void)
 362 {
 363     unsigned int irq,irq_offset;
 364     volatile unsigned int value;
 365     volatile unsigned int value_cirq;
 366     int ix;
 367     print_func();
 368     for (irq = 64; irq < (NR_MT_IRQ_LINE); irq+=16)
 369     {
 370         value = readl(IOMEM(GIC_DIST_BASE + GIC_DIST_CONFIG + (irq / 16) * 4));
 371         dbgmsg(CIRQ_LOG_LEVEL "irq:%d,sens:%08x,value:0x%08x\n",irq,GIC_DIST_BASE + GIC_DIST_CONFIG + (irq / 16) * 4,value);
 372         irq_offset = (irq-64) / 32;
 373         for (ix = 0; ix < 16; ix++)
 374         {
 375             if (value & (0x2)) //edge trigger
 376                 mt_cirq_set_sens(irq-64+ix,MT_EDGE_SENSITIVE);
 377             else//level trigger
 378                 mt_cirq_set_sens(irq-64+ix,MT_LEVEL_SENSITIVE);
 379             value >>= 2;
 380         }
 381         value_cirq = readl(IOMEM(CIRQ_SENS0 + irq_offset*4));
 382         dbgmsg(CIRQ_LOG_LEVEL "irq:%d,cirq_value:0x%08x\n",irq,value_cirq);
 383     }
 384 }
 385
 386 static void mt_cirq_clone_mask(void)
 387 {
 388     unsigned int irq,irq_offset;
 389     volatile unsigned int value;
 390     volatile unsigned int value_cirq;
 391     int ix;
 392     print_func();
 393     for (irq = 64; irq < (NR_MT_IRQ_LINE); irq+=32)
 394     {
 395         value = readl(IOMEM(GIC_DIST_BASE + GIC_DIST_ENABLE_SET + irq / 32 * 4));
 396         dbgmsg(CIRQ_LOG_LEVEL "irq:%d,mask:%08x,value:0x%08x\n",irq,(GIC_DIST_BASE + GIC_DIST_ENABLE_SET + irq / 32 * 4) ,value);
 397         irq_offset = (irq-64) / 32;
 398         for (ix = 0; ix < 32; ix++)
 399         {
 400             if (value & (0x1)) //enable
 401                 mt_cirq_unmask(irq+ix-64);
 402             else//disable
 403                 mt_cirq_mask(irq+ix-64);
 404
 405             value >>= 1;
 406         }
 407         value_cirq = readl(IOMEM(CIRQ_MASK0 + irq_offset*4));
 408         dbgmsg(CIRQ_LOG_LEVEL "irq:%d,cirq_value:0x%08x\n",irq,value_cirq);
 409     }
 410 }
 411 void mt_cirq_clone_gic(void)
 412 {
 413     mt_cirq_clone_pol();
 414     mt_cirq_clone_sens();
 415     mt_cirq_clone_mask();
 416 }
 417
 418
 419 #if defined(LDVT)
 420 /*
 421  * cirq_dvt_show: To show usage.
 422  */
 423 static ssize_t cirq_dvt_show(struct device_driver *driver, char *buf)
 424 {
 425     return snprintf(buf, PAGE_SIZE, "CIRQ dvt test\n");
 426 }
 427
 428 /*
 429  * mci_dvt_store: To select mci test case.
 430  */
 431 static ssize_t cirq_dvt_store(struct device_driver *driver, const char *buf,
 432                               size_t count)
 433 {
 434     char *p = (char *)buf;
 435     unsigned int num;
 436
 437     num = simple_strtoul(p, &p, 10);
 438     switch(num){
 439         case 1:
 440             mt_cirq_clone_gic();
 441             mt_cirq_dump_reg();
 442             break;
 443         case 2:
 444             mt_cirq_test();
 445             break;
 446         case 3:
 447             mt_cirq_disable();
 448             break;
 449         default:
 450             break;
 451     }
 452
 453     return count;
 454 }
 455 DRIVER_ATTR(cirq_dvt, 0664, cirq_dvt_show, cirq_dvt_store);
 456 #endif //!LDVT
 457
 458 /*
 459  * CIRQ interrupt service routine.
 460  */
 461 static irqreturn_t cirq_irq_handler(int irq, void *dev_id)
 462 {
 463     printk("CIRQ_Handler\n");
 464     mt_cirq_ack_all();
 465     return IRQ_HANDLED;
 466 }
 467
 468 /*
 469  * always return 0
 470  * */
 471 static int __init mt_cirq_init(void){
 472         int ret;
 473         printk("CIRQ init...\n");
 474         if (request_irq(MT_CIRQ_IRQ_ID, cirq_irq_handler, IRQF_TRIGGER_LOW, "CIRQ",  NULL)) {
 475             printk(KERN_ERR"CIRQ IRQ LINE NOT AVAILABLE!!\n");
 476         }else
 477         {
 478             printk("CIRQ handler init success.");
 479         }
 480         ret = driver_register(&mt_cirq_drv.driver);
 481 #ifdef LDVT
 482         ret = driver_create_file(&mt_cirq_drv.driver, &driver_attr_cirq_dvt);
 483 #endif
 484         if (ret == 0)
 485         printk("CIRQ init done...\n");
 486         return 0;
 487
 488 }
 489
 490 #if defined(LDVT)
 491 #define __CHECK_IRQ_TYPE
 492 #if defined(__CHECK_IRQ_TYPE)
 493 #define X_DEFINE_IRQ(__name, __num, __polarity, __sensitivity) \
 494         { .num = __num, .polarity = __polarity, .sensitivity = __sensitivity, },
 495 #define L 0
 496 #define H 1
 497 #define EDGE MT_EDGE_SENSITIVE
 498 #define LEVEL MT_LEVEL_SENSITIVE
 499 struct __check_irq_type
 500 {
 501     int num;
 502     int polarity;
 503     int sensitivity;
 504 };
 505 struct __check_irq_type __check_irq_type[] =
 506 {
 507 #include <mach/x_define_irq.h>
 508     { .num = -1, },
 509 };
 510 #undef X_DEFINE_IRQ
 511 #undef L
 512 #undef H
 513 #undef EDGE
 514 #undef LEVEL
 515 #endif
 516
 517 void mt_cirq_dump_reg(void)
 518 {
 519     int cirq_num;
 520     int pol,sens,mask;
 521     int irq_iter;
 522
 523     printk("IRQ:\tPOL\tSENS\tMASK\n");
 524     for (cirq_num = 0; cirq_num < MT_NR_CIRQ; cirq_num++)
 525     {
 526         pol = mt_cirq_get_pol(cirq_num);
 527         sens = mt_cirq_get_sens(cirq_num);
 528         mask = mt_cirq_get_mask(cirq_num);
 529 #if defined(__CHECK_IRQ_TYPE)
 530         //only check unmask irq
 531         if (0 == mask){
 532             irq_iter = 0;
 533             while (__check_irq_type[irq_iter].num >= 0) {
 534                 if (__check_irq_type[irq_iter].num == (cirq_num+64)){
 535                     if(__check_irq_type[irq_iter].sensitivity != sens){
 536                         printk("[CIRQ] Error sens in irq:%d\n",cirq_num+64);
 537                     }
 538                     if(__check_irq_type[irq_iter].polarity != (pol)){
 539                         printk("[CIRQ] Error polarity in irq:%d\n",cirq_num+64);
 540                     }
 541                     break;
 542                 }
 543                 irq_iter++;
 544             }
 545         }
 546 #endif
 547         printk("IRQ:%d\t%d\t%d\t%d\n",cirq_num+64,pol,sens,mask);
 548
 549     }
 550 }
 551 int mt_cirq_test(void)
 552 {
 553     int cirq_num = 100;
 554     mt_cirq_enable();
 555
 556     /*test polarity*/
 557     mt_cirq_set_pol(cirq_num,MT_CIRQ_POL_NEG);
 558     if ( MT_CIRQ_POL_NEG != mt_cirq_get_pol(cirq_num))
 559         printk("mt_cirq_set_pol test failed!!\n");
 560     mt_cirq_set_pol(cirq_num,MT_CIRQ_POL_POS);
 561     if ( MT_CIRQ_POL_POS != mt_cirq_get_pol(cirq_num))
 562         printk("mt_cirq_set_pol test failed!!\n");
 563
 564     /*test sensitivity*/
 565     mt_cirq_set_sens(cirq_num,MT_EDGE_SENSITIVE);
 566     if ( MT_EDGE_SENSITIVE != mt_cirq_get_sens(cirq_num))
 567         printk("mt_cirq_set_sens test failed!!\n");
 568     mt_cirq_set_sens(cirq_num,MT_LEVEL_SENSITIVE);
 569     if ( MT_LEVEL_SENSITIVE != mt_cirq_get_sens(cirq_num))
 570         printk("mt_cirq_set_sens test failed!!\n");
 571
 572     /*test mask*/
 573     mt_cirq_mask(cirq_num);
 574     if ( 1 != mt_cirq_get_mask(cirq_num))
 575         printk("mt_cirq_mask test failed!!\n");
 576     mt_cirq_unmask(cirq_num);
 577     mt_cirq_set_sens(cirq_num,MT_LEVEL_SENSITIVE);
 578     if ( 0 != mt_cirq_get_mask(cirq_num))
 579         printk("mt_cirq_unmask test failed!!\n");
 580
 581
 582     mt_cirq_clone_gic();
 583     mt_cirq_dump_reg();
 584
 585     return 0;
 586 }
 587 #endif //!LDVT
 588 arch_initcall(mt_cirq_init);
 589 EXPORT_SYMBOL(mt_cirq_enable);
 590 EXPORT_SYMBOL(mt_cirq_disable);
 591 EXPORT_SYMBOL(mt_cirq_clone_gic);
 592 EXPORT_SYMBOL(mt_cirq_flush);
 593