drivers/char/nvram.c

   1 /*
   2  * CMOS/NV-RAM driver for Linux
   3  *
   4  * Copyright (C) 1997 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
   5  * idea by and with help from Richard Jelinek <rj@suse.de>
   6  *
   7  * This driver allows you to access the contents of the non-volatile memory in
   8  * the mc146818rtc.h real-time clock. This chip is built into all PCs and into
   9  * many Atari machines. In the former it's called "CMOS-RAM", in the latter
  10  * "NVRAM" (NV stands for non-volatile).
  11  *
  12  * The data are supplied as a (seekable) character device, /dev/nvram. The
  13  * size of this file is 50, the number of freely available bytes in the memory
  14  * (i.e., not used by the RTC itself).
  15  *
  16  * Checksums over the NVRAM contents are managed by this driver. In case of a
  17  * bad checksum, reads and writes return -EIO. The checksum can be initialized
  18  * to a sane state either by ioctl(NVRAM_INIT) (clear whole NVRAM) or
  19  * ioctl(NVRAM_SETCKS) (doesn't change contents, just makes checksum valid
  20  * again; use with care!)
  21  *
  22  * This file also provides some functions for other parts of the kernel that
  23  * want to access the NVRAM: nvram_{read,write,check_checksum,set_checksum}.
  24  * Obviously this can be used only if this driver is always configured into
  25  * the kernel and is not a module. Since the functions are used by some Atari
  26  * drivers, this is the case on the Atari.
  27  *
  28  *
  29  *      1.1     Cesar Barros: SMP locking fixes
  30  *              added changelog
  31  */
  32
  33 #define NVRAM_VERSION           "1.1"
  34
  35 #include <linux/module.h>
  36 #include <linux/config.h>
  37
  38 #define PC              1
  39 #define ATARI   2
  40
  41 /* select machine configuration */
  42 #if defined(CONFIG_ATARI)
  43 #define MACH ATARI
  44 #elif defined(__i386__) || defined(__arm__) /* and others?? */
  45 #define MACH PC
  46 #else
  47 #error Cannot build nvram driver for this machine configuration.
  48 #endif
  49
  50 #if MACH == PC
  51
  52 /* RTC in a PC */
  53 #define CHECK_DRIVER_INIT() 1
  54
  55 /* On PCs, the checksum is built only over bytes 2..31 */
  56 #define PC_CKS_RANGE_START      2
  57 #define PC_CKS_RANGE_END        31
  58 #define PC_CKS_LOC                      32
  59
  60 #define mach_check_checksum     pc_check_checksum
  61 #define mach_set_checksum       pc_set_checksum
  62 #define mach_proc_infos         pc_proc_infos
  63
  64 #endif
  65
  66 #if MACH == ATARI
  67
  68 /* Special parameters for RTC in Atari machines */
  69 #include <asm/atarihw.h>
  70 #include <asm/atariints.h>
  71 #define RTC_PORT(x)                     (TT_RTC_BAS + 2*(x))
  72 #define CHECK_DRIVER_INIT() (MACH_IS_ATARI && ATARIHW_PRESENT(TT_CLK))
  73
  74 /* On Ataris, the checksum is over all bytes except the checksum bytes
  75  * themselves; these are at the very end */
  76 #define ATARI_CKS_RANGE_START   0
  77 #define ATARI_CKS_RANGE_END             47
  78 #define ATARI_CKS_LOC                   48
  79
  80 #define mach_check_checksum     atari_check_checksum
  81 #define mach_set_checksum       atari_set_checksum
  82 #define mach_proc_infos         atari_proc_infos
  83
  84 #endif
  85
  86 /* Note that *all* calls to CMOS_READ and CMOS_WRITE must be done with
  87  * rtc_lock held. Due to the index-port/data-port design of the RTC, we
  88  * don't want two different things trying to get to it at once. (e.g. the
  89  * periodic 11 min sync from time.c vs. this driver.)
  90  */
  91
  92 #include <linux/types.h>
  93 #include <linux/errno.h>
  94 #include <linux/miscdevice.h>
  95 #include <linux/malloc.h>
  96 #include <linux/ioport.h>
  97 #include <linux/fcntl.h>
  98 #include <linux/mc146818rtc.h>
  99 #include <linux/nvram.h>
 100 #include <linux/init.h>
 101 #include <linux/proc_fs.h>
 102 #include <linux/spinlock.h>
 103
 104 #include <asm/io.h>
 105 #include <asm/uaccess.h>
 106 #include <asm/system.h>
 107
 108 extern spinlock_t rtc_lock;
 109
 110 static int nvram_open_cnt = 0;  /* #times opened */
 111 static int nvram_open_mode;             /* special open modes */
 112 #define NVRAM_WRITE             1               /* opened for writing (exclusive) */
 113 #define NVRAM_EXCL              2               /* opened with O_EXCL */
 114
 115 #define RTC_FIRST_BYTE          14      /* RTC register number of first NVRAM byte */
 116 #define NVRAM_BYTES                     50      /* number of NVRAM bytes */
 117
 118
 119 static int mach_check_checksum( void );
 120 static void mach_set_checksum( void );
 121 #ifdef CONFIG_PROC_FS
 122 static int mach_proc_infos( unsigned char *contents, char *buffer, int *len,
 123                                                         off_t *begin, off_t offset, int size );
 124 #endif
 125
 126
 127 /*
 128  * These are the internal NVRAM access functions, which do NOT disable
 129  * interrupts and do not check the checksum. Both tasks are left to higher
 130  * level function, so they need to be done only once per syscall.
 131  */
 132
 133 static __inline__ unsigned char nvram_read_int( int i )
 134 {
 135         return( CMOS_READ( RTC_FIRST_BYTE+i ) );
 136 }
 137
 138 static __inline__ void nvram_write_int( unsigned char c, int i )
 139 {
 140         CMOS_WRITE( c, RTC_FIRST_BYTE+i );
 141 }
 142
 143 static __inline__ int nvram_check_checksum_int( void )
 144 {
 145         return( mach_check_checksum() );
 146 }
 147
 148 static __inline__ void nvram_set_checksum_int( void )
 149 {
 150         mach_set_checksum();
 151 }
 152
 153 #if MACH == ATARI
 154
 155 /*
 156  * These non-internal functions are provided to be called by other parts of
 157  * the kernel. It's up to the caller to ensure correct checksum before reading
 158  * or after writing (needs to be done only once).
 159  *
 160  * They're only built if CONFIG_ATARI is defined, because Atari drivers use
 161  * them. For other configurations (PC), the rest of the kernel can't rely on
 162  * them being present (this driver may not be configured at all, or as a
 163  * module), so they access config information themselves.
 164  */
 165
 166 unsigned char nvram_read_byte( int i )
 167 {
 168         unsigned long flags;
 169         unsigned char c;
 170
 171         spin_lock_irqsave (&rtc_lock, flags);
 172         c = nvram_read_int( i );
 173         spin_unlock_irqrestore (&rtc_lock, flags);
 174         return( c );
 175 }
 176
 177 /* This races nicely with trying to read with checksum checking (nvram_read) */
 178 void nvram_write_byte( unsigned char c, int i )
 179 {
 180         unsigned long flags;
 181
 182         spin_lock_irqsave (&rtc_lock, flags);
 183         nvram_write_int( c, i );
 184         spin_unlock_irqrestore (&rtc_lock, flags);
 185 }
 186
 187 int nvram_check_checksum( void )
 188 {
 189         unsigned long flags;
 190         int rv;
 191
 192         spin_lock_irqsave (&rtc_lock, flags);
 193         rv = nvram_check_checksum_int();
 194         spin_unlock_irqrestore (&rtc_lock, flags);
 195         return( rv );
 196 }
 197
 198 void nvram_set_checksum( void )
 199 {
 200         unsigned long flags;
 201
 202         spin_lock_irqsave (&rtc_lock, flags);
 203         nvram_set_checksum_int();
 204         spin_unlock_irqrestore (&rtc_lock, flags);
 205 }
 206
 207 #endif /* MACH == ATARI */
 208
 209
 210 /*
 211  * The are the file operation function for user access to /dev/nvram
 212  */
 213
 214 static long long nvram_llseek(struct file *file,loff_t offset, int origin )
 215 {
 216         switch( origin ) {
 217           case 0:
 218                 /* nothing to do */
 219                 break;
 220           case 1:
 221                 offset += file->f_pos;
 222                 break;
 223           case 2:
 224                 offset += NVRAM_BYTES;
 225                 break;
 226         }
 227         return( (offset >= 0) ? (file->f_pos = offset) : -EINVAL );
 228 }
 229
 230 static ssize_t nvram_read(struct file * file,
 231         char * buf, size_t count, loff_t *ppos )
 232 {
 233         char contents [NVRAM_BYTES];
 234         unsigned i = *ppos;
 235         char *tmp;
 236
 237         spin_lock_irq (&rtc_lock);
 238
 239         if (!nvram_check_checksum_int())
 240                 goto checksum_err;
 241
 242         for (tmp = contents; count-- > 0 && i < NVRAM_BYTES; ++i, ++tmp)
 243                 *tmp = nvram_read_int(i);
 244
 245         spin_unlock_irq (&rtc_lock);
 246
 247         copy_to_user_ret (buf, contents, tmp - contents, -EFAULT);
 248
 249         *ppos = i;
 250
 251         return (tmp - contents);
 252
 253 checksum_err:
 254         spin_unlock_irq (&rtc_lock);
 255         return -EIO;
 256 }
 257
 258 static ssize_t nvram_write(struct file * file,
 259                 const char * buf, size_t count, loff_t *ppos )
 260 {
 261         char contents [NVRAM_BYTES];
 262         unsigned i = *ppos;
 263         char * tmp;
 264
 265         /* could comebody please help me indent this better? */
 266         copy_from_user_ret (contents, buf, (NVRAM_BYTES - i) < count ?
 267                                                 (NVRAM_BYTES - i) : count,
 268                                 -EFAULT);
 269
 270         spin_lock_irq (&rtc_lock);
 271
 272         if (!nvram_check_checksum_int())
 273                 goto checksum_err;
 274
 275         for (tmp = contents; count-- > 0 && i < NVRAM_BYTES; ++i, ++tmp)
 276                 nvram_write_int (*tmp, i);
 277
 278         nvram_set_checksum_int();
 279
 280         spin_unlock_irq (&rtc_lock);
 281
 282         *ppos = i;
 283
 284         return (tmp - contents);
 285
 286 checksum_err:
 287         spin_unlock_irq (&rtc_lock);
 288         return -EIO;
 289 }
 290
 291 static int nvram_ioctl( struct inode *inode, struct file *file,
 292                                                 unsigned int cmd, unsigned long arg )
 293 {
 294         int i;
 295
 296         switch( cmd ) {
 297
 298           case NVRAM_INIT:                      /* initialize NVRAM contents and checksum */
 299                 if (!capable(CAP_SYS_ADMIN))
 300                         return( -EACCES );
 301
 302                 spin_lock_irq (&rtc_lock);
 303
 304                 for( i = 0; i < NVRAM_BYTES; ++i )
 305                         nvram_write_int( 0, i );
 306                 nvram_set_checksum_int();
 307
 308                 spin_unlock_irq (&rtc_lock);
 309                 return( 0 );
 310
 311           case NVRAM_SETCKS:            /* just set checksum, contents unchanged
 312                                                                  * (maybe useful after checksum garbaged
 313                                                                  * somehow...) */
 314                 if (!capable(CAP_SYS_ADMIN))
 315                         return( -EACCES );
 316
 317                 spin_lock_irq (&rtc_lock);
 318                 nvram_set_checksum_int();
 319                 spin_unlock_irq (&rtc_lock);
 320                 return( 0 );
 321
 322           default:
 323                 return( -EINVAL );
 324         }
 325 }
 326
 327 static int nvram_open( struct inode *inode, struct file *file )
 328 {
 329         if ((nvram_open_cnt && (file->f_flags & O_EXCL)) ||
 330                 (nvram_open_mode & NVRAM_EXCL) ||
 331                 ((file->f_mode & 2) && (nvram_open_mode & NVRAM_WRITE)))
 332                 return( -EBUSY );
 333
 334         if (file->f_flags & O_EXCL)
 335                 nvram_open_mode |= NVRAM_EXCL;
 336         if (file->f_mode & 2)
 337                 nvram_open_mode |= NVRAM_WRITE;
 338         nvram_open_cnt++;
 339         return( 0 );
 340 }
 341
 342 static int nvram_release( struct inode *inode, struct file *file )
 343 {
 344         nvram_open_cnt--;
 345         if (file->f_flags & O_EXCL)
 346                 nvram_open_mode &= ~NVRAM_EXCL;
 347         if (file->f_mode & 2)
 348                 nvram_open_mode &= ~NVRAM_WRITE;
 349
 350         return( 0 );
 351 }
 352
 353
 354 #ifndef CONFIG_PROC_FS
 355 static int nvram_read_proc( char *buffer, char **start, off_t offset,
 356                             int size, int *eof, void *data) { return 0; }
 357 #else
 358
 359 static int nvram_read_proc( char *buffer, char **start, off_t offset,
 360                                                         int size, int *eof, void *data )
 361 {
 362         unsigned char contents[NVRAM_BYTES];
 363     int i, len = 0;
 364     off_t begin = 0;
 365
 366         spin_lock_irq (&rtc_lock);
 367         for( i = 0; i < NVRAM_BYTES; ++i )
 368                 contents[i] = nvram_read_int( i );
 369         spin_unlock_irq (&rtc_lock);
 370
 371         *eof = mach_proc_infos( contents, buffer, &len, &begin, offset, size );
 372
 373     if (offset >= begin + len)
 374                 return( 0 );
 375     *start = buffer + (offset - begin);
 376     return( size < begin + len - offset ? size : begin + len - offset );
 377
 378 }
 379
 380 /* This macro frees the machine specific function from bounds checking and
 381  * this like that... */
 382 #define PRINT_PROC(fmt,args...)                                                 \
 383         do {                                                                                            \
 384                 *len += sprintf( buffer+*len, fmt, ##args );    \
 385                 if (*begin + *len > offset + size)                              \
 386                         return( 0 );                                                            \
 387                 if (*begin + *len < offset) {                                   \
 388                         *begin += *len;                                                         \
 389                         *len = 0;                                                                       \
 390                 }                                                                                               \
 391         } while(0)
 392
 393 #endif /* CONFIG_PROC_FS */
 394
 395 static struct file_operations nvram_fops = {
 396         owner:          THIS_MODULE,
 397         llseek:         nvram_llseek,
 398         read:           nvram_read,
 399         write:          nvram_write,
 400         ioctl:          nvram_ioctl,
 401         open:           nvram_open,
 402         release:        nvram_release,
 403 };
 404
 405 static struct miscdevice nvram_dev = {
 406         NVRAM_MINOR,
 407         "nvram",
 408         &nvram_fops
 409 };
 410
 411
 412 static int __init nvram_init(void)
 413 {
 414         /* First test whether the driver should init at all */
 415         if (!CHECK_DRIVER_INIT())
 416             return( -ENXIO );
 417
 418         printk(KERN_INFO "Non-volatile memory driver v%s\n", NVRAM_VERSION );
 419         misc_register( &nvram_dev );
 420         create_proc_read_entry("driver/nvram",0,0,nvram_read_proc,NULL);
 421         return( 0 );
 422 }
 423
 424 static void __exit nvram_cleanup_module (void)
 425 {
 426         remove_proc_entry( "driver/nvram", 0 );
 427         misc_deregister( &nvram_dev );
 428 }
 429
 430 module_init(nvram_init);
 431 module_exit(nvram_cleanup_module);
 432
 433
 434 /*
 435  * Machine specific functions
 436  */
 437
 438
 439 #if MACH == PC
 440
 441 static int pc_check_checksum( void )
 442 {
 443         int i;
 444         unsigned short sum = 0;
 445
 446         for( i = PC_CKS_RANGE_START; i <= PC_CKS_RANGE_END; ++i )
 447                 sum += nvram_read_int( i );
 448         return( (sum & 0xffff) ==
 449                         ((nvram_read_int(PC_CKS_LOC) << 8) |
 450                          nvram_read_int(PC_CKS_LOC+1)) );
 451 }
 452
 453 static void pc_set_checksum( void )
 454 {
 455         int i;
 456         unsigned short sum = 0;
 457
 458         for( i = PC_CKS_RANGE_START; i <= PC_CKS_RANGE_END; ++i )
 459                 sum += nvram_read_int( i );
 460         nvram_write_int( sum >> 8, PC_CKS_LOC );
 461         nvram_write_int( sum & 0xff, PC_CKS_LOC+1 );
 462 }
 463
 464 #ifdef CONFIG_PROC_FS
 465
 466 static char *floppy_types[] = {
 467         "none", "5.25'' 360k", "5.25'' 1.2M", "3.5'' 720k", "3.5'' 1.44M", "3.5'' 2.88M"
 468 };
 469
 470 static char *gfx_types[] = {
 471         "EGA, VGA, ... (with BIOS)",
 472         "CGA (40 cols)",
 473         "CGA (80 cols)",
 474         "monochrome",
 475 };
 476
 477 static int pc_proc_infos( unsigned char *nvram, char *buffer, int *len,
 478                                                   off_t *begin, off_t offset, int size )
 479 {
 480         int checksum;
 481         int type;
 482
 483         spin_lock_irq (&rtc_lock);
 484         checksum = nvram_check_checksum_int();
 485         spin_unlock_irq (&rtc_lock);
 486
 487         PRINT_PROC( "Checksum status: %svalid\n", checksum ? "" : "not " );
 488
 489         PRINT_PROC( "# floppies     : %d\n",
 490                                 (nvram[6] & 1) ? (nvram[6] >> 6) + 1 : 0 );
 491         PRINT_PROC( "Floppy 0 type  : " );
 492         type = nvram[2] >> 4;
 493         if (type < sizeof(floppy_types)/sizeof(*floppy_types))
 494                 PRINT_PROC( "%s\n", floppy_types[type] );
 495         else
 496                 PRINT_PROC( "%d (unknown)\n", type );
 497         PRINT_PROC( "Floppy 1 type  : " );
 498         type = nvram[2] & 0x0f;
 499         if (type < sizeof(floppy_types)/sizeof(*floppy_types))
 500                 PRINT_PROC( "%s\n", floppy_types[type] );
 501         else
 502                 PRINT_PROC( "%d (unknown)\n", type );
 503
 504         PRINT_PROC( "HD 0 type      : " );
 505         type = nvram[4] >> 4;
 506         if (type)
 507                 PRINT_PROC( "%02x\n", type == 0x0f ? nvram[11] : type );
 508         else
 509                 PRINT_PROC( "none\n" );
 510
 511         PRINT_PROC( "HD 1 type      : " );
 512         type = nvram[4] & 0x0f;
 513         if (type)
 514                 PRINT_PROC( "%02x\n", type == 0x0f ? nvram[12] : type );
 515         else
 516                 PRINT_PROC( "none\n" );
 517
 518         PRINT_PROC( "HD type 48 data: %d/%d/%d C/H/S, precomp %d, lz %d\n",
 519                                 nvram[18] | (nvram[19] << 8),
 520                                 nvram[20], nvram[25],
 521                                 nvram[21] | (nvram[22] << 8),
 522                                 nvram[23] | (nvram[24] << 8) );
 523         PRINT_PROC( "HD type 49 data: %d/%d/%d C/H/S, precomp %d, lz %d\n",
 524                                 nvram[39] | (nvram[40] << 8),
 525                                 nvram[41], nvram[46],
 526                                 nvram[42] | (nvram[43] << 8),
 527                                 nvram[44] | (nvram[45] << 8) );
 528
 529         PRINT_PROC( "DOS base memory: %d kB\n", nvram[7] | (nvram[8] << 8) );
 530         PRINT_PROC( "Extended memory: %d kB (configured), %d kB (tested)\n",
 531                                 nvram[9] | (nvram[10] << 8),
 532                                 nvram[34] | (nvram[35] << 8) );
 533
 534         PRINT_PROC( "Gfx adapter    : %s\n", gfx_types[ (nvram[6] >> 4)&3 ] );
 535
 536         PRINT_PROC( "FPU            : %sinstalled\n",
 537                                 (nvram[6] & 2) ? "" : "not " );
 538
 539         return( 1 );
 540 }
 541 #endif
 542
 543 #endif /* MACH == PC */
 544
 545 #if MACH == ATARI
 546
 547 static int atari_check_checksum( void )
 548 {
 549         int i;
 550         unsigned char sum = 0;
 551
 552         for( i = ATARI_CKS_RANGE_START; i <= ATARI_CKS_RANGE_END; ++i )
 553                 sum += nvram_read_int( i );
 554         return( nvram_read_int( ATARI_CKS_LOC ) == (~sum & 0xff) &&
 555                         nvram_read_int( ATARI_CKS_LOC+1 ) == (sum & 0xff) );
 556 }
 557
 558 static void atari_set_checksum( void )
 559 {
 560         int i;
 561         unsigned char sum = 0;
 562
 563         for( i = ATARI_CKS_RANGE_START; i <= ATARI_CKS_RANGE_END; ++i )
 564                 sum += nvram_read_int( i );
 565         nvram_write_int( ~sum, ATARI_CKS_LOC );
 566         nvram_write_int( sum, ATARI_CKS_LOC+1 );
 567 }
 568
 569 #ifdef CONFIG_PROC_FS
 570
 571 static struct {
 572         unsigned char val;
 573         char *name;
 574 } boot_prefs[] = {
 575         { 0x80, "TOS" },
 576         { 0x40, "ASV" },
 577         { 0x20, "NetBSD (?)" },
 578         { 0x10, "Linux" },
 579         { 0x00, "unspecified" }
 580 };
 581
 582 static char *languages[] = {
 583         "English (US)",
 584         "German",
 585         "French",
 586         "English (UK)",
 587         "Spanish",
 588         "Italian",
 589         "6 (undefined)",
 590         "Swiss (French)",
 591         "Swiss (German)"
 592 };
 593
 594 static char *dateformat[] = {
 595         "MM%cDD%cYY",
 596         "DD%cMM%cYY",
 597         "YY%cMM%cDD",
 598         "YY%cDD%cMM",
 599         "4 (undefined)",
 600         "5 (undefined)",
 601         "6 (undefined)",
 602         "7 (undefined)"
 603 };
 604
 605 static char *colors[] = {
 606         "2", "4", "16", "256", "65536", "??", "??", "??"
 607 };
 608
 609 #define fieldsize(a)    (sizeof(a)/sizeof(*a))
 610
 611 static int atari_proc_infos( unsigned char *nvram, char *buffer, int *len,
 612                             off_t *begin, off_t offset, int size )
 613 {
 614         int checksum = nvram_check_checksum();
 615         int i;
 616         unsigned vmode;
 617
 618         PRINT_PROC( "Checksum status  : %svalid\n", checksum ? "" : "not " );
 619
 620         PRINT_PROC( "Boot preference  : " );
 621         for( i = fieldsize(boot_prefs)-1; i >= 0; --i ) {
 622                 if (nvram[1] == boot_prefs[i].val) {
 623                         PRINT_PROC( "%s\n", boot_prefs[i].name );
 624                         break;
 625                 }
 626         }
 627         if (i < 0)
 628                 PRINT_PROC( "0x%02x (undefined)\n", nvram[1] );
 629
 630         PRINT_PROC( "SCSI arbitration : %s\n", (nvram[16] & 0x80) ? "on" : "off" );
 631         PRINT_PROC( "SCSI host ID     : " );
 632         if (nvram[16] & 0x80)
 633                 PRINT_PROC( "%d\n", nvram[16] & 7 );
 634         else
 635                 PRINT_PROC( "n/a\n" );
 636
 637         /* the following entries are defined only for the Falcon */
 638         if ((atari_mch_cookie >> 16) != ATARI_MCH_FALCON)
 639                 return 1;
 640
 641         PRINT_PROC( "OS language      : " );
 642         if (nvram[6] < fieldsize(languages))
 643                 PRINT_PROC( "%s\n", languages[nvram[6]] );
 644         else
 645                 PRINT_PROC( "%u (undefined)\n", nvram[6] );
 646         PRINT_PROC( "Keyboard language: " );
 647         if (nvram[7] < fieldsize(languages))
 648                 PRINT_PROC( "%s\n", languages[nvram[7]] );
 649         else
 650                 PRINT_PROC( "%u (undefined)\n", nvram[7] );
 651         PRINT_PROC( "Date format      : " );
 652         PRINT_PROC( dateformat[nvram[8]&7],
 653                                 nvram[9] ? nvram[9] : '/', nvram[9] ? nvram[9] : '/' );
 654         PRINT_PROC( ", %dh clock\n", nvram[8] & 16 ? 24 : 12 );
 655         PRINT_PROC( "Boot delay       : " );
 656         if (nvram[10] == 0)
 657                 PRINT_PROC( "default" );
 658         else
 659                 PRINT_PROC( "%ds%s\n", nvram[10],
 660                                         nvram[10] < 8 ? ", no memory test" : "" );
 661
 662         vmode = (nvram[14] << 8) || nvram[15];
 663         PRINT_PROC( "Video mode       : %s colors, %d columns, %s %s monitor\n",
 664                                 colors[vmode & 7],
 665                                 vmode & 8 ? 80 : 40,
 666                                 vmode & 16 ? "VGA" : "TV",
 667                                 vmode & 32 ? "PAL" : "NTSC" );
 668         PRINT_PROC( "                   %soverscan, compat. mode %s%s\n",
 669                                 vmode & 64 ? "" : "no ",
 670                                 vmode & 128 ? "on" : "off",
 671                                 vmode & 256 ?
 672                                   (vmode & 16 ? ", line doubling" : ", half screen") : "" );
 673
 674         return( 1 );
 675 }
 676 #endif
 677
 678 #endif /* MACH == ATARI */
 679
 680 /*
 681  * Local variables:
 682  *  c-indent-level: 4
 683  *  tab-width: 4
 684  * End:
 685  */