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