/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: 2015-04-20 20:01:04 UTC
  • Revision ID: csa@suren.me-20150420200104-b5xny65io8lvoz3w
Big redign of model structures

Show diffs side-by-side

added added

removed removed

Lines of Context:
cli.c
28
28
#include "pcitool/sysinfo.h"
29
29
#include "pcitool/formaters.h"
30
30
 
31
 
//#include "pci.h"
 
31
#include "pci.h"
32
32
#include "tools.h"
33
 
#include "kernel.h"
 
33
#include "kmem.h"
34
34
#include "error.h"
 
35
#include "model.h"
35
36
 
36
37
/* defines */
37
38
#define MAX_KBUF 14
353
354
void Silence(const char *format, ...) {
354
355
}
355
356
 
356
 
void List(pcilib_t *handle, pcilib_model_description_t *model_info, const char *bank, int details) {
 
357
void List(pcilib_t *handle, const pcilib_model_description_t *model_info, const char *bank, int details) {
357
358
    int i,j;
358
 
    pcilib_register_bank_description_t *banks;
359
 
    pcilib_register_description_t *registers;
360
 
    pcilib_event_description_t *events;
361
 
    pcilib_event_data_type_description_t *types;
 
359
    const pcilib_register_bank_description_t *banks;
 
360
    const pcilib_register_description_t *registers;
 
361
    const pcilib_event_description_t *events;
 
362
    const pcilib_event_data_type_description_t *types;
362
363
 
363
364
    const pcilib_board_info_t *board_info = pcilib_get_board_info(handle);
364
 
    const pcilib_dma_info_t *dma_info = pcilib_get_dma_info(handle);
 
365
    const pcilib_dma_description_t *dma_info = pcilib_get_dma_info(handle);
365
366
    
366
 
    for (i = 0; i < PCILIB_MAX_BANKS; i++) {
 
367
    for (i = 0; i < PCILIB_MAX_BARS; i++) {
367
368
        if (board_info->bar_length[i] > 0) {
368
369
            printf(" BAR %d - ", i);
369
370
 
384
385
    
385
386
    if ((dma_info)&&(dma_info->engines)) {
386
387
        printf("DMA Engines: \n");
387
 
        for (i = 0; dma_info->engines[i]; i++) {
388
 
            pcilib_dma_engine_description_t *engine = dma_info->engines[i];
 
388
        for (i = 0; dma_info->engines[i].addr_bits; i++) {
 
389
            const pcilib_dma_engine_description_t *engine = &dma_info->engines[i];
389
390
            printf(" DMA %2d ", engine->addr);
390
391
            switch (engine->direction) {
391
392
                case PCILIB_DMA_FROM_DEVICE:
436
437
    if (registers) {
437
438
        pcilib_register_bank_addr_t bank_addr = 0;
438
439
        if (bank) {
439
 
            pcilib_register_bank_t bank_id = pcilib_find_bank(handle, bank);
440
 
            pcilib_register_bank_description_t *b = model_info->banks + bank_id;
 
440
            pcilib_register_bank_t bank_id = pcilib_find_register_bank(handle, bank);
 
441
            const pcilib_register_bank_description_t *b = model_info->banks + bank_id;
441
442
 
442
443
            bank_addr = b->addr;
443
444
            if (b->description) printf("%s:\n", b->description);
506
507
    }
507
508
}
508
509
 
509
 
void Info(pcilib_t *handle, pcilib_model_description_t *model_info) {
 
510
void Info(pcilib_t *handle, const pcilib_model_description_t *model_info) {
510
511
    const pcilib_board_info_t *board_info = pcilib_get_board_info(handle);
511
512
 
512
513
    printf("Vendor: %x, Device: %x, Bus: %x, Slot: %x, Function: %x\n", board_info->vendor_id, board_info->device_id, board_info->bus, board_info->slot, board_info->func);
578
579
        unsigned long maxlength = 0;
579
580
        
580
581
 
581
 
        for (i = 0; i < PCILIB_MAX_BANKS; i++) {
 
582
        for (i = 0; i < PCILIB_MAX_REGISTER_BANKS; i++) {
582
583
            if ((addr >= board_info->bar_start[i])&&((board_info->bar_start[i] + board_info->bar_length[i]) >= (addr + access))) {
583
584
                bar = i;
584
585
                break;
895
896
 
896
897
 
897
898
 
898
 
int ReadRegister(pcilib_t *handle, pcilib_model_description_t *model_info, const char *bank, const char *reg) {
 
899
int ReadRegister(pcilib_t *handle, const pcilib_model_description_t *model_info, const char *bank, const char *reg) {
899
900
    int i;
900
901
    int err;
901
902
    const char *format;
907
908
    
908
909
    if (reg) {
909
910
        pcilib_register_t regid = pcilib_find_register(handle, bank, reg);
910
 
        bank_id = pcilib_find_bank_by_addr(handle, model_info->registers[regid].bank);
 
911
        bank_id = pcilib_find_register_bank_by_addr(handle, model_info->registers[regid].bank);
911
912
        format = model_info->banks[bank_id].format;
912
913
        if (!format) format = "%lu";
913
914
 
925
926
    
926
927
        if (model_info->registers) {
927
928
            if (bank) {
928
 
                bank_id = pcilib_find_bank(handle, bank);
 
929
                bank_id = pcilib_find_register_bank(handle, bank);
929
930
                bank_addr = model_info->banks[bank_id].addr;
930
931
            }
931
932
            
932
933
            printf("Registers:\n");
933
934
            for (i = 0; model_info->registers[i].bits; i++) {
934
935
                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)) { 
935
 
                    bank_id = pcilib_find_bank_by_addr(handle, model_info->registers[i].bank);
 
936
                    bank_id = pcilib_find_register_bank_by_addr(handle, model_info->registers[i].bank);
936
937
                    format = model_info->banks[bank_id].format;
937
938
                    if (!format) format = "%lu";
938
939
 
966
967
    fwrite(tbuf, access/8, n, o); \
967
968
}
968
969
 
969
 
int ReadRegisterRange(pcilib_t *handle, pcilib_model_description_t *model_info, const char *bank, uintptr_t addr, long addr_shift, size_t n, FILE *o) {
 
970
int ReadRegisterRange(pcilib_t *handle, const pcilib_model_description_t *model_info, const char *bank, uintptr_t addr, long addr_shift, size_t n, FILE *o) {
970
971
    int err;
971
972
    int i;
972
973
 
973
 
    pcilib_register_bank_description_t *banks = model_info->banks;
974
 
    pcilib_register_bank_t bank_id = pcilib_find_bank(handle, bank);
 
974
    const pcilib_register_bank_description_t *banks = model_info->banks;
 
975
    pcilib_register_bank_t bank_id = pcilib_find_register_bank(handle, bank);
975
976
 
976
977
    if (bank_id == PCILIB_REGISTER_BANK_INVALID) {
977
978
        if (bank) Error("Invalid register bank is specified (%s)", bank);
1087
1088
    return 0;
1088
1089
}
1089
1090
 
1090
 
int WriteRegisterRange(pcilib_t *handle, pcilib_model_description_t *model_info, const char *bank, uintptr_t addr, long addr_shift, size_t n, char ** data) {
 
1091
int WriteRegisterRange(pcilib_t *handle, const pcilib_model_description_t *model_info, const char *bank, uintptr_t addr, long addr_shift, size_t n, char ** data) {
1091
1092
    pcilib_register_value_t *buf, *check;
1092
1093
    int res, i, err;
1093
1094
    unsigned long value;
1122
1123
 
1123
1124
}
1124
1125
 
1125
 
int WriteRegister(pcilib_t *handle, pcilib_model_description_t *model_info, const char *bank, const char *reg, char ** data) {
 
1126
int WriteRegister(pcilib_t *handle, const pcilib_model_description_t *model_info, const char *bank, const char *reg, char ** data) {
1126
1127
    int err;
1127
1128
 
1128
1129
    unsigned long val;
1756
1757
    return 0;
1757
1758
}
1758
1759
 
1759
 
int StartStopDMA(pcilib_t *handle,  pcilib_model_description_t *model_info, pcilib_dma_engine_addr_t dma, pcilib_dma_direction_t dma_direction, int start) {
 
1760
int StartStopDMA(pcilib_t *handle,  const pcilib_model_description_t *model_info, pcilib_dma_engine_addr_t dma, pcilib_dma_direction_t dma_direction, int start) {
1760
1761
    int err;
1761
1762
    pcilib_dma_engine_t dmaid;
1762
1763
    
1763
1764
    if (dma == PCILIB_DMA_ENGINE_ADDR_INVALID) {
1764
 
        const pcilib_dma_info_t *dma_info = pcilib_get_dma_info(handle);
 
1765
        const pcilib_dma_description_t *dma_info = pcilib_get_dma_info(handle);
1765
1766
 
1766
1767
        if (start) Error("DMA engine should be specified");
1767
1768
 
1768
 
        for (dmaid = 0; dma_info->engines[dmaid]; dmaid++) {
 
1769
        for (dmaid = 0; dma_info->engines[dmaid].addr_bits; dmaid++) {
1769
1770
            err = pcilib_start_dma(handle, dmaid, 0);
1770
 
            if (err) Error("Error starting DMA Engine (%s %i)", ((dma_info->engines[dmaid]->direction == PCILIB_DMA_FROM_DEVICE)?"C2S":"S2C"), dma_info->engines[dmaid]->addr);
 
1771
            if (err) Error("Error starting DMA Engine (%s %i)", ((dma_info->engines[dmaid].direction == PCILIB_DMA_FROM_DEVICE)?"C2S":"S2C"), dma_info->engines[dmaid].addr);
1771
1772
            err = pcilib_stop_dma(handle, dmaid, PCILIB_DMA_FLAG_PERSISTENT);
1772
 
            if (err) Error("Error stopping DMA Engine (%s %i)", ((dma_info->engines[dmaid]->direction == PCILIB_DMA_FROM_DEVICE)?"C2S":"S2C"), dma_info->engines[dmaid]->addr);
 
1773
            if (err) Error("Error stopping DMA Engine (%s %i)", ((dma_info->engines[dmaid].direction == PCILIB_DMA_FROM_DEVICE)?"C2S":"S2C"), dma_info->engines[dmaid].addr);
1773
1774
        }
1774
1775
        
1775
1776
        return 0;
1851
1852
    
1852
1853
    if (n == MAX_USES) return 0;
1853
1854
 
 
1855
    memset(&uses[n], 0, sizeof(pcilib_kmem_use_t));
1854
1856
    uses[n].use = use;
1855
1857
    return (*n_uses)++;
1856
1858
}
1878
1880
 
1879
1881
    size_t useid, n_uses = 1;   // Use 0 is for others
1880
1882
 
1881
 
    memset(uses, 0, sizeof(uses));
 
1883
    memset(uses, 0, sizeof(kmem_use_info_t));
1882
1884
    
1883
1885
    pos = strrchr(device, '/');
1884
1886
    if (pos) ++pos;
1905
1907
        if (!f) Error("Can't access file (%s)", fname);
1906
1908
 
1907
1909
        while(!feof(f)) {
1908
 
            fgets(info, 256, f);
 
1910
            if (!fgets(info, 256, f))
 
1911
                break;
 
1912
 
1909
1913
            if (!strncmp(info, "use:", 4)) use = strtoul(info+4, NULL, 16);
1910
1914
            if (!strncmp(info, "size:", 5)) size = strtoul(info+5, NULL, 10);
1911
1915
            if (!strncmp(info, "refs:", 5)) refs = strtoul(info+5, NULL, 10);
1912
1916
            if (!strncmp(info, "mode:", 5)) mode = strtoul(info+5, NULL, 16);
1913
1917
            if (!strncmp(info, "hw ref:", 7)) hwref = strtoul(info+7, NULL, 10);
 
1918
 
1914
1919
        }
1915
1920
        fclose(f);
1916
1921
 
1960
1965
        else if ((uses[i].use >> 16) == PCILIB_KMEM_USE_USER)   printf("User %04x         ", uses[i].use&0xFFFF);
1961
1966
        else printf ("                   ");
1962
1967
        printf("  ");
1963
 
        printf("% 6lu", uses[i].count);
 
1968
        printf("%6zu", uses[i].count);
1964
1969
        printf("     ");
1965
 
        printf("% 10s", GetPrintSize(stmp, uses[i].size));
 
1970
        printf("%10s", GetPrintSize(stmp, uses[i].size));
1966
1971
        printf("      ");
1967
1972
        if (uses[i].referenced&&uses[i].hw_lock) printf("HW+SW");
1968
1973
        else if (uses[i].referenced) printf("   SW");
2122
2127
    return 0;
2123
2128
}
2124
2129
 
2125
 
int ListDMA(pcilib_t *handle, const char *device, pcilib_model_description_t *model_info) {
 
2130
int ListDMA(pcilib_t *handle, const char *device, const pcilib_model_description_t *model_info) {
2126
2131
    int err;
2127
2132
    
2128
2133
    DIR *dir;
2163
2168
        if (!f) Error("Can't access file (%s)", fname);
2164
2169
 
2165
2170
        while(!feof(f)) {
2166
 
            fgets(info, 256, f);
 
2171
            if (!fgets(info, 256, f))
 
2172
                break;
 
2173
 
2167
2174
            if (!strncmp(info, "use:", 4)) use = strtoul(info+4, NULL, 16);
2168
2175
//          if (!strncmp(info, "size:", 5)) size = strtoul(info+5, NULL, 10);
2169
2176
//          if (!strncmp(info, "refs:", 5)) refs = strtoul(info+5, NULL, 10);
2207
2214
        else printf("D");
2208
2215
 
2209
2216
        printf("        ");
2210
 
        printf("% 10s", GetPrintSize(stmp, status.ring_size * status.buffer_size));
 
2217
        printf("%10s", GetPrintSize(stmp, status.ring_size * status.buffer_size));
2211
2218
        
2212
2219
        printf("         ");
2213
2220
        printf("%zu - %zu (of %zu)", status.ring_tail, status.ring_head, status.ring_size);
2223
2230
    return 0;
2224
2231
}
2225
2232
 
2226
 
int ListBuffers(pcilib_t *handle, const char *device, pcilib_model_description_t *model_info, pcilib_dma_engine_addr_t dma, pcilib_dma_direction_t dma_direction) {
 
2233
int ListBuffers(pcilib_t *handle, const char *device, const pcilib_model_description_t *model_info, pcilib_dma_engine_addr_t dma, pcilib_dma_direction_t dma_direction) {
2227
2234
    int err;
2228
2235
    size_t i;
2229
2236
    pcilib_dma_engine_t dmaid;
2253
2260
    for (i = 0; i < status.ring_size; i++) {
2254
2261
        printf("%8zu    ", i);
2255
2262
        printf("%c%c %c%c ", buffer[i].used?'U':' ',  buffer[i].error?'E':' ', buffer[i].first?'F':' ', buffer[i].last?'L':' ');
2256
 
        printf("% 10s", GetPrintSize(stmp, buffer[i].size));
 
2263
        printf("%10s", GetPrintSize(stmp, buffer[i].size));
2257
2264
        printf("\n");
2258
2265
    }
2259
2266
 
2267
2274
    return 0;
2268
2275
}
2269
2276
 
2270
 
int ReadBuffer(pcilib_t *handle, const char *device, pcilib_model_description_t *model_info, pcilib_dma_engine_addr_t dma, pcilib_dma_direction_t dma_direction, size_t block, FILE *o) {
 
2277
int ReadBuffer(pcilib_t *handle, const char *device, const pcilib_model_description_t *model_info, pcilib_dma_engine_addr_t dma, pcilib_dma_direction_t dma_direction, size_t block, FILE *o) {
2271
2278
    int err;
2272
2279
    pcilib_dma_engine_t dmaid;
2273
2280
    pcilib_dma_engine_status_t status;
2303
2310
}
2304
2311
 
2305
2312
 
2306
 
int EnableIRQ(pcilib_t *handle, pcilib_model_description_t *model_info, pcilib_irq_type_t irq_type) {
 
2313
int EnableIRQ(pcilib_t *handle, const pcilib_model_description_t *model_info, pcilib_irq_type_t irq_type) {
2307
2314
    int err;
2308
2315
 
2309
2316
    err = pcilib_enable_irq(handle, irq_type, 0);
2315
2322
    return err;
2316
2323
}
2317
2324
 
2318
 
int DisableIRQ(pcilib_t *handle, pcilib_model_description_t *model_info, pcilib_irq_type_t irq_type) {
 
2325
int DisableIRQ(pcilib_t *handle, const pcilib_model_description_t *model_info, pcilib_irq_type_t irq_type) {
2319
2326
    int err;
2320
2327
    
2321
2328
    err = pcilib_disable_irq(handle, 0);
2327
2334
    return err;
2328
2335
}
2329
2336
 
2330
 
int AckIRQ(pcilib_t *handle, pcilib_model_description_t *model_info, pcilib_irq_hw_source_t irq_source) {
 
2337
int AckIRQ(pcilib_t *handle, const pcilib_model_description_t *model_info, pcilib_irq_hw_source_t irq_source) {
2331
2338
    pcilib_clear_irq(handle, irq_source);
2332
2339
    return 0;
2333
2340
}
2334
2341
 
2335
 
int WaitIRQ(pcilib_t *handle, pcilib_model_description_t *model_info, pcilib_irq_hw_source_t irq_source, pcilib_timeout_t timeout) {
 
2342
int WaitIRQ(pcilib_t *handle, const pcilib_model_description_t *model_info, pcilib_irq_hw_source_t irq_source, pcilib_timeout_t timeout) {
2336
2343
    int err;
2337
2344
    size_t count;
2338
2345
 
2361
2368
    int force = 0;
2362
2369
    int verify = 0;
2363
2370
    
2364
 
    pcilib_model_t model = PCILIB_MODEL_DETECT;
2365
 
    pcilib_model_description_t *model_info;
 
2371
    const char *model = NULL;
 
2372
    const pcilib_model_description_t *model_info;
2366
2373
    MODE mode = MODE_INVALID;
2367
2374
    GRAB_MODE grab_mode = 0;
2368
2375
    size_t trigger_time = 0;
2639
2646
                fpga_device = optarg;
2640
2647
            break;
2641
2648
            case OPT_MODEL:
2642
 
                if (!strcasecmp(optarg, "pci")) model = PCILIB_MODEL_PCI;
 
2649
                model = optarg;
 
2650
/*              if (!strcasecmp(optarg, "pci")) model = PCILIB_MODEL_PCI;
2643
2651
                else if (!strcasecmp(optarg, "ipecamera")) model = PCILIB_MODEL_IPECAMERA;
2644
2652
                else if (!strcasecmp(optarg, "kapture")) model = PCILIB_MODEL_KAPTURE;
2645
 
                else Usage(argc, argv, "Invalid memory model (%s) is specified", optarg);
 
2653
                else Usage(argc, argv, "Invalid memory model (%s) is specified", optarg);*/
2646
2654
            break;
2647
2655
            case OPT_BAR:
2648
2656
                bank = optarg;
2838
2846
    handle = pcilib_open(fpga_device, model);
2839
2847
    if (handle < 0) Error("Failed to open FPGA device: %s", fpga_device);
2840
2848
 
2841
 
    model = pcilib_get_model(handle);
2842
2849
    model_info = pcilib_get_model_description(handle);
2843
2850
 
2844
2851
    switch (mode) {
2866
2873
        else Usage(argc, argv, "The %i data values is specified, but %i required", argc - optind, size);
2867
2874
     case MODE_READ:
2868
2875
        if (!addr) {
2869
 
            if (model == PCILIB_MODEL_PCI) {
 
2876
            if (((!model_info->dma)||(!model_info->dma->api))&&(!model_info->api)) {
 
2877
//          if (model == PCILIB_MODEL_PCI) {
2870
2878
                if ((amode != ACCESS_DMA)&&(amode != ACCESS_CONFIG)) 
2871
2879
                    Usage(argc, argv, "The address is not specified");
2872
2880
            } else ++mode;
2927
2935
            addr = NULL;
2928
2936
        } else if ((isxnumber(addr))&&(sscanf(addr, "%lx", &start) == 1)) {
2929
2937
                // check if the address in the register range
2930
 
            pcilib_register_range_t *ranges =  model_info->ranges;
 
2938
            const pcilib_register_range_t *ranges =  model_info->ranges;
2931
2939
            
2932
2940
            if (ranges) {
2933
2941
                for (i = 0; ranges[i].start != ranges[i].end; i++) 
2935
2943
                        
2936
2944
                    // register access in plain mode
2937
2945
                if (ranges[i].start != ranges[i].end) {
2938
 
                    pcilib_register_bank_t regbank = pcilib_find_bank_by_addr(handle, ranges[i].bank);
 
2946
                    pcilib_register_bank_t regbank = pcilib_find_register_bank_by_addr(handle, ranges[i].bank);
2939
2947
                    if (regbank == PCILIB_REGISTER_BANK_INVALID) Error("Configuration error: register bank specified in the address range is not found");
2940
2948
                    
2941
2949
                    bank = model_info->banks[regbank].name;
2991
2999
            case MODE_BENCHMARK:
2992
3000
            case MODE_READ:
2993
3001
            case MODE_WRITE:
2994
 
                if ((!isnumber(bank))||(sscanf(bank,"%li", &itmp) != 1)||(itmp < 0)||(itmp >= PCILIB_MAX_BANKS)) 
 
3002
                if ((!isnumber(bank))||(sscanf(bank,"%li", &itmp) != 1)||(itmp < 0)||(itmp >= PCILIB_MAX_REGISTER_BANKS)) 
2995
3003
                    Usage(argc, argv, "Invalid data bank (%s) is specified", bank);
2996
3004
                else bar = itmp;
2997
3005
            break;
2998
3006
            default:
2999
 
                if (pcilib_find_bank(handle, bank) == PCILIB_REGISTER_BANK_INVALID)
 
3007
                if (pcilib_find_register_bank(handle, bank) == PCILIB_REGISTER_BANK_INVALID)
3000
3008
                    Usage(argc, argv, "Invalid data bank (%s) is specified", bank);
3001
3009
        }
3002
3010
    }