/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 pcilib/bank.c

  • Committer: Suren A. Chilingaryan
  • Date: 2015-09-10 03:08:04 UTC
  • mfrom: (277.2.17 test_xml)
  • Revision ID: csa@suren.me-20150910030804-djti3wcmk4yubhp7
Initial integration of XML support

Show diffs side-by-side

added added

removed removed

Lines of Context:
pcilib/bank.c
51
51
        
52
52
        bank_ctx->bank = ctx->banks + ctx->num_banks_init;
53
53
        bank_ctx->api = bapi;
 
54
        bank_ctx->xml = ctx->xml.bank_nodes[ctx->num_banks_init];
54
55
        ctx->bank_ctx[ctx->num_banks_init] = bank_ctx;
55
56
    }
56
57
 
76
77
    ctx->num_banks_init = 0;
77
78
}
78
79
 
79
 
 
80
 
int pcilib_add_register_banks(pcilib_t *ctx, size_t n, const pcilib_register_bank_description_t *banks) {
81
 
        // DS: Override existing banks 
 
80
int pcilib_add_register_banks(pcilib_t *ctx, pcilib_model_modification_flags_t flags, size_t n, const pcilib_register_bank_description_t *banks, pcilib_register_bank_t *ids) {
 
81
    size_t i;
 
82
    pcilib_register_bank_t bank;
 
83
    size_t dyn_banks = ctx->dyn_banks;
 
84
    size_t num_banks = ctx->num_banks;
82
85
        
83
86
    if (!n) {
84
87
        for (n = 0; banks[n].access; n++);
86
89
 
87
90
    if ((ctx->num_banks + n + 1) > PCILIB_MAX_REGISTER_BANKS)
88
91
        return PCILIB_ERROR_TOOBIG;
89
 
        
 
92
 
 
93
/*
90
94
    memcpy(ctx->banks + ctx->num_banks, banks, n * sizeof(pcilib_register_bank_description_t));
91
95
    ctx->num_banks += n;
 
96
*/
 
97
 
 
98
    for (i = 0; i < n; i++) {
 
99
            // Try to find if the bank is already existing...
 
100
        bank = pcilib_find_register_bank_by_name(ctx, banks[i].name);
 
101
        if ((bank == PCILIB_REGISTER_BANK_INVALID)&&(banks[i].addr != PCILIB_REGISTER_BANK_DYNAMIC))
 
102
            bank = pcilib_find_register_bank_by_addr(ctx, banks[i].addr);
 
103
 
 
104
        if (bank == PCILIB_REGISTER_BANK_INVALID) {
 
105
            bank = num_banks++;
 
106
        } else if (flags&PCILIB_MODEL_MODIFICATION_FLAG_SKIP_EXISTING) {
 
107
            if (ids) ids[i] = bank;
 
108
            continue;
 
109
        } else if ((flags&PCILIB_MODEL_MODIFICATION_FLAG_OVERRIDE) == 0) {
 
110
            if (pcilib_find_register_bank_by_name(ctx, banks[i].name) == PCILIB_REGISTER_BANK_INVALID)
 
111
                pcilib_error("The bank %s is already existing and override flag is not set", banks[i].name);
 
112
            else
 
113
                pcilib_error("The bank with address 0x%lx is already existing and override flag is not set", banks[i].addr);
 
114
            return PCILIB_ERROR_EXIST;
 
115
        }
 
116
        
 
117
        memcpy(ctx->banks + bank,  banks + i, sizeof(pcilib_register_bank_description_t));
 
118
        if (ids) ids[i] = bank;
 
119
        
 
120
        if (banks[i].addr == PCILIB_REGISTER_BANK_DYNAMIC) {
 
121
            ctx->banks[bank].addr = PCILIB_REGISTER_BANK_DYNAMIC + dyn_banks + 1;
 
122
            dyn_banks++;
 
123
        }
 
124
    }
 
125
    
 
126
    ctx->num_banks = num_banks;
 
127
    ctx->dyn_banks = dyn_banks;
92
128
 
93
129
        // If banks are already initialized, we need to re-run the initialization code
94
130
        // DS: Locking is currently missing
100
136
    return 0;
101
137
}
102
138
 
103
 
int pcilib_add_register_protocols(pcilib_t *ctx, size_t n, const pcilib_register_protocol_description_t *protocols) {
 
139
int pcilib_add_register_protocols(pcilib_t *ctx, pcilib_model_modification_flags_t flags, size_t n, const pcilib_register_protocol_description_t *protocols, pcilib_register_protocol_t *ids) {
104
140
        // DS: Override existing banks 
105
141
        
106
142
    if (!n) {
116
152
    return 0;
117
153
}
118
154
 
119
 
 
120
 
int pcilib_add_register_ranges(pcilib_t *ctx, size_t n, const pcilib_register_range_t *ranges) {
121
 
        // DS: Override existing banks 
122
 
        
 
155
int pcilib_add_register_ranges(pcilib_t *ctx, pcilib_model_modification_flags_t flags, size_t n, const pcilib_register_range_t *ranges) {
123
156
    if (!n) {
124
157
        for (n = 0; ranges[n].end; n++);
125
158
    }
135
168
 
136
169
pcilib_register_bank_t pcilib_find_register_bank_by_addr(pcilib_t *ctx, pcilib_register_bank_addr_t bank) {
137
170
    pcilib_register_bank_t i;
138
 
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
139
 
    const pcilib_register_bank_description_t *banks = model_info->banks;
140
171
 
141
 
    for (i = 0; banks[i].access; i++)
142
 
        if (banks[i].addr == bank) return i;
 
172
    for (i = 0; ctx->banks[i].access; i++)
 
173
        if (ctx->banks[i].addr == bank) return i;
143
174
 
144
175
    return PCILIB_REGISTER_BANK_INVALID;
145
176
}
146
177
 
147
178
pcilib_register_bank_t pcilib_find_register_bank_by_name(pcilib_t *ctx, const char *bankname) {
148
179
    pcilib_register_bank_t i;
149
 
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
150
 
    const pcilib_register_bank_description_t *banks = model_info->banks;
151
180
 
152
 
    for (i = 0; banks[i].access; i++)
153
 
        if (!strcasecmp(banks[i].name, bankname)) return i;
 
181
    for (i = 0; ctx->banks[i].access; i++)
 
182
        if (!strcasecmp(ctx->banks[i].name, bankname)) return i;
154
183
 
155
184
    return PCILIB_REGISTER_BANK_INVALID;
156
185
}
203
232
 
204
233
pcilib_register_protocol_t pcilib_find_register_protocol_by_addr(pcilib_t *ctx, pcilib_register_protocol_addr_t protocol) {
205
234
    pcilib_register_protocol_t i;
206
 
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
207
 
    const pcilib_register_protocol_description_t *protocols = model_info->protocols;
208
235
 
209
 
    for (i = 0; protocols[i].api; i++)
210
 
        if (protocols[i].addr == protocol) return i;
 
236
    for (i = 0; ctx->protocols[i].api; i++)
 
237
        if (ctx->protocols[i].addr == protocol) return i;
211
238
 
212
239
    return PCILIB_REGISTER_PROTOCOL_INVALID;
213
240
}
214
241
 
215
242
pcilib_register_protocol_t pcilib_find_register_protocol_by_name(pcilib_t *ctx, const char *name) {
216
243
    pcilib_register_protocol_t i;
217
 
    const pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
218
 
    const pcilib_register_protocol_description_t *protocols = model_info->protocols;
219
244
 
220
 
    for (i = 0; protocols[i].api; i++)
221
 
        if (!strcasecmp(protocols[i].name, name)) return i;
 
245
    for (i = 0; ctx->protocols[i].api; i++)
 
246
        if (!strcasecmp(ctx->protocols[i].name, name)) return i;
222
247
 
223
248
    return PCILIB_REGISTER_PROTOCOL_INVALID;
224
249
}