OpenCores
URL https://opencores.org/ocsvn/w11/w11/trunk

Subversion Repositories w11

[/] [w11/] [tags/] [w11a_V0.61/] [tools/] [src/] [librlinktpp/] [RtclRlinkConnect.cpp] - Blame information for rev 10

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 10 wfjm 
// $Id: RtclRlinkConnect.cpp 375 2011-04-02 07:56:47Z mueller $
2 
//
3 
// Copyright 2011- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
4 
//
5 
// This program is free software; you may redistribute and/or modify it under
6 
// the terms of the GNU General Public License as published by the Free
7 
// Software Foundation, either version 2, or at your option any later version.
8 
//
9 
// This program is distributed in the hope that it will be useful, but
10 
// WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY
11 
// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 
// for complete details.
13 
//
14 
// Revision History:
15 
// Date         Rev Version  Comment
16 
// 2011-03-27   374   1.0    Initial version
17 
// 2011-02-11   360   0.1    First draft
18 
// ---------------------------------------------------------------------------
19 
 
20 
/*!
21 
  \file
22 
  \version $Id: RtclRlinkConnect.cpp 375 2011-04-02 07:56:47Z mueller $
23 
  \brief   Implemenation of class RtclRlinkConnect.
24 
 */
25 
 
26 
#include <ctype.h>
27 
 
28 
#include <stdexcept>
29 
#include <iostream>
30 
 
31 
#include "librtcltools/Rtcl.hpp"
32 
#include "librtcltools/RtclOPtr.hpp"
33 
#include "librtcltools/RtclNameSet.hpp"
34 
#include "librtcltools/RtclStats.hpp"
35 
#include "librtools/RmethDsc.hpp"
36 
#include "librtools/RosPrintf.hpp"
37 
#include "librlink/RlinkCommandList.hpp"
38 
#include "RtclRlinkConnect.hpp"
39 
 
40 
using namespace std;
41 
using namespace Retro;
42 
 
43 
/*!
44 
  \class Retro::RtclRlinkConnect
45 
  \brief FIXME_docs
46 
*/
47 
 
48 
//------------------------------------------+-----------------------------------
49 
//! Default constructor
50 
 
51 
RtclRlinkConnect::RtclRlinkConnect(Tcl_Interp* interp, const char* name)
52 
  : RtclProxyOwned<RlinkConnect>("RlinkConnect", interp, name,
53 
                                 new RlinkConnect()),
54 
    fErrCnt(0),
55 
    fLogFileName("-")
56 
{
57 
  typedef RmethDsc<RtclRlinkConnect, RtclArgs> mdsc_t;
58 
  AddMeth("open",     new mdsc_t(this, &RtclRlinkConnect::M_open));
59 
  AddMeth("close",    new mdsc_t(this, &RtclRlinkConnect::M_close));
60 
  AddMeth("exec",     new mdsc_t(this, &RtclRlinkConnect::M_exec));
61 
  AddMeth("amap",     new mdsc_t(this, &RtclRlinkConnect::M_amap));
62 
  AddMeth("errcnt",   new mdsc_t(this, &RtclRlinkConnect::M_errcnt));
63 
  AddMeth("wtlam",    new mdsc_t(this, &RtclRlinkConnect::M_wtlam));
64 
  AddMeth("oob",      new mdsc_t(this, &RtclRlinkConnect::M_oob));
65 
  AddMeth("stats",    new mdsc_t(this, &RtclRlinkConnect::M_stats));
66 
  AddMeth("log",      new mdsc_t(this, &RtclRlinkConnect::M_log));
67 
  AddMeth("print",    new mdsc_t(this, &RtclRlinkConnect::M_print));
68 
  AddMeth("dump",     new mdsc_t(this, &RtclRlinkConnect::M_dump));
69 
  AddMeth("config",   new mdsc_t(this, &RtclRlinkConnect::M_config));
70 
  AddMeth("$default", new mdsc_t(this, &RtclRlinkConnect::M_default));
71 
 
72 
  for (size_t i=0; i<8; i++) {
73 
    fCmdnameObj[i] = Tcl_NewStringObj(RlinkCommand::CommandName(i), -1);
74 
  }
75 
}
76 
 
77 
//------------------------------------------+-----------------------------------
78 
//! Destructor
79 
 
80 
RtclRlinkConnect::~RtclRlinkConnect()
81 
{}
82 
 
83 
//------------------------------------------+-----------------------------------
84 
//! FIXME_docs
85 
 
86 
int RtclRlinkConnect::M_open(RtclArgs& args)
87 
{
88 
  string path;
89 
 
90 
  if (!args.GetArg("?path", path)) return kERR;
91 
  if (!args.AllDone()) return kERR;
92 
 
93 
  RerrMsg emsg;
94 
  if (args.NOptMiss() == 0) {               // open path
95 
    if (!Obj().Open(path, emsg)) {
96 
      args.AppendResult(emsg.Message());
97 
      return kERR;
98 
    }
99 
  } else {                                  // open
100 
    string name = Obj().IsOpen() ? Obj().Port()->Url() : string();
101 
    args.SetResult(name);
102 
  }
103 
  return kOK;
104 
}
105 
 
106 
//------------------------------------------+-----------------------------------
107 
//! FIXME_docs
108 
 
109 
int RtclRlinkConnect::M_close(RtclArgs& args)
110 
{
111 
  if (!args.AllDone()) return kERR;
112 
 
113 
  if (!Obj().IsOpen()) {
114 
    args.AppendResult("-E: port not open", NULL);
115 
    return kERR;
116 
  }
117 
  Obj().Close();
118 
  return kOK;
119 
}
120 
 
121 
//------------------------------------------+-----------------------------------
122 
//! FIXME_docs
123 
 
124 
int RtclRlinkConnect::M_exec(RtclArgs& args)
125 
{
126 
  static RtclNameSet optset("-rreg|-rblk|-wreg|-wblk|-stat|-attn|-init|"
127 
                            "-edata|-estat|-estatdef|"
128 
                            "-volatile|-print|-dump|-rlist");
129 
 
130 
  Tcl_Interp* interp = args.Interp();
131 
 
132 
  RlinkCommandList clist;
133 
  string opt;
134 
  uint16_t addr;
135 
 
136 
  vector<string> vardata;
137 
  vector<string> varstat;
138 
  string varprint;
139 
  string vardump;
140 
  string varlist;
141 
 
142 
  uint8_t estatdef_val = 0x00;
143 
  uint8_t estatdef_msk = 0xff;
144 
 
145 
  while (args.NextOpt(opt, optset)) {
146 
 
147 
    size_t lsize = clist.Size();
148 
    if        (opt == "-rreg") {            // -rreg addr ?varData ?varStat ---
149 
      if (!GetAddr(args, Obj(), addr)) return kERR;
150 
      if (!GetVarName(args, "??varData", lsize, vardata)) return kERR;
151 
      if (!GetVarName(args, "??varStat", lsize, varstat)) return kERR;
152 
      clist.AddRreg(addr);
153 
 
154 
    } else if (opt == "-rblk") {            // -rblk addr size ?varData ?varStat
155 
      int32_t bsize;
156 
      if (!GetAddr(args, Obj(), addr)) return kERR;
157 
      if (!args.GetArg("bsize", bsize, 1, 256)) return kERR;
158 
      if (!GetVarName(args, "??varData", lsize, vardata)) return kERR;
159 
      if (!GetVarName(args, "??varStat", lsize, varstat)) return kERR;
160 
      clist.AddRblk(addr, (size_t) bsize);
161 
 
162 
    } else if (opt == "-wreg") {            // -wreg addr data ?varStat -------
163 
      uint16_t data;
164 
      if (!GetAddr(args, Obj(), addr)) return kERR;
165 
      if (!args.GetArg("data", data)) return kERR;
166 
      if (!GetVarName(args, "??varStat", lsize, varstat)) return kERR;
167 
      clist.AddWreg(addr, data);
168 
 
169 
    } else if (opt == "-wblk") {            // -wblk addr block ?varStat ------
170 
      vector<uint16_t> block;
171 
      if (!GetAddr(args, Obj(), addr)) return kERR;
172 
      if (!args.GetArg("data", block, 1, 256)) return kERR;
173 
      if (!GetVarName(args, "??varStat", lsize, varstat)) return kERR;
174 
      clist.AddWblk(addr, block);
175 
 
176 
    } else if (opt == "-stat") {            // -stat varData ?varStat ---------
177 
      if (!GetVarName(args, "??varData", lsize, vardata)) return kERR;
178 
      if (!GetVarName(args, "??varStat", lsize, varstat)) return kERR;
179 
      clist.AddStat();
180 
 
181 
    } else if (opt == "-attn") {            // -attn varData ?varStat ---------
182 
      if (!GetVarName(args, "??varData", lsize, vardata)) return kERR;
183 
      if (!GetVarName(args, "??varStat", lsize, varstat)) return kERR;
184 
      clist.AddAttn();
185 
 
186 
    } else if (opt == "-init") {            // -init addr data ?varStat -------
187 
      uint16_t data;
188 
      if (!GetAddr(args, Obj(), addr)) return kERR;
189 
      if (!args.GetArg("data", data)) return kERR;
190 
      if (!GetVarName(args, "??varStat", lsize, varstat)) return kERR;
191 
      clist.AddInit(addr, data);
192 
 
193 
    } else if (opt == "-edata") {           // -edata data ?mask --------------
194 
      if (!ClistNonEmpty(args, clist)) return kERR;
195 
      if (clist[lsize-1].Expect()==0) {
196 
        clist.LastExpect(new RlinkCommandExpect());
197 
      }
198 
      if (clist[lsize-1].Command() == RlinkCommand::kCmdRblk) {
199 
        vector<uint16_t> data;
200 
        vector<uint16_t> mask;
201 
        size_t bsize = clist[lsize-1].BlockSize();
202 
        if (!args.GetArg("data", data, 0, bsize)) return kERR;
203 
        if (!args.GetArg("??mask", mask, 0, bsize)) return kERR;
204 
        clist[lsize-1].Expect()->SetBlock(data, mask);
205 
      } else {
206 
        uint16_t data=0;
207 
        uint16_t mask=0;
208 
        if (!args.GetArg("data", data)) return kERR;
209 
        if (!args.GetArg("??mask", mask)) return kERR;
210 
        clist[lsize-1].Expect()->SetData(data, mask);
211 
      }
212 
 
213 
    } else if (opt == "-estat") {           // -estat ?stat ?mask -------------
214 
      if (!ClistNonEmpty(args, clist)) return kERR;
215 
      uint8_t stat=0;
216 
      uint8_t mask=0;
217 
      if (!args.GetArg("??stat", stat)) return kERR;
218 
      if (!args.GetArg("??mask", mask)) return kERR;
219 
      if (args.NOptMiss() == 2)  mask = 0xff;
220 
      if (clist[lsize-1].Expect()==0) {
221 
        clist.LastExpect(new RlinkCommandExpect());
222 
      }
223 
      clist[lsize-1].Expect()->SetStatus(stat, mask);
224 
 
225 
    } else if (opt == "-estatdef") {        // -estatdef ?stat ?mask -----------
226 
      uint8_t stat=0;
227 
      uint8_t mask=0;
228 
      if (!args.GetArg("??stat", stat)) return kERR;
229 
      if (!args.GetArg("??mask", mask)) return kERR;
230 
      if (args.NOptMiss() == 2)  mask = 0xff;
231 
      estatdef_val = stat;
232 
      estatdef_msk = mask;
233 
 
234 
    } else if (opt == "-volatile") {        // -volatile ----------------------
235 
      if (!ClistNonEmpty(args, clist)) return kERR;
236 
      clist.LastVolatile();
237 
 
238 
    } else if (opt == "-print") {           // -print ?varRes -----------------
239 
      varprint = "-";
240 
      if (!args.GetArg("??varRes", varprint)) return kERR;
241 
    } else if (opt == "-dump") {            // -dump ?varRes ------------------
242 
      vardump = "-";
243 
      if (!args.GetArg("??varRes", vardump)) return kERR;
244 
    } else if (opt == "-rlist") {           // -rlist ?varRes -----------------
245 
      varlist = "-";
246 
      if (!args.GetArg("??varRes", varlist)) return kERR;
247 
    }
248 
 
249 
    if (lsize != clist.Size()) {            // cmd added to clist (ind=lsize!)
250 
      if (estatdef_msk != 0xff) {             // estatdef defined
251 
        if (clist[lsize].Expect()==0) {
252 
          clist.LastExpect(new RlinkCommandExpect());
253 
        }
254 
        clist[lsize].Expect()->SetStatus(estatdef_val, estatdef_msk);
255 
      }
256 
    }
257 
  }
258 
 
259 
  int nact = 0;
260 
  if (varprint == "-") nact += 1;
261 
  if (vardump  == "-") nact += 1;
262 
  if (varlist  == "-") nact += 1;
263 
  if (nact > 1) {
264 
    args.AppendResult("-E: more that one of -print,-dump,-list without ",
265 
                      "target variable found", NULL);
266 
    return kERR;
267 
  }
268 
 
269 
  if (!args.AllDone()) return kERR;
270 
 
271 
  RerrMsg emsg;
272 
 
273 
  if (!Obj().Exec(clist, emsg)) {
274 
    args.AppendResult(emsg.Message());
275 
    return kERR;
276 
  }
277 
 
278 
  for (size_t icmd=0; icmd<clist.Size(); icmd++) {
279 
    RlinkCommand& cmd = clist[icmd];
280 
 
281 
    if (cmd.TestFlagAny(RlinkCommand::kFlagChkStat)) fErrCnt += 1;
282 
    if (cmd.TestFlagAny(RlinkCommand::kFlagChkData)) fErrCnt += 1;
283 
 
284 
    if (icmd<vardata.size() && !vardata[icmd].empty()) {
285 
      RtclOPtr pres;
286 
      vector<uint16_t> retstat;
287 
      RtclOPtr pele;
288 
      switch (cmd.Command()) {
289 
        case RlinkCommand::kCmdRreg:
290 
        case RlinkCommand::kCmdAttn:
291 
          pres = Tcl_NewIntObj((int)cmd.Data());
292 
          break;
293 
 
294 
        case RlinkCommand::kCmdRblk:
295 
          pres = Rtcl::NewListIntObj(cmd.Block());
296 
          break;
297 
 
298 
        case RlinkCommand::kCmdStat:
299 
          retstat.resize(2);
300 
          retstat[0] = cmd.StatRequest();
301 
          retstat[1] = cmd.Data();
302 
          pres = Rtcl::NewListIntObj(retstat);
303 
          break;
304 
      }
305 
      if(!Rtcl::SetVar(interp, vardata[icmd], pres)) return kERR;
306 
    }
307 
 
308 
    if (icmd<varstat.size() && !varstat[icmd].empty()) {
309 
      RtclOPtr pres = Tcl_NewIntObj((int)cmd.Status());
310 
      if (!Rtcl::SetVar(interp, varstat[icmd], pres)) return kERR;
311 
    }
312 
  }
313 
 
314 
  if (!varprint.empty()) {
315 
    ostringstream sos;
316 
    const RlinkConnect::LogOpts& logopts = Obj().GetLogOpts();
317 
    clist.Print(sos, &Obj().AddrMap(), logopts.baseaddr, logopts.basedata,
318 
                logopts.basestat);
319 
    RtclOPtr pobj = Rtcl::NewLinesObj(sos);
320 
    if (!Rtcl::SetVarOrResult(args.Interp(), varprint, pobj)) return kERR;
321 
  }
322 
 
323 
  if (!vardump.empty()) {
324 
    ostringstream sos;
325 
    clist.Dump(sos, 0);
326 
    RtclOPtr pobj = Rtcl::NewLinesObj(sos);
327 
    if (!Rtcl::SetVarOrResult(args.Interp(), vardump, pobj)) return kERR;
328 
  }
329 
 
330 
  if (!varlist.empty()) {
331 
    RtclOPtr prlist = Tcl_NewListObj(0, NULL);
332 
    for (size_t icmd=0; icmd<clist.Size(); icmd++) {
333 
      RlinkCommand& cmd(clist[icmd]);
334 
 
335 
      RtclOPtr pres = Tcl_NewListObj(0, NULL);
336 
      Tcl_ListObjAppendElement(NULL, pres, fCmdnameObj[cmd.Command()]);
337 
      Tcl_ListObjAppendElement(NULL, pres, Tcl_NewIntObj((int)cmd.Request()));
338 
      Tcl_ListObjAppendElement(NULL, pres, Tcl_NewIntObj((int)cmd.Flags()));
339 
      Tcl_ListObjAppendElement(NULL, pres, Tcl_NewIntObj((int)cmd.Status()));
340 
 
341 
      switch (cmd.Command()) {
342 
        case RlinkCommand::kCmdRreg:
343 
        case RlinkCommand::kCmdAttn:
344 
          Tcl_ListObjAppendElement(NULL, pres, Tcl_NewIntObj((int)cmd.Data()));
345 
          break;
346 
 
347 
        case RlinkCommand::kCmdRblk:
348 
          Tcl_ListObjAppendElement(NULL, pres,
349 
                                   Rtcl::NewListIntObj(cmd.Block()));
350 
          break;
351 
 
352 
        case RlinkCommand::kCmdStat:
353 
          Tcl_ListObjAppendElement(NULL, pres,
354 
                                   Tcl_NewIntObj((int)cmd.StatRequest()));
355 
          Tcl_ListObjAppendElement(NULL, pres, Tcl_NewIntObj((int)cmd.Data()));
356 
          break;
357 
      }
358 
      Tcl_ListObjAppendElement(NULL, prlist, pres);
359 
    }
360 
    if (!Rtcl::SetVarOrResult(args.Interp(), varlist, prlist)) return kERR;
361 
  }
362 
 
363 
  return kOK;
364 
}
365 
 
366 
//------------------------------------------+-----------------------------------
367 
//! FIXME_docs
368 
 
369 
int RtclRlinkConnect::M_amap(RtclArgs& args)
370 
{
371 
  static RtclNameSet optset("-name|-testname|-testaddr|-insert|-erase|"
372 
                            "-clear|-print");
373 
 
374 
  const RlinkAddrMap& addrmap = Obj().AddrMap();
375 
 
376 
  string opt;
377 
  string name;
378 
  uint16_t addr=0;
379 
 
380 
  if (args.NextOpt(opt, optset)) {
381 
    if        (opt == "-name") {            // amap -name addr
382 
      if (!args.GetArg("addr", addr, 0x00ff)) return kERR;
383 
      if (!args.AllDone()) return kERR;
384 
      string   tstname;
385 
      if(addrmap.Find(addr, tstname)) {
386 
        args.SetResult(tstname);
387 
      } else {
388 
        args.AppendResult("-E: address \"", args.PeekArgString(-1),
389 
                          "\" not mapped", NULL);
390 
        return kERR;
391 
      }
392 
 
393 
    } else if (opt == "-testname") {        // amap -testname name
394 
      if (!args.GetArg("name", name)) return kERR;
395 
      if (!args.AllDone()) return kERR;
396 
      uint16_t tstaddr;
397 
      args.SetResult(int(addrmap.Find(name, tstaddr)));
398 
 
399 
    } else if (opt == "-testaddr") {        // amap -testaddr addr
400 
      if (!args.GetArg("addr", addr, 0x00ff)) return kERR;
401 
      if (!args.AllDone()) return kERR;
402 
      string   tstname;
403 
      args.SetResult(int(addrmap.Find(addr, tstname)));
404 
 
405 
    } else if (opt == "-insert") {          // amap -insert name addr
406 
      uint16_t tstaddr;
407 
      string   tstname;
408 
      int      tstint;
409 
      if (!args.GetArg("name", name)) return kERR;
410 
      // enforce that the name is not a valid representation of an int
411 
      if (Tcl_GetIntFromObj(NULL, args[args.NDone()-1], &tstint) == kOK) {
412 
        args.AppendResult("-E: name should not look like an int but \"",
413 
                          name.c_str(), "\" does", NULL);
414 
        return kERR;
415 
      }
416 
      if (!args.GetArg("addr", addr, 0x00ff)) return kERR;
417 
      if (!args.AllDone()) return kERR;
418 
      if (addrmap.Find(name, tstaddr)) {
419 
        args.AppendResult("-E: mapping already defined for \"", name.c_str(),
420 
                          "\"", NULL);
421 
        return kERR;
422 
      }
423 
      if (addrmap.Find(addr, tstname)) {
424 
        args.AppendResult("-E: mapping already defined for address \"",
425 
                          args.PeekArgString(-1), "\"", NULL);
426 
        return kERR;
427 
      }
428 
      Obj().AddrMapInsert(name, addr);
429 
 
430 
    } else if (opt == "-erase") {           // amap -erase name
431 
      if (!args.GetArg("name", name)) return kERR;
432 
      if (!args.AllDone()) return kERR;
433 
      if (!Obj().AddrMapErase(name)) {
434 
        args.AppendResult("-E: no mapping defined for \"", name.c_str(),
435 
                          "\"", NULL);
436 
        return kERR;
437 
      }
438 
 
439 
    } else if (opt == "-clear") {           // amap -clear
440 
      if (!args.AllDone()) return kERR;
441 
      Obj().AddrMapClear();
442 
 
443 
    } else if (opt == "-print") {           // amap -print
444 
      if (!args.AllDone()) return kERR;
445 
      ostringstream sos;
446 
      addrmap.Print(sos);
447 
      args.AppendResultLines(sos);
448 
    }
449 
 
450 
  } else {
451 
    if (!args.OptValid()) return kERR;
452 
    if (!args.GetArg("?name", name)) return kERR;
453 
    if (args.NOptMiss()==0) {               // amap name
454 
      uint16_t tstaddr;
455 
      if(addrmap.Find(name, tstaddr)) {
456 
        args.SetResult(int(tstaddr));
457 
      } else {
458 
        args.AppendResult("-E: no mapping defined for \"", name.c_str(),
459 
                          "\"", NULL);
460 
        return kERR;
461 
      }
462 
 
463 
    } else {                                // amap
464 
      RtclOPtr plist = Tcl_NewListObj(0, NULL);
465 
      const RlinkAddrMap::amap_t amap = addrmap.Amap();
466 
      for (RlinkAddrMap::amap_cit_t it=amap.begin(); it!=amap.end(); it++) {
467 
        Tcl_Obj* tpair[2];
468 
        tpair[0] = Tcl_NewIntObj(it->first);
469 
        tpair[1] = Tcl_NewStringObj((it->second).c_str(),(it->second).length());
470 
        Tcl_ListObjAppendElement(NULL, plist, Tcl_NewListObj(2, tpair));
471 
      }
472 
      args.SetResult(plist);
473 
    }
474 
  }
475 
 
476 
  return kOK;
477 
}
478 
 
479 
//------------------------------------------+-----------------------------------
480 
//! FIXME_docs
481 
 
482 
int RtclRlinkConnect::M_errcnt(RtclArgs& args)
483 
{
484 
  static RtclNameSet optset("-clear");
485 
  string opt;
486 
  bool fclear = false;
487 
 
488 
  while (args.NextOpt(opt, optset)) {
489 
    if (opt == "-clear") fclear = true;
490 
  }
491 
  if (!args.AllDone()) return kERR;
492 
 
493 
  args.SetResult(int(fErrCnt));
494 
  if (fclear) fErrCnt = 0;
495 
 
496 
  return kOK;
497 
}
498 
 
499 
//------------------------------------------+-----------------------------------
500 
//! FIXME_docs
501 
 
502 
int RtclRlinkConnect::M_wtlam(RtclArgs& args)
503 
{
504 
  double tout;
505 
  if (!args.GetArg("tout", tout, 0.001)) return kERR;
506 
  if (!args.AllDone()) return kERR;
507 
 
508 
  RerrMsg emsg;
509 
  double twait = Obj().WaitAttn(tout, emsg);
510 
 
511 
  if (twait == -2.) {
512 
    args.AppendResult(emsg.Message());
513 
    return kERR;
514 
  } else if (twait == -1.) {
515 
    if (Obj().GetLogOpts().printlevel >= 2) {
516 
      Obj().LogFile()() << "-- wtlam to=" << RosPrintf(tout, "f", 0,3)
517 
                        << " FAIL timeout" << endl;
518 
      fErrCnt += 1;
519 
      args.SetResult(tout);
520 
      return kOK;
521 
    }
522 
  }
523 
 
524 
  if (Obj().GetLogOpts().printlevel >= 1) {
525 
    Obj().LogFile()() << "-- wtlam to=" << RosPrintf(tout, "f", 0,3)
526 
                      << "  T=" << RosPrintf(twait, "f", 0,3)
527 
                      << "  OK" << endl;
528 
  }
529 
 
530 
  args.SetResult(twait);
531 
  return kOK;
532 
}
533 
 
534 
//------------------------------------------+-----------------------------------
535 
//! FIXME_docs
536 
 
537 
int RtclRlinkConnect::M_oob(RtclArgs& args)
538 
{
539 
  static RtclNameSet optset("-rlmon|-rbmon|-sbcntl|-sbdata");
540 
 
541 
  string opt;
542 
  uint16_t addr;
543 
  uint16_t data;
544 
  RerrMsg emsg;
545 
 
546 
  if (args.NextOpt(opt, optset)) {
547 
    if        (opt == "-rlmon") {           // oob -rlmon (0|1)
548 
      if (!args.GetArg("val", data, 1)) return kERR;
549 
      if (!args.AllDone()) return kERR;
550 
      addr = 15;                              // rlmon on bit 15
551 
      if (!Obj().SndOob(0x00, (addr<<8)+data, emsg)) {
552 
        args.AppendResult(emsg.Message());
553 
        return kERR;
554 
      }
555 
 
556 
    } else if (opt == "-rbmon") {           // oob -rbmon (0|1)
557 
      if (!args.GetArg("val", data, 1)) return kERR;
558 
      if (!args.AllDone()) return kERR;
559 
      addr = 14;                              // rbmon on bit 14
560 
      if (!Obj().SndOob(0x00, (addr<<8)+data, emsg)) {
561 
        args.AppendResult(emsg.Message());
562 
        return kERR;
563 
      }
564 
 
565 
    } else if (opt == "-sbcntl") {          // oob -sbcntl bit (0|1)
566 
      if (!args.GetArg("bit", addr, 15)) return kERR;
567 
      if (!args.GetArg("val", data,  1)) return kERR;
568 
      if (!args.AllDone()) return kERR;
569 
      if (!Obj().SndOob(0x00, (addr<<8)+data, emsg)) {
570 
        args.AppendResult(emsg.Message());
571 
        return kERR;
572 
      }
573 
 
574 
    } else if (opt == "-sbdata") {          // oob -sbdata addr val
575 
      if (!args.GetArg("bit", addr, 0x0ff)) return kERR;
576 
      if (!args.GetArg("val", data)) return kERR;
577 
      if (!args.AllDone()) return kERR;
578 
      if (!Obj().SndOob(addr, data, emsg)) {
579 
        args.AppendResult(emsg.Message());
580 
        return kERR;
581 
      }
582 
    }
583 
  } else {
584 
     args.AppendResult("-E: missing option, one of "
585 
                       "-rlmon,-rbmon,-sbcntl,-sbdata",
586 
                       NULL);
587 
     return kERR;
588 
  }
589 
 
590 
  return kOK;
591 
}
592 
 
593 
//------------------------------------------+-----------------------------------
594 
//! FIXME_docs
595 
 
596 
int RtclRlinkConnect::M_stats(RtclArgs& args)
597 
{
598 
  RtclStats::Context cntx;
599 
  if (!RtclStats::GetArgs(args, cntx)) return kERR;
600 
  if (!RtclStats::Exec(args, cntx, Obj().Stats())) return kERR;
601 
  if (Obj().Port()) {
602 
    if (!RtclStats::Exec(args, cntx, Obj().Port()->Stats())) return kERR;
603 
  }
604 
  return kOK;
605 
}
606 
 
607 
//------------------------------------------+-----------------------------------
608 
//! FIXME_docs
609 
 
610 
int RtclRlinkConnect::M_log(RtclArgs& args)
611 
{
612 
  string msg;
613 
  if (!args.GetArg("msg", msg)) return kERR;
614 
  if (!args.AllDone()) return kERR;
615 
  if (Obj().GetLogOpts().printlevel != 0 ||
616 
      Obj().GetLogOpts().dumplevel  != 0 ||
617 
      Obj().GetLogOpts().tracelevel != 0) {
618 
    Obj().LogFile()() << "# " << msg << endl;
619 
  }
620 
  return kOK;
621 
}
622 
 
623 
//------------------------------------------+-----------------------------------
624 
//! FIXME_docs
625 
 
626 
int RtclRlinkConnect::M_print(RtclArgs& args)
627 
{
628 
  if (!args.AllDone()) return kERR;
629 
 
630 
  ostringstream sos;
631 
  Obj().Print(sos);
632 
  args.SetResult(sos);
633 
  return kOK;
634 
}
635 
 
636 
//------------------------------------------+-----------------------------------
637 
//! FIXME_docs
638 
 
639 
int RtclRlinkConnect::M_dump(RtclArgs& args)
640 
{
641 
  if (!args.AllDone()) return kERR;
642 
 
643 
  ostringstream sos;
644 
  Obj().Dump(sos, 0);
645 
  args.SetResult(sos);
646 
  return kOK;
647 
}
648 
 
649 
//------------------------------------------+-----------------------------------
650 
//! FIXME_docs
651 
 
652 
int RtclRlinkConnect::M_config(RtclArgs& args)
653 
{
654 
  static RtclNameSet optset("-baseaddr|-basedata|-basestat|"
655 
                            "-logfile|-logprintlevel|-logdumplevel|"
656 
                            "-logtracelevel");
657 
 
658 
  RlinkConnect::LogOpts logopts = Obj().GetLogOpts();
659 
 
660 
  if (args.NDone() == (size_t)args.Objc()) {
661 
    ostringstream sos;
662 
    sos << "-baseaddr " << RosPrintf(logopts.baseaddr, "d")
663 
        << " -basedata " << RosPrintf(logopts.basedata, "d")
664 
        << " -basestat " << RosPrintf(logopts.basestat, "d")
665 
        << " -logfile {" << fLogFileName << "}"
666 
        << " -logprintlevel " << RosPrintf(logopts.printlevel, "d")
667 
        << " -logdumplevel " << RosPrintf(logopts.dumplevel, "d")
668 
        << " -logtracelevel " << RosPrintf(logopts.tracelevel, "d");
669 
    args.AppendResult(sos);
670 
    return kOK;
671 
  }
672 
 
673 
  string opt;
674 
  while (args.NextOpt(opt, optset)) {
675 
    if        (opt == "-baseaddr") {        // -baseaddr ?base -----------------
676 
      if (!ConfigBase(args, logopts.baseaddr)) return kERR;
677 
      if (args.NOptMiss() == 0) Obj().SetLogOpts(logopts);
678 
 
679 
    } else if (opt == "-basedata") {        // -basedata ?base -----------------
680 
      if (!ConfigBase(args, logopts.basedata)) return kERR;
681 
      if (args.NOptMiss() == 0) Obj().SetLogOpts(logopts);
682 
 
683 
    } else if (opt == "-basestat") {        // -basestat ?base -----------------
684 
      if (!ConfigBase(args, logopts.basestat)) return kERR;
685 
      if (args.NOptMiss() == 0) Obj().SetLogOpts(logopts);
686 
 
687 
    } else if (opt == "-logfile") {         // -logfile ?name ------------------
688 
      if (!args.Config("??name", fLogFileName)) return false;
689 
      if (args.NOptMiss() == 0) {             // new filename ?
690 
        if (fLogFileName == "-") {
691 
          Obj().LogUseStream(&cout);
692 
        } else {
693 
          if (!Obj().LogOpen(fLogFileName)) {
694 
            args.AppendResult("-E: open failed for \"",
695 
                              fLogFileName.c_str(), "\", using stdout", NULL);
696 
            Obj().LogUseStream(&cout);
697 
            fLogFileName = "-";
698 
            return kERR;
699 
          }
700 
        }
701 
      }
702 
 
703 
    } else if (opt == "-logprintlevel") {   // -logprintlevel ?loglevel --------
704 
      if (!args.Config("??loglevel", logopts.printlevel, 3)) return false;
705 
      if (args.NOptMiss() == 0) Obj().SetLogOpts(logopts);
706 
 
707 
    } else if (opt == "-logdumplevel") {    // -logdumplevel ?loglevel ---------
708 
      if (!args.Config("??loglevel", logopts.dumplevel, 3)) return false;
709 
      if (args.NOptMiss() == 0) Obj().SetLogOpts(logopts);
710 
 
711 
    } else if (opt == "-logtracelevel") {   // -logtracelevel ?loglevel --------
712 
      if (!args.Config("??loglevel", logopts.tracelevel, 3)) return false;
713 
      if (args.NOptMiss() == 0) Obj().SetLogOpts(logopts);
714 
    }
715 
  }
716 
 
717 
  if (!args.AllDone()) return kERR;
718 
  return kOK;
719 
}
720 
 
721 
//------------------------------------------+-----------------------------------
722 
//! FIXME_docs
723 
 
724 
int RtclRlinkConnect::M_default(RtclArgs& args)
725 
{
726 
  if (!args.AllDone()) return kERR;
727 
  ostringstream sos;
728 
  const RlinkConnect::LogOpts& logopts = Obj().GetLogOpts();
729 
 
730 
  sos << "print base:  " << "addr " << RosPrintf(logopts.baseaddr, "d", 2)
731 
      << "  data " << RosPrintf(logopts.basedata, "d", 2)
732 
      << "  stat " << RosPrintf(logopts.basestat, "d", 2) << endl;
733 
  sos << "logfile:     " << fLogFileName
734 
      << "   printlevel " << logopts.printlevel
735 
      << "   dumplevel " << logopts.dumplevel;
736 
 
737 
  args.AppendResultLines(sos);
738 
  return kOK;
739 
}
740 
 
741 
//------------------------------------------+-----------------------------------
742 
//! FIXME_docs
743 
 
744 
bool RtclRlinkConnect::GetAddr(RtclArgs& args, RlinkConnect& conn,
745 
                               uint16_t& addr)
746 
{
747 
  Tcl_Obj* pobj=0;
748 
  if (!args.GetArg("addr", pobj)) return kERR;
749 
 
750 
  int tstint;
751 
  // if a number is given..
752 
  if (Tcl_GetIntFromObj(NULL, pobj, &tstint) == kOK) {
753 
    if (tstint >= 0 && tstint <= 0x00ff) {
754 
      addr = (uint16_t)tstint;
755 
    } else {
756 
      args.AppendResult("-E: value \"", Tcl_GetString(pobj),
757 
                        "\" for \"addr\" out of range 0...0x00ff", NULL);
758 
      return false;
759 
    }
760 
  // if a name is given
761 
  } else {
762 
    string name(Tcl_GetString(pobj));
763 
    uint16_t tstaddr;
764 
    if (Obj().AddrMap().Find(name, tstaddr)) {
765 
      addr = tstaddr;
766 
    } else {
767 
      args.AppendResult("-E: no address mapping known for \"",
768 
                        Tcl_GetString(pobj), "\"", NULL);
769 
      return false;
770 
    }
771 
  }
772 
 
773 
  return true;
774 
}
775 
 
776 
//------------------------------------------+-----------------------------------
777 
//! FIXME_docs
778 
 
779 
bool RtclRlinkConnect::GetVarName(RtclArgs& args, const char* argname,
780 
                                  size_t nind,
781 
                                  std::vector<std::string>& varname)
782 
{
783 
  while (varname.size() < nind+1) varname.push_back(string());
784 
  string name;
785 
  if (!args.GetArg(argname, name)) return false;
786 
  if (name.length()) {                      // if variable defined
787 
    char c = name[0];
788 
    if (isdigit(c) || c=='+' || c=='-' ) {  // check for mistaken number
789 
      args.AppendResult("-E: invalid variable name \"", name.c_str(),
790 
                        "\": looks like a number", NULL);
791 
      return false;
792 
    }
793 
  }
794 
 
795 
  varname[nind] = name;
796 
  return true;
797 
}
798 
 
799 
//------------------------------------------+-----------------------------------
800 
//! FIXME_docs
801 
 
802 
bool RtclRlinkConnect::ConfigBase(RtclArgs& args, size_t& base)
803 
{
804 
  size_t tmp = base;
805 
  if (!args.Config("??base", tmp, 16, 2)) return false;
806 
  if (tmp != base && tmp != 2 && tmp !=8 && tmp != 16) {
807 
    args.AppendResult("-E: base must be 2, 8, or 16, found \"",
808 
                      args.PeekArgString(-1), "\"", NULL);
809 
  }
810 
  base = tmp;
811 
  return true;
812 
}
813 
 
814 
 
815 
//------------------------------------------+-----------------------------------
816 
//! FIXME_docs
817 
 
818 
bool RtclRlinkConnect::ClistNonEmpty(RtclArgs& args,
819 
                                     const RlinkCommandList& clist)
820 
{
821 
  if (clist.Size() == 0) {
822 
    args.AppendResult("-E: -volatile not allowed on empty command list", NULL);
823 
    return false;
824 
  }
825 
  return true;
826 
}
827 
 
828 
//------------------------------------------+-----------------------------------
829 
#if (defined(Retro_NoInline) || defined(Retro_RtclRlinkConnect_NoInline))
830 
#define inline
831 
//#include "RtclRlinkConnect.ipp"
832 
#undef  inline
833 
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.