/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 dma/nwl.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:
dma/nwl.c
15
15
#include "nwl.h"
16
16
 
17
17
#include "nwl_defines.h"
 
18
#include "nwl_register.h"
18
19
 
19
20
 
20
21
#define NWL_XAUI_ENGINE 0
21
22
#define NWL_XRAWDATA_ENGINE 1
22
23
#define NWL_FIX_EOP_FOR_BIG_PACKETS             // requires precise sizes in read requests
23
24
 
24
 
/*
25
 
pcilib_register_bank_description_t ipecamera_register_banks[] = {
26
 
    { PCILIB_REGISTER_DMABANK0, PCILIB_BAR0, 128, PCILIB_DEFAULT_PROTOCOL, DMA_NWL_OFFSET, DMA_NWL_OFFSET, PCILIB_LITTLE_ENDIAN, 32, PCILIB_LITTLE_ENDIAN, "%lx", "dma", "NorthWest Logick DMA Engine" },
27
 
    { 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL }
28
 
};
29
 
*/
30
 
 
31
 
 
32
25
 
33
26
typedef struct {
34
27
    pcilib_dma_engine_description_t desc;
58
51
#define nwl_read_register(var, ctx, base, reg) pcilib_datacpy(&var, base + reg, 4, 1, ctx->dma_bank->raw_endianess)
59
52
#define nwl_write_register(var, ctx, base, reg) pcilib_datacpy(base + reg, &var, 4, 1, ctx->dma_bank->raw_endianess)
60
53
 
 
54
static int nwl_add_registers(nwl_dma_t *ctx) {
 
55
    int err;
 
56
    size_t n, i, j;
 
57
    int length;
 
58
    const char *names[NWL_MAX_DMA_ENGINE_REGISTERS];
 
59
    uintptr_t addr[NWL_MAX_DMA_ENGINE_REGISTERS];
 
60
    
 
61
        // We don't want DMA registers
 
62
    if (pcilib_find_bank_by_addr(ctx->pcilib, PCILIB_REGISTER_BANK_DMA) == PCILIB_REGISTER_BANK_INVALID) return 0;
 
63
    
 
64
    err = pcilib_add_registers(ctx->pcilib, 0, nwl_dma_registers);
 
65
    if (err) return err;
 
66
 
 
67
    err = pcilib_add_registers(ctx->pcilib, 0, nwl_xrawdata_registers);
 
68
    if (err) return err;
 
69
    
 
70
    for (n = 0; nwl_dma_engine_registers[n].bits; n++) {
 
71
        names[n] = nwl_dma_engine_registers[n].name;
 
72
        addr[n] = nwl_dma_engine_registers[n].addr;
 
73
    }
 
74
 
 
75
    if (ctx->n_engines > 9) length = 2;
 
76
    else length = 1;
 
77
    
 
78
    for (i = 0; i < ctx->n_engines; i++) {
 
79
        for (j = 0; nwl_dma_engine_registers[j].bits; j++) {
 
80
            const char *direction;
 
81
            nwl_dma_engine_registers[j].name = nwl_dma_engine_register_names[i * NWL_MAX_DMA_ENGINE_REGISTERS + j];
 
82
            nwl_dma_engine_registers[j].addr = addr[j] + (ctx->engines[i].base_addr - ctx->base_addr);
 
83
//          printf("%lx %lx\n", (ctx->engines[i].base_addr - ctx->base_addr), nwl_dma_engine_registers[j].addr);
 
84
            
 
85
            switch (ctx->engines[i].desc.direction) {
 
86
                case PCILIB_DMA_FROM_DEVICE:
 
87
                    direction =  "r";
 
88
                break;
 
89
                case PCILIB_DMA_TO_DEVICE:
 
90
                    direction = "w";
 
91
                break;
 
92
                default:
 
93
                    direction = "";
 
94
            }
 
95
            
 
96
            sprintf((char*)nwl_dma_engine_registers[j].name, names[j], length, ctx->engines[i].desc.addr, direction);
 
97
        }
 
98
        
 
99
        err = pcilib_add_registers(ctx->pcilib, n, nwl_dma_engine_registers);
 
100
        if (err) return err;
 
101
    }
 
102
    
 
103
    for (n = 0; nwl_dma_engine_registers[n].bits; n++) {
 
104
        nwl_dma_engine_registers[n].name = names[n];
 
105
        nwl_dma_engine_registers[n].addr = addr[n];
 
106
    }
 
107
    
 
108
    return 0;
 
109
}
 
110
 
61
111
static int nwl_read_engine_config(nwl_dma_t *ctx, pcilib_nwl_engine_description_t *info, char *base) {
62
112
    uint32_t val;
63
113
    
101
151
    pcilib_nwl_engine_description_t *info = ctx->engines + dma;
102
152
    char *base = ctx->engines[dma].base_addr;
103
153
 
 
154
    return 0;
104
155
    if (info->desc.addr == NWL_XRAWDATA_ENGINE) {
105
156
            // Stop Generators
106
157
        nwl_read_register(val, ctx, ctx->base_addr, TX_CONFIG_ADDRESS);
182
233
        pcilib_register_bank_t dma_bank = pcilib_find_bank_by_addr(pcilib, PCILIB_REGISTER_BANK_DMA);
183
234
 
184
235
        if (dma_bank == PCILIB_REGISTER_BANK_INVALID) {
 
236
            free(ctx);
185
237
            pcilib_error("DMA Register Bank could not be found");
186
238
            return NULL;
187
239
        }
210
262
        pcilib_set_dma_engine_description(pcilib, n_engines, NULL);
211
263
        
212
264
        ctx->n_engines = n_engines;
 
265
        
 
266
        err = nwl_add_registers(ctx);
 
267
        if (err) {
 
268
            free(ctx);
 
269
            pcilib_error("Failed to add DMA registers");
 
270
            return NULL;
 
271
        }
213
272
    }
214
273
    return (pcilib_dma_context_t*)ctx;
215
274
}