Next Previous Contents

## 3. General Non-Device Specific Boot Args

These are the boot arguments that are not related to any specific device or peripheral. They are instead related to certain internal kernel parameters, such as memory handling, ramdisk handling, root file system handling and others.

## 3.1 Root Filesystem options

The following options all pertain to how the kernel selects and handles the root filesystem.

### The `root=' Argument

This argument tells the kernel what device is to be used as the root filesystem while booting. The default of this setting is the value of the root device of the system that the kernel was built on. For example, if the kernel in question was built on a system that used `/dev/hda1' as the root partition, then the default root device would be `/dev/hda1'. To override this default value, and select the second floppy drive as the root device, one would use `root=/dev/fd1'.

Valid root devices are any of the following devices:

(1) /dev/hdaN to /dev/hddN, which is partition N on ST-506 compatible disk `a to d'.

(2) /dev/sdaN to /dev/sdeN, which is partition N on SCSI compatible disk `a to e'.

(3) /dev/xdaN to /dev/xdbN, which is partition N on XT compatible disk `a to b'.

(4) /dev/fdN, which is floppy disk drive number N. Having N=0 would be the DOS `A:' drive, and N=1 would be `B:'.

(5) /dev/nfs, which is not really a device, but rather a flag to tell the kernel to get the root fs via the network.

(6) /dev/ram, which is the RAM disk.

The more awkward and less portable numeric specification of the above possible disk devices in major/minor format is also accepted. (e.g. /dev/sda3 is major 8, minor 3, so you could use `root=0x803` as an alternative.)

This is one of the few kernel boot arguments that has its default stored in the kernel image, and which can thus be altered with the `rdev` utility.

### The `rootflags=' Argument

This option allows you to give options pertaining to the mounting of the root filesystem just as you would to the `mount` program. An example could be giving the `noatime` option to an ext2 fs.

### The `rootfstype=' Argument

This option allows you to give a comma separated list of fs types that will be tried for a match when trying to mount the root filesystem. This list will be used instead of the internal default which usually starts with ext2, minix and the like.

### The `ro' Argument

When the kernel boots, it needs a root filesystem to read basic things off of. This is the root filesystem that is mounted at boot. However, if the root filesystem is mounted with write access, you can not reliably check the filesystem integrity with half-written files in progress. The `ro' option tells the kernel to mount the root filesystem as `readonly' so that any filesystem consistency check programs (fsck) can safely assume that there are no half-written files in progress while performing the check. No programs or processes can write to files on the filesystem in question until it is `remounted' as read/write capable.

This is one of the few kernel boot arguments that has its default stored in the kernel image, and which can thus be altered with the `rdev` utility.

### The `rw' Argument

This is the exact opposite of the above, in that it tells the kernel to mount the root filesystem as read/write. The default is to mount the root filesystem as read only. Do not run any `fsck' type programs on a filesystem that is mounted read/write.

The same value stored in the image file mentioned above is also used for this parameter, accessible via `rdev`.

### The `nfsroot=' Argument

This argument tells the kernel which machine, what directory and what NFS options to use for the root filesystem. Also note that the argument `root=/dev/nfs` is required. Detailed information on using an NFS root fs is in the file `linux/Documentation/nfsroot.txt`.

### The `ip=' or `nfsaddrs=' Argument

If you are using NFS as a root filesystem, then there is no programs like `ifconfig` and `route` present until the root fs is mounted, and so the kernel has to configure the network interfaces directly. This boot argument sets up the various network interface addresses that are required to communicate over the network. If this argument is not given, then the kernel tries to use RARP and/or BOOTP to figure out these parameters.

## 3.2 Options Relating to RAM Disk Management

The following options all relate to how the kernel handles the RAM disk device, which is usually used for bootstrapping machines during the install phase, or for machines with modular drivers that need to be installed to access the root filesystem.

### The `ramdisk_start=' Argument

To allow a kernel image to reside on a floppy disk along with a compressed ramdisk image, the `ramdisk_start=<offset>' command was added. The kernel can't be included into the compressed ramdisk filesystem image, because it needs to be stored starting at block zero so that the BIOS can load the bootsector and then the kernel can bootstrap itself to get going.

Note: If you are using an uncompressed ramdisk image, then the kernel can be a part of the filesystem image that is being loaded into the ramdisk, and the floppy can be booted with LILO, or the two can be separate as is done for the compressed images.

If you are using a two-disk boot/root setup (kernel on disk 1, ramdisk image on disk 2) then the ramdisk would start at block zero, and an offset of zero would be used. Since this is the default value, you would not need to actually use the command at all.

### The `load_ramdisk=' Argument

This parameter tells the kernel whether it is to try to load a ramdisk image or not. Specifying `load_ramdisk=1' will tell the kernel to load a floppy into the ramdisk. The default value is zero, meaning that the kernel should not try to load a ramdisk.

Please see the file `linux/Documentation/ramdisk.txt` for a complete description of the new boot time arguments, and how to use them. A description of how this parameter can be set and stored in the kernel image via `rdev' is also described.

### The `prompt_ramdisk=' Argument

This parameter tells the kernel whether or not to give you a prompt asking you to insert the floppy containing the ramdisk image. In a single floppy configuration the ramdisk image is on the same floppy as the kernel that just finished loading/booting and so a prompt is not needed. In this case one can use `prompt_ramdisk=0'. In a two floppy configuration, you will need the chance to switch disks, and thus `prompt_ramdisk=1' can be used. Since this is the default value, it doesn't really need to be specified. ( (Historical note: Sneaky people used to use the `vga=ask' LILO option to temporarily pause the boot process and allow a chance to switch from boot to root floppy.)

Please see the file `linux/Documentation/ramdisk.txt` for a complete description of the new boot time arguments, and how to use them. A description of how this parameter can be set and stored in the kernel image via `rdev' is also described.

### The `ramdisk_size=' Argument

While it is true that the ramdisk grows dynamically as required, there is an upper bound on its size so that it doesn't consume all available RAM and leave you in a mess. The default is 4096 (i.e. 4MB) which should be large enough for most needs. You can override the default to a bigger or smaller size with this boot argument.

Please see the file `linux/Documentation/ramdisk.txt` for a complete description of the new boot time arguments, and how to use them. A description of how this parameter can be set and stored in the kernel image via `rdev' is also described.

### The `ramdisk_blocksize=' Argument

This can be tuned for better memory management behaviour. Quoting from the ramdisk driver `rd.c`:

It would be very desirable to have a soft-blocksize (that in the case of the ramdisk driver is also the hardblocksize ;) of PAGE_SIZE because doing that we'll achieve a far better MM footprint. Using a rd_blocksize of BLOCK_SIZE in the worst case we'll make PAGE_SIZE/BLOCK_SIZE buffer-pages unfreeable. With a rd_blocksize of PAGE_SIZE instead we are sure that only 1 page will be protected. Depending on the size of the ramdisk you may want to change the ramdisk blocksize to achieve a better or worse MM behaviour. The default is still BLOCK_SIZE (needed by rd_load_image that supposes the filesystem in the image uses a BLOCK_SIZE blocksize)

### The `ramdisk=' Argument (obsolete)

(NOTE: This argument is obsolete, and should not be used except on kernels v1.3.47 and older. The commands that should be used for the ramdisk device are documented above. Newer kernels may accept this as an alias for `ramdisk_size`.)

This specifies the size in kB of the RAM disk device. For example, if one wished to have a root filesystem on a 1.44MB floppy loaded into the RAM disk device, they would use:

            ramdisk=1440

This is one of the few kernel boot arguments that has its default stored in the kernel image, and which can thus be altered with the `rdev` utility.

### The `noinitrd' (initial RAM disk) Argument

The v2.x and newer kernels have a feature where the root filesystem can be initially a RAM disk, and the kernel executes `/linuxrc` on that RAM image. This feature is typically used to allow loading of modules needed to mount the real root filesystem (e.g. load the SCSI driver modules stored in the RAM disk image, and then mount the real root filesystem on a SCSI disk.)

The actual `noinitrd' argument determines what happens to the initrd data after the kernel has booted. When specified, instead of converting it to a RAM disk, it is accessible via `/dev/initrd`, which can be read once before the RAM is released back to the system. For full details on using the initial RAM disk, please consult `linux/Documentation/initrd.txt`. In addition, the most recent versions of `LILO` and `LOADLIN` should have additional useful information.

## 3.3 Boot Arguments Related to Memory Handling

The following arguments alter how Linux detects or handles the physical and virtual memory of your system.

### The `cachesize=' Argument

Override level 2 CPU cache size detection (in kB). Sometimes CPU hardware bugs make them report the cache size incorrectly. The kernel will attempt work arounds to fix known problems, but for some CPUs it is not possible to determine what the correct size should be. This option provides an override for these situations.

### The `mem=' Argument

This argument has several purposes: The original purpose was to specify the amount of installed memory (or a value less than that if you wanted to limit the amount of memory available to linux).

The next (and hardly used) purpose is to specify `mem=nopentium` which tells the Linux kernel to not use the 4MB page table performance feature. If you want to use it for both purposes, use a separate `mem=` for each one.

The original BIOS call defined in the PC specification that returns the amount of installed memory was only designed to be able to report up to 64MB. (Yes, another lack of foresight, just like the 1024 cylinder disks... sigh.) Linux uses this BIOS call at boot to determine how much memory is installed. A newer specification (e820) allows the BIOS to get this right on most machines nowadays. If you have more than 64MB of RAM installed on an older machine, you can use this boot argument to tell Linux how much memory you have. Here is a quote from Linus on the usage of the `mem=` parameter.

``The kernel will accept any `mem=xx' parameter you give it, and if it turns out that you lied to it, it will crash horribly sooner or later. The parameter indicates the highest addressable RAM address, so `mem=0x1000000' means you have 16MB of memory, for example. For a 96MB machine this would be `mem=0x6000000'. If you tell Linux that it has more memory than it actually does have, bad things will happen: maybe not at once, but surely eventually.''

Note that the argument does not have to be in hex, and the suffixes `k' and `M' (case insensitive) can be used to specify kilobytes and Megabytes, respectively. (A `k' will cause a 10 bit shift on your value, and a `M' will cause a 20 bit shift.) A typical example for a 128MB machine would be "`mem=128m`".

In some cases, the memory reported via e820 can also be wrong, and so the `mem=exactmap` was added. You use this in conjunction with specifying an exact memory map, such as:

            mem=exactmap mem=640K@0 mem=1023M@1M

for a 1GB machine with the usual 384k of ISA memory mapped I/O space excluded from use.

### The `memfrac=' Argument

Memory is broken down into zones; on i386 these zones correspond to `DMA' (for legacy ISA devices that can only address up to 16MB via DMA); `Normal' for memory from 16MB up to 1GB, and `HighMem' for memory beyond 1GB (assuming your kernel was built with high mem support enabled). The two (or three) integers supplied here determine how much memory in each zone should be kept free - with the size of the zone divided by the number supplied being used as the minimum (so smaller numbers mean keep more free in the zone). The defaults are currently `memfrac=32,128,128`.

### The `swap=' Argument

This allows the user to tune some of the virtual memory (VM) parameters that are related to swapping to disk. It accepts the following eight parameters:

            MAX_PAGE_AGE
            PAGE_ADVANCE
            PAGE_DECLINE
            PAGE_INITIAL_AGE
            AGE_CLUSTER_FRACT
            AGE_CLUSTER_MIN
            PAGEOUT_WEIGHT
            BUFFEROUT_WEIGHT

Interested hackers are advised to have a read of `linux/mm/swap.c` and also make note of the goodies in `/proc/sys/vm`. Kernels come with some useful documentation on this in the `linux/Documentation/vm/` directory.

### The `buff=' Argument

Similar to the `swap=' argument, this allows the user to tune some of the parameters related to buffer memory management. It accepts the following six parameters:

            MAX_BUFF_AGE
            BUFF_ADVANCE
            BUFF_DECLINE
            BUFF_INITIAL_AGE
            BUFFEROUT_WEIGHT
            BUFFERMEM_GRACE

Interested hackers are advised to have a read of `linux/mm/swap.c` and also make note of the goodies in `/proc/sys/vm`. Kernels come with some useful documentation on this in the `linux/Documentation/vm/` directory.

## 3.4 Other Misc. Kernel Boot Arguments

These various boot arguments let the user tune certain internal kernel parameters.

### The `acpi=' Argument

Currently this only accepts `off' to disable the ACPI subsystem.

### The `console=' Argument

Usually the console is the 1st virtual terminal, and so boot messages appear on your VGA screen. Sometimes it is nice to be able to use another device like a serial port (or even a printer!) to be the console when no video device is present. It is also useful to capture boot time messages if a problem stops progress before they can be logged to disk. An example would be to use `console=ttyS1,9600` for selecting the 2nd serial port at 9600 baud to be the console. More information can be found in `linux/Documentation/serial-console.txt`.

### The `debug' Argument

The kernel communicates important (and not-so important) messages to the operator via the `printk()` function. If the message is considered important, the `printk()` function will put a copy on the present console as well as handing it off to the `klogd()` facility so that it gets logged to disk. The reason for printing important messages to the console as well as logging them to disk is because under unfortunate circumstances (e.g. a disk failure) the message won't make it to disk and will be lost.

The threshold for what is and what isn't considered important is set by the `console_loglevel` variable. The default is to log anything more important than `DEBUG` (level 7) to the console. (These levels are defined in the include file `kernel.h`) Specifying `debug` as a boot argument will set the console loglevel to 10, so that all kernel messages appear on the console.

The console loglevel can usually also be set at run time via an option to the `klogd()` program. Check the man page for the version installed on your system to see how to do this.

### The `decnet=' Argument

If you are using DECnet, you can supply two comma separated integers here to give your area and node respectively.

### The `devfs=' Argument

If you are using devfs, instead of the standard static devices in `/dev/` then you can supply the words `only` or `mount` with this argument. There are also additional debug arguments that are listed in the source.

### The `gpt' Argument

If you are using EFI GUID Partition Table handling, you can use this to override problems associated with an invalid PMBR.

### The `idle=' Argument

Setting this to `poll' causes the idle loop in the kernel to poll on the need reschedule flag instead of waiting for an interrupt to happen. This can result in an improvement in performance on SMP systems (albeit at the cost of an increase in power consumption).

### The `init=' Argument

The kernel defaults to starting the `init' program at boot, which then takes care of setting up the computer for users via launching getty programs, running `rc' scripts and the like. The kernel first looks for `/sbin/init`, then `/etc/init` (depreciated), and as a last resort, it will try to use `/bin/sh` (possibly on `/etc/rc`). If for example, your init program got corrupted and thus stopped you from being able to boot, you could simply use the boot prompt `init=/bin/sh` which would drop you directly into a shell at boot, allowing you to replace the corrupted program.

### The `isapnp=' Argument

This takes the form of: `isapnp=read_port,reset,skip_pci_scan,verbose`

### The `isapnp_reserve_dma=' Argument

This takes the form of: `isapnp_reserve_dma=n1,n2,n3,...nN` where n1 ... nN are the DMA channel numbers to not use for PnP.

### The `isapnp_reserve_io=' Argument

This takes the form of: `isapnp_reserve_irq=io1,size1,io2,size2,...ioN,sizeN` where ioX,sizeX are I/O start and length pairs of regions in I/O space that are not to be used by PnP.

### The `isapnp_reserve_irq=' Argument

This takes the form of: `isapnp_reserve_irq=n1,n2,n3,...nN` where n1 ... nN are the interrupt numbers to not use for PnP.

### The `isapnp_reserve_mem=' Argument

This takes the form of: `isapnp_reserve_mem=mem1,size1,mem2,size2,...memN,sizeN` where ioX,sizeX are I/O start and length pairs of regions in memory space that are not to be used by PnP.

### The `kbd-reset' Argument

Normally on i386 based machines, the Linux kernel does not reset the keyboard controller at boot, since the BIOS is supposed to do this. But as usual, not all machines do what they should. Supplying this option may help if you are having problems with your keyboard behaviour. It simply forces a reset at initialization time. (Some have argued that this should be the default behaviour anyways).

### The `lockd.udpport=' and `lockd.tcpport' Argument

These tell the kernel to use the given port numbers for NFS lockd operation (for either UDP or TCP operation).

### The `maxcpus=' Argument

The number given with this argument limits the maximum number of CPUs activated in SMP mode. Using a value of 0 is equivalent to the `nosmp` option.

### The `mca-pentium' Argument

The IBM model 95 Microchannel machines seem to lock up on the test that Linux usually does to detect the type of math chip coupling. Since all Pentium chips have a built in math processor, this test (and the lock up problem) can be avoided by using this boot option.

### The `md=' Argument

If your root filesystem is on a Multiple Device then you can use this (assuming you compiled in boot support) to tell the kernel the multiple device layout. The format (from the file `linux/Documentation/md.txt`) is:

`md=md_device_num,raid_level,chunk_size_factor,fault_level,dev0,dev1,...,devN`

Where `md_device_num` is the number of the md device, i.e. 0 means md0, 1 means md1, etc. For `raid_level`, use -1 for linear mode and 0 for striped mode. Other modes are currently unsupported. The `chunk_size_factor` is for raid-0 and raid-1 only and sets the chunk size as PAGE_SIZE shifted left the specified amount. The `fault_level` is only for raid-1 and sets the maximum fault number to the specified number. (Currently unsupported due to lack of boot support for raid1.) The `dev0-devN` are a comma separated list of the devices that make up the individual md device: e.g. `/dev/hda1,/dev/hdc1,/dev/sda1`

See also `raid=`.

### The `nmi_watchdog=' Argument

Supplying a non-zero integer will enable the non maskable interrupt watchdog (assuming IO APIC support is compiled in). This checks to see if the interrupt count is increasing (indicating normal system activity) and if it is not then it assumes that a processor is stuck and forces an error dump of diagnostic information.

### The `no387' Argument

Some i387 coprocessor chips have bugs that show up when used in 32 bit protected mode. For example, some of the early ULSI-387 chips would cause solid lockups while performing floating point calculations, apparently due to a bug in the FRSAV/FRRESTOR instructions. Using the `no387' boot argument causes Linux to ignore the math coprocessor even if you have one. Of course you must then have your kernel compiled with math emulation support! This may also be useful if you have one of those really old 386 machines that could use an 80287 FPU, as Linux can't use an 80287.

### The `no-hlt' Argument

The i386 (and successors thereof) family of CPUs have a `hlt' instruction which tells the CPU that nothing is going to happen until an external device (keyboard, modem, disk, etc.) calls upon the CPU to do a task. This allows the CPU to enter a `low-power' mode where it sits like a zombie until an external device wakes it up (usually via an interrupt). Some of the early i486DX-100 chips had a problem with the `hlt' instruction, in that they couldn't reliably return to operating mode after this instruction was used. Using the `no-hlt' instruction tells Linux to just run an infinite loop when there is nothing else to do, and to not halt your CPU when there is no activity. This allows people with these broken chips to use Linux, although they would be well advised to seek a replacement through a warranty where possible.

### The `no-scroll' Argument

Using this argument at boot disables scrolling features that make it difficult to use Braille terminals.

### The `noapic' Argument

Using this option tells a SMP kernel to not use some of the advanced features of the interrupt controller on multi processor machines. Use of this option may be required when a device (such as those using ne2k-pci or 3c59xi drivers) stops generating interrupts (i.e. `cat /proc/interrupts` shows the same interrupt count.) See `linux/Documentation/IO-APIC.txt` for more information.

### The `noht' Argument

This will disable hyper-threading on intel processors that have this feature.

### The `noisapnp' Argument

If ISA PnP is built into the kernel, this will disable it.

### The `nomce' Argument

Some newer processors have the ability to self-monitor and detect inconsistencies that should not regularly happen. If an inconsistency is detected, a Machine Check Exception will take place and the system will be halted (rather than plundering forward and corrupting your data). You can use this argument to disable this feature, but be sure to check that your CPU is not overheating or otherwise faulty first.

### The `nosmp' Argument

Use of this option will tell a SMP kernel on a SMP machine to operate single processor. Typically only used for debugging and determining if a particular problem is SMP related.

### The `noresume' Argument

If software suspend is enabled, and a suspend to disk file has been specified, using this argument will give a normal boot and the suspend data will be ignored.

### The `notsc' Argument

Use of this option will tell the kernel to not use the Time Stamp Counter for anything, even if the CPU has one.

### The `nofxsr" Argument

Use of this option will tell the kernel to not use any speed-up tricks involving the floating point unit, even if the processor supports them.

### The `panic=' Argument

In the unlikely event of a kernel panic (i.e. an internal error that has been detected by the kernel, and which the kernel decides is serious enough to moan loudly and then halt everything), the default behaviour is to just sit there until someone comes along and notices the panic message on the screen and reboots the machine. However if a machine is running unattended in an isolated location it may be desirable for it to automatically reset itself so that the machine comes back on line. For example, using `panic=30` at boot would cause the kernel to try and reboot itself 30 seconds after the kernel panic happened. A value of zero gives the default behaviour, which is to wait forever.

Note that this timeout value can also be read and set via the `/proc/sys/kernel/panic` sysctl interface.

### The `pirq=' Argument

Using this option tells a SMP kernel information on the PCI slot versus IRQ settings for SMP motherboards which are unknown (or known to be blacklisted). See `linux/Documentation/IO-APIC.txt` for more information.

### The `profile=' Argument

Kernel developers can profile how and where the kernel is spending its CPU cycles in an effort to maximize efficiency and performance. This option lets you set the profile shift count at boot. Typically it is set to two. You need a tool such as `readprofile.c` that can make use of the `/proc/profile` output.

### The `quiet' Argument

This is pretty much the opposite of the `debug' argument. When this is given, only important and system critical kernel messages are printed to the console. Normal messages about hardware detection at boot are suppressed.

### The `raid=' Argument

Accepts `noautodetect` at the moment. See also `md=`.

### The `reboot=' Argument

This option controls the type of reboot that Linux will do when it resets the computer (typically via `/sbin/init` handling a Control-Alt-Delete). The default as of v2.0 kernels is to do a `cold' reboot (i.e. full reset, BIOS does memory check, etc.) instead of a `warm' reboot (i.e. no full reset, no memory check). It was changed to be cold by default since that tends to work on cheap/broken hardware that fails to reboot when a warm reboot is requested. To get the old behaviour (i.e. warm reboots) use `reboot=w` or in fact any word that starts with `w` will work.

Other accepted options are `c', `b', `h', and `s', for cold, bios, hard, and SMP respectively. The `s' takes an optional digit to specify which CPU should handle the reboot. Options can be combined where it makes sense, i.e. `reboot=b,s2`

### The `reserve=' Argument

This is used to protect I/O port regions from probes. The form of the command is:

> `reserve=iobase,extent[,iobase,extent]...`

In some machines it may be necessary to prevent device drivers from checking for devices (auto-probing) in a specific region. This may be because of poorly designed hardware that causes the boot to freeze (such as some ethercards), hardware that is mistakenly identified, hardware whose state is changed by an earlier probe, or merely hardware you don't want the kernel to initialize.

The `reserve` boot-time argument addresses this problem by specifying an I/O port region that shouldn't be probed. That region is reserved in the kernel's port registration table as if a device has already been found in that region (with the name `reserved`). Note that this mechanism shouldn't be necessary on most machines. Only when there is a problem or special case would it be necessary to use this.

The I/O ports in the specified region are protected against device probes that do a `check_region()` prior to probing blindly into a region of I/O space. This was put in to be used when some driver was hanging on a NE2000, or misidentifying some other device as its own. A correct device driver shouldn't probe a reserved region, unless another boot argument explicitly specifies that it do so. This implies that `reserve` will most often be used with some other boot argument. Hence if you specify a `reserve` region to protect a specific device, you must generally specify an explicit probe for that device. Most drivers ignore the port registration table if they are given an explicit address.

For example, the boot line

            reserve=0x300,32  blah=0x300

keeps all device drivers except the driver for `blah' from probing `0x300-0x31f`.

As usual with boot-time specifiers there is an 11 parameter limit, thus you can only specify 5 reserved regions per `reserve` keyword. Multiple `reserve` specifiers will work if you have an unusually complicated request.

### The `resume=' Argument

If you are using software suspend, then this will allow you to specify the file name of the suspend to disk data that you want the machine to resume from.

### The `vga=' Argument

Note that this is not really a boot argument. It is an option that is interpreted by LILO and not by the kernel like all the other boot arguments are. However its use has become so common that it deserves a mention here. It can also be set via using `rdev -v` or equivalently `vidmode` on the vmlinuz file. This allows the setup code to use the video BIOS to change the default display mode before actually booting the Linux kernel. Typical modes are 80x50, 132x44 and so on. The best way to use this option is to start with `vga=ask` which will prompt you with a list of various modes that you can use with your video adapter before booting the kernel. Once you have the number from the above list that you want to use, you can later put it in place of the `ask'. For more information, please see the file `linux/Documentation/svga.txt` that comes with all recent kernel versions.

Note that newer kernels (v2.1 and up) have the setup code that changes the video mode as an option, listed as `Video mode selection support` so you need to enable this option if you want to use this feature.

Next Previous Contents