sys/platform/pc32/i386/userconfig.c

   1 /**
   2  ** Copyright (c) 1995
   3  **      Michael Smith, msmith@freebsd.org.  All rights reserved.
   4  **
   5  ** This code contains a module marked :
   6
   7  * Copyright (c) 1991 Regents of the University of California.
   8  * All rights reserved.
   9  * Copyright (c) 1994 Jordan K. Hubbard
  10  * All rights reserved.
  11  * Copyright (c) 1994 David Greenman
  12  * All rights reserved.
  13  *
  14  * Many additional changes by Bruce Evans
  15  *
  16  * This code is derived from software contributed by the
  17  * University of California Berkeley, Jordan K. Hubbard,
  18  * David Greenman and Bruce Evans.
  19
  20  ** As such, it contains code subject to the above copyrights.
  21  ** The module and its copyright can be found below.
  22  **
  23  ** Redistribution and use in source and binary forms, with or without
  24  ** modification, are permitted provided that the following conditions
  25  ** are met:
  26  ** 1. Redistributions of source code must retain the above copyright
  27  **    notice, this list of conditions and the following disclaimer as
  28  **    the first lines of this file unmodified.
  29  ** 2. Redistributions in binary form must reproduce the above copyright
  30  **    notice, this list of conditions and the following disclaimer in the
  31  **    documentation and/or other materials provided with the distribution.
  32  ** 3. All advertising materials mentioning features or use of this software
  33  **    must display the following acknowledgment:
  34  **      This product includes software developed by Michael Smith.
  35  ** 4. The name of the author may not be used to endorse or promote products
  36  **    derived from this software without specific prior written permission.
  37  **
  38  ** THIS SOFTWARE IS PROVIDED BY MICHAEL SMITH ``AS IS'' AND ANY EXPRESS OR
  39  ** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  40  ** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  41  ** IN NO EVENT SHALL MICHAEL SMITH BE LIABLE FOR ANY DIRECT, INDIRECT,
  42  ** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  43  ** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  44  ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  45  ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  46  ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  47  ** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48  **
  49  ** $FreeBSD: src/sys/i386/i386/userconfig.c,v 1.175.2.10 2002/10/05 18:31:48 scottl Exp $
  50  **/
  51
  52 /**
  53  ** USERCONFIG
  54  **
  55  ** Kernel boot-time configuration manipulation tool for FreeBSD.
  56  **
  57  ** Two modes of operation are supported : the default is the line-editor mode,
  58  ** the command "visual" invokes the fullscreen mode.
  59  **
  60  ** The line-editor mode is the old favorite from FreeBSD 2.0/20.05 &c., the
  61  ** fullscreen mode requires syscons or a minimal-ansi serial console.
  62  **/
  63
  64 /**
  65  ** USERCONFIG, visual mode.
  66  **
  67  **   msmith@freebsd.org
  68  **
  69  ** Look for "EDIT THIS LIST" to add to the list of known devices
  70  **
  71  **
  72  ** There are a number of assumptions made in this code.
  73  **
  74  ** - That the console supports a minimal set of ANSI escape sequences
  75  **   (See the screen manipulation section for a summary)
  76  **   and has at least 24 rows.
  77  ** - That values less than or equal to zero for any of the device
  78  **   parameters indicate that the driver does not use the parameter.
  79  ** - That flags are _always_ editable.
  80  **
  81  ** Devices marked as disabled are imported as such.
  82  **
  83  ** For this tool to be useful, the list of devices below _MUST_ be updated
  84  ** when a new driver is brought into the kernel.  It is not possible to
  85  ** extract this information from the drivers in the kernel.
  86  **
  87  ** XXX - TODO:
  88  **
  89  ** - Display _what_ a device conflicts with.
  90  ** - Implement page up/down (as what?)
  91  ** - Wizard mode (no restrictions)
  92  ** - Find out how to put syscons back into low-intensity mode so that the
  93  **   !b escape is useful on the console.  (It seems to be that it actually
  94  **   gets low/high intensity backwards. That looks OK.)
  95  **
  96  ** - Only display headings with devices under them. (difficult)
  97  **/
  98
  99 #include "opt_userconfig.h"
 100 #define COMPAT_OLDISA   /* get the definitions */
 101
 102 #include <sys/param.h>
 103 #include <sys/systm.h>
 104 #include <sys/kernel.h>
 105 #include <sys/malloc.h>
 106 #include <sys/reboot.h>
 107 #include <sys/linker.h>
 108 #include <sys/sysctl.h>
 109 #include <sys/bus.h>
 110 #include <sys/cons.h>
 111
 112 #include <machine/md_var.h>
 113 #include <machine/limits.h>
 114
 115 #define _BUS_ISA_ARCH_ISA_DEVICE_H_
 116
 117 #undef NPNP
 118 #define NPNP 0
 119
 120 #if NPNP > 0
 121 #include <machine_base/isa/pnp.h>
 122 #endif
 123
 124 static MALLOC_DEFINE(M_DEVL, "uc_devlist", "uc_device lists in userconfig()");
 125
 126 #include <machine/uc_device.h>
 127 static struct uc_device *uc_devlist;    /* list read by kget to extract changes */
 128 static struct uc_device *uc_devtab;     /* fake uc_device table */
 129
 130 static int userconfig_boot_parsing;     /* set if we are reading from the boot instructions */
 131
 132 static void load_devtab(void);
 133 static void free_devtab(void);
 134 static void save_resource(struct uc_device *);
 135
 136 static int
 137 sysctl_machdep_uc_devlist(SYSCTL_HANDLER_ARGS)
 138 {
 139         struct uc_device *id;
 140         int error=0;
 141         char name[8];
 142
 143         if(!req->oldptr) {
 144                 /* Only sizing */
 145                 id=uc_devlist;
 146                 while(id) {
 147                         error+=sizeof(struct uc_device)+8;
 148                         id=id->id_next;
 149                 }
 150                 return(SYSCTL_OUT(req,0,error));
 151         } else {
 152                 /* Output the data. The buffer is filled with consecutive
 153                  * struct uc_device and char buf[8], containing the name
 154                  * (not guaranteed to end with '\0').
 155                  */
 156                 id=uc_devlist;
 157                 while(id) {
 158                         error=sysctl_handle_opaque(oidp,id,
 159                                 sizeof(struct uc_device),req);
 160                         if(error) return(error);
 161                         strncpy(name,id->id_name,8);
 162                         error=sysctl_handle_opaque(oidp,name,
 163                                 8,req);
 164                         if(error) return(error);
 165                         id=id->id_next;
 166                 }
 167                 return(0);
 168         }
 169 }
 170
 171 SYSCTL_PROC( _machdep, OID_AUTO, uc_devlist, CTLFLAG_RD,
 172         0, 0, sysctl_machdep_uc_devlist, "A",
 173         "List of ISA devices changed in UserConfig");
 174
 175 /*
 176 ** Obtain command input.
 177 **
 178 ** Initially, input is read from a possibly-loaded script.
 179 ** At the end of the script, or if no script is supplied,
 180 ** behaviour is determined by the RB_CONFIG (-c) flag.  If
 181 ** the flag is set, user input is read from the console; if
 182 ** unset, the 'quit' command is invoked and userconfig
 183 ** will exit.
 184 **
 185 ** Note that quit commands encountered in the script will be
 186 ** ignored if the RB_CONFIG flag is supplied.
 187 */
 188 static const char       *config_script;
 189 static int              config_script_size; /* use of int for -ve magic value */
 190
 191 #define has_config_script()     (config_script_size > 0)
 192
 193 static int
 194 init_config_script(void)
 195 {
 196     caddr_t             autoentry, autoattr;
 197
 198     /* Look for loaded userconfig script */
 199     autoentry = preload_search_by_type("userconfig_script");
 200     if (autoentry != NULL) {
 201         /* We have one, get size and data */
 202         config_script_size = 0;
 203         if ((autoattr = preload_search_info(autoentry, MODINFO_SIZE)) != NULL)
 204             config_script_size = (size_t)*(u_int32_t *)autoattr;
 205         config_script = NULL;
 206         if ((autoattr = preload_search_info(autoentry, MODINFO_ADDR)) != NULL)
 207             config_script = *(const char **)autoattr;
 208         /* sanity check */
 209         if ((config_script_size == 0) || (config_script == NULL)) {
 210             config_script_size = 0;
 211             config_script = NULL;
 212         }
 213     }
 214     return has_config_script();
 215 }
 216
 217 static int
 218 kgetchar(void)
 219 {
 220     int                 c = -1;
 221 #ifdef INTRO_USERCONFIG
 222     static int          intro = 0;
 223 #endif
 224
 225     if (has_config_script())
 226     {
 227         /* Consume character from loaded userconfig script, display */
 228         userconfig_boot_parsing = 1;
 229         c = *config_script;
 230         config_script++;
 231         config_script_size--;
 232
 233     } else {
 234
 235 #ifdef INTRO_USERCONFIG
 236         if (userconfig_boot_parsing) {
 237             if (!(boothowto & RB_CONFIG)) {
 238                 /* userconfig_script, !RB_CONFIG -> quit */
 239                 if (intro == 0) {
 240                     c = 'q';
 241                     config_script = "uit\n";
 242                     config_script_size = strlen(config_script);
 243                     /* userconfig_script will be 1 on the next pass */
 244                 }
 245             } else {
 246                 /* userconfig_script, RB_CONFIG -> cngetc() */
 247             }
 248         } else {
 249             if (!(boothowto & RB_CONFIG)) {
 250                 /* no userconfig_script, !RB_CONFIG -> show intro */
 251                 if (intro == 0) {
 252                     intro = 1;
 253                     c = 'i';
 254                     config_script = "ntro\n";
 255                     config_script_size = strlen(config_script);
 256                     /* userconfig_script will be 1 on the next pass */
 257                 }
 258             } else {
 259                 /* no userconfig_script, RB_CONFIG -> cngetc() */
 260             }
 261         }
 262 #else /* !INTRO_USERCONFIG */
 263         /* assert(boothowto & RB_CONFIG) */
 264 #endif /* INTRO_USERCONFIG */
 265         userconfig_boot_parsing = 0;
 266         if (c <= 0)
 267             c = cngetc();
 268     }
 269     return(c);
 270 }
 271
 272 #ifndef FALSE
 273 #define FALSE   (0)
 274 #define TRUE    (!FALSE)
 275 #endif
 276
 277 #ifdef VISUAL_USERCONFIG
 278
 279 typedef struct
 280 {
 281     char        dev[16];                /* device basename */
 282     char        name[60];               /* long name */
 283     int         attrib;                 /* things to do with the device */
 284     int         class;                  /* device classification */
 285 } DEV_INFO;
 286
 287 #define FLG_INVISIBLE   (1<<0)          /* device should not be shown */
 288 #define FLG_MANDATORY   (1<<1)          /* device can be edited but not disabled */
 289 #define FLG_FIXIRQ      (1<<2)          /* device IRQ cannot be changed */
 290 #define FLG_FIXIOBASE   (1<<3)          /* device iobase cannot be changed */
 291 #define FLG_FIXMADDR    (1<<4)          /* device maddr cannot be changed */
 292 #define FLG_FIXMSIZE    (1<<5)          /* device msize cannot be changed */
 293 #define FLG_FIXDRQ      (1<<6)          /* device DRQ cannot be changed */
 294 #define FLG_FIXED       (FLG_FIXIRQ|FLG_FIXIOBASE|FLG_FIXMADDR|FLG_FIXMSIZE|FLG_FIXDRQ)
 295 #define FLG_IMMUTABLE   (FLG_FIXED|FLG_MANDATORY)
 296
 297 #define CLS_STORAGE     1               /* storage devices */
 298 #define CLS_NETWORK     2               /* network interfaces */
 299 #define CLS_COMMS       3               /* serial, parallel ports */
 300 #define CLS_INPUT       4               /* user input : mice, keyboards, joysticks etc */
 301 #define CLS_MMEDIA      5               /* "multimedia" devices (sound, video, etc) */
 302 #define CLS_MISC        255             /* none of the above */
 303
 304
 305 typedef struct
 306 {
 307     char        name[60];
 308     int         number;
 309 } DEVCLASS_INFO;
 310
 311 static DEVCLASS_INFO devclass_names[] = {
 312 {       "Storage :        ",    CLS_STORAGE},
 313 {       "Network :        ",    CLS_NETWORK},
 314 {       "Communications : ",    CLS_COMMS},
 315 {       "Input :          ",    CLS_INPUT},
 316 {       "Multimedia :     ",    CLS_MMEDIA},
 317 {       "Miscellaneous :  ",    CLS_MISC},
 318 {       "",0}};
 319
 320
 321 /********************* EDIT THIS LIST **********************/
 322
 323 /** Notes :
 324  **
 325  ** - Devices that shouldn't be seen or removed should be marked FLG_INVISIBLE.
 326  ** - XXX The list below should be reviewed by the driver authors to verify
 327  **   that the correct flags have been set for each driver, and that the
 328  **   descriptions are accurate.
 329  **/
 330
 331 static DEV_INFO device_info[] = {
 332 /*---Name-----   ---Description---------------------------------------------- */
 333 {"adv",         "AdvanSys SCSI narrow controller",      0,              CLS_STORAGE},
 334 {"bt",          "Buslogic SCSI controller",             0,              CLS_STORAGE},
 335 {"nca",         "ProAudio Spectrum SCSI and compatibles",       0,      CLS_STORAGE},
 336 {"sea",         "Seagate ST01/ST02 SCSI and compatibles",       0,      CLS_STORAGE},
 337 {"stg",         "TMC 18C30/18C50 based SCSI cards",     0,              CLS_STORAGE},
 338 {"wdc",         "IDE/ESDI/MFM disk controller",         0,              CLS_STORAGE},
 339 {"ata",         "ATA/ATAPI compatible disk controller", 0,              CLS_STORAGE},
 340 {"fdc",         "Floppy disk controller",               FLG_FIXED,      CLS_STORAGE},
 341 {"wd",          "IDE or ST506 compatible storage device", FLG_INVISIBLE, CLS_STORAGE},
 342 {"ad",          "ATA/ATAPI compatible storage device",  FLG_INVISIBLE,  CLS_STORAGE},
 343 {"fd",          "Floppy disk device",                   FLG_INVISIBLE,  CLS_STORAGE},
 344
 345 {"cs",          "IBM EtherJet, CS89x0-based Ethernet adapters",0,       CLS_NETWORK},
 346 {"ed",          "NE1000,NE2000,3C503,WD/SMC80xx Ethernet adapters",0,   CLS_NETWORK},
 347 {"ep",          "3C509 Ethernet adapter",               0,              CLS_NETWORK},
 348 {"ex",          "Intel EtherExpress Pro/10 Ethernet adapter",   0,      CLS_NETWORK},
 349 {"fe",          "Fujitsu MB86960A/MB86965A Ethernet adapters",  0,      CLS_NETWORK},
 350 {"lnc",         "Isolan, Novell NE2100/NE32-VL Ethernet adapters",      0,CLS_NETWORK},
 351 {"sn",          "SMC/Megahertz Ethernet adapters",                      0,CLS_NETWORK},
 352 {"xe",          "Xircom PC Card Ethernet adapter",              0,      CLS_NETWORK},
 353 {"sbni",        "Granch SBNI12-xx adapters",            0,              CLS_NETWORK},
 354
 355 {"sio",         "8250/16450/16550 Serial port",         0,              CLS_COMMS},
 356 {"cx",          "Cronyx/Sigma multiport sync/async adapter",0,          CLS_COMMS},
 357 {"cy",          "Cyclades multiport async adapter",     0,              CLS_COMMS},
 358 {"si",          "Specialix SI/XIO/SX async adapter",    0,              CLS_COMMS},
 359 {"stl",         "Stallion EasyIO/Easy Connection 8/32 async adapter",0, CLS_COMMS},
 360 {"stli",        "Stallion intelligent async adapter"    ,0,             CLS_COMMS},
 361 {"ppc",         "Parallel Port chipset",                0,              CLS_COMMS},
 362
 363 {"atkbdc",      "Keyboard controller",                  FLG_INVISIBLE,  CLS_INPUT},
 364 {"atkbd",       "Keyboard",                             FLG_FIXED,      CLS_INPUT},
 365 {"psm",         "PS/2 Mouse",                           FLG_FIXED,      CLS_INPUT},
 366 {"joy",         "Joystick",                             FLG_FIXED,      CLS_INPUT},
 367 {"sc",          "Syscons console driver",               FLG_IMMUTABLE,  CLS_INPUT},
 368
 369 {"sbc",         "PCM Creative SoundBlaster/ESS/Avance sounce cards",    0,CLS_MMEDIA},
 370 {"gusc",        "PCM Gravis UltraSound sound cards",    0,              CLS_MMEDIA},
 371 {"pcm",         "PCM Generic soundcard support",                0,              CLS_MMEDIA},
 372 {"sb",          "VOXWARE Soundblaster PCM (SB/Pro/16, ProAudio Spectrum)",0,CLS_MMEDIA},
 373 {"sbxvi",       "VOXWARE Soundblaster 16",              0,              CLS_MMEDIA},
 374 {"sbmidi",      "VOXWARE Soundblaster MIDI interface",  0,              CLS_MMEDIA},
 375 {"pas",         "VOXWARE ProAudio Spectrum PCM and MIDI",       0,      CLS_MMEDIA},
 376 {"gus",         "VOXWARE Gravis Ultrasound, Ultrasound 16 and Ultrasound MAX",0,CLS_MMEDIA},
 377 {"gusxvi",      "VOXWARE Gravis Ultrasound 16-bit PCM", 0,              CLS_MMEDIA},
 378 {"gusmax",      "VOXWARE Gravis Ultrasound MAX",        0,              CLS_MMEDIA},
 379 {"mss",         "VOXWARE Microsoft Sound System",       0,              CLS_MMEDIA},
 380 {"opl",         "VOXWARE OPL-2/3 FM, SB/Pro/16, ProAudio Spectrum",0,CLS_MMEDIA},
 381 {"mpu",         "VOXWARE Roland MPU401 MIDI",           0,              CLS_MMEDIA},
 382 {"sscape",      "VOXWARE Ensoniq Soundscape MIDI interface",    0,      CLS_MMEDIA},
 383 {"sscape_mss",  "VOXWARE Ensoniq Soundscape PCM",       0,              CLS_MMEDIA},
 384 {"uart",        "VOXWARE 6850 MIDI UART",               0,              CLS_MMEDIA},
 385 {"pca",         "PC speaker PCM audio driver",          FLG_FIXED,      CLS_MMEDIA},
 386 {"scc",         "IBM Smart Capture Card",               0,              CLS_MMEDIA},
 387
 388 {"apm",         "Advanced Power Management",            FLG_FIXED,      CLS_MISC},
 389 {"pcic",        "PC-card controller",                   0,              CLS_MISC},
 390 {"npx",         "Math coprocessor",                     FLG_IMMUTABLE,  CLS_MISC},
 391 {"vga",         "Catchall PCI VGA driver",              FLG_INVISIBLE,  CLS_MISC},
 392 {"","",0,0}};
 393
 394
 395 typedef struct _devlist_struct
 396 {
 397     char        name[80];
 398     int         attrib;                 /* flag values as per the FLG_* defines above */
 399     int         class;                  /* disk, etc as per the CLS_* defines above */
 400     char        dev[16];
 401     int         iobase,irq,drq,maddr,msize,unit,flags,id;
 402     int         comment;                /* 0 = device, 1 = comment, 2 = collapsed comment */
 403     int         conflicts;              /* set/reset by findconflict, count of conflicts */
 404     int         changed;                /* nonzero if the device has been edited */
 405     struct uc_device    *device;
 406     struct _devlist_struct *prev,*next;
 407 } DEV_LIST;
 408
 409
 410 #define DEV_DEVICE      0
 411 #define DEV_COMMENT     1
 412 #define DEV_ZOOMED      2
 413
 414 #define LIST_CURRENT    (1<<0)
 415 #define LIST_SELECTED   (1<<1)
 416
 417 #define KEY_EXIT        0       /* return codes from dolist() and friends */
 418 #define KEY_DO          1
 419 #define KEY_DEL         2
 420 #define KEY_TAB         3
 421 #define KEY_REDRAW      4
 422
 423 #define KEY_UP          5       /* these only returned from editval() */
 424 #define KEY_DOWN        6
 425 #define KEY_LEFT        7
 426 #define KEY_RIGHT       8
 427 #define KEY_NULL        9       /* this allows us to spin & redraw */
 428
 429 #define KEY_ZOOM        10      /* these for zoom all/collapse all */
 430 #define KEY_UNZOOM      11
 431
 432 #define KEY_HELP        12      /* duh? */
 433
 434 static void redraw(void);
 435 static void insdev(DEV_LIST *dev, DEV_LIST *list);
 436 static int  devinfo(DEV_LIST *dev);
 437 static int  visuserconfig(void);
 438
 439 static DEV_LIST *active = NULL,*inactive = NULL;        /* driver lists */
 440 static DEV_LIST *alist,*ilist;                          /* visible heads of the driver lists */
 441 static DEV_LIST scratch;                                /* scratch record */
 442 static int      conflicts;                              /* total conflict count */
 443
 444
 445 static char lines[] = "--------------------------------------------------------------------------------";
 446 static char spaces[] = "                                                                                     ";
 447
 448
 449 /**
 450  ** Device manipulation stuff : find, describe, configure.
 451  **/
 452
 453 /**
 454  ** setdev
 455  **
 456  ** Sets the device referenced by (*dev) to the parameters in the struct,
 457  ** and the enable flag according to (enabled)
 458  **/
 459 static void
 460 setdev(DEV_LIST *dev, int enabled)
 461 {
 462     dev->device->id_iobase = dev->iobase;                               /* copy happy */
 463     dev->device->id_irq = (u_short)(dev->irq < 16 ? 1<<dev->irq : 0);   /* IRQ is bitfield */
 464     dev->device->id_drq = (short)dev->drq;
 465     dev->device->id_maddr = (caddr_t)dev->maddr;
 466     dev->device->id_msize = dev->msize;
 467     dev->device->id_flags = dev->flags;
 468     dev->device->id_enabled = enabled;
 469 }
 470
 471
 472 /**
 473  ** getdevs
 474  **
 475  ** Walk the kernel device tables and build the active and inactive lists
 476  **/
 477 static void
 478 getdevs(void)
 479 {
 480     int                 i;
 481     struct uc_device    *ap;
 482
 483         ap = uc_devtab;                         /* pointer to array of devices */
 484         for (i = 0; ap[i].id_id; i++)                   /* for each device in this table */
 485         {
 486             scratch.unit = ap[i].id_unit;               /* device parameters */
 487             strcpy(scratch.dev,ap[i].id_name);
 488             scratch.iobase = ap[i].id_iobase;
 489             scratch.irq = ffs(ap[i].id_irq)-1;
 490             scratch.drq = ap[i].id_drq;
 491             scratch.maddr = (int)ap[i].id_maddr;
 492             scratch.msize = ap[i].id_msize;
 493             scratch.flags = ap[i].id_flags;
 494
 495             scratch.comment = DEV_DEVICE;               /* admin stuff */
 496             scratch.conflicts = 0;
 497             scratch.device = &ap[i];                    /* save pointer for later reference */
 498             scratch.changed = 0;
 499             if (!devinfo(&scratch))                     /* get more info on the device */
 500                 insdev(&scratch,ap[i].id_enabled?active:inactive);
 501         }
 502 }
 503
 504
 505 /**
 506  ** Devinfo
 507  **
 508  ** Fill in (dev->name), (dev->attrib) and (dev->type) from the device_info array.
 509  ** If the device is unknown, put it in the CLS_MISC class, with no flags.
 510  **
 511  ** If the device is marked "invisible", return nonzero; the caller should
 512  ** not insert any such device into either list.
 513  **
 514  **/
 515 static int
 516 devinfo(DEV_LIST *dev)
 517 {
 518     int         i;
 519
 520     for (i = 0; device_info[i].class; i++)
 521     {
 522         if (!strcmp(dev->dev,device_info[i].dev))
 523         {
 524             if (device_info[i].attrib & FLG_INVISIBLE)  /* forget we ever saw this one */
 525                 return(1);
 526             strcpy(dev->name,device_info[i].name);      /* get the name */
 527             dev->attrib = device_info[i].attrib;
 528             dev->class = device_info[i].class;
 529             return(0);
 530         }
 531     }
 532     strcpy(dev->name,"Unknown device");
 533     dev->attrib = 0;
 534     dev->class = CLS_MISC;
 535     return(0);
 536 }
 537
 538
 539 /**
 540  ** List manipulation stuff : add, move, initialise, free, traverse
 541  **
 542  ** Note that there are assumptions throughout this code that
 543  ** the first entry in a list will never move. (assumed to be
 544  ** a comment).
 545  **/
 546
 547
 548 /**
 549  ** Adddev
 550  **
 551  ** appends a copy of (dev) to the end of (*list)
 552  **/
 553 static void
 554 addev(DEV_LIST *dev, DEV_LIST **list)
 555 {
 556
 557     DEV_LIST    *lp,*ap;
 558
 559     lp = (DEV_LIST *)kmalloc(sizeof(DEV_LIST),M_DEVL,M_WAITOK);
 560     bcopy(dev,lp,sizeof(DEV_LIST));                     /* create copied record */
 561
 562     if (*list)                                          /* list exists */
 563     {
 564         ap = *list;
 565         while(ap->next)
 566             ap = ap->next;                              /* scoot to end of list */
 567         lp->prev = ap;
 568         lp->next = NULL;
 569         ap->next = lp;
 570     }else{                                              /* list does not yet exist */
 571         *list = lp;
 572         lp->prev = lp->next = NULL;                     /* list now exists */
 573     }
 574 }
 575
 576
 577 /**
 578  ** Findspot
 579  **
 580  ** Finds the 'appropriate' place for (dev) in (list)
 581  **
 582  ** 'Appropriate' means in numeric order with other devices of the same type,
 583  ** or in alphabetic order following a comment of the appropriate type.
 584  ** or at the end of the list if an appropriate comment is not found. (this should
 585  ** never happen)
 586  ** (Note that the appropriate point is never the top, but may be the bottom)
 587  **/
 588 static DEV_LIST *
 589 findspot(DEV_LIST *dev, DEV_LIST *list)
 590 {
 591     DEV_LIST    *ap = NULL;
 592
 593     /* search for a previous instance of the same device */
 594     for (ap = list; ap; ap = ap->next)
 595     {
 596         if (ap->comment != DEV_DEVICE)                  /* ignore comments */
 597             continue;
 598         if (!strcmp(dev->dev,ap->dev))                  /* same base device */
 599         {
 600             if ((dev->unit <= ap->unit)                 /* belongs before (equal is bad) */
 601                 || !ap->next)                           /* or end of list */
 602             {
 603                 ap = ap->prev;                          /* back up one */
 604                 break;                                  /* done here */
 605             }
 606             if (ap->next)                                       /* if the next item exists */
 607             {
 608                 if (ap->next->comment != DEV_DEVICE)    /* next is a comment */
 609                     break;
 610                 if (strcmp(dev->dev,ap->next->dev))             /* next is a different device */
 611                     break;
 612             }
 613         }
 614     }
 615
 616     if (!ap)                                            /* not sure yet */
 617     {
 618         /* search for a class that the device might belong to */
 619         for (ap = list; ap; ap = ap->next)
 620         {
 621             if (ap->comment != DEV_DEVICE)              /* look for simlar devices */
 622                 continue;
 623             if (dev->class != ap->class)                /* of same class too 8) */
 624                 continue;
 625             if (strcmp(dev->dev,ap->dev) < 0)           /* belongs before the current entry */
 626             {
 627                 ap = ap->prev;                          /* back up one */
 628                 break;                                  /* done here */
 629             }
 630             if (ap->next)                               /* if the next item exists */
 631                 if (ap->next->comment != DEV_DEVICE)    /* next is a comment, go here */
 632                     break;
 633         }
 634     }
 635
 636     if (!ap)                                            /* didn't find a match */
 637     {
 638         for (ap = list; ap->next; ap = ap->next)        /* try for a matching comment */
 639             if ((ap->comment != DEV_DEVICE)
 640                 && (ap->class == dev->class))           /* appropriate place? */
 641                 break;
 642     }                                                   /* or just put up with last */
 643
 644     return(ap);
 645 }
 646
 647
 648 /**
 649  ** Insdev
 650  **
 651  ** Inserts a copy of (dev) at the appropriate point in (list)
 652  **/
 653 static void
 654 insdev(DEV_LIST *dev, DEV_LIST *list)
 655 {
 656     DEV_LIST    *lp,*ap;
 657
 658     lp = (DEV_LIST *)kmalloc(sizeof(DEV_LIST),M_DEVL,M_WAITOK);
 659     bcopy(dev,lp,sizeof(DEV_LIST));                     /* create copied record */
 660
 661     ap = findspot(lp,list);                             /* find appropriate spot */
 662     lp->next = ap->next;                                /* point to next */
 663     if (ap->next)
 664         ap->next->prev = lp;                            /* point next to new */
 665     lp->prev = ap;                                      /* point new to current */
 666     ap->next = lp;                                      /* and current to new */
 667 }
 668
 669
 670 /**
 671  ** Movedev
 672  **
 673  ** Moves (dev) from its current list to an appropriate place in (list)
 674  ** (dev) may not come from the top of a list, but it may from the bottom.
 675  **/
 676 static void
 677 movedev(DEV_LIST *dev, DEV_LIST *list)
 678 {
 679     DEV_LIST    *ap;
 680
 681     ap = findspot(dev,list);
 682     dev->prev->next = dev->next;                        /* remove from old list */
 683     if (dev->next)
 684         dev->next->prev = dev->prev;
 685
 686     dev->next = ap->next;                               /* insert in new list */
 687     if (ap->next)
 688         ap->next->prev = dev;                           /* point next to new */
 689     dev->prev = ap;                                     /* point new to current */
 690     ap->next = dev;                                     /* and current to new */
 691 }
 692
 693
 694 /**
 695  ** Initlist
 696  **
 697  ** Initialises (*list) with the basic headings
 698  **/
 699 static void
 700 initlist(DEV_LIST **list)
 701 {
 702     int         i;
 703
 704     for(i = 0; devclass_names[i].name[0]; i++)          /* for each devtype name */
 705     {
 706         strcpy(scratch.name,devclass_names[i].name);
 707         scratch.comment = DEV_ZOOMED;
 708         scratch.class = devclass_names[i].number;
 709         scratch.attrib = FLG_MANDATORY;                 /* can't be moved */
 710         addev(&scratch,list);                           /* add to the list */
 711     }
 712 }
 713
 714
 715 /**
 716  ** savelist
 717  **
 718  ** Walks (list) and saves the settings of any entry marked as changed.
 719  **
 720  ** The device's active field is set according to (active).
 721  **
 722  ** Builds the uc_devlist used by kget to extract the changed device information.
 723  ** The code for this was taken almost verbatim from the original module.
 724  **/
 725 static void
 726 savelist(DEV_LIST *list, int active)
 727 {
 728     struct uc_device    *id_p,*id_pn;
 729     char *name;
 730
 731     while (list)
 732     {
 733         if ((list->comment == DEV_DEVICE) &&            /* is a device */
 734             (list->changed) &&                          /* has been changed */
 735             (list->device != NULL)) {                   /* has an uc_device structure */
 736
 737             setdev(list,active);                        /* set the device itself */
 738
 739             id_pn = NULL;
 740             for (id_p=uc_devlist; id_p; id_p=id_p->id_next)
 741             {                                           /* look on the list for it */
 742                 if (id_p->id_id == list->device->id_id)
 743                 {
 744                     name = list->device->id_name;
 745                     id_pn = id_p->id_next;
 746                     if (id_p->id_name)
 747                             kfree(id_p->id_name, M_DEVL);
 748                     bcopy(list->device,id_p,sizeof(struct uc_device));
 749                     save_resource(list->device);
 750                     id_p->id_name = kmalloc(strlen(name) + 1, M_DEVL,M_WAITOK);
 751                     strcpy(id_p->id_name, name);
 752                     id_pn->id_next = uc_devlist;
 753                     id_p->id_next = id_pn;
 754                     break;
 755                 }
 756             }
 757             if (!id_pn)                                 /* not already on the list */
 758             {
 759                 name = list->device->id_name;
 760                 id_pn = kmalloc(sizeof(struct uc_device),M_DEVL,M_WAITOK);
 761                 bcopy(list->device,id_pn,sizeof(struct uc_device));
 762                 save_resource(list->device);
 763                 id_pn->id_name = kmalloc(strlen(name) + 1, M_DEVL,M_WAITOK);
 764                 strcpy(id_pn->id_name, name);
 765                 id_pn->id_next = uc_devlist;
 766                 uc_devlist = id_pn;                     /* park at top of list */
 767             }
 768         }
 769         list = list->next;
 770     }
 771 }
 772
 773
 774 /**
 775  ** nukelist
 776  **
 777  ** Frees all storage in use by a (list).
 778  **/
 779 static void
 780 nukelist(DEV_LIST *list)
 781 {
 782     DEV_LIST    *dp;
 783
 784     if (!list)
 785         return;
 786     while(list->prev)                                   /* walk to head of list */
 787         list = list->prev;
 788
 789     while(list)
 790     {
 791         dp = list;
 792         list = list->next;
 793         kfree(dp,M_DEVL);
 794     }
 795 }
 796
 797
 798 /**
 799  ** prevent
 800  **
 801  ** Returns the previous entry in (list), skipping zoomed regions.  Returns NULL
 802  ** if there is no previous entry. (Only possible if list->prev == NULL given the
 803  ** premise that there is always a comment at the head of the list)
 804  **/
 805 static DEV_LIST *
 806 prevent(DEV_LIST *list)
 807 {
 808     DEV_LIST    *dp;
 809
 810     if (!list)
 811         return(NULL);
 812     dp = list->prev;                    /* start back one */
 813     while(dp)
 814     {
 815         if (dp->comment == DEV_ZOOMED)  /* previous section is zoomed */
 816             return(dp);                 /* so skip to comment */
 817         if (dp->comment == DEV_COMMENT) /* not zoomed */
 818             return(list->prev);         /* one back as normal */
 819         dp = dp->prev;                  /* backpedal */
 820     }
 821     return(dp);                         /* NULL, we can assume */
 822 }
 823
 824
 825 /**
 826  ** nextent
 827  **
 828  ** Returns the next entry in (list), skipping zoomed regions.  Returns NULL
 829  ** if there is no next entry. (Possible if the current entry is last, or
 830  ** if the current entry is the last heading and it's collapsed)
 831  **/
 832 static DEV_LIST *
 833 nextent(DEV_LIST *list)
 834 {
 835     DEV_LIST    *dp;
 836
 837     if (!list)
 838         return(NULL);
 839     if (list->comment != DEV_ZOOMED)    /* no reason to skip */
 840         return(list->next);
 841     dp = list->next;
 842     while(dp)
 843     {
 844         if (dp->comment != DEV_DEVICE)  /* found another heading */
 845             break;
 846         dp = dp->next;
 847     }
 848     return(dp);                         /* back we go */
 849 }
 850
 851
 852 /**
 853  ** ofsent
 854  **
 855  ** Returns the (ofs)th entry down from (list), or NULL if it doesn't exist
 856  **/
 857 static DEV_LIST *
 858 ofsent(int ofs, DEV_LIST *list)
 859 {
 860     while (ofs-- && list)
 861         list = nextent(list);
 862     return(list);
 863 }
 864
 865
 866 /**
 867  ** findconflict
 868  **
 869  ** Scans every element of (list) and sets the conflict tags appropriately
 870  ** Returns the number of conflicts found.
 871  **/
 872 static int
 873 findconflict(DEV_LIST *list)
 874 {
 875     int         count = 0;                      /* number of conflicts found */
 876     DEV_LIST    *dp,*sp;
 877
 878     for (dp = list; dp; dp = dp->next)          /* over the whole list */
 879     {
 880         if (dp->comment != DEV_DEVICE)          /* comments don't usually conflict */
 881             continue;
 882
 883         dp->conflicts = 0;                      /* assume the best */
 884         for (sp = list; sp; sp = sp->next)      /* scan the entire list for conflicts */
 885         {
 886             if (sp->comment != DEV_DEVICE)      /* likewise */
 887                 continue;
 888
 889             if (sp == dp)                       /* always conflict with itself */
 890                 continue;
 891
 892             if ((dp->iobase > 0) &&             /* iobase conflict? */
 893                 (dp->iobase == sp->iobase))
 894                 dp->conflicts = 1;
 895             if ((dp->irq > 0) &&                /* irq conflict? */
 896                 (dp->irq == sp->irq))
 897                 dp->conflicts = 1;
 898             if ((dp->drq > 0) &&                /* drq conflict? */
 899                 (dp->drq == sp->drq))
 900                 dp->conflicts = 1;
 901             if ((sp->maddr > 0) &&              /* maddr/msize conflict? */
 902                 (dp->maddr > 0) &&
 903                 (sp->maddr + ((sp->msize == 0) ? 1 : sp->msize) > dp->maddr) &&
 904                 (dp->maddr + ((dp->msize == 0) ? 1 : dp->msize) > sp->maddr))
 905                 dp->conflicts = 1;
 906         }
 907         count += dp->conflicts;                 /* count conflicts */
 908     }
 909     return(count);
 910 }
 911
 912
 913 /**
 914  ** expandlist
 915  **
 916  ** Unzooms all headings in (list)
 917  **/
 918 static void
 919 expandlist(DEV_LIST *list)
 920 {
 921     while(list)
 922     {
 923         if (list->comment == DEV_COMMENT)
 924             list->comment = DEV_ZOOMED;
 925         list = list->next;
 926     }
 927 }
 928
 929
 930 /**
 931  ** collapselist
 932  **
 933  ** Zooms all headings in (list)
 934  **/
 935 static void
 936 collapselist(DEV_LIST *list)
 937 {
 938     while(list)
 939     {
 940         if (list->comment == DEV_ZOOMED)
 941             list->comment = DEV_COMMENT;
 942         list = list->next;
 943     }
 944 }
 945
 946
 947 /**
 948  ** Screen-manipulation stuff
 949  **
 950  ** This is the basic screen layout :
 951  **
 952  **     0    5   10   15   20   25   30   35   40   45   50   55   60   67   70   75
 953  **     |....|....|....|....|....|....|....|....|....|....|....|....|....|....|....|....
 954  **    +--------------------------------------------------------------------------------+
 955  ** 0 -|---Active Drivers----------------------------xx Conflicts------Dev---IRQ--Port--|
 956  ** 1 -| ........................                                    .......  ..  0x....|
 957  ** 2 -| ........................                                    .......  ..  0x....|
 958  ** 3 -| ........................                                    .......  ..  0x....|
 959  ** 4 -| ........................                                    .......  ..  0x....|
 960  ** 5 -| ........................                                    .......  ..  0x....|
 961  ** 6 -| ........................                                    .......  ..  0x....|
 962  ** 7 -| ........................                                    .......  ..  0x....|
 963  ** 8 -| ........................                                    .......  ..  0x....|
 964  ** 9 -|---Inactive Drivers--------------------------------------------Dev--------------|
 965  ** 10-| ........................                                    .......            |
 966  ** 11-| ........................                                    .......            |
 967  ** 12-| ........................                                    .......            |
 968  ** 13-| ........................                                    .......            |
 969  ** 14-| ........................                                    .......            |
 970  ** 15-| ........................                                    .......            |
 971  ** 16-| ........................                                    .......            |
 972  ** 17-|------------------------------------------------------UP-DOWN-------------------|
 973  ** 18-| Relevant parameters for the current device                                     |
 974  ** 19-|                                                                                |
 975  ** 20-|                                                                                |
 976  ** 21-|--------------------------------------------------------------------------------|
 977  ** 22-| Help texts go here                                                             |
 978  ** 23-|                                                                                |
 979  **    +--------------------------------------------------------------------------------+
 980  **
 981  ** Help texts
 982  **
 983  ** On a collapsed comment :
 984  **
 985  ** [Enter] Expand device list      [z]   Expand all lists
 986  ** [TAB]   Change fields           [Q]   Save and Exit
 987  **
 988  ** On an expanded comment :
 989  **
 990  ** [Enter] Collapse device list    [Z]   Collapse all lists
 991  ** [TAB]   Change fields           [Q]   Save and Exit
 992  **
 993  ** On a comment with no followers
 994  **
 995  **
 996  ** [TAB]   Change fields           [Q]   Save and Exit
 997  **
 998  ** On a device in the active list
 999  **
1000  ** [Enter] Edit device parameters  [DEL] Disable device
1001  ** [TAB]   Change fields           [Q]   Save and Exit             [?] Help
1002  **
1003  ** On a device in the inactive list
1004  **
1005  ** [Enter] Enable device
1006  ** [TAB]   Change fields           [Q]   Save and Exit             [?] Help
1007  **
1008  ** While editing parameters
1009  **
1010  ** <parameter-specific help here>
1011  ** [TAB]   Change fields           [Q]   Save device parameters
1012  **/
1013
1014
1015
1016 /**
1017  **
1018  ** The base-level screen primitives :
1019  **
1020  ** bold()      - enter bold mode               \E[1m     (md)
1021  ** inverse()   - enter inverse mode            \E[7m     (so)
1022  ** normal()    - clear bold/inverse mode       \E[m      (se)
1023  ** clear()     - clear the screen              \E[H\E[J  (ce)
1024  ** move(x,y)   - move the cursor to x,y        \E[y;xH:  (cm)
1025  **/
1026
1027 static void
1028 bold(void)
1029 {
1030     kprintf("\033[1m");
1031 }
1032
1033 static void
1034 inverse(void)
1035 {
1036     kprintf("\033[7m");
1037 }
1038
1039 static void
1040 normal(void)
1041 {
1042     kprintf("\033[m");
1043 }
1044
1045 static void
1046 clear(void)
1047 {
1048     normal();
1049     kprintf("\033[H\033[J");
1050 }
1051
1052 static void
1053 move(int x, int y)
1054 {
1055     kprintf("\033[%d;%dH",y+1,x+1);
1056 }
1057
1058
1059 /**
1060  **
1061  ** High-level screen primitives :
1062  **
1063  ** putxyl(x,y,str,len) - put (len) bytes of (str) at (x,y), supports embedded formatting
1064  ** putxy(x,y,str)      - put (str) at (x,y), supports embedded formatting
1065  ** erase(x,y,w,h)      - clear the box (x,y,w,h)
1066  ** txtbox(x,y,w,y,str) - put (str) in a region at (x,y,w,h)
1067  ** putmsg(str)         - put (str) in the message area
1068  ** puthelp(str)        - put (str) in the upper helpline
1069  ** pad(str,len)        - pad (str) to (len) with spaces
1070  ** drawline(row,detail,list,inverse,*dhelp)
1071  **                     - draws a line for (*list) at (row) onscreen.  If (detail) is
1072  **                       nonzero, include port, IRQ and maddr, if (inverse) is nonzero,
1073  **                       draw the line in inverse video, and display (*dhelp) on the
1074  **                       helpline.
1075  ** drawlist(row,num,detail,list)
1076  **                     - draw (num) entries from (list) at (row) onscreen, passile (detail)
1077  **                       through to drawline().
1078  ** showparams(dev)     - displays the relevant parameters for (dev) below the lists onscreen.
1079  ** yesno(str)          - displays (str) in the message area, and returns nonzero on 'y' or 'Y'
1080  ** redraw();           - Redraws the entire screen layout, including the
1081  **                     - two list panels.
1082  **/
1083
1084 /**
1085  ** putxy
1086  **   writes (str) at x,y onscreen
1087  ** putxyl
1088  **   writes up to (len) of (str) at x,y onscreen.
1089  **
1090  ** Supports embedded formatting :
1091  ** !i - inverse mode.
1092  ** !b - bold mode.
1093  ** !n - normal mode.
1094  **/
1095 static void
1096 putxyl(int x, int y, char *str, int len)
1097 {
1098     move(x,y);
1099     normal();
1100
1101     while((*str) && (len--))
1102     {
1103         if (*str == '!')                /* format escape? */
1104         {
1105             switch(*(str+1))            /* depending on the next character */
1106             {
1107             case 'i':
1108                 inverse();
1109                 str +=2;                /* skip formatting */
1110                 len++;                  /* doesn't count for length */
1111                 break;
1112
1113             case 'b':
1114                 bold();
1115                 str  +=2;               /* skip formatting */
1116                 len++;                  /* doesn't count for length */
1117                 break;
1118
1119             case 'n':
1120                 normal();
1121                 str +=2;                /* skip formatting */
1122                 len++;                  /* doesn't count for length */
1123                 break;
1124
1125             default:
1126                 kprintf("%c", *str++);  /* not an escape */
1127             }
1128         }else{
1129             kprintf("%c", *str++);              /* emit the character */
1130         }
1131     }
1132 }
1133
1134 #define putxy(x,y,str)  putxyl(x,y,str,-1)
1135
1136
1137 /**
1138  ** erase
1139  **
1140  ** Erases the region (x,y,w,h)
1141  **/
1142 static void
1143 erase(int x, int y, int w, int h)
1144 {
1145     int         i;
1146
1147     normal();
1148     for (i = 0; i < h; i++)
1149         putxyl(x,y++,spaces,w);
1150 }
1151
1152
1153 /**
1154  ** txtbox
1155  **
1156  ** Writes (str) into the region (x,y,w,h), supports embedded formatting using
1157  ** putxy.  Lines are not wrapped, newlines must be forced with \n.
1158  **/
1159 static void
1160 txtbox(int x, int y, int w, int h, char *str)
1161 {
1162     int         i = 0;
1163
1164     h--;
1165     while((str[i]) && h)
1166     {
1167         if (str[i] == '\n')                     /* newline */
1168         {
1169             putxyl(x,y,str,(i<w)?i:w);          /* write lesser of i or w */
1170             y++;                                /* move down */
1171             h--;                                /* room for one less */
1172             str += (i+1);                       /* skip first newline */
1173             i = 0;                              /* zero offset */
1174         }else{
1175             i++;                                /* next character */
1176         }
1177     }
1178     if (h)                                      /* end of string, not region */
1179         putxyl(x,y,str,w);
1180 }
1181
1182
1183 /**
1184  ** putmsg
1185  **
1186  ** writes (msg) in the helptext area
1187  **/
1188 static void
1189 putmsg(char *msg)
1190 {
1191     erase(0,18,80,3);                           /* clear area */
1192     txtbox(0,18,80,3,msg);
1193 }
1194
1195
1196 /**
1197  ** puthelp
1198  **
1199  ** Writes (msg) in the helpline area
1200  **/
1201 static void
1202 puthelp(char *msg)
1203 {
1204     erase(0,22,80,1);
1205     putxy(0,22,msg);
1206 }
1207
1208
1209 /**
1210  ** masterhelp
1211  **
1212  ** Draws the help message at the bottom of the screen
1213  **/
1214 static void
1215 masterhelp(char *msg)
1216 {
1217     erase(0,23,80,1);
1218     putxy(0,23,msg);
1219 }
1220
1221
1222 /**
1223  ** pad
1224  **
1225  ** space-pads a (str) to (len) characters
1226  **/
1227 static void
1228 pad(char *str, int len)
1229 {
1230     int         i;
1231
1232     for (i = 0; str[i]; i++)                    /* find the end of the string */
1233         ;
1234     if (i >= len)                               /* no padding needed */
1235         return;
1236     while(i < len)                              /* pad */
1237         str[i++] = ' ';
1238     str[i] = '\0';
1239 }
1240
1241
1242 /**
1243  ** drawline
1244  **
1245  ** Displays entry (ofs) of (list) in region at (row) onscreen, optionally displaying
1246  ** the port and IRQ fields if (detail) is nonzero.  If (inverse), in inverse video.
1247  **
1248  ** The text (dhelp) is displayed if the item is a normal device, otherwise
1249  ** help is shown for normal or zoomed comments
1250  **/
1251 static void
1252 drawline(int row, int detail, DEV_LIST *list, int inverse, char *dhelp)
1253 {
1254     char        lbuf[90],nb[70],db[20],ib[16],pb[16];
1255
1256     if (list->comment == DEV_DEVICE)
1257     {
1258         nb[0] = ' ';
1259         strncpy(nb+1,list->name,57);
1260     }else{
1261         strncpy(nb,list->name,58);
1262         if ((list->comment == DEV_ZOOMED) && (list->next))
1263             if (list->next->comment == DEV_DEVICE)      /* only mention if there's something hidden */
1264                 strcat(nb,"  (Collapsed)");
1265     }
1266     nb[58] = '\0';
1267     pad(nb,60);
1268     if (list->conflicts)                        /* device in conflict? */
1269     {
1270         if (inverse)
1271         {
1272             strcpy(nb+54," !nCONF!i ");         /* tag conflict, careful of length */
1273         }else{
1274             strcpy(nb+54," !iCONF!n ");         /* tag conflict, careful of length */
1275         }
1276     }
1277     if (list->comment == DEV_DEVICE)
1278     {
1279         ksprintf(db,"%s%d",list->dev,list->unit);
1280         pad(db,8);
1281     }else{
1282         strcpy(db,"        ");
1283     }
1284     if ((list->irq > 0) && detail && (list->comment == DEV_DEVICE))
1285     {
1286         ksprintf(ib," %d",list->irq);
1287         pad(ib,4);
1288     }else{
1289         strcpy(ib,"    ");
1290     }
1291     if ((list->iobase > 0) && detail && (list->comment == DEV_DEVICE))
1292     {
1293         ksprintf(pb,"0x%x",list->iobase);
1294         pad(pb,7);
1295     }else{
1296         strcpy(pb,"       ");
1297     }
1298
1299     ksprintf(lbuf,"  %s%s%s%s%s",inverse?"!i":"",nb,db,ib,pb);
1300
1301     putxyl(0,row,lbuf,80);
1302     if (dhelp)
1303     {
1304         switch(list->comment)
1305         {
1306         case DEV_DEVICE:        /* ordinary device */
1307             puthelp(dhelp);
1308             break;
1309         case DEV_COMMENT:
1310             puthelp("");
1311             if (list->next)
1312                 if (list->next->comment == DEV_DEVICE)
1313                     puthelp("  [!bEnter!n] Collapse device list    [!bC!n]    Collapse all lists");
1314             break;
1315         case DEV_ZOOMED:
1316             puthelp("");
1317             if (list->next)
1318                 if (list->next->comment == DEV_DEVICE)
1319                     puthelp("  [!bEnter!n] Expand device list      [!bX!n]    Expand all lists");
1320             break;
1321         default:
1322             puthelp("  WARNING: This list entry corrupted!");
1323             break;
1324         }
1325     }
1326     move(0,row);                                /* put the cursor somewhere relevant */
1327 }
1328
1329
1330 /**
1331  ** drawlist
1332  **
1333  ** Displays (num) lines of the contents of (list) at (row), optionally
1334  ** displaying the port and IRQ fields as well if (detail) is nonzero.
1335  **/
1336 static void
1337 drawlist(int row, int num, int detail, DEV_LIST *list)
1338 {
1339     int         ofs;
1340
1341     for(ofs = 0; ofs < num; ofs++)
1342     {
1343         if (list)
1344         {
1345             drawline(row+ofs,detail,list,0,NULL);       /* NULL -> don't draw empty help string */
1346             list = nextent(list);                       /* move down visible list */
1347         }else{
1348             erase(0,row+ofs,80,1);
1349         }
1350     }
1351 }
1352
1353
1354 /**
1355  ** redrawactive
1356  **
1357  ** Redraws the active list
1358  **/
1359 static void
1360 redrawactive(void)
1361 {
1362     char        cbuf[16];
1363
1364     if (conflicts)
1365     {
1366         ksprintf(cbuf,"!i%d conflict%s-",conflicts,(conflicts>1)?"s":"");
1367         putxy(45,0,cbuf);
1368     }else{
1369         putxyl(45,0,lines,16);
1370     }
1371     drawlist(1,8,1,alist);                      /* draw device lists */
1372 }
1373
1374 /**
1375  ** redrawinactive
1376  **
1377  ** Redraws the inactive list
1378  **/
1379 static void
1380 redrawinactive(void)
1381 {
1382     drawlist(10,7,0,ilist);                     /* draw device lists */
1383 }
1384
1385
1386 /**
1387  ** redraw
1388  **
1389  ** Clear the screen and redraw the entire layout
1390  **/
1391 static void
1392 redraw(void)
1393 {
1394     clear();
1395     putxy(0,0,lines);
1396     putxy(3,0,"!bActive!n-!bDrivers");
1397     putxy(63,0,"!bDev!n---!bIRQ!n--!bPort");
1398     putxy(0,9,lines);
1399     putxy(3,9,"!bInactive!n-!bDrivers");
1400     putxy(63,9,"!bDev");
1401     putxy(0,17,lines);
1402     putxy(0,21,lines);
1403     masterhelp("  [!bTAB!n]   Change fields           [!bQ!n]   Save and Exit             [!b?!n] Help");
1404
1405     redrawactive();
1406     redrawinactive();
1407 }
1408
1409
1410 /**
1411  ** yesnocancel
1412  **
1413  ** Put (str) in the message area, and return 1 if the user hits 'y' or 'Y',
1414  ** 2 if they hit 'c' or 'C',  or 0 for 'n' or 'N'.
1415  **/
1416 static int
1417 yesnocancel(char *str)
1418 {
1419
1420     putmsg(str);
1421     for(;;)
1422         switch(kgetchar())
1423         {
1424         case -1:
1425         case 'n':
1426         case 'N':
1427             return(0);
1428
1429         case 'y':
1430         case 'Y':
1431             return(1);
1432
1433         case 'c':
1434         case 'C':
1435             return(2);
1436         }
1437 }
1438
1439
1440 /**
1441  ** showparams
1442  **
1443  ** Show device parameters in the region below the lists
1444  **
1445  **     0    5   10   15   20   25   30   35   40   45   50   55   60   67   70   75
1446  **     |....|....|....|....|....|....|....|....|....|....|....|....|....|....|....|....
1447  **    +--------------------------------------------------------------------------------+
1448  ** 17-|--------------------------------------------------------------------------------|
1449  ** 18-| Port address : 0x0000     Memory address : 0x00000   Conflict allowed          |
1450  ** 19-| IRQ number   : 00         Memory size    : 0x0000                              |
1451  ** 20-| Flags        : 0x0000     DRQ number     : 00                                  |
1452  ** 21-|--------------------------------------------------------------------------------|
1453  **/
1454 static void
1455 showparams(DEV_LIST *dev)
1456 {
1457     char        buf[80];
1458
1459     erase(0,18,80,3);                           /* clear area */
1460     if (!dev)
1461         return;
1462     if (dev->comment != DEV_DEVICE)
1463         return;
1464
1465
1466     if (dev->iobase > 0)
1467     {
1468         ksprintf(buf,"Port address : 0x%x",dev->iobase);
1469         putxy(1,18,buf);
1470     }
1471
1472     if (dev->irq > 0)
1473     {
1474         ksprintf(buf,"IRQ number   : %d",dev->irq);
1475         putxy(1,19,buf);
1476     }
1477     ksprintf(buf,"Flags        : 0x%x",dev->flags);
1478     putxy(1,20,buf);
1479     if (dev->maddr > 0)
1480     {
1481         ksprintf(buf,"Memory address : 0x%x",dev->maddr);
1482         putxy(26,18,buf);
1483     }
1484     if (dev->msize > 0)
1485     {
1486         ksprintf(buf,"Memory size    : 0x%x",dev->msize);
1487         putxy(26,19,buf);
1488     }
1489
1490     if (dev->drq > 0)
1491     {
1492         ksprintf(buf,"DRQ number     : %d",dev->drq);
1493         putxy(26,20,buf);
1494     }
1495 }
1496
1497
1498 /**
1499  ** Editing functions for device parameters
1500  **
1501  ** editval(x,y,width,hex,min,max,val)  - Edit (*val) in a field (width) wide at (x,y)
1502  **                                       onscreen.  Refuse values outsise (min) and (max).
1503  ** editparams(dev)                     - Edit the parameters for (dev)
1504  **/
1505
1506
1507 #define VetRet(code)                                                    \
1508 {                                                                       \
1509     if ((i >= min) && (i <= max))       /* legit? */                    \
1510     {                                                                   \
1511         *val = i;                                                       \
1512         ksprintf(buf,hex?"0x%x":"%d",i);                                \
1513         putxy(hex?x-2:x,y,buf);                                         \
1514         return(code);                   /* all done and exit */         \
1515     }                                                                   \
1516     i = *val;                           /* restore original value */    \
1517     delta = 1;                          /* restore other stuff */       \
1518 }
1519
1520
1521 /**
1522  ** editval
1523  **
1524  ** Edit (*val) at (x,y) in (hex)?hex:decimal mode, allowing values between (min) and (max)
1525  ** in a field (width) wide. (Allow one space)
1526  ** If (ro) is set, we're in "readonly" mode, so disallow edits.
1527  **
1528  ** Return KEY_TAB on \t, KEY_EXIT on 'q'
1529  **/
1530 static int
1531 editval(int x, int y, int width, int hex, int min, int max, int *val, int ro)
1532 {
1533     int         i = *val;                       /* work with copy of the value */
1534     char        buf[2+11+1],tc[11+1];           /* display buffer, text copy */
1535     int         xp = 0;                         /* cursor offset into text copy */
1536     int         delta = 1;                      /* force redraw first time in */
1537     int         c;
1538     int         extended = 0;                   /* stage counter for extended key sequences */
1539
1540     if (hex)                                    /* we presume there's a leading 0x onscreen */
1541         putxy(x-2,y,"!i0x");                    /* coz there sure is now */
1542
1543     for (;;)
1544     {
1545         if (delta)                              /* only update if necessary */
1546         {
1547             ksprintf(tc,hex?"%x":"%d",i);       /* make a text copy of the value */
1548             ksprintf(buf,"!i%s",tc);            /* format for printing */
1549             erase(x,y,width,1);                 /* clear the area */
1550             putxy(x,y,buf);                     /* write */
1551             xp = strlen(tc);                    /* cursor always at end */
1552             move(x+xp,y);                       /* position the cursor */
1553         }
1554
1555         c = kgetchar();
1556
1557         switch(extended)                        /* escape handling */
1558         {
1559         case 0:
1560             if (c == 0x1b)                      /* esc? */
1561             {
1562                 extended = 1;                   /* flag and spin */
1563                 continue;
1564             }
1565             extended = 0;
1566             break;                              /* nope, drop through */
1567
1568         case 1:                                 /* there was an escape prefix */
1569             if (c == '[' || c == 'O')           /* second character in sequence */
1570             {
1571                 extended = 2;
1572                 continue;
1573             }
1574             if (c == 0x1b)
1575                 return(KEY_EXIT);               /* double esc exits */
1576             extended = 0;
1577             break;                              /* nup, not a sequence. */
1578
1579         case 2:
1580             extended = 0;
1581             switch(c)                           /* looks like the real McCoy */
1582             {
1583             case 'A':
1584                 VetRet(KEY_UP);                 /* leave if OK */
1585                 continue;
1586             case 'B':
1587                 VetRet(KEY_DOWN);               /* leave if OK */
1588                 continue;
1589             case 'C':
1590                 VetRet(KEY_RIGHT);              /* leave if OK */
1591                 continue;
1592             case 'D':
1593                 VetRet(KEY_LEFT);               /* leave if OK */
1594                 continue;
1595
1596             default:
1597                 continue;
1598             }
1599         }
1600
1601         switch(c)
1602         {
1603         case '\t':                              /* trying to tab off */
1604             VetRet(KEY_TAB);                    /* verify and maybe return */
1605             break;
1606
1607         case -1:
1608         case 'q':
1609         case 'Q':
1610             VetRet(KEY_EXIT);
1611             break;
1612
1613         case '\b':
1614         case '\177':                            /* BS or DEL */
1615             if (ro)                             /* readonly? */
1616             {
1617                 puthelp(" !iThis value cannot be edited (Press ESC)");
1618                 while(kgetchar() != 0x1b);      /* wait for key */
1619                 return(KEY_NULL);               /* spin */
1620             }
1621             if (xp)                             /* still something left to delete */
1622             {
1623                 i = (hex ? i/0x10u : i/10);     /* strip last digit */
1624                 delta = 1;                      /* force update */
1625             }
1626             break;
1627
1628         case 588:
1629             VetRet(KEY_UP);
1630             break;
1631
1632         case '\r':
1633         case '\n':
1634         case 596:
1635             VetRet(KEY_DOWN);
1636             break;
1637
1638         case 591:
1639             VetRet(KEY_LEFT);
1640             break;
1641
1642         case 593:
1643             VetRet(KEY_RIGHT);
1644             break;
1645
1646         default:
1647             if (ro)                             /* readonly? */
1648             {
1649                 puthelp(" !iThis value cannot be edited (Press ESC)");
1650                 while(kgetchar() != 0x1b);      /* wait for key */
1651                 return(KEY_NULL);               /* spin */
1652             }
1653             if (xp >= width)                    /* no room for more characters anyway */
1654                 break;
1655             if (hex)
1656             {
1657                 if ((c >= '0') && (c <= '9'))
1658                 {
1659                     i = i*0x10 + (c-'0');       /* update value */
1660                     delta = 1;
1661                     break;
1662                 }
1663                 if ((c >= 'a') && (c <= 'f'))
1664                 {
1665                     i = i*0x10 + (c-'a'+0xa);
1666                     delta = 1;
1667                     break;
1668                 }
1669                 if ((c >= 'A') && (c <= 'F'))
1670                 {
1671                     i = i*0x10 + (c-'A'+0xa);
1672                     delta = 1;
1673                     break;
1674                 }
1675             }else{
1676                 if ((c >= '0') && (c <= '9'))
1677                 {
1678                     i = i*10 + (c-'0');         /* update value */
1679                     delta = 1;                  /* force redraw */
1680                     break;
1681                 }
1682             }
1683             break;
1684         }
1685     }
1686 }
1687
1688
1689 /**
1690  ** editparams
1691  **
1692  ** Edit the parameters for (dev)
1693  **
1694  ** Note that it's _always_ possible to edit the flags, otherwise it might be
1695  ** possible for this to spin in an endless loop...
1696  **     0    5   10   15   20   25   30   35   40   45   50   55   60   67   70   75
1697  **     |....|....|....|....|....|....|....|....|....|....|....|....|....|....|....|....
1698  **    +--------------------------------------------------------------------------------+
1699  ** 17-|--------------------------------------------------------------------------------|
1700  ** 18-| Port address : 0x0000     Memory address : 0x00000   Conflict allowed          |
1701  ** 19-| IRQ number   : 00         Memory size    : 0x0000                              |
1702  ** 20-| Flags        : 0x0000     DRQ number     : 00                                  |
1703  ** 21-|--------------------------------------------------------------------------------|
1704  **
1705  ** The "intelligence" in this function that hops around based on the directional
1706  ** returns from editval isn't very smart, and depends on the layout above.
1707  **/
1708 static void
1709 editparams(DEV_LIST *dev)
1710 {
1711     int         ret;
1712     char        buf[16];                /* needs to fit the device name */
1713
1714     putxy(2,17,"!bParameters!n-!bfor!n-!bdevice!n-");
1715     ksprintf(buf,"!b%s",dev->dev);
1716     putxy(24,17,buf);
1717
1718     erase(1,22,80,1);
1719     for (;;)
1720     {
1721     ep_iobase:
1722         if (dev->iobase > 0)
1723         {
1724             puthelp("  IO Port address (Hexadecimal, 0x1-0xffff)");
1725             ret = editval(18,18,5,1,0x1,0xffff,&(dev->iobase),(dev->attrib & FLG_FIXIOBASE));
1726             switch(ret)
1727             {
1728             case KEY_EXIT:
1729                 goto ep_exit;
1730
1731             case KEY_RIGHT:
1732                 if (dev->maddr > 0)
1733                     goto ep_maddr;
1734                 break;
1735
1736             case KEY_TAB:
1737             case KEY_DOWN:
1738                 goto ep_irq;
1739             }
1740             goto ep_iobase;
1741         }
1742     ep_irq:
1743         if (dev->irq > 0)
1744         {
1745             puthelp("  Interrupt number (Decimal, 1-15)");
1746             ret = editval(16,19,3,0,1,15,&(dev->irq),(dev->attrib & FLG_FIXIRQ));
1747             switch(ret)
1748             {
1749             case KEY_EXIT:
1750                 goto ep_exit;
1751
1752             case KEY_RIGHT:
1753                 if (dev->msize > 0)
1754                     goto ep_msize;
1755                 break;
1756
1757             case KEY_UP:
1758                 if (dev->iobase > 0)
1759                     goto ep_iobase;
1760                 break;
1761
1762             case KEY_TAB:
1763             case KEY_DOWN:
1764                 goto ep_flags;
1765             }
1766             goto ep_irq;
1767         }
1768     ep_flags:
1769         puthelp("  Device-specific flag values.");
1770         ret = editval(18,20,8,1,INT_MIN,INT_MAX,&(dev->flags),0);
1771         switch(ret)
1772         {
1773         case KEY_EXIT:
1774             goto ep_exit;
1775
1776         case KEY_RIGHT:
1777             if (dev->drq > 0)
1778                 goto ep_drq;
1779             break;
1780
1781         case KEY_UP:
1782             if (dev->irq > 0)
1783                 goto ep_irq;
1784             if (dev->iobase > 0)
1785                 goto ep_iobase;
1786             break;
1787
1788         case KEY_DOWN:
1789             if (dev->maddr > 0)
1790                 goto ep_maddr;
1791             if (dev->msize > 0)
1792                 goto ep_msize;
1793             if (dev->drq > 0)
1794                 goto ep_drq;
1795             break;
1796
1797         case KEY_TAB:
1798             goto ep_maddr;
1799         }
1800         goto ep_flags;
1801     ep_maddr:
1802         if (dev->maddr > 0)
1803         {
1804             puthelp("  Device memory start address (Hexadecimal, 0x1-0xfffff)");
1805             ret = editval(45,18,6,1,0x1,0xfffff,&(dev->maddr),(dev->attrib & FLG_FIXMADDR));
1806             switch(ret)
1807             {
1808             case KEY_EXIT:
1809                 goto ep_exit;
1810
1811             case KEY_LEFT:
1812                 if (dev->iobase > 0)
1813                     goto ep_iobase;
1814                 break;
1815
1816             case KEY_UP:
1817                 goto ep_flags;
1818
1819             case KEY_DOWN:
1820                 if (dev->msize > 0)
1821                     goto ep_msize;
1822                 if (dev->drq > 0)
1823                     goto ep_drq;
1824                 break;
1825
1826             case KEY_TAB:
1827                 goto ep_msize;
1828             }
1829             goto ep_maddr;
1830         }
1831     ep_msize:
1832         if (dev->msize > 0)
1833         {
1834             puthelp("  Device memory size (Hexadecimal, 0x1-0x10000)");
1835             ret = editval(45,19,5,1,0x1,0x10000,&(dev->msize),(dev->attrib & FLG_FIXMSIZE));
1836             switch(ret)
1837             {
1838             case KEY_EXIT:
1839                 goto ep_exit;
1840
1841             case KEY_LEFT:
1842                 if (dev->irq > 0)
1843                     goto ep_irq;
1844                 break;
1845
1846             case KEY_UP:
1847                 if (dev->maddr > 0)
1848                     goto ep_maddr;
1849                 goto ep_flags;
1850
1851             case KEY_DOWN:
1852                 if (dev->drq > 0)
1853                     goto ep_drq;
1854                 break;
1855
1856             case KEY_TAB:
1857                 goto ep_drq;
1858             }
1859             goto ep_msize;
1860         }
1861     ep_drq:
1862         if (dev->drq > 0)
1863         {
1864             puthelp("  Device DMA request number (Decimal, 1-7)");
1865             ret = editval(43,20,2,0,1,7,&(dev->drq),(dev->attrib & FLG_FIXDRQ));
1866             switch(ret)
1867             {
1868             case KEY_EXIT:
1869                 goto ep_exit;
1870
1871             case KEY_LEFT:
1872                 goto ep_flags;
1873
1874             case KEY_UP:
1875                 if (dev->msize > 0)
1876                     goto ep_msize;
1877                 if (dev->maddr > 0)
1878                     goto ep_maddr;
1879                 goto ep_flags;
1880
1881             case KEY_TAB:
1882                 goto ep_iobase;
1883             }
1884             goto ep_drq;
1885         }
1886     }
1887     ep_exit:
1888     dev->changed = 1;                                   /* mark as changed */
1889 }
1890
1891 static char *helptext[] =
1892 {
1893     "                Using the UserConfig kernel settings editor",
1894     "                -------------------------------------------",
1895     "",
1896     "VISUAL MODE:",
1897     "",
1898     "- - Layout -",
1899     "",
1900     "The screen displays a list of available drivers, divided into two",
1901     "scrolling lists: Active Drivers, and Inactive Drivers.  Each list is",
1902     "by default collapsed and can be expanded to show all the drivers",
1903     "available in each category.  The parameters for the currently selected",
1904     "driver are shown at the bottom of the screen.",
1905     "",
1906     "- - Moving around -",
1907     "",
1908     "To move in the current list, use the UP and DOWN cursor keys to select",
1909     "an item (the selected item will be highlighted).  If the item is a",
1910     "category name, you may alternatively expand or collapse the list of",
1911     "drivers for that category by pressing [!bENTER!n].  Once the category is",
1912     "expanded, you can select each driver in the same manner and either:",
1913     "",
1914     "  - change its parameters using [!bENTER!n]",
1915     "  - move it to the Inactive list using [!bDEL!n]",
1916     "",
1917     "Use the [!bTAB!n] key to toggle between the Active and Inactive list; if",
1918     "you need to move a driver from the Inactive list back to the Active",
1919     "one, select it in the Inactive list, using [!bTAB!n] to change lists if",
1920     "necessary, and press [!bENTER!n] -- the device will be moved back to",
1921     "its place in the Active list.",
1922     "",
1923     "- - Altering the list/parameters -",
1924     "",
1925     "Any drivers for devices not installed in your system should be moved",
1926     "to the Inactive list, until there are no remaining parameter conflicts",
1927     "between the drivers, as indicated at the top.",
1928     "",
1929     "Once the list of Active drivers only contains entries for the devices",
1930     "present in your system, you can set their parameters (Interrupt, DMA",
1931     "channel, I/O addresses).  To do this, select the driver and press",
1932     "[!bENTER!n]: it is now possible to edit the settings at the",
1933     "bottom of the screen.  Use [!bTAB!n] to change fields, and when you are",
1934     "finished, use [!bQ!n] to return to the list.",
1935     "",
1936     "- - Saving changes -",
1937     "",
1938     "When all settings seem correct, and you wish to proceed with the",
1939     "kernel device probing and boot, press [!bQ!n] -- you will be asked to",
1940     "confirm your choice.",
1941     "",
1942     NULL
1943 };
1944
1945
1946 /**
1947  ** helpscreen
1948  **
1949  ** Displays help text onscreen for people that are confused, using a simple
1950  ** pager.
1951  **/
1952 static void
1953 helpscreen(void)
1954 {
1955     int         topline = 0;                    /* where we are in the text */
1956     int         line = 0;                       /* last line we displayed */
1957     int         c, delta = 1;
1958     char        prompt[80];
1959
1960     for (;;)                                    /* loop until user quits */
1961     {
1962         /* display help text */
1963         if (delta)
1964         {
1965             clear();                            /* remove everything else */
1966             for (line = topline;
1967                  (line < (topline + 24)) && (helptext[line]);
1968                  line++)
1969                 putxy(0,line-topline,helptext[line]);
1970             delta = 0;
1971         }
1972
1973         /* prompt */
1974         ksprintf(prompt,"!i --%s-- [U]p [D]own [Q]uit !n",helptext[line] ? "MORE" : "END");
1975         putxy(0,24,prompt);
1976
1977         c = kgetchar();                         /* so what do they say? */
1978
1979         switch (c)
1980         {
1981         case 'u':
1982         case 'U':
1983         case 'b':
1984         case 'B':                               /* wired into 'more' users' fingers */
1985             if (topline > 0)                    /* room to go up? */
1986             {
1987                 topline -= 24;
1988                 if (topline < 0)                /* don't go too far */
1989                     topline = 0;
1990                 delta = 1;
1991             }
1992             break;
1993
1994         case 'd':
1995         case 'D':
1996         case ' ':                               /* expected by most people */
1997             if (helptext[line])                 /* maybe more below? */
1998             {
1999                 topline += 24;
2000                 delta = 1;
2001             }
2002             break;
2003
2004         case 'q':
2005         case 'Q':
2006             redraw();                           /* restore the screen */
2007             return;
2008         }
2009     }
2010 }
2011
2012
2013 /**
2014  ** High-level control functions
2015  **/
2016
2017
2018 /**
2019  ** dolist
2020  **
2021  ** Handle user movement within (*list) in the region starting at (row) onscreen with
2022  ** (num) lines, starting at (*ofs) offset from row onscreen.
2023  ** Pass (detail) on to drawing routines.
2024  **
2025  ** If the user hits a key other than a cursor key, maybe return a code.
2026  **
2027  ** (*list) points to the device at the top line in the region, (*ofs) is the
2028  ** position of the highlight within the region.  All routines below
2029  ** this take only a device and an absolute row : use ofsent() to find the
2030  ** device, and add (*ofs) to (row) to find the absolute row.
2031  **/
2032 static int
2033 dolist(int row, int num, int detail, int *ofs, DEV_LIST **list, char *dhelp)
2034 {
2035     int         extended = 0;
2036     int         c;
2037     DEV_LIST    *lp;
2038     int         delta = 1;
2039
2040     for(;;)
2041     {
2042         if (delta)
2043         {
2044             showparams(ofsent(*ofs,*list));                             /* show device parameters */
2045             drawline(row+*ofs,detail,ofsent(*ofs,*list),1,dhelp);       /* highlight current line */
2046             delta = 0;
2047         }
2048
2049         c = kgetchar();                         /* get a character */
2050         if ((extended == 2) || (c==588) || (c==596))    /* console gives "alternative" codes */
2051         {
2052             extended = 0;                       /* no longer */
2053             switch(c)
2054             {
2055             case 588:                           /* syscons' idea of 'up' */
2056             case 'A':                           /* up */
2057                 if (*ofs)                       /* just a move onscreen */
2058                 {
2059                     drawline(row+*ofs,detail,ofsent(*ofs,*list),0,dhelp);/* unhighlight current line */
2060                     (*ofs)--;                   /* move up */
2061                 }else{
2062                     lp = prevent(*list);        /* can we go up? */
2063                     if (!lp)                    /* no */
2064                         break;
2065                     *list = lp;                 /* yes, move up list */
2066                     drawlist(row,num,detail,*list);
2067                 }
2068                 delta = 1;
2069                 break;
2070
2071             case 596:                           /* dooby-do */
2072             case 'B':                           /* down */
2073                 lp = ofsent(*ofs,*list);        /* get current item */
2074                 if (!nextent(lp))
2075                     break;                      /* nothing more to move to */
2076                 drawline(row+*ofs,detail,ofsent(*ofs,*list),0,dhelp);   /* unhighlight current line */
2077                 if (*ofs < (num-1))             /* room to move onscreen? */
2078                 {
2079                     (*ofs)++;
2080                 }else{
2081                     *list = nextent(*list);     /* scroll region down */
2082                     drawlist(row,num,detail,*list);
2083                 }
2084                 delta = 1;
2085                 break;
2086             }
2087         }else{
2088             switch(c)
2089             {
2090             case '\033':
2091                 extended=1;
2092                 break;
2093
2094             case '[':                           /* cheat : always preceeds cursor move */
2095             case 'O':                           /* ANSI application key mode */
2096                 if (extended==1)
2097                     extended=2;
2098                 else
2099                     extended=0;
2100                 break;
2101
2102             case 'Q':
2103             case 'q':
2104                 return(KEY_EXIT);               /* user requests exit */
2105
2106             case '\r':
2107             case '\n':
2108                 return(KEY_DO);                 /* "do" something */
2109
2110             case '\b':
2111             case '\177':
2112             case 599:
2113                 return(KEY_DEL);                /* "delete" response */
2114
2115             case 'X':
2116             case 'x':
2117                 return(KEY_UNZOOM);             /* expand everything */
2118
2119             case 'C':
2120             case 'c':
2121                 return(KEY_ZOOM);               /* collapse everything */
2122
2123             case '\t':
2124                 drawline(row+*ofs,detail,ofsent(*ofs,*list),0,dhelp);   /* unhighlight current line */
2125                 return(KEY_TAB);                                /* "move" response */
2126
2127             case '\014':                        /* ^L, redraw */
2128                 return(KEY_REDRAW);
2129
2130             case '?':                           /* helptext */
2131                 return(KEY_HELP);
2132
2133             }
2134         }
2135     }
2136 }
2137
2138
2139 /**
2140  ** visuserconfig
2141  **
2142  ** Do the fullscreen config thang
2143  **/
2144 static int
2145 visuserconfig(void)
2146 {
2147     int actofs = 0, inactofs = 0, mode = 0, ret = -1, i;
2148     DEV_LIST    *dp;
2149
2150     initlist(&active);
2151     initlist(&inactive);
2152     alist = active;
2153     ilist = inactive;
2154
2155     getdevs();
2156
2157     conflicts = findconflict(active);           /* find conflicts in the active list only */
2158
2159     redraw();
2160
2161     for(;;)
2162     {
2163         switch(mode)
2164         {
2165         case 0:                                 /* active devices */
2166             ret = dolist(1,8,1,&actofs,&alist,
2167                          "  [!bEnter!n] Edit device parameters  [!bDEL!n] Disable device");
2168             switch(ret)
2169             {
2170             case KEY_TAB:
2171                 mode = 1;                       /* swap lists */
2172                 break;
2173
2174             case KEY_REDRAW:
2175                 redraw();
2176                 break;
2177
2178             case KEY_ZOOM:
2179                 alist = active;
2180                 actofs = 0;
2181                 expandlist(active);
2182                 redrawactive();
2183                 break;
2184
2185             case KEY_UNZOOM:
2186                 alist = active;
2187                 actofs = 0;
2188                 collapselist(active);
2189                 redrawactive();
2190                 break;
2191
2192             case KEY_DEL:
2193                 dp = ofsent(actofs,alist);      /* get current device */
2194                 if (dp)                         /* paranoia... */
2195                 {
2196                     if (dp->attrib & FLG_MANDATORY)     /* can't be deleted */
2197                         break;
2198                     if (dp == alist)            /* moving top item on list? */
2199                     {
2200                         if (dp->next)
2201                         {
2202                             alist = dp->next;   /* point list to non-moving item */
2203                         }else{
2204                             alist = dp->prev;   /* end of list, go back instead */
2205                         }
2206                     }else{
2207                         if (!dp->next)          /* moving last item on list? */
2208                             actofs--;
2209                     }
2210                     dp->conflicts = 0;          /* no conflicts on the inactive list */
2211                     movedev(dp,inactive);       /* shift to inactive list */
2212                     conflicts = findconflict(active);   /* update conflict tags */
2213                     dp->changed = 1;
2214                     redrawactive();                     /* redraw */
2215                     redrawinactive();
2216                 }
2217                 break;
2218
2219             case KEY_DO:                        /* edit device parameters */
2220                 dp = ofsent(actofs,alist);      /* get current device */
2221                 if (dp)                         /* paranoia... */
2222                 {
2223                     if (dp->comment == DEV_DEVICE)      /* can't edit comments, zoom? */
2224                     {
2225                         masterhelp("  [!bTAB!n]   Change fields           [!bQ!n]   Save device parameters");
2226                         editparams(dp);
2227                         masterhelp("  [!bTAB!n]   Change fields           [!bQ!n]   Save and Exit             [!b?!n] Help");
2228                         putxy(0,17,lines);
2229                         conflicts = findconflict(active);       /* update conflict tags */
2230                     }else{                              /* DO on comment = zoom */
2231                         switch(dp->comment)             /* Depends on current state */
2232                         {
2233                         case DEV_COMMENT:               /* not currently zoomed */
2234                             dp->comment = DEV_ZOOMED;
2235                             break;
2236
2237                         case DEV_ZOOMED:
2238                             dp->comment = DEV_COMMENT;
2239                             break;
2240                         }
2241                     }
2242                     redrawactive();
2243                 }
2244                 break;
2245             }
2246             break;
2247
2248         case 1:                                 /* inactive devices */
2249             ret = dolist(10,7,0,&inactofs,&ilist,
2250                          "  [!bEnter!n] Enable device                                   ");
2251             switch(ret)
2252             {
2253             case KEY_TAB:
2254                 mode = 0;
2255                 break;
2256
2257             case KEY_REDRAW:
2258                 redraw();
2259                 break;
2260
2261             case KEY_ZOOM:
2262                 ilist = inactive;
2263                 inactofs = 0;
2264                 expandlist(inactive);
2265                 redrawinactive();
2266                 break;
2267
2268             case KEY_UNZOOM:
2269                 ilist = inactive;
2270                 inactofs = 0;
2271                 collapselist(inactive);
2272                 redrawinactive();
2273                 break;
2274
2275             case KEY_DO:
2276                 dp = ofsent(inactofs,ilist);    /* get current device */
2277                 if (dp)                         /* paranoia... */
2278                 {
2279                     if (dp->comment == DEV_DEVICE)      /* can't move comments, zoom? */
2280                     {
2281                         if (dp == ilist)                /* moving top of list? */
2282                         {
2283                             if (dp->next)
2284                             {
2285                                 ilist = dp->next;       /* point list to non-moving item */
2286                             }else{
2287                                 ilist = dp->prev;       /* can't go down, go up instead */
2288                             }
2289                         }else{
2290                             if (!dp->next)              /* last entry on list? */
2291                                 inactofs--;             /* shift cursor up one */
2292                         }
2293
2294                         movedev(dp,active);             /* shift to active list */
2295                         conflicts = findconflict(active);       /* update conflict tags */
2296                         dp->changed = 1;
2297                         alist = dp;                     /* put at top and current */
2298                         actofs = 0;
2299                         while(dp->comment == DEV_DEVICE)
2300                             dp = dp->prev;              /* forcibly unzoom section */
2301                         dp ->comment = DEV_COMMENT;
2302                         mode = 0;                       /* and swap modes to follow it */
2303
2304                     }else{                              /* DO on comment = zoom */
2305                         switch(dp->comment)             /* Depends on current state */
2306                         {
2307                         case DEV_COMMENT:               /* not currently zoomed */
2308                             dp->comment = DEV_ZOOMED;
2309                             break;
2310
2311                         case DEV_ZOOMED:
2312                             dp->comment = DEV_COMMENT;
2313                             break;
2314                         }
2315                     }
2316                     redrawactive();                     /* redraw */
2317                     redrawinactive();
2318                 }
2319                 break;
2320
2321             default:                            /* nothing else relevant here */
2322                 break;
2323             }
2324             break;
2325         default:
2326             mode = 0;                           /* shouldn't happen... */
2327         }
2328
2329         /* handle returns that are the same for both modes */
2330         switch (ret) {
2331         case KEY_HELP:
2332             helpscreen();
2333             break;
2334
2335         case KEY_EXIT:
2336             i = yesnocancel(" Save these parameters before exiting? ([!bY!n]es/[!bN!n]o/[!bC!n]ancel) ");
2337             switch(i)
2338             {
2339             case 2:                             /* cancel */
2340                 redraw();
2341                 break;
2342
2343             case 1:                             /* save and exit */
2344                 savelist(active,1);
2345                 savelist(inactive,0);
2346
2347             case 0:                             /* exit */
2348                 nukelist(active);               /* clean up after ourselves */
2349                 nukelist(inactive);
2350                 normal();
2351                 clear();
2352                 return(1);
2353             }
2354             break;
2355         }
2356     }
2357 }
2358 #endif /* VISUAL_USERCONFIG */
2359
2360 /*
2361  * Copyright (c) 1991 Regents of the University of California.
2362  * All rights reserved.
2363  * Copyright (c) 1994 Jordan K. Hubbard
2364  * All rights reserved.
2365  * Copyright (c) 1994 David Greenman
2366  * All rights reserved.
2367  *
2368  * Many additional changes by Bruce Evans
2369  *
2370  * This code is derived from software contributed by the
2371  * University of California Berkeley, Jordan K. Hubbard,
2372  * David Greenman and Bruce Evans.
2373  *
2374  * Redistribution and use in source and binary forms, with or without
2375  * modification, are permitted provided that the following conditions
2376  * are met:
2377  * 1. Redistributions of source code must retain the above copyright
2378  *    notice, this list of conditions and the following disclaimer.
2379  * 2. Redistributions in binary form must reproduce the above copyright
2380  *    notice, this list of conditions and the following disclaimer in the
2381  *    documentation and/or other materials provided with the distribution.
2382  * 3. All advertising materials mentioning features or use of this software
2383  *    must display the following acknowledgement:
2384  *      This product includes software developed by the University of
2385  *      California, Berkeley and its contributors.
2386  * 4. Neither the name of the University nor the names of its contributors
2387  *    may be used to endorse or promote products derived from this software
2388  *    without specific prior written permission.
2389  *
2390  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
2391  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
2392  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
2393  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
2394  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
2395  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
2396  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2397  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
2398  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
2399  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2400  * SUCH DAMAGE.
2401  *
2402  * $FreeBSD: src/sys/i386/i386/userconfig.c,v 1.175.2.10 2002/10/05 18:31:48 scottl Exp $
2403  */
2404
2405 #define PARM_DEVSPEC    0x1
2406 #define PARM_INT        0x2
2407 #define PARM_ADDR       0x3
2408 #define PARM_STRING     0x4
2409
2410 typedef struct _cmdparm {
2411     int type;
2412     union {
2413         struct uc_device *dparm;
2414         int iparm;
2415         union {
2416                 void *aparm;
2417                 const char *sparm;
2418         } u;
2419     } parm;
2420 } CmdParm;
2421
2422 typedef int (*CmdFunc)(CmdParm *);
2423
2424 typedef struct _cmd {
2425     char *name;
2426     CmdFunc handler;
2427     CmdParm *parms;
2428 } Cmd;
2429
2430
2431 #if 0
2432 static void lsscsi(void);
2433 static int list_scsi(CmdParm *);
2434 #endif
2435
2436 static int lsdevtab(struct uc_device *);
2437 static struct uc_device *find_device(char *, int);
2438 static struct uc_device *search_devtable(struct uc_device *, char *, int);
2439 static void cngets(char *, int);
2440 static Cmd *parse_cmd(char *);
2441 static int parse_args(const char *, CmdParm *);
2442 static int save_dev(struct uc_device *);
2443
2444 static int list_devices(CmdParm *);
2445 static int set_device_ioaddr(CmdParm *);
2446 static int set_device_irq(CmdParm *);
2447 static int set_device_drq(CmdParm *);
2448 static int set_device_iosize(CmdParm *);
2449 static int set_device_mem(CmdParm *);
2450 static int set_device_flags(CmdParm *);
2451 static int set_device_enable(CmdParm *);
2452 static int set_device_disable(CmdParm *);
2453 static int quitfunc(CmdParm *);
2454 static int helpfunc(CmdParm *);
2455 static int introfunc(CmdParm *);
2456
2457 #if NPNP > 0
2458 static int lspnp(void);
2459 static int set_pnp_parms(CmdParm *);
2460 #endif
2461
2462 static int lineno;
2463
2464 static CmdParm addr_parms[] = {
2465     { PARM_DEVSPEC, {} },
2466     { PARM_ADDR, {} },
2467     { -1, {} },
2468 };
2469
2470 static CmdParm int_parms[] = {
2471     { PARM_DEVSPEC, {} },
2472     { PARM_INT, {} },
2473     { -1, {} },
2474 };
2475
2476 static CmdParm dev_parms[] = {
2477     { PARM_DEVSPEC, {} },
2478     { -1, {} },
2479 };
2480
2481 #if NPNP > 0
2482 static CmdParm string_arg[] = {
2483     { PARM_STRING, {} },
2484     { -1, {} },
2485 };
2486 #endif
2487
2488 static Cmd CmdList[] = {
2489     { "?",      helpfunc,               NULL },         /* ? (help)     */
2490     { "di",     set_device_disable,     dev_parms },    /* disable dev  */
2491     { "dr",     set_device_drq,         int_parms },    /* drq dev #    */
2492     { "en",     set_device_enable,      dev_parms },    /* enable dev   */
2493     { "ex",     quitfunc,               NULL },         /* exit (quit)  */
2494     { "f",      set_device_flags,       int_parms },    /* flags dev mask */
2495     { "h",      helpfunc,               NULL },         /* help         */
2496     { "intro",  introfunc,              NULL },         /* intro screen */
2497     { "iom",    set_device_mem,         addr_parms },   /* iomem dev addr */
2498     { "ios",    set_device_iosize,      int_parms },    /* iosize dev size */
2499     { "ir",     set_device_irq,         int_parms },    /* irq dev #    */
2500     { "l",      list_devices,           NULL },         /* ls, list     */
2501 #if NPNP > 0
2502     { "pn",     set_pnp_parms,          string_arg },   /* pnp ... */
2503 #endif
2504     { "po",     set_device_ioaddr,      int_parms },    /* port dev addr */
2505     { "res",    (CmdFunc)cpu_reset,     NULL },         /* reset CPU    */
2506     { "q",      quitfunc,               NULL },         /* quit         */
2507 #if 0
2508     { "s",      list_scsi,              NULL },         /* scsi */
2509 #endif
2510 #ifdef VISUAL_USERCONFIG
2511     { "v",      (CmdFunc)visuserconfig, NULL },         /* visual mode */
2512 #endif
2513     { NULL,     NULL,                   NULL },
2514 };
2515
2516 void
2517 userconfig(void)
2518 {
2519     static char banner = 1;
2520     char input[80];
2521     int rval;
2522     Cmd *cmd;
2523
2524     load_devtab();
2525     init_config_script();
2526     while (1) {
2527
2528         /* Only display signon banner if we are about to go interactive */
2529         if (!has_config_script()) {
2530             if (!(boothowto & RB_CONFIG))
2531 #ifdef INTRO_USERCONFIG
2532                 banner = 0;
2533 #else
2534                 return;
2535 #endif
2536             if (banner) {
2537                 banner = 0;
2538                 kprintf("FreeBSD Kernel Configuration Utility - Version 1.2\n"
2539                        " Type \"help\" for help"
2540 #ifdef VISUAL_USERCONFIG
2541                        " or \"visual\" to go to the visual\n"
2542                        " configuration interface (requires MGA/VGA display or\n"
2543                        " serial terminal capable of displaying ANSI graphics)"
2544 #endif
2545                        ".\n");
2546             }
2547         }
2548
2549         kprintf("config> ");
2550         cngets(input, 80);
2551         if (input[0] == '\0')
2552             continue;
2553         cmd = parse_cmd(input);
2554         if (!cmd) {
2555             kprintf("Invalid command or syntax.  Type `?' for help.\n");
2556             continue;
2557         }
2558         rval = (*cmd->handler)(cmd->parms);
2559         if (rval) {
2560             free_devtab();
2561             return;
2562         }
2563     }
2564 }
2565
2566 static Cmd *
2567 parse_cmd(char *cmd)
2568 {
2569     Cmd *cp;
2570
2571     for (cp = CmdList; cp->name; cp++) {
2572         int len = strlen(cp->name);
2573
2574         if (!strncmp(cp->name, cmd, len)) {
2575             while (*cmd && *cmd != ' ' && *cmd != '\t')
2576                 ++cmd;
2577             if (parse_args(cmd, cp->parms))
2578                 return NULL;
2579             else
2580                 return cp;
2581         }
2582     }
2583     return NULL;
2584 }
2585
2586 static int
2587 parse_args(const char *cmd, CmdParm *parms)
2588 {
2589     while (1) {
2590         char *ptr;
2591
2592         if (*cmd == ' ' || *cmd == '\t') {
2593             ++cmd;
2594             continue;
2595         }
2596         if (parms == NULL || parms->type == -1) {
2597                 if (*cmd == '\0')
2598                         return 0;
2599                 kprintf("Extra arg(s): %s\n", cmd);
2600                 return 1;
2601         }
2602         if (parms->type == PARM_DEVSPEC) {
2603             int i = 0;
2604             char devname[64];
2605             int unit = 0;
2606
2607             while (*cmd && !(*cmd == ' ' || *cmd == '\t' ||
2608               (*cmd >= '0' && *cmd <= '9')))
2609                 devname[i++] = *(cmd++);
2610             devname[i] = '\0';
2611             if (*cmd >= '0' && *cmd <= '9') {
2612                 unit = strtoul(cmd, &ptr, 10);
2613                 if (cmd == ptr) {
2614                     kprintf("Invalid device number\n");
2615                     /* XXX should print invalid token here and elsewhere. */
2616                     return 1;
2617                 }
2618                 /* XXX else should require end of token. */
2619                 cmd = ptr;
2620             }
2621             if ((parms->parm.dparm = find_device(devname, unit)) == NULL) {
2622                 kprintf("No such device: %s%d\n", devname, unit);
2623                 return 1;
2624             }
2625             ++parms;
2626             continue;
2627         }
2628         if (parms->type == PARM_INT) {
2629             parms->parm.iparm = strtoul(cmd, &ptr, 0);
2630             if (cmd == ptr) {
2631                 kprintf("Invalid numeric argument\n");
2632                 return 1;
2633             }
2634             cmd = ptr;
2635             ++parms;
2636             continue;
2637         }
2638         if (parms->type == PARM_ADDR) {
2639             parms->parm.u.aparm = (void *)(uintptr_t)strtoul(cmd, &ptr, 0);
2640             if (cmd == ptr) {
2641                 kprintf("Invalid address argument\n");
2642                 return 1;
2643             }
2644             cmd = ptr;
2645             ++parms;
2646             continue;
2647         }
2648         if (parms->type == PARM_STRING) {
2649             parms->parm.u.sparm = cmd;
2650             return 0;
2651         }
2652     }
2653     return 0;
2654 }
2655
2656 static int
2657 list_devices(CmdParm *parms)
2658 {
2659     lineno = 0;
2660     if (lsdevtab(uc_devtab)) return 0;
2661 #if NPNP > 0
2662     if (lspnp()) return 0;
2663 #endif
2664     return 0;
2665 }
2666
2667 static int
2668 set_device_ioaddr(CmdParm *parms)
2669 {
2670     parms[0].parm.dparm->id_iobase = parms[1].parm.iparm;
2671     save_dev(parms[0].parm.dparm);
2672     return 0;
2673 }
2674
2675 static int
2676 set_device_irq(CmdParm *parms)
2677 {
2678     unsigned irq;
2679
2680     irq = parms[1].parm.iparm;
2681     if (irq == 2) {
2682         kprintf("Warning: Remapping IRQ 2 to IRQ 9\n");
2683         irq = 9;
2684     }
2685     else if (irq != -1 && irq > 15) {
2686         kprintf("An IRQ > 15 would be invalid.\n");
2687         return 0;
2688     }
2689     parms[0].parm.dparm->id_irq = (irq < 16 ? 1 << irq : 0);
2690     save_dev(parms[0].parm.dparm);
2691     return 0;
2692 }
2693
2694 static int
2695 set_device_drq(CmdParm *parms)
2696 {
2697     unsigned drq;
2698
2699     /*
2700      * The bounds checking is just to ensure that the value can be printed
2701      * in 5 characters.  32768 gets converted to -32768 and doesn't fit.
2702      */
2703     drq = parms[1].parm.iparm;
2704     parms[0].parm.dparm->id_drq = (drq < 32768 ? drq : -1);
2705     save_dev(parms[0].parm.dparm);
2706     return 0;
2707 }
2708
2709 static int
2710 set_device_iosize(CmdParm *parms)
2711 {
2712     parms[0].parm.dparm->id_msize = parms[1].parm.iparm;
2713     save_dev(parms[0].parm.dparm);
2714     return 0;
2715 }
2716
2717 static int
2718 set_device_mem(CmdParm *parms)
2719 {
2720     parms[0].parm.dparm->id_maddr = parms[1].parm.u.aparm;
2721     save_dev(parms[0].parm.dparm);
2722     return 0;
2723 }
2724
2725 static int
2726 set_device_flags(CmdParm *parms)
2727 {
2728     parms[0].parm.dparm->id_flags = parms[1].parm.iparm;
2729     save_dev(parms[0].parm.dparm);
2730     return 0;
2731 }
2732
2733 static int
2734 set_device_enable(CmdParm *parms)
2735 {
2736     parms[0].parm.dparm->id_enabled = TRUE;
2737     save_dev(parms[0].parm.dparm);
2738     return 0;
2739 }
2740
2741 static int
2742 set_device_disable(CmdParm *parms)
2743 {
2744     parms[0].parm.dparm->id_enabled = FALSE;
2745     save_dev(parms[0].parm.dparm);
2746     return 0;
2747 }
2748
2749 #if NPNP > 0
2750
2751 static int
2752 sysctl_machdep_uc_pnplist(SYSCTL_HANDLER_ARGS)
2753 {
2754         int error=0;
2755
2756         if(!req->oldptr) {
2757                 /* Only sizing */
2758                 return(SYSCTL_OUT(req,0,sizeof(struct pnp_cinfo)*MAX_PNP_LDN));
2759         } else {
2760                 /*
2761                  * Output the pnp_ldn_overrides[] table.
2762                  */
2763                 error=sysctl_handle_opaque(oidp,&pnp_ldn_overrides,
2764                         sizeof(struct pnp_cinfo)*MAX_PNP_LDN,req);
2765                 if(error) return(error);
2766                 return(0);
2767         }
2768 }
2769
2770 SYSCTL_PROC( _machdep, OID_AUTO, uc_pnplist, CTLFLAG_RD,
2771         0, 0, sysctl_machdep_uc_pnplist, "A",
2772         "List of PnP overrides changed in UserConfig");
2773
2774 /*
2775  * this function sets the kernel table to override bios PnP
2776  * configuration.
2777  */
2778 static int
2779 set_pnp_parms(CmdParm *parms)
2780 {
2781     u_long idx, val, ldn, csn;
2782     int i;
2783     char *q;
2784     const char *p = parms[0].parm.u.sparm;
2785     struct pnp_cinfo d;
2786
2787     csn=strtoul(p,&q, 0);
2788     ldn=strtoul(q,&q, 0);
2789     for (p=q; *p && (*p==' ' || *p=='\t'); p++) ;
2790     if (csn < 1 || csn > MAX_PNP_CARDS || ldn >= MAX_PNP_LDN) {
2791         kprintf("bad csn/ldn %ld:%ld\n", csn, ldn);
2792         return 0;
2793     }
2794     for (i=0; i < MAX_PNP_LDN; i++) {
2795         if (pnp_ldn_overrides[i].csn == csn &&
2796             pnp_ldn_overrides[i].ldn == ldn)
2797                 break;
2798     }
2799     if (i==MAX_PNP_LDN) {
2800         for (i=0; i < MAX_PNP_LDN; i++) {
2801             if (pnp_ldn_overrides[i].csn <1 ||
2802                  pnp_ldn_overrides[i].csn > MAX_PNP_CARDS)
2803                  break;
2804         }
2805     }
2806     if (i==MAX_PNP_LDN) {
2807         kprintf("sorry, no PnP entries available, try delete one\n");
2808         return 0 ;
2809     }
2810     d = pnp_ldn_overrides[i] ;
2811     d.csn = csn;
2812     d.ldn = ldn ;
2813     while (*p) {
2814         idx = 0;
2815         val = 0;
2816         if (!strncmp(p,"irq",3)) {
2817             idx=strtoul(p+3,&q, 0);
2818             val=strtoul(q,&q, 0);
2819             if (idx >=0 && idx < 2) d.irq[idx] = val;
2820         } else if (!strncmp(p,"flags",5)) {
2821             idx=strtoul(p+5,&q, 0);
2822             d.flags = idx;
2823         } else if (!strncmp(p,"drq",3)) {
2824             idx=strtoul(p+3,&q, 0);
2825             val=strtoul(q,&q, 0);
2826             if (idx >=0 && idx < 2) d.drq[idx] = val;
2827         } else if (!strncmp(p,"port",4)) {
2828             idx=strtoul(p+4,&q, 0);
2829             val=strtoul(q,&q, 0);
2830             if (idx >=0 && idx < 8) d.port[idx] = val;
2831         } else if (!strncmp(p,"mem",3)) {
2832             idx=strtoul(p+3,&q, 0);
2833             val=strtoul(q,&q, 0);
2834             if (idx >=0 && idx < 4) d.mem[idx].base = val;
2835         } else if (!strncmp(p,"bios",4)) {
2836             q = p+ 4;
2837             d.override = 0 ;
2838         } else if (!strncmp(p,"os",2)) {
2839             q = p+2 ;
2840             d.override = 1 ;
2841         } else if (!strncmp(p,"disable",7)) {
2842             q = p+7 ;
2843             d.enable = 0 ;
2844         } else if (!strncmp(p,"enable",6)) {
2845             q = p+6;
2846             d.enable = 1 ;
2847         } else if (!strncmp(p,"delete",6)) {
2848             bzero(&pnp_ldn_overrides[i], sizeof (pnp_ldn_overrides[i]));
2849             if (i==0) pnp_ldn_overrides[i].csn = 255;/* not reinit */
2850             return 0;
2851         } else {
2852             kprintf("unknown command <%s>\n", p);
2853             break;
2854         }
2855         for (p=q; *p && (*p==' ' || *p=='\t'); p++) ;
2856     }
2857     pnp_ldn_overrides[i] = d ;
2858     return 0;
2859 }
2860 #endif /* NPNP */
2861
2862 static int
2863 quitfunc(CmdParm *parms)
2864 {
2865     /*
2866      * If kernel config supplied, and we are parsing it, and -c also supplied,
2867      * ignore a quit command,  This provides a safety mechanism to allow
2868      * recovery from a damaged/buggy kernel config.
2869      */
2870     if ((boothowto & RB_CONFIG) && userconfig_boot_parsing)
2871         return 0;
2872     return 1;
2873 }
2874
2875 static int
2876 helpfunc(CmdParm *parms)
2877 {
2878     kprintf(
2879     "Command\t\t\tDescription\n"
2880     "-------\t\t\t-----------\n"
2881     "ls\t\t\tList currently configured devices\n"
2882     "port <devname> <addr>\tSet device port (i/o address)\n"
2883     "irq <devname> <number>\tSet device irq\n"
2884     "drq <devname> <number>\tSet device drq\n"
2885     "iomem <devname> <addr>\tSet device maddr (memory address)\n"
2886     "iosize <devname> <size>\tSet device memory size\n"
2887     "flags <devname> <mask>\tSet device flags\n"
2888     "enable <devname>\tEnable device\n"
2889     "disable <devname>\tDisable device (will not be probed)\n");
2890 #if NPNP > 0
2891     kprintf(
2892     "pnp <csn> <ldn> [enable|disable]\tenable/disable device\n"
2893     "pnp <csn> <ldn> [os|bios]\tset parameters using FreeBSD or BIOS\n"
2894     "pnp <csn> <ldn> [portX <addr>]\tset addr for port X (0..7)\n"
2895     "pnp <csn> <ldn> [memX <maddr>]\tset addr for memory range X (0..3)\n"
2896     "pnp <csn> <ldn> [irqX <number>]\tset irq X (0..1) to number, 0=unused\n"
2897     "pnp <csn> <ldn> [drqX <number>]\tset drq X (0..1) to number, 4=unused\n");
2898 #endif
2899     kprintf(
2900     "quit\t\t\tExit this configuration utility\n"
2901     "reset\t\t\tReset CPU\n");
2902 #ifdef VISUAL_USERCONFIG
2903     kprintf("visual\t\t\tGo to fullscreen mode.\n");
2904 #endif
2905     kprintf(
2906     "help\t\t\tThis message\n\n"
2907     "Commands may be abbreviated to a unique prefix\n");
2908     return 0;
2909 }
2910
2911 #if defined (VISUAL_USERCONFIG)
2912 static void
2913 center(int y, char *str)
2914 {
2915     putxy((80 - strlen(str)) / 2, y, str);
2916 }
2917 #endif
2918
2919 static int
2920 introfunc(CmdParm *parms)
2921 {
2922 #if defined (VISUAL_USERCONFIG)
2923     int curr_item, first_time, extended = 0;
2924     static char *choices[] = {
2925         " Skip kernel configuration and continue with installation ",
2926         " Start kernel configuration in full-screen visual mode    ",
2927         " Start kernel configuration in CLI mode                   ",
2928     };
2929
2930     clear();
2931     center(2, "!bKernel Configuration Menu!n");
2932
2933     curr_item = 0;
2934     first_time = 1;
2935     while (1) {
2936         char tmp[80];
2937         int c, i;
2938
2939         if (!extended) {
2940             for (i = 0; i < 3; i++) {
2941                 tmp[0] = '\0';
2942                 if (curr_item == i)
2943                     strcpy(tmp, "!i");
2944                 strcat(tmp, choices[i]);
2945                 if (curr_item == i)
2946                     strcat(tmp, "!n");
2947                 putxy(10, 5 + i, tmp);
2948             }
2949
2950             if (first_time) {
2951                 putxy(2, 10, "Here you have the chance to go into kernel configuration mode, making");
2952                 putxy(2, 11, "any changes which may be necessary to properly adjust the kernel to");
2953                 putxy(2, 12, "match your hardware configuration.");
2954                 putxy(2, 14, "If you are installing FreeBSD for the first time, select Visual Mode");
2955                 putxy(2, 15, "(press Down-Arrow then ENTER).");
2956                 putxy(2, 17, "If you need to do more specialized kernel configuration and are an");
2957                 putxy(2, 18, "experienced FreeBSD user, select CLI mode.");
2958                 putxy(2, 20, "If you are !icertain!n that you do not need to configure your kernel");
2959                 putxy(2, 21, "then simply press ENTER or Q now.");
2960                 first_time = 0;
2961             }
2962
2963             move(0, 0); /* move the cursor out of the way */
2964         }
2965         c = kgetchar();
2966         if ((extended == 2) || (c == 588) || (c == 596)) {      /* console gives "alternative" codes */
2967             extended = 0;               /* no longer */
2968             switch (c) {
2969             case 588:
2970             case 'A':                           /* up */
2971                 if (curr_item > 0)
2972                     --curr_item;
2973                 break;
2974
2975             case 596:
2976             case 'B':                           /* down */
2977                 if (curr_item < 2)
2978                     ++curr_item;
2979                 break;
2980             }
2981         }
2982         else {
2983             switch(c) {
2984             case '\033':
2985                 extended = 1;
2986                 break;
2987
2988             case '[':                           /* cheat : always preceeds cursor move */
2989             case 'O':                           /* ANSI application key mode */
2990                 if (extended == 1)
2991                     extended = 2;
2992                 else
2993                     extended = 0;
2994                 break;
2995
2996             case -1:
2997             case 'Q':
2998             case 'q':
2999                 clear();
3000                 return 1;       /* user requests exit */
3001
3002             case '1':                           /* select an item */
3003             case 'S':
3004             case 's':
3005                 curr_item = 0;
3006                 break;
3007             case '2':
3008             case 'V':
3009             case 'v':
3010                 curr_item = 1;
3011                 break;
3012             case '3':
3013             case 'C':
3014             case 'c':
3015                 curr_item = 2;
3016                 break;
3017
3018             case 'U':                           /* up */
3019             case 'u':
3020             case 'P':
3021             case 'p':
3022                 if (curr_item > 0)
3023                     --curr_item;
3024                 break;
3025
3026             case 'D':                           /* down */
3027             case 'd':
3028             case 'N':
3029             case 'n':
3030                 if (curr_item < 2)
3031                     ++curr_item;
3032                 break;
3033
3034             case '\r':
3035             case '\n':
3036                 clear();
3037                 if (!curr_item)
3038                     return 1;
3039                 else if (curr_item == 1)
3040                     return visuserconfig();
3041                 else {
3042                     putxy(0, 1, "Type \"help\" for help or \"quit\" to exit.");
3043                     /* enable quitfunc */
3044                     userconfig_boot_parsing=0;
3045                     move (0, 3);
3046                     boothowto |= RB_CONFIG;     /* force -c */
3047                     return 0;
3048                 }
3049                 break;
3050             }
3051         }
3052     }
3053 #endif
3054 }
3055
3056 #if NPNP > 0
3057 static int
3058 lspnp(void)
3059 {
3060     struct pnp_cinfo *c;
3061     int i, first = 1;
3062
3063
3064     for (i=0; i< MAX_PNP_LDN; i++) {
3065         c = &pnp_ldn_overrides[i];
3066         if (c->csn >0 && c->csn != 255) {
3067             int pmax, mmax;
3068             static char pfmt[] =
3069                 "port 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x ";
3070             static char mfmt[] =
3071                 "mem 0x%x 0x%x 0x%x 0x%x";
3072             char buf[256];
3073             if (lineno >= 23) {
3074                     if (!userconfig_boot_parsing) {
3075                             kprintf("<More> ");
3076                             if (kgetchar() == 'q') {
3077                                     kprintf("quit\n");
3078                                     return (1);
3079                             }
3080                             kprintf("\n");
3081                     }
3082                     lineno = 0;
3083             }
3084             if (lineno == 0 || first)
3085                 kprintf("CSN LDN conf en irqs  drqs others (PnP devices)\n");
3086             first = 0 ;
3087             kprintf("%3d %3d %4s %2s %2d %-2d %2d %-2d ",
3088                 c->csn, c->ldn,
3089                 c->override ? "OS  ":"BIOS",
3090                 c->enable ? "Y":"N",
3091                 c->irq[0], c->irq[1], c->drq[0], c->drq[1]);
3092             if (c->flags)
3093                 kprintf("flags 0x%08lx ",c->flags);
3094             for (pmax = 7; pmax >=0 ; pmax--)
3095                 if (c->port[pmax]!=0) break;
3096             for (mmax = 3; mmax >=0 ; mmax--)
3097                 if (c->mem[mmax].base!=0) break;
3098             if (pmax>=0) {
3099                 strcpy(buf, pfmt);
3100                 buf[10 + 5*pmax]='\0';
3101                 kprintf(buf,
3102                     c->port[0], c->port[1], c->port[2], c->port[3],
3103                     c->port[4], c->port[5], c->port[6], c->port[7]);
3104             }
3105             if (mmax>=0) {
3106                 strcpy(buf, mfmt);
3107                 buf[8 + 5*mmax]='\0';
3108                 kprintf(buf,
3109                     c->mem[0].base, c->mem[1].base,
3110                     c->mem[2].base, c->mem[3].base);
3111             }
3112             kprintf("\n");
3113         }
3114     }
3115     return 0 ;
3116 }
3117 #endif /* NPNP */
3118
3119 static int
3120 lsdevtab(struct uc_device *dt)
3121 {
3122     for (; dt->id_id != 0; dt++) {
3123         char dname[80];
3124
3125         if (lineno >= 23) {
3126                 kprintf("<More> ");
3127                 if (!userconfig_boot_parsing) {
3128                         if (kgetchar() == 'q') {
3129                                 kprintf("quit\n");
3130                                 return (1);
3131                         }
3132                         kprintf("\n");
3133                 }
3134                 lineno = 0;
3135         }
3136         if (lineno == 0) {
3137                 kprintf(
3138 "Device   port       irq   drq   iomem   iosize   unit  flags      enab\n"
3139                     );
3140                 ++lineno;
3141         }
3142         ksprintf(dname, "%s%d", dt->id_name, dt->id_unit);
3143         kprintf("%-9.9s%-#11x%-6d%-6d%-8p%-9d%-6d%-#11x%-5s\n",
3144             dname, /* dt->id_id, dt->id_driver(by name), */ dt->id_iobase,
3145             ffs(dt->id_irq) - 1, dt->id_drq, dt->id_maddr, dt->id_msize,
3146             /* dt->id_intr(by name), */ dt->id_unit, dt->id_flags,
3147             dt->id_enabled ? "Yes" : "No");
3148         ++lineno;
3149     }
3150     return(0);
3151 }
3152
3153 static void
3154 load_devtab(void)
3155 {
3156     int i, val;
3157     int count = resource_count();
3158     int id = 1;
3159     int dt;
3160     char *name;
3161     int unit;
3162
3163     uc_devtab = kmalloc(sizeof(struct uc_device)*(count + 1), M_DEVL,
3164         M_WAITOK | M_ZERO);
3165     dt = 0;
3166     for (i = 0; i < count; i++) {
3167         name = resource_query_name(i);
3168         unit = resource_query_unit(i);
3169         if (unit < 0)
3170             continue;   /* skip wildcards */
3171         uc_devtab[dt].id_id = id++;
3172         resource_int_value(name, unit, "port", &uc_devtab[dt].id_iobase);
3173         val = 0;
3174         resource_int_value(name, unit, "irq", &val);
3175         uc_devtab[dt].id_irq = (1 << val);
3176         resource_int_value(name, unit, "drq", &uc_devtab[dt].id_drq);
3177         resource_int_value(name, unit, "maddr",(int *)&uc_devtab[dt].id_maddr);
3178         resource_int_value(name, unit, "msize", &uc_devtab[dt].id_msize);
3179         uc_devtab[dt].id_unit = unit;
3180         resource_int_value(name, unit, "flags", &uc_devtab[dt].id_flags);
3181         val = 0;
3182         resource_int_value(name, unit, "disabled", &val);
3183         uc_devtab[dt].id_enabled = !val;
3184         uc_devtab[dt].id_name = kmalloc(strlen(name) + 1, M_DEVL,M_WAITOK);
3185         strcpy(uc_devtab[dt].id_name, name);
3186         dt++;
3187     }
3188 }
3189
3190 static void
3191 free_devtab(void)
3192 {
3193     int i;
3194     int count = resource_count();
3195
3196     for (i = 0; i < count; i++)
3197         if (uc_devtab[i].id_name)
3198             kfree(uc_devtab[i].id_name, M_DEVL);
3199     kfree(uc_devtab, M_DEVL);
3200 }
3201
3202 static struct uc_device *
3203 find_device(char *devname, int unit)
3204 {
3205     struct uc_device *ret;
3206
3207     if ((ret = search_devtable(uc_devtab, devname, unit)) != NULL)
3208         return ret;
3209     return NULL;
3210 }
3211
3212 static struct uc_device *
3213 search_devtable(struct uc_device *dt, char *devname, int unit)
3214 {
3215     for (; dt->id_id != 0; dt++)
3216         if (!strcmp(dt->id_name, devname) && dt->id_unit == unit)
3217             return dt;
3218     return NULL;
3219 }
3220
3221 static void
3222 cngets(char *input, int maxin)
3223 {
3224     int c, nchars = 0;
3225
3226     while (1) {
3227         c = kgetchar();
3228         /* Treat ^H or ^? as backspace */
3229         if ((c == '\010' || c == '\177')) {
3230                 if (nchars) {
3231                         kprintf("\010 \010");
3232                         *--input = '\0', --nchars;
3233                 }
3234                 continue;
3235         }
3236         /* Treat ^U or ^X as kill line */
3237         else if ((c == '\025' || c == '\030')) {
3238                 while (nchars) {
3239                         kprintf("\010 \010");
3240                         *--input = '\0', --nchars;
3241                 }
3242                 continue;
3243         }
3244         kprintf("%c", c);
3245         if ((++nchars == maxin) || (c == '\n') || (c == '\r') || ( c == -1)) {
3246             *input = '\0';
3247             break;
3248         }
3249         *input++ = (u_char)c;
3250     }
3251 }
3252
3253
3254 #if 0
3255 /* scsi: Support for displaying configured SCSI devices.
3256  * There is no way to edit them, and this is inconsistent
3257  * with the ISA method.  This is here as a basis for further work.
3258  */
3259 static char *
3260 type_text(char *name)   /* XXX: This is bogus */
3261 {
3262         if (strcmp(name, "sd") == 0)
3263                 return "disk";
3264
3265         if (strcmp(name, "st") == 0)
3266                 return "tape";
3267
3268         return "device";
3269 }
3270
3271 id_put(char *desc, int id)
3272 {
3273     if (id != SCCONF_UNSPEC)
3274     {
3275         if (desc)
3276             kprintf("%s", desc);
3277
3278         if (id == SCCONF_ANY)
3279             kprintf("?");
3280         else
3281             kprintf("%d", id);
3282     }
3283 }
3284
3285 static void
3286 lsscsi(void)
3287 {
3288     int i;
3289
3290     kprintf("scsi: (can't be edited):\n");
3291
3292     for (i = 0; scsi_cinit[i].driver; i++)
3293     {
3294         id_put("controller scbus", scsi_cinit[i].scbus);
3295
3296         if (scsi_cinit[i].unit != -1)
3297         {
3298             kprintf(" at ");
3299             id_put(scsi_cinit[i].driver, scsi_cinit[i].unit);
3300         }
3301
3302         kprintf("\n");
3303     }
3304
3305     for (i = 0; scsi_dinit[i].name; i++)
3306     {
3307                 kprintf("%s ", type_text(scsi_dinit[i].name));
3308
3309                 id_put(scsi_dinit[i].name, scsi_dinit[i].unit);
3310                 id_put(" at scbus", scsi_dinit[i].cunit);
3311                 id_put(" target ", scsi_dinit[i].target);
3312                 id_put(" lun ", scsi_dinit[i].lun);
3313
3314                 if (scsi_dinit[i].flags)
3315                 kprintf(" flags 0x%x\n", scsi_dinit[i].flags);
3316
3317                 kprintf("\n");
3318     }
3319 }
3320
3321 static int
3322 list_scsi(CmdParm *parms)
3323 {
3324     lineno = 0;
3325     lsscsi();
3326     return 0;
3327 }
3328 #endif
3329
3330 static void
3331 save_resource(struct uc_device *idev)
3332 {
3333     char *name;
3334     int unit;
3335
3336     name = idev->id_name;
3337     unit = idev->id_unit;
3338     resource_set_int(name, unit, "port", idev->id_iobase);
3339     resource_set_int(name, unit, "irq", ffs(idev->id_irq) - 1);
3340     resource_set_int(name, unit, "drq", idev->id_drq);
3341     resource_set_int(name, unit, "maddr", (int)idev->id_maddr);
3342     resource_set_int(name, unit, "msize", idev->id_msize);
3343     resource_set_int(name, unit, "flags", idev->id_flags);
3344     resource_set_int(name, unit, "disabled", !idev->id_enabled);
3345 }
3346
3347 static int
3348 save_dev(struct uc_device *idev)
3349 {
3350         struct uc_device        *id_p,*id_pn;
3351         char *name = idev->id_name;
3352
3353         for (id_p = uc_devlist; id_p; id_p = id_p->id_next) {
3354                 if (id_p->id_id == idev->id_id) {
3355                         id_pn = id_p->id_next;
3356                         if (id_p->id_name)
3357                                 kfree(id_p->id_name, M_DEVL);
3358                         bcopy(idev,id_p,sizeof(struct uc_device));
3359                         save_resource(idev);
3360                         id_p->id_name = kmalloc(strlen(name)+1, M_DEVL,M_WAITOK);
3361                         strcpy(id_p->id_name, name);
3362                         id_p->id_next = id_pn;
3363                         return 1;
3364                 }
3365         }
3366         id_pn = kmalloc(sizeof(struct uc_device),M_DEVL,M_WAITOK);
3367         bcopy(idev,id_pn,sizeof(struct uc_device));
3368         save_resource(idev);
3369         id_pn->id_name = kmalloc(strlen(name) + 1, M_DEVL,M_WAITOK);
3370         strcpy(id_pn->id_name, name);
3371         id_pn->id_next = uc_devlist;
3372         uc_devlist = id_pn;
3373         return 0;
3374 }
3375
3376