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;