usr.sbin/sicontrol/sicontrol.c

   1 /*
   2  * Device driver for Specialix range (SLXOS) of serial line multiplexors.
   3  *      SLXOS configuration and debug interface
   4  *
   5  * Copyright (C) 1990, 1992 Specialix International,
   6  * Copyright (C) 1993, Andy Rutter <andy@acronym.co.uk>
   7  * Copyright (C) 1995, Peter Wemm <peter@haywire.dialix.com>
   8  *
   9  * Derived from:        SunOS 4.x version
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notices, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notices, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *      This product includes software developed by Andy Rutter of
  22  *      Advanced Methods and Tools Ltd. based on original information
  23  *      from Specialix International.
  24  * 4. Neither the name of Advanced Methods and Tools, nor Specialix
  25  *    International may be used to endorse or promote products derived from
  26  *    this software without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY ``AS IS'' AND ANY EXPRESS OR IMPLIED
  29  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  30  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
  31  * NO EVENT SHALL THE AUTHORS BE LIABLE.
  32  *
  33  * $FreeBSD: src/usr.sbin/sicontrol/sicontrol.c,v 1.12.2.1 2000/12/11 01:03:39 obrien Exp $
  34  */
  35
  36 #define _KERNEL_STRUCTURES
  37
  38 #include <sys/types.h>
  39 #include <sys/param.h>
  40 #include <sys/stat.h>
  41 #include <sys/ioctl.h>
  42 #include <sys/tty.h>
  43
  44 #include <dev/serial/si/si.h>
  45
  46 #include <ctype.h>
  47 #include <err.h>
  48 #include <fcntl.h>
  49 #include <paths.h>
  50 #include <stdio.h>
  51 #include <stdlib.h>
  52 #include <string.h>
  53
  54 #define U_DEBUG         0
  55 #define U_TXINT         1
  56 #define U_RXINT         2
  57 #define U_NPORT         3
  58 #define U_MSTATE        4
  59 #define U_STAT_CCB      5
  60 #define U_STAT_TTY      6
  61 #define U_MAX           7
  62 #define U_ALL           -1
  63
  64 static void     ccb_stat(int, char **);
  65 static void     debug(int, char **);
  66 static void     dostat(void);
  67 static int      getnum(char *);
  68 static int      islevel(char *);
  69 static int      lvls2bits(char *);
  70 static void     mstate(int, char **);
  71 static void     nport(int, char **);
  72 static int      opencontrol(void);
  73 static void     prlevels(int);
  74 static void     prusage(int, int) __dead2;
  75 static void     rxint(int, char **);
  76 static void     tty_stat(int, char **);
  77 static void     txint(int, char **);
  78
  79 static struct lv {
  80         const char *lv_name;
  81         int     lv_bit;
  82 } lv[] = {
  83         {"entry",       DBG_ENTRY},
  84         {"open",        DBG_OPEN},
  85         {"close",       DBG_CLOSE},
  86         {"read",        DBG_READ},
  87         {"write",       DBG_WRITE},
  88         {"param",       DBG_PARAM},
  89         {"modem",       DBG_MODEM},
  90         {"select",      DBG_SELECT},
  91         {"optim",       DBG_OPTIM},
  92         {"intr",        DBG_INTR},
  93         {"start",       DBG_START},
  94         {"lstart",      DBG_LSTART},
  95         {"ioctl",       DBG_IOCTL},
  96         {"fail",        DBG_FAIL},
  97         {"autoboot",    DBG_AUTOBOOT},
  98         {"download",    DBG_DOWNLOAD},
  99         {"drain",       DBG_DRAIN},
 100         {"poll",        DBG_POLL},
 101         {0,             0}
 102 };
 103
 104 static struct opt {
 105         const char *o_name;
 106         void    (*o_func)(int, char **);
 107 } opt[] = {
 108         {"debug",               debug},
 109         {"rxint_throttle",      rxint},
 110         {"int_throttle",        txint},
 111         {"nport",               nport},
 112         {"mstate",              mstate},
 113         {"ccbstat",             ccb_stat},
 114         {"ttystat",             tty_stat},
 115         {0,                     0}
 116 };
 117
 118 static struct stat_list {
 119         void (*st_func)(int, char **);
 120 } stat_list[] = {
 121         {mstate},
 122         {0}
 123 };
 124
 125 static const char *usagestr[] = {
 126         "debug [[add|del|set debug_levels] | [off]]\n",
 127         "int_throttle [newvalue]\n",
 128         "rxint_throttle [newvalue]\n",
 129         "nport\n",
 130         "mstate\n",
 131         "ccbstat\n",
 132         "ttystat\n",
 133         0
 134 };
 135
 136 static int alldev = 0;
 137 static int ctlfd;
 138 static char *Devname;
 139 static struct si_tcsi tc;
 140
 141 int
 142 main(int argc, char **argv)
 143 {
 144         struct opt *op;
 145         void (*func)(int, char **) = NULL;
 146
 147         if (argc < 2)
 148                 prusage(U_ALL, 1);
 149         Devname = argv[1];
 150         if (strcmp(Devname, "-") == 0) {
 151                 alldev = 1;
 152         } else {
 153                 sidev_t dev;
 154                 struct stat st;
 155
 156                 if (strchr(Devname, '/') == NULL) {
 157                         char *acp = malloc(6 + strlen(Devname));
 158                         strcpy(acp, _PATH_DEV);
 159                         strcat(acp, Devname);
 160                         Devname = acp;
 161                 }
 162                 if (stat(Devname, &st) < 0)
 163                         errx(1, "can't stat %s", Devname);
 164                 dev.sid_card = SI_CARD(minor(st.st_rdev));
 165                 dev.sid_port = SI_PORT(minor(st.st_rdev));
 166                 dev.sid_control = 0;
 167                 tc.tc_dev = dev;
 168         }
 169         ctlfd = opencontrol();
 170         if (argc == 2) {
 171                 dostat();
 172                 exit(0);
 173         }
 174
 175         argc--; argv++;
 176         for (op = opt; op->o_name; op++) {
 177                 if (strcmp(argv[1], op->o_name) == 0) {
 178                         func = op->o_func;
 179                         break;
 180                 }
 181         }
 182         if (func == NULL)
 183                 prusage(U_ALL, 1);
 184
 185         argc -= 2;
 186         argv += 2;
 187         (*func)(argc, argv);
 188         exit(0);
 189 }
 190
 191 int
 192 opencontrol(void)
 193 {
 194         int fd;
 195
 196         fd = open(CONTROLDEV, O_RDWR|O_NDELAY);
 197         if (fd < 0)
 198                 err(1, "open on %s", CONTROLDEV);
 199         return(fd);
 200 }
 201
 202 /*
 203  * Print a usage message - this relies on U_DEBUG==0 and U_BOOT==1.
 204  * Don't print the DEBUG usage string unless explicity requested.
 205  */
 206 void
 207 prusage(int strn, int eflag)
 208 {
 209         const char **cp;
 210
 211         if (strn == U_ALL) {
 212                 fprintf(stderr, "usage: sicontrol %s", usagestr[1]);
 213                 fprintf(stderr, "       sicontrol %s", usagestr[2]);
 214                 fprintf(stderr, "       sicontrol %s", usagestr[3]);
 215                 fprintf(stderr, "       sicontrol devname %s", usagestr[4]);
 216                 for (cp = &usagestr[5]; *cp; cp++)
 217                         fprintf(stderr, "       sicontrol devname %s", *cp);
 218         }
 219         else if (strn >= 0 && strn <= U_MAX)
 220                 fprintf(stderr, "usage: sicontrol devname %s", usagestr[strn]);
 221         else
 222                 fprintf(stderr, "sicontrol: usage ???\n");
 223         exit(eflag);
 224 }
 225
 226 /* print port status */
 227 void
 228 dostat(void)
 229 {
 230         char *av[1], *acp;
 231         struct stat_list *stp;
 232         struct si_tcsi stc;
 233         int donefirst = 0;
 234
 235         printf("%s: ", alldev ? "ALL" : Devname);
 236         acp = malloc(strlen(Devname) + 3);
 237         memset(acp, ' ', strlen(Devname));
 238         strcat(acp, "  ");
 239         stc = tc;
 240         for (stp = stat_list; stp->st_func != NULL; stp++) {
 241                 if (donefirst)
 242                         fputs(acp, stdout);
 243                 else
 244                         donefirst++;
 245                 av[0] = NULL;
 246                 tc = stc;
 247                 (*stp->st_func)(-1, av);
 248         }
 249 }
 250
 251 /*
 252  * debug
 253  * debug [[set|add|del debug_lvls] | [off]]
 254  */
 255 void
 256 debug(int ac, char **av)
 257 {
 258         int level;
 259
 260         if (ac > 2)
 261                 prusage(U_DEBUG, 1);
 262         if (alldev) {
 263                 if (ioctl(ctlfd, TCSIGDBG_ALL, &tc.tc_dbglvl) < 0)
 264                         err(1, "TCSIGDBG_ALL on %s", Devname);
 265         } else {
 266                 if (ioctl(ctlfd, TCSIGDBG_LEVEL, &tc) < 0)
 267                         err(1, "TCSIGDBG_LEVEL on %s", Devname);
 268         }
 269
 270         switch (ac) {
 271         case 0:
 272                 printf("%s: debug levels - ", Devname);
 273                 prlevels(tc.tc_dbglvl);
 274                 return;
 275         case 1:
 276                 if (strcmp(av[0], "off") == 0) {
 277                         tc.tc_dbglvl = 0;
 278                         break;
 279                 }
 280                 prusage(U_DEBUG, 1);
 281                 /* no return */
 282         case 2:
 283                 level = lvls2bits(av[1]);
 284                 if (strcmp(av[0], "add") == 0)
 285                         tc.tc_dbglvl |= level;
 286                 else if (strcmp(av[0], "del") == 0)
 287                         tc.tc_dbglvl &= ~level;
 288                 else if (strcmp(av[0], "set") == 0)
 289                         tc.tc_dbglvl = level;
 290                 else
 291                         prusage(U_DEBUG, 1);
 292         }
 293         if (alldev) {
 294                 if (ioctl(ctlfd, TCSISDBG_ALL, &tc.tc_dbglvl) < 0)
 295                         err(1, "TCSISDBG_ALL on %s", Devname);
 296         } else {
 297                 if (ioctl(ctlfd, TCSISDBG_LEVEL, &tc) < 0)
 298                         err(1, "TCSISDBG_LEVEL on %s", Devname);
 299         }
 300 }
 301
 302 void
 303 rxint(int ac, char **av)
 304 {
 305         tc.tc_port = 0;
 306         switch (ac) {
 307         case 0:
 308                 printf("%s: ", Devname);
 309                 /* FALLTHROUGH */
 310         case -1:
 311                 if (ioctl(ctlfd, TCSIGRXIT, &tc) < 0)
 312                         err(1, "TCSIGRXIT");
 313                 printf("RX interrupt throttle: %d msec\n", tc.tc_int*10);
 314                 break;
 315         case 1:
 316                 tc.tc_int = getnum(av[0]) / 10;
 317                 if (tc.tc_int == 0)
 318                         tc.tc_int = 1;
 319                 if (ioctl(ctlfd, TCSIRXIT, &tc) < 0)
 320                         err(1, "TCSIRXIT on %s at %d msec",
 321                                 Devname, tc.tc_int*10);
 322                 break;
 323         default:
 324                 prusage(U_RXINT, 1);
 325         }
 326 }
 327
 328 void
 329 txint(int ac, char **av)
 330 {
 331
 332         tc.tc_port = 0;
 333         switch (ac) {
 334         case 0:
 335                 printf("%s: ", Devname);
 336                 /* FALLTHROUGH */
 337         case -1:
 338                 if (ioctl(ctlfd, TCSIGIT, &tc) < 0)
 339                         err(1, "TCSIGIT");
 340                 printf("aggregate interrupt throttle: %d\n", tc.tc_int);
 341                 break;
 342         case 1:
 343                 tc.tc_int = getnum(av[0]);
 344                 if (ioctl(ctlfd, TCSIIT, &tc) < 0)
 345                         err(1, "TCSIIT on %s at %d", Devname, tc.tc_int);
 346                 break;
 347         default:
 348                 prusage(U_TXINT, 1);
 349         }
 350 }
 351
 352 void
 353 mstate(int ac, char **av __unused)
 354 {
 355         switch (ac) {
 356         case 0:
 357                 printf("%s: ", Devname);
 358                 /* FALLTHROUGH */
 359         case -1:
 360                 break;
 361         default:
 362                 prusage(U_MSTATE, 1);
 363         }
 364         if (ioctl(ctlfd, TCSISTATE, &tc) < 0)
 365                 err(1, "TCSISTATE on %s", Devname);
 366         printf("modem bits state - (0x%x)", tc.tc_int);
 367         if (tc.tc_int & IP_DCD) printf(" DCD");
 368         if (tc.tc_int & IP_DTR) printf(" DTR");
 369         if (tc.tc_int & IP_RTS) printf(" RTS");
 370         printf("\n");
 371 }
 372
 373 void
 374 nport(int ac, char **av __unused)
 375 {
 376         int ports;
 377
 378         if (ac != 0)
 379                 prusage(U_NPORT, 1);
 380         if (ioctl(ctlfd, TCSIPORTS, &ports) < 0)
 381                 err(1, "TCSIPORTS on %s", Devname);
 382         printf("SLXOS: total of %d ports\n", ports);
 383 }
 384
 385 void
 386 ccb_stat(int ac, char **av __unused)
 387 {
 388         struct si_pstat sip;
 389 #define CCB     sip.tc_ccb
 390
 391         if (ac != 0)
 392                 prusage(U_STAT_CCB, 1);
 393         sip.tc_dev = tc.tc_dev;
 394         if (ioctl(ctlfd, TCSI_CCB, &sip) < 0)
 395                 err(1, "TCSI_CCB on %s", Devname);
 396         printf("%s: ", Devname);
 397
 398                                                         /* WORD next - Next Channel */
 399                                                         /* WORD addr_uart - Uart address */
 400                                                         /* WORD module - address of module struct */
 401         printf("\tuart_type 0x%x\n", CCB.type);         /* BYTE type - Uart type */
 402                                                         /* BYTE fill - */
 403         printf("\tx_status 0x%x\n", CCB.x_status);      /* BYTE x_status - XON / XOFF status */
 404         printf("\tc_status 0x%x\n", CCB.c_status);      /* BYTE c_status - cooking status */
 405         printf("\thi_rxipos 0x%x\n", CCB.hi_rxipos);    /* BYTE hi_rxipos - stuff into rx buff */
 406         printf("\thi_rxopos 0x%x\n", CCB.hi_rxopos);    /* BYTE hi_rxopos - stuff out of rx buffer */
 407         printf("\thi_txopos 0x%x\n", CCB.hi_txopos);    /* BYTE hi_txopos - Stuff into tx ptr */
 408         printf("\thi_txipos 0x%x\n", CCB.hi_txipos);    /* BYTE hi_txipos - ditto out */
 409         printf("\thi_stat 0x%x\n", CCB.hi_stat);                /* BYTE hi_stat - Command register */
 410         printf("\tdsr_bit 0x%x\n", CCB.dsr_bit);                /* BYTE dsr_bit - Magic bit for DSR */
 411         printf("\ttxon 0x%x\n", CCB.txon);              /* BYTE txon - TX XON char */
 412         printf("\ttxoff 0x%x\n", CCB.txoff);            /* BYTE txoff - ditto XOFF */
 413         printf("\trxon 0x%x\n", CCB.rxon);              /* BYTE rxon - RX XON char */
 414         printf("\trxoff 0x%x\n", CCB.rxoff);            /* BYTE rxoff - ditto XOFF */
 415         printf("\thi_mr1 0x%x\n", CCB.hi_mr1);          /* BYTE hi_mr1 - mode 1 image */
 416         printf("\thi_mr2 0x%x\n", CCB.hi_mr2);          /* BYTE hi_mr2 - mode 2 image */
 417         printf("\thi_csr 0x%x\n", CCB.hi_csr);          /* BYTE hi_csr - clock register */
 418         printf("\thi_op 0x%x\n", CCB.hi_op);            /* BYTE hi_op - Op control */
 419         printf("\thi_ip 0x%x\n", CCB.hi_ip);            /* BYTE hi_ip - Input pins */
 420         printf("\thi_state 0x%x\n", CCB.hi_state);      /* BYTE hi_state - status */
 421         printf("\thi_prtcl 0x%x\n", CCB.hi_prtcl);      /* BYTE hi_prtcl - Protocol */
 422         printf("\thi_txon 0x%x\n", CCB.hi_txon);                /* BYTE hi_txon - host copy tx xon stuff */
 423         printf("\thi_txoff 0x%x\n", CCB.hi_txoff);      /* BYTE hi_txoff - */
 424         printf("\thi_rxon 0x%x\n", CCB.hi_rxon);                /* BYTE hi_rxon - */
 425         printf("\thi_rxoff 0x%x\n", CCB.hi_rxoff);      /* BYTE hi_rxoff - */
 426         printf("\tclose_prev 0x%x\n", CCB.close_prev);  /* BYTE close_prev - Was channel previously closed */
 427         printf("\thi_break 0x%x\n", CCB.hi_break);      /* BYTE hi_break - host copy break process */
 428         printf("\tbreak_state 0x%x\n", CCB.break_state);        /* BYTE break_state - local copy ditto */
 429         printf("\thi_mask 0x%x\n", CCB.hi_mask);                /* BYTE hi_mask - Mask for CS7 etc. */
 430         printf("\tmask_z280 0x%x\n", CCB.mask_z280);    /* BYTE mask_z280 - Z280's copy */
 431                                                         /* BYTE res[0x60 - 36] - */
 432                                                         /* BYTE hi_txbuf[SLXOS_BUFFERSIZE] - */
 433                                                         /* BYTE hi_rxbuf[SLXOS_BUFFERSIZE] - */
 434                                                         /* BYTE res1[0xA0] - */
 435 }
 436
 437 void
 438 tty_stat(int ac, char **av __unused)
 439 {
 440         struct si_pstat sip;
 441 #define TTY     sip.tc_tty
 442
 443         if (ac != 0)
 444                 prusage(U_STAT_TTY, 1);
 445         sip.tc_dev = tc.tc_dev;
 446         if (ioctl(ctlfd, TCSI_TTY, &sip) < 0)
 447                 err(1, "TCSI_TTY on %s", Devname);
 448         printf("%s: ", Devname);
 449
 450         printf("\tt_outq.c_cc %d.\n", TTY.t_outq.c_cc); /* struct clist t_outq */
 451         printf("\tt_dev %p\n", TTY.t_dev);              /* t_dev */
 452         printf("\tt_flags 0x%x\n", TTY.t_flags);        /* int  t_flags */
 453         printf("\tt_state 0x%x\n", TTY.t_state);        /* int  t_state */
 454         printf("\tt_ihiwat %d.\n", TTY.t_ihiwat);       /* int  t_ihiwat */
 455         printf("\tt_ilowat %d.\n", TTY.t_ilowat);       /* int  t_ilowat */
 456         printf("\tt_ohiwat %d.\n", TTY.t_ohiwat);       /* int  t_ohiwat */
 457         printf("\tt_olowat %d.\n", TTY.t_olowat);       /* int  t_olowat */
 458         printf("\tt_iflag 0x%x\n", TTY.t_iflag);        /* t_iflag */
 459         printf("\tt_oflag 0x%x\n", TTY.t_oflag);        /* t_oflag */
 460         printf("\tt_cflag 0x%x\n", TTY.t_cflag);        /* t_cflag */
 461         printf("\tt_lflag 0x%x\n", TTY.t_lflag);        /* t_lflag */
 462         printf("\tt_cc %p\n", (void *)TTY.t_cc);        /* t_cc */
 463         printf("\tt_termios.c_ispeed 0x%x\n", TTY.t_termios.c_ispeed);  /* t_termios.c_ispeed */
 464         printf("\tt_termios.c_ospeed 0x%x\n", TTY.t_termios.c_ospeed);  /* t_termios.c_ospeed */
 465 }
 466
 467 int
 468 islevel(char *tk)
 469 {
 470         struct lv *lvp;
 471         char *acp;
 472
 473         for (acp = tk; *acp; acp++)
 474                 if (isupper(*acp))
 475                         *acp = tolower(*acp);
 476         for (lvp = lv; lvp->lv_name; lvp++)
 477                 if (strcmp(lvp->lv_name, tk) == 0)
 478                         return(lvp->lv_bit);
 479         return(0);
 480 }
 481
 482 /*
 483  * Convert a string consisting of tokens separated by white space, commas
 484  * or `|' into a bitfield - flag any unrecognised tokens.
 485  */
 486 int
 487 lvls2bits(char *str)
 488 {
 489         int i, bits = 0;
 490         int errflag = 0;
 491         char token[20];
 492
 493         while (sscanf(str, "%[^,| \t]", token) == 1) {
 494                 str += strlen(token);
 495                 while (isspace(*str) || *str==',' || *str=='|')
 496                         str++;
 497                 if (strcmp(token, "all") == 0)
 498                         return(0xffffffff);
 499                 if ((i = islevel(token)) == 0) {
 500                         warnx("unknown token '%s'", token);
 501                         errflag++;
 502                 } else
 503                         bits |= i;
 504         }
 505         if (errflag)
 506                 exit(1);
 507
 508         return(bits);
 509 }
 510
 511 int
 512 getnum(char *str)
 513 {
 514         int x;
 515         char *acp = str;
 516
 517         x = 0;
 518         while (*acp) {
 519                 if (!isdigit(*acp))
 520                         errx(1, "%s is not a number", str);
 521                 x *= 10;
 522                 x += (*acp - '0');
 523                 acp++;
 524         }
 525         return(x);
 526 }
 527
 528 void
 529 prlevels(int x)
 530 {
 531         struct lv *lvp;
 532
 533         switch (x) {
 534         case 0:
 535                 printf("(none)\n");
 536                 break;
 537         case 0xffffffff:
 538                 printf("all\n");
 539                 break;
 540         default:
 541                 for (lvp = lv; lvp->lv_name; lvp++)
 542                         if (x & lvp->lv_bit)
 543                                 printf(" %s", lvp->lv_name);
 544                 printf("\n");
 545         }
 546 }