2
//#define PCILIB_FILE_IO
3
#define _POSIX_C_SOURCE 199309L
12
#include <sys/ioctl.h>
14
#include <arpa/inet.h>
24
#include "ipecamera/model.h"
25
#include "kapture/model.h"
28
pcilib_t *pcilib_open(const char *device, pcilib_model_t model) {
29
pcilib_t *ctx = malloc(sizeof(pcilib_t));
32
memset(ctx, 0, sizeof(pcilib_t));
34
ctx->handle = open(device, O_RDWR);
35
if (ctx->handle < 0) {
36
pcilib_error("Error opening device (%s)", device);
41
ctx->page_mask = (uintptr_t)-1;
44
if (!model) model = pcilib_get_model(ctx);
46
memcpy(&ctx->model_info, pcilib_model + model, sizeof(pcilib_model_description_t));
48
pcilib_init_event_engine(ctx);
54
pcilib_model_description_t *pcilib_get_model_description(pcilib_t *ctx) {
55
return &ctx->model_info;
58
const pcilib_board_info_t *pcilib_get_board_info(pcilib_t *ctx) {
61
if (ctx->page_mask == (uintptr_t)-1) {
62
ret = ioctl( ctx->handle, PCIDRIVER_IOC_PCI_INFO, &ctx->board_info );
64
pcilib_error("PCIDRIVER_IOC_PCI_INFO ioctl have failed");
68
ctx->page_mask = pcilib_get_page_mask();
71
return &ctx->board_info;
76
pcilib_context_t *pcilib_get_implementation_context(pcilib_t *ctx) {
77
return ctx->event_ctx;
80
pcilib_model_t pcilib_get_model(pcilib_t *ctx) {
81
if (ctx->model == PCILIB_MODEL_DETECT) {
82
// unsigned short vendor_id;
83
// unsigned short device_id;
85
//return PCILIB_MODEL_PCI;
87
const pcilib_board_info_t *board_info = pcilib_get_board_info(ctx);
88
if (!board_info) return PCILIB_MODEL_PCI;
90
if ((board_info->vendor_id == PCIE_XILINX_VENDOR_ID)&&(board_info->device_id == PCIE_IPECAMERA_DEVICE_ID))
91
ctx->model = PCILIB_MODEL_IPECAMERA;
92
else if ((board_info->vendor_id == PCIE_XILINX_VENDOR_ID)&&(board_info->device_id == PCIE_KAPTURE_DEVICE_ID))
93
ctx->model = PCILIB_MODEL_IPECAMERA;
95
ctx->model = PCILIB_MODEL_PCI;
101
static pcilib_bar_t pcilib_detect_bar(pcilib_t *ctx, uintptr_t addr, size_t size) {
105
const pcilib_board_info_t *board_info = pcilib_get_board_info(ctx);
106
if (!board_info) return PCILIB_BAR_INVALID;
108
for (i = 0; i < PCILIB_MAX_BANKS; i++) {
109
if (board_info->bar_length[i] > 0) {
110
if ((addr >= board_info->bar_start[i])&&((board_info->bar_start[i] + board_info->bar_length[i]) >= (addr + size))) return i;
117
if (n > 0) return n - 1;
119
return PCILIB_BAR_INVALID;
122
int pcilib_detect_address(pcilib_t *ctx, pcilib_bar_t *bar, uintptr_t *addr, size_t size) {
123
const pcilib_board_info_t *board_info = pcilib_get_board_info(ctx);
124
if (!board_info) return PCILIB_ERROR_NOTFOUND;
126
if (*bar == PCILIB_BAR_DETECT) {
127
*bar = pcilib_detect_bar(ctx, *addr, size);
128
if (*bar == PCILIB_BAR_INVALID) {
129
pcilib_error("The requested data block at address 0x%x with size %zu does not belongs to any available memory bank", *addr, size);
130
return PCILIB_ERROR_NOTFOUND;
132
if (*addr < board_info->bar_start[*bar])
133
*addr += board_info->bar_start[*bar];
135
if ((*addr < board_info->bar_start[*bar])||((board_info->bar_start[*bar] + board_info->bar_length[*bar]) < (((uintptr_t)*addr) + size))) {
136
if ((board_info->bar_length[*bar]) >= (((uintptr_t)*addr) + size)) {
137
*addr += board_info->bar_start[*bar];
139
pcilib_error("The requested data block at address 0x%x with size %zu does not belong the specified memory bank (Bar %i: starting at 0x%x with size 0x%x)", *addr, size, *bar, board_info->bar_start[*bar], board_info->bar_length[*bar]);
140
return PCILIB_ERROR_NOTFOUND;
145
*addr -= board_info->bar_start[*bar];
146
*addr += board_info->bar_start[*bar] & ctx->page_mask;
151
void *pcilib_map_bar(pcilib_t *ctx, pcilib_bar_t bar) {
155
const pcilib_board_info_t *board_info = pcilib_get_board_info(ctx);
156
if (!board_info) return NULL;
158
if (ctx->bar_space[bar]) return ctx->bar_space[bar];
160
ret = ioctl( ctx->handle, PCIDRIVER_IOC_MMAP_MODE, PCIDRIVER_MMAP_PCI );
162
pcilib_error("PCIDRIVER_IOC_MMAP_MODE ioctl have failed", bar);
166
ret = ioctl( ctx->handle, PCIDRIVER_IOC_MMAP_AREA, PCIDRIVER_BAR0 + bar );
168
pcilib_error("PCIDRIVER_IOC_MMAP_AREA ioctl have failed for bank %i", bar);
172
#ifdef PCILIB_FILE_IO
173
file_io_handle = open("/root/data", O_RDWR);
174
res = mmap( 0, board_info->bar_length[bar], PROT_WRITE | PROT_READ, MAP_SHARED, ctx->file_io_handle, 0 );
176
res = mmap( 0, board_info->bar_length[bar], PROT_WRITE | PROT_READ, MAP_SHARED, ctx->handle, 0 );
178
if ((!res)||(res == MAP_FAILED)) {
179
pcilib_error("Failed to mmap data bank %i", bar);
187
void pcilib_unmap_bar(pcilib_t *ctx, pcilib_bar_t bar, void *data) {
188
const pcilib_board_info_t *board_info = pcilib_get_board_info(ctx);
189
if (!board_info) return;
191
if (ctx->bar_space[bar]) return;
193
munmap(data, board_info->bar_length[bar]);
194
#ifdef PCILIB_FILE_IO
195
close(ctx->file_io_handle);
199
int pcilib_map_register_space(pcilib_t *ctx) {
201
pcilib_register_bank_t i;
203
if (!ctx->reg_bar_mapped) {
204
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
205
pcilib_register_bank_description_t *banks = model_info->banks;
207
for (i = 0; ((banks)&&(banks[i].access)); i++) {
210
pcilib_bar_t bar = banks[i].bar;
212
if (bar == PCILIB_BAR_DETECT) {
213
uintptr_t addr = banks[0].read_addr;
215
err = pcilib_detect_address(ctx, &bar, &addr, 1);
218
if (!ctx->bar_space[bar]) {
219
reg_space = pcilib_map_bar(ctx, bar);
220
// pcilib_memcpy(&buf, reg_space, 8);
223
ctx->bar_space[bar] = reg_space;
225
return PCILIB_ERROR_FAILED;
228
} else if (!ctx->bar_space[bar]) {
229
reg_space = pcilib_map_bar(ctx, bar);
231
ctx->bar_space[bar] = reg_space;
233
return PCILIB_ERROR_FAILED;
235
// pcilib_memcpy(&buf, reg_space, 8);
238
if (!i) ctx->reg_bar = bar;
241
ctx->reg_bar_mapped = 1;
247
int pcilib_map_data_space(pcilib_t *ctx, uintptr_t addr) {
251
if (!ctx->data_bar_mapped) {
252
const pcilib_board_info_t *board_info = pcilib_get_board_info(ctx);
253
if (!board_info) return PCILIB_ERROR_FAILED;
255
err = pcilib_map_register_space(ctx);
257
pcilib_error("Error mapping register space");
263
for (i = 0; i < PCILIB_MAX_BANKS; i++) {
264
if ((ctx->bar_space[i])||(!board_info->bar_length[i])) continue;
267
if (board_info->bar_start[i] == addr) {
283
if (addr) pcilib_error("Unable to find the specified data space (%lx)", addr);
284
else pcilib_error("Unable to find the data space");
285
return PCILIB_ERROR_NOTFOUND;
288
ctx->data_bar = data_bar;
290
if (!ctx->bar_space[data_bar]) {
291
char *data_space = pcilib_map_bar(ctx, data_bar);
292
if (data_space) ctx->bar_space[data_bar] = data_space;
294
pcilib_error("Unable to map the data space");
295
return PCILIB_ERROR_FAILED;
299
ctx->data_bar_mapped = 0;
306
static void pcilib_unmap_register_space(pcilib_t *ctx) {
307
if (ctx->reg_space) {
308
pcilib_unmap_bar(ctx, ctx->reg_bar, ctx->reg_space);
309
ctx->reg_space = NULL;
313
static void pcilib_unmap_data_space(pcilib_t *ctx) {
314
if (ctx->data_space) {
315
pcilib_unmap_bar(ctx, ctx->data_bar, ctx->data_space);
316
ctx->data_space = NULL;
321
char *pcilib_resolve_register_address(pcilib_t *ctx, pcilib_bar_t bar, uintptr_t addr) {
322
if (bar == PCILIB_BAR_DETECT) {
323
// First checking the default register bar
324
size_t offset = addr - ctx->board_info.bar_start[ctx->reg_bar];
325
if ((addr > ctx->board_info.bar_start[ctx->reg_bar])&&(offset < ctx->board_info.bar_length[ctx->reg_bar])) {
326
if (!ctx->bar_space[ctx->reg_bar]) {
327
pcilib_error("The register bar is not mapped");
331
return ctx->bar_space[ctx->reg_bar] + offset + (ctx->board_info.bar_start[ctx->reg_bar] & ctx->page_mask);
334
// Otherwise trying to detect
335
bar = pcilib_detect_bar(ctx, addr, 1);
336
if (bar != PCILIB_BAR_INVALID) {
337
size_t offset = addr - ctx->board_info.bar_start[bar];
338
if ((offset < ctx->board_info.bar_length[bar])&&(ctx->bar_space[bar])) {
339
if (!ctx->bar_space[bar]) {
340
pcilib_error("The requested bar (%i) is not mapped", bar);
343
return ctx->bar_space[bar] + offset + (ctx->board_info.bar_start[bar] & ctx->page_mask);
347
if (!ctx->bar_space[bar]) {
348
pcilib_error("The requested bar (%i) is not mapped", bar);
352
if (addr < ctx->board_info.bar_length[bar]) {
353
return ctx->bar_space[bar] + addr + (ctx->board_info.bar_start[bar] & ctx->page_mask);
356
if ((addr >= ctx->board_info.bar_start[bar])&&(addr < (ctx->board_info.bar_start[bar] + ctx->board_info.bar_length[ctx->reg_bar]))) {
357
return ctx->bar_space[bar] + (addr - ctx->board_info.bar_start[bar]) + (ctx->board_info.bar_start[bar] & ctx->page_mask);
364
char *pcilib_resolve_data_space(pcilib_t *ctx, uintptr_t addr, size_t *size) {
367
err = pcilib_map_data_space(ctx, addr);
369
pcilib_error("Failed to map the specified address space (%lx)", addr);
373
if (size) *size = ctx->board_info.bar_length[ctx->data_bar];
375
return ctx->bar_space[ctx->data_bar] + (ctx->board_info.bar_start[ctx->data_bar] & ctx->page_mask);
379
void pcilib_close(pcilib_t *ctx) {
383
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
384
pcilib_event_api_description_t *eapi = model_info->event_api;
385
pcilib_dma_api_description_t *dapi = model_info->dma_api;
387
if ((eapi)&&(eapi->free)) eapi->free(ctx->event_ctx);
388
if ((dapi)&&(dapi->free)) dapi->free(ctx->dma_ctx);
390
if (ctx->model_info.registers != model_info->registers) {
391
free(ctx->model_info.registers);
392
ctx->model_info.registers = pcilib_model[ctx->model].registers;
395
if (ctx->kmem_list) {
396
pcilib_warning("Not all kernel buffers are properly cleaned");
398
while (ctx->kmem_list) {
399
pcilib_free_kernel_memory(ctx, ctx->kmem_list, 0);
403
for (i = 0; i < PCILIB_MAX_BANKS; i++) {
404
if (ctx->bar_space[i]) {
405
char *ptr = ctx->bar_space[i];
406
ctx->bar_space[i] = NULL;
407
pcilib_unmap_bar(ctx, i, ptr);
416
int pcilib_read(pcilib_t *ctx, pcilib_bar_t bar, uintptr_t addr, size_t size, void *buf) {
419
pcilib_detect_address(ctx, &bar, &addr, size);
420
data = pcilib_map_bar(ctx, bar);
422
pcilib_memcpy(buf, data + addr, size);
424
pcilib_unmap_bar(ctx, bar, data);
429
int pcilib_write(pcilib_t *ctx, pcilib_bar_t bar, uintptr_t addr, size_t size, void *buf) {
432
pcilib_detect_address(ctx, &bar, &addr, size);
433
data = pcilib_map_bar(ctx, bar);
435
pcilib_memcpy(data + addr, buf, size);
437
pcilib_unmap_bar(ctx, bar, data);
443
int pcilib_read_fifo(pcilib_t *ctx, pcilib_bar_t bar, uintptr_t addr, uint8_t fifo_size, size_t n, void *buf) {
447
pcilib_detect_address(ctx, &bar, &addr, fifo_size);
448
data = pcilib_map_bar(ctx, bar);
450
for (i = 0; i < n; i++) {
451
pcilib_memcpy(buf + i * fifo_size, data + addr, fifo_size);
454
pcilib_unmap_bar(ctx, bar, data);
459
int pcilib_write_fifo(pcilib_t *ctx, pcilib_bar_t bar, uintptr_t addr, uint8_t fifo_size, size_t n, void *buf) {
463
pcilib_detect_address(ctx, &bar, &addr, fifo_size);
464
data = pcilib_map_bar(ctx, bar);
466
for (i = 0; i < n; i++) {
467
pcilib_memcpy(data + addr, buf + i * fifo_size, fifo_size);
470
pcilib_unmap_bar(ctx, bar, data);