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 15

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

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

powered by: WebSVN 2.1.0

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