From: viro@www.linux.org.uk 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 | 511 ++++++++++++++++++++++------------------------ 1 files changed, 248 insertions(+), 263 deletions(-) diff -puN drivers/block/paride/pt.c~large-dev_t-2nd-03 drivers/block/paride/pt.c --- 25/drivers/block/paride/pt.c~large-dev_t-2nd-03 2003-09-05 00:49:32.000000000 -0700 +++ 25-akpm/drivers/block/paride/pt.c 2003-09-05 00:49:32.000000000 -0700 @@ -126,7 +126,6 @@ static int drive2[6] = { 0, 0, 0, -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 *fil 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 pau 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 s 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); - - if ((unit >= PT_UNITS) || (!PT.present)) - return -ENODEV; + int unit = iminor(inode) & 0x7F; + struct pt_unit *tape = pt + unit; + int err; - if (!atomic_dec_and_test(&PT.available)) { - atomic_inc(&PT.available); - return -EBUSY; - } - - pt_identify(unit); - - if (!PT.flags & PT_MEDIA) { - atomic_inc(&PT.available); + if (unit >= PT_UNITS || (!tape->present)) return -ENODEV; - } - if ((!PT.flags & PT_WRITE_OK) && (file->f_mode & 2)) { - atomic_inc(&PT.available); - return -EROFS; - } + err = -EBUSY; + if (!atomic_dec_and_test(&tape->available)) + goto out; + + pt_identify(tape); + + err = -ENODEV; + if (!tape->flags & PT_MEDIA) + goto out; + + 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, 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, 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 f 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 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 } } - 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 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 *fil 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"); _