Introduction

• some knowledge of the 386/486 architecture and the PC hardware is essential to understand parts of the code. I would recommend that you have a manual handy when reading the code.

• This description is specific to Linux 1.2.3. I had this version installed on my machine and did not find the need to keep up with the latest updates, so bear with me.

• Most of the info is from the comments that I found along the way and some of it I have put together.

• In all cases I will use the name of the file where the code is contained for some action.
• As far as convention goes, I have used emphasized mode when referring to routines and files, and typewriter mode when referring to macros and variables in the code.

Boot up part done by a PC.

Linux Boot Sequence

• linux/arch/i386/boot/bootsect.S

• Resides in the boot sector.
• Initially boot sector is loaded at 0x7c0 and control is passed to it.
• Move the boot sector to INITSEG(=0x90000) {see figure}
• Set up stack at 0x9000:0x4000-12 The 12 bytes are used for storing drive parameters.
• Copy the drive parameters into the above mentioned reserved location.
• Load setup sectors from disk directly after the boot block.
• Get the number of sectors/track info by probing with different #sectors. This is done as there is no system call which gives the number of sectors/track info.
• Print the message:

   Loading
  
   

• Load system into SYSSEG(=0x10000). This is done by the read_it routine which then calls read_track. The "......" which is printed during the bootup time is printed by the read_track routine.
• Check the data at the end of the bootblock to see if the Root device has been defined. In case it has not been defined, set defaults and store it back.
• Jump to the SETUP code which has been loaded at SETUPSEG (=0x90200) just after the boot block.

 Memory map 

	  0x07c00 |             |  - original boot sector loaded by
		  |             |     BIOS(256 words)
		  |-------------|
	  0x10000 |             |  - SYSSEG, system is loaded here.
		  |-------------|
	  0x20000 |             |
		  |-------------|
	  0x30000 |             |
		  |-------------|
		  z             z
		  |-------------|
	  0x80000 |             | 
		  |-------------|  - INITSEG, Boot sector is moved here
	  0x90000 |-------------|  - setup sectors imm after boot block
		  |             |
		  |_____________|  - 0x9000:0x4000-12, Stack
		  |-------------|  - drive parameters
		  |             |
		  |-------------|
		  |             |
		  |-------------|

 NOTE: Max system size can be 8*65536 - 4096 bytes.

 

• linux/arch/i386/boot/setup.S
• Some code which says "BOOTLIN depends on this being done early" Can't figure out what this means
• Check the signature at the end of setup. Signature should be AA55 5A5A. In case of Bad signature, copy again from where the original SETUP code could be and try again. In case of a failure again, print a message and enter an infinite loop.
• Get the memory size and set the keyboard repeat rate to maximum.
• Check for EGA/VGA and some other? config parameters.
• Get hd0 and hd1 parameters From where? and store it in INITSEG.
• Check if there is a disk 1. In case the first disk is absent clear the data corresponding to the config parameters of the first disk.
• Check if there is a PS/2 mouse.
• Ignore interrupts (cli) and disable NMI for bootup.
• Copy the system to the final location i.e from 0x1000 - 0x90000 below 640K
• Load the segment descriptor registers

  idt (interrupt descriptor table) is loaded with 0x000000

  meaning idt_base = 0x0000, idt_limit = 0x00

  gdt (global descriptor table) is loaded with 0x09(512+gdt)80

  which means gdt_limit = 0x80 => 256 gdt_base = 0x9xxxx+512. Why add 512?

• Enable A20
• Ensure that coprocessor is properly reset. Some delays are inserted here and I don't really know why?
• Setup the interrupts.

  IBM has used 0x08-0x0f for BIOS.

  Reprogram the 8259's to use int 0x20-0x2f

  8259-1 uses interrupts 0x20-0x27

  8259-2 uses interrupts 0x28-0x2f

  and then mask everything off.

• Set the protected mode bit, and jump to the kernel. Since we are now in protected mode, the jump is made to KERNEL_CS:0x1000 Remember that 0x1000 was the location to which the kernel was earlier moved to.
• linux/arch/i386/boot/compressed/head.S:startup_32
  • Check if A20 is enabled.
  • Reset the NT flag, Clear BSS.
  • Call decompress_kernel At this point the kernel resides in the absolute address 0x00001000, decompressing to moves the kernel to a different location. The first page 0-0x1000 is left free. 0x1000 onwards will be use for the page directory.
• linux/arch/i386/compressed/misc.c:decompress_kernel
  • uncompress the kernel and puts it in virtual address 0x1000 0000(=1MB).
• linux/arch/i386/boot/compressed/head.S:startup_32
  • Initialize registers and clear BSS.
  • call setup_idt
    • sets up the interrupt descriptor table with 256 interrupt gates all of which point to the ignore_int routine. The ignore_int routine prints "Unknown Interrupt" message.
  • Check if A20 is enabled and initialize EFLAGS.
  • Copy bootup parameters out of the way into empty_zero_page as illustrated in the memory map figure #2.
  • Check if 386/486 and get the type of the processor.
  • Check for co-processor.
  • call setup_paging
    • Clear both the swapper_pg_dir and pg0 areas. swapper_pg_dir -> page directory pg0 -> kernel page table
    • Make an entry from the pg_dir to setup pg0 as the page table for the kernel.
    • The kernel is then mapped at the virtual addresses

      0x0000 0000 : an identical mapping used when accessing addresses within the kernel.

      0xc000 0000 : to map the kernel into the virtual address space of any other process.

    • Fill up the page table entries for the kernel in pg0
    • Make cr3 point to the swapper_pg_dir(the page directory) and mark paging begin.
  • Load the idtr and gdtr registers to new tables.
  • Clear the ldt register.
  • Call start_kernel(0,0,0).

  	      _________________  0x0000  (Unused)
  	      |               |
  	      |---------------|  0x1000  (swapper_pg_dir)
  	      |               |  0x1c00 & 0x1000 contain entries for kernel
  	      |---------------|  0x2000  (pg0) 
  	      |               |
  	      |---------------|  0x3000  (empty_bad_page)
  	      |               |
  	      |---------------|  0x4000  (empty_bad_page_table)
  	      |               |
  	      |---------------|  0x5000  (empty_zero_page)
  	      |_______________|   - 2KB Bootup params 
  	      |               |   - 2KB Command line args
  	      |---------------|  0x6000  (floppy_track_buffer)
  	      |               |
  
  
  
  			 Memory map 2
  
   

• linux/init/main.c:start_kernel
  • call setup_arch
• linux/arch/i386/kernel/setup.c:setup_arch
  • Get Root device, drive info, screen info, aux device
  • Initialize memory for init_task i.e task 0.
  • Get the command line parameters and set the end & beginning of memory.
  • Allocate I/O space addresses for dma, timer, rtc This is done using calls to request_region, with the device name, and the address range at which this device is mapped.
• linux/init/main.c:start_kernel
  • call paging_init
• linux/arch/i386/mm/init.c:paging_init
  • check if there is a page table associated with the kernel, otherwise allocate space to hold a page table and then map the memory into the page table. Invalidate the page directory register. call free_area_init
• linux/mm/swap.c:free_area_init
  • Set the min number of pages that should be free at any time. The value of this cannot be < 16 (arbitrary).
  • call init_swap_cache
    • Align memory_start
    • The swap_cache contains a pointer for each page in system. Reserve enough memory to hold these pointers and appropriately modify memory_start. Also reset these pointers to 0.
  • Reserve memory for a memory map (a pointer for every page) and set all these to MAP_PAGE_RESERVED. Appropriately modify start_mem.
  • It seems that linux maps free pages using a buddy system. The code here seems to allocate bitmaps for free_area_list (there are 6 of these) and for each case the sizeof the bitmap is halved. Have to inspect the code to confirm that it actually uses a buddy system. All bitmaps are initially set to 0.
• linux/arch/i386/mm/init.c:paging_init
• linux/init/main.c:start_kernel
  • call trap_init
• linux/arch/i386/kernel/traps.c:trap_init
  • set trap gates for page fault, double fault, coprocess, for all the faults and call gates for single_step, bounds and overflow
  • set system entry point to int 0x80
  • set tss and ldt descriptor and initialize all descriptors in the global descriptor table to 0. There are two descriptors for each process in the gdt -- one for tss and one for ldt.
  • Load the ldt and tss registers with 0.
• linux/init/main.c:start_kernel
  • call init_IRQ
• linux/arch/i386/kernel/irq.c:init_IRQ
  • Program the timer chip to interrupt every 10ms.
  • Set the timer interrupt vector.
  • Set all the interrupts from PIC1 to bad_interrupt.
  • Allocate IRQ2 for cascade and IRQ13 for math_error.
  • Allocate I/O space addresses for PIC1(0x20-0x40) and PIC2(0xa0-0xc0)
• linux/init/main.c:start_kernel
  • call sched_init
• linux/kernel/sched.c:sched_init
  • Set the bottom half handlers for timer, tqueue and immediate
  • Allocate through request_irq, TIMER_IRQ(IRQ 0) for the timer interrupt handler -- do_timer. request_irq makes an entry in its internal tables to have the do_timer routine called every time an interrupt arrives or IRQ 0.
  • Enable the bottom half handlers
• linux/init/main.c:start_kernel
  • call parse_options to parse command line options.
  • call init_modules
• linux/kernel/module.c
  • figure out the #symbols in the kernel and setup the #entries field in the kernel symbol table.
  • set the state of the kernel module to RUNNING.
• linux/init/main.c:start_kernel
  • if kernel profiling is turned on, then reserve memory to hold the profiling information.
  • call console_init
• linux/drivers/char/tty.c:console_init
  • Initialize all ldisciplines to 0
  • Register a line discipline for N_TTY(Tty) by making a call to tty_register_ldisc
  • Clear the standard termios structure.
  • Initialize the iflag, oflag, cflag and lflag of the standard termios structure. Initial values are as follows:

    iflag -> ICRNL+IXON

    oflag -> OPOST+ONLCR

    cflag -> B38400+CS8+CREAD

    lflag -> ISIG+ICANON+ECHO+ECHOE+ECHOK+ECHOKE+ECHOCTL+IEXTEN

    For meaning of the initialized values see man stty.
  • call con_init
• linux/drivers/char/console.c:con_init
  • Initialize the console_driver (tty_driver struct) for the console. The console_driver structure contains functions to open,close read/ioctl the console device.
  • call tty_register_driver
• linux/drivers/char/tty_io.c:tty_register_driver
  • calls `linux/fs/devices.c:register_chrdev' to register the device as a character device. register_chrdev performs sanity checks to see if the major device number is within the correct range and then associate a set of file operations with the device. It also checks to see if the device has already been registered. **The reason why the console driver has to be registered with the file system is because all devices are accessed via the file system, so the file system should know which routines to call, when requests are made to this device.
  • add the console driver to the kernel list of tty drivers.
• linux/drivers/char/console.c:con_init
  • call con_setsize to set the default number of rows and columns on the console.
  • set a timer to blank out the screen on expiry
  • Check type of the display (monochrome/EGA/VGA) and depending on display type reserve addresses in the I/O address space by calling request_region with appropriate values.
  • Initialize virtual consoles for MIN_NR_CONSOLES (1) by allocating meory and moving start_mem above that area. Initialize the vc struct fields by calling vc_init. vc_init also does a few other things which I have not been able to figure out as yet
  • Set the current foreground console, initialize the cursor position, clear the screen to the end and print

     Console EGA ...80x24...
    
     

  • call register_console
• linux/kernel/printk.c:register_console
  • called during console initialization time to initialize the console driver printing function with the printk routine. This allows all printk's of kernel to print directly to the console. Also prints all kernel generated messages thru printk which occured before the console driver was initialized.
• linux/drivers/char/console.c:con_init
• linux/drivers/char/tty.c:console_init
• linux/init/main.c:start_kernel
  • call bios32_init
• linux/arch/i386/kernel/bios32.c:bios32_init
  • Checks for a valid BIOS signature from 0xe000 to 0xffff. Flag an error if more than one entry is found.
  • call pci_biosinit Haven't figured out how this works as yet.
  • call probe_pci
• linux/init/main.c:start_kernel
  • call kmalloc_init
• linux/mm/kmalloc.c:kmalloc_init
  • The total amount of memory available for kmalloc, is 128K, and is managed by using an array of structures called sizes. Memory is managed in powers of 2 called order. The kmalloc_init() routine performs some sanity checking on this structure to determine if in each order the sum of the available memory + data_structure with each allocated block < total kmallocable memory. System will panic if any such inconsistency is found.
• linux/init/main.c:start_kernel
  • call calibrate_delay
  • Computes the BogoMips of the machine. This is computed by trying to estimate the number of iterations of a loop that can be executed in 1s. Since the loop which is executed contains 2 instructions/iteration, divinding loops_per_sec/500000 gives the BogoMips rating.
  • call chr_dev_init
• linux/drivers/char/mem.c:chr_dev_init
  • Register memory as a character device with the file system, using register_chrdev
  • call tty_init
• linux/drivers/char/tty_io.c:tty_init
  • First check to see if the size of the tty_structure is > PAGE_SIZE. What purpose does the tty_struct serve?
  • Register tty and cua(AUX device) devices with the file system using register_chrdev
  • call kbd_init
• linux/drivers/char/keyboard.c:kbd_init
  • Initialize keyboard_structures. (One for each virtual console). kbd_struct is defined in linux/drivers/char/kbd_kern.h, and seems to have some fields for setting LED etc. Don't know what it is exactly used for.
  • Set the bottom half handler of the keyboard device to kbd_bh
  • Grab the IRQ for keyboard using a call to request_irq
  • Reserve I/O space addresses for keyboard using request_region
  • There is some special processing done here for if the machine is an alpha, which I have conveniently omitted to understand.
  • Enable the keyboard bottom half handler.
• linux/drivers/char/tty_io.c:tty_init
  • call rs_init
• linux/drivers/char/serial.c:rs_init
  • rs_init is used to initialize tty devices connected on the serial port using the RS232C connector.
  • Setup and enable a bottom half handler for the serial device.
  • Setup a timer.
  • If auto configuring of IRQ is turned on, check if the system is generating any wild interrupts by calling check_wild_interrupts. This routine returns a bitmap of IRQ's which generate wild interrupts. Such IRQ's are ignored while autoprobing for the serial port IRQ is done at a later stage.
  • An array of IRQ_ports and IRQ_timeouts is initialized to 0. The IRQ_ports seems to be an array of per IRQ pointers to the UART structures. Have to still figure out what the timeouts are for
  • call show_serial_version to print the message

     Serial driver 4.11 ....
    
     

  • Initialize the serial_driver structure for the ttyS and the callout_device structure for cua. The ttyS device is for attaching ttys/slip/mouse, while the cua device is used for modems.
  • Register the serial_driver and the callout_driver with the other tty drivers using tty_register_driver. Similar to how the console driver was registered earlier.
  • Information about each serial line is stored in a table of async_struct. Some fields of this table -- rs_table -- are statically initialized. The remaining fields are now initialized and a call to autoconfig is made with the port address of the tty line.
    • first attempts to check for existence of the serial port.
    • If that succeeds it tries the loopback test (provided the flag for that is set).
    • calls do_auto_irq to get the IRQ number associated with the chip. This is done by grabbing all the unassigned IRQs, and setting each of the these to rs_probe. rs_probe when executed will set a flag and the IRQ number which triggered it off. Then make two attempts to generate a serial port interrupt and identify the IRQ line on which the interrupt was received. If the IRQ identified in both cases match, a positive identification has been done, so free all the interrupts that were grabbed(free_all_interrupts).
    • Probe and determine the UART chip used.
    • Reserve I/O space addresses for the serial device using request_region
  • If autoconfig succeeded in determining the chip, print the message

   ttyS at addr(irq)....
  
   

• linux/drivers/char/tty_io.c:tty_init
  • call cyc_init if cyclom card is present.
• linux/drivers/char/cyclades.c:cyc_init
  • Most of the stuff is similar to that of the serial driver described above.
  • Show version of the driver
  • Initialize cy_serial_driver and cy_callout driver and register them with the list of tty drivers using tty_register_driver.
  • Set up and enable the bottom half handler do_cyclades_bh.
  • The IRQ_cards structure is initialized to 0. This is a per IRQ array of pointers to the cyclades_card structure which maps an IRQ number to the corresponding card.
  • Scan through the table cy_card which contains all possible base addresses of the card along with the corresponding IRQ number, number of chips and the line number of the first channel on the card. The base address field alone is statically initialized. On detection of a card, the remaining fields are filled up.
  • The existence and number of chips on the card is determined by making a call to cyc_init_card. It seems that the cyclades card is memory mapped rather than I/O mapped.
  • If autoprobing of IRQs is turned on, use do_auto_irq to determine, the IRQ used by the card. If an IRQ is found bind it to the card using request_irq Also initialize the corresponding entry of the IRQ_cards array to point to the cyclades_card structure.
  • Since each card can have multiple ports associated with it, the state of each of the ports has to be initialized.
  • All remaining ports are initialized to 0.
• linux/drivers/char/tty_io.c:tty_init
  • call pty_init
• linux/drivers/char/pty.c:pty_init
  • initialize the pty_driver and the pty_slave_driver structures and register them with the kernel list of tty drivers using tty_register_driver routine
• linux/drivers/char/tty_io.c:tty_init
  • call vcs_init
• linux/drivers/char/vc_screen.c:vcs_init
  • register the file operations structure for handling virtual consoles with register_chrdev
• linux/drivers/char/tty_io.c:tty_init
• linux/drivers/char/mem.c:chr_dev_init
  • call lp_init
• linux/drivers/char/lp.c:lp_init
  • Register the file operations associated with the printer with the kernel file system using register_chrdev.
  • The lp_table structure contains all possible port values and addresses that can be taken by the line printer.
  • Use the base address as specified in the lp_table structure and check if the address range required is free. This is done by making a call to check_region with the address range as arguments. check_region goes through the list of I/O address ranges which have reserved by other drivers in the kernel(using request_region).
  • If the default address range is free, then probe the associated port by writing to it and the reading back the value after some delay.
  • If the probe succeeded, then mark the existence of the port by making a corresponding entry in the lp_table. Then reset the printer, reserve the I/O address range used by the printer with a call to request_region. Finally print the message

     lp. at ....
    
     

  • There seems to be no probing for the IRQ to be used with the line printer driver. The defaults in the lp_table assume that no IRQs are used with the lp_table and this does not seem to get modified anywhere. Is this right?
• linux/drivers/char/mem.c:chr_dev_init
  • call mouse_init
• linux/drivers/char/mouse.c:mouse_init
  • call bus_mouse_init, if configured for a bus mouse
• linux/drivers/char/busmouse.c:chr_dev_init
  • Configure the mouse port to check existence.
  • Write a signature byte to the signature port, delay for some time and then read it back. If the byte read from the port is not the same as what was written, return back reporting absence of mouse.
  • Now configure it to the default values and set up the mouse driver.
  • Print the message

     Logitech Bus Mouse ....
    
     

• linux/drivers/char/mouse.c:mouse_init
  • call psaux_init, if configured for a PS Mouse or a 82710 mouse.
• linux/drivers/char/psaux.c:psaux_init
  • check for 82C710 type of pointing device by calling probe_qp
    • As an aside, the qp in probe_qp seems to be due to quickport. Some explanation as to why references within the file have been changed from quickport to 82C710.
    • write some config information to the device address. The code write 0x55 and 0xAA(0xAA=~0x55). Then addresses the chip and writes 0xe4 & ~0xe4=0x1b. 0xe4=390/4 where 390 is the config address.
    • Then it tries reading back the config address and if it is not 0xe4, then the probe has failed.
    • Else initializes qp_data and qp_status and closes the chip config mode.
    • The details of why the above sequence was done is chip specific, and I don't really know what it means. I just copied it out from the comments with the code.
  • print the message.

     82C710 at .....
    
     

  • Initialize psaux_fops read and write routines.
  • call poll_qp_status to check if the receive and transmit buffer is empty.
  • All the initialization for the 82C710 type device is over. Now test for a PS/2 type device.
  • Check if the aux_device_present variable is set to 0xaa. This value is initialized in setup_arch
  • In case the device is absent return back, otherwise print the message

     PS/2 auxiliary ....
    
     

    poll the status of the device.
  • Reserve some memory to hold pointers to a queue.
  • If aux device detected, the initialize the aux device.
• linux/drivers/char/mouse.c:mouse_init
  • call ms_bus_mouse_init, if configured for a Microsoft Bus mouse.
• linux/drivers/char/msbusmouse.c:ms_bus_mouse_init
  • Initialize the mouse driver.
  • Get a byte from the signature port and check if it is 0xde.
  • Get another byte from the signature port and store it in mse_byte . Does the MSE_SIGNATURE_PORT return a 16-bit value whose first byte is always 0xde?
  • Repeat this process of getting both signature bytes from the signature port 4 times and compare the second byte with mse_byte .
  • If the same value is read everytime from the port, then mark the mouse device as present.
  • Disable the mouse from generating interrupts.
  • Print the message

     Microsoft BusMouse detected and installed.
    
     

• linux/drivers/char/mouse.c:mouse_init
  • call atixl_busmouse_init, if configured for a ATI-XL busmouse.
• linux/drivers/char/atixlmouse.c:atixl_busmouse_init
  • Read from the signature port thrice. If first two values are different and first value == third value mouse has been detected. Print the message

     ATI inport
    
     

  • Reset the device and initialize the values of the mouse driver.
  • Print the message

     Bus mouse detected and installed.
    
     

• linux/drivers/char/mouse.c:mouse_init
  • Register the mouse driver with the filesystem using register_chrdev
• linux/drivers/char/mem.c:chr_dev_init
  • call soundcard_init, if configured to detect the soundcard.
• linux/drivers/sound/soundcard.c:soundcard_init
  • Register the file operations structure for the sound card with the file system using register_chrdev
  • Set a flag soundcard_configured to indicate that the driver for the soundcard has been installed.
  • There is a lot more stuff here, but I am ignoring it at present as I don't have a sound card. Later when I find time, Will complete this section
• linux/drivers/char/mem.c:chr_dev_init
  • call qic02_tape_init
• linux/drivers/char/tpqic02.c:qic02_tape_init
  • Perform some sanity checks like checking if the size of tpstatus struct is correct and if DMA buffer size is correct.
  • Print a message and call qic02_get_resources if dynamic configuration not set.
    • Check if IRQ number requested is valid and then make a call to request_irq to register qic02_tape_interrupt as the interrupt routine.
    • Request a DMA channel for the tape by making a call to request_dma. request_dma checks if the requested dma channel is free, in which case it is alloted to the requesting device.
    • Print a message indicating the the status of the tape driver configuration so far.
    • call tape_reset
      • call ifc_init to initialize the interface.
      • reset the chip, wait for 30s and then deassert the reset I think this does a rewind
    • call tp_sense
      • Reads drive status and sets generic status.
      • It first waits for the current read or write to finish. This is done by first busy waiting followed by sleeping and finally timing out the current operation.
      • Then it gets the current drive status using get_status. Then sets the generic status gs and initializes the ioctl status structure for the tape drive.
  • This part of the code deals with dynamic configuration of the device.
  • First print the message

     Runtime config .....
     DMA buffers...
     

  • Get the address of the tape buffer for DMA transfer and align it to TAPE_BLKSIZE boundary and print the address of the tape buffer. Also perform a check to see if buffer is in low 16M of memory (if reqd by CONFIG_MAX_16M.)
  • Register the tape driver qic02_tape_fops with the filesystem using register_chrdev
  • Turn off the timer for the tape driver.
  • Initialize the generic status (ioctl_status) for the tape drive.
• linux/drivers/char/mem.c:chr_dev_init
  • If FTAPE is configured, allocate NR_FTAPE_BUFFERS of each 32KB aligned and print the message

     ftape: allocated .....
    
     

• linux/init/main.c:start_kernel
  • call blk_dev_init
• linux/drivers/block/ll_rw_blk.c:blk_dev_init
  • The kernel maintains a table of request structures for all the block devices all_requests. Each of the request structures, contains all information about the request such as the device number, the command, the number of sectors, the address, buffer head etc.
  • The all_requests table is first initialized by making all device field of all the structures = -1, indicating an inactive entry.
  • ro_bits is then cleared. ro_bits is a bitmap for used to make a device readonly.
  • Now comes the part where each device is detected and the appropriate driver initialized.
  • call hd_init if CONFIG_BLK_DEV_HD is set.
• linux/drivers/block/hd.c:hd_init
  • Register the file operations for the hard disk device with the kernel file system file operations using register_blkdev. register_blkdev registers the file operations with the file system depending on the MAJOR device number of the device. In case the major device number of the device is 0, it triesa to register the device with the highest available device number upto MAX_BLKDEV.
  • Set up the request function for this device by making blk_dev[HD_MAJOR].request_fn = do_hd_request
  • Set the number of sectors to read ahead for the hard disk to 8.
  • There is some stuff about hd_gendisk.next..., which needs some figuring out.
  • Set the timer routine for the hard disk.
• linux/driver/block/ll_rw_blk.c:blk_dev_init
  • call ide_init if configured for ide drivers.
• linux/driver/block/ide.c:ide_init
  • The ide driver can support two interfaces, and on each of these interfaces upto MAX_DRIVES(=2). Each of these drives could have multiple partitions, specified by the bits in the minor device number which are reserved for this purpose -- PARTN_BITS(=6). All device information is stored in a two dimensional table ide_dev indexed by the interface and the drive number. The initialization sequence described below has to be carried out for each of the hardware interfaces.
  • call init_ide_data
    • For each logical drive (partition) in this interface, initialize the blocksize (ide_blksizes) to 1K.
    • Set the default blocksize for the device.
    • Initialize the non-geometry fields of ide_dev. There is comment here that ide_setup runs before this routine, but have not been able to trace the point at which the call to ide_setup is made.
  • For hardware interface 0, then call probe_cmos_for_drives to detect the presence of drives.
    • Read from the CMOS address 0x12. The state of each nibble(=0xf) indicates the presence of the disk.
    • The disk geometry can now be determined from the BIOS, so fields of ide_dev[0].drive number can be initialized. Sets dev->present for the detected drives. Recall that as one of the first steps in the setup_arch routine, we got the disk parameters and saved it. That is now used for the above initialization.
    CMOS and BIOS do not contain information about the drives connected to the second hardware interface, and these have to be detected by probing. Therefore dev->present will not be set for the drives connected on the second ide interface.
  • call probe_for_drives to identify all drives on this interface.
• linux/drivers/block/ide.c:probe_for_drives
  • Check if the range of I/O addresses used by the IDE driver is free. If it is not free report an error and return back.
  • The remaining section of the code, probes for the devices, initializes them and then reserves I/O addresses.
  • First allow interrupts, this is required in identifying the IRQ.
  • call probe_for_drive for the first drive on the interface.
• linux/drivers/block/ide.c:probe_for_drive
  • If dont_probe is set for this device, then return back.
  • call do_probe with the ide device structure and ask it to identify itself
    • First checks to see if the probed device is a CDROM the command is a WIN_IDENTIFY in which case it returns back. Since CDROMS use the ATAPI interface use WIN_PIDENTIFY instead.
    • Select the target drive, wait for 10ms and then read from the drive again. If the value returned by the read is not the same as what was written out, and the device structure does not indicate the presence of the device, then return back with an error value of 3 indicating bad status from device. The OUT_BYTE and IN_BYTE macros used here automatically compute the effective I/O port address depending on the port address provided to the macro and the number of the ide interface used.
    • If the device is ready and not busy or is present or the command is WIN_PIDENTIFY make two attempts to identify the device type by calling try_to_identify
      • Disable device from generating an interrupt
      • if PROBE_FOR_IRQS is defined, then first check if an IRQ has already been probed for and located for the current interface, then grab all the available IRQs, and enable the device IRQ for the device.
      • Wait for 10ms.
      • Read with both the HD_STATUS and HD_ALTSTATUS commands and check if they are the same for all the fields. If they differ, then the drive is an Old Seagate drive (so says the comment), use the HD_STATUS command. The difference between the two commands is that HD_STATUS will clear the IRQ field.
      • Send a command to ask for the drive ID and set a time out. The timeout is 15s for a hard drive an 0.5s for a CDROM.
      • Wait till either the timeout occurs (in which case turn off the IRQ probing and return with an error value of 1) or till the drive status stops being BUSY.
      • Check the status of the last operation to see if any error occured, in which case, return with an error value of 2.
      • If no error occured call do_identify to read the drive identification into internal tables.
        • Reserve memory for storing the device id.
        • Read 512 bytes of id info from the drive using the IN_SECTORS macro.
        • The WIN_PIDENTIFY may sometimes return values in Big-endian, so using the model, find out if conversion is required and set a flag.
        • Check if the command was for WIN_PIDENTIFY and depending on the type of the drive, print the identification message on the console and return.
        • For hard disk drives, more processing is required. First extract the disk geometry if one is not already found. This will occur in the case of the drives connected to the second interface, for which information is not found in the CMOS/BIOS.
        • Next check if the logical geometry of the device has defined in which case replace the values of the drive geometry stored earlier with these logical values.
        • If the drive geometry thus obtained is incorrect, i.e it has impossible values for #heads, then reset back to the values in the physical drive geometry.
        • Correct the #cylinders value if the value obtained from BIOS is too small.
        • Determine the capacity of the disk in #sectors? If lba is supported by the drive use it otherwise compute capacity as #cylinders*#heads*#sectors. No idea as to what lba is
        • Print the message:

           hd.: ...   w/..Cache, .... CHS=././.
          
           

        • Determine the maximum number of Multiple sectors which can be read from the disk and print this info. There is some stuff here about multsect which I hope means this. Correct me if I am wrong.
      • Set return value = 0, indicating successful identification of drive.
      • If IRQ probing was turned on, then turn it off using probe_irq_off,which returns the IRQ number which generated the interrupt. Multiple IRQs are indicated by a negative value for the IRQ number and 0 indicates failure. In case of successful probing of IRQ, initialize the IRQ number for the current interface, otherwise indicate failure and print a message.
    • If try_to_identify fails twice in succession, then print the status of the device and a message indicating failure.
    • Disable the device irq,wait for 10ms and ensure that drive irq is clear by reading the device status.
    • If the currently selected drive on the interface is the second drive, then reset it to the first, disable the irq, wait for 10ms and return with the error code.
  • If do_probe failed the last time, use it with WIN_PIDENTIFY to detect a CDROM drive.
  • If drive still not detected return with a value 0, indicating unsuccessful probe.
  • If the id field is NULL, print an error message indicating presence of non-IDE device.
  • Indicate presence of device and return.
  • If the device type is a CDROM, call cdrom_setup to set up the drive configuration.
  • If device is disk then check if the #heads lies within the correct range otherwise print an error message.
  • return indicating successful probe.
• linux/drivers/block/ide.c:probe_for_drives
  • If probe_for_drive returned successfully for the first drive, or it there is a second drive present on the interface, probe for the second drive using probe_for_drive.
  • Clear any IRQs.
  • If a drive has been detected on this interface, then reserve I/O addresses for the interface by making a call to request_region.
  • Restore the flags which were saved earlier befor allowing interrupts.
• linux/drivers/block/ide.c:ide_init
  • Now setup the generic hard disk structure. First comes the number of devices attached to each of the interfaces.
  • Check if the IRQs used by the two interfaces are the same and if option for sharing the IRQs has been turned on, then set sharing_single_irq. Otherwise print an error message and return.
  • Check if the second interface uses IRQ 14, which clashes with the IRQ # used by the old harddisk driver. So print an error message and return.
  • For each of the interfaces, the devices, request functions and irqs have to be registered.
  • First setup the IRQ handler through setup_irq which in turn calls register_irq to register the handler for the irq. In case sharing of irqs is required a single handler is used, otherwise two handlers have to be installed.
  • Next register the file operations on the device with the file system using a call to register_blkdev
  • Then setup the routines to be called on expiry of the timer.
  • Set up the request functions for the interfaces. Again if irq is shared, use a common function.
  • Finally add the generic disk structure to the kernel list of generic disk structures pointed to by gendisk_head.
  linux/drivers/block/ll_rw_blk.c:blk_dev_init
  • call xd_init to initialize XT hard disk driver.
  linux/drivers/block/xd.c:xd_init
  • Register the file operations for the XT hard disk driver with the file system using register_blkdev.
  • Set up the request function and the read ahead for the device.
  • xd_gendisk is the generic disk structure for the XT hard disk. Add it to the kernel list of generic disk structures.