/alps/ipecamera

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

« back to all changes in this revision

Viewing changes to pci.c

  • Committer: Suren A. Chilingaryan
  • Date: 2011-12-12 04:45:35 UTC
  • Revision ID: csa@dside.dyndns.org-20111212044535-6no1q7g230i8uvlv
multithread preprocessing of ipecamera frames and code reorganization

Show diffs side-by-side

added added

removed removed

Lines of Context:
pci.c
7
7
#include <strings.h>
8
8
#include <stdlib.h>
9
9
#include <stdint.h>
10
 
#include <stdarg.h>
11
10
#include <fcntl.h>
12
11
#include <unistd.h>
13
12
#include <sys/ioctl.h>
16
15
#include <errno.h>
17
16
#include <assert.h>
18
17
 
 
18
#include "pcilib.h"
19
19
#include "pci.h"
20
 
 
21
20
#include "kernel.h"
22
21
#include "tools.h"
23
22
#include "error.h"
25
24
#include "ipecamera/model.h"
26
25
 
27
26
 
28
 
static void pcilib_print_error(const char *msg, ...) {
29
 
    va_list va;
30
 
    
31
 
    va_start(va, msg);
32
 
    vprintf(msg, va);
33
 
    va_end(va);
34
 
    printf("\n");
35
 
}
36
 
 
37
 
void (*pcilib_error)(const char *msg, ...) = pcilib_print_error;
38
 
void (*pcilib_warning)(const char *msg, ...) = pcilib_print_error;
39
 
 
40
 
int pcilib_set_error_handler(void (*err)(const char *msg, ...), void (*warn)(const char *msg, ...)) {
41
 
    if (err) pcilib_error = err;
42
 
    else pcilib_error = pcilib_print_error;
43
 
    if (warn) pcilib_warning = warn;
44
 
    else pcilib_warning = pcilib_print_error;
45
 
}
46
 
 
47
27
pcilib_t *pcilib_open(const char *device, pcilib_model_t model) {
48
28
    pcilib_t *ctx = malloc(sizeof(pcilib_t));
49
29
 
98
78
 
99
79
pcilib_model_t pcilib_get_model(pcilib_t *ctx) {
100
80
    if (ctx->model == PCILIB_MODEL_DETECT) {
101
 
        unsigned short vendor_id;
102
 
        unsigned short device_id;
 
81
//      unsigned short vendor_id;
 
82
//      unsigned short device_id;
103
83
 
104
84
        //return PCILIB_MODEL_PCI;
105
85
        
421
401
}
422
402
 
423
403
int pcilib_read(pcilib_t *ctx, pcilib_bar_t bar, uintptr_t addr, size_t size, void *buf) {
424
 
    int i;
425
404
    void *data;
426
405
 
427
406
    pcilib_detect_address(ctx, &bar, &addr, size);
428
407
    data = pcilib_map_bar(ctx, bar);
429
408
 
430
409
    pcilib_memcpy(buf, data + addr, size);
431
 
    
432
 
    pcilib_unmap_bar(ctx, bar, data);    
 
410
 
 
411
    pcilib_unmap_bar(ctx, bar, data);
 
412
 
 
413
    return 0;
433
414
}
434
415
 
435
416
int pcilib_write(pcilib_t *ctx, pcilib_bar_t bar, uintptr_t addr, size_t size, void *buf) {
436
 
    int i;
437
417
    void *data;
438
418
 
439
419
    pcilib_detect_address(ctx, &bar, &addr, size);
440
420
    data = pcilib_map_bar(ctx, bar);
441
421
 
442
422
    pcilib_memcpy(data + addr, buf, size);
443
 
    
444
 
    pcilib_unmap_bar(ctx, bar, data);    
 
423
 
 
424
    pcilib_unmap_bar(ctx, bar, data);
 
425
 
 
426
    return 0;
445
427
}
446
428
 
447
429
 
448
430
int pcilib_read_fifo(pcilib_t *ctx, pcilib_bar_t bar, uintptr_t addr, uint8_t fifo_size, size_t n, void *buf) {
449
431
    int i;
450
432
    void *data;
451
 
    
 
433
 
452
434
    pcilib_detect_address(ctx, &bar, &addr, fifo_size);
453
435
    data = pcilib_map_bar(ctx, bar);
454
436
 
455
437
    for (i = 0; i < n; i++) {
456
438
        pcilib_memcpy(buf + i * fifo_size, data + addr, fifo_size);
457
439
    }
458
 
    
459
 
    pcilib_unmap_bar(ctx, bar, data);    
 
440
 
 
441
    pcilib_unmap_bar(ctx, bar, data);
 
442
 
 
443
    return 0;
460
444
}
461
445
 
462
446
int pcilib_write_fifo(pcilib_t *ctx, pcilib_bar_t bar, uintptr_t addr, uint8_t fifo_size, size_t n, void *buf) {
470
454
        pcilib_memcpy(data + addr, buf + i * fifo_size, fifo_size);
471
455
    }
472
456
 
473
 
    pcilib_unmap_bar(ctx, bar, data);    
 
457
    pcilib_unmap_bar(ctx, bar, data);
 
458
 
 
459
    return 0;
474
460
}
475