¬† ¬† ¬† ¬† ¬†



The Linux BootPrompt-HowTo

by Paul Gortmaker.

v1.4, Mar 21, 2003
This is the BootPrompt-Howto, which is a compilation of all the possible boot time arguments that can be passed to the Linux kernel at boot time. A discussion of how the kernel sorts boot time arguments, along with an overview of some of the popular software used to boot Linux kernels is also included.

1. Introduction

2. Overview of Boot Prompt Arguments

3. General Non-Device Specific Boot Args

4. Boot Arguments to Control PCI Bus Behaviour (`pci=')

5. Boot Arguments for Video Frame Buffer Drivers

6. Boot Arguments for SCSI Peripherals.

7. Hard Disks

8. The Sound Drivers


10. Serial and ISDN Drivers

11. Other Hardware Devices

12. Copying, Translations, Closing, etc.

1. Introduction




The BootPrompt-Howto is by:

Paul Gortmaker, p_gortmaker @ yahoo.com


1.1 Intended Audience and Applicability






1.2 Related Documentation



Kernel Source Home



1.3 New Versions of this Document




2. Overview of Boot Prompt Arguments





2.1 LILO (LInux LOader)



        LILO: linux root=/dev/hda1


2.2 LoadLin




2.3 The ``rdev'' utility




2.4 How the Kernel Sorts the Arguments

Most of the boot args take the form of:





2.5 Setting Environment Variables.


2.6 Passing Arguments to the `init' program


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.


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.)


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.


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:



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:


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:



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


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:


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




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.


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




The `pci=' argument (not avail. in v2.0 kernels) can be used to change the behaviour of PCI bus device probing and device behaviour. Firstly the file linux/drivers/pci/pci.c checks for architecture independent pci= options. The remaining allowed arguments are handled in linux/arch/???/kernel/bios32.c and are listed below for ???=i386.

4.1 The `pci=assign-busses' Argument

This tells the kernel to always assign all PCI bus numbers, overriding whatever the firmware may have done.

4.2 The `pci=bios' and `pci=nobios' Arguments

These are used to set/clear the flag indicating that the PCI probing is to take place via the PCI BIOS. The default is to use the BIOS.

4.3 The `pci=conf1' and `pci=conf2' Arguments

If PCI direct mode is enabled, the use of these enables either configuration Type 1 or Type 2. These implicitly clear the PCI BIOS probe flag (i.e. `pci=nobios') too.

4.4 The `pci=irqmask=' Argument

This allows the user to supply an IRQ mask value, which is converted using strtol(). It will set a bit mask of IRQs allowed to be assigned automatically to PCI devices. You can make the kernel exclude IRQs of your ISA cards this way.

4.5 The `pci=lastbus=' Argument

This allows the user to supply a lastbus value, which is converted using strtol(). It will scan all buses till bus N. Can be useful if the kernel is unable to find your secondary buses and you want to tell it explicitly which ones they are.

4.6 The `pci=noacpi' Argument


4.7 The `pci=nopeer' Argument

This disables the default peer bridge fixup, which according to the source does the following:

``In case there are peer host bridges, scan bus behind each of them. Although several sources claim that the host bridges should have header type 1 and be assigned a bus number as for PCI2PCI bridges, the reality doesn't pass this test and the bus number is usually set by BIOS to the first free value.''

4.8 The `pci=nosort' Argument

Using this argument instructs the kernel to not sort the PCI devices during the probing phase.

4.9 The `pci=off' Argument

Using this option disables all PCI bus probing. Any device drivers that make use of PCI functions to find and initialize hardware will most likely fail to work.

4.10 The `pci=usepirqmask' Argument

This sets the USE_PIRQ_MASK flag during PCI init. The kernel will honour the possible IRQ mask stored in the BIOS PIR table. This is needed on some systems with broken BIOSes, notably some HP Pavilion N5400 and Omnibook XE3 notebooks. This will have no effect if ACPI IRQ routing is enabled.

4.11 The `pci=rom' Argument

This sets the ASSIGN_ROM flag during the probing phase. The kernel will assign address space to expansion ROMs. Use with caution as certain devices share address decoders between ROMs and other resources.

5. Boot Arguments for Video Frame Buffer Drivers





5.1 The `video=map:...' Argument


5.2 The `video=scrollback:...' Argument


5.3 The `video=vc:...' Argument


6. Boot Arguments for SCSI Peripherals.


6.1 Arguments for Upper and Mid-level Drivers


Maximum Probed LUNs (`max_scsi_luns=')





SCSI Logging (`scsi_logging=')


Parameters for the SCSI Tape Driver (`st=')





Full details can be found in the README.st file that is in the scsi directory of the kernel source tree.

6.2 Arguments for SCSI Host Adapter Drivers



aha1542= Adaptec aha1540, aha1542

aic7xxx= Adaptec aha274x, aha284x, aic7xxx

advansys= AdvanSys SCSI Host Adaptors

in2000= Always IN2000 Host Adaptor

AM53C974= AMD AM53C974 based hardware

BusLogic= ISA/PCI/EISA BusLogic SCSI Hosts

eata= EATA SCSI Cards

tmc8xx= Future Domain TMC-8xx, TMC-950


ppa= IOMEGA Parallel Port / ZIP drive

ncr5380= NCR5380 based controllers

ncr53c400= NCR53c400 based controllers

ncr53c406a= NCR53c406a based controllers

pas16= Pro Audio Spectrum

st0x= Seagate ST-0x

t128= Trantor T128

u14-34f= Ultrastor SCSI cards

wd7000= Western Digital WD7000 cards

7. Hard Disks


7.1 IDE Disk/CD-ROM Driver Parameters



                                to the fastest PIO mode supported,
                                if possible for this drive only.
                                Not fully supported by all chipset types,
                                and quite likely to cause trouble with
                                older/odd IDE drives.

                                where "base" is usually 0x1f0 or 0x170
                                to the fastest PIO mode supported,
                                for all drives on this interface.
                                Not fully supported by all chipset types,
                                and quite likely to cause trouble with
                                older/odd IDE drives.
                                This is the default for most chipsets,
                                except the cmd640.


 "ide0=dtc2278"         : probe/support DTC2278 interface
 "ide0=ht6560b"         : probe/support HT6560B interface
                          (not for PCI -- automatically detected)
 "ide0=qd6580"          : probe/support qd6580 interface
 "ide0=umc8672"         : probe/support umc8672 chipsets


 "ide2=0x180,0x386"     : probe typical PCMCIA IDE interface location















8. The Sound Drivers

Note that there was a rewrite of a lot of the sound core and related drivers. The older stuff is generally called `OSS' and the newer is called `ALSA'. The intention is to drop the OSS stuff eventually. To avoid name conflict, the ALSA stuff generally has `snd-' as a prefix to all the boot parameters.

Note that each driver has its own individual boot argument (very old kernels used a shared sound=). Also, generally no defaults are set at compile time (i.e. you must supply a boot argument for older non-PNP ISA cards to be detected.) Your best source of information for your card is the files in linux/Documentation/sound/.

8.1 Individual Sound Device Driver Arguments

ALSA ISA drivers

snd-dummy= Dummy soundcard

snd-mpu401= mpu401 UART

snd-mtpav= MOTU Midi Timepiece

snd-serial= Serial UART 16450/16550 MIDI

snd-virmidi= Dummy soundcard for virtual rawmidi devices

snd-ad1816a= ADI SoundPort AD1816A

snd-ad1848= Generic driver for AD1848/AD1847/CS4248

snd-als100= Avance Logic ALS100

snd-azt2320= Aztech Systems AZT2320 (and 2316)

snd-cmi8330= C-Media's CMI8330

snd-cs4231= Generic driver for CS4231 chips

snd-cs4232= Generic driver for CS4232 chips

snd-cs4236= Generic driver for CS4235/6/7/8/9 chips

snd-dt019x= Diamond Technologies DT-019x

snd-es1688= Generic ESS AudioDrive ESx688

snd-es18xx= Generic ESS AudioDrive ES18xx

snd-gusclassic= Gus classic

snd-gusextreme= Gus extreme

snd-gusmax= Gus Max

snd-interwave= Interwave

snd-interwave-stb= Interwave

snd-opl3sa2= Yamaha OPL3SA2

snd-opti93x= OPTi 82c93x based cards

snd-opti92x-cs4231= OPTi 82c92x/CS4231

snd-opti92x-ad1848= OPTi 82c92x/AD1848

snd-es968= ESS AudioDrive ES968

snd-sb16= SoundBlaster 16

snd-sbawe= SoundBlaster 16 AWE

snd-sb8= Old 8 bit SoundBlaster (1.0, 2.0, Pro)

snd-sgalaxy= Sound galaxy

snd-wavefront= Wavefront

OSS drivers

ad1848= AD1848

adlib= Adlib

mad16= MAD16

pas2= ProAudioSpectrum PAS16

sb= SoundBlaster

uart401= UART 401 (on card chip)

uart6850= UART 6850 (on card chip)

opl3= Yamaha OPL2/OPL3/OPL4 FM Synthesizer (on card chip)

opl3sa= Yamaha OPL3-SA FM Synthesizer (on card chip)

opl3sa2= Yamaha OPL3-SA2/SA3 FM Synthesizer (on card chip)

ALSA PCI Drivers

snd-ali5451= ALi PCI audio M5451

snd-als4000= Avance Logic ALS4000

snd-cmipci= C-Media CMI8338 and 8738

snd-cs4281= Cirrus Logic CS4281

snd-cs46xx= Cirrus Logic Sound Fusion CS46XX

snd-emu10k1= EMU10K1 (SB Live!)

snd-ens1370= Ensoniq ES1370 AudioPCI

snd-ens1371= Ensoniq ES1371 AudioPCI

snd-es1938= ESS Solo-1 (ES1938, ES1946, ES1969)

snd-es1968= ESS Maestro 1/2/2E

snd-fm801= ForteMedia FM801

snd-intel8x0= Intel ICH (i8x0) chipsets

snd-maestro3= ESS Maestro3/Allegro (ES1988)

snd-korg1212= Korg 1212 IO

snd-rme32= RME Digi32, Digi32/8 and Digi32 PRO

snd-nm256= NeoMagic 256AV and 256ZX

snd-rme96= RME Digi96, Digi96/8 and Digi96/8 PRO/PAD/PST

snd-rme9652= RME Digi9652 audio interface

snd-hdsp= RME Hammerfall DSP

snd-sonicvibes= S3 SonicVibes

snd-trident= Trident 4DWave DX/NX & SiS SI7018

snd-via82xx= VIA South Bridge VT82C686A/B/C, VT8233A/C, VT8235

snd-ymfpci= Yamaha DS1/DS1E

snd-ice1712= ICEnsemble ICE1712 (Envy24)




9.1 Old CD-ROM Driver Arguments

aztcd= Aztech Interface


sonycd535= CDU-535 Sony Interface

gscd= GoldStar Interface

isp16= ISP16 Interface

mcd= Mitsumi Standard Interface

mcdx= Mitsumi XA/MultiSession Interface

optcd= Optics Storage Interface

cm206= Phillips CM206 Interface

sjcd= Sanyo Interface

sbpcd= SoundBlaster Pro Interface

10. Serial and ISDN Drivers

10.1 The ISDN drivers

Please see linux/Documentation/isdn/ for the full details of all the options the following ISDN drivers accept.

icn= ICN ISDN driver

pcbit= PCBIT ISDN driver

teles= Teles ISDN driver

10.2 The Serial drivers

Please see linux/Documentation/ and/or the README files in linux/drivers/char for the full details of all the options that the following support.

digi= DigiBoard Driver

riscom8= RISCom/8 Multiport Serial Driver

baycom= Baycom Serial/Parallel Radio Modem

11. Other Hardware Devices

Any other devices that didn't fit into any of the above categories got lumped together here.

11.1 Ethernet Devices (`ether=', `netdev=')




The most common use of this parameter is to force probing for a second ethercard, as the default is to only probe for one (with 2.4 and older kernels). This can be accomplished with a simple:



IMPORTANT NOTE TO MODULE USERS: The above will not force a probe for a second card if you are using the driver(s) as run time loadable modules (instead of having them complied into the kernel). Most Linux distributions use a bare bones kernel combined with a large selection of modular drivers. The ether= only applies to drivers compiled directly into the kernel.

The Ethernet-HowTo has complete and extensive documentation on using multiple cards and on the card/driver specific implementation of the param_n values where used. Interested readers should refer to the section in that document on their particular card for more complete information. Ethernet-HowTo

11.2 The Floppy Disk Driver (`floppy=')

There are many floppy driver options, and they are all listed in floppy.txt in linux/Documentation. There are too many options in that file to list here. Instead, only those options that may be required to get a Linux install to proceed on less than normal hardware are reprinted here.

floppy=0,daring Tells the floppy driver that your floppy controller should be used with caution (disables all daring operations).


floppy=nodma Tells the floppy driver not to use DMA for data transfers. This is needed on HP Omnibooks, which don't have a workable DMA channel for the floppy driver. This option is also useful if you frequently get `Unable to allocate DMA memory' messages. Use of `nodma' is not recommended if you have a FDC without a FIFO (8272A or 82072). 82072A and later are OK). The FDC model is reported at boot. You also need at least a 486 to use nodma.

floppy=nofifo Disables the FIFO entirely. This is needed if you get `Bus master arbitration error' messages from your Ethernet card (or from other devices) while accessing the floppy.

floppy=broken_dcl Don't use the disk change line, but assume that the disk was changed whenever the device node is reopened. Needed on some boxes where the disk change line is broken or unsupported. This should be regarded as a stopgap measure, indeed it makes floppy operation less efficient due to unneeded cache flushings, and slightly more unreliable. Please verify your cable connection and jumper settings if you have any DCL problems. However, some older drives, and also some Laptops are known not to have a DCL.

floppy=debug Print (additional) debugging messages.

floppy=messages Print informational messages for some operations (disk change notifications, warnings about over and underruns, and about autodetection).

11.3 The Bus Mouse Driver (`bmouse=')


11.4 The MS Bus Mouse Driver (`msmouse=')

The MS mouse driver only accepts one parameter, that being the hardware IRQ value to be used.

11.5 The Printer Driver (`lp=')

With this boot argument you can tell the printer driver what ports to use and what ports not to use. The latter comes in handy if you don't want the printer driver to claim all available parallel ports, so that other drivers (e.g. PLIP, PPA) can use them instead.

The format of the argument is multiple i/o, IRQ pairs. For example, lp=0x3bc,0,0x378,7 would use the port at 0x3bc in IRQ-less (polling) mode, and use IRQ 7 for the port at 0x378. The port at 0x278 (if any) would not be probed, since autoprobing only takes place in the absence of a lp= argument. To disable the printer driver entirely, one can use lp=0.

11.6 The Parallel port IP driver (`plip=')

Using plip=timid will tell the plip driver to avoid any ports that appear to be in use by other parallel port devices. Otherwise you can use plip=parportN where N is a non-zero integer indicating the parallel port to use. (Using N=0 will disable the plip driver.)

12. Copying, Translations, Closing, etc.

Hey, you made it to the end! (Phew...) Now just the legal stuff.

12.1 Copyright and Disclaimer

This document is Copyright (c) 1995-1999 by Paul Gortmaker. Copying and redistribution is allowed under the conditions as outlined in the Linux Documentation Project Copyright, available from where you obtained this document, OR as outlined in the GNU General Public License, version 2 (see linux/COPYING).

This document is not gospel. However, it is probably the most up to date info that you will be able to find. Nobody is responsible for what happens to your hardware but yourself. If your stuff goes up in smoke, or anything else bad happens, we take no responsibility. ie. THE AUTHOR IS NOT RESPONSIBLE FOR ANY DAMAGES INCURRED DUE TO ACTIONS TAKEN BASED ON THE INFORMATION INCLUDED IN THIS DOCUMENT.



12.2 Closing

If you have found any glaring typos, or outdated info in this document, please let me know. It is easy to overlook stuff, as the kernel (and the number of drivers) is huge compared to what it was when I started this.


Paul Gortmaker, p_gortmaker @ yahoo.com



Subscribe to Comments Feed

Who we are ?


More About the foundation...

Frequent Questions

Linux Training / Board
