/*
 * Copyright © 2014 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Author:
 *    Yuan Shengquan <shengquan.yuan@intel.com>
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdint.h>
#include <errno.h>

#ifndef ANDROID
#include <readline/readline.h>
#include <readline/history.h>
#endif

#include "igdbg.yacc.h"

#include "i915_reg.h"
#include "main.h"

int iopl(int level);
int ioperm(unsigned long from, unsigned long num, int turn_on);
int yyparse();

int devmem_fd = -1;
int devmem_strict = 0;

unsigned short devid, is_gen7=0, is_gen8=0;

uint32_t phy_mmio,phy_fb, stolen_base;
unsigned char *linear_mmio,*linear_gtt,*linear_fb;/* linear mmio,fb,gtt */
unsigned int stolen_size, gtt_size, gtt_mapable_size;
int verbose=0;

char *cmd_buf=NULL,*cmd_ptr=NULL,*cmd_end=NULL;

void  print_bin_fmt(unsigned int value,int space)
{
    char buf[33];
    int i=0;
    unsigned int n = value;
    
    memset(buf,(int)'0',32);
    buf[32]='\0';
    do {
        buf[i++] = (n&1)+'0';
        n/=2;
    } while(n);
#define print_four_bits(from) printf("|%c%c%c%c|  ",buf[from],buf[from-1],buf[from-2],buf[from-3])
    for (i=0;i<space;i++) printf(" ");
    printf("31  28  27  24  23  20  19  16  15  12  11  08  07  04  03  00\n");
    for (i=0;i<space;i++) printf(" ");
    for (i=31;i>=3;i=i-4)
        print_four_bits(i);

    printf("\n");
    
    for (i=0;i<space;i++) printf(" ");
    for (i=7; i>=0;i--) {
        printf("  0x%1x   ", 0xf & (value >> (i*4)));
    }
    
    printf("\n");
}

int intel_gmch_probe(unsigned int gpu_devid)
{
    uint16_t gmch_ctrl, snb_gmch_ctrl;
    uint32_t gtt_base;
    
    pci_read_config_word(2, SNB_GMCH_CTRL, snb_gmch_ctrl);

    //chv_get_stolen_size
    gmch_ctrl = snb_gmch_ctrl;
    gmch_ctrl >>= SNB_GMCH_GMS_SHIFT;
    gmch_ctrl &= SNB_GMCH_GMS_MASK;
    /*
     * 0x0  to 0x10: 32MB increments starting at 0MB
     * 0x11 to 0x16: 4MB increments starting at 8MB
     * 0x17 to 0x1d: 4MB increments start at 36MB
     */
    if (gmch_ctrl < 0x11)
        stolen_size =  gmch_ctrl << 25;
    else if (gmch_ctrl < 0x17)
        stolen_size = (gmch_ctrl - 0x11 + 2) << 22;
    else
        stolen_size = (gmch_ctrl - 0x17 + 9) << 22;
    /* Read Graphics Base of Stolen Memory directly */
    pci_read_config_dword(2, 0x5c, stolen_base);
    stolen_base &= ~((1<<20) - 1);
    
    /* get GTT size */
    //chv_get_total_gtt_size
    gmch_ctrl = snb_gmch_ctrl;
    gmch_ctrl >>= SNB_GMCH_GGMS_SHIFT;
    gmch_ctrl &= SNB_GMCH_GGMS_MASK;
    if (is_gen7)
        gtt_size = 1<<20;
    if (is_gen8) {
        if (gmch_ctrl)
            gtt_size = 1 << (20 + gmch_ctrl);
    }
    gtt_mapable_size = (gtt_size/8)*4096;

    /* Read Graphics Translate Talbe Base */
    pci_read_config_dword(2, 0x70, gtt_base);
    gtt_base &= ~((1<<20) - 1);
    
    printf("Stolen size =%dK (physical base=[0x%x~0x%x](%dM~%dM))\n",
           stolen_size/1024, stolen_base, stolen_base+stolen_size,
           stolen_base>>20, (stolen_base+stolen_size)>>20);
    printf("GTT size = %dK (Can map %dM memory), location at 0x%x (%dM)\n",
           gtt_size/1024, gtt_mapable_size>>20, gtt_base, gtt_base>>20);
    
    return 0;
}

unsigned int check_deviceid(void)
{
    switch (devid) {
    case 0x0152:
    case 0x0162:
    case 0x0156:
    case 0x0166:
    case 0x015a:
    case 0x016a:
        is_gen7 = 1;
        printf("Found Ivybridge(GEN7)\n");
        return devid;
    case 0x0a06:
    case 0x0a16:
    case 0x0a26:
    case 0x0d06:
    case 0x0d16:
    case 0x0d26:
        is_gen7 = 1;
        printf("Found Haswell(GEN7)\n");
        return devid;
    case 0x22b0:
    case 0x22b1:
    case 0x22b2:
    case 0x22b3:
        is_gen8 = 1;
        printf("Found CherryView(GEN8)\n");
        return devid;
    }    

    return 0;
}

/*
00:02.0 Class 0300: Device 8086:22b0 (rev 14)
Subsystem: Device 8086:7270
Flags: bus master, fast devsel, latency 0, IRQ 133
    Memory at 90000000 (64-bit, non-prefetchable) [size=16M]
    Memory at 80000000 (64-bit, prefetchable) [size=256M]
            I/O ports at 1000 [size=64]
            Expansion ROM at <unassigned> [disabled]
    Capabilities: [d0] Power Management version 2
    Capabilities: [90] MSI: Enable+ Count=1/1 Maskable- 64bit-
    Capabilities: [b0] Vendor Specific Information: Len=07 <?>
    Kernel driver in use: i915
*/
static int setup_devmem(void)
{
    uint32_t value_dw0; /* the first DWORD of PCI config */
    int fd=devmem_fd, mmio_size;

    /* Allow read/write to ALL io ports */
    ioperm(0, 1024, 1);
    iopl(3);

    /* get the physical mmio address */
    value_dw0 = pci_get_long(0,(2<<3),0/*PCI_DEVICE_ID*/);
    devid = (value_dw0 >> 16) & 0xffff; /* byte 2/3 is device ID */
    if (check_deviceid() == 0) {
        fprintf(stderr,"Chip id=0x%x,not supported,exit\n",devid);
        return 1;
    }

    /* pci base0: mmio/gtt
     * pci base2: aperture
     */
    phy_mmio = pci_get_long(0,2<<3, PCI_BASE_ADDRESS_0);
    printf("MMADR:  PCI base0 for MMIO/GTT is 0x%08x\n", phy_mmio);
    phy_fb = pci_get_long(0,2<<3, PCI_BASE_ADDRESS_2);
    printf("GMADR:  PCI base2 for Aperture is 0x%08x\n", phy_fb);
    
    phy_mmio &= ~4095;
    phy_fb &= ~4095;

    /* map mmio/gtt to user space */
    if (is_gen7)
        mmio_size = 2 << 20;
    if (is_gen8)
        mmio_size = 8 << 20;
    linear_mmio = (unsigned char *)mmap64(NULL, mmio_size, PROT_READ|PROT_WRITE, 
                                          MAP_SHARED, fd, phy_mmio);
    linear_gtt = (unsigned char *)mmap64(NULL, mmio_size, PROT_READ|PROT_WRITE, 
                                         MAP_SHARED, fd, phy_mmio + mmio_size);
    if ((linear_mmio == MAP_FAILED) || (linear_gtt == MAP_FAILED)) {
        fprintf(stderr, "Mapping mmio or gtt address 0x%x failed, reason %s\n",
                phy_mmio, strerror(errno));
        fprintf(stderr, "Please try \"nopat\" in kernel boot command line?\n");
        return 1;  
    }

    /* map frame buffer to user space */
    linear_fb = (unsigned char *)mmap64(NULL,FB_MMAP_MB<<20, PROT_READ|PROT_WRITE, 
                                        MAP_SHARED, fd, phy_fb);
    if (linear_fb == MAP_FAILED) {
        fprintf(stderr, "Mapping framebuffer address 0x%x failed, reason %s\n",
                phy_fb, strerror(errno));
        return 1;  
    }
    intel_gmch_probe(devid);

    unsigned char dummy[16];
    lseek(fd, 0x1000000, SEEK_SET); /* kernel code address */
    if (read(fd, dummy, 16) == -1) {
        fprintf(stderr, "CONFIG_STRICT_DEVMEM is enabled and system RAM dump is disabled\n");
        devmem_strict = 1;
    }
    return 0;
}

static int process_exit(char *cmdhdr)
{
    exit(0);

    return 0;
}

static int process_help(char *cmdhdr)
{
    printf("igdbg -v -d <device> -c <comand>\n");
    printf("  Device by defalt is /dev/mem which may forbit RAM dump due to kernel CONFIG_STRICT_DEVMEM\n");
    printf("  Kernel module in linux/ provide a similar /dev/mem which is not restricted by STRICT_DEVMEM kernel config \n");
    printf("  Command is a single command which is executed immediately. Without it, it will display a prompt to enter the command\n");
    printf("  Command list\n");
    printf("     exit: exit igdbg\n");
    printf("     help: dump this help infomation\n");
    printf("     verbose: verbose display\n");
    printf("     irq <time>: sample IRQ for seconds\n");
    printf("     regread <reg>: get the value of a register\n");
    printf("     regwrite <reg> <value>: write value into a register\n");
    printf("     onscreen: dump gtt information of current onscreen display\n");
    printf("         onscreen buffer is from ADPA(Analog Display Port Register) or DSPASurf/DSPABSurf register\n");
    printf("     dumpfb <offset> <size>: dump content of frambuffer\n");
    printf("     dumpfbl <offset> <size>: dump content of frambuffer with linear mode\n");
    printf("     fillfb <offset> <size> <value>:fill framebuffer\n");
    printf("     fillfbl <offset> <size> <value>:fill framebuffer with linear mode\n");
    printf("     dumpgtt <start addr> <size>: dump gtt information of current display\n");
    printf("     dumpstat <context state bo>: dump context state buffer of a ring\n");
    printf("        <state bo> can get by (bellow example the bo is 0x0af2f000):\n");
    printf("        adb shell cat /sys/kernel/debug/dri/0/i915_context_status\n");
    printf("           render ring: ffff8800196bcc40:.... (pinned x 1) (ggtt offset: 0af2f000, size....)\n");
    printf("     dumppgtt <context state bo>: dump the ppgtt mapping of a context\n");
    printf("     dumpring <context state bo> <head> <tail>: dump the ring including the chained batch buffer\n");
    printf("     fence: dump fence registers\n");
    printf("     pipe: dump pipe information\n");
    printf("     plane: dump plane information\n");
    printf("     port: dump port information\n");
    printf("     overlay: dump overlay register\n");
    printf("     pciread <bus> <dev> <func> <offset>: read dword value from the offset of pci configuration space\n");
    printf("     pciwrite <bus> <dev> <func> <offset> <value>: read dword value into the offset of pci configuration space\n");
    printf("     dumppci: dump pci configuration space\n");
    printf("     inl <port>: get a value from a port\n");
    printf("     msgread <port> <reg> : read MSG from port and reg\n");
    printf("     msgwrite <port> <reg> <value>: write value to MSG port reg\n");
    return 0;
}

static int process_verbose(char *cmdhdr)
{
    printf("Enable verbose display\n");
    verbose=1;

    return 0;
}


static int process_dumppci(char *cmdhdr)
{
    int i;
    for (i=0;i<256;i=i+4) {
        uint32_t value=pci_get_long(0,2<<3,i);
        if ((i % 16)==0) 
            printf("\n0x%02x: ",i);
        printf("%02x %02x %02x %02x ",
               (unsigned char)((value)&0xff),(unsigned char)((value>>8)&0xff),
               (unsigned char)((value>>16)&0xff),(unsigned char)((value>>24)&0xff));
    }
    printf("\n");
    
    return 0;
}

int process_inl(char *cmdhdr,unsigned int reg)
{
    unsigned int value=inl(reg);
    
    printf("read port 0x%x,value is 0x%08x\n",reg,value);

    print_bin_fmt(value,15);
    
    return 0;
}

static int process_pciwrite(char *cmdhdr,unsigned int bus, unsigned int dev, unsigned func,
                            unsigned int offset,unsigned int value)
{
    if (offset & 3) {
        fprintf(stderr,"offset isn't dword aligned, change it from %d to %d\n",
                offset, offset & 0xfffffffc);
        offset = offset & 0xfffffffc;
    }
    printf("write pci configuration space offset 0x%x with value 0x%x,original value 0x%x\n",
           offset,value,pci_get_long(bus, PCI_DEVFN(dev, func),offset));
    pci_set_long(bus, PCI_DEVFN(dev, func),offset,value);
    printf("      read back the value:0x%x\n",pci_get_long(bus, PCI_DEVFN(dev, func),offset));

    return 0;
}


static int process_pciread(char *cmdhdr,unsigned int bus, unsigned int dev, unsigned func,
                            unsigned int offset)
{
    uint32_t value;
    
    if (offset & 3) {
        fprintf(stderr,"offset isn't dword aligned, change it from %d to %d\n",
                offset, offset & 0xfffffffc);
        offset = offset & 0xfffffffc;
    }
    value = pci_get_long(bus, PCI_DEVFN(dev, func),offset);
    
    printf("read pci configuration space offset 0x%x, value 0x%x\n",
           offset,value);
    print_bin_fmt(value,15);

    return 0;
}

/*  add one command...
 *  1. add one entry into this cmd_list
 *  2. define its handler in this file
 *  3. add the command synax into igdbg.lex
 */
typedef unsigned int (*cmd_handler)(char *cmdhdr,...);
struct cmd_struct {
    char *cmd;
    cmd_handler func;
} cmd_list[] = {
    {"exit",(cmd_handler)process_exit },
    {"quit",(cmd_handler)process_exit },
    {"help",(cmd_handler)process_help },
    {"verbose",(cmd_handler)process_verbose },
    {"regread",(cmd_handler)process_regread },
    {"regwrite",(cmd_handler)process_regwrite },
    {"onscreen",(cmd_handler)process_onscreen },
    {"dumpfb",(cmd_handler)process_dumpfb },
    {"fillfb",(cmd_handler)process_fillfb },
    {"dumpfbl",(cmd_handler)process_dumpfbl },
    {"fillfbl",(cmd_handler)process_fillfbl },
    {"irq",(cmd_handler)process_irq },
    {"pipe",(cmd_handler)process_pipe },
    {"port",(cmd_handler)process_port },
    {"plane",(cmd_handler)process_plane },
    {"overlay",(cmd_handler)process_overlay },
    {"fence",(cmd_handler)process_fence },
    {"stolen",(cmd_handler)process_stolen },
    {"dumpgtt",(cmd_handler)process_dumpgtt },
    {"dumppgtt",(cmd_handler)process_dumpppgtt },
    {"dumpstat",(cmd_handler)process_dumpstat },
    {"dumpring",(cmd_handler)process_dumpring },
    {"estatus",(cmd_handler)process_estatus },
    {"cstatus",(cmd_handler)process_cstatus },
    {"dumppci",(cmd_handler)process_dumppci },
    {"pciread",(cmd_handler)process_pciread },
    {"pciwrite",(cmd_handler)process_pciwrite },
    {"inl",(cmd_handler)process_inl },
    {"msgread",(cmd_handler)process_msgread },
    {"msgwrite",(cmd_handler)process_msgwrite },
};

int process_cmd(char *cmdhdr,int argc, ...)
{
    va_list arg_ptr;
    cmd_handler handler=NULL;
    unsigned int i;

    for (i=0; i<sizeof(cmd_list)/sizeof(struct cmd_struct); i++) {
        if (strcmp(cmd_list[i].cmd,cmdhdr) == 0) {
            handler = cmd_list[i].func;
            break;
        }
    }

    if (handler==NULL) {
        fprintf(stderr,"invalide command: %s\n",cmdhdr);
        return 1;
    }
    
    va_start(arg_ptr,argc);

    forcewake_on();
    
    if (argc==0)
        handler(cmdhdr);
    else if (argc==1) {
        unsigned int para1;

        para1 = va_arg(arg_ptr,unsigned int);
        handler(cmdhdr,para1);
    } if (argc==2) {
        unsigned int para1,para2;

        para1 = va_arg(arg_ptr,unsigned int);
        para2 = va_arg(arg_ptr,unsigned int);
        handler(cmdhdr,para1,para2);
    } if (argc==3) {
        unsigned int para1,para2,para3;

        para1 = va_arg(arg_ptr,unsigned int);
        para2 = va_arg(arg_ptr,unsigned int);
        para3 = va_arg(arg_ptr,unsigned int);
        handler(cmdhdr,para1,para2,para3);
    } if (argc==4) {
        unsigned int para1,para2,para3,para4;

        para1 = va_arg(arg_ptr,unsigned int);
        para2 = va_arg(arg_ptr,unsigned int);
        para3 = va_arg(arg_ptr,unsigned int);
        para4 = va_arg(arg_ptr,unsigned int);
        handler(cmdhdr,para1,para2,para3,para4);
    } if (argc==5) {
        unsigned int para1,para2,para3,para4,para5;

        para1 = va_arg(arg_ptr,unsigned int);
        para2 = va_arg(arg_ptr,unsigned int);
        para3 = va_arg(arg_ptr,unsigned int);
        para4 = va_arg(arg_ptr,unsigned int);
        para5 = va_arg(arg_ptr,unsigned int);
        handler(cmdhdr,para1,para2,para3,para4,para5);
    } if (argc==0xff) { /* command is <cmd subcmd str1 str2> */
        unsigned char *subcmd,*filename;

        subcmd = va_arg(arg_ptr,unsigned char *);
        filename = va_arg(arg_ptr,unsigned char *);
        handler(cmdhdr,subcmd,filename);
    }
    if (argc==0xfe) { /* command is <cmd subcmd exp1 exp2 exp3> */
        unsigned char *subcmd;
        unsigned int para1, para2, para3;
        subcmd = va_arg(arg_ptr,unsigned char *);
        para1 = va_arg(arg_ptr,unsigned int);
        para2 = va_arg(arg_ptr,unsigned int);
        para3 = va_arg(arg_ptr,unsigned int);
        handler(cmdhdr,subcmd,para1, para2, para3);
    }
    forcewake_off();
    
    va_end(arg_ptr);
    free(cmdhdr);

    return 0;
}

int main(int argc, char *argv[])
{
    char opt;
    char *devmem = NULL;
    
    while ((opt=getopt(argc,argv,"hvc:d:")) != -1) {
        switch (opt) {
            case 'v':
                verbose = 1;
                break;
            case 'c':
                cmd_buf = optarg;
                break;
            case 'd':
                devmem = strdup(optarg);
                break;
            case 'h':
            case '?':
            default:
                process_help("help");
                exit(0);
        }
    }
    /*
    if (open_ioport()) {
        printf("can't opne /dev/port\n");
    }
    */
    if (devmem == NULL)
        devmem = strdup("/dev/mem");

    devmem_fd = open(devmem, O_RDWR);
    if (devmem_fd == -1) {
        fprintf(stderr, "Open %s failed:%s\n", devmem, strerror(errno));
        return 1;
    }

    printf("**********************************************\n");
    if (setup_devmem()) {
        close(devmem_fd);
        exit(-1);
    }
    printf("**********************************************\n");

    if (cmd_buf) {
        cmd_ptr = cmd_buf;
        cmd_end = cmd_ptr + strlen(cmd_buf);
        yyparse();

        close(devmem_fd);

        return 0;
    }

#ifdef ANDROID
    cmd_buf = (char *)malloc(1024);
#endif        
    for (;;) {
#ifdef ANDROID
        printf("(igdbg)");
        gets(cmd_buf);
#else            
        cmd_buf = readline("(igdbg)");
#endif            
        if (!cmd_buf)
            break;
        if (strlen(cmd_buf)==0)
            continue;
            
        cmd_ptr = cmd_buf;
        cmd_end = cmd_ptr + strlen(cmd_buf);
            
        yyparse();
    }
    free(cmd_buf);

    close(devmem_fd);
    
    return 0;
}