Subversion Repositories shark

/*
 * Project: S.Ha.R.K.
 *
 * Coordinators:
 *   Giorgio Buttazzo    <giorgio@sssup.it>
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *
 * Authors     :
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *   Massimiliano Giorgi <massy@gandalf.sssup.it>
 *   Luca Abeni          <luca@gandalf.sssup.it>
 *   (see the web pages for full authors list)
 *
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
 *
 * http://www.sssup.it
 * http://retis.sssup.it
 * http://shark.sssup.it
 */

/***************************************

  CVS :        $Id: ide.c,v 1.1.1.1 2002-03-29 14:12:49 pj Exp $
 
  Revision:    $Revision: 1.1.1.1 $

  Last update: $Date: 2002-03-29 14:12:49 $

  This module contains IDE initialization, IDE glue between
  the "block device" module and the IDE low level module and some
  usefull function used by the low level module.

***************************************/

/*
 * Copyright (C) 19992,2000 Massimiliano Giorgi
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "glue.h"

#include <fs/sysmacro.h>
#include <fs/major.h>
#include <fs/magic.h>
#include <fs/bdevinit.h>
#include <fs/assert.h>
#include <fs/maccess.h>
#include <fs/assert.h>

#include "sysind.h"
#include "bdev.h"
#include "phdsk.h"
#include "lodsk.h"
#include "ide.h"
#include "idereq.h"

/*
 * FLAGS
 */

/*+ if defined: scan for device on interface also if soft reset fail +*/
#define FORCE_SCANNING 1
//#undef FORCE_SCANNING

/*+ if defined: use PIO (polled) I/O on all interfaces, disable DMA +*/
#define FORCE_PIOMODE 1
//#undef FORCE_PIOMODE

/*+ if 1: search only master device (no slave) +*/
/*+ if 0: search master and slave device +*/
#define ONLY_MASTER 1

/*
 * DEBUG
 */

/*+ if defined: trace initialization ++*/
#define TRACE_INIT KERN_DEBUG
#undef TRACE_INIT

/*+ if defined: trace ide_scan() [to find devices] +*/
#define TRACE_IDESCAN KERN_DEBUG
#undef TRACE_IDESCAN

/*+ if defined: trace ide_scandisk() [to find logical layout] +*/
#define TRACE_IDESCANDEV KERN_DEBUG
#undef TRACE_IDESCANDEV

/**/

/*+ these are debug macros... +*/

#ifdef TRACE_INIT
#define printk0(fmt,args...) \
        printk(TRACE_INIT "ide_init: " fmt,##args)
#else
#define printk0(fmt,args...)
#endif

#ifdef TRACE_IDESCAN
#define printk1(fmt,args...) \
        printk(TRACE_IDESCAN "ide_scan: " fmt,##args)
#else
#define printk1(fmt,args...)
#endif

#ifdef TRACE_IDESCANDEV
#define printk2(fmt,args...) \
        printk(TRACE_IDESCANDEV "ide_scandisk: " fmt,##args)
#else
#define printk2(fmt,args...)
#endif

/*
 *
 *
 */

/*+ Name used by this block device +*/
static char device_name[]="ide";

// /dev/ide/hd-i0mp1

/*+ Mantains informatio about a single interface +*/
/* warning: must not cross 4KBytes boundaries (required for DMA operations) */
struct ideinfo ide[MAXIDEINTERFACES]={{0}};
//struct ideinfo ide[MAXIDEINTERFACES] __attribute__((nocommon));
//struct ideinfo ide[MAXIDEINTERFACES] __attribute__((section("ide_section")))=
//{0};

/*+ Mantains information about every physical device +*/
static struct ideminorinfo mtable[MAXIDEMINOR];

/*
 *
 *
 *
 */

//#ifndef NDEBUG
void ide_dump_status(void)
{
  int i;

  printk(KERN_INFO "ide block device status:");
  for (i=0;i<MAXIDEINTERFACES;i++)
    if (!is_ide_free(i)) {
      printk(KERN_INFO "  ide%i:",i);
      printk(KERN_INFO "    errors: %i",ide[i].errors);
    }
}
//#endif

/*
 * how parameters are mapped to device minor number:
 *
 *   7   6   5   4   3   2   1   0
 * ---------------------------------
 * I   .   .   I   I   .   .   .   I
 * ---------------------------------
 *       ^       ^         ^
 *       I       I         I-- logical disk (aka partition)
 *       I       I------------ drive id     (aka master,slave)
 *       I-------------------- interface
 */

/*++++++++++++++++++++++++++++++++++++++
 
  Convert an interface id, driver id, logical disk to a device id.

  __dev_t idemakedev
    return a device id

  int ideif
    ide interface sequential number

  int drv
    ide channel (IDE_MASTER, IDE_SLAVE)

  int lodsk
    logical disk (aka partition) on than device
  ++++++++++++++++++++++++++++++++++++++*/

static __inline__ __dev_t idemakedev(int ideif,int drv,int lodsk)
{
  return makedev(MAJOR_B_IDE,((ideif&0x7)<<5)|((drv&0x1)<<4)|(lodsk&0xf));
}

/*++++++++++++++++++++++++++++++++++++++
 
  Extract an interface id from a device id.

  int idehwif
    return an interface id

  __dev_t dev
    device id to parse
  ++++++++++++++++++++++++++++++++++++++*/

static __inline__ int idehwif(__dev_t dev)
{
  return minor(dev)>>5;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Extract a drive id from a device id.

  int idedriveid
    return a device id

  __dev_t dev
    device id to parse
  ++++++++++++++++++++++++++++++++++++++*/

static __inline__ int idedriveid(__dev_t dev)
{
  return (minor(dev)&0x10)?1:0;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Extract a logical disk id from a device id.

  int idelodsk
    return a logical disk id

  __dev_t dev
    device id to parse
  ++++++++++++++++++++++++++++++++++++++*/

static __inline__ int idelodsk(__dev_t dev)
{
  return minor(dev)&0xf;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Extract the minor part of a device number.

  int idemindex
    return a device minor number

  __dev_t dev
    device id to parse
  ++++++++++++++++++++++++++++++++++++++*/

static __inline__ int idemindex(__dev_t dev)
{
  return minor(dev);
}


/*++++++++++++++++++++++++++++++++++++++
 
  Parse a device minor number from a device id and a logical disk id.

  int idemindexext
    return a device minor number

  __dev_t dev
    device id to parse

  int lodsk
    logical disk id to parse
  ++++++++++++++++++++++++++++++++++++++*/

static __inline__ int idemindexext(__dev_t dev, int lodsk)
{
  return minor(dev)+(lodsk&0xf);
}

/* --- */

//#ifndef NDEBUG
int ide_dump_startsize(__dev_t dev, __blkcnt_t *start, __blkcnt_t *size)
{
  int i;
  if (major(dev)!=MAJOR_B_IDE) return -1;
  i=idemindex(dev);
  if (mtable[i].used) {
    *start=mtable[i].start;
    *size=mtable[i].size;
    return 0;
  }
  return -1;
}
//#endif

/*
 *
 * to manage struct ata_diskid
 *
 */

/*++++++++++++++++++++++++++++++++++++++
 
  Dump, using printk(), the "important" information returned by an ide
  device in response to an ATA IDENTIFY request.

  struct ata_diskid *ptr
    pointer to the structure returned by an IDENTIFY command
   
  struct ide_diskinfo *info
    pointer to the disk information structure (build decoding an
    ata_diskid structure)
  ++++++++++++++++++++++++++++++++++++++*/

static void ide_dump_diskid(struct ata_diskid *ptr,
                            struct ide_diskinfo *info)
{
  char atabuf[256];
  int i,j;
 
  if (is_ATA4(ptr)||is_ATA3(ptr)||is_ATA2(ptr)||is_ATA(ptr)) {
    i=0;
    if (is_ATA(ptr)) {
      atabuf[i++]='1';
      atabuf[i++]=' ';
    }
    if (is_ATA2(ptr)) {
      atabuf[i++]='2';
      atabuf[i++]=' ';
    }
    if (is_ATA3(ptr)) {
      atabuf[i++]='3';
      atabuf[i++]=' ';
    }
    if (is_ATA4(ptr)) {
      atabuf[i++]='4';
      atabuf[i++]=' ';
    }
    atabuf[i++]='\0';
  } else
    /* actualy only ATA disk are recognized */
    sprintf(atabuf,"?");

  printk(IDELOG "    device         : hard disk");
  printk(IDELOG "    model          : %s",ptr->model);
  printk(IDELOG "    serial         : %s",ptr->serial);
  printk(IDELOG "    firmware rev   : %s",ptr->firmware);
  printk(IDELOG "    default C/H/S  : %i/%i/%i",
         ptr->def_cyls,ptr->def_heads,ptr->def_sects);
  printk(IDELOG "    total capacity : ~%4.3f GBytes",
         (double)ptr->lba_capacity/(1024.0*1024.0*2.0));
  printk(IDELOG "    ATA            : %s",atabuf);
  printk(IDELOG "    LBA            : %s",is_LBAcapable(ptr)?"yes":"no");

  i=0;
  if (info->max_pio_mode<0) strcpy(atabuf,"none");
  else {
    for (j=info->max_pio_mode;j>=0;j--) {
      strcpy(atabuf+i,"pio"); i+=3;
      atabuf[i++]=j+'0';
      atabuf[i++]=' ';
    }
    atabuf[i++]='\0';
  }
  printk(IDELOG "    PIO modes      : %s",atabuf);

  i=0;
  if (info->max_dma_mode<0) strcpy(atabuf,"none");
  else {
    for (j=info->max_dma_mode;j>=0;j--) {
      strcpy(atabuf+i,"mword"); i+=5;
      atabuf[i++]=j+'0';
      atabuf[i++]=' ';
    }
    atabuf[i++]='\0';
  }  
  printk(IDELOG "    DMA modes      : %s",atabuf);
 
  i=0;
  if (info->max_udma_mode<0) strcpy(atabuf,"none");
  else {
    for (j=info->max_udma_mode;j>=0;j--) {
      strcpy(atabuf+i,"udma"); i+=4;
      atabuf[i++]=j+'0';
      atabuf[i++]=' ';
    }
    atabuf[i++]='\0';
  }
  printk(IDELOG "    UDMA modes     : %s",atabuf);    
}

/*++++++++++++++++++++++++++++++++++++++
 
  Dump, using printk(), the "important" information returned by an ide
  device in response to an ATAPI PACKET IDENTIFY request.

  struct atapi_diskid *ptr
    pointer to the structure returned by a PACKET IDENTIFY command
  ++++++++++++++++++++++++++++++++++++++*/

static void ide_dump_atapidiskid(struct atapi_diskid *ptr)
{
  char atabuf[16];
  //__uint8_t *p;
  char *dev;
  int i=0;
 
  if (is_ATAPIdevice(ptr)) {
    strcpy(atabuf,"ATAPI ");
    i=6;
  }
 
  if (is_ATA4(ptr)||is_ATA3(ptr)||is_ATA2(ptr)||is_ATA(ptr)) {
    if (is_ATA(ptr)) {
      atabuf[i++]='1';
      atabuf[i++]=' ';
    }
    if (is_ATA2(ptr)) {
      atabuf[i++]='2';
      atabuf[i++]=' ';
    }
    if (is_ATA3(ptr)) {
      atabuf[i++]='3';
      atabuf[i++]=' ';
    }
    if (is_ATA4(ptr)) {
      atabuf[i++]='4';
      atabuf[i++]=' ';
    }
    atabuf[i++]='\0';
  } else {
    /* actualy only ATA disk are recognized */
    atabuf[i++]='?';
    atabuf[i++]='\0';
  }

  if (is_directdev(ptr)) dev="direct";
  else if (is_sequentialdev(ptr)) dev="sequential";
  else if (is_printerdev(ptr)) dev="printer";
  else if (is_processordev(ptr)) dev="processor";
  else if (is_writeoncedev(ptr)) dev="write once";
  else if (is_cdromdev(ptr)) dev="cd-rom";
  else if (is_scannerdev(ptr)) dev="scanner";
  else if (is_opticalmemorydev(ptr)) dev="optical memory";
  else if (is_mediachengerdev(ptr)) dev="media changer";
  else if (is_communicatordev(ptr)) dev="communicator";
  else if (is_arraydev(ptr)) dev="array";
  else dev="?";
 
  printk(IDELOG "    device         : %s",dev);
  printk(IDELOG "    model          : %s",ptr->model);
  printk(IDELOG "    serial         : %s",ptr->serial);
  printk(IDELOG "    firmware rev   : %s",ptr->firmware);
  printk(IDELOG "    ATA            : %s",atabuf);  
}
 
/*
 *
 * Interface the "block device" module to the low-level routine
 *
 */

/*
void dump_buffer(__uint8_t *buf)
{
  int i;
  for (i=0;i<512;i++) {
    cprintf("%02x ",(int)*(buf+i));
    if (i%16==15) cprintf("\n");
  }
}
*/


/*++++++++++++++++++++++++++++++++++++++
 
  Try to lock a device.
  (A device can be locked if the device is a partition and the whole
  disk is not locked or if the device is the whole disk and any partititions
  have been locked).
 
  int ide_trylock
    return ?_ERR on error, ?_OK on success and, ?_CANT on failure
   
  __devt_t device
    device to use
  ++++++++++++++++++++++++++++++++++++++*/

static int ide_trylock(__dev_t device)
{
  int i,ind,ind2;
 
  ind=idemindex(device);
  assertk(ind>=0&&ind<MAXIDEMINOR);
 
  if (!mtable[ind].used) return TRYLOCK_ERR;

  if (mtable[ind].blocked) return TRYLOCK_CANT;
 
  if (idelodsk(device)==0) {
    for (i=1;;i++) {
      ind2=idemindex(idemakedev(idehwif(device),idedriveid(device),i));
      assertk(ind2>=0&&ind2<MAXIDEMINOR);
      if (ind2==ind) {
        mtable[ind].blocked=1;
        return TRYLOCK_OK;
      }
      if (!mtable[ind2].used) continue;
      if (mtable[ind2].blocked) return TRYLOCK_CANT;
    }
  }

  ind2=idemindex(idemakedev(idehwif(device),idedriveid(device),0));
  assertk(ind2>=0&&ind2<MAXIDEMINOR);
  assertk(mtable[ind2].used==1);

  if (mtable[ind2].blocked) return TRYLOCK_CANT;

  mtable[ind].blocked=1;
  return TRYLOCK_OK;
}

static int ide_tryunlock(__dev_t device)
{
  int ind;
 
  ind=idemindex(device);
  assertk(ind>=0&&ind<MAXIDEMINOR);
 
  if (!mtable[ind].used) return TRYUNLOCK_ERR;
  if (!mtable[ind].blocked) return TRYUNLOCK_ERR;
  mtable[ind].blocked=0;
  return TRYUNLOCK_OK;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Read a block of data (sector) from a device into a buffer.

  int bd_ide_read
    return 0 on success, other values on error

  __dev_t device
    device id to read from

  __blkcnt_t blocknum
    block number to read

  __uint8_t *buffer
    buffer for the readed data
  ++++++++++++++++++++++++++++++++++++++*/

static int bd_ide_read(__dev_t device, __blkcnt_t blocknum, __uint8_t *buffer)
{
  register int ideif=idehwif(device);
  register int index=idemindex(device);
  int res;
 
  magic_assert(ide[ideif].magic,IDE_MAGIC,
               "ide%i: interface overwritten",ideif);
  magic_assert(mtable[index].magic,IDE_MAGIC_MINOR,
               "ide%i: minor %i overwritten",ideif,minor(device));
 
  if (major(device)!=MAJOR_B_IDE) {
    printk(IDEERRLOG "ide%i: major %i is not EIDE",ideif,major(device));
    return -1;
  }
 
  if (minor(device)>MAXIDEMINOR) {
    printk(IDEERRLOG "ide%i: minor %i out of range",ideif,minor(device));
    return -1;
  }
 
  if (!mtable[index].used) {
    printk(IDEERRLOG "ide%i: minor %i not present",ideif,minor(device));
    return -1;
  }

  //cprintf("index=%i\n",index);
  //cprintf("blocknum=%li\n",(long)blocknum);
  //cprintf("size=%li\n",(long)mtable[index].size);
  //cprintf("start=%li\n",(long)mtable[index].start);  
  //cprintf("sizeof(size)=%i\n",sizeof(mtable[index].size));
 
  /*
  if (blocknum<0||blocknum>=mtable[index].size) {
    printk(IDEERRLOG "ide%i: request block out of range",ideif);
    return -1;
  }
  */
 
  res=ide_read(ideif,idedriveid(device),
                  mtable[index].start+blocknum,
                  buffer);

  //if (blocknum==0x9ea19)
  //  dump_buffer(buffer);
 
  //cprintf("index=%i\n",index);
  //cprintf("blocknum=%li\n",(long)blocknum);
  //cprintf("size=%li\n",(long)mtable[index].size);
  //cprintf("sizeof(size)=%i\n\n",sizeof(mtable[index].size));

  return res;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Move the head on a specified cylinder.

  int bd_ide_seek
    return 0 on success, other values on error

  __dev_t device
    device id to read from

  __blkcnt_t blocknum
    block number to moving into
  ++++++++++++++++++++++++++++++++++++++*/

static int bd_ide_seek(__dev_t device, __blkcnt_t blocknum)
{
  register int ideif=idehwif(device);
  register int index=idemindex(device);
  int res;
 
  magic_assert(ide[ideif].magic,IDE_MAGIC,
               "ide%i: interface overwritten",ideif);
  magic_assert(mtable[index].magic,IDE_MAGIC_MINOR,
               "ide%i: minor %i overwritten",ideif,minor(device));

  if (major(device)!=MAJOR_B_IDE) {
    printk(IDEERRLOG "ide%i: major %i is not EIDE",ideif,major(device));
    return -1;
  }
 
  if (minor(device)>MAXIDEMINOR) {
    printk(IDEERRLOG "ide%i: minor %i out of range",ideif,minor(device));
    return -1;
  }
 
  if (!mtable[index].used) {
    printk(IDEERRLOG "ide%i: minor %i not present",ideif,minor(device));
    return -1;
  }

  res=ide_seek(ideif,idedriveid(device),
                  mtable[index].start+blocknum);

  return res;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Write a block of data (sector) from a buffer into a device (not yet
  implemented, return always error).

  int bd_ide_write
    return 0 on success, other value on errors

  __dev_t device
    device id to write into

  __blkcnt_t blocknum
    block number to write

  __uint8_t *buffer
    buffer to write into
  ++++++++++++++++++++++++++++++++++++++*/

static int bd_ide_write(__dev_t device, __blkcnt_t blocknum, __uint8_t *buffer)
{
  register int ideif=idehwif(device);
  register int index=idemindex(device);
  int res;
 
  magic_assert(ide[ideif].magic,IDE_MAGIC,
               "ide%i: interface overwritten",ideif);
  magic_assert(mtable[index].magic,IDE_MAGIC_MINOR,
               "ide%i: minor %i overwritten",ideif,minor(device));

  if (major(device)!=MAJOR_B_IDE) {
    printk(IDEERRLOG "ide%i: major %i is not EIDE",ideif,major(device));
    return -1;
  }
 
  if (minor(device)>MAXIDEMINOR) {
    printk(IDEERRLOG "ide%i: minor %i out of range",ideif,minor(device));
    return -1;
  }
 
  if (!mtable[index].used) {
    printk(IDEERRLOG "ide%i: minor %i not present",ideif,minor(device));
    return -1;
  }

  res=ide_write(ideif,idedriveid(device),
                  mtable[index].start+blocknum,
                  buffer);

  return res;
}

/*
 *
 * Initialization
 *
 */

/*+ Data used to register the IDE module to the block device manager +*/
static struct block_device_operations ide_operations={
  ide_trylock,
  ide_tryunlock,
  bd_ide_read,
  bd_ide_seek,
  bd_ide_write
};

/* this information are saved from the initialization routine for
 * futher reference
 */

/*+ initialization parameter (for the "glue" initialization) +*/
void *ide_parm_initserver=NULL;

/*+ show information during startup? +*/
int ide_showinfo_flag=0;

/*++++++++++++++++++++++++++++++++++++++
 
  This function try to register an IDE interface, scan for device and
  identify the logical struct of the device

  int ide_tryregister
    return 0 on successe <0 on error

  int port0
    first port of the ide interface (ide port)

  int port1
    second port of the ide interface (control port)

  int irq
    irq of the ide interface
   
  int dma
    dma 16bits channel (if using not bus master mode)

  int bmdma
    port for the bus master dma operations
  ++++++++++++++++++++++++++++++++++++++*/

static int ide_tryregister(int port0, int port1, int irq, int dma, int bmdma)
{
  int ideif,res,j;
 
  ideif=ide_register(port0,port1,irq,dma,bmdma);
  printk0("registering IDE at 0x%04x,0x%04x,%i,%i,0x%04x... ",
          port0,port1,irq,dma,bmdma);
  if (ideif>=0) {
    res=ide_scan(ideif);
    printk0("found %i peripheral(s)",res);
    if (res>0) {
      for (j=IDE_MASTER;j<=IDE_SLAVE;j++) {
        if (ide[ideif].pdisk[j]!=NULL) {
          printk0("scanning %s for logical layout",
                  j==IDE_MASTER?"master":"slave");
          ide_scandisk(ideif,j);
        }
      }
      return 0;
    }
    return -1;
  } else
    printk0("registering failed");
  return -2;
}

/*++++++++++++++++++++++++++++++++++++++

  This function parse a string to find "command line options" for the
  IDE subsystem; see source for comments.

  int ide_scanparms
    return 0 on success, other values on error

  char *str
    string to parse
  ++++++++++++++++++++++++++++++++++++++*/

static int ide_scanparms(char *str)
{
  int port0,port1,irq,dma=-1,bmdma=-1;
  char *ptr;
  int ret;

  /* available string options:

     ide=port,sec_port,irq
     example
     "ide=0x1f0,0x3f0,14"

     try to register this ide interface
   */

  printk0("(start) searching for parameters");  
  if (str==NULL) {
    printk0("(end) searching for parameters");  
    return 0;
  }
 
  ptr=str;
  for (;;) {
    ptr=strscn(ptr,"ide=");
    if (ptr==NULL) return 0;
    ret=sscanf(ptr,"ide=%x,%x,%i,%i,%x",&port0,&port1,&irq,&dma,&bmdma);
    if (ret==3||ret==5) {
      {
        int len;
        char *s;
        s=strchr(ptr,' ');
        if (s!=NULL) len=s-ptr+1;
        else len=strlen(ptr);
        memset(ptr,len,' ');
      }
      ide_tryregister(port0,port1,irq,dma,bmdma);
    }
    ptr++;
  }
  printk0("(end) searching for parameters");  
  return 0;
}

/*++++++++++++++++++++++++++++++++++++++

  This function initialize the IDE subsystem; must be called before every
  other function.

  It initialize internal data structure, register itself to the bdev
  (block dev) manager and try to initialize "standard" IDE interface;
  non-standard ide interface can be initialize using the struct IDE_PARMS
  (see include/fs/fsinit.h).

  int ide_init
    return 0 on success, other on failure

  BDEV_PARMS *parms
    pointer to a structure contains general and specific initialization
    data
  ++++++++++++++++++++++++++++++++++++++*/

int ide_init(BDEV_PARMS *parms)
{
  struct block_device bd;
  __uint32_t addr;
  int res;
  int i;

  printk0("START");
 
  init_idereq();
  printk0("init_idereq()... done");
 
  for (i=0;i<MAXIDEINTERFACES;i++) {
   
    magic_set(ide[i].magic,IDE_MAGIC);
   
    ide[i].server=NIL;
    ide[i].io_port=0;
    ide[i].io_port2=0;
    ide[i].irq=0;
    ide[i].pdisk[IDE_MASTER]=NULL;
    ide[i].info[IDE_MASTER].use_lba=0;
    ide[i].pdisk[IDE_SLAVE]=NULL;
    ide[i].info[IDE_SLAVE].use_lba=0;    
    //ide[i].reqhead=NIL;
    //ide[i].reqtail=NIL;
    ide[i].errors=0;

    /* some check on the ide[].prd struct */    
    addr=__lin_to_phy(ide[i].prd);

    /* must be 32bits aligned! */
    assertk((addr&3)==0); /* this is granted by aligned(4) of the struct */

    /* must not cross 4KBytes boundaries! */
    if ((addr&0xfffff000)!=((addr+sizeof(ide[i].prd)-1)&0xfffff000)) {
      printk(KERN_EMERG "ide[%i].prd cross 4Kbytes boundary!",i);
      printk(KERN_EMERG "ide[] table is located at 0x%08lx",(long)&ide);
      printk(KERN_EMERG "ide[%i] is located at 0x%08lx",
             i,(long unsigned)(&ide[i]));
      printk(KERN_EMERG "ide[%i].prd is located at 0x%08lx",
             i,(long unsigned)(&ide[i].prd));
      printk(KERN_EMERG "ide[%i].prd is located at 0x%08lx (phy) for 0x%04x",
             i,(long unsigned)addr,(int)sizeof(ide[i].prd));
     
      /* now! */
      assertk(0==-1);
    }
   
  }

  for (i=0;i<MAXIDEMINOR;i++) {
   
    magic_set(mtable[i].magic,IDE_MAGIC_MINOR);

    mtable[i].start=0;
    mtable[i].size=0;
    mtable[i].used=0;
    mtable[i].blocked=0;
  }

  ide_parm_initserver=IDEPARMS(parms).parm_initserver;
  ide_showinfo_flag=parms->showinfo;
  bd.bd_sectorsize=IDE_SECTOR_SIZE;
  bd.bd_op=&ide_operations;

  printk0("static data initialization... done");
 
  res=bdev_register(makedev(MAJOR_B_IDE,0),device_name,&bd);
  if (res) return -1;

  printk0("registering IDE to block-dev... done");

  /* Well... bus master dma operations i/o ports would be reported
   * by the pci device management module
   */
  ide_tryregister(0x1f0,0x3f0,14,3,0xe000);
  ide_tryregister(0x170,0x370,15,-1,0xe008);

  ide_scanparms(parms->config);

  printk0("END");
  return 0;    
}

/*
 *
 *
 */

/*++++++++++++++++++++++++++++++++++++++
 
  Scan for device on an IDE interface: reset the device, issue a
  IDENTIFY command and optional a PACKET IDENTIFY; if a hard disk
  is found it is registered to the "physical disk" module.

  int ide_scan
    return the number of device found on the interface (0,1 or 2)

  int ideif
    the interface to scan (every interface has a progess number)
  ++++++++++++++++++++++++++++++++++++++*/

int ide_scan(int ideif)
{
  struct ata_diskid   info;
  struct atapi_diskid info2;
  struct phdskinfo    disk;
  struct phdskinfo    *phdskptr;
  int                 drv;
  int                 res;
  //int                 ind;
  int                 found;
  int                 atapi;
  int                 fl;
 
  printk1("START");
 
  magic_assert(ide[ideif].magic,IDE_MAGIC,
               "ide: interface(%i) overwritten",ideif);

  if (ide[ideif].pdisk[IDE_MASTER]!=NULL||
      ide[ideif].pdisk[IDE_SLAVE]!=NULL)
    return 0;

  /* phase 0 */
  /* softreset */

  printk1("making a soft reset...");
  res=do_ide_softreset(ideif);
  if (res) {
    printk1("soft reset fail");
#ifndef FORCE_SCANNING
    printk1("END");
    return 0;
#endif
    printk1("FORCE_SCANNING");
  } else
    printk1("soft reset... done");
 
  /* phase 1 */
  /* searching for disk drive */

  found=0;
  for (drv=IDE_MASTER;drv<=(ONLY_MASTER?IDE_MASTER:IDE_SLAVE);drv++) {

    printk1("scanning for %s",drv==IDE_MASTER?"master":"slave");
   
    atapi=0;
    res=ide_identify(ideif,drv,&info);
   
    printk1("identify... done (device %sfound)",res==IDE_OK?"":"NOT ");
     
    if (res!=IDE_OK) {
      atapi=1;
      res=ide_pidentify(ideif,drv,&info2);
      printk1("pidentify... done (device %sfound)",res==IDE_OK?"":"NOT ");
    }
   
    if (res==IDE_OK) {
       
      if (ide_showinfo_flag&&!found) {
        printk(IDELOG "ide%i: 0x%3x,%i,%i,0x%04x",ideif,
               ide[ideif].io_port,ide[ideif].irq,
               (ide[ideif].dma==255)?-1:ide[ideif].dma,
               ide[ideif].io_bmdma);
      }
      found++;
             
      /* if this is an ATAPI device... */      
      if (atapi) {
        if (ide_showinfo_flag) {
          printk(IDELOG "ide%i: %s device",
                 ideif,drv==IDE_MASTER?"master":"slave");
          ide_dump_atapidiskid(&info2);
        }
        /* ATAPI devices not managed yet! */
        continue;
      }

      disk.pd_device=idemakedev(ideif,drv,0);

      disk.pd_sectsize=IDE_SECTOR_SIZE;      
      disk.pd_size=(__uint32_t)info.act_cyls*info.act_heads*info.act_sects;

      disk.pd_logeom.cyls=disk.pd_phgeom.cyls=info.act_cyls;
      disk.pd_logeom.heads=disk.pd_phgeom.heads=info.act_heads;
      disk.pd_logeom.sectors=disk.pd_phgeom.sectors=info.act_sects;

      if (is_LBAcapable(&info)) {
        ide[ideif].info[drv].use_lba=TRUE;
        disk.pd_ide_check_geom=0;
      } else {
        ide[ideif].info[drv].use_lba=FALSE;
        disk.pd_ide_check_geom=0;
      }

      /* for PIO capabilities */
      {
        __int8_t support;
        if (info.fields_valid&2) {
          if (info.eide_PIO_modes&2) support=4;
          else if (info.eide_PIO_modes&1) support=3;
          else support=info.PIO_mode;  
        } else
          support=info.PIO_mode;       
        ide[ideif].info[drv].max_pio_mode=support;
      }
      /* for DMA capabilities */
      {
        __int8_t support;
        if (info.DMA_mword&4) support=2;
        else if (info.DMA_mword&2) support=1;
        else if (info.DMA_mword&1) support=0;
        else support=-1;
        ide[ideif].info[drv].max_dma_mode=support;
      }
      /* for ULTRA DMA capabilities */
      {
        __int8_t support;
        if (!(info.fields_valid&4)) support=-1;
        else if (info.UDMA_cap&4) support=2;
        else if (info.UDMA_cap&2) support=1;
        else if (info.UDMA_cap&1) support=0;
        else support=-1;
        ide[ideif].info[drv].max_udma_mode=support;
      }
     
      /* Well... BM-DMA used by default (if possible)*/
      ide[ideif].info[drv].use_dma=0;
      fl=0;
      if (ide[ideif].info[drv].max_dma_mode!=-1) fl=1;
      if (ide[ideif].info[drv].max_udma_mode!=-1) fl=1;
#ifdef FORCE_PIOMODE
      fl=0; // so use PIO mode
#endif
      ide[ideif].info[drv].use_bm_dma=fl;
     
      /* Show informations... if request */
      if (ide_showinfo_flag) {
        printk(IDELOG "ide%i: %s device",
               ideif,drv==IDE_MASTER?"master":"slave");
        ide_dump_diskid(&info,&ide[ideif].info[drv]);
      }

      sprintf(disk.pd_name,"hd%c",'a'+ideif*2+drv);

      /* Register physical disk information */
      phdskptr=phdsk_register(&disk);
      if (phdskptr==NULL) continue;
      ide[ideif].pdisk[drv]=phdskptr;
     
      /* Well, the queueing algorithm must know the physical disk layout */
      ide[ideif].queue[drv].disk=phdskptr;

      /* Activate look a head... (if possible) */
      res=ide_enablelookahead(ideif,drv);
      if (ide_showinfo_flag)
        printk(IDELOG "ide%i: look ahead %s for %s device",
               ideif,
               res==IDE_OK?"activated":"not activated",
               drv==IDE_MASTER?"master":"slave"
               );      
    }      
  }

  if (found==0) {
    printk(IDELOG "ide: no device found on 0x%x,%i, unregistering interface",
           ide[ideif].io_port,ide[ideif].irq);

    ide_unregister(ideif);

  }
 
  return found;
}
                         
/* --- */

/*++++++++++++++++++++++++++++++++++++++
 
  This function is called by the "logical disk" module to inform this module
  that a logical disk partition is found [see ide_scandisk()].

  int _callback
    must return 0 to continue searching for new partition, -1 to stop
    scanning

  int ind
    partition index (for linux users: it is the number after the device
    name, ex. hda1, hdb5 )

  struct lodskinfo *ptr
    information on partition found

  void *data
    private data for this module: is a pointer to a __dev_t to identify
    the device where this partition reside
  ++++++++++++++++++++++++++++++++++++++*/

static int _callback(int ind, struct lodskinfo *ptr, void *data)
{
  char name[32];
  int index;
  __dev_t dev;
 
  printk2("found logical device %i",ind);
 
  assertk(ind>0);
  if (ind>MAXIDELODSK) {
    printk(IDELOG "ide: found more than %i partitions... skipped!",
           MAXIDELODSK);
    return -1;
  }
 
  index=idemindexext(*(__dev_t *)data,ind);
  mtable[index].start=ptr->start;  
  mtable[index].size=ptr->size;
  mtable[index].used=1;

 
  dev=makedev(major(*(__dev_t *)data),index);
  sprintf(name,"hd%c%i",
          idehwif(dev)*2+idedriveid(dev)+'a',
          ind
          );
 
  index=bdev_register_minor(dev,name,ptr->fs_ind);
 
  return 0;
}

/*++++++++++++++++++++++++++++++++++++++
 
  Scan an IDE device to find its logical structure; it use the service
  from the "logical disk" module to perform this.

  int ide_scandisk
    return 0 on success, other on error

  int hwif
    ide interface where there is the device

  int drv
    device to scan (IDE_MASTER, IDE_SLAVE)

  ++++++++++++++++++++++++++++++++++++++*/

int ide_scandisk(int hwif, int drv)
{
  char name[8];
  __dev_t device;
  int index;

  printk2("START");
   
  //cprintf("hwif=%i drv=%i\n",hwif,drv);
  device=idemakedev(hwif,drv,0);
  //cprintf("device=%i\n",(int)device);
  index=idemindex(device);
  //cprintf("minor=%i\n",(int)minor(device));
  //cprintf("---index=%i\n",index);
 
  mtable[index].start=0;
  mtable[index].size=ide[hwif].pdisk[drv]->pd_size;
  mtable[index].used=1;  
  sprintf(name,"hd%c",hwif*2+drv+'a');

  bdev_register_minor(device,name,FS_DEFAULT);
 
  lodsk_scan(device,
             _callback,
             (void*)&device,
             ide_showinfo_flag,
             name);

  printk2("END");
  return 0;
}