drivers/block/paride/pt.c

   1 /*
   2         pt.c    (c) 1998  Grant R. Guenther <grant@torque.net>
   3                           Under the terms of the GNU General Public License.
   4
   5         This is the high-level driver for parallel port ATAPI tape
   6         drives based on chips supported by the paride module.
   7
   8         The driver implements both rewinding and non-rewinding
   9         devices, filemarks, and the rewind ioctl.  It allocates
  10         a small internal "bounce buffer" for each open device, but
  11         otherwise expects buffering and blocking to be done at the
  12         user level.  As with most block-structured tapes, short
  13         writes are padded to full tape blocks, so reading back a file
  14         may return more data than was actually written.
  15
  16         By default, the driver will autoprobe for a single parallel
  17         port ATAPI tape drive, but if their individual parameters are
  18         specified, the driver can handle up to 4 drives.
  19
  20         The rewinding devices are named /dev/pt0, /dev/pt1, ...
  21         while the non-rewinding devices are /dev/npt0, /dev/npt1, etc.
  22
  23         The behaviour of the pt driver can be altered by setting
  24         some parameters from the insmod command line.  The following
  25         parameters are adjustable:
  26
  27             drive0      These four arguments can be arrays of
  28             drive1      1-6 integers as follows:
  29             drive2
  30             drive3      <prt>,<pro>,<uni>,<mod>,<slv>,<dly>
  31
  32                         Where,
  33
  34                 <prt>   is the base of the parallel port address for
  35                         the corresponding drive.  (required)
  36
  37                 <pro>   is the protocol number for the adapter that
  38                         supports this drive.  These numbers are
  39                         logged by 'paride' when the protocol modules
  40                         are initialised.  (0 if not given)
  41
  42                 <uni>   for those adapters that support chained
  43                         devices, this is the unit selector for the
  44                         chain of devices on the given port.  It should
  45                         be zero for devices that don't support chaining.
  46                         (0 if not given)
  47
  48                 <mod>   this can be -1 to choose the best mode, or one
  49                         of the mode numbers supported by the adapter.
  50                         (-1 if not given)
  51
  52                 <slv>   ATAPI devices can be jumpered to master or slave.
  53                         Set this to 0 to choose the master drive, 1 to
  54                         choose the slave, -1 (the default) to choose the
  55                         first drive found.
  56
  57                 <dly>   some parallel ports require the driver to
  58                         go more slowly.  -1 sets a default value that
  59                         should work with the chosen protocol.  Otherwise,
  60                         set this to a small integer, the larger it is
  61                         the slower the port i/o.  In some cases, setting
  62                         this to zero will speed up the device. (default -1)
  63
  64             major       You may use this parameter to override the
  65                         default major number (96) that this driver
  66                         will use.  Be sure to change the device
  67                         name as well.
  68
  69             name        This parameter is a character string that
  70                         contains the name the kernel will use for this
  71                         device (in /proc output, for instance).
  72                         (default "pt").
  73
  74             verbose     This parameter controls the amount of logging
  75                         that the driver will do.  Set it to 0 for
  76                         normal operation, 1 to see autoprobe progress
  77                         messages, or 2 to see additional debugging
  78                         output.  (default 0)
  79
  80         If this driver is built into the kernel, you can use
  81         the following command line parameters, with the same values
  82         as the corresponding module parameters listed above:
  83
  84             pt.drive0
  85             pt.drive1
  86             pt.drive2
  87             pt.drive3
  88
  89         In addition, you can use the parameter pt.disable to disable
  90         the driver entirely.
  91
  92 */
  93
  94 /*   Changes:
  95
  96         1.01    GRG 1998.05.06  Round up transfer size, fix ready_wait,
  97                                 loosed interpretation of ATAPI standard
  98                                 for clearing error status.
  99                                 Eliminate sti();
 100         1.02    GRG 1998.06.16  Eliminate an Ugh.
 101         1.03    GRG 1998.08.15  Adjusted PT_TMO, use HZ in loop timing,
 102                                 extra debugging
 103         1.04    GRG 1998.09.24  Repair minor coding error, added jumbo support
 104
 105 */
 106
 107 #define PT_VERSION      "1.04"
 108 #define PT_MAJOR        96
 109 #define PT_NAME         "pt"
 110 #define PT_UNITS        4
 111
 112 #include <linux/types.h>
 113
 114 /* Here are things one can override from the insmod command.
 115    Most are autoprobed by paride unless set here.  Verbose is on
 116    by default.
 117
 118 */
 119
 120 static int verbose = 0;
 121 static int major = PT_MAJOR;
 122 static char *name = PT_NAME;
 123 static int disable = 0;
 124
 125 static int drive0[6] = { 0, 0, 0, -1, -1, -1 };
 126 static int drive1[6] = { 0, 0, 0, -1, -1, -1 };
 127 static int drive2[6] = { 0, 0, 0, -1, -1, -1 };
 128 static int drive3[6] = { 0, 0, 0, -1, -1, -1 };
 129
 130 static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
 131
 132 #define D_PRT   0
 133 #define D_PRO   1
 134 #define D_UNI   2
 135 #define D_MOD   3
 136 #define D_SLV   4
 137 #define D_DLY   5
 138
 139 #define DU              (*drives[unit])
 140
 141 /* end of parameters */
 142
 143 #include <linux/module.h>
 144 #include <linux/init.h>
 145 #include <linux/fs.h>
 146 #include <linux/delay.h>
 147 #include <linux/slab.h>
 148 #include <linux/mtio.h>
 149 #include <linux/device.h>
 150 #include <linux/sched.h>        /* current, TASK_*, schedule_timeout() */
 151 #include <linux/mutex.h>
 152
 153 #include <linux/uaccess.h>
 154
 155 module_param(verbose, int, 0);
 156 module_param(major, int, 0);
 157 module_param(name, charp, 0);
 158 module_param_array(drive0, int, NULL, 0);
 159 module_param_array(drive1, int, NULL, 0);
 160 module_param_array(drive2, int, NULL, 0);
 161 module_param_array(drive3, int, NULL, 0);
 162
 163 #include "paride.h"
 164
 165 #define PT_MAX_RETRIES  5
 166 #define PT_TMO          3000    /* interrupt timeout in jiffies */
 167 #define PT_SPIN_DEL     50      /* spin delay in micro-seconds  */
 168 #define PT_RESET_TMO    30      /* 30 seconds */
 169 #define PT_READY_TMO    60      /* 60 seconds */
 170 #define PT_REWIND_TMO   1200    /* 20 minutes */
 171
 172 #define PT_SPIN         ((1000000/(HZ*PT_SPIN_DEL))*PT_TMO)
 173
 174 #define STAT_ERR        0x00001
 175 #define STAT_INDEX      0x00002
 176 #define STAT_ECC        0x00004
 177 #define STAT_DRQ        0x00008
 178 #define STAT_SEEK       0x00010
 179 #define STAT_WRERR      0x00020
 180 #define STAT_READY      0x00040
 181 #define STAT_BUSY       0x00080
 182 #define STAT_SENSE      0x1f000
 183
 184 #define ATAPI_TEST_READY        0x00
 185 #define ATAPI_REWIND            0x01
 186 #define ATAPI_REQ_SENSE         0x03
 187 #define ATAPI_READ_6            0x08
 188 #define ATAPI_WRITE_6           0x0a
 189 #define ATAPI_WFM               0x10
 190 #define ATAPI_IDENTIFY          0x12
 191 #define ATAPI_MODE_SENSE        0x1a
 192 #define ATAPI_LOG_SENSE         0x4d
 193
 194 static DEFINE_MUTEX(pt_mutex);
 195 static int pt_open(struct inode *inode, struct file *file);
 196 static long pt_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 197 static int pt_release(struct inode *inode, struct file *file);
 198 static ssize_t pt_read(struct file *filp, char __user *buf,
 199                        size_t count, loff_t * ppos);
 200 static ssize_t pt_write(struct file *filp, const char __user *buf,
 201                         size_t count, loff_t * ppos);
 202 static int pt_detect(void);
 203
 204 /* bits in tape->flags */
 205
 206 #define PT_MEDIA        1
 207 #define PT_WRITE_OK     2
 208 #define PT_REWIND       4
 209 #define PT_WRITING      8
 210 #define PT_READING     16
 211 #define PT_EOF         32
 212
 213 #define PT_NAMELEN      8
 214 #define PT_BUFSIZE  16384
 215
 216 struct pt_unit {
 217         struct pi_adapter pia;  /* interface to paride layer */
 218         struct pi_adapter *pi;
 219         int flags;              /* various state flags */
 220         int last_sense;         /* result of last request sense */
 221         int drive;              /* drive */
 222         atomic_t available;     /* 1 if access is available 0 otherwise */
 223         int bs;                 /* block size */
 224         int capacity;           /* Size of tape in KB */
 225         int present;            /* device present ? */
 226         char *bufptr;
 227         char name[PT_NAMELEN];  /* pf0, pf1, ... */
 228 };
 229
 230 static int pt_identify(struct pt_unit *tape);
 231
 232 static struct pt_unit pt[PT_UNITS];
 233
 234 static char pt_scratch[512];    /* scratch block buffer */
 235 static void *par_drv;           /* reference of parport driver */
 236
 237 /* kernel glue structures */
 238
 239 static const struct file_operations pt_fops = {
 240         .owner = THIS_MODULE,
 241         .read = pt_read,
 242         .write = pt_write,
 243         .unlocked_ioctl = pt_ioctl,
 244         .open = pt_open,
 245         .release = pt_release,
 246         .llseek = noop_llseek,
 247 };
 248
 249 /* sysfs class support */
 250 static struct class *pt_class;
 251
 252 static inline int status_reg(struct pi_adapter *pi)
 253 {
 254         return pi_read_regr(pi, 1, 6);
 255 }
 256
 257 static inline int read_reg(struct pi_adapter *pi, int reg)
 258 {
 259         return pi_read_regr(pi, 0, reg);
 260 }
 261
 262 static inline void write_reg(struct pi_adapter *pi, int reg, int val)
 263 {
 264         pi_write_regr(pi, 0, reg, val);
 265 }
 266
 267 static inline u8 DRIVE(struct pt_unit *tape)
 268 {
 269         return 0xa0+0x10*tape->drive;
 270 }
 271
 272 static int pt_wait(struct pt_unit *tape, int go, int stop, char *fun, char *msg)
 273 {
 274         int j, r, e, s, p;
 275         struct pi_adapter *pi = tape->pi;
 276
 277         j = 0;
 278         while ((((r = status_reg(pi)) & go) || (stop && (!(r & stop))))
 279                && (j++ < PT_SPIN))
 280                 udelay(PT_SPIN_DEL);
 281
 282         if ((r & (STAT_ERR & stop)) || (j > PT_SPIN)) {
 283                 s = read_reg(pi, 7);
 284                 e = read_reg(pi, 1);
 285                 p = read_reg(pi, 2);
 286                 if (j > PT_SPIN)
 287                         e |= 0x100;
 288                 if (fun)
 289                         printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
 290                                " loop=%d phase=%d\n",
 291                                tape->name, fun, msg, r, s, e, j, p);
 292                 return (e << 8) + s;
 293         }
 294         return 0;
 295 }
 296
 297 static int pt_command(struct pt_unit *tape, char *cmd, int dlen, char *fun)
 298 {
 299         struct pi_adapter *pi = tape->pi;
 300         pi_connect(pi);
 301
 302         write_reg(pi, 6, DRIVE(tape));
 303
 304         if (pt_wait(tape, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
 305                 pi_disconnect(pi);
 306                 return -1;
 307         }
 308
 309         write_reg(pi, 4, dlen % 256);
 310         write_reg(pi, 5, dlen / 256);
 311         write_reg(pi, 7, 0xa0); /* ATAPI packet command */
 312
 313         if (pt_wait(tape, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
 314                 pi_disconnect(pi);
 315                 return -1;
 316         }
 317
 318         if (read_reg(pi, 2) != 1) {
 319                 printk("%s: %s: command phase error\n", tape->name, fun);
 320                 pi_disconnect(pi);
 321                 return -1;
 322         }
 323
 324         pi_write_block(pi, cmd, 12);
 325
 326         return 0;
 327 }
 328
 329 static int pt_completion(struct pt_unit *tape, char *buf, char *fun)
 330 {
 331         struct pi_adapter *pi = tape->pi;
 332         int r, s, n, p;
 333
 334         r = pt_wait(tape, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
 335                     fun, "completion");
 336
 337         if (read_reg(pi, 7) & STAT_DRQ) {
 338                 n = (((read_reg(pi, 4) + 256 * read_reg(pi, 5)) +
 339                       3) & 0xfffc);
 340                 p = read_reg(pi, 2) & 3;
 341                 if (p == 0)
 342                         pi_write_block(pi, buf, n);
 343                 if (p == 2)
 344                         pi_read_block(pi, buf, n);
 345         }
 346
 347         s = pt_wait(tape, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
 348
 349         pi_disconnect(pi);
 350
 351         return (r ? r : s);
 352 }
 353
 354 static void pt_req_sense(struct pt_unit *tape, int quiet)
 355 {
 356         char rs_cmd[12] = { ATAPI_REQ_SENSE, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
 357         char buf[16];
 358         int r;
 359
 360         r = pt_command(tape, rs_cmd, 16, "Request sense");
 361         mdelay(1);
 362         if (!r)
 363                 pt_completion(tape, buf, "Request sense");
 364
 365         tape->last_sense = -1;
 366         if (!r) {
 367                 if (!quiet)
 368                         printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
 369                                tape->name, buf[2] & 0xf, buf[12], buf[13]);
 370                 tape->last_sense = (buf[2] & 0xf) | ((buf[12] & 0xff) << 8)
 371                     | ((buf[13] & 0xff) << 16);
 372         }
 373 }
 374
 375 static int pt_atapi(struct pt_unit *tape, char *cmd, int dlen, char *buf, char *fun)
 376 {
 377         int r;
 378
 379         r = pt_command(tape, cmd, dlen, fun);
 380         mdelay(1);
 381         if (!r)
 382                 r = pt_completion(tape, buf, fun);
 383         if (r)
 384                 pt_req_sense(tape, !fun);
 385
 386         return r;
 387 }
 388
 389 static void pt_sleep(int cs)
 390 {
 391         schedule_timeout_interruptible(cs);
 392 }
 393
 394 static int pt_poll_dsc(struct pt_unit *tape, int pause, int tmo, char *msg)
 395 {
 396         struct pi_adapter *pi = tape->pi;
 397         int k, e, s;
 398
 399         k = 0;
 400         e = 0;
 401         s = 0;
 402         while (k < tmo) {
 403                 pt_sleep(pause);
 404                 k++;
 405                 pi_connect(pi);
 406                 write_reg(pi, 6, DRIVE(tape));
 407                 s = read_reg(pi, 7);
 408                 e = read_reg(pi, 1);
 409                 pi_disconnect(pi);
 410                 if (s & (STAT_ERR | STAT_SEEK))
 411                         break;
 412         }
 413         if ((k >= tmo) || (s & STAT_ERR)) {
 414                 if (k >= tmo)
 415                         printk("%s: %s DSC timeout\n", tape->name, msg);
 416                 else
 417                         printk("%s: %s stat=0x%x err=0x%x\n", tape->name, msg, s,
 418                                e);
 419                 pt_req_sense(tape, 0);
 420                 return 0;
 421         }
 422         return 1;
 423 }
 424
 425 static void pt_media_access_cmd(struct pt_unit *tape, int tmo, char *cmd, char *fun)
 426 {
 427         if (pt_command(tape, cmd, 0, fun)) {
 428                 pt_req_sense(tape, 0);
 429                 return;
 430         }
 431         pi_disconnect(tape->pi);
 432         pt_poll_dsc(tape, HZ, tmo, fun);
 433 }
 434
 435 static void pt_rewind(struct pt_unit *tape)
 436 {
 437         char rw_cmd[12] = { ATAPI_REWIND, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 438
 439         pt_media_access_cmd(tape, PT_REWIND_TMO, rw_cmd, "rewind");
 440 }
 441
 442 static void pt_write_fm(struct pt_unit *tape)
 443 {
 444         char wm_cmd[12] = { ATAPI_WFM, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 };
 445
 446         pt_media_access_cmd(tape, PT_TMO, wm_cmd, "write filemark");
 447 }
 448
 449 #define DBMSG(msg)      ((verbose>1)?(msg):NULL)
 450
 451 static int pt_reset(struct pt_unit *tape)
 452 {
 453         struct pi_adapter *pi = tape->pi;
 454         int i, k, flg;
 455         int expect[5] = { 1, 1, 1, 0x14, 0xeb };
 456
 457         pi_connect(pi);
 458         write_reg(pi, 6, DRIVE(tape));
 459         write_reg(pi, 7, 8);
 460
 461         pt_sleep(20 * HZ / 1000);
 462
 463         k = 0;
 464         while ((k++ < PT_RESET_TMO) && (status_reg(pi) & STAT_BUSY))
 465                 pt_sleep(HZ / 10);
 466
 467         flg = 1;
 468         for (i = 0; i < 5; i++)
 469                 flg &= (read_reg(pi, i + 1) == expect[i]);
 470
 471         if (verbose) {
 472                 printk("%s: Reset (%d) signature = ", tape->name, k);
 473                 for (i = 0; i < 5; i++)
 474                         printk("%3x", read_reg(pi, i + 1));
 475                 if (!flg)
 476                         printk(" (incorrect)");
 477                 printk("\n");
 478         }
 479
 480         pi_disconnect(pi);
 481         return flg - 1;
 482 }
 483
 484 static int pt_ready_wait(struct pt_unit *tape, int tmo)
 485 {
 486         char tr_cmd[12] = { ATAPI_TEST_READY, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 487         int k, p;
 488
 489         k = 0;
 490         while (k < tmo) {
 491                 tape->last_sense = 0;
 492                 pt_atapi(tape, tr_cmd, 0, NULL, DBMSG("test unit ready"));
 493                 p = tape->last_sense;
 494                 if (!p)
 495                         return 0;
 496                 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
 497                         return p;
 498                 k++;
 499                 pt_sleep(HZ);
 500         }
 501         return 0x000020;        /* timeout */
 502 }
 503
 504 static void xs(char *buf, char *targ, int offs, int len)
 505 {
 506         int j, k, l;
 507
 508         j = 0;
 509         l = 0;
 510         for (k = 0; k < len; k++)
 511                 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
 512                         l = targ[j++] = buf[k + offs];
 513         if (l == 0x20)
 514                 j--;
 515         targ[j] = 0;
 516 }
 517
 518 static int xn(char *buf, int offs, int size)
 519 {
 520         int v, k;
 521
 522         v = 0;
 523         for (k = 0; k < size; k++)
 524                 v = v * 256 + (buf[k + offs] & 0xff);
 525         return v;
 526 }
 527
 528 static int pt_identify(struct pt_unit *tape)
 529 {
 530         int dt, s;
 531         char *ms[2] = { "master", "slave" };
 532         char mf[10], id[18];
 533         char id_cmd[12] = { ATAPI_IDENTIFY, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
 534         char ms_cmd[12] =
 535             { ATAPI_MODE_SENSE, 0, 0x2a, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
 536         char ls_cmd[12] =
 537             { ATAPI_LOG_SENSE, 0, 0x71, 0, 0, 0, 0, 0, 36, 0, 0, 0 };
 538         char buf[36];
 539
 540         s = pt_atapi(tape, id_cmd, 36, buf, "identify");
 541         if (s)
 542                 return -1;
 543
 544         dt = buf[0] & 0x1f;
 545         if (dt != 1) {
 546                 if (verbose)
 547                         printk("%s: Drive %d, unsupported type %d\n",
 548                                tape->name, tape->drive, dt);
 549                 return -1;
 550         }
 551
 552         xs(buf, mf, 8, 8);
 553         xs(buf, id, 16, 16);
 554
 555         tape->flags = 0;
 556         tape->capacity = 0;
 557         tape->bs = 0;
 558
 559         if (!pt_ready_wait(tape, PT_READY_TMO))
 560                 tape->flags |= PT_MEDIA;
 561
 562         if (!pt_atapi(tape, ms_cmd, 36, buf, "mode sense")) {
 563                 if (!(buf[2] & 0x80))
 564                         tape->flags |= PT_WRITE_OK;
 565                 tape->bs = xn(buf, 10, 2);
 566         }
 567
 568         if (!pt_atapi(tape, ls_cmd, 36, buf, "log sense"))
 569                 tape->capacity = xn(buf, 24, 4);
 570
 571         printk("%s: %s %s, %s", tape->name, mf, id, ms[tape->drive]);
 572         if (!(tape->flags & PT_MEDIA))
 573                 printk(", no media\n");
 574         else {
 575                 if (!(tape->flags & PT_WRITE_OK))
 576                         printk(", RO");
 577                 printk(", blocksize %d, %d MB\n", tape->bs, tape->capacity / 1024);
 578         }
 579
 580         return 0;
 581 }
 582
 583
 584 /*
 585  * returns  0, with id set if drive is detected
 586  *         -1, if drive detection failed
 587  */
 588 static int pt_probe(struct pt_unit *tape)
 589 {
 590         if (tape->drive == -1) {
 591                 for (tape->drive = 0; tape->drive <= 1; tape->drive++)
 592                         if (!pt_reset(tape))
 593                                 return pt_identify(tape);
 594         } else {
 595                 if (!pt_reset(tape))
 596                         return pt_identify(tape);
 597         }
 598         return -1;
 599 }
 600
 601 static int pt_detect(void)
 602 {
 603         struct pt_unit *tape;
 604         int specified = 0, found = 0;
 605         int unit;
 606
 607         printk("%s: %s version %s, major %d\n", name, name, PT_VERSION, major);
 608
 609         par_drv = pi_register_driver(name);
 610         if (!par_drv) {
 611                 pr_err("failed to register %s driver\n", name);
 612                 return -1;
 613         }
 614
 615         specified = 0;
 616         for (unit = 0; unit < PT_UNITS; unit++) {
 617                 struct pt_unit *tape = &pt[unit];
 618                 tape->pi = &tape->pia;
 619                 atomic_set(&tape->available, 1);
 620                 tape->flags = 0;
 621                 tape->last_sense = 0;
 622                 tape->present = 0;
 623                 tape->bufptr = NULL;
 624                 tape->drive = DU[D_SLV];
 625                 snprintf(tape->name, PT_NAMELEN, "%s%d", name, unit);
 626                 if (!DU[D_PRT])
 627                         continue;
 628                 specified++;
 629                 if (pi_init(tape->pi, 0, DU[D_PRT], DU[D_MOD], DU[D_UNI],
 630                      DU[D_PRO], DU[D_DLY], pt_scratch, PI_PT,
 631                      verbose, tape->name)) {
 632                         if (!pt_probe(tape)) {
 633                                 tape->present = 1;
 634                                 found++;
 635                         } else
 636                                 pi_release(tape->pi);
 637                 }
 638         }
 639         if (specified == 0) {
 640                 tape = pt;
 641                 if (pi_init(tape->pi, 1, -1, -1, -1, -1, -1, pt_scratch,
 642                             PI_PT, verbose, tape->name)) {
 643                         if (!pt_probe(tape)) {
 644                                 tape->present = 1;
 645                                 found++;
 646                         } else
 647                                 pi_release(tape->pi);
 648                 }
 649
 650         }
 651         if (found)
 652                 return 0;
 653
 654         pi_unregister_driver(par_drv);
 655         printk("%s: No ATAPI tape drive detected\n", name);
 656         return -1;
 657 }
 658
 659 static int pt_open(struct inode *inode, struct file *file)
 660 {
 661         int unit = iminor(inode) & 0x7F;
 662         struct pt_unit *tape = pt + unit;
 663         int err;
 664
 665         mutex_lock(&pt_mutex);
 666         if (unit >= PT_UNITS || (!tape->present)) {
 667                 mutex_unlock(&pt_mutex);
 668                 return -ENODEV;
 669         }
 670
 671         err = -EBUSY;
 672         if (!atomic_dec_and_test(&tape->available))
 673                 goto out;
 674
 675         pt_identify(tape);
 676
 677         err = -ENODEV;
 678         if (!(tape->flags & PT_MEDIA))
 679                 goto out;
 680
 681         err = -EROFS;
 682         if ((!(tape->flags & PT_WRITE_OK)) && (file->f_mode & FMODE_WRITE))
 683                 goto out;
 684
 685         if (!(iminor(inode) & 128))
 686                 tape->flags |= PT_REWIND;
 687
 688         err = -ENOMEM;
 689         tape->bufptr = kmalloc(PT_BUFSIZE, GFP_KERNEL);
 690         if (tape->bufptr == NULL) {
 691                 printk("%s: buffer allocation failed\n", tape->name);
 692                 goto out;
 693         }
 694
 695         file->private_data = tape;
 696         mutex_unlock(&pt_mutex);
 697         return 0;
 698
 699 out:
 700         atomic_inc(&tape->available);
 701         mutex_unlock(&pt_mutex);
 702         return err;
 703 }
 704
 705 static long pt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 706 {
 707         struct pt_unit *tape = file->private_data;
 708         struct mtop __user *p = (void __user *)arg;
 709         struct mtop mtop;
 710
 711         switch (cmd) {
 712         case MTIOCTOP:
 713                 if (copy_from_user(&mtop, p, sizeof(struct mtop)))
 714                         return -EFAULT;
 715
 716                 switch (mtop.mt_op) {
 717
 718                 case MTREW:
 719                         mutex_lock(&pt_mutex);
 720                         pt_rewind(tape);
 721                         mutex_unlock(&pt_mutex);
 722                         return 0;
 723
 724                 case MTWEOF:
 725                         mutex_lock(&pt_mutex);
 726                         pt_write_fm(tape);
 727                         mutex_unlock(&pt_mutex);
 728                         return 0;
 729
 730                 default:
 731                         /* FIXME: rate limit ?? */
 732                         printk(KERN_DEBUG "%s: Unimplemented mt_op %d\n", tape->name,
 733                                mtop.mt_op);
 734                         return -EINVAL;
 735                 }
 736
 737         default:
 738                 return -ENOTTY;
 739         }
 740 }
 741
 742 static int
 743 pt_release(struct inode *inode, struct file *file)
 744 {
 745         struct pt_unit *tape = file->private_data;
 746
 747         if (atomic_read(&tape->available) > 1)
 748                 return -EINVAL;
 749
 750         if (tape->flags & PT_WRITING)
 751                 pt_write_fm(tape);
 752
 753         if (tape->flags & PT_REWIND)
 754                 pt_rewind(tape);
 755
 756         kfree(tape->bufptr);
 757         tape->bufptr = NULL;
 758
 759         atomic_inc(&tape->available);
 760
 761         return 0;
 762
 763 }
 764
 765 static ssize_t pt_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
 766 {
 767         struct pt_unit *tape = filp->private_data;
 768         struct pi_adapter *pi = tape->pi;
 769         char rd_cmd[12] = { ATAPI_READ_6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 770         int k, n, r, p, s, t, b;
 771
 772         if (!(tape->flags & (PT_READING | PT_WRITING))) {
 773                 tape->flags |= PT_READING;
 774                 if (pt_atapi(tape, rd_cmd, 0, NULL, "start read-ahead"))
 775                         return -EIO;
 776         } else if (tape->flags & PT_WRITING)
 777                 return -EIO;
 778
 779         if (tape->flags & PT_EOF)
 780                 return 0;
 781
 782         t = 0;
 783
 784         while (count > 0) {
 785
 786                 if (!pt_poll_dsc(tape, HZ / 100, PT_TMO, "read"))
 787                         return -EIO;
 788
 789                 n = count;
 790                 if (n > 32768)
 791                         n = 32768;      /* max per command */
 792                 b = (n - 1 + tape->bs) / tape->bs;
 793                 n = b * tape->bs;       /* rounded up to even block */
 794
 795                 rd_cmd[4] = b;
 796
 797                 r = pt_command(tape, rd_cmd, n, "read");
 798
 799                 mdelay(1);
 800
 801                 if (r) {
 802                         pt_req_sense(tape, 0);
 803                         return -EIO;
 804                 }
 805
 806                 while (1) {
 807
 808                         r = pt_wait(tape, STAT_BUSY,
 809                                     STAT_DRQ | STAT_ERR | STAT_READY,
 810                                     DBMSG("read DRQ"), "");
 811
 812                         if (r & STAT_SENSE) {
 813                                 pi_disconnect(pi);
 814                                 pt_req_sense(tape, 0);
 815                                 return -EIO;
 816                         }
 817
 818                         if (r)
 819                                 tape->flags |= PT_EOF;
 820
 821                         s = read_reg(pi, 7);
 822
 823                         if (!(s & STAT_DRQ))
 824                                 break;
 825
 826                         n = (read_reg(pi, 4) + 256 * read_reg(pi, 5));
 827                         p = (read_reg(pi, 2) & 3);
 828                         if (p != 2) {
 829                                 pi_disconnect(pi);
 830                                 printk("%s: Phase error on read: %d\n", tape->name,
 831                                        p);
 832                                 return -EIO;
 833                         }
 834
 835                         while (n > 0) {
 836                                 k = n;
 837                                 if (k > PT_BUFSIZE)
 838                                         k = PT_BUFSIZE;
 839                                 pi_read_block(pi, tape->bufptr, k);
 840                                 n -= k;
 841                                 b = k;
 842                                 if (b > count)
 843                                         b = count;
 844                                 if (copy_to_user(buf + t, tape->bufptr, b)) {
 845                                         pi_disconnect(pi);
 846                                         return -EFAULT;
 847                                 }
 848                                 t += b;
 849                                 count -= b;
 850                         }
 851
 852                 }
 853                 pi_disconnect(pi);
 854                 if (tape->flags & PT_EOF)
 855                         break;
 856         }
 857
 858         return t;
 859
 860 }
 861
 862 static ssize_t pt_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
 863 {
 864         struct pt_unit *tape = filp->private_data;
 865         struct pi_adapter *pi = tape->pi;
 866         char wr_cmd[12] = { ATAPI_WRITE_6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 867         int k, n, r, p, s, t, b;
 868
 869         if (!(tape->flags & PT_WRITE_OK))
 870                 return -EROFS;
 871
 872         if (!(tape->flags & (PT_READING | PT_WRITING))) {
 873                 tape->flags |= PT_WRITING;
 874                 if (pt_atapi
 875                     (tape, wr_cmd, 0, NULL, "start buffer-available mode"))
 876                         return -EIO;
 877         } else if (tape->flags & PT_READING)
 878                 return -EIO;
 879
 880         if (tape->flags & PT_EOF)
 881                 return -ENOSPC;
 882
 883         t = 0;
 884
 885         while (count > 0) {
 886
 887                 if (!pt_poll_dsc(tape, HZ / 100, PT_TMO, "write"))
 888                         return -EIO;
 889
 890                 n = count;
 891                 if (n > 32768)
 892                         n = 32768;      /* max per command */
 893                 b = (n - 1 + tape->bs) / tape->bs;
 894                 n = b * tape->bs;       /* rounded up to even block */
 895
 896                 wr_cmd[4] = b;
 897
 898                 r = pt_command(tape, wr_cmd, n, "write");
 899
 900                 mdelay(1);
 901
 902                 if (r) {        /* error delivering command only */
 903                         pt_req_sense(tape, 0);
 904                         return -EIO;
 905                 }
 906
 907                 while (1) {
 908
 909                         r = pt_wait(tape, STAT_BUSY,
 910                                     STAT_DRQ | STAT_ERR | STAT_READY,
 911                                     DBMSG("write DRQ"), NULL);
 912
 913                         if (r & STAT_SENSE) {
 914                                 pi_disconnect(pi);
 915                                 pt_req_sense(tape, 0);
 916                                 return -EIO;
 917                         }
 918
 919                         if (r)
 920                                 tape->flags |= PT_EOF;
 921
 922                         s = read_reg(pi, 7);
 923
 924                         if (!(s & STAT_DRQ))
 925                                 break;
 926
 927                         n = (read_reg(pi, 4) + 256 * read_reg(pi, 5));
 928                         p = (read_reg(pi, 2) & 3);
 929                         if (p != 0) {
 930                                 pi_disconnect(pi);
 931                                 printk("%s: Phase error on write: %d \n",
 932                                        tape->name, p);
 933                                 return -EIO;
 934                         }
 935
 936                         while (n > 0) {
 937                                 k = n;
 938                                 if (k > PT_BUFSIZE)
 939                                         k = PT_BUFSIZE;
 940                                 b = k;
 941                                 if (b > count)
 942                                         b = count;
 943                                 if (copy_from_user(tape->bufptr, buf + t, b)) {
 944                                         pi_disconnect(pi);
 945                                         return -EFAULT;
 946                                 }
 947                                 pi_write_block(pi, tape->bufptr, k);
 948                                 t += b;
 949                                 count -= b;
 950                                 n -= k;
 951                         }
 952
 953                 }
 954                 pi_disconnect(pi);
 955                 if (tape->flags & PT_EOF)
 956                         break;
 957         }
 958
 959         return t;
 960 }
 961
 962 static int __init pt_init(void)
 963 {
 964         int unit;
 965         int err;
 966
 967         if (disable) {
 968                 err = -EINVAL;
 969                 goto out;
 970         }
 971
 972         if (pt_detect()) {
 973                 err = -ENODEV;
 974                 goto out;
 975         }
 976
 977         err = register_chrdev(major, name, &pt_fops);
 978         if (err < 0) {
 979                 printk("pt_init: unable to get major number %d\n", major);
 980                 for (unit = 0; unit < PT_UNITS; unit++)
 981                         if (pt[unit].present)
 982                                 pi_release(pt[unit].pi);
 983                 goto out;
 984         }
 985         major = err;
 986         pt_class = class_create(THIS_MODULE, "pt");
 987         if (IS_ERR(pt_class)) {
 988                 err = PTR_ERR(pt_class);
 989                 goto out_chrdev;
 990         }
 991
 992         for (unit = 0; unit < PT_UNITS; unit++)
 993                 if (pt[unit].present) {
 994                         device_create(pt_class, NULL, MKDEV(major, unit), NULL,
 995                                       "pt%d", unit);
 996                         device_create(pt_class, NULL, MKDEV(major, unit + 128),
 997                                       NULL, "pt%dn", unit);
 998                 }
 999         goto out;
1000
1001 out_chrdev:
1002         unregister_chrdev(major, "pt");
1003 out:
1004         return err;
1005 }
1006
1007 static void __exit pt_exit(void)
1008 {
1009         int unit;
1010         for (unit = 0; unit < PT_UNITS; unit++)
1011                 if (pt[unit].present) {
1012                         device_destroy(pt_class, MKDEV(major, unit));
1013                         device_destroy(pt_class, MKDEV(major, unit + 128));
1014                 }
1015         class_destroy(pt_class);
1016         unregister_chrdev(major, name);
1017         for (unit = 0; unit < PT_UNITS; unit++)
1018                 if (pt[unit].present)
1019                         pi_release(pt[unit].pi);
1020 }
1021
1022 MODULE_LICENSE("GPL");
1023 module_init(pt_init)
1024 module_exit(pt_exit)