/* This file contains the "device dependent" part of a hard disk driver that
 * uses the ROM BIOS.  It makes a call and just waits for the transfer to
 * happen.  It is not interrupt driven and thus will (*) have poor performance.
 * The advantage is that it should work on virtually any PC, XT, 386, PS/2
 * or clone.  The demo disk uses this driver.  It is suggested that all
 * MINIX users try the other drivers, and use this one only as a last resort,
 * if all else fails.
 *
 * (*) The performance is within 10% of the AT driver for reads on any disk
 *     and writes on a 2:1 interleaved disk, it will be DMA_BUF_SIZE bytes
 *     per revolution for a minimum of 60 kb/s for writes to 1:1 disks.
 *
 * The file contains one entry point:
 *
 *	 bios_winchester_task:	main entry when system is brought up
 *
 *
 * Changes:
 *	30 Apr 1992 by Kees J. Bot: device dependent/independent split.
 *	14 May 2000 by Kees J. Bot: d-d/i rewrite.
 */

#include "../drivers.h"
#include "../libdriver/driver.h"
#include "../libdriver/drvlib.h"
#include <minix/sysutil.h>
#include <minix/safecopies.h>
#include <minix/keymap.h>
#include <sys/ioc_disk.h>
#include <ibm/int86.h>
#include <assert.h>

#define ME "BIOS_WINI"

/* Error codes */
#define ERR		 (-1)	/* general error */

/* Parameters for the disk drive. */
#define MAX_DRIVES         8	/* this driver supports 8 drives (d0 - d7)*/
#define MAX_SECS	 255	/* bios can transfer this many sectors */
#define NR_MINORS      (MAX_DRIVES * DEV_PER_DRIVE)
#define SUB_PER_DRIVE	(NR_PARTITIONS * NR_PARTITIONS)
#define NR_SUBDEVS	(MAX_DRIVES * SUB_PER_DRIVE)

PRIVATE int pc_at = 1;	/* What about PC XTs? */

/* Variables. */
PRIVATE struct wini {		/* main drive struct, one entry per drive */
  unsigned cylinders;		/* number of cylinders */
  unsigned heads;		/* number of heads */
  unsigned sectors;		/* number of sectors per track */
  unsigned open_ct;		/* in-use count */
  int drive_id;			/* Drive ID at BIOS level */
  int present;			/* Valid drive */
  int int13ext;			/* IBM/MS INT 13 extensions supported? */
  struct device part[DEV_PER_DRIVE];	/* disks and partitions */
  struct device subpart[SUB_PER_DRIVE]; /* subpartitions */
} wini[MAX_DRIVES], *w_wn;

PRIVATE int w_drive;			/* selected drive */
PRIVATE struct device *w_dv;		/* device's base and size */
PRIVATE vir_bytes bios_buf_vir, bios_buf_size;
PRIVATE phys_bytes bios_buf_phys;
PRIVATE int remap_first = 0;		/* Remap drives for CD HD emulation */
PRIVATE char my_bios_buf[16384];
PRIVATE cp_grant_id_t my_bios_grant_id;

_PROTOTYPE(int main, (void) );
FORWARD _PROTOTYPE( struct device *w_prepare, (int device) );
FORWARD _PROTOTYPE( char *w_name, (void) );
FORWARD _PROTOTYPE( int w_transfer, (int proc_nr, int opcode, u64_t position,
				iovec_t *iov, unsigned nr_req, int safe) );
FORWARD _PROTOTYPE( int w_do_open, (struct driver *dp, message *m_ptr) );
FORWARD _PROTOTYPE( int w_do_close, (struct driver *dp, message *m_ptr) );
FORWARD _PROTOTYPE( void w_init, (void) );
FORWARD _PROTOTYPE( void w_geometry, (struct partition *entry));
FORWARD _PROTOTYPE( int w_other, (struct driver *dp, message *m_ptr, int)    );
FORWARD _PROTOTYPE( int my_vircopy, (endpoint_t, int, vir_bytes, endpoint_t,
	int, vir_bytes, size_t, size_t));

/* Entry points to this driver. */
PRIVATE struct driver w_dtab = {
  w_name,	/* current device's name */
  w_do_open,	/* open or mount request, initialize device */
  w_do_close,	/* release device */
  do_diocntl,	/* get or set a partition's geometry */
  w_prepare,	/* prepare for I/O on a given minor device */
  w_transfer,	/* do the I/O */
  nop_cleanup,	/* no cleanup needed */
  w_geometry,	/* tell the geometry of the disk */
  nop_signal,		/* no cleanup needed on shutdown */
  nop_alarm,		/* ignore leftover alarms */
  nop_cancel,		/* ignore CANCELs */
  nop_select,		/* ignore selects */
  w_other,		/* catch-all for unrecognized commands and ioctls */
  NULL			/* leftover hardware interrupts */
};

/*===========================================================================*
 *				bios_winchester_task			     *
 *===========================================================================*/
PUBLIC int main()
{
  long v;
  struct sigaction sa;
 
  sa.sa_handler = SIG_MESS;
  sigemptyset(&sa.sa_mask);
  sa.sa_flags = 0;
  if (sigaction(SIGTERM,&sa,NULL)<0) panic("BIOS","sigaction failed", errno);

  v= 0;
  env_parse("bios_remap_first", "d", 0, &v, 0, 1);
  remap_first= v;

/* Set special disk parameters then call the generic main loop. */
  driver_task(&w_dtab);
  return(OK);
}

/*===========================================================================*
 *				w_prepare				     *
 *===========================================================================*/
PRIVATE struct device *w_prepare(device)
int device;
{
/* Prepare for I/O on a device. */

  if (device < NR_MINORS) {			/* d0, d0p[0-3], d1, ... */
	w_drive = device / DEV_PER_DRIVE;	/* save drive number */
	w_wn = &wini[w_drive];
	w_dv = &w_wn->part[device % DEV_PER_DRIVE];
  } else
  if ((unsigned) (device -= MINOR_d0p0s0) < NR_SUBDEVS) {/*d[0-7]p[0-3]s[0-3]*/
	w_drive = device / SUB_PER_DRIVE;
	w_wn = &wini[w_drive];
	w_dv = &w_wn->subpart[device % SUB_PER_DRIVE];
  } else {
	return(NIL_DEV);
  }
  if (w_drive >= MAX_DRIVES || !w_wn->present)
  	return NIL_DEV;
  return(w_dv);
}

/*===========================================================================*
 *				w_name					     *
 *===========================================================================*/
PRIVATE char *w_name()
{
/* Return a name for the current device. */
  static char name[] = "bios-d0";

  name[6] = '0' + w_drive;
  return name;
}

/*===========================================================================*
 *				w_transfer				     *
 *===========================================================================*/
PRIVATE int my_vircopy(from_proc, from_seg, from_vir, to_proc, to_seg,
  to_vir, grant_offset, size)
endpoint_t from_proc;
int from_seg;
vir_bytes from_vir;
endpoint_t to_proc;
int to_seg;
vir_bytes to_vir;
vir_bytes grant_offset;
size_t size;
{
	phys_bytes addr;
	int r;

	if(from_seg == GRANT_SEG) {
  		if((r=sys_umap(from_proc, GRANT_SEG,
			(vir_bytes)from_vir, (phys_bytes)size+grant_offset,
  			&addr)) != OK) {
			panic(ME, "sys_umap in my_vircopy failed", r);
		}
		from_seg = PHYS_SEG;
		from_vir = addr + grant_offset;
	}

	if(to_seg == GRANT_SEG) {
  		if((r=sys_umap(to_proc, GRANT_SEG,
			(vir_bytes)to_vir, (phys_bytes)size+grant_offset,
  			&addr)) != OK) {
			panic(ME, "sys_umap in my_vircopy failed", r);
		}
		to_seg = PHYS_SEG;
		to_vir = addr + grant_offset;
	}

	return sys_physcopy(from_proc, from_seg, from_vir,
		to_proc, to_seg, to_vir, size);
}

/*===========================================================================*
 *				w_transfer				     *
 *===========================================================================*/
PRIVATE int w_transfer(proc_nr, opcode, pos64, iov, nr_req, safe)
int proc_nr;			/* process doing the request */
int opcode;			/* DEV_GATHER or DEV_SCATTER */
u64_t pos64;			/* offset on device to read or write */
iovec_t *iov;			/* pointer to read or write request vector */
unsigned nr_req;		/* length of request vector */
int safe;			/* use safecopies? */
{
  struct wini *wn = w_wn;
  iovec_t *iop, *iov_end = iov + nr_req;
  int r, errors;
  unsigned nbytes, count, chunk;
  unsigned long block;
  vir_bytes i13e_rw_off, rem_buf_size;
  size_t vir_offset = 0;
  unsigned long dv_size = cv64ul(w_dv->dv_size);
  unsigned secspcyl = wn->heads * wn->sectors;
  off_t position;
  struct int13ext_rw {
	u8_t	len;
	u8_t	res1;
	u16_t	count;
	u16_t	addr[2];
	u32_t	block[2];
  } i13e_rw;
  struct reg86u reg86;

  if (ex64hi(pos64))
	panic(__FILE__, "should handle 64-bit offsets", NO_NUM);
  position= ex64lo(pos64);

  /* Check disk address. */
  if ((position & SECTOR_MASK) != 0) return(EINVAL);

  errors = 0;

  i13e_rw_off= bios_buf_size-sizeof(i13e_rw);
  rem_buf_size= (i13e_rw_off & ~SECTOR_MASK);
  assert(rem_buf_size != 0);

  while (nr_req > 0) {
	/* How many bytes to transfer? */
	nbytes = 0;
	for (iop = iov; iop < iov_end; iop++) {
		if (nbytes + iop->iov_size > rem_buf_size) {
			/* Don't do half a segment if you can avoid it. */
			if (nbytes == 0) nbytes = rem_buf_size;
			break;
		}
		nbytes += iop->iov_size;
	}
	if ((nbytes & SECTOR_MASK) != 0) return(EINVAL);

	/* Which block on disk and how close to EOF? */
	if (position >= dv_size) return(OK);		/* At EOF */
	if (position + nbytes > dv_size) nbytes = dv_size - position;
	block = div64u(add64ul(w_dv->dv_base, position), SECTOR_SIZE);

	/* Degrade to per-sector mode if there were errors. */
	if (errors > 0) nbytes = SECTOR_SIZE;

	if (opcode == DEV_SCATTER_S) {
		/* Copy from user space to the DMA buffer. */
		count = 0;
		for (iop = iov; count < nbytes; iop++) {
			chunk = iov->iov_size;
			if (count + chunk > nbytes) chunk = nbytes - count;
			assert(chunk <= rem_buf_size);
			r= my_vircopy(proc_nr, safe ? GRANT_SEG : D,
				(vir_bytes) iop->iov_addr,
				SYSTEM, D, bios_buf_vir+count, 
				vir_offset, chunk);
			if (r != OK)
				panic(ME, "copy failed", r);
			count += chunk;
		}
	}

	/* Do the transfer */
	if (wn->int13ext) {
		i13e_rw.len = 0x10;
		i13e_rw.res1 = 0;
		i13e_rw.count = nbytes >> SECTOR_SHIFT;
		i13e_rw.addr[0] = bios_buf_phys % HCLICK_SIZE;
		i13e_rw.addr[1] = bios_buf_phys / HCLICK_SIZE;
		i13e_rw.block[0] = block;
		i13e_rw.block[1] = 0;
		r= sys_vircopy(SELF, D, (vir_bytes)&i13e_rw,
			SYSTEM, D, (bios_buf_vir+i13e_rw_off), 
			sizeof(i13e_rw));
		if (r != OK)
			panic(ME, "sys_vircopy failed", r);

		/* Set up an extended read or write BIOS call. */
		reg86.u.b.intno = 0x13;
		reg86.u.w.ax = opcode == DEV_SCATTER_S ? 0x4300 : 0x4200;
		reg86.u.b.dl = wn->drive_id;
		reg86.u.w.si = (bios_buf_phys + i13e_rw_off) % HCLICK_SIZE;
		reg86.u.w.ds = (bios_buf_phys + i13e_rw_off) / HCLICK_SIZE;
	} else {
		/* Set up an ordinary read or write BIOS call. */
		unsigned cylinder = block / secspcyl;
		unsigned sector = (block % wn->sectors) + 1;
		unsigned head = (block % secspcyl) / wn->sectors;

		reg86.u.b.intno = 0x13;
		reg86.u.b.ah = opcode == DEV_SCATTER_S ? 0x03 : 0x02;
		reg86.u.b.al = nbytes >> SECTOR_SHIFT;
		reg86.u.w.bx = bios_buf_phys % HCLICK_SIZE;
		reg86.u.w.es = bios_buf_phys / HCLICK_SIZE;
		reg86.u.b.ch = cylinder & 0xFF;
		reg86.u.b.cl = sector | ((cylinder & 0x300) >> 2);
		reg86.u.b.dh = head;
		reg86.u.b.dl = wn->drive_id;
	}

	r= sys_int86(&reg86);
	if (r != OK)
		panic(ME, "BIOS call failed", r);

	if (reg86.u.w.f & 0x0001) {
		/* An error occurred, try again sector by sector unless */
		if (++errors == 2) return(EIO);
		continue;
	}

	if (opcode == DEV_GATHER_S) {
		/* Copy from the DMA buffer to user space. */
		count = 0;
		for (iop = iov; count < nbytes; iop++) {
			chunk = iov->iov_size;
			if (count + chunk > nbytes) chunk = nbytes - count;
			assert(chunk <= rem_buf_size);
			r = my_vircopy(SYSTEM, D, bios_buf_vir+count, 
				proc_nr, safe ? GRANT_SEG : D,
				iop->iov_addr, vir_offset, chunk);
			if (r != OK)
				panic(ME, "sys_vircopy failed", r);
			count += chunk;
		}
	}

	/* Book the bytes successfully transferred. */
	position += nbytes;
	for (;;) {
		if (nbytes < iov->iov_size) {
			/* Not done with this one yet. */
			vir_offset += nbytes;
			iov->iov_size -= nbytes;
			break;
		}
		nbytes -= iov->iov_size;
		vir_offset = 0;
		iov->iov_size = 0;
		if (nbytes == 0) {
			/* The rest is optional, so we return to give FS a
			 * chance to think it over.
			 */
			return(OK);
		}
		iov++;
		nr_req--;
	}
  }
  return(OK);
}

/*============================================================================*
 *				w_do_open				      *
 *============================================================================*/
PRIVATE int w_do_open(dp, m_ptr)
struct driver *dp;
message *m_ptr;
{
/* Device open: Initialize the controller and read the partition table. */

  static int init_done = FALSE;

  if (!init_done) { w_init(); init_done = TRUE; }

  if (w_prepare(m_ptr->DEVICE) == NIL_DEV) return(ENXIO);

  if (w_wn->open_ct++ == 0) {
	/* Partition the disk. */
	partition(&w_dtab, w_drive * DEV_PER_DRIVE, P_PRIMARY, 0);
  }
  return(OK);
}

/*============================================================================*
 *				w_do_close				      *
 *============================================================================*/
PRIVATE int w_do_close(dp, m_ptr)
struct driver *dp;
message *m_ptr;
{
/* Device close: Release a device. */

  if (w_prepare(m_ptr->DEVICE) == NIL_DEV) return(ENXIO);
  w_wn->open_ct--;
  return(OK);
}

/*===========================================================================*
 *				w_init					     *
 *===========================================================================*/
PRIVATE void w_init()
{
/* This routine is called at startup to initialize the drive parameters. */

  int r, drive, drive_id, nr_drives;
  struct wini *wn;
  unsigned long capacity;
  struct int13ext_params {
	u16_t	len;
	u16_t	flags;
	u32_t	cylinders;
	u32_t	heads;
	u32_t	sectors;
	u32_t	capacity[2];
	u16_t	bts_per_sec;
	u16_t	config[2];
  } i13e_par;
  struct reg86u reg86;

  /* Ask the system task for a suitable buffer */
  r= sys_getbiosbuffer(&bios_buf_vir, &bios_buf_size);
  if (r != OK)
  	panic(ME, "sys_getbiosbuffer failed", r);

  if(bios_buf_size >= sizeof(my_bios_buf)) {
        printf("bios_wini: truncating buffer %d -> %d\n",
		bios_buf_size, sizeof(my_bios_buf));
	bios_buf_size = sizeof(my_bios_buf);
  }

  r= sys_umap(SYSTEM, D, (vir_bytes)bios_buf_vir, (phys_bytes)bios_buf_size,
  	&bios_buf_phys);
  if (r != OK)
  	panic(ME, "sys_umap failed", r);
  if (bios_buf_phys+bios_buf_size > 0x100000)
  	panic(ME, "bad BIOS buffer, phys", bios_buf_phys);
#if 0
  printf("bios_wini: got buffer size %d, virtual 0x%x, phys 0x%x\n",
  		bios_buf_size, bios_buf_vir, bios_buf_phys);
#endif

  /* Get the geometry of the drives */
  for (drive = 0; drive < MAX_DRIVES; drive++) {
  	if (remap_first)
  	{
  		if (drive == 7)
			drive_id= 0x80;
		else
			drive_id= 0x80 + drive + 1;
  	}
  	else
		drive_id= 0x80 + drive;

	(void) w_prepare(drive * DEV_PER_DRIVE);
	wn = w_wn;
	wn->drive_id= drive_id;

	reg86.u.b.intno = 0x13;
	reg86.u.b.ah = 0x08;	/* Get drive parameters. */
	reg86.u.b.dl = drive_id;
	r= sys_int86(&reg86);
	if (r != OK)
		panic(ME, "BIOS call failed", r);

	nr_drives = !(reg86.u.w.f & 0x0001) ? reg86.u.b.dl : drive;
	if (drive_id >= 0x80 + nr_drives) continue;
	wn->present= 1;

	wn->heads = reg86.u.b.dh + 1;
	wn->sectors = reg86.u.b.cl & 0x3F;
	wn->cylinders = (reg86.u.b.ch | ((reg86.u.b.cl & 0xC0) << 2)) + 1;

	capacity = (unsigned long) wn->cylinders * wn->heads * wn->sectors;

	reg86.u.b.intno = 0x13;
	reg86.u.b.ah = 0x41;	/* INT 13 Extensions - Installation check */
	reg86.u.w.bx = 0x55AA;
	reg86.u.b.dl = drive_id;

	if (pc_at) {
		r= sys_int86(&reg86);
		if (r != OK)
			panic(ME, "BIOS call failed", r);
	}

	if (!(reg86.u.w.f & 0x0001) && reg86.u.w.bx == 0xAA55
				&& (reg86.u.w.cx & 0x0001)) {
		/* INT 13 Extensions available. */
		i13e_par.len = 0x001E;	/* Input size of parameter packet */
		r= sys_vircopy(SELF, D, (vir_bytes)&i13e_par,
			SYSTEM, D, bios_buf_vir, 
			sizeof(i13e_par));
		if (r != OK)
			panic(ME, "sys_vircopy failed\n", r);
		reg86.u.b.intno = 0x13;
		reg86.u.b.ah = 0x48;	/* Ext. Get drive parameters. */
		reg86.u.b.dl = drive_id;
		reg86.u.w.si = bios_buf_phys % HCLICK_SIZE;
		reg86.u.w.ds = bios_buf_phys / HCLICK_SIZE;

		r= sys_int86(&reg86);
		if (r != OK)
			panic(ME, "BIOS call failed", r);

		r= sys_vircopy(SYSTEM, D, bios_buf_vir,
			 SELF, D, (vir_bytes)&i13e_par,
			sizeof(i13e_par));
		if (r != OK)
			panic(ME, "sys_vircopy failed\n", r);

		if (!(reg86.u.w.f & 0x0001)) {
			wn->int13ext = 1;	/* Extensions can be used. */
			capacity = i13e_par.capacity[0];
			if (i13e_par.capacity[1] != 0) capacity = 0xFFFFFFFF;
		}
	}

	if (wn->int13ext) {
		printf("%s: %lu sectors\n", w_name(), capacity);
	} else {
		printf("%s: %d cylinders, %d heads, %d sectors per track\n",
			w_name(), wn->cylinders, wn->heads, wn->sectors);
	}
	wn->part[0].dv_size = mul64u(capacity, SECTOR_SIZE);
  }
}

/*============================================================================*
 *				w_geometry				      *
 *============================================================================*/
PRIVATE void w_geometry(entry)
struct partition *entry;
{
  entry->cylinders = w_wn->cylinders;
  entry->heads = w_wn->heads;
  entry->sectors = w_wn->sectors;
}

/*============================================================================*
 *				w_other				      *
 *============================================================================*/
PRIVATE int w_other(dr, m, safe)
struct driver *dr;
message *m;
int safe;
{
        int r, timeout, prev;

        if (m->m_type != DEV_IOCTL_S )
                return EINVAL;

	if (m->REQUEST == DIOCOPENCT) {
                int count;
                if (w_prepare(m->DEVICE) == NIL_DEV) return ENXIO;
                count = w_wn->open_ct;
		if(safe) {
		   r=sys_safecopyto(m->IO_ENDPT, (vir_bytes)m->ADDRESS,
		       0, (vir_bytes)&count, sizeof(count), D);
		} else {
                   r=sys_datacopy(SELF, (vir_bytes)&count,
                        m->IO_ENDPT, (vir_bytes)m->ADDRESS, sizeof(count));
		}

		if(r != OK)
                        return r;
                return OK;
        }

        return EINVAL;
}

