/*   hptraid.c  Copyright (C) 2001 Red Hat, Inc. All rights reserved.   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, or (at your option)   any later version.      You should have received a copy of the GNU General Public License   (for example /usr/src/linux/COPYING); if not, write to the Free   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.        Authors: 	Arjan van de Ven <arjanv@redhat.com>   Based on work   	Copyleft  (C) 2001 by Wilfried Weissmann <wweissmann@gmx.at>	Copyright (C) 1994-96 Marc ZYNGIER <zyngier@ufr-info-p7.ibp.fr>   Based on work done by S鴕en Schmidt for FreeBSD   */#include <linux/module.h>#include <linux/init.h>#include <linux/sched.h>#include <linux/smp_lock.h>#include <linux/kernel.h>#include <linux/blkdev.h>#include <linux/blkpg.h>#include <linux/genhd.h>#include <linux/ioctl.h>#include <linux/ide.h>#include <asm/uaccess.h>#include "ataraid.h"static int hptraid_open(struct inode * inode, struct file * filp);static int hptraid_release(struct inode * inode, struct file * filp);static int hptraid_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);static int hptraidspan_make_request (request_queue_t *q, int rw, struct buffer_head * bh);static int hptraid0_make_request (request_queue_t *q, int rw, struct buffer_head * bh);static int hptraid1_make_request (request_queue_t *q, int rw, struct buffer_head * bh);struct hptdisk {	kdev_t	device;	unsigned long sectors;	struct block_device *bdev;	unsigned long last_pos;};struct hptraid {	unsigned int stride;	unsigned int disks;	unsigned long sectors;        u_int32_t magic_0;	struct geom geom;		struct hptdisk disk[8];	unsigned long cutoff[8];	unsigned int cutoff_disks[8];	};struct hptraid_dev {	int major;	int minor;	int device;};static struct hptraid_dev devlist[]={	{IDE0_MAJOR,  0, -1},	{IDE0_MAJOR, 64, -1},	{IDE1_MAJOR,  0, -1},	{IDE1_MAJOR, 64, -1},	{IDE2_MAJOR,  0, -1},	{IDE2_MAJOR, 64, -1},	{IDE3_MAJOR,  0, -1},	{IDE3_MAJOR, 64, -1},	{IDE4_MAJOR,  0, -1},	{IDE4_MAJOR, 64, -1},	{IDE5_MAJOR,  0, -1},	{IDE5_MAJOR, 64, -1},	{IDE6_MAJOR,  0, -1},	{IDE6_MAJOR, 64, -1}};static struct raid_device_operations hptraidspan_ops = {	open:                   hptraid_open,	release:                hptraid_release,	ioctl:			hptraid_ioctl,	make_request:		hptraidspan_make_request};static struct raid_device_operations hptraid0_ops = {	open:                   hptraid_open,	release:                hptraid_release,	ioctl:			hptraid_ioctl,	make_request:		hptraid0_make_request};static struct raid_device_operations hptraid1_ops = {	open:                   hptraid_open,	release:                hptraid_release,	ioctl:			hptraid_ioctl,	make_request:		hptraid1_make_request};static struct hptraid raid[14];static int hptraid_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg){	unsigned int minor;	unsigned char val;	unsigned long sectors;		if (!inode || !inode->i_rdev) 			return -EINVAL;	minor = MINOR(inode->i_rdev)>>SHIFT;		switch (cmd) {         	case BLKGETSIZE:   /* Return device size */			if (!arg)  return -EINVAL;			sectors = ataraid_gendisk.part[MINOR(inode->i_rdev)].nr_sects;			if (MINOR(inode->i_rdev)&15)				return put_user(sectors, (unsigned long *) arg);			return put_user(raid[minor].sectors , (unsigned long *) arg);			break;					case HDIO_GETGEO:		{			struct hd_geometry *loc = (struct hd_geometry *) arg;			unsigned short bios_cyl;						if (!loc) return -EINVAL;			val = 255;			if (put_user(val, (byte *) &loc->heads)) return -EFAULT;			val=63;			if (put_user(val, (byte *) &loc->sectors)) return -EFAULT;			bios_cyl = raid[minor].sectors/63/255;			if (put_user(bios_cyl, (unsigned short *) &loc->cylinders)) return -EFAULT;			if (put_user((unsigned)ataraid_gendisk.part[MINOR(inode->i_rdev)].start_sect,				(unsigned long *) &loc->start)) return -EFAULT;			return 0;		}		case HDIO_GETGEO_BIG:		{			struct hd_big_geometry *loc = (struct hd_big_geometry *) arg;			unsigned int bios_cyl;			if (!loc) return -EINVAL;			val = 255;			if (put_user(val, (byte *) &loc->heads)) return -EFAULT;			val = 63;			if (put_user(val, (byte *) &loc->sectors)) return -EFAULT;			bios_cyl = raid[minor].sectors/63/255;			if (put_user(bios_cyl, (unsigned int *) &loc->cylinders)) return -EFAULT;			if (put_user((unsigned)ataraid_gendisk.part[MINOR(inode->i_rdev)].start_sect,				(unsigned long *) &loc->start)) return -EFAULT;			return 0;		}					default:			return blk_ioctl(inode->i_rdev, cmd, arg);	};	return 0;}static int hptraidspan_make_request (request_queue_t *q, int rw, struct buffer_head * bh){	unsigned long rsect;	unsigned int disk;	int device;	struct hptraid *thisraid;	rsect = bh->b_rsector;	device = (bh->b_rdev >> SHIFT)&MAJOR_MASK;	thisraid = &raid[device];	/* Partitions need adding of the start sector of the partition to the requested sector */		rsect += ataraid_gendisk.part[MINOR(bh->b_rdev)].start_sect;	for (disk=0;disk<thisraid->disks;disk++) {		if (disk==1)			rsect+=10;			// the "on next disk" contition check is a bit odd		if (thisraid->disk[disk].sectors > rsect+1)			break;		rsect-=thisraid->disk[disk].sectors-(disk?11:1);	}		// request spans over 2 disks => request must be split	if(rsect+bh->b_size/512 >= thisraid->disk[disk].sectors)		return -1;		/*	 * The new BH_Lock semantics in ll_rw_blk.c guarantee that this	 * is the only IO operation happening on this bh.	 */	 	bh->b_rdev = thisraid->disk[disk].device;	bh->b_rsector = rsect;	/*	 * Let the main block layer submit the IO and resolve recursion:	 */	return 1;}static int hptraid0_make_request (request_queue_t *q, int rw, struct buffer_head * bh){	unsigned long rsect;	unsigned long rsect_left,rsect_accum = 0;	unsigned long block;	unsigned int disk=0,real_disk=0;	int i;	int device;	struct hptraid *thisraid;	rsect = bh->b_rsector;	/* Ok. We need to modify this sector number to a new disk + new sector number. 	 * If there are disks of different sizes, this gets tricky. 	 * Example with 3 disks (1Gb, 4Gb and 5 GB):	 * The first 3 Gb of the "RAID" are evenly spread over the 3 disks.	 * Then things get interesting. The next 2Gb (RAID view) are spread across disk 2 and 3	 * and the last 1Gb is disk 3 only.	 *	 * the way this is solved is like this: We have a list of "cutoff" points where everytime	 * a disk falls out of the "higher" count, we mark the max sector. So once we pass a cutoff	 * point, we have to divide by one less.	 */		device = (bh->b_rdev >> SHIFT)&MAJOR_MASK;	thisraid = &raid[device];	if (thisraid->stride==0)		thisraid->stride=1;	/* Partitions need adding of the start sector of the partition to the requested sector */		rsect += ataraid_gendisk.part[MINOR(bh->b_rdev)].start_sect;	/* Woops we need to split the request to avoid crossing a stride barrier */	if ((rsect/thisraid->stride) != ((rsect+(bh->b_size/512)-1)/thisraid->stride)) {		return -1;	}				rsect_left = rsect;		for (i=0;i<8;i++) {		if (thisraid->cutoff_disks[i]==0)			break;		if (rsect > thisraid->cutoff[i]) {			/* we're in the wrong area so far */			rsect_left -= thisraid->cutoff[i];			rsect_accum += thisraid->cutoff[i]/thisraid->cutoff_disks[i];		} else {			block = rsect_left / thisraid->stride;			disk = block % thisraid->cutoff_disks[i];			block = (block / thisraid->cutoff_disks[i]) * thisraid->stride;			rsect = rsect_accum + (rsect_left % thisraid->stride) + block;			break;		}	}		for (i=0;i<8;i++) {		if ((disk==0) && (thisraid->disk[i].sectors > rsect_accum)) {			real_disk = i;			break;		}		if ((disk>0) && (thisraid->disk[i].sectors >= rsect_accum)) {			disk--;		}			}	disk = real_disk;		/* All but the first disk have a 10 sector offset */	if (i>0)		rsect+=10;				/*	 * The new BH_Lock semantics in ll_rw_blk.c guarantee that this	 * is the only IO operation happening on this bh.	 */	 	bh->b_rdev = thisraid->disk[disk].device;	bh->b_rsector = rsect;	/*	 * Let the main block layer submit the IO and resolve recursion:	 */	return 1;}static int hptraid1_read_request (request_queue_t *q, int rw, struct buffer_head * bh){	int device;	int dist;	int bestsofar,bestdist,i;	static int previous;	/* Reads are simple in principle. Pick a disk and go. 	   Initially I cheat by just picking the one which the last known	   head position is closest by.	   Later on, online/offline checking and performance needs adding */		device = (bh->b_rdev >> SHIFT)&MAJOR_MASK;	bh->b_rsector += ataraid_gendisk.part[MINOR(bh->b_rdev)].start_sect;	bestsofar = 0; 	bestdist = raid[device].disk[0].last_pos - bh->b_rsector;	if (bestdist<0) 		bestdist=-bestdist;	if (bestdist>4095)		bestdist=4095;	for (i=1 ; i<raid[device].disks; i++) {		dist = raid[device].disk[i].last_pos - bh->b_rsector;		if (dist<0) 			dist = -dist;