/alps/pcitool

To get this branch, use:
bzr branch http://suren.me/webbzr/alps/pcitool

« back to all changes in this revision

Viewing changes to cli.c

  • Committer: Suren A. Chilingaryan
  • Date: 2011-07-09 03:33:18 UTC
  • Revision ID: csa@dside.dyndns.org-20110709033318-2k7vk5s5p5u7btem
Support dynamic registers, support register offsets and multiregisters (bitmasks), list NWL DMA registers

Show diffs side-by-side

added added

removed removed

Lines of Context:
cli.c
172
172
void Silence(const char *format, ...) {
173
173
}
174
174
 
175
 
void List(pcilib_t *handle, pcilib_model_t model, const char *bank) {
 
175
void List(pcilib_t *handle, pcilib_model_description_t *model_info, const char *bank, int details) {
176
176
    int i;
177
177
    pcilib_register_bank_description_t *banks;
178
178
    pcilib_register_description_t *registers;
180
180
 
181
181
    const pcilib_board_info_t *board_info = pcilib_get_board_info(handle);
182
182
    const pcilib_dma_info_t *dma_info = pcilib_get_dma_info(handle);
183
 
 
 
183
    
184
184
    for (i = 0; i < PCILIB_MAX_BANKS; i++) {
185
185
        if (board_info->bar_length[i] > 0) {
186
186
            printf(" BAR %d - ", i);
232
232
    }
233
233
 
234
234
    if ((bank)&&(bank != (char*)-1)) banks = NULL;
235
 
    else banks = pcilib_model[model].banks;
 
235
    else banks = model_info->banks;
236
236
    
237
237
    if (banks) {
238
238
        printf("Banks: \n");
247
247
    }
248
248
    
249
249
    if (bank == (char*)-1) registers = NULL;
250
 
    else registers = pcilib_model[model].registers;
 
250
    else registers = model_info->registers;
251
251
    
252
252
    if (registers) {
253
253
        pcilib_register_bank_addr_t bank_addr;
254
254
        if (bank) {
255
255
            pcilib_register_bank_t bank_id = pcilib_find_bank(handle, bank);
256
 
            pcilib_register_bank_description_t *b = pcilib_model[model].banks + bank_id;
 
256
            pcilib_register_bank_description_t *b = model_info->banks + bank_id;
257
257
 
258
258
            bank_addr = b->addr;
259
259
            if (b->description) printf("%s:\n", b->description);
266
266
            const char *mode;
267
267
            
268
268
            if ((bank)&&(registers[i].bank != bank_addr)) continue;
 
269
            if (registers[i].type == PCILIB_REGISTER_BITS) {
 
270
                if (!details) continue;
 
271
                
 
272
                if (registers[i].bits > 1) {
 
273
                    printf("    [%2u:%2u] - %s\n", registers[i].offset, registers[i].offset + registers[i].bits, registers[i].name);
 
274
                } else {
 
275
                    printf("    [   %2u] - %s\n", registers[i].offset, registers[i].name);
 
276
                }
 
277
                
 
278
                continue;
 
279
            }
269
280
 
270
281
            if (registers[i].mode == PCILIB_REGISTER_RW) mode = "RW";
271
282
            else if (registers[i].mode == PCILIB_REGISTER_R) mode = "R ";
273
284
            else mode = "  ";
274
285
            
275
286
            printf(" 0x%02x (%2i %s) %s", registers[i].addr, registers[i].bits, mode, registers[i].name);
276
 
            if ((registers[i].description)&&(registers[i].description[0])) {
 
287
            if ((details > 0)&&(registers[i].description)&&(registers[i].description[0])) {
277
288
                printf(": %s", registers[i].description);
278
289
            }
279
290
            printf("\n");
283
294
    }
284
295
 
285
296
    if (bank == (char*)-1) events = NULL;
286
 
    else events = pcilib_model[model].events;
 
297
    else events = model_info->events;
287
298
 
288
299
    if (events) {
289
300
        printf("Events: \n");
297
308
    }
298
309
}
299
310
 
300
 
void Info(pcilib_t *handle, pcilib_model_t model) {
 
311
void Info(pcilib_t *handle, pcilib_model_description_t *model_info) {
301
312
    const pcilib_board_info_t *board_info = pcilib_get_board_info(handle);
302
313
 
303
314
    printf("Vendor: %x, Device: %x, Interrupt Pin: %i, Interrupt Line: %i\n", board_info->vendor_id, board_info->device_id, board_info->interrupt_pin, board_info->interrupt_line);
304
 
    List(handle, model, (char*)-1);
 
315
    List(handle, model_info, (char*)-1, 0);
305
316
}
306
317
 
307
318
 
567
578
 
568
579
 
569
580
 
570
 
int ReadRegister(pcilib_t *handle, pcilib_model_t model, const char *bank, const char *reg) {
 
581
int ReadRegister(pcilib_t *handle, pcilib_model_description_t *model_info, const char *bank, const char *reg) {
571
582
    int i;
572
583
    int err;
573
584
    const char *format;
574
585
 
575
586
    pcilib_register_bank_t bank_id;
576
587
    pcilib_register_bank_addr_t bank_addr;
577
 
    pcilib_register_description_t *registers = pcilib_model[model].registers;
578
588
 
579
589
    pcilib_register_value_t value;
580
590
    
581
591
    if (reg) {
582
592
        pcilib_register_t regid = pcilib_find_register(handle, bank, reg);
583
 
        bank_id = pcilib_find_bank_by_addr(handle, registers[regid].bank);
584
 
        format = pcilib_model[model].banks[bank_id].format;
 
593
        bank_id = pcilib_find_bank_by_addr(handle, model_info->registers[regid].bank);
 
594
        format = model_info->banks[bank_id].format;
585
595
        if (!format) format = "%lu";
586
596
 
587
597
        err = pcilib_read_register_by_id(handle, regid, &value);
593
603
            printf("\n");
594
604
        }
595
605
    } else {
596
 
        
597
 
        if (registers) {
 
606
            // Adding DMA registers
 
607
        pcilib_get_dma_info(handle);    
 
608
    
 
609
        if (model_info->registers) {
598
610
            if (bank) {
599
611
                bank_id = pcilib_find_bank(handle, bank);
600
 
                bank_addr = pcilib_model[model].banks[bank_id].addr;
 
612
                bank_addr = model_info->banks[bank_id].addr;
601
613
            }
602
614
            
603
615
            printf("Registers:\n");
604
 
            for (i = 0; registers[i].bits; i++) {
605
 
                if ((registers[i].mode & PCILIB_REGISTER_R)&&((!bank)||(registers[i].bank == bank_addr))) {
606
 
                    bank_id = pcilib_find_bank_by_addr(handle, registers[i].bank);
607
 
                    format = pcilib_model[model].banks[bank_id].format;
 
616
            for (i = 0; model_info->registers[i].bits; i++) {
 
617
                if ((model_info->registers[i].mode & PCILIB_REGISTER_R)&&((!bank)||(model_info->registers[i].bank == bank_addr))&&(model_info->registers[i].type != PCILIB_REGISTER_BITS)) { 
 
618
                    bank_id = pcilib_find_bank_by_addr(handle, model_info->registers[i].bank);
 
619
                    format = model_info->banks[bank_id].format;
608
620
                    if (!format) format = "%lu";
609
621
 
610
622
                    err = pcilib_read_register_by_id(handle, i, &value);
611
 
                    if (err) printf(" %s = error reading value", registers[i].name);
 
623
                    if (err) printf(" %s = error reading value", model_info->registers[i].name);
612
624
                    else {
613
 
                        printf(" %s = ", registers[i].name);
 
625
                        printf(" %s = ", model_info->registers[i].name);
614
626
                        printf(format, value);
615
627
                    }
616
628
 
617
629
                    printf(" [");
618
 
                    printf(format, registers[i].defvalue);
 
630
                    printf(format, model_info->registers[i].defvalue);
619
631
                    printf("]");
 
632
                    printf("\n");
620
633
                }
621
 
                printf("\n");
622
634
            }
623
635
        } else {
624
636
            printf("No registers");
627
639
    }
628
640
}
629
641
 
630
 
int ReadRegisterRange(pcilib_t *handle, pcilib_model_t model, const char *bank, uintptr_t addr, size_t n) {
 
642
int ReadRegisterRange(pcilib_t *handle, pcilib_model_description_t *model_info, const char *bank, uintptr_t addr, size_t n) {
631
643
    int err;
632
644
    int i;
633
645
 
634
 
    pcilib_register_bank_description_t *banks = pcilib_model[model].banks;
 
646
    pcilib_register_bank_description_t *banks = model_info->banks;
635
647
    pcilib_register_bank_t bank_id = pcilib_find_bank(handle, bank);
636
648
 
637
649
    if (bank_id == PCILIB_REGISTER_BANK_INVALID) {
726
738
    free(buf);
727
739
}
728
740
 
729
 
int WriteRegisterRange(pcilib_t *handle, pcilib_model_t model, const char *bank, uintptr_t addr, size_t n, char ** data) {
 
741
int WriteRegisterRange(pcilib_t *handle, pcilib_model_description_t *model_info, const char *bank, uintptr_t addr, size_t n, char ** data) {
730
742
    pcilib_register_value_t *buf, *check;
731
743
    int res, i, err;
732
744
    unsigned long value;
750
762
 
751
763
    if (memcmp(buf, check, size)) {
752
764
        printf("Write failed: the data written and read differ, the foolowing is read back:\n");
753
 
        ReadRegisterRange(handle, model, bank, addr, n);
 
765
        ReadRegisterRange(handle, model_info, bank, addr, n);
754
766
        exit(-1);
755
767
    }
756
768
 
759
771
 
760
772
}
761
773
 
762
 
int WriteRegister(pcilib_t *handle, pcilib_model_t model, const char *bank, const char *reg, char ** data) {
 
774
int WriteRegister(pcilib_t *handle, pcilib_model_description_t *model_info, const char *bank, const char *reg, char ** data) {
763
775
    int err;
764
776
    int i;
765
777
 
827
839
    long itmp;
828
840
    unsigned char c;
829
841
 
 
842
    int details = 0;
830
843
    int quiete = 0;
831
844
    
832
845
    pcilib_model_t model = PCILIB_MODEL_DETECT;
 
846
    pcilib_model_description_t *model_info;
833
847
    MODE mode = MODE_INVALID;
834
848
    const char *type = NULL;
835
849
    ACCESS_MODE amode = ACCESS_BAR;
865
879
                mode = MODE_INFO;
866
880
            break;
867
881
            case OPT_LIST:
868
 
                if (mode != MODE_INVALID) Usage(argc, argv, "Multiple operations are not supported");
 
882
                if (mode == MODE_LIST) details++;
 
883
                else if (mode != MODE_INVALID) Usage(argc, argv, "Multiple operations are not supported");
869
884
 
870
885
                mode = MODE_LIST;
871
886
            break;
966
981
    if (handle < 0) Error("Failed to open FPGA device: %s", fpga_device);
967
982
 
968
983
    model = pcilib_get_model(handle);
 
984
    model_info = pcilib_get_model_description(handle);
969
985
 
970
986
    switch (mode) {
971
987
     case MODE_WRITE:
1027
1043
            amode = ACCESS_BAR;
1028
1044
        } else if ((isxnumber(addr))&&(sscanf(addr, "%lx", &start) == 1)) {
1029
1045
                // check if the address in the register range
1030
 
            pcilib_register_range_t *ranges =  pcilib_model[model].ranges;
 
1046
            pcilib_register_range_t *ranges =  model_info->ranges;
1031
1047
            
1032
1048
            if (ranges) {
1033
1049
                for (i = 0; ranges[i].start != ranges[i].end; i++) 
1069
1085
 
1070
1086
    switch (mode) {
1071
1087
     case MODE_INFO:
1072
 
        Info(handle, model);
 
1088
        Info(handle, model_info);
1073
1089
     break;
1074
1090
     case MODE_LIST:
1075
 
        List(handle, model, bank);
 
1091
        List(handle, model_info, bank, details);
1076
1092
     break;
1077
1093
     case MODE_BENCHMARK:
1078
1094
        Benchmark(handle, amode, dma, bar, start, size_set?size:0, access);
1085
1101
        }
1086
1102
     break;
1087
1103
     case MODE_READ_REGISTER:
1088
 
        if ((reg)||(!addr)) ReadRegister(handle, model, bank, reg);
1089
 
        else ReadRegisterRange(handle, model, bank, start, size);
 
1104
        if ((reg)||(!addr)) ReadRegister(handle, model_info, bank, reg);
 
1105
        else ReadRegisterRange(handle, model_info, bank, start, size);
1090
1106
     break;
1091
1107
     case MODE_WRITE:
1092
1108
        WriteData(handle, amode, dma, bar, start, size, access, endianess, data);
1093
1109
     break;
1094
1110
     case MODE_WRITE_REGISTER:
1095
 
        if (reg) WriteRegister(handle, model, bank, reg, data);
1096
 
        else WriteRegisterRange(handle, model, bank, start, size, data);
 
1111
        if (reg) WriteRegister(handle, model_info, bank, reg, data);
 
1112
        else WriteRegisterRange(handle, model_info, bank, start, size, data);
1097
1113
     break;
1098
1114
     case MODE_RESET:
1099
1115
        pcilib_reset(handle);