[PATCH] large dev_t - second series (3/15)

	paride/pt.c cleanups - passing pointer to pt_unit instead of index
in array; same as had been done for pd/pcd/pf.

drivers/block/paride/pt.c

@@ -126,7 +126,6 @@ static int drive2[6] = { 0, 0, 0, -1, -1, -1 };
 static int drive3[6] = { 0, 0, 0, -1, -1, -1 };
 
 static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
-static int pt_drive_count;
 
 #define D_PRT   0
 #define D_PRO   1
@@ -218,9 +217,7 @@ static ssize_t pt_write(struct file *filp, const char *buf,
 			size_t count, loff_t * ppos);
 static int pt_detect(void);
 
-static int pt_identify(int unit);
-
-/* bits in PT.flags */
+/* bits in tape->flags */
 
 #define PT_MEDIA	1
 #define PT_WRITE_OK	2
@@ -246,12 +243,9 @@ struct pt_unit {
 	char name[PT_NAMELEN];	/* pf0, pf1, ... */
 };
 
-struct pt_unit pt[PT_UNITS];
-
-/*  'unit' must be defined in all functions - either as a local or a param */
+static int pt_identify(struct pt_unit *tape);
 
-#define PT pt[unit]
-#define PI PT.pi
+struct pt_unit pt[PT_UNITS];
 
 static char pt_scratch[512];	/* scratch block buffer */
 
@@ -266,156 +260,139 @@ static struct file_operations pt_fops = {
 	.release = pt_release,
 };
 
-static void pt_init_units(void)
+static inline int status_reg(struct pi_adapter *pi)
 {
-	int unit, j;
-
-	pt_drive_count = 0;
-	for (unit = 0; unit < PT_UNITS; unit++) {
-		PT.pi = &PT.pia;
-		atomic_set(&PT.available, 1);
-		PT.flags = 0;
-		PT.last_sense = 0;
-		PT.present = 0;
-		PT.bufptr = NULL;
-		PT.drive = DU[D_SLV];
-		j = 0;
-		while ((j < PT_NAMELEN - 2) && (PT.name[j] = name[j]))
-			j++;
-		PT.name[j++] = '0' + unit;
-		PT.name[j] = 0;
-		if (DU[D_PRT])
-			pt_drive_count++;
-	}
+	return pi_read_regr(pi, 1, 6);
 }
 
-static inline int status_reg(int unit)
+static inline int read_reg(struct pi_adapter *pi, int reg)
 {
-	return pi_read_regr(PI, 1, 6);
+	return pi_read_regr(pi, 0, reg);
 }
 
-static inline int read_reg(int unit, int reg)
+static inline void write_reg(struct pi_adapter *pi, int reg, int val)
 {
-	return pi_read_regr(PI, 0, reg);
+	pi_write_regr(pi, 0, reg, val);
 }
 
-static inline void write_reg(int unit, int reg, int val)
+static inline u8 DRIVE(struct pt_unit *tape)
 {
-	pi_write_regr(PI, 0, reg, val);
+	return 0xa0+0x10*tape->drive;
 }
 
-#define DRIVE           (0xa0+0x10*PT.drive)
-
-static int pt_wait(int unit, int go, int stop, char *fun, char *msg)
+static int pt_wait(struct pt_unit *tape, int go, int stop, char *fun, char *msg)
 {
 	int j, r, e, s, p;
+	struct pi_adapter *pi = tape->pi;
 
 	j = 0;
-	while ((((r = status_reg(unit)) & go) || (stop && (!(r & stop))))
+	while ((((r = status_reg(pi)) & go) || (stop && (!(r & stop))))
 	       && (j++ < PT_SPIN))
 		udelay(PT_SPIN_DEL);
 
 	if ((r & (STAT_ERR & stop)) || (j >= PT_SPIN)) {
-		s = read_reg(unit, 7);
-		e = read_reg(unit, 1);
-		p = read_reg(unit, 2);
+		s = read_reg(pi, 7);
+		e = read_reg(pi, 1);
+		p = read_reg(pi, 2);
 		if (j >= PT_SPIN)
 			e |= 0x100;
 		if (fun)
 			printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
 			       " loop=%d phase=%d\n",
-			       PT.name, fun, msg, r, s, e, j, p);
+			       tape->name, fun, msg, r, s, e, j, p);
 		return (e << 8) + s;
 	}
 	return 0;
 }
 
-static int pt_command(int unit, char *cmd, int dlen, char *fun)
+static int pt_command(struct pt_unit *tape, char *cmd, int dlen, char *fun)
 {
-	pi_connect(PI);
+	struct pi_adapter *pi = tape->pi;
+	pi_connect(pi);
 
-	write_reg(unit, 6, DRIVE);
+	write_reg(pi, 6, DRIVE(tape));
 
-	if (pt_wait(unit, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
-		pi_disconnect(PI);
+	if (pt_wait(tape, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
+		pi_disconnect(pi);
 		return -1;
 	}
 
-	write_reg(unit, 4, dlen % 256);
-	write_reg(unit, 5, dlen / 256);
-	write_reg(unit, 7, 0xa0);	/* ATAPI packet command */
+	write_reg(pi, 4, dlen % 256);
+	write_reg(pi, 5, dlen / 256);
+	write_reg(pi, 7, 0xa0);	/* ATAPI packet command */
 
-	if (pt_wait(unit, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
-		pi_disconnect(PI);
+	if (pt_wait(tape, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
+		pi_disconnect(pi);
 		return -1;
 	}
 
-	if (read_reg(unit, 2) != 1) {
-		printk("%s: %s: command phase error\n", PT.name, fun);
-		pi_disconnect(PI);
+	if (read_reg(pi, 2) != 1) {
+		printk("%s: %s: command phase error\n", tape->name, fun);
+		pi_disconnect(pi);
 		return -1;
 	}
 
-	pi_write_block(PI, cmd, 12);
+	pi_write_block(pi, cmd, 12);
 
 	return 0;
 }
 
-static int pt_completion(int unit, char *buf, char *fun)
+static int pt_completion(struct pt_unit *tape, char *buf, char *fun)
 {
+	struct pi_adapter *pi = tape->pi;
 	int r, s, n, p;
 
-	r = pt_wait(unit, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
+	r = pt_wait(tape, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
 		    fun, "completion");
 
-	if (read_reg(unit, 7) & STAT_DRQ) {
-		n = (((read_reg(unit, 4) + 256 * read_reg(unit, 5)) +
+	if (read_reg(pi, 7) & STAT_DRQ) {
+		n = (((read_reg(pi, 4) + 256 * read_reg(pi, 5)) +
 		      3) & 0xfffc);
-		p = read_reg(unit, 2) & 3;
+		p = read_reg(pi, 2) & 3;
 		if (p == 0)
-			pi_write_block(PI, buf, n);
+			pi_write_block(pi, buf, n);
 		if (p == 2)
-			pi_read_block(PI, buf, n);
+			pi_read_block(pi, buf, n);
 	}
 
-	s = pt_wait(unit, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
+	s = pt_wait(tape, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
 
-	pi_disconnect(PI);
+	pi_disconnect(pi);
 
 	return (r ? r : s);
 }
 
-static void pt_req_sense(int unit, int quiet)
+static void pt_req_sense(struct pt_unit *tape, int quiet)
 {
 	char rs_cmd[12] = { ATAPI_REQ_SENSE, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
 	char buf[16];
 	int r;
 
-	r = pt_command(unit, rs_cmd, 16, "Request sense");
+	r = pt_command(tape, rs_cmd, 16, "Request sense");
 	mdelay(1);
 	if (!r)
-		pt_completion(unit, buf, "Request sense");
+		pt_completion(tape, buf, "Request sense");
 
-	PT.last_sense = -1;
+	tape->last_sense = -1;
 	if (!r) {
 		if (!quiet)
 			printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
-			       PT.name, buf[2] & 0xf, buf[12], buf[13]);
-		PT.last_sense = (buf[2] & 0xf) | ((buf[12] & 0xff) << 8)
+			       tape->name, buf[2] & 0xf, buf[12], buf[13]);
+		tape->last_sense = (buf[2] & 0xf) | ((buf[12] & 0xff) << 8)
 		    | ((buf[13] & 0xff) << 16);
 	}
 }
 
-static int pt_atapi(int unit, char *cmd, int dlen, char *buf, char *fun)
+static int pt_atapi(struct pt_unit *tape, char *cmd, int dlen, char *buf, char *fun)
 {
 	int r;
 
-	r = pt_command(unit, cmd, dlen, fun);
+	r = pt_command(tape, cmd, dlen, fun);
 	mdelay(1);
 	if (!r)
-		r = pt_completion(unit, buf, fun);
+		r = pt_completion(tape, buf, fun);
 	if (r)
-		pt_req_sense(unit, !fun);
+		pt_req_sense(tape, !fun);
 
 	return r;
 }
@@ -426,8 +403,9 @@ static void pt_sleep(int cs)
 	schedule_timeout(cs);
 }
 
-static int pt_poll_dsc(int unit, int pause, int tmo, char *msg)
+static int pt_poll_dsc(struct pt_unit *tape, int pause, int tmo, char *msg)
 {
+	struct pi_adapter *pi = tape->pi;
 	int k, e, s;
 
 	k = 0;
@@ -436,94 +414,95 @@ static int pt_poll_dsc(int unit, int pause, int tmo, char *msg)
 	while (k < tmo) {
 		pt_sleep(pause);
 		k++;
-		pi_connect(PI);
-		write_reg(unit, 6, DRIVE);
-		s = read_reg(unit, 7);
-		e = read_reg(unit, 1);
-		pi_disconnect(PI);
+		pi_connect(pi);
+		write_reg(pi, 6, DRIVE(tape));
+		s = read_reg(pi, 7);
+		e = read_reg(pi, 1);
+		pi_disconnect(pi);
 		if (s & (STAT_ERR | STAT_SEEK))
 			break;
 	}
 	if ((k >= tmo) || (s & STAT_ERR)) {
 		if (k >= tmo)
-			printk("%s: %s DSC timeout\n", PT.name, msg);
+			printk("%s: %s DSC timeout\n", tape->name, msg);
 		else
-			printk("%s: %s stat=0x%x err=0x%x\n", PT.name, msg, s,
+			printk("%s: %s stat=0x%x err=0x%x\n", tape->name, msg, s,
 			       e);
-		pt_req_sense(unit, 0);
+		pt_req_sense(tape, 0);
 		return 0;
 	}
 	return 1;
 }
 
-static void pt_media_access_cmd(int unit, int tmo, char *cmd, char *fun)
+static void pt_media_access_cmd(struct pt_unit *tape, int tmo, char *cmd, char *fun)
 {
-	if (pt_command(unit, cmd, 0, fun)) {
-		pt_req_sense(unit, 0);
+	if (pt_command(tape, cmd, 0, fun)) {
+		pt_req_sense(tape, 0);
 		return;
 	}
-	pi_disconnect(PI);
-	pt_poll_dsc(unit, HZ, tmo, fun);
+	pi_disconnect(tape->pi);
+	pt_poll_dsc(tape, HZ, tmo, fun);
 }
 
-static void pt_rewind(int unit)
+static void pt_rewind(struct pt_unit *tape)
 {
 	char rw_cmd[12] = { ATAPI_REWIND, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
-	pt_media_access_cmd(unit, PT_REWIND_TMO, rw_cmd, "rewind");
+	pt_media_access_cmd(tape, PT_REWIND_TMO, rw_cmd, "rewind");
 }
 
-static void pt_write_fm(int unit)
+static void pt_write_fm(struct pt_unit *tape)
 {
 	char wm_cmd[12] = { ATAPI_WFM, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 };
 
-	pt_media_access_cmd(unit, PT_TMO, wm_cmd, "write filemark");
+	pt_media_access_cmd(tape, PT_TMO, wm_cmd, "write filemark");
 }
 
 #define DBMSG(msg)      ((verbose>1)?(msg):NULL)
 
-static int pt_reset(int unit)
+static int pt_reset(struct pt_unit *tape)
 {
+	struct pi_adapter *pi = tape->pi;
 	int i, k, flg;
 	int expect[5] = { 1, 1, 1, 0x14, 0xeb };
 
-	pi_connect(PI);
-	write_reg(unit, 6, DRIVE);
-	write_reg(unit, 7, 8);
+	pi_connect(pi);
+	write_reg(pi, 6, DRIVE(tape));
+	write_reg(pi, 7, 8);
 
 	pt_sleep(20 * HZ / 1000);
 
 	k = 0;
-	while ((k++ < PT_RESET_TMO) && (status_reg(unit) & STAT_BUSY))
+	while ((k++ < PT_RESET_TMO) && (status_reg(pi) & STAT_BUSY))
 		pt_sleep(HZ / 10);
 
 	flg = 1;
 	for (i = 0; i < 5; i++)
-		flg &= (read_reg(unit, i + 1) == expect[i]);
+		flg &= (read_reg(pi, i + 1) == expect[i]);
 
 	if (verbose) {
-		printk("%s: Reset (%d) signature = ", PT.name, k);
+		printk("%s: Reset (%d) signature = ", tape->name, k);
 		for (i = 0; i < 5; i++)
-			printk("%3x", read_reg(unit, i + 1));
+			printk("%3x", read_reg(pi, i + 1));
 		if (!flg)
 			printk(" (incorrect)");
 		printk("\n");
 	}
 
-	pi_disconnect(PI);
+	pi_disconnect(pi);
 	return flg - 1;
 }
 
-static int pt_ready_wait(int unit, int tmo)
+static int pt_ready_wait(struct pt_unit *tape, int tmo)
 {
 	char tr_cmd[12] = { ATAPI_TEST_READY, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 	int k, p;
 
 	k = 0;
 	while (k < tmo) {
-		PT.last_sense = 0;
-		pt_atapi(unit, tr_cmd, 0, NULL, DBMSG("test unit ready"));
-		p = PT.last_sense;
+		tape->last_sense = 0;
+		pt_atapi(tape, tr_cmd, 0, NULL, DBMSG("test unit ready"));
+		p = tape->last_sense;
 		if (!p)
 			return 0;
 		if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
@@ -558,7 +537,7 @@ static int xn(char *buf, int offs, int size)
 	return v;
 }
 
-static int pt_identify(int unit)
+static int pt_identify(struct pt_unit *tape)
 {
 	int dt, s;
 	char *ms[2] = { "master", "slave" };
@@ -570,7 +549,7 @@ static int pt_identify(int unit)
 	    { ATAPI_LOG_SENSE, 0, 0x71, 0, 0, 0, 0, 0, 36, 0, 0, 0 };
 	char buf[36];
 
-	s = pt_atapi(unit, id_cmd, 36, buf, "identify");
+	s = pt_atapi(tape, id_cmd, 36, buf, "identify");
 	if (s)
 		return -1;
 
@@ -578,36 +557,36 @@ static int pt_identify(int unit)
 	if (dt != 1) {
 		if (verbose)
 			printk("%s: Drive %d, unsupported type %d\n",
-			       PT.name, PT.drive, dt);
+			       tape->name, tape->drive, dt);
 		return -1;
 	}
 
 	xs(buf, mf, 8, 8);
 	xs(buf, id, 16, 16);
 
-	PT.flags = 0;
-	PT.capacity = 0;
-	PT.bs = 0;
+	tape->flags = 0;
+	tape->capacity = 0;
+	tape->bs = 0;
 
-	if (!pt_ready_wait(unit, PT_READY_TMO))
-		PT.flags |= PT_MEDIA;
+	if (!pt_ready_wait(tape, PT_READY_TMO))
+		tape->flags |= PT_MEDIA;
 
-	if (!pt_atapi(unit, ms_cmd, 36, buf, "mode sense")) {
+	if (!pt_atapi(tape, ms_cmd, 36, buf, "mode sense")) {
 		if (!(buf[2] & 0x80))
-			PT.flags |= PT_WRITE_OK;
-		PT.bs = xn(buf, 10, 2);
+			tape->flags |= PT_WRITE_OK;
+		tape->bs = xn(buf, 10, 2);
 	}
 
-	if (!pt_atapi(unit, ls_cmd, 36, buf, "log sense"))
-		PT.capacity = xn(buf, 24, 4);
+	if (!pt_atapi(tape, ls_cmd, 36, buf, "log sense"))
+		tape->capacity = xn(buf, 24, 4);
 
-	printk("%s: %s %s, %s", PT.name, mf, id, ms[PT.drive]);
-	if (!(PT.flags & PT_MEDIA))
+	printk("%s: %s %s, %s", tape->name, mf, id, ms[tape->drive]);
+	if (!(tape->flags & PT_MEDIA))
 		printk(", no media\n");
 	else {
-		if (!(PT.flags & PT_WRITE_OK))
+		if (!(tape->flags & PT_WRITE_OK))
 			printk(", RO");
-		printk(", blocksize %d, %d MB\n", PT.bs, PT.capacity / 1024);
+		printk(", blocksize %d, %d MB\n", tape->bs, tape->capacity / 1024);
 	}
 
 	return 0;
@@ -618,109 +597,117 @@ static int pt_identify(int unit)
  * returns  0, with id set if drive is detected
  *	   -1, if drive detection failed
  */
-static int pt_probe(int unit)
+static int pt_probe(struct pt_unit *tape)
 {
-	if (PT.drive == -1) {
-		for (PT.drive = 0; PT.drive <= 1; PT.drive++)
-			if (!pt_reset(unit))
-				return pt_identify(unit);
+	if (tape->drive == -1) {
+		for (tape->drive = 0; tape->drive <= 1; tape->drive++)
+			if (!pt_reset(tape))
+				return pt_identify(tape);
 	} else {
-		if (!pt_reset(unit))
-			return pt_identify(unit);
+		if (!pt_reset(tape))
+			return pt_identify(tape);
 	}
 	return -1;
 }
 
 static int pt_detect(void)
 {
-	int k, unit;
+	struct pt_unit *tape;
+	int specified = 0, found = 0;
+	int unit;
 
 	printk("%s: %s version %s, major %d\n", name, name, PT_VERSION, major);
 
-	k = 0;
-	if (pt_drive_count == 0) {
-		unit = 0;
-		if (pi_init(PI, 1, -1, -1, -1, -1, -1, pt_scratch,
-			    PI_PT, verbose, PT.name)) {
-			if (!pt_probe(unit)) {
-				PT.present = 1;
-				k++;
+	specified = 0;
+	for (unit = 0; unit < PT_UNITS; unit++) {
+		struct pt_unit *tape = &pt[unit];
+		tape->pi = &tape->pia;
+		atomic_set(&tape->available, 1);
+		tape->flags = 0;
+		tape->last_sense = 0;
+		tape->present = 0;
+		tape->bufptr = NULL;
+		tape->drive = DU[D_SLV];
+		snprintf(tape->name, PT_NAMELEN, "%s%d", name, unit);
+		if (!DU[D_PRT])
+			continue;
+		specified++;
+		if (pi_init(tape->pi, 0, DU[D_PRT], DU[D_MOD], DU[D_UNI],
+		     DU[D_PRO], DU[D_DLY], pt_scratch, PI_PT,
+		     verbose, tape->name)) {
+			if (!pt_probe(tape)) {
+				tape->present = 1;
+				found++;
 			} else
-				pi_release(PI);
+				pi_release(tape->pi);
+		}
+	}
+	if (specified == 0) {
+		tape = pt;
+		if (pi_init(tape->pi, 1, -1, -1, -1, -1, -1, pt_scratch,
+			    PI_PT, verbose, tape->name)) {
+			if (!pt_probe(tape)) {
+				tape->present = 1;
+				found++;
+			} else
+				pi_release(tape->pi);
 		}
 
-	} else
-		for (unit = 0; unit < PT_UNITS; unit++)
-			if (DU[D_PRT])
-				if (pi_init
-				    (PI, 0, DU[D_PRT], DU[D_MOD], DU[D_UNI],
-				     DU[D_PRO], DU[D_DLY], pt_scratch, PI_PT,
-				     verbose, PT.name)) {
-					if (!pt_probe(unit)) {
-						PT.present = 1;
-						k++;
-					} else
-						pi_release(PI);
-				}
-
-	if (k)
+	}
+	if (found)
 		return 0;
 
 	printk("%s: No ATAPI tape drive detected\n", name);
 	return -1;
 }
 
-#define DEVICE_NR(inode)	(iminor(inode) & 0x7F)
-
 static int pt_open(struct inode *inode, struct file *file)
 {
-	int unit = DEVICE_NR(inode);
+	int unit = iminor(inode) & 0x7F;
+	struct pt_unit *tape = pt + unit;
+	int err;
 
-	if ((unit >= PT_UNITS) || (!PT.present))
+	if (unit >= PT_UNITS || (!tape->present))
 		return -ENODEV;
 
-	if (!atomic_dec_and_test(&PT.available)) {
-		atomic_inc(&PT.available);
-		return -EBUSY;
-	}
+	err = -EBUSY;
+	if (!atomic_dec_and_test(&tape->available))
+		goto out;
 
-	pt_identify(unit);
+	pt_identify(tape);
 
-	if (!PT.flags & PT_MEDIA) {
-		atomic_inc(&PT.available);
-		return -ENODEV;
-	}
+	err = -ENODEV;
+	if (!tape->flags & PT_MEDIA)
+		goto out;
 
-	if ((!PT.flags & PT_WRITE_OK) && (file->f_mode & 2)) {
-		atomic_inc(&PT.available);
-		return -EROFS;
-	}
+	err = -EROFS;
+	if ((!tape->flags & PT_WRITE_OK) && (file->f_mode & 2))
+		goto out;
 
 	if (!(iminor(inode) & 128))
-		PT.flags |= PT_REWIND;
+		tape->flags |= PT_REWIND;
 
-	PT.bufptr = kmalloc(PT_BUFSIZE, GFP_KERNEL);
-	if (PT.bufptr == NULL) {
-		atomic_inc(&PT.available);
-		printk("%s: buffer allocation failed\n", PT.name);
-		return -ENOMEM;
+	err = -ENOMEM;
+	tape->bufptr = kmalloc(PT_BUFSIZE, GFP_KERNEL);
+	if (tape->bufptr == NULL) {
+		printk("%s: buffer allocation failed\n", tape->name);
+		goto out;
 	}
 
+	file->private_data = tape;
 	return 0;
+
+out:
+	atomic_inc(&tape->available);
+	return err;
 }
 
 static int pt_ioctl(struct inode *inode, struct file *file,
 	 unsigned int cmd, unsigned long arg)
 {
-	int unit;
+	struct pt_unit *tape = file->private_data;
 	struct mtop mtop;
 
-	unit = DEVICE_NR(inode);
-	if (unit >= PT_UNITS)
-		return -EINVAL;
-	if (!PT.present)
-		return -ENODEV;
-
 	switch (cmd) {
 	case MTIOCTOP:
 		if (copy_from_user((char *) &mtop, (char *) arg,
@@ -730,21 +717,21 @@ static int pt_ioctl(struct inode *inode, struct file *file,
 		switch (mtop.mt_op) {
 
 		case MTREW:
-			pt_rewind(unit);
+			pt_rewind(tape);
 			return 0;
 
 		case MTWEOF:
-			pt_write_fm(unit);
+			pt_write_fm(tape);
 			return 0;
 
 		default:
-			printk("%s: Unimplemented mt_op %d\n", PT.name,
+			printk("%s: Unimplemented mt_op %d\n", tape->name,
 			       mtop.mt_op);
 			return -EINVAL;
 		}
 
 	default:
-		printk("%s: Unimplemented ioctl 0x%x\n", PT.name, cmd);
+		printk("%s: Unimplemented ioctl 0x%x\n", tape->name, cmd);
 		return -EINVAL;
 
 	}
@@ -753,21 +740,21 @@ static int pt_ioctl(struct inode *inode, struct file *file,
 static int
 pt_release(struct inode *inode, struct file *file)
 {
-	int unit = DEVICE_NR(inode);
+	struct pt_unit *tape = file->private_data;
 
-	if ((unit >= PT_UNITS) || (atomic_read(&PT.available) > 1))
+	if (atomic_read(&tape->available) > 1)
 		return -EINVAL;
 
-	if (PT.flags & PT_WRITING)
-		pt_write_fm(unit);
+	if (tape->flags & PT_WRITING)
+		pt_write_fm(tape);
 
-	if (PT.flags & PT_REWIND)
-		pt_rewind(unit);
+	if (tape->flags & PT_REWIND)
+		pt_rewind(tape);
 
-	kfree(PT.bufptr);
-	PT.bufptr = NULL;
+	kfree(tape->bufptr);
+	tape->bufptr = NULL;
 
-	atomic_inc(&PT.available);
+	atomic_inc(&tape->available);
 
 	return 0;
 
@@ -775,70 +762,70 @@ pt_release(struct inode *inode, struct file *file)
 
 static ssize_t pt_read(struct file *filp, char *buf, size_t count, loff_t * ppos)
 {
-	struct inode *ino = filp->f_dentry->d_inode;
-	int unit = DEVICE_NR(ino);
+	struct pt_unit *tape = filp->private_data;
+	struct pi_adapter *pi = tape->pi;
 	char rd_cmd[12] = { ATAPI_READ_6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 	int k, n, r, p, s, t, b;
 
-	if (!(PT.flags & (PT_READING | PT_WRITING))) {
-		PT.flags |= PT_READING;
-		if (pt_atapi(unit, rd_cmd, 0, NULL, "start read-ahead"))
+	if (!(tape->flags & (PT_READING | PT_WRITING))) {
+		tape->flags |= PT_READING;
+		if (pt_atapi(tape, rd_cmd, 0, NULL, "start read-ahead"))
 			return -EIO;
-	} else if (PT.flags & PT_WRITING)
+	} else if (tape->flags & PT_WRITING)
 		return -EIO;
 
-	if (PT.flags & PT_EOF)
+	if (tape->flags & PT_EOF)
 		return 0;
 
 	t = 0;
 
 	while (count > 0) {
 
-		if (!pt_poll_dsc(unit, HZ / 100, PT_TMO, "read"))
+		if (!pt_poll_dsc(tape, HZ / 100, PT_TMO, "read"))
 			return -EIO;
 
 		n = count;
 		if (n > 32768)
 			n = 32768;	/* max per command */
-		b = (n - 1 + PT.bs) / PT.bs;
-		n = b * PT.bs;	/* rounded up to even block */
+		b = (n - 1 + tape->bs) / tape->bs;
+		n = b * tape->bs;	/* rounded up to even block */
 
 		rd_cmd[4] = b;
 
-		r = pt_command(unit, rd_cmd, n, "read");
+		r = pt_command(tape, rd_cmd, n, "read");
 
 		mdelay(1);
 
 		if (r) {
-			pt_req_sense(unit, 0);
+			pt_req_sense(tape, 0);
 			return -EIO;
 		}
 
 		while (1) {
 
-			r = pt_wait(unit, STAT_BUSY,
+			r = pt_wait(tape, STAT_BUSY,
 				    STAT_DRQ | STAT_ERR | STAT_READY,
 				    DBMSG("read DRQ"), "");
 
 			if (r & STAT_SENSE) {
-				pi_disconnect(PI);
-				pt_req_sense(unit, 0);
+				pi_disconnect(pi);
+				pt_req_sense(tape, 0);
 				return -EIO;
 			}
 
 			if (r)
-				PT.flags |= PT_EOF;
+				tape->flags |= PT_EOF;
 
-			s = read_reg(unit, 7);
+			s = read_reg(pi, 7);
 
 			if (!(s & STAT_DRQ))
 				break;
 
-			n = (read_reg(unit, 4) + 256 * read_reg(unit, 5));
-			p = (read_reg(unit, 2) & 3);
+			n = (read_reg(pi, 4) + 256 * read_reg(pi, 5));
+			p = (read_reg(pi, 2) & 3);
 			if (p != 2) {
-				pi_disconnect(PI);
-				printk("%s: Phase error on read: %d\n", PT.name,
+				pi_disconnect(pi);
+				printk("%s: Phase error on read: %d\n", tape->name,
 				       p);
 				return -EIO;
 			}
@@ -847,13 +834,13 @@ static ssize_t pt_read(struct file *filp, char *buf, size_t count, loff_t * ppos
 				k = n;
 				if (k > PT_BUFSIZE)
 					k = PT_BUFSIZE;
-				pi_read_block(PI, PT.bufptr, k);
+				pi_read_block(pi, tape->bufptr, k);
 				n -= k;
 				b = k;
 				if (b > count)
 					b = count;
-				if (copy_to_user(buf + t, PT.bufptr, b)) {
-					pi_disconnect(PI);
+				if (copy_to_user(buf + t, tape->bufptr, b)) {
+					pi_disconnect(pi);
 					return -EFAULT;
 				}
 				t += b;
@@ -861,8 +848,8 @@ static ssize_t pt_read(struct file *filp, char *buf, size_t count, loff_t * ppos
 			}
 
 		}
-		pi_disconnect(PI);
-		if (PT.flags & PT_EOF)
+		pi_disconnect(pi);
+		if (tape->flags & PT_EOF)
 			break;
 	}
 
@@ -872,75 +859,75 @@ static ssize_t pt_read(struct file *filp, char *buf, size_t count, loff_t * ppos
 
 static ssize_t pt_write(struct file *filp, const char *buf, size_t count, loff_t * ppos)
 {
-	struct inode *ino = filp->f_dentry->d_inode;
-	int unit = DEVICE_NR(ino);
+	struct pt_unit *tape = filp->private_data;
+	struct pi_adapter *pi = tape->pi;
 	char wr_cmd[12] = { ATAPI_WRITE_6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 	int k, n, r, p, s, t, b;
 
-	if (!(PT.flags & PT_WRITE_OK))
+	if (!(tape->flags & PT_WRITE_OK))
 		return -EROFS;
 
-	if (!(PT.flags & (PT_READING | PT_WRITING))) {
-		PT.flags |= PT_WRITING;
+	if (!(tape->flags & (PT_READING | PT_WRITING))) {
+		tape->flags |= PT_WRITING;
 		if (pt_atapi
-		    (unit, wr_cmd, 0, NULL, "start buffer-available mode"))
+		    (tape, wr_cmd, 0, NULL, "start buffer-available mode"))
 			return -EIO;
-	} else if (PT.flags & PT_READING)
+	} else if (tape->flags & PT_READING)
 		return -EIO;
 
-	if (PT.flags & PT_EOF)
+	if (tape->flags & PT_EOF)
 		return -ENOSPC;
 
 	t = 0;
 
 	while (count > 0) {
 
-		if (!pt_poll_dsc(unit, HZ / 100, PT_TMO, "write"))
+		if (!pt_poll_dsc(tape, HZ / 100, PT_TMO, "write"))
 			return -EIO;
 
 		n = count;
 		if (n > 32768)
 			n = 32768;	/* max per command */
-		b = (n - 1 + PT.bs) / PT.bs;
-		n = b * PT.bs;	/* rounded up to even block */
+		b = (n - 1 + tape->bs) / tape->bs;
+		n = b * tape->bs;	/* rounded up to even block */
 
 		wr_cmd[4] = b;
 
-		r = pt_command(unit, wr_cmd, n, "write");
+		r = pt_command(tape, wr_cmd, n, "write");
 
 		mdelay(1);
 
 		if (r) {	/* error delivering command only */
-			pt_req_sense(unit, 0);
+			pt_req_sense(tape, 0);
 			return -EIO;
 		}
 
 		while (1) {
 
-			r = pt_wait(unit, STAT_BUSY,
+			r = pt_wait(tape, STAT_BUSY,
 				    STAT_DRQ | STAT_ERR | STAT_READY,
 				    DBMSG("write DRQ"), NULL);
 
 			if (r & STAT_SENSE) {
-				pi_disconnect(PI);
-				pt_req_sense(unit, 0);
+				pi_disconnect(pi);
+				pt_req_sense(tape, 0);
 				return -EIO;
 			}
 
 			if (r)
-				PT.flags |= PT_EOF;
+				tape->flags |= PT_EOF;
 
-			s = read_reg(unit, 7);
+			s = read_reg(pi, 7);
 
 			if (!(s & STAT_DRQ))
 				break;
 
-			n = (read_reg(unit, 4) + 256 * read_reg(unit, 5));
-			p = (read_reg(unit, 2) & 3);
+			n = (read_reg(pi, 4) + 256 * read_reg(pi, 5));
+			p = (read_reg(pi, 2) & 3);
 			if (p != 0) {
-				pi_disconnect(PI);
+				pi_disconnect(pi);
 				printk("%s: Phase error on write: %d \n",
-				       PT.name, p);
+				       tape->name, p);
 				return -EIO;
 			}
 
@@ -951,19 +938,19 @@ static ssize_t pt_write(struct file *filp, const char *buf, size_t count, loff_t
 				b = k;
 				if (b > count)
 					b = count;
-				if (copy_from_user(PT.bufptr, buf + t, b)) {
-					pi_disconnect(PI);
+				if (copy_from_user(tape->bufptr, buf + t, b)) {
+					pi_disconnect(pi);
 					return -EFAULT;
 				}
-				pi_write_block(PI, PT.bufptr, k);
+				pi_write_block(pi, tape->bufptr, k);
 				t += b;
 				count -= b;
 				n -= k;
 			}
 
 		}
-		pi_disconnect(PI);
-		if (PT.flags & PT_EOF)
+		pi_disconnect(pi);
+		if (tape->flags & PT_EOF)
 			break;
 	}
 
@@ -977,22 +964,20 @@ static int __init pt_init(void)
 	if (disable)
 		return -1;
 
-	pt_init_units();
-
 	if (pt_detect())
 		return -1;
 
 	if (register_chrdev(major, name, &pt_fops)) {
 		printk("pt_init: unable to get major number %d\n", major);
 		for (unit = 0; unit < PT_UNITS; unit++)
-			if (PT.present)
-				pi_release(PI);
+			if (pt[unit].present)
+				pi_release(pt[unit].pi);
 		return -1;
 	}
 
 	devfs_mk_dir("pt");
 	for (unit = 0; unit < PT_UNITS; unit++)
-		if (PT.present) {
+		if (pt[unit].present) {
 			devfs_mk_cdev(MKDEV(major, unit),
 				      S_IFCHR | S_IRUSR | S_IWUSR,
 				      "pt/%d", unit);
@@ -1007,15 +992,15 @@ static void __exit pt_exit(void)
 {
 	int unit;
 	for (unit = 0; unit < PT_UNITS; unit++)
-		if (PT.present) {
+		if (pt[unit].present) {
 			devfs_remove("pt/%d", unit);
 			devfs_remove("pt/%dn", unit);
 		}
 	devfs_remove("pt");
 	unregister_chrdev(major, name);
 	for (unit = 0; unit < PT_UNITS; unit++)
-		if (PT.present)
-			pi_release(PI);
+		if (pt[unit].present)
+			pi_release(pt[unit].pi);
 }
 
 MODULE_LICENSE("GPL");