usr.sbin/tadpolectl/tadpolectl.c

   1 /* $NetBSD: tadpolectl.c,v 1.7 2008/04/28 20:24:17 martin Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1999 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Tim Rightnour.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <ctype.h>
  33 #include <err.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36 #include <stdlib.h>
  37 #include <fcntl.h>
  38 #include <unistd.h>
  39 #include <sys/ioctl.h>
  40 #include <sys/types.h>
  41 #include <sys/envsys.h>
  42 #include <machine/apmvar.h>
  43 #include <machine/tctrl.h>
  44
  45 #define TCTRL_DEV       "/dev/tctrl0"
  46
  47 int aflag, nflag, wflag, dev;
  48
  49 #define PROTO(x) int x __P((int, int, int));
  50 void usage __P((void));
  51 static void parse __P((char *));
  52 char *dashdot __P((const char *));
  53 int main __P((int, char *[]));
  54 PROTO(hw_version)
  55 PROTO(hw_microcontroller_version)
  56 PROTO(hw_poweroncycles)
  57 PROTO(hw_poweronseconds)
  58 PROTO(hw_power_mains)
  59 PROTO(hw_power_battery_int)
  60 PROTO(hw_power_battery_ext)
  61 PROTO(hw_power_battery_int_chargerate)
  62 PROTO(hw_power_battery_ext_chargerate)
  63 PROTO(hw_power_battery_int_chargelevel)
  64 PROTO(hw_power_battery_ext_chargelevel)
  65 PROTO(hw_video_external)
  66 PROTO(hw_video_lid)
  67 PROTO(hw_video_syncinva)
  68 PROTO(hw_video_syncinvb)
  69 PROTO(hw_video_compsync)
  70 PROTO(hw_video_tft_brightness)
  71 PROTO(hw_speaker_freq)
  72 PROTO(hw_speaker_volume)
  73 PROTO(hw_kbd_repeat_delay)
  74 PROTO(hw_kbd_repeat_speed)
  75 PROTO(hw_mouse_recalibrate)
  76 PROTO(hw_power_battery_chargedisabled)
  77 PROTO(hw_mouse_disable)
  78 PROTO(hw_kbd_click)
  79 PROTO(hw_mouse_intclick)
  80 PROTO(hw_mouse_extclick)
  81 PROTO(hw_mouse_sensitivity)
  82 PROTO(hw_serial_power)
  83
  84 #define NUM_MIBS 29
  85 #define TABLE(n) { __STRING(n), 0, n }
  86
  87 struct {
  88         const char *mib;
  89         int value;
  90         int (*funcptr)(int, int, int);
  91 } table[NUM_MIBS] = {
  92         TABLE(hw_microcontroller_version),
  93         TABLE(hw_version),
  94         TABLE(hw_poweroncycles),
  95         TABLE(hw_poweronseconds),
  96         TABLE(hw_power_mains),
  97         TABLE(hw_power_battery_int),
  98         TABLE(hw_power_battery_ext),
  99         TABLE(hw_power_battery_chargedisabled),
 100         TABLE(hw_power_battery_int_chargerate),
 101         TABLE(hw_power_battery_ext_chargerate),
 102         TABLE(hw_power_battery_int_chargelevel),
 103         TABLE(hw_power_battery_ext_chargelevel),
 104         TABLE(hw_video_external),
 105         TABLE(hw_video_lid),
 106         TABLE(hw_video_syncinva),
 107         TABLE(hw_video_syncinvb),
 108         TABLE(hw_video_compsync),
 109         TABLE(hw_video_tft_brightness),
 110         TABLE(hw_speaker_freq),
 111         TABLE(hw_speaker_volume),
 112         TABLE(hw_kbd_repeat_delay),
 113         TABLE(hw_kbd_repeat_speed),
 114         TABLE(hw_kbd_click),
 115         TABLE(hw_mouse_recalibrate),
 116         TABLE(hw_mouse_disable),
 117         TABLE(hw_mouse_intclick),
 118         TABLE(hw_mouse_extclick),
 119         TABLE(hw_mouse_sensitivity),
 120         TABLE(hw_serial_power),
 121 };
 122
 123 #define FUNC(x) \
 124 int \
 125 x(readflg, new, num) \
 126         int readflg, new, num;
 127
 128 #define READ_REQ(a, b, c) \
 129         req.cmdbuf[0] = a; \
 130         req.cmdlen = b; \
 131         req.rsplen = c; \
 132         ioctl(dev, TCTRL_CMD_REQ, &req)
 133
 134 #define WRITE_REQ(a, b, c) \
 135         req.cmdbuf[0] = a; \
 136         req.cmdlen = b; \
 137         req.rsplen = c; \
 138         ioctl(dev, TCTRL_CMD_REQ, &req)
 139
 140 #define READ_ONLY \
 141         if (!readflg) \
 142                 return(0)
 143
 144 /* hardware functions */
 145
 146 FUNC(hw_mouse_sensitivity)
 147 {
 148         struct tctrl_req req;
 149
 150         req.cmdbuf[1] = 0xff;
 151         req.cmdbuf[2] = 0x00;
 152         READ_REQ(0x2c, 3, 2);
 153         table[num].value = req.rspbuf[0];
 154         if (readflg)
 155                 return(1);
 156         if (new == 0)
 157                 req.cmdbuf[2] = 0x00;
 158         else if (new > 255)
 159                 req.cmdbuf[2] = 0xff;
 160         else
 161                 req.cmdbuf[2] = new;
 162         req.cmdbuf[1] = 0x00;
 163         WRITE_REQ(0x2c, 3, 2);
 164         req.cmdbuf[1] = 0xff;
 165         req.cmdbuf[2] = 0x00;
 166         READ_REQ(0x2c, 3, 2);
 167         table[num].value = req.rspbuf[0];
 168         return(1);
 169 }
 170
 171 FUNC(hw_power_battery_chargedisabled)
 172 {
 173         struct tctrl_req req;
 174
 175         req.cmdbuf[1] = 0xff;
 176         req.cmdbuf[2] = 0x00;
 177         READ_REQ(0x22, 3, 2);
 178         table[num].value = req.rspbuf[0]&0x01 ? 1 : 0;
 179         if (readflg)
 180                 return(1);
 181         if (new == 0)
 182                 req.cmdbuf[2] = 0x00;
 183         else
 184                 req.cmdbuf[2] = 0x01;
 185         req.cmdbuf[1] = ~0x01;
 186         WRITE_REQ(0x22, 3, 2);
 187         req.cmdbuf[1] = 0xff;
 188         req.cmdbuf[2] = 0x00;
 189         READ_REQ(0x22, 3, 2);
 190         table[num].value = req.rspbuf[0]&0x01 ? 1 : 0;
 191         return(1);
 192 }
 193
 194 FUNC(hw_mouse_disable)
 195 {
 196         struct tctrl_req req;
 197
 198         req.cmdbuf[1] = 0xff;
 199         req.cmdbuf[2] = 0x00;
 200         READ_REQ(0x22, 3, 2);
 201         table[num].value = req.rspbuf[0]&0x02 ? 1 : 0;
 202         if (readflg)
 203                 return(1);
 204         if (new == 0)
 205                 req.cmdbuf[2] = 0x00;
 206         else
 207                 req.cmdbuf[2] = 0x02;
 208         req.cmdbuf[1] = ~0x02;
 209         WRITE_REQ(0x22, 3, 2);
 210         req.cmdbuf[1] = 0xff;
 211         req.cmdbuf[2] = 0x00;
 212         READ_REQ(0x22, 3, 2);
 213         table[num].value = req.rspbuf[0]&0x02 ? 1 : 0;
 214         return(1);
 215 }
 216
 217 FUNC(hw_kbd_click)
 218 {
 219         struct tctrl_req req;
 220
 221         req.cmdbuf[1] = 0xff;
 222         req.cmdbuf[2] = 0x00;
 223         READ_REQ(0x22, 3, 2);
 224         table[num].value = req.rspbuf[0]&0x04 ? 1 : 0;
 225         if (readflg)
 226                 return(1);
 227         if (new == 0)
 228                 req.cmdbuf[2] = 0x00;
 229         else
 230                 req.cmdbuf[2] = 0x04;
 231         req.cmdbuf[1] = ~0x04;
 232         WRITE_REQ(0x22, 3, 2);
 233         req.cmdbuf[1] = 0xff;
 234         req.cmdbuf[2] = 0x00;
 235         READ_REQ(0x22, 3, 2);
 236         table[num].value = req.rspbuf[0]&0x04 ? 1 : 0;
 237         return(1);
 238 }
 239
 240 FUNC(hw_mouse_intclick)
 241 {
 242         struct tctrl_req req;
 243
 244         req.cmdbuf[1] = 0xff;
 245         req.cmdbuf[2] = 0x00;
 246         READ_REQ(0x22, 3, 2);
 247         table[num].value = req.rspbuf[0]&0x08 ? 1 : 0;
 248         if (readflg)
 249                 return(1);
 250         if (new == 0)
 251                 req.cmdbuf[2] = 0x00;
 252         else
 253                 req.cmdbuf[2] = 0x08;
 254         req.cmdbuf[1] = ~0x08;
 255         WRITE_REQ(0x22, 3, 2);
 256         req.cmdbuf[1] = 0xff;
 257         req.cmdbuf[2] = 0x00;
 258         READ_REQ(0x22, 3, 2);
 259         table[num].value = req.rspbuf[0]&0x08 ? 1 : 0;
 260         return(1);
 261 }
 262
 263 FUNC(hw_mouse_extclick)
 264 {
 265         struct tctrl_req req;
 266
 267         req.cmdbuf[1] = 0xff;
 268         req.cmdbuf[2] = 0x00;
 269         READ_REQ(0x22, 3, 2);
 270         table[num].value = req.rspbuf[0]&0x10 ? 1 : 0;
 271         if (readflg)
 272                 return(1);
 273         if (new == 0)
 274                 req.cmdbuf[2] = 0x00;
 275         else
 276                 req.cmdbuf[2] = 0x10;
 277         req.cmdbuf[1] = ~0x10;
 278         WRITE_REQ(0x22, 3, 2);
 279         req.cmdbuf[1] = 0xff;
 280         req.cmdbuf[2] = 0x00;
 281         READ_REQ(0x22, 3, 2);
 282         table[num].value = req.rspbuf[0]&0x10 ? 1 : 0;
 283         return(1);
 284 }
 285
 286 /* ARGSUSED */
 287 FUNC(hw_mouse_recalibrate)
 288 {
 289         struct tctrl_req req;
 290
 291         table[num].value = 0;
 292         if (readflg)
 293                 return(1);
 294         READ_REQ(0x36, 1, 1);
 295         return(1);
 296 }
 297
 298 FUNC(hw_kbd_repeat_delay)
 299 {
 300         struct tctrl_req req;
 301
 302         req.cmdbuf[1] = 0xff;
 303         req.cmdbuf[2] = 0x00;
 304         READ_REQ(0x28, 3, 2);
 305         table[num].value = req.rspbuf[0];
 306         if (readflg)
 307                 return(1);
 308         if (new == 0)
 309                 req.cmdbuf[2] = 0x00;
 310         else if (new > 255)
 311                 req.cmdbuf[2] = 0xff;
 312         else
 313                 req.cmdbuf[2] = new;
 314         req.cmdbuf[1] = 0x00;
 315         WRITE_REQ(0x28, 3, 2);
 316         req.cmdbuf[1] = 0xff;
 317         req.cmdbuf[2] = 0x00;
 318         READ_REQ(0x28, 3, 2);
 319         table[num].value = req.rspbuf[0];
 320         return(1);
 321 }
 322
 323 FUNC(hw_kbd_repeat_speed)
 324 {
 325         struct tctrl_req req;
 326
 327         req.cmdbuf[1] = 0xff;
 328         req.cmdbuf[2] = 0x00;
 329         READ_REQ(0x29, 3, 2);
 330         table[num].value = req.rspbuf[0];
 331         if (readflg)
 332                 return(1);
 333         if (new == 0)
 334                 req.cmdbuf[2] = 0x00;
 335         else if (new > 255)
 336                 req.cmdbuf[2] = 0xff;
 337         else
 338                 req.cmdbuf[2] = new;
 339         req.cmdbuf[1] = 0x00;
 340         WRITE_REQ(0x29, 3, 2);
 341         req.cmdbuf[1] = 0xff;
 342         req.cmdbuf[2] = 0x00;
 343         READ_REQ(0x29, 3, 2);
 344         table[num].value = req.rspbuf[0];
 345         return(1);
 346 }
 347
 348 FUNC(hw_speaker_freq)
 349 {
 350         struct tctrl_req req;
 351
 352         table[num].value = 0;
 353         if (readflg)
 354                 return(1);
 355         req.cmdbuf[1] = new * 256;
 356         req.cmdbuf[2] = new % 256;
 357         WRITE_REQ(0x37, 3, 1);
 358         return(1);
 359 }
 360
 361 FUNC(hw_speaker_volume)
 362 {
 363         struct tctrl_req req;
 364
 365         req.cmdbuf[1] = 0xff;
 366         req.cmdbuf[2] = 0x00;
 367         READ_REQ(0x23, 3, 2);
 368         table[num].value = req.rspbuf[0];
 369         if (readflg)
 370                 return(1);
 371         if (new == 0)
 372                 req.cmdbuf[2] = 0x00;
 373         else if (new > 255)
 374                 req.cmdbuf[2] = 0xff;
 375         else
 376                 req.cmdbuf[2] = new;
 377         req.cmdbuf[1] = 0x00;
 378         WRITE_REQ(0x23, 3, 2);
 379         req.cmdbuf[1] = 0xff;
 380         req.cmdbuf[2] = 0x00;
 381         READ_REQ(0x23, 3, 2);
 382         table[num].value = req.rspbuf[0];
 383         return(1);
 384 }
 385
 386 FUNC(hw_video_tft_brightness)
 387 {
 388         struct tctrl_req req;
 389
 390         req.cmdbuf[1] = 0xff;
 391         req.cmdbuf[2] = 0x00;
 392         READ_REQ(0x24, 3, 2);
 393         table[num].value = req.rspbuf[0];
 394         if (readflg)
 395                 return(1);
 396         if (new == 0)
 397                 req.cmdbuf[2] = 0x00;
 398         else if (new > 255)
 399                 req.cmdbuf[2] = 0xff;
 400         else
 401                 req.cmdbuf[2] = new;
 402         req.cmdbuf[1] = 0x00;
 403         WRITE_REQ(0x24, 3, 2);
 404         req.cmdbuf[1] = 0xff;
 405         req.cmdbuf[2] = 0x00;
 406         READ_REQ(0x24, 3, 2);
 407         table[num].value = req.rspbuf[0];
 408         return(1);
 409 }
 410
 411 FUNC(hw_video_syncinva)
 412 {
 413         struct tctrl_req req;
 414
 415         req.cmdbuf[1] = 0xff;
 416         req.cmdbuf[2] = 0x00;
 417         READ_REQ(0x21, 3, 2);
 418         table[num].value = req.rspbuf[0]&0x02 ? 1 : 0;
 419         if (readflg)
 420                 return(1);
 421         if (new == 0)
 422                 req.cmdbuf[2] = 0x00;
 423         else
 424                 req.cmdbuf[2] = 0x02;
 425         req.cmdbuf[1] = ~0x02;
 426         WRITE_REQ(0x21, 3, 2);
 427         req.cmdbuf[1] = 0xff;
 428         req.cmdbuf[2] = 0x00;
 429         READ_REQ(0x21, 3, 2);
 430         table[num].value = req.rspbuf[0]&0x02 ? 1 : 0;
 431         return(1);
 432 }
 433
 434 FUNC(hw_video_syncinvb)
 435 {
 436         struct tctrl_req req;
 437
 438         req.cmdbuf[1] = 0xff;
 439         req.cmdbuf[2] = 0x00;
 440         READ_REQ(0x21, 3, 2);
 441         table[num].value = req.rspbuf[0]&0x04 ? 1 : 0;
 442         if (readflg)
 443                 return(1);
 444         if (new == 0)
 445                 req.cmdbuf[2] = 0x00;
 446         else
 447                 req.cmdbuf[2] = 0x04;
 448         req.cmdbuf[1] = ~0x04;
 449         WRITE_REQ(0x21, 3, 2);
 450         req.cmdbuf[1] = 0xff;
 451         req.cmdbuf[2] = 0x00;
 452         READ_REQ(0x21, 3, 2);
 453         table[num].value = req.rspbuf[0]&0x04 ? 1 : 0;
 454         return(1);
 455 }
 456
 457 FUNC(hw_video_compsync)
 458 {
 459         struct tctrl_req req;
 460
 461         req.cmdbuf[1] = 0xff;
 462         req.cmdbuf[2] = 0x00;
 463         READ_REQ(0x21, 3, 2);
 464         table[num].value = req.rspbuf[0]&0x10 ? 1 : 0;
 465         if (readflg)
 466                 return(1);
 467         if (new == 0)
 468                 req.cmdbuf[2] = 0x00;
 469         else
 470                 req.cmdbuf[2] = 0x10;
 471         req.cmdbuf[1] = ~0x10;
 472         WRITE_REQ(0x21, 3, 2);
 473         req.cmdbuf[1] = 0xff;
 474         req.cmdbuf[2] = 0x00;
 475         READ_REQ(0x21, 3, 2);
 476         table[num].value = req.rspbuf[0]&0x10 ? 1 : 0;
 477         return(1);
 478 }
 479
 480 /* ARGSUSED */
 481 FUNC(hw_video_lid)
 482 {
 483         struct tctrl_req req;
 484         short i;
 485
 486         READ_ONLY;
 487         READ_REQ(0x11, 1, 3);
 488         i = (req.rspbuf[0]<<8) + req.rspbuf[1];
 489         table[num].value = i&0x0040 ? 0 : 1;
 490         return(1);
 491 }
 492
 493 /* ARGSUSED */
 494 FUNC(hw_video_external)
 495 {
 496         struct tctrl_req req;
 497         short i;
 498
 499         READ_ONLY;
 500         READ_REQ(0x11, 1, 3);
 501         i = (req.rspbuf[0]<<8) + req.rspbuf[1];
 502         table[num].value = i&0x0008 ? 1 : 0;
 503         return(1);
 504 }
 505
 506 /* ARGSUSED */
 507 FUNC(hw_power_battery_int_chargelevel)
 508 {
 509         struct tctrl_req req;
 510
 511         READ_ONLY;
 512         READ_REQ(0x7a, 1, 3);
 513         table[num].value = req.rspbuf[0] == 0xfb ? 0 : req.rspbuf[0];
 514         return(1);
 515
 516 }
 517
 518 /* ARGSUSED */
 519 FUNC(hw_power_battery_ext_chargelevel)
 520 {
 521         struct tctrl_req req;
 522
 523         READ_ONLY;
 524         READ_REQ(0x7b, 1, 3);
 525         table[num].value = req.rspbuf[0] == 0xfb ? 0 : req.rspbuf[0];
 526         return(1);
 527 }
 528
 529 FUNC(hw_power_battery_int_chargerate)
 530 {
 531         struct tctrl_req req;
 532
 533         READ_REQ(0x18, 1, 2);
 534         table[num].value = req.rspbuf[0];
 535         if (readflg)
 536                 return(1);
 537         req.cmdbuf[1] = new < 255 ? new : 255;
 538         WRITE_REQ(0x39, 2, 1);
 539         READ_REQ(0x18, 1, 2);
 540         table[num].value = req.rspbuf[0];
 541         return(1);
 542 }
 543
 544 FUNC(hw_power_battery_ext_chargerate)
 545 {
 546         struct tctrl_req req;
 547
 548         READ_REQ(0x18, 1, 2);
 549         table[num].value = req.rspbuf[0];
 550         if (readflg)
 551                 return(1);
 552         req.cmdbuf[1] = new < 255 ? new : 255;
 553         WRITE_REQ(0x39, 2, 1);
 554         READ_REQ(0x18, 1, 2);
 555         table[num].value = req.rspbuf[0];
 556         return(1);
 557 }
 558
 559 /* ARGSUSED */
 560 FUNC(hw_power_battery_ext)
 561 {
 562         int i;
 563         struct tctrl_req req;
 564
 565         READ_ONLY;
 566         READ_REQ(0x11, 1, 3);
 567         i = (req.rspbuf[0]<<8) + req.rspbuf[1];
 568         table[num].value = i&0x0004 ? 1 : 0;
 569         return(1);
 570 }
 571
 572 /* ARGSUSED */
 573 FUNC(hw_power_battery_int)
 574 {
 575         int i;
 576         struct tctrl_req req;
 577
 578         READ_ONLY;
 579         READ_REQ(0x11, 1, 3);
 580         i = (req.rspbuf[0]<<8) + req.rspbuf[1];
 581         table[num].value = i&0x0002 ? 1 : 0;
 582         return(1);
 583 }
 584
 585 /* ARGSUSED */
 586 FUNC(hw_power_mains)
 587 {
 588         int i;
 589         struct tctrl_req req;
 590
 591         READ_ONLY;
 592         READ_REQ(0x11, 1, 3);
 593         i = (req.rspbuf[0]<<8) + req.rspbuf[1];
 594         table[num].value = i&0x0001 ? 1 : 0;
 595         return(1);
 596 }
 597
 598 /* ARGSUSED */
 599 FUNC(hw_poweroncycles)
 600 {
 601         struct tctrl_req req;
 602
 603         READ_ONLY;
 604         READ_REQ(0x09, 1, 5);
 605         table[num].value = (req.rspbuf[0]<<24)+(req.rspbuf[1]<<16)+
 606             (req.rspbuf[2]<<8)+req.rspbuf[3];
 607         return(1);
 608 }
 609
 610 /* ARGSUSED */
 611 FUNC(hw_poweronseconds)
 612 {
 613         struct tctrl_req req;
 614
 615         READ_ONLY;
 616         READ_REQ(0x0a, 1, 5);
 617         table[num].value = (req.rspbuf[0]<<24)+(req.rspbuf[1]<<16)+
 618             (req.rspbuf[2]<<8)+req.rspbuf[3];
 619         return(1);
 620 }
 621
 622 /* ARGSUSED */
 623 FUNC(hw_microcontroller_version)
 624 {
 625         char buf[BUFSIZ];
 626         struct tctrl_req req;
 627
 628         READ_ONLY;
 629         READ_REQ(0x04, 1, 3);
 630         snprintf(buf, sizeof(buf), "%d%d", req.rspbuf[0]*1000,
 631             req.rspbuf[1]*10);
 632         table[num].value = atoi(strdup(buf));
 633         return(1);
 634 }
 635
 636
 637 /* ARGSUSED */
 638 FUNC(hw_version)
 639 {
 640         char buf[BUFSIZ];
 641         struct tctrl_req req;
 642
 643         READ_ONLY;
 644         READ_REQ(0x03, 1, 3);
 645         snprintf(buf, sizeof(buf), "%d%d", req.rspbuf[0]*1000,
 646             req.rspbuf[1]*10);
 647         table[num].value = atoi(strdup(buf));
 648         return(1);
 649 }
 650
 651 FUNC(hw_serial_power)
 652 {
 653         struct tctrl_pwr pwrreq;
 654
 655         if (!readflg) {
 656                 pwrreq.rw = 0x00;
 657                 pwrreq.state = new;
 658                 ioctl(dev, TCTRL_SERIAL_PWR, &pwrreq);
 659         }
 660         pwrreq.rw = 0x01;
 661         ioctl(dev, TCTRL_SERIAL_PWR, &pwrreq);
 662         table[num].value = pwrreq.state;
 663         return(1);
 664 }
 665
 666 void
 667 usage()
 668 {
 669         (void)fprintf(stderr,
 670             "usage: tadpolectl [-n] name ...\n"
 671             "       tadpolectl [-n] -w name=value\n"
 672             "       tadpolectl [-n] -a\n");
 673         exit(1);
 674 }
 675
 676 static void
 677 parse(string)
 678         char *string;
 679 {
 680         char *cp, buf[BUFSIZ];
 681         int newval = 0;
 682         int i, j, ret;
 683
 684         string = dashdot(string);
 685         snprintf(buf, (size_t)BUFSIZ, "%s", string);
 686         if ((cp = strchr(string, '=')) != NULL) {
 687                 if (!wflag)
 688                         errx(2, "Must specify -w to set variables");
 689                 *strchr(buf, '=') = '\0';
 690                 *cp++ = '\0';
 691                 while (isspace((unsigned char) *cp))
 692                         cp++;
 693                 newval = atoi(cp);
 694         }
 695         for (j=0,i=-1; j < NUM_MIBS; j++) {
 696                 if (strcmp(string, table[j].mib) == 0) {
 697                         i = j;
 698                         break;
 699                 }
 700         }
 701         if (i == -1)
 702                 errx(2, "Named value does not exist");
 703
 704         if (wflag) {
 705                 ret = (*table[i].funcptr)(0, newval, i);
 706                 if (!ret)
 707                         errx(2, "Cannot modify this value");
 708         } else
 709                 ret = (*table[i].funcptr)(1, 0, i);
 710         if (nflag)
 711                 printf("%d\n", table[i].value);
 712         else
 713                 printf("%s = %d\n", dashdot(table[i].mib), table[i].value);
 714 }
 715
 716 char *
 717 dashdot(string)
 718         const char *string;
 719 {
 720         char *p;
 721         char *save;
 722
 723         p = strdup(string);
 724         save = p;
 725
 726         for (; (*p = *string) != '\0'; ++p, ++string) {
 727                 if (*p == '.')
 728                         *p = '_';
 729                 else if (*p == '_')
 730                         *p = '.';
 731         }
 732         return(save);
 733 }
 734
 735 int
 736 main(argc, argv)
 737         int argc;
 738         char *argv[];
 739 {
 740         int ch, j;
 741
 742         while ((ch = getopt(argc, argv, "anw")) != -1) {
 743                 switch (ch) {
 744
 745                 case 'a':
 746                         aflag = 1;
 747                         break;
 748                 case 'n':
 749                         nflag = 1;
 750                         break;
 751                 case 'w':
 752                         wflag = 1;
 753                         break;
 754                 default:
 755                         usage();
 756                 }
 757         }
 758         argc -= optind;
 759         argv += optind;
 760
 761         if ((dev = open(TCTRL_DEV, O_RDONLY, NULL)) == -1)
 762                 err(1, "%s", TCTRL_DEV);
 763
 764         if (aflag) {
 765                 for (j=0; j < NUM_MIBS; j++) {
 766                         (void)(*table[j].funcptr)(1, 0, j);
 767                         if (nflag)
 768                                 printf("%d\n", table[j].value);
 769                         else
 770                                 printf("%s = %d\n", dashdot(table[j].mib),
 771                                     table[j].value);
 772                 }
 773                 return(0);
 774         }
 775         if (argc == 0)
 776                 usage();
 777         while (argc-- > 0)
 778                 parse(*argv++);
 779         return(0);
 780 }