/alps/ipecamera

                case PCILIB_DMA_TYPE_PACKET:

                    printf("Packet");

                break;

            }

            

            printf(", Address Width: %02lu bits\n", engine->addr_bits);

    else registers = model_info->registers;

    

    if (registers) {

        if (bank) {

            pcilib_register_bank_t bank_id = pcilib_find_bank(handle, bank);

            pcilib_register_bank_description_t *b = model_info->banks + bank_id;

    int err;

    int i, j, errors;

    void *data, *buf, *check;

    struct timeval start, end;

    unsigned long time;

    size_t size, min_size, max_size;

            err = pcilib_wait_irq(handle, 0, 0, &irqs);

            if (err) irqs = 0;

            

            

            printf("RW: ");

            if (mbs < 0) printf("failed ...   ");

        gettimeofday(&end,NULL);

 

        time = (end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec);

        

        fflush(0);

 

        gettimeofday(&end,NULL);

 

        time = (end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec);

        

        fflush(0);

 

 

    free(check);

    free(buf);

}

 

#define pci2host16(endianess, value) endianess?

    const char *format;

 

    pcilib_register_bank_t bank_id;

 

    pcilib_register_value_t value;

    

    }

 

    int access = banks[bank_id].access / 8;

    int block_width, blocks_per_line;

    int numbers_per_block, numbers_per_line; 

    

int WriteData(pcilib_t *handle, ACCESS_MODE mode, pcilib_dma_engine_addr_t dma, pcilib_bar_t bar, uintptr_t addr, size_t n, access_t access, int endianess, char ** data) {

    int read_back = 0;

    void *buf, *check;

    int size = n * abs(access);

    size_t ret;

    pcilib_dma_engine_t dmaid;

            case 2: res = sscanf(data[i], "%hx", ((uint16_t*)buf)+i); break;

            case 4: res = sscanf(data[i], "%x", ((uint32_t*)buf)+i); break;

            case 8: res = sscanf(data[i], "%lx", ((uint64_t*)buf)+i); break;

        }

        if ((res != 1)||(!isxnumber(data[i]))) Error("Can't parse data value at poition %i, (%s) is not valid hex number", i, data[i]);

    }

 

int WriteRegister(pcilib_t *handle, pcilib_model_description_t *model_info, const char *bank, const char *reg, char ** data) {

    int err;

 

    unsigned long val;

    pcilib_register_value_t value;

 

 

    pcilib_register_t regid = pcilib_find_register(handle, bank, reg);

    if (regid == PCILIB_REGISTER_INVALID) Error("Can't find register (%s) from bank (%s)", reg, bank?bank:"autodetected");

    

    if (info->flags&PCILIB_EVENT_INFO_FLAG_BROKEN) {

        ctx->broken_count++;

    }

 

    data = pcilib_get_data(handle, event_id, ctx->data, &size);

    if (!data) {

        ctx->broken_count++;

    }

    

    

        else Error("Write failed");

    }

 

    

//    printf("%lu %lu\n", info->seqnum, info->offset);

 

*/

 

//    printf("data callback: %lu\n", event_id);    

}

 

int raw_data(pcilib_event_id_t event_id, pcilib_event_info_t *info, pcilib_event_flags_t flags, size_t size, void *data, void *user) {

//    printf("%i\n", event_id);

}

 

 

void GrabStats(GRABContext *ctx, struct timeval *end_time) {

    pcilib_timeout_t duration, fps_duration;

    struct timeval cur;

 

    if (!end_time) {

        gettimeofday(&cur, NULL);

    

    while ((entry = readdir(dir)) != NULL) {

        FILE *f;

        

        if (strncmp(entry->d_name, "kbuf", 4)) continue;

        if (!isnumber(entry->d_name+4)) continue;

        

        printf("%08lx  ", uses[i].use);

        if (!i) printf("All Others         ");

        printf("  ");

        printf("% 6lu", uses[i].count);

        printf("     ");

    void *data;

    size_t size;

    pcilib_kmem_handle_t *kbuf;

    kbuf = pcilib_alloc_kernel_memory(handle, 0, block + 1, 0, 0, use, PCILIB_KMEM_FLAG_REUSE|PCILIB_KMEM_FLAG_TRY);

    if (!kbuf) {

        printf("The specified kernel buffer is not allocated\n");

        return 0;

    }

    data = pcilib_kmem_get_block_ua(handle, kbuf, block);

    if (data) {

        size = pcilib_kmem_get_block_size(handle, kbuf, block);

    } else {

        printf("The specified block is not existing\n");

    }

    pcilib_free_kernel_memory(handle, kbuf, KMEM_FLAG_REUSE);

}

 

int FreeKMEM(pcilib_t *handle, const char *device, const char *use, int force) {

    int err;

    int i;

    unsigned long useid;

    pcilib_kmem_flags_t flags = PCILIB_KMEM_FLAG_HARDWARE|PCILIB_KMEM_FLAG_PERSISTENT|PCILIB_KMEM_FLAG_EXCLUSIVE; 

    if (force) flags |= PCILIB_KMEM_FLAG_FORCE; // this will ignore mmap locks as well.

 

        

        return 0;

    }

    if ((!isxnumber(use))||(sscanf(use, "%lx", &useid) != 1)) Error("Invalid use (%s) is specified", use);

    err = pcilib_clean_kernel_memory(handle, useid, flags);

    if (err) Error("Error cleaning kernel buffers for use (0x%lx)", useid);

    return 0;

}

 

    printf("--------------------------------------------------------------------------------\n");

    while ((entry = readdir(dir)) != NULL) {

        FILE *f;

        

        if (strncmp(entry->d_name, "kbuf", 4)) continue;

        if (!isnumber(entry->d_name+4)) continue;

        if (dmaid == PCILIB_DMA_ENGINE_INVALID) continue;

        

        

        err = pcilib_start_dma(handle, dmaid, 0);

        if (err) {

            printf("-- Wrong state, start is failed\n");

 

    dmaid = pcilib_find_dma_by_addr(handle, dma_direction, dma);

    if (dmaid == PCILIB_DMA_ENGINE_INVALID) Error("The specified DMA engine is not found");

    err = pcilib_start_dma(handle, dmaid, 0);

    if (err) Error("Error starting the specified DMA engine");

    err = pcilib_get_dma_status(handle, dmaid, &status, 0, NULL);

    if (err) Error("Failed to obtain status of the specified DMA engine");

    buffer = (pcilib_dma_buffer_status_t*)malloc(status.ring_size*sizeof(pcilib_dma_buffer_status_t));

    if (!buffer) Error("Failed to allocate memory for status buffer");

    err = pcilib_get_dma_status(handle, dmaid, &status, status.ring_size, buffer);

    if (err) Error("Failed to obtain extended status of the specified DMA engine");

    printf("Buffer      Status      Total Size         \n");

    printf("--------------------------------------------------------------------------------\n");

    for (i = 0; i < status.ring_size; i++) {

        printf("%8zu    ", i);

        printf("%c%c %c%c ", buffer[i].used?'U':' ',  buffer[i].error?'E':' ', buffer[i].first?'F':' ', buffer[i].last?'L':' ');

        printf("% 10s", PrintSize(stmp, buffer[i].size));

        printf("\n");

    }

    printf("--------------------------------------------------------------------------------\n");

    printf("U - Used, E - Error, F - First block, L - Last Block\n");

    free(buffer);

 

    pcilib_stop_dma(handle, dmaid, 0);

 

}

 

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) {

    int err;

    pcilib_dma_engine_t dmaid;

    pcilib_dma_engine_status_t status;

    pcilib_dma_buffer_status_t *buffer;

    size_t size;

 

    dmaid = pcilib_find_dma_by_addr(handle, dma_direction, dma);

    if (dmaid == PCILIB_DMA_ENGINE_INVALID) Error("The specified DMA engine is not found");

    const char *data_type = NULL;

    const char *dma_channel = NULL;

    const char *use = NULL;

    size_t block = 0;

    pcilib_dma_direction_t dma_direction = PCILIB_DMA_BIDIRECTIONAL;

    

    pcilib_dma_engine_addr_t dma = PCILIB_DMA_ENGINE_ADDR_INVALID;

    uintptr_t start = -1;

    size_t size = 1;

    access_t access = 4;

    int endianess = 0;

    size_t timeout = 0;

    const char *output = NULL;

    size_t iterations = BENCHMARK_ITERATIONS;

 

    pcilib_t *handle;

    int size_set = 0;

    int timeout_set = 0;

    int run_time_set = 0;

                mode = MODE_WAIT_IRQ;

                if (optarg) num_offset = optarg;

                else if ((optind < argc)&&(argv[optind][0] != '-'))  num_offset = argv[optind++];

                

 

            break;

            case OPT_LIST_KMEM:

                if (mode != MODE_INVALID) Usage(argc, argv, "Multiple operations are not supported");

                }

            break;

            case OPT_SIZE:

                    if (strcasecmp(optarg, "unlimited"))

                        Usage(argc, argv, "Invalid size is specified (%s)", optarg);

                    else

                        size = 0;//(size_t)-1;

                        

                size_set = 1;

            break;

                

            break;

            case OPT_TIMEOUT:

                    if (strcasecmp(optarg, "unlimited"))

                        Usage(argc, argv, "Invalid timeout is specified (%s)", optarg);

                    else

                        timeout = PCILIB_TIMEOUT_INFINITE;

                timeout_set = 1;

            break;

            case OPT_OUTPUT:

                data_type = optarg;

            break;

            case OPT_RUN_TIME:

                    if (strcasecmp(optarg, "unlimited"))

                        Usage(argc, argv, "Invalid run-time is specified (%s)", optarg);

                    else

                        run_time = 0;

                run_time_set = 1;

            break;

            case OPT_TRIGGER_TIME:

     case MODE_FREE_KMEM:

        FreeKMEM(handle, fpga_device, use, force);

     break;

    }

 

    if (ofile) fclose(ofile);