/alps/pcitool

To get this branch, use:
bzr branch http://darksoft.org/webbzr/alps/pcitool

« back to all changes in this revision

Viewing changes to cli.c

  • Committer: Suren A. Chilingaryan
  • Date: 2011-04-12 00:57:02 UTC
  • Revision ID: csa@dside.dyndns.org-20110412005702-ir1cch0f1feop7ay
Infrastructure for event API

Show diffs side-by-side

added added

removed removed

Lines of Context:
cli.c
18
18
#include <getopt.h>
19
19
 
20
20
#include "pci.h"
21
 
#include "ipecamera.h"
22
21
#include "tools.h"
23
22
#include "kernel.h"
24
23
 
50
49
    MODE_READ,
51
50
    MODE_READ_REGISTER,
52
51
    MODE_WRITE,
53
 
    MODE_WRITE_REGISTER
 
52
    MODE_WRITE_REGISTER,
 
53
    MODE_RESET,
 
54
    MODE_GRAB
54
55
} MODE;
55
56
 
56
57
typedef enum {
60
61
    OPT_ACCESS = 'a',
61
62
    OPT_ENDIANESS = 'e',
62
63
    OPT_SIZE = 's',
 
64
    OPT_OUTPUT = 'o',
63
65
    OPT_INFO = 'i',
64
66
    OPT_BENCHMARK = 'p',
65
67
    OPT_LIST = 'l',
66
68
    OPT_READ = 'r',
67
69
    OPT_WRITE = 'w',
 
70
    OPT_GRAB = 'g',
 
71
    OPT_RESET = 128,
68
72
    OPT_HELP = 'h',
69
73
} OPTIONS;
70
74
 
75
79
    {"access",                  required_argument, 0, OPT_ACCESS },
76
80
    {"endianess",               required_argument, 0, OPT_ENDIANESS },
77
81
    {"size",                    required_argument, 0, OPT_SIZE },
 
82
    {"size",                    required_argument, 0, OPT_OUTPUT },
78
83
    {"info",                    no_argument, 0, OPT_INFO },
79
84
    {"list",                    no_argument, 0, OPT_LIST },
 
85
    {"reset",                   no_argument, 0, OPT_RESET },
80
86
    {"benchmark",               no_argument, 0, OPT_BENCHMARK },
81
87
    {"read",                    optional_argument, 0, OPT_READ },
82
88
    {"write",                   optional_argument, 0, OPT_WRITE },
 
89
    {"grab",                    optional_argument, 0, OPT_GRAB },
83
90
    {"help",                    no_argument, 0, OPT_HELP },
84
91
    { 0, 0, 0, 0 }
85
92
};
108
115
"       -p              - Performance Evaluation\n"
109
116
"       -r <addr|reg>   - Read Data/Register\n"
110
117
"       -w <addr|reg>   - Write Data/Register\n"
 
118
"       -g <event>      - Grab Event\n"
 
119
"       --reset         - Reset board\n"
111
120
"       --help          - Help message\n"
112
121
"\n"
113
122
"  Addressing:\n"
121
130
"       -s <size>       - Number of words (default: 1)\n"
122
131
"       -a <bitness>    - Bits per word (default: 32)\n"
123
132
"       -e <l|b>        - Endianess Little/Big (default: host)\n"
 
133
"       -o <file>       - Output to file (default: stdout)\n"
124
134
"\n"
125
135
"  Data:\n"
126
136
"       Data can be specified as sequence of hexdecimal number or\n"
557
567
    return 0;
558
568
}
559
569
 
 
570
int Grab(pcilib_t *handle, const char *output) {
 
571
    int err;
 
572
    
 
573
    void *data = NULL;
 
574
    size_t size, written;
 
575
    
 
576
    FILE *o;
 
577
    
 
578
    err = pcilib_grab(handle, PCILIB_ALL_EVENTS, &size, &data, NULL);
 
579
    if (err) {
 
580
        Error("Grabbing event is failed");
 
581
    }
 
582
 
 
583
    if (output) {    
 
584
        o = fopen(output, "w");
 
585
        if (!o) {
 
586
            Error("Failed to open file \"%s\"", output);
 
587
        }
 
588
        
 
589
        printf("Writting %i bytes into %s...\n", size, output);
 
590
    } else o = stdout;
 
591
    
 
592
    written = fwrite(data, 1, size, o);
 
593
    if (written != size) {
 
594
        if (written > 0) Error("Write failed, only %z bytes out of %z are stored", written, size);
 
595
        else Error("Write failed");
 
596
    }
 
597
    
 
598
    if (o != stdout) fclose(o);
 
599
 
 
600
    return 0;
 
601
}
560
602
 
561
603
int main(int argc, char **argv) {
562
604
    int i;
571
613
    const char *reg = NULL;
572
614
    const char *bank = NULL;
573
615
    char **data = NULL;
 
616
    const char *event = NULL;
574
617
    
575
618
    uintptr_t start = -1;
576
619
    size_t size = 1;
577
620
    access_t access = 4;
578
621
    int skip = 0;
579
622
    int endianess = 0;
 
623
    const char *output = NULL;
580
624
 
581
625
    pcilib_t *handle;
582
626
    
583
 
    while ((c = getopt_long(argc, argv, "hilpr::w::d:m:b:a:s:e:", long_options, NULL)) != (unsigned char)-1) {
 
627
    while ((c = getopt_long(argc, argv, "hilpr::w::d:m:b:a:s:e:g:", long_options, NULL)) != (unsigned char)-1) {
584
628
        extern int optind;
585
629
        switch (c) {
586
630
            case OPT_HELP:
596
640
 
597
641
                mode = MODE_LIST;
598
642
            break;
 
643
            case OPT_RESET:
 
644
                if (mode != MODE_INVALID) Usage(argc, argv, "Multiple operations are not supported");
 
645
 
 
646
                mode = MODE_RESET;
 
647
            break;
599
648
            case OPT_BENCHMARK:
600
649
                if (mode != MODE_INVALID) Usage(argc, argv, "Multiple operations are not supported");
601
650
 
615
664
                if (optarg) addr = optarg;
616
665
                else if ((optind < argc)&&(argv[optind][0] != '-')) addr = argv[optind++];
617
666
            break;
 
667
            case OPT_GRAB:
 
668
                if (mode != MODE_INVALID) Usage(argc, argv, "Multiple operations are not supported");
 
669
 
 
670
                mode = MODE_GRAB;
 
671
                if (optarg) event = optarg;
 
672
                else if ((optind < argc)&&(argv[optind][0] != '-')) event = argv[optind++];
 
673
            break;
618
674
            case OPT_DEVICE:
619
675
                fpga_device = optarg;
620
676
            break;
652
708
                } else Usage(argc, argv, "Invalid endianess is specified (%s)", optarg);
653
709
                
654
710
            break;
 
711
            case OPT_OUTPUT:
 
712
                output = optarg;
 
713
            break;
655
714
            default:
656
715
                Usage(argc, argv, "Unknown option (%s)", argv[optind]);
657
716
        }
674
733
        if (!addr) Usage(argc, argv, "The address is not specified");
675
734
        if (((argc - optind) == 1)&&(*argv[optind] == '*')) {
676
735
            int vallen = strlen(argv[optind]);
677
 
            data = (char**)malloc(size * (vallen + sizeof(char*)));
678
 
            if (!data) Error("Error allocating memory for data array");
679
 
            for (i = 0; i < size; i++) {
680
 
                data[i] = ((char*)data) + size * sizeof(char*) + i * vallen;
681
 
                strcpy(data[i], argv[optind] + 1);
 
736
            if (vallen > 1) {
 
737
                data = (char**)malloc(size * (vallen + sizeof(char*)));
 
738
                if (!data) Error("Error allocating memory for data array");
 
739
 
 
740
                for (i = 0; i < size; i++) {
 
741
                    data[i] = ((char*)data) + size * sizeof(char*) + i * vallen;
 
742
                    strcpy(data[i], argv[optind] + 1);
 
743
                }
 
744
            } else {
 
745
                data = (char**)malloc(size * (9 + sizeof(char*)));
 
746
                if (!data) Error("Error allocating memory for data array");
 
747
                
 
748
                for (i = 0; i < size; i++) {
 
749
                    data[i] = ((char*)data) + size * sizeof(char*) + i * 9;
 
750
                    sprintf(data[i], "%x", i);
 
751
                }
682
752
            }
683
753
        } else if ((argc - optind) == size) data = argv + optind;
684
754
        else Usage(argc, argv, "The %i data values is specified, but %i required", argc - optind, size);
757
827
        if (reg) WriteRegister(handle, model, bank, reg, data);
758
828
        else WriteRegisterRange(handle, model, bank, start, size, data);
759
829
     break;
 
830
     case MODE_RESET:
 
831
        pcilib_reset(handle);
 
832
     break;
 
833
     case MODE_GRAB:
 
834
        Grab(handle, output);
 
835
     break;
760
836
    }
761
837
 
762
838
    pcilib_close(handle);