← Back to branch summary

~ubuntu-branches/ubuntu/saucy/dahdi-tools/saucy

« back to all changes in this revision

Viewing changes to xpp/mpp_funcs.c

  • Committer: Bazaar Package Importer
  • Author(s): Jean-Michel Dault, Tzafrir Cohen
  • Date: 2010-02-16 13:44:09 UTC
  • mfrom: (1.1.2 upstream) (2.1.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100216134409-4y4k26mgzyra537o
Tags: 1:2.2.1-0ubuntu1
http://bugs.debian.org/536257
http://bugs.debian.org/564381
* Merge from Debian pkg-voip.
  * Changes from Debian:
  - debian/control: Change Maintainer
  - debian/control: Removed Uploaders field.
  - debian/control: Removed Debian Vcs-Svn entry and replaced with
      ubuntu-voip Vcs-Bzr, to reflect divergence in packages.
  - debian/control: Package dahdi Depends on  dahdi-dkms | dahdi-source

* From Debian pkg-voip:
[ Tzafrir Cohen ]
* New upstream release (Closes: #536257, #564381).
* Patch 'bashism' dropped: merged upstream. 
* Patch xpp_no_extra_at dropped: merged upstream. 
* Add an example genconf_parameters.
* Compat level 7.
* Bump standars version to 3.8.3.0 (no change needed)
* Udev rules are now in dahdi-linux.
* Patches perl_fix_noserial, perl_fix_transportdir: Fixes for some
  minor perl issues.
* Add the missing ${misc:Depends}, as per lintian. 
* Patch astribank_allow_ignoreend: an extra missing patch from upstream. 
* Patches init_unload_modules and init_unload_oslec: also unload OSLEC
  when unloading all modules.

Show diffs side-by-side

added added

removed removed

Lines of Context:
xpp/mpp_funcs.c
30
30
#include "mpp_funcs.h"
31
31
#include "debug.h"
32
32
 
33
 
static const char rcsid[] = "$Id: mpp_funcs.c 6617 2009-05-13 20:18:20Z tzafrir $";
 
33
static const char rcsid[] = "$Id: mpp_funcs.c 7621 2009-11-22 11:48:40Z tzafrir $";
34
34
 
35
35
#define DBG_MASK        0x02
36
36
 
76
76
        return msgs[et];
77
77
};
78
78
 
 
79
const char *dev_dest2str(enum dev_dest dest)
 
80
{
 
81
        const static char       *msgs[] = {
 
82
                [DEST_NONE]     = "NONE",
 
83
                [DEST_FPGA]     = "FPGA",
 
84
                [DEST_EEPROM]   = "EEPROM",
 
85
        };
 
86
        if(dest > sizeof(msgs)/sizeof(msgs[0]))
 
87
                return NULL;
 
88
        return msgs[dest];
 
89
};
 
90
 
79
91
struct command_desc {
80
92
        uint8_t         op;
81
93
        const char      *name;
98
110
        CMD_RECV(ACK),
99
111
        CMD_SEND(PROTO_QUERY),
100
112
        CMD_SEND(STATUS_GET),
101
 
        CMD_SEND(STATUS_GET_REPLY),
102
 
        CMD_SEND(EEPROM_SET),
103
 
        CMD_SEND(CAPS_GET),
104
 
        CMD_RECV(CAPS_GET_REPLY),
105
 
        CMD_SEND(CAPS_SET),
106
 
        CMD_SEND(EXTRAINFO_GET),
107
 
        CMD_SEND(EXTRAINFO_GET_REPLY),
108
 
        CMD_SEND(EXTRAINFO_SET),
109
 
        CMD_RECV(PROTO_REPLY),
110
 
        CMD_SEND(RENUM),
111
 
        CMD_SEND(EEPROM_BLK_RD),
112
 
        CMD_RECV(EEPROM_BLK_RD_REPLY),
113
 
        CMD_SEND(DEV_SEND_SEG),
114
 
        CMD_SEND(DEV_SEND_START),
115
 
        CMD_SEND(DEV_SEND_END),
116
 
        CMD_SEND(RESET),
117
 
        CMD_SEND(HALF_RESET),
118
 
        CMD_SEND(SER_SEND),
119
 
        CMD_SEND(SER_RECV),
120
 
        /* Twinstar */
121
 
        CMD_SEND(TWS_WD_MODE_SET),
122
 
        CMD_SEND(TWS_WD_MODE_GET),
123
 
        CMD_RECV(TWS_WD_MODE_GET_REPLY),
124
 
        CMD_SEND(TWS_PORT_SET),
125
 
        CMD_SEND(TWS_PORT_GET),
126
 
        CMD_RECV(TWS_PORT_GET_REPLY),
127
 
        CMD_SEND(TWS_PWR_GET),
128
 
        CMD_RECV(TWS_PWR_GET_REPLY),
129
 
};
 
113
        CMD_RECV(STATUS_GET_REPLY),
 
114
        CMD_SEND(EEPROM_SET),
 
115
        CMD_SEND(CAPS_GET),
 
116
        CMD_RECV(CAPS_GET_REPLY),
 
117
        CMD_SEND(CAPS_SET),
 
118
        CMD_SEND(EXTRAINFO_GET),
 
119
        CMD_RECV(EXTRAINFO_GET_REPLY),
 
120
        CMD_SEND(EXTRAINFO_SET),
 
121
        CMD_RECV(PROTO_REPLY),
 
122
        CMD_SEND(RENUM),
 
123
        CMD_SEND(EEPROM_BLK_RD),
 
124
        CMD_RECV(EEPROM_BLK_RD_REPLY),
 
125
        CMD_SEND(DEV_SEND_SEG),
 
126
        CMD_SEND(DEV_SEND_START),
 
127
        CMD_SEND(DEV_SEND_END),
 
128
        CMD_SEND(RESET),
 
129
        CMD_SEND(HALF_RESET),
 
130
        CMD_SEND(SER_SEND),
 
131
        CMD_SEND(SER_RECV),
 
132
        /* Twinstar */
 
133
        CMD_SEND(TWS_WD_MODE_SET),
 
134
        CMD_SEND(TWS_WD_MODE_GET),
 
135
        CMD_RECV(TWS_WD_MODE_GET_REPLY),
 
136
        CMD_SEND(TWS_PORT_SET),
 
137
        CMD_SEND(TWS_PORT_GET),
 
138
        CMD_RECV(TWS_PORT_GET_REPLY),
 
139
        CMD_SEND(TWS_PWR_GET),
 
140
        CMD_RECV(TWS_PWR_GET_REPLY),
 
141
};
 
142
 
 
143
static const struct command_desc        command_table_V13[] = {
 
144
        CMD_RECV(ACK),
 
145
        CMD_SEND(PROTO_QUERY),
 
146
        CMD_SEND(STATUS_GET),
 
147
        CMD_RECV(STATUS_GET_REPLY_V13),
 
148
        CMD_SEND(EEPROM_SET),
 
149
        CMD_SEND(CAPS_GET),
 
150
        CMD_RECV(CAPS_GET_REPLY),
 
151
        CMD_SEND(CAPS_SET),
 
152
        CMD_SEND(EXTRAINFO_GET),
 
153
        CMD_RECV(EXTRAINFO_GET_REPLY),
 
154
        CMD_SEND(EXTRAINFO_SET),
 
155
        CMD_RECV(PROTO_REPLY),
 
156
        CMD_SEND(RENUM),
 
157
        CMD_SEND(EEPROM_BLK_RD),
 
158
        CMD_RECV(EEPROM_BLK_RD_REPLY),
 
159
        CMD_SEND(DEV_SEND_SEG),
 
160
        CMD_SEND(DEV_SEND_START),
 
161
        CMD_SEND(DEV_SEND_END),
 
162
        CMD_SEND(RESET),
 
163
        CMD_SEND(HALF_RESET),
 
164
        CMD_SEND(SER_SEND),
 
165
        CMD_SEND(SER_RECV),
 
166
        /* Twinstar */
 
167
        CMD_SEND(TWS_WD_MODE_SET),
 
168
        CMD_SEND(TWS_WD_MODE_GET),
 
169
        CMD_RECV(TWS_WD_MODE_GET_REPLY),
 
170
        CMD_SEND(TWS_PORT_SET),
 
171
        CMD_SEND(TWS_PORT_GET),
 
172
        CMD_RECV(TWS_PORT_GET_REPLY),
 
173
        CMD_SEND(TWS_PWR_GET),
 
174
        CMD_RECV(TWS_PWR_GET_REPLY),
 
175
};
 
176
 
130
177
#undef  CMD_SEND
131
178
#undef  CMD_RECV
132
179
 
148
195
        free(cmd);
149
196
}
150
197
 
151
 
struct mpp_command *new_command(uint8_t op, uint16_t extra_data)
 
198
const struct command_desc *get_command_desc(uint8_t protocol_version, uint8_t op)
 
199
{
 
200
        const struct command_desc       *desc;
 
201
 
 
202
        switch(protocol_version) {
 
203
                case MK_PROTO_VERSION(1,3):
 
204
                        if(op > sizeof(command_table_V13)/sizeof(command_table_V13[0])) {
 
205
                                //ERR("Invalid op=0x%X. Bigger than max valid op\n", op);
 
206
                                return NULL;
 
207
                        }
 
208
                        desc = &command_table_V13[op];
 
209
                        if(!desc->name)
 
210
                                return NULL;
 
211
                        break;
 
212
                default:
 
213
                        if(op > sizeof(command_table)/sizeof(command_table[0])) {
 
214
                                //ERR("Invalid op=0x%X. Bigger than max valid op\n", op);
 
215
                                return NULL;
 
216
                        }
 
217
                        desc = &command_table[op];
 
218
                        if(!desc->name)
 
219
                                return NULL;
 
220
                        break;
 
221
        }
 
222
        return desc;
 
223
}
 
224
 
 
225
struct mpp_command *new_command(uint8_t protocol_version, uint8_t op, uint16_t extra_data)
152
226
{
153
227
        struct mpp_command              *cmd;
154
228
        const struct command_desc       *desc;
155
229
        uint16_t                        len;
156
230
 
157
 
        DBG("OP=0x%X (extra_data %d)\n", op, extra_data);
158
 
        if(op > sizeof(command_table)/sizeof(command_table[0])) {
159
 
                ERR("Invalid op=0x%X. Bigger than max valid op\n", op);
160
 
                return NULL;
161
 
        }
162
 
        desc = &command_table[op];
163
 
        if(!desc->name) {
 
231
        desc = get_command_desc(protocol_version, op);
 
232
        if(!desc) {
164
233
                ERR("Unknown op=0x%X.\n", op);
165
234
                return NULL;
166
235
        }
 
236
        DBG("OP=0x%X [%s] (extra_data %d)\n", op, desc->name, extra_data);
167
237
        len = desc->len + extra_data;
168
238
        if((cmd = malloc(len)) == NULL) {
169
239
                ERR("Out of memory\n");
175
245
        return cmd;
176
246
}
177
247
 
178
 
const struct command_desc *get_command_desc(uint8_t op)
179
 
{
180
 
        const struct command_desc       *desc;
181
 
 
182
 
        if(op > sizeof(command_table)/sizeof(command_table[0])) {
183
 
                //ERR("Invalid op=0x%X. Bigger than max valid op\n", op);
184
 
                return NULL;
185
 
        }
186
 
        desc = &command_table[op];
187
 
        if(!desc->name)
188
 
                return NULL;
189
 
        return desc;
190
 
}
191
 
 
192
 
const char *get_command_name(uint8_t op)
193
 
{
194
 
        const struct command_desc       *desc;
195
 
 
196
 
        if((desc = get_command_desc(op)) == NULL)
197
 
                return NULL;
198
 
        return desc->name;
199
 
}
200
 
 
201
248
void dump_command(struct mpp_command *cmd)
202
249
{
203
250
        uint16_t        len;
239
286
#endif
240
287
        ret = send_usb(astribank, (char *)cmd, len, timeout);
241
288
        if(ret < 0) {
242
 
                ERR("send_usb failed ret=%d\n", ret);
 
289
                DBG("send_usb failed ret=%d\n", ret);
243
290
        }
244
291
        astribank->tx_sequenceno++;
245
292
        return ret;
259
306
        if(ret < 0) {
260
307
                ERR("Receive from usb failed.\n");
261
308
                goto err;
 
309
        } else if(ret == 0) {
 
310
                goto err;       /* No reply */
262
311
        }
263
312
        if(ret != reply->header.len) {
264
313
                ERR("Wrong length received: got %d bytes, but length field says %d bytes%s\n",
277
326
}
278
327
 
279
328
 
 
329
__attribute__((warn_unused_result))
280
330
int process_command(struct astribank_device *astribank, struct mpp_command *cmd, struct mpp_command **reply_ref)
281
331
{
282
332
        struct mpp_command              *reply = NULL;
283
333
        const struct command_desc       *reply_desc;
284
334
        const struct command_desc       *expected;
 
335
        const struct command_desc       *cmd_desc;
285
336
        uint8_t                         reply_op;
286
337
        int                             ret;
287
338
 
288
339
        if(reply_ref)
289
340
                *reply_ref = NULL;      /* So the caller knows if a reply was received */
290
341
        reply_op = cmd->header.op | 0x80;
291
 
        expected = get_command_desc(reply_op);
 
342
        if(cmd->header.op == MPP_PROTO_QUERY)
 
343
                astribank->mpp_proto_version = MPP_PROTOCOL_VERSION;    /* bootstrap */
 
344
        cmd_desc = get_command_desc(astribank->mpp_proto_version, cmd->header.op);
 
345
        expected = get_command_desc(astribank->mpp_proto_version, reply_op);
292
346
        //printf("%s: len=%d\n", __FUNCTION__, cmd->header.len);
293
347
        ret = send_command(astribank, cmd, TIMEOUT);
294
 
        if(ret < 0) {
295
 
                ERR("send_command failed: %d\n", ret);
296
 
                goto out;
297
 
        }
298
348
        if(!reply_ref) {
299
349
                DBG("No reply requested\n");
300
350
                goto out;
301
351
        }
 
352
        if(ret < 0) {
 
353
                ERR("send_command failed: %d\n", ret);
 
354
                goto out;
 
355
        }
302
356
        reply = recv_command(astribank, TIMEOUT);
303
357
        if(!reply) {
304
358
                ERR("recv_command failed\n");
312
366
                goto out;
313
367
        }
314
368
        DBG("REPLY OP: 0x%X\n", reply->header.op);
315
 
        reply_desc = get_command_desc(reply->header.op);
 
369
        reply_desc = get_command_desc(astribank->mpp_proto_version, reply->header.op);
316
370
        if(!reply_desc) {
317
371
                ERR("Unknown reply op=0x%02X\n", reply->header.op);
318
372
                ret = -EPROTO;
329
383
                        goto out;
330
384
                } else if(status != STAT_OK) {
331
385
 
332
 
                        ERR("Got ACK (for OP=0x%X): %d - %s\n",
 
386
                        ERR("Got ACK (for OP=0x%X [%s]): %d - %s\n",
333
387
                                cmd->header.op,
 
388
                                cmd_desc->name,
334
389
                                status,
335
390
                                ack_status_msg(status));
336
391
#if 0
370
425
        return ret;
371
426
}
372
427
 
 
428
static int set_ihex_version(char *dst, const char *src)
 
429
{
 
430
        memcpy(dst, src, VERSION_LEN);
 
431
        return 0;
 
432
}
 
433
 
373
434
/*
374
435
 * Protocol Commands
375
436
 */
382
443
 
383
444
        DBG("\n");
384
445
        assert(astribank != NULL);
385
 
        if((cmd = new_command(MPP_PROTO_QUERY, 0)) == NULL) {
 
446
        if((cmd = new_command(astribank->mpp_proto_version, MPP_PROTO_QUERY, 0)) == NULL) {
386
447
                ERR("new_command failed\n");
387
448
                return -ENOMEM;
388
449
        }
393
454
                return ret;
394
455
        }
395
456
        astribank->mpp_proto_version = CMD_FIELD(reply, PROTO_REPLY, proto_version);
396
 
        if(astribank->mpp_proto_version != MPP_PROTOCOL_VERSION) {
 
457
        if(! MPP_SUPPORTED_VERSION(astribank->mpp_proto_version)) {
397
458
                ERR("Got mpp protocol version: %02x (expected %02x)\n",
398
459
                        astribank->mpp_proto_version,
399
460
                        MPP_PROTOCOL_VERSION);
400
461
                ret = -EPROTO;
401
462
                goto out;
402
463
        }
403
 
        INFO("Protocol version: %02x\n", astribank->mpp_proto_version);
 
464
        if(astribank->mpp_proto_version != MPP_PROTOCOL_VERSION) {
 
465
                ERR("Deprecated (but working) MPP protocol version [%X]. Please upgrade to [%X] ASAP\n",
 
466
                        astribank->mpp_proto_version, MPP_PROTOCOL_VERSION);
 
467
        }
 
468
        DBG("Protocol version: %02x\n", astribank->mpp_proto_version);
 
469
        ret = astribank->mpp_proto_version;
404
470
        free_command(reply);
405
471
out:
406
472
        return ret;
414
480
 
415
481
        DBG("\n");
416
482
        assert(astribank != NULL);
417
 
        if((cmd = new_command(MPP_STATUS_GET, 0)) == NULL) {
 
483
        if((cmd = new_command(astribank->mpp_proto_version, MPP_STATUS_GET, 0)) == NULL) {
418
484
                ERR("new_command failed\n");
419
485
                return -ENOMEM;
420
486
        }
425
491
        }
426
492
        astribank->eeprom_type = 0x3 & (CMD_FIELD(reply, STATUS_GET_REPLY, i2cs_data) >> 3);
427
493
        astribank->status = CMD_FIELD(reply, STATUS_GET_REPLY, status);
 
494
        astribank->fw_versions = CMD_FIELD(reply, STATUS_GET_REPLY, fw_versions);
428
495
        DBG("EEPROM TYPE: %02x\n", astribank->eeprom_type);
429
496
        DBG("FPGA Firmware: %s\n", (astribank->status & 0x1) ? "Loaded" : "Empty");
 
497
        DBG("Firmware Versions: USB='%s' FPGA='%s' EEPROM='%s'\n",
 
498
                astribank->fw_versions.usb,
 
499
                astribank->fw_versions.fpga,
 
500
                astribank->fw_versions.eeprom);
430
501
        free_command(reply);
431
502
        return ret;
432
503
}
439
510
 
440
511
        DBG("\n");
441
512
        assert(astribank != NULL);
442
 
        if((cmd = new_command(MPP_EEPROM_SET, 0)) == NULL) {
 
513
        if((cmd = new_command(astribank->mpp_proto_version, MPP_EEPROM_SET, 0)) == NULL) {
443
514
                ERR("new_command failed\n");
444
515
                return -ENOMEM;
445
516
        }
460
531
 
461
532
        DBG("\n");
462
533
        assert(astribank != NULL);
463
 
        if((cmd = new_command(MPP_RENUM, 0)) == NULL) {
 
534
        if((cmd = new_command(astribank->mpp_proto_version, MPP_RENUM, 0)) == NULL) {
464
535
                ERR("new_command failed\n");
465
536
                return -ENOMEM;
466
537
        }
483
554
 
484
555
        DBG("\n");
485
556
        assert(astribank != NULL);
486
 
        if((cmd = new_command(MPP_CAPS_GET, 0)) == NULL) {
 
557
        if((cmd = new_command(astribank->mpp_proto_version, MPP_CAPS_GET, 0)) == NULL) {
487
558
                ERR("new_command failed\n");
488
559
                return -ENOMEM;
489
560
        }
521
592
 
522
593
        DBG("\n");
523
594
        assert(astribank != NULL);
524
 
        if((cmd = new_command(MPP_CAPS_SET, 0)) == NULL) {
 
595
        if((cmd = new_command(astribank->mpp_proto_version, MPP_CAPS_SET, 0)) == NULL) {
525
596
                ERR("new_command failed\n");
526
597
                return -ENOMEM;
527
598
        }
545
616
 
546
617
        DBG("\n");
547
618
        assert(astribank != NULL);
548
 
        if((cmd = new_command(MPP_EXTRAINFO_GET, 0)) == NULL) {
 
619
        if((cmd = new_command(astribank->mpp_proto_version, MPP_EXTRAINFO_GET, 0)) == NULL) {
549
620
                ERR("new_command failed\n");
550
621
                return -ENOMEM;
551
622
        }
570
641
 
571
642
        DBG("\n");
572
643
        assert(astribank != NULL);
573
 
        if((cmd = new_command(MPP_EXTRAINFO_SET, 0)) == NULL) {
 
644
        if((cmd = new_command(astribank->mpp_proto_version, MPP_EXTRAINFO_SET, 0)) == NULL) {
574
645
                ERR("new_command failed\n");
575
646
                return -ENOMEM;
576
647
        }
593
664
 
594
665
        DBG("len = %d, offset = %d\n", len, offset);
595
666
        assert(astribank != NULL);
596
 
        if((cmd = new_command(MPP_EEPROM_BLK_RD, 0)) == NULL) {
 
667
        if((cmd = new_command(astribank->mpp_proto_version, MPP_EEPROM_BLK_RD, 0)) == NULL) {
597
668
                ERR("new_command failed\n");
598
669
                return -ENOMEM;
599
670
        }
605
676
                size = ret;
606
677
                goto out;
607
678
        }
 
679
        size = reply->header.len - sizeof(struct mpp_header) - sizeof(struct d_EEPROM_BLK_RD_REPLY);
608
680
        INFO("size=%d offset=0x%X\n", size, CMD_FIELD(reply, EEPROM_BLK_RD_REPLY, offset));
609
681
        dump_packet(LOG_DEBUG, "BLK_RD", (char *)reply, ret);
610
 
        size = reply->header.len - sizeof(struct mpp_header) - sizeof(struct d_EEPROM_BLK_RD_REPLY);
611
682
        if(size > len) {
612
683
                ERR("Truncating reply (was %d, now %d)\n", size, len);
613
684
                size = len;
618
689
        return size;
619
690
}
620
691
 
621
 
int mpp_send_start(struct astribank_device *astribank, enum dev_dest dest)
 
692
int mpp_send_start(struct astribank_device *astribank, enum dev_dest dest, const char *ihex_version)
622
693
{
623
694
        struct mpp_command      *cmd;
624
695
        struct mpp_command      *reply = NULL;
625
696
        int                     ret = 0;
626
697
 
627
 
        DBG("dest = %d\n", dest);
 
698
        DBG("dest = %s ihex_version = '%s'\n", dev_dest2str(dest), ihex_version);
628
699
        assert(astribank != NULL);
629
 
        if((cmd = new_command(MPP_DEV_SEND_START, 0)) == NULL) {
 
700
        if((cmd = new_command(astribank->mpp_proto_version, MPP_DEV_SEND_START, 0)) == NULL) {
630
701
                ERR("new_command failed\n");
631
702
                ret = -ENOMEM;
632
703
                goto out;
633
704
        }
634
705
        CMD_FIELD(cmd, DEV_SEND_START, dest) = dest;
 
706
        set_ihex_version(CMD_FIELD(cmd, DEV_SEND_START, ihex_version), ihex_version);
635
707
        ret = process_command(astribank, cmd, &reply);
636
708
        if(ret < 0) {
637
709
                ERR("process_command failed: %d\n", ret);
654
726
 
655
727
        DBG("\n");
656
728
        assert(astribank != NULL);
657
 
        if((cmd = new_command(MPP_DEV_SEND_END, 0)) == NULL) {
 
729
        if((cmd = new_command(astribank->mpp_proto_version, MPP_DEV_SEND_END, 0)) == NULL) {
658
730
                ERR("new_command failed\n");
659
731
                ret = -ENOMEM;
660
732
                goto out;
686
758
        }
687
759
        DBG("len = %d, offset = %d (0x%02X, 0x%02X)\n", len, offset, *data, *(data + 1));
688
760
        assert(astribank != NULL);
689
 
        if((cmd = new_command(MPP_DEV_SEND_SEG, len)) == NULL) {
 
761
        if((cmd = new_command(astribank->mpp_proto_version, MPP_DEV_SEND_SEG, len)) == NULL) {
690
762
                ERR("new_command failed\n");
691
763
                return -ENOMEM;
692
764
        }
723
795
 
724
796
        DBG("full = %s\n", (full_reset) ? "YES" : "NO");
725
797
        assert(astribank != NULL);
726
 
        if((cmd = new_command(op, 0)) == NULL) {
 
798
        if((cmd = new_command(astribank->mpp_proto_version, op, 0)) == NULL) {
727
799
                ERR("new_command failed\n");
728
800
                return -ENOMEM;
729
801
        }
744
816
 
745
817
        DBG("len=%d\n", len);
746
818
        assert(astribank != NULL);
747
 
        if((cmd = new_command(MPP_SER_SEND, len)) == NULL) {
 
819
        if((cmd = new_command(astribank->mpp_proto_version, MPP_SER_SEND, len)) == NULL) {
748
820
                ERR("new_command failed\n");
749
821
                return -ENOMEM;
750
822
        }
802
874
 
803
875
        DBG("\n");
804
876
        assert(astribank != NULL);
805
 
        if((cmd = new_command(MPP_TWS_WD_MODE_GET, 0)) == NULL) {
 
877
        if((cmd = new_command(astribank->mpp_proto_version, MPP_TWS_WD_MODE_GET, 0)) == NULL) {
806
878
                ERR("new_command failed\n");
807
879
                return -ENOMEM;
808
880
        }
825
897
 
826
898
        DBG("%s\n", (yes) ? "YES" : "NO");
827
899
        assert(astribank != NULL);
828
 
        if((cmd = new_command(MPP_TWS_WD_MODE_SET, 0)) == NULL) {
 
900
        if((cmd = new_command(astribank->mpp_proto_version, MPP_TWS_WD_MODE_SET, 0)) == NULL) {
829
901
                ERR("new_command failed\n");
830
902
                return -ENOMEM;
831
903
        }
847
919
 
848
920
        DBG("\n");
849
921
        assert(astribank != NULL);
850
 
        if((cmd = new_command(MPP_TWS_PWR_GET, 0)) == NULL) {
 
922
        if((cmd = new_command(astribank->mpp_proto_version, MPP_TWS_PWR_GET, 0)) == NULL) {
851
923
                ERR("new_command failed\n");
852
924
                return -ENOMEM;
853
925
        }
870
942
 
871
943
        DBG("\n");
872
944
        assert(astribank != NULL);
873
 
        if((cmd = new_command(MPP_TWS_PORT_GET, 0)) == NULL) {
 
945
        if((cmd = new_command(astribank->mpp_proto_version, MPP_TWS_PORT_GET, 0)) == NULL) {
874
946
                ERR("new_command failed\n");
875
947
                return -ENOMEM;
876
948
        }
889
961
{
890
962
        struct mpp_command      *cmd;
891
963
        int                     ret;
892
 
        struct mpp_command      *reply;
893
964
 
894
965
        DBG("\n");
895
966
        assert(astribank != NULL);
897
968
                ERR("Invalid portnum (%d)\n", portnum);
898
969
                return -EINVAL;
899
970
        }
900
 
        if((cmd = new_command(MPP_TWS_PORT_SET, 0)) == NULL) {
 
971
        if((cmd = new_command(astribank->mpp_proto_version, MPP_TWS_PORT_SET, 0)) == NULL) {
901
972
                ERR("new_command failed\n");
902
973
                return -ENOMEM;
903
974
        }
904
975
        CMD_FIELD(cmd, TWS_PORT_SET, portnum) = portnum;
905
 
        ret = process_command(astribank, cmd, &reply);
 
976
        ret = process_command(astribank, cmd, NULL);
906
977
        if(ret < 0) {
907
978
                ERR("process_command failed: %d\n", ret);
908
979
                return ret;
909
980
        }
910
 
        free_command(reply);
911
981
        return 0;
912
982
}
913
983
 
981
1051
 
982
1052
void show_astribank_status(struct astribank_device *astribank, FILE *fp)
983
1053
{
984
 
        fprintf(fp, "Astribank: EEPROM      : %s\n", eeprom_type2str(astribank->eeprom_type));
 
1054
        char    version_buf[BUFSIZ];
 
1055
        int     is_loaded = STATUS_FPGA_LOADED(astribank->status);
 
1056
 
 
1057
        fprintf(fp, "Astribank: EEPROM      : %s\n",
 
1058
                eeprom_type2str(astribank->eeprom_type));
985
1059
        fprintf(fp, "Astribank: FPGA status : %s\n",
986
 
                STATUS_FPGA_LOADED(astribank->status) ? "Loaded" : "Empty");
 
1060
                is_loaded ? "Loaded" : "Empty");
 
1061
        if(is_loaded) {
 
1062
                memset(version_buf, 0, sizeof(version_buf));
 
1063
                memcpy(version_buf, astribank->fw_versions.fpga, VERSION_LEN);
 
1064
                fprintf(fp, "Astribank: FPGA version: %s\n",
 
1065
                        version_buf);
 
1066
        }
987
1067
}
988
1068
 
989
1069
void show_extrainfo(const struct extrainfo *extrainfo, FILE *fp)