/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 pywrap/pcipywrap.c

  • Committer: Suren A. Chilingaryan
  • Date: 2016-03-02 22:36:19 UTC
  • mfrom: (346.1.35 pcitool)
  • Revision ID: csa@suren.me-20160302223619-r1zd62x6kwbyd321
Further improvements of Python scripting and web-interface API for register manipulations by Vasiliy Chernov

Show diffs side-by-side

added added

removed removed

Lines of Context:
pywrap/pcipywrap.c
94
94
}
95
95
 
96
96
 
97
 
void __redirect_logs_to_exeption()
 
97
void redirect_logs_to_exeption()
98
98
{
99
99
    pcilib_set_logger(pcilib_get_log_level(),
100
100
                      pcilib_print_error_to_py,
128
128
 
129
129
    if(py_val)
130
130
        pcilib_pydict_set_item(dict,
131
 
                               PyString_FromString(name),
 
131
                               PyUnicode_FromString(name),
132
132
                               py_val);
133
133
    else
134
134
        pcilib_pydict_set_item(dict,
135
 
                               PyString_FromString("defvalue"),
136
 
                               PyString_FromString("invalid"));
 
135
                               PyUnicode_FromString("defvalue"),
 
136
                               PyUnicode_FromString("invalid"));
137
137
}
138
138
 
139
139
PyObject * pcilib_convert_property_info_to_pyobject(pcilib_t* ctx, pcilib_property_info_t listItem)
142
142
 
143
143
    if(listItem.name)
144
144
        pcilib_pydict_set_item(pylistItem,
145
 
                               PyString_FromString("name"),
146
 
                               PyString_FromString(listItem.name));
 
145
                               PyUnicode_FromString("name"),
 
146
                               PyUnicode_FromString(listItem.name));
147
147
 
148
148
    if(listItem.description)
149
149
        pcilib_pydict_set_item(pylistItem,
150
 
                               PyString_FromString("description"),
151
 
                               PyString_FromString(listItem.description));
 
150
                               PyUnicode_FromString("description"),
 
151
                               PyUnicode_FromString(listItem.description));
152
152
 
153
153
    if(listItem.path)
154
154
        pcilib_pydict_set_item(pylistItem,
155
 
                               PyString_FromString("path"),
156
 
                               PyString_FromString(listItem.path));
 
155
                               PyUnicode_FromString("path"),
 
156
                               PyUnicode_FromString(listItem.path));
157
157
 
158
158
    //serialize types
159
159
    const char* type = "invalid";
175
175
        break;
176
176
    }
177
177
    pcilib_pydict_set_item(pylistItem,
178
 
                           PyString_FromString("type"),
179
 
                           PyString_FromString(type));
 
178
                           PyUnicode_FromString("type"),
 
179
                           PyUnicode_FromString(type));
180
180
 
181
181
 
182
182
    //serialize modes
183
183
    PyObject* modes = PyList_New(0);
184
184
 
185
185
    if((listItem.mode & PCILIB_ACCESS_R ) == PCILIB_REGISTER_R)
186
 
        pcilib_pylist_append(modes, PyString_FromString("R"));
 
186
        pcilib_pylist_append(modes, PyUnicode_FromString("R"));
187
187
    if((listItem.mode & PCILIB_ACCESS_W ) == PCILIB_REGISTER_W)
188
 
        pcilib_pylist_append(modes, PyString_FromString("W"));
 
188
        pcilib_pylist_append(modes, PyUnicode_FromString("W"));
189
189
    if((listItem.mode & PCILIB_ACCESS_RW ) == PCILIB_REGISTER_RW)
190
 
        pcilib_pylist_append(modes, PyString_FromString("RW"));
 
190
        pcilib_pylist_append(modes, PyUnicode_FromString("RW"));
191
191
    if((listItem.mode & PCILIB_REGISTER_INCONSISTENT) == PCILIB_REGISTER_INCONSISTENT)
192
 
        pcilib_pylist_append(modes, PyString_FromString("NO_CHK"));
 
192
        pcilib_pylist_append(modes, PyUnicode_FromString("NO_CHK"));
193
193
 
194
194
    pcilib_pydict_set_item(pylistItem,
195
 
                           PyString_FromString("mode"),
 
195
                           PyUnicode_FromString("mode"),
196
196
                           modes);
197
197
 
198
198
    //serialize flags
199
199
    PyObject* flags = PyList_New(0);
200
200
 
201
201
    if((listItem.flags & PCILIB_LIST_FLAG_CHILDS ) == PCILIB_LIST_FLAG_CHILDS)
202
 
        pcilib_pylist_append(flags, PyString_FromString("childs"));
 
202
        pcilib_pylist_append(flags, PyUnicode_FromString("childs"));
203
203
 
204
204
    pcilib_pydict_set_item(pylistItem,
205
 
                           PyString_FromString("flags"),
 
205
                           PyUnicode_FromString("flags"),
206
206
                           flags);
207
207
 
208
208
    if(listItem.unit)
209
209
        pcilib_pydict_set_item(pylistItem,
210
 
                               PyString_FromString("unit"),
211
 
                               PyString_FromString(listItem.unit));
 
210
                               PyUnicode_FromString("unit"),
 
211
                               PyUnicode_FromString(listItem.unit));
212
212
 
213
213
    return pylistItem;
214
214
}
219
219
 
220
220
    if(listItem.name)
221
221
        pcilib_pydict_set_item(pylistItem,
222
 
                               PyString_FromString("name"),
223
 
                               PyString_FromString(listItem.name));
 
222
                               PyUnicode_FromString("name"),
 
223
                               PyUnicode_FromString(listItem.name));
224
224
 
225
225
    if(listItem.description)
226
226
        pcilib_pydict_set_item(pylistItem,
227
 
                               PyString_FromString("description"),
228
 
                               PyString_FromString(listItem.description));
 
227
                               PyUnicode_FromString("description"),
 
228
                               PyUnicode_FromString(listItem.description));
229
229
 
230
230
    if(listItem.bank)
231
231
        pcilib_pydict_set_item(pylistItem,
232
 
                               PyString_FromString("bank"),
233
 
                               PyString_FromString(listItem.bank));
 
232
                               PyUnicode_FromString("bank"),
 
233
                               PyUnicode_FromString(listItem.bank));
234
234
 
235
235
 
236
236
    //serialize modes
237
237
    PyObject* modes = PyList_New(0);
238
238
 
239
239
    if((listItem.mode & PCILIB_REGISTER_R) == PCILIB_REGISTER_R)
240
 
        pcilib_pylist_append(modes, PyString_FromString("R"));
 
240
        pcilib_pylist_append(modes, PyUnicode_FromString("R"));
241
241
    if((listItem.mode & PCILIB_REGISTER_W) == PCILIB_REGISTER_W)
242
 
        pcilib_pylist_append(modes, PyString_FromString("W"));
 
242
        pcilib_pylist_append(modes, PyUnicode_FromString("W"));
243
243
    if((listItem.mode & PCILIB_REGISTER_RW) == PCILIB_REGISTER_RW)
244
 
        pcilib_pylist_append(modes, PyString_FromString("RW"));
 
244
        pcilib_pylist_append(modes, PyUnicode_FromString("RW"));
245
245
    if((listItem.mode & PCILIB_REGISTER_W1C) == PCILIB_REGISTER_W1C)
246
 
        pcilib_pylist_append(modes, PyString_FromString("W1C"));
 
246
        pcilib_pylist_append(modes, PyUnicode_FromString("W1C"));
247
247
    if((listItem.mode & PCILIB_REGISTER_RW1C) == PCILIB_REGISTER_RW1C)
248
 
        pcilib_pylist_append(modes, PyString_FromString("RW1C"));
 
248
        pcilib_pylist_append(modes, PyUnicode_FromString("RW1C"));
249
249
    if((listItem.mode & PCILIB_REGISTER_W1I) == PCILIB_REGISTER_W1I)
250
 
        pcilib_pylist_append(modes, PyString_FromString("W1I"));
 
250
        pcilib_pylist_append(modes, PyUnicode_FromString("W1I"));
251
251
    if((listItem.mode & PCILIB_REGISTER_RW1I) == PCILIB_REGISTER_RW1I)
252
 
        pcilib_pylist_append(modes, PyString_FromString("RW1I"));
 
252
        pcilib_pylist_append(modes, PyUnicode_FromString("RW1I"));
253
253
    if((listItem.mode & PCILIB_REGISTER_INCONSISTENT) == PCILIB_REGISTER_INCONSISTENT)
254
 
        pcilib_pylist_append(modes, PyString_FromString("NO_CHK"));
 
254
        pcilib_pylist_append(modes, PyUnicode_FromString("NO_CHK"));
255
255
 
256
256
    pcilib_pydict_set_item(pylistItem,
257
 
                           PyString_FromString("mode"),
 
257
                           PyUnicode_FromString("mode"),
258
258
                           modes);
259
259
 
260
260
    pcilib_value_t defval = {0};
273
273
        add_pcilib_value_to_dict(ctx, range, &minval, "min");
274
274
        add_pcilib_value_to_dict(ctx, range, &maxval, "max");
275
275
        pcilib_pydict_set_item(pylistItem,
276
 
                               PyString_FromString("range"),
 
276
                               PyUnicode_FromString("range"),
277
277
                               range);
278
278
    }
279
279
 
301
301
 
302
302
            if(listItem.values[j].name)
303
303
                pcilib_pydict_set_item(valuesItem,
304
 
                                       PyString_FromString("name"),
305
 
                                       PyString_FromString(listItem.values[j].name));
 
304
                                       PyUnicode_FromString("name"),
 
305
                                       PyUnicode_FromString(listItem.values[j].name));
306
306
            if(listItem.values[j].description)
307
307
            {
308
308
                pcilib_pydict_set_item(valuesItem,
309
 
                                       PyString_FromString("description"),
310
 
                                       PyString_FromString(listItem.values[j].description));
 
309
                                       PyUnicode_FromString("description"),
 
310
                                       PyUnicode_FromString(listItem.values[j].description));
311
311
 
312
312
            }
313
313
            pcilib_pylist_append(values, valuesItem);
314
314
        }
315
315
 
316
316
        pcilib_pydict_set_item(pylistItem,
317
 
                               PyString_FromString("values"),
 
317
                               PyUnicode_FromString("values"),
318
318
                               values);
319
319
    }
320
320
 
322
322
 
323
323
}
324
324
 
325
 
Pcipywrap *new_Pcipywrap(const char* fpga_device, const char* model)
 
325
pcipywrap *new_pcipywrap(const char* fpga_device, const char* model)
326
326
{
327
327
    //opening device
328
328
    pcilib_t* ctx = pcilib_open(fpga_device, model);
331
331
        set_python_exception("Failed pcilib_open(%s, %s)", fpga_device, model);
332
332
        return NULL;
333
333
    }
334
 
    Pcipywrap *self;
335
 
    self = (Pcipywrap *) malloc(sizeof(Pcipywrap));
 
334
    pcipywrap *self;
 
335
    self = (pcipywrap *) malloc(sizeof(pcipywrap));
336
336
    self->shared = 0;
337
337
    self->ctx = ctx;
338
338
    return self;
339
339
}
340
340
 
341
 
Pcipywrap *create_Pcipywrap(PyObject* ctx)
 
341
pcipywrap *create_pcipywrap(PyObject* ctx)
342
342
{
343
 
    if(!PyCObject_Check(ctx))
 
343
    if(!PyCapsule_CheckExact(ctx))
344
344
    {
345
 
        set_python_exception("Incorrect ctx type. Only PyCObject is allowed");
 
345
        set_python_exception("Incorrect ctx type. Only PyCapsule is allowed");
346
346
        return NULL;
347
347
    }
348
348
 
349
 
    Pcipywrap *self;
350
 
    self = (Pcipywrap *) malloc(sizeof(Pcipywrap));
 
349
    pcipywrap *self;
 
350
    self = (pcipywrap *) malloc(sizeof(pcipywrap));
351
351
    self->shared = 1;
352
 
    self->ctx = PyCObject_AsVoidPtr(ctx);
 
352
    self->ctx = PyCapsule_GetPointer(ctx, PyCapsule_GetName(ctx));
 
353
 
353
354
    return self;
354
355
}
355
356
 
356
 
void delete_Pcipywrap(Pcipywrap *self) {
 
357
void delete_pcipywrap(pcipywrap *self) {
357
358
    if(!self->shared)
358
359
        pcilib_close(self->ctx);
359
360
 
360
361
    free(self);
361
362
}
362
363
 
363
 
PyObject* Pcipywrap_read_register(Pcipywrap *self, const char *regname, const char *bank)
 
364
PyObject* pcipywrap_read_register(pcipywrap *self, const char *regname, const char *bank)
364
365
{
365
366
    pcilib_value_t val = {0};
366
367
    pcilib_register_value_t reg_value;
384
385
    return pcilib_get_value_as_pyobject(self->ctx, &val, NULL);
385
386
}
386
387
 
387
 
PyObject* Pcipywrap_write_register(Pcipywrap *self, PyObject* val, const char *regname, const char *bank)
 
388
PyObject* pcipywrap_write_register(pcipywrap *self, PyObject* val, const char *regname, const char *bank)
388
389
{
389
390
    pcilib_value_t val_internal = {0};
390
391
    pcilib_register_value_t reg_value;
415
416
        return NULL;
416
417
    }
417
418
 
418
 
    return PyInt_FromLong((long)1);
 
419
    return PyLong_FromLong((long)1);
419
420
}
420
421
 
421
 
PyObject* Pcipywrap_get_property(Pcipywrap *self, const char *prop)
 
422
PyObject* pcipywrap_get_property(pcipywrap *self, const char *prop)
422
423
{
423
424
    int err;
424
425
    pcilib_value_t val = {0};
434
435
    return pcilib_get_value_as_pyobject(self->ctx, &val, NULL);
435
436
}
436
437
 
437
 
PyObject* Pcipywrap_set_property(Pcipywrap *self, PyObject* val, const char *prop)
 
438
PyObject* pcipywrap_set_property(pcipywrap *self, PyObject* val, const char *prop)
438
439
{
439
440
    int err;
440
441
 
453
454
        return NULL;
454
455
    }
455
456
 
456
 
    return PyInt_FromLong((long)1);
 
457
    return PyLong_FromLong((long)1);
457
458
}
458
459
 
459
 
PyObject* Pcipywrap_get_registers_list(Pcipywrap *self, const char *bank)
 
460
PyObject* pcipywrap_get_registers_list(pcipywrap *self, const char *bank)
460
461
{
461
 
    pcilib_register_info_t *list = pcilib_get_register_list(self->ctx, bank, PCILIB_LIST_FLAGS_DEFAULT);
462
 
    PyObject* pyList = PyList_New(0);
463
 
    for(int i = 0; i < ((pcilib_t*)self->ctx)->num_reg; i++)
464
 
    {
465
 
        //serialize item attributes
466
 
        PyObject* pylistItem = pcilib_convert_register_info_to_pyobject(self->ctx, list[i]);
467
 
        pcilib_pylist_append(pyList, pylistItem);
468
 
        //Py_DECREF(pylistItem);
469
 
    }
470
 
    pcilib_free_register_info(self->ctx, list);
471
 
    return pyList;
 
462
   pcilib_register_info_t *list = pcilib_get_register_list(self->ctx, bank, PCILIB_LIST_FLAGS_DEFAULT);
 
463
 
 
464
   if(!list) {
 
465
      set_python_exception("pcilib_get_register_list return NULL");
 
466
      return NULL;
 
467
   }
 
468
 
 
469
   PyObject* pyList = PyList_New(0);
 
470
   for(int i = 0; list[i].name; i++)
 
471
   {
 
472
      //serialize item attributes
 
473
      PyObject* pylistItem = pcilib_convert_register_info_to_pyobject(self->ctx, list[i]);
 
474
      pcilib_pylist_append(pyList, pylistItem);
 
475
   }
 
476
   pcilib_free_register_info(self->ctx, list);
 
477
   return pyList;
472
478
}
473
479
 
474
 
PyObject* Pcipywrap_get_register_info(Pcipywrap *self, const char* reg,const char *bank)
 
480
PyObject* pcipywrap_get_register_info(pcipywrap *self, const char* reg,const char *bank)
475
481
{
476
482
    pcilib_register_info_t *info = pcilib_get_register_info(self->ctx, bank, reg, PCILIB_LIST_FLAGS_DEFAULT);
477
483
 
487
493
    return py_info;
488
494
}
489
495
 
490
 
PyObject* Pcipywrap_get_property_list(Pcipywrap *self, const char* branch)
 
496
PyObject* pcipywrap_get_property_list(pcipywrap *self, const char* branch)
491
497
{
492
498
    pcilib_property_info_t *list = pcilib_get_property_list(self->ctx, branch, PCILIB_LIST_FLAGS_DEFAULT);
493
499
 
505
511
    return pyList;
506
512
}
507
513
 
508
 
PyObject* Pcipywrap_read_dma(Pcipywrap *self, unsigned char dma, size_t size)
 
514
PyObject* pcipywrap_read_dma(pcipywrap *self, unsigned char dma, size_t size)
509
515
{
510
516
    int err;
511
517
    void* buf = NULL;
526
532
    return py_buf;
527
533
}
528
534
 
529
 
PyObject* Pcipywrap_lock_global(Pcipywrap *self)
 
535
PyObject* pcipywrap_lock_global(pcipywrap *self)
530
536
{
531
537
    int err;
532
538
 
537
543
        return NULL;
538
544
    }
539
545
 
540
 
    return PyInt_FromLong((long)1);
 
546
    return PyLong_FromLong((long)1);
541
547
}
542
548
 
543
 
void Pcipywrap_unlock_global(Pcipywrap *self)
 
549
void pcipywrap_unlock_global(pcipywrap *self)
544
550
{
545
551
    pcilib_unlock_global(self->ctx);
546
552
    return;
547
553
}
548
554
 
549
 
PyObject* Pcipywrap_lock(Pcipywrap *self, const char *lock_id)
 
555
PyObject* pcipywrap_lock(pcipywrap *self, const char *lock_id)
550
556
{
551
557
    pcilib_lock_t* lock = pcilib_get_lock(self->ctx,
552
 
                                          PCILIB_LOCK_FLAGS_DEFAULT,
 
558
                                          PCILIB_LOCK_FLAG_PERSISTENT,
553
559
                                          lock_id);
554
560
    if(!lock)
555
561
    {
565
571
        return NULL;
566
572
    }
567
573
 
568
 
    return PyInt_FromLong((long)1);
 
574
    return PyLong_FromLong((long)1);
569
575
}
570
576
 
571
 
PyObject* Pcipywrap_try_lock(Pcipywrap *self, const char *lock_id)
 
577
PyObject* pcipywrap_try_lock(pcipywrap *self, const char *lock_id)
572
578
{
573
579
    pcilib_lock_t* lock = pcilib_get_lock(self->ctx,
574
 
                                          PCILIB_LOCK_FLAGS_DEFAULT,
 
580
                                          PCILIB_LOCK_FLAG_PERSISTENT,
575
581
                                          lock_id);
576
582
    if(!lock)
577
583
    {
586
592
        return NULL;
587
593
    }
588
594
 
589
 
    return PyInt_FromLong((long)1);
 
595
    return PyLong_FromLong((long)1);
590
596
}
591
597
 
592
 
PyObject* Pcipywrap_unlock(Pcipywrap *self, const char *lock_id)
 
598
PyObject* pcipywrap_unlock(pcipywrap *self, const char *lock_id)
593
599
{
594
600
    pcilib_lock_t* lock = pcilib_get_lock(self->ctx,
595
 
                                          PCILIB_LOCK_FLAGS_DEFAULT,
 
601
                                          PCILIB_LOCK_FLAG_PERSISTENT,
596
602
                                          lock_id);
597
603
    if(!lock)
598
604
    {
601
607
    }
602
608
 
603
609
    pcilib_unlock(lock);
604
 
    return PyInt_FromLong((long)1);
 
610
    return PyLong_FromLong((long)1);
605
611
}
606
612
 
607
613