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 overide 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 /* Here are things one can override from the insmod command.
 113    Most are autoprobed by paride unless set here.  Verbose is on
 114    by default.
 115
 116 */
 117
 118 static int verbose = 0;
 119 static int major = PT_MAJOR;
 120 static char *name = PT_NAME;
 121 static int disable = 0;
 122
 123 static int drive0[6] = { 0, 0, 0, -1, -1, -1 };
 124 static int drive1[6] = { 0, 0, 0, -1, -1, -1 };
 125 static int drive2[6] = { 0, 0, 0, -1, -1, -1 };
 126 static int drive3[6] = { 0, 0, 0, -1, -1, -1 };
 127
 128 static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
 129
 130 #define D_PRT   0
 131 #define D_PRO   1
 132 #define D_UNI   2
 133 #define D_MOD   3
 134 #define D_SLV   4
 135 #define D_DLY   5
 136
 137 #define DU              (*drives[unit])
 138
 139 /* end of parameters */
 140
 141 #include <linux/module.h>
 142 #include <linux/init.h>
 143 #include <linux/fs.h>
 144 #include <linux/devfs_fs_kernel.h>
 145 #include <linux/delay.h>
 146 #include <linux/slab.h>
 147 #include <linux/mtio.h>
 148 #include <linux/device.h>
 149
 150 #include <asm/uaccess.h>
 151
 152 #ifndef MODULE
 153
 154 #include "setup.h"
 155
 156 static STT pt_stt[5] = {
 157         {"drive0", 6, drive0},
 158         {"drive1", 6, drive1},
 159         {"drive2", 6, drive2},
 160         {"drive3", 6, drive3},
 161         {"disable", 1, &disable}
 162 };
 163
 164 void
 165 pt_setup(char *str, int *ints)
 166 {
 167         generic_setup(pt_stt, 5, str);
 168 }
 169
 170 #endif
 171
 172 MODULE_PARM(verbose, "i");
 173 MODULE_PARM(major, "i");
 174 MODULE_PARM(name, "s");
 175 MODULE_PARM(drive0, "1-6i");
 176 MODULE_PARM(drive1, "1-6i");
 177 MODULE_PARM(drive2, "1-6i");
 178 MODULE_PARM(drive3, "1-6i");
 179
 180 #include "paride.h"
 181
 182 #define PT_MAX_RETRIES  5
 183 #define PT_TMO          3000    /* interrupt timeout in jiffies */
 184 #define PT_SPIN_DEL     50      /* spin delay in micro-seconds  */
 185 #define PT_RESET_TMO    30      /* 30 seconds */
 186 #define PT_READY_TMO    60      /* 60 seconds */
 187 #define PT_REWIND_TMO   1200    /* 20 minutes */
 188
 189 #define PT_SPIN         ((1000000/(HZ*PT_SPIN_DEL))*PT_TMO)
 190
 191 #define STAT_ERR        0x00001
 192 #define STAT_INDEX      0x00002
 193 #define STAT_ECC        0x00004
 194 #define STAT_DRQ        0x00008
 195 #define STAT_SEEK       0x00010
 196 #define STAT_WRERR      0x00020
 197 #define STAT_READY      0x00040
 198 #define STAT_BUSY       0x00080
 199 #define STAT_SENSE      0x1f000
 200
 201 #define ATAPI_TEST_READY        0x00
 202 #define ATAPI_REWIND            0x01
 203 #define ATAPI_REQ_SENSE         0x03
 204 #define ATAPI_READ_6            0x08
 205 #define ATAPI_WRITE_6           0x0a
 206 #define ATAPI_WFM               0x10
 207 #define ATAPI_IDENTIFY          0x12
 208 #define ATAPI_MODE_SENSE        0x1a
 209 #define ATAPI_LOG_SENSE         0x4d
 210
 211 static int pt_open(struct inode *inode, struct file *file);
 212 static int pt_ioctl(struct inode *inode, struct file *file,
 213                     unsigned int cmd, unsigned long arg);
 214 static int pt_release(struct inode *inode, struct file *file);
 215 static ssize_t pt_read(struct file *filp, char __user *buf,
 216                        size_t count, loff_t * ppos);
 217 static ssize_t pt_write(struct file *filp, const char __user *buf,
 218                         size_t count, loff_t * ppos);
 219 static int pt_detect(void);
 220
 221 /* bits in tape->flags */
 222
 223 #define PT_MEDIA        1
 224 #define PT_WRITE_OK     2
 225 #define PT_REWIND       4
 226 #define PT_WRITING      8
 227 #define PT_READING     16
 228 #define PT_EOF         32
 229
 230 #define PT_NAMELEN      8
 231 #define PT_BUFSIZE  16384
 232
 233 struct pt_unit {
 234         struct pi_adapter pia;  /* interface to paride layer */
 235         struct pi_adapter *pi;
 236         int flags;              /* various state flags */
 237         int last_sense;         /* result of last request sense */
 238         int drive;              /* drive */
 239         atomic_t available;     /* 1 if access is available 0 otherwise */
 240         int bs;                 /* block size */
 241         int capacity;           /* Size of tape in KB */
 242         int present;            /* device present ? */
 243         char *bufptr;
 244         char name[PT_NAMELEN];  /* pf0, pf1, ... */
 245 };
 246
 247 static int pt_identify(struct pt_unit *tape);
 248
 249 struct pt_unit pt[PT_UNITS];
 250
 251 static char pt_scratch[512];    /* scratch block buffer */
 252
 253 /* kernel glue structures */
 254
 255 static struct file_operations pt_fops = {
 256         .owner = THIS_MODULE,
 257         .read = pt_read,
 258         .write = pt_write,
 259         .ioctl = pt_ioctl,
 260         .open = pt_open,
 261         .release = pt_release,
 262 };
 263
 264 /* sysfs class support */
 265 static struct class_simple *pt_class;
 266
 267 static inline int status_reg(struct pi_adapter *pi)
 268 {
 269         return pi_read_regr(pi, 1, 6);
 270 }
 271
 272 static inline int read_reg(struct pi_adapter *pi, int reg)
 273 {
 274         return pi_read_regr(pi, 0, reg);
 275 }
 276
 277 static inline void write_reg(struct pi_adapter *pi, int reg, int val)
 278 {
 279         pi_write_regr(pi, 0, reg, val);
 280 }
 281
 282 static inline u8 DRIVE(struct pt_unit *tape)
 283 {
 284         return 0xa0+0x10*tape->drive;
 285 }
 286
 287 static int pt_wait(struct pt_unit *tape, int go, int stop, char *fun, char *msg)
 288 {
 289         int j, r, e, s, p;
 290         struct pi_adapter *pi = tape->pi;
 291
 292         j = 0;
 293         while ((((r = status_reg(pi)) & go) || (stop && (!(r & stop))))
 294                && (j++ < PT_SPIN))
 295                 udelay(PT_SPIN_DEL);
 296
 297         if ((r & (STAT_ERR & stop)) || (j >= PT_SPIN)) {
 298                 s = read_reg(pi, 7);
 299                 e = read_reg(pi, 1);
 300                 p = read_reg(pi, 2);
 301                 if (j >= PT_SPIN)
 302                         e |= 0x100;
 303                 if (fun)
 304                         printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
 305                                " loop=%d phase=%d\n",
 306                                tape->name, fun, msg, r, s, e, j, p);
 307                 return (e << 8) + s;
 308         }
 309         return 0;
 310 }
 311
 312 static int pt_command(struct pt_unit *tape, char *cmd, int dlen, char *fun)
 313 {
 314         struct pi_adapter *pi = tape->pi;
 315         pi_connect(pi);
 316
 317         write_reg(pi, 6, DRIVE(tape));
 318
 319         if (pt_wait(tape, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
 320                 pi_disconnect(pi);
 321                 return -1;
 322         }
 323
 324         write_reg(pi, 4, dlen % 256);
 325         write_reg(pi, 5, dlen / 256);
 326         write_reg(pi, 7, 0xa0); /* ATAPI packet command */
 327
 328         if (pt_wait(tape, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
 329                 pi_disconnect(pi);
 330                 return -1;
 331         }
 332
 333         if (read_reg(pi, 2) != 1) {
 334                 printk("%s: %s: command phase error\n", tape->name, fun);
 335                 pi_disconnect(pi);
 336                 return -1;
 337         }
 338
 339         pi_write_block(pi, cmd, 12);
 340
 341         return 0;
 342 }
 343
 344 static int pt_completion(struct pt_unit *tape, char *buf, char *fun)
 345 {
 346         struct pi_adapter *pi = tape->pi;
 347         int r, s, n, p;
 348
 349         r = pt_wait(tape, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
 350                     fun, "completion");
 351
 352         if (read_reg(pi, 7) & STAT_DRQ) {
 353                 n = (((read_reg(pi, 4) + 256 * read_reg(pi, 5)) +
 354                       3) & 0xfffc);
 355                 p = read_reg(pi, 2) & 3;
 356                 if (p == 0)
 357                         pi_write_block(pi, buf, n);
 358                 if (p == 2)
 359                         pi_read_block(pi, buf, n);
 360         }
 361
 362         s = pt_wait(tape, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
 363
 364         pi_disconnect(pi);
 365
 366         return (r ? r : s);
 367 }
 368
 369 static void pt_req_sense(struct pt_unit *tape, int quiet)
 370 {
 371         char rs_cmd[12] = { ATAPI_REQ_SENSE, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
 372         char buf[16];
 373         int r;
 374
 375         r = pt_command(tape, rs_cmd, 16, "Request sense");
 376         mdelay(1);
 377         if (!r)
 378                 pt_completion(tape, buf, "Request sense");
 379
 380         tape->last_sense = -1;
 381         if (!r) {
 382                 if (!quiet)
 383                         printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
 384                                tape->name, buf[2] & 0xf, buf[12], buf[13]);
 385                 tape->last_sense = (buf[2] & 0xf) | ((buf[12] & 0xff) << 8)
 386                     | ((buf[13] & 0xff) << 16);
 387         }
 388 }
 389
 390 static int pt_atapi(struct pt_unit *tape, char *cmd, int dlen, char *buf, char *fun)
 391 {
 392         int r;
 393
 394         r = pt_command(tape, cmd, dlen, fun);
 395         mdelay(1);
 396         if (!r)
 397                 r = pt_completion(tape, buf, fun);
 398         if (r)
 399                 pt_req_sense(tape, !fun);
 400
 401         return r;
 402 }
 403
 404 static void pt_sleep(int cs)
 405 {
 406         current->state = TASK_INTERRUPTIBLE;
 407         schedule_timeout(cs);
 408 }
 409
 410 static int pt_poll_dsc(struct pt_unit *tape, int pause, int tmo, char *msg)
 411 {
 412         struct pi_adapter *pi = tape->pi;
 413         int k, e, s;
 414
 415         k = 0;
 416         e = 0;
 417         s = 0;
 418         while (k < tmo) {
 419                 pt_sleep(pause);
 420                 k++;
 421                 pi_connect(pi);
 422                 write_reg(pi, 6, DRIVE(tape));
 423                 s = read_reg(pi, 7);
 424                 e = read_reg(pi, 1);
 425                 pi_disconnect(pi);
 426                 if (s & (STAT_ERR | STAT_SEEK))
 427                         break;
 428         }
 429         if ((k >= tmo) || (s & STAT_ERR)) {
 430                 if (k >= tmo)
 431                         printk("%s: %s DSC timeout\n", tape->name, msg);
 432                 else
 433                         printk("%s: %s stat=0x%x err=0x%x\n", tape->name, msg, s,
 434                                e);
 435                 pt_req_sense(tape, 0);
 436                 return 0;
 437         }
 438         return 1;
 439 }
 440
 441 static void pt_media_access_cmd(struct pt_unit *tape, int tmo, char *cmd, char *fun)
 442 {
 443         if (pt_command(tape, cmd, 0, fun)) {
 444                 pt_req_sense(tape, 0);
 445                 return;
 446         }
 447         pi_disconnect(tape->pi);
 448         pt_poll_dsc(tape, HZ, tmo, fun);
 449 }
 450
 451 static void pt_rewind(struct pt_unit *tape)
 452 {
 453         char rw_cmd[12] = { ATAPI_REWIND, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 454
 455         pt_media_access_cmd(tape, PT_REWIND_TMO, rw_cmd, "rewind");
 456 }
 457
 458 static void pt_write_fm(struct pt_unit *tape)
 459 {
 460         char wm_cmd[12] = { ATAPI_WFM, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 };
 461
 462         pt_media_access_cmd(tape, PT_TMO, wm_cmd, "write filemark");
 463 }
 464
 465 #define DBMSG(msg)      ((verbose>1)?(msg):NULL)
 466
 467 static int pt_reset(struct pt_unit *tape)
 468 {
 469         struct pi_adapter *pi = tape->pi;
 470         int i, k, flg;
 471         int expect[5] = { 1, 1, 1, 0x14, 0xeb };
 472
 473         pi_connect(pi);
 474         write_reg(pi, 6, DRIVE(tape));
 475         write_reg(pi, 7, 8);
 476
 477         pt_sleep(20 * HZ / 1000);
 478
 479         k = 0;
 480         while ((k++ < PT_RESET_TMO) && (status_reg(pi) & STAT_BUSY))
 481                 pt_sleep(HZ / 10);
 482
 483         flg = 1;
 484         for (i = 0; i < 5; i++)
 485                 flg &= (read_reg(pi, i + 1) == expect[i]);
 486
 487         if (verbose) {
 488                 printk("%s: Reset (%d) signature = ", tape->name, k);
 489                 for (i = 0; i < 5; i++)
 490                         printk("%3x", read_reg(pi, i + 1));
 491                 if (!flg)
 492                         printk(" (incorrect)");
 493                 printk("\n");
 494         }
 495
 496         pi_disconnect(pi);
 497         return flg - 1;
 498 }
 499
 500 static int pt_ready_wait(struct pt_unit *tape, int tmo)
 501 {
 502         char tr_cmd[12] = { ATAPI_TEST_READY, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 503         int k, p;
 504
 505         k = 0;
 506         while (k < tmo) {
 507                 tape->last_sense = 0;
 508                 pt_atapi(tape, tr_cmd, 0, NULL, DBMSG("test unit ready"));
 509                 p = tape->last_sense;
 510                 if (!p)
 511                         return 0;
 512                 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
 513                         return p;
 514                 k++;
 515                 pt_sleep(HZ);
 516         }
 517         return 0x000020;        /* timeout */
 518 }
 519
 520 static void xs(char *buf, char *targ, int offs, int len)
 521 {
 522         int j, k, l;
 523
 524         j = 0;
 525         l = 0;
 526         for (k = 0; k < len; k++)
 527                 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
 528                         l = targ[j++] = buf[k + offs];
 529         if (l == 0x20)
 530                 j--;
 531         targ[j] = 0;
 532 }
 533
 534 static int xn(char *buf, int offs, int size)
 535 {
 536         int v, k;
 537
 538         v = 0;
 539         for (k = 0; k < size; k++)
 540                 v = v * 256 + (buf[k + offs] & 0xff);
 541         return v;
 542 }
 543
 544 static int pt_identify(struct pt_unit *tape)
 545 {
 546         int dt, s;
 547         char *ms[2] = { "master", "slave" };
 548         char mf[10], id[18];
 549         char id_cmd[12] = { ATAPI_IDENTIFY, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
 550         char ms_cmd[12] =
 551             { ATAPI_MODE_SENSE, 0, 0x2a, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
 552         char ls_cmd[12] =
 553             { ATAPI_LOG_SENSE, 0, 0x71, 0, 0, 0, 0, 0, 36, 0, 0, 0 };
 554         char buf[36];
 555
 556         s = pt_atapi(tape, id_cmd, 36, buf, "identify");
 557         if (s)
 558                 return -1;
 559
 560         dt = buf[0] & 0x1f;
 561         if (dt != 1) {
 562                 if (verbose)
 563                         printk("%s: Drive %d, unsupported type %d\n",
 564                                tape->name, tape->drive, dt);
 565                 return -1;
 566         }
 567
 568         xs(buf, mf, 8, 8);
 569         xs(buf, id, 16, 16);
 570
 571         tape->flags = 0;
 572         tape->capacity = 0;
 573         tape->bs = 0;
 574
 575         if (!pt_ready_wait(tape, PT_READY_TMO))
 576                 tape->flags |= PT_MEDIA;
 577
 578         if (!pt_atapi(tape, ms_cmd, 36, buf, "mode sense")) {
 579                 if (!(buf[2] & 0x80))
 580                         tape->flags |= PT_WRITE_OK;
 581                 tape->bs = xn(buf, 10, 2);
 582         }
 583
 584         if (!pt_atapi(tape, ls_cmd, 36, buf, "log sense"))
 585                 tape->capacity = xn(buf, 24, 4);
 586
 587         printk("%s: %s %s, %s", tape->name, mf, id, ms[tape->drive]);
 588         if (!(tape->flags & PT_MEDIA))
 589                 printk(", no media\n");
 590         else {
 591                 if (!(tape->flags & PT_WRITE_OK))
 592                         printk(", RO");
 593                 printk(", blocksize %d, %d MB\n", tape->bs, tape->capacity / 1024);
 594         }
 595
 596         return 0;
 597 }
 598
 599
 600 /*
 601  * returns  0, with id set if drive is detected
 602  *         -1, if drive detection failed
 603  */
 604 static int pt_probe(struct pt_unit *tape)
 605 {
 606         if (tape->drive == -1) {
 607                 for (tape->drive = 0; tape->drive <= 1; tape->drive++)
 608                         if (!pt_reset(tape))
 609                                 return pt_identify(tape);
 610         } else {
 611                 if (!pt_reset(tape))
 612                         return pt_identify(tape);
 613         }
 614         return -1;
 615 }
 616
 617 static int pt_detect(void)
 618 {
 619         struct pt_unit *tape;
 620         int specified = 0, found = 0;
 621         int unit;
 622
 623         printk("%s: %s version %s, major %d\n", name, name, PT_VERSION, major);
 624
 625         specified = 0;
 626         for (unit = 0; unit < PT_UNITS; unit++) {
 627                 struct pt_unit *tape = &pt[unit];
 628                 tape->pi = &tape->pia;
 629                 atomic_set(&tape->available, 1);
 630                 tape->flags = 0;
 631                 tape->last_sense = 0;
 632                 tape->present = 0;
 633                 tape->bufptr = NULL;
 634                 tape->drive = DU[D_SLV];
 635                 snprintf(tape->name, PT_NAMELEN, "%s%d", name, unit);
 636                 if (!DU[D_PRT])
 637                         continue;
 638                 specified++;
 639                 if (pi_init(tape->pi, 0, DU[D_PRT], DU[D_MOD], DU[D_UNI],
 640                      DU[D_PRO], DU[D_DLY], pt_scratch, PI_PT,
 641                      verbose, tape->name)) {
 642                         if (!pt_probe(tape)) {
 643                                 tape->present = 1;
 644                                 found++;
 645                         } else
 646                                 pi_release(tape->pi);
 647                 }
 648         }
 649         if (specified == 0) {
 650                 tape = pt;
 651                 if (pi_init(tape->pi, 1, -1, -1, -1, -1, -1, pt_scratch,
 652                             PI_PT, verbose, tape->name)) {
 653                         if (!pt_probe(tape)) {
 654                                 tape->present = 1;
 655                                 found++;
 656                         } else
 657                                 pi_release(tape->pi);
 658                 }
 659
 660         }
 661         if (found)
 662                 return 0;
 663
 664         printk("%s: No ATAPI tape drive detected\n", name);
 665         return -1;
 666 }
 667
 668 static int pt_open(struct inode *inode, struct file *file)
 669 {
 670         int unit = iminor(inode) & 0x7F;
 671         struct pt_unit *tape = pt + unit;
 672         int err;
 673
 674         if (unit >= PT_UNITS || (!tape->present))
 675                 return -ENODEV;
 676
 677         err = -EBUSY;
 678         if (!atomic_dec_and_test(&tape->available))
 679                 goto out;
 680
 681         pt_identify(tape);
 682
 683         err = -ENODEV;
 684         if (!tape->flags & PT_MEDIA)
 685                 goto out;
 686
 687         err = -EROFS;
 688         if ((!tape->flags & PT_WRITE_OK) && (file->f_mode & 2))
 689                 goto out;
 690
 691         if (!(iminor(inode) & 128))
 692                 tape->flags |= PT_REWIND;
 693
 694         err = -ENOMEM;
 695         tape->bufptr = kmalloc(PT_BUFSIZE, GFP_KERNEL);
 696         if (tape->bufptr == NULL) {
 697                 printk("%s: buffer allocation failed\n", tape->name);
 698                 goto out;
 699         }
 700
 701         file->private_data = tape;
 702         return 0;
 703
 704 out:
 705         atomic_inc(&tape->available);
 706         return err;
 707 }
 708
 709 static int pt_ioctl(struct inode *inode, struct file *file,
 710          unsigned int cmd, unsigned long arg)
 711 {
 712         struct pt_unit *tape = file->private_data;
 713         struct mtop __user *p = (void __user *)arg;
 714         struct mtop mtop;
 715
 716         switch (cmd) {
 717         case MTIOCTOP:
 718                 if (copy_from_user(&mtop, p, sizeof(struct mtop)))
 719                         return -EFAULT;
 720
 721                 switch (mtop.mt_op) {
 722
 723                 case MTREW:
 724                         pt_rewind(tape);
 725                         return 0;
 726
 727                 case MTWEOF:
 728                         pt_write_fm(tape);
 729                         return 0;
 730
 731                 default:
 732                         printk("%s: Unimplemented mt_op %d\n", tape->name,
 733                                mtop.mt_op);
 734                         return -EINVAL;
 735                 }
 736
 737         default:
 738                 printk("%s: Unimplemented ioctl 0x%x\n", tape->name, cmd);
 739                 return -EINVAL;
 740
 741         }
 742 }
 743
 744 static int
 745 pt_release(struct inode *inode, struct file *file)
 746 {
 747         struct pt_unit *tape = file->private_data;
 748
 749         if (atomic_read(&tape->available) > 1)
 750                 return -EINVAL;
 751
 752         if (tape->flags & PT_WRITING)
 753                 pt_write_fm(tape);
 754
 755         if (tape->flags & PT_REWIND)
 756                 pt_rewind(tape);
 757
 758         kfree(tape->bufptr);
 759         tape->bufptr = NULL;
 760
 761         atomic_inc(&tape->available);
 762
 763         return 0;
 764
 765 }
 766
 767 static ssize_t pt_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
 768 {
 769         struct pt_unit *tape = filp->private_data;
 770         struct pi_adapter *pi = tape->pi;
 771         char rd_cmd[12] = { ATAPI_READ_6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 772         int k, n, r, p, s, t, b;
 773
 774         if (!(tape->flags & (PT_READING | PT_WRITING))) {
 775                 tape->flags |= PT_READING;
 776                 if (pt_atapi(tape, rd_cmd, 0, NULL, "start read-ahead"))
 777                         return -EIO;
 778         } else if (tape->flags & PT_WRITING)
 779                 return -EIO;
 780
 781         if (tape->flags & PT_EOF)
 782                 return 0;
 783
 784         t = 0;
 785
 786         while (count > 0) {
 787
 788                 if (!pt_poll_dsc(tape, HZ / 100, PT_TMO, "read"))
 789                         return -EIO;
 790
 791                 n = count;
 792                 if (n > 32768)
 793                         n = 32768;      /* max per command */
 794                 b = (n - 1 + tape->bs) / tape->bs;
 795                 n = b * tape->bs;       /* rounded up to even block */
 796
 797                 rd_cmd[4] = b;
 798
 799                 r = pt_command(tape, rd_cmd, n, "read");
 800
 801                 mdelay(1);
 802
 803                 if (r) {
 804                         pt_req_sense(tape, 0);
 805                         return -EIO;
 806                 }
 807
 808                 while (1) {
 809
 810                         r = pt_wait(tape, STAT_BUSY,
 811                                     STAT_DRQ | STAT_ERR | STAT_READY,
 812                                     DBMSG("read DRQ"), "");
 813
 814                         if (r & STAT_SENSE) {
 815                                 pi_disconnect(pi);
 816                                 pt_req_sense(tape, 0);
 817                                 return -EIO;
 818                         }
 819
 820                         if (r)
 821                                 tape->flags |= PT_EOF;
 822
 823                         s = read_reg(pi, 7);
 824
 825                         if (!(s & STAT_DRQ))
 826                                 break;
 827
 828                         n = (read_reg(pi, 4) + 256 * read_reg(pi, 5));
 829                         p = (read_reg(pi, 2) & 3);
 830                         if (p != 2) {
 831                                 pi_disconnect(pi);
 832                                 printk("%s: Phase error on read: %d\n", tape->name,
 833                                        p);
 834                                 return -EIO;
 835                         }
 836
 837                         while (n > 0) {
 838                                 k = n;
 839                                 if (k > PT_BUFSIZE)
 840                                         k = PT_BUFSIZE;
 841                                 pi_read_block(pi, tape->bufptr, k);
 842                                 n -= k;
 843                                 b = k;
 844                                 if (b > count)
 845                                         b = count;
 846                                 if (copy_to_user(buf + t, tape->bufptr, b)) {
 847                                         pi_disconnect(pi);
 848                                         return -EFAULT;
 849                                 }
 850                                 t += b;
 851                                 count -= b;
 852                         }
 853
 854                 }
 855                 pi_disconnect(pi);
 856                 if (tape->flags & PT_EOF)
 857                         break;
 858         }
 859
 860         return t;
 861
 862 }
 863
 864 static ssize_t pt_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
 865 {
 866         struct pt_unit *tape = filp->private_data;
 867         struct pi_adapter *pi = tape->pi;
 868         char wr_cmd[12] = { ATAPI_WRITE_6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 869         int k, n, r, p, s, t, b;
 870
 871         if (!(tape->flags & PT_WRITE_OK))
 872                 return -EROFS;
 873
 874         if (!(tape->flags & (PT_READING | PT_WRITING))) {
 875                 tape->flags |= PT_WRITING;
 876                 if (pt_atapi
 877                     (tape, wr_cmd, 0, NULL, "start buffer-available mode"))
 878                         return -EIO;
 879         } else if (tape->flags & PT_READING)
 880                 return -EIO;
 881
 882         if (tape->flags & PT_EOF)
 883                 return -ENOSPC;
 884
 885         t = 0;
 886
 887         while (count > 0) {
 888
 889                 if (!pt_poll_dsc(tape, HZ / 100, PT_TMO, "write"))
 890                         return -EIO;
 891
 892                 n = count;
 893                 if (n > 32768)
 894                         n = 32768;      /* max per command */
 895                 b = (n - 1 + tape->bs) / tape->bs;
 896                 n = b * tape->bs;       /* rounded up to even block */
 897
 898                 wr_cmd[4] = b;
 899
 900                 r = pt_command(tape, wr_cmd, n, "write");
 901
 902                 mdelay(1);
 903
 904                 if (r) {        /* error delivering command only */
 905                         pt_req_sense(tape, 0);
 906                         return -EIO;
 907                 }
 908
 909                 while (1) {
 910
 911                         r = pt_wait(tape, STAT_BUSY,
 912                                     STAT_DRQ | STAT_ERR | STAT_READY,
 913                                     DBMSG("write DRQ"), NULL);
 914
 915                         if (r & STAT_SENSE) {
 916                                 pi_disconnect(pi);
 917                                 pt_req_sense(tape, 0);
 918                                 return -EIO;
 919                         }
 920
 921                         if (r)
 922                                 tape->flags |= PT_EOF;
 923
 924                         s = read_reg(pi, 7);
 925
 926                         if (!(s & STAT_DRQ))
 927                                 break;
 928
 929                         n = (read_reg(pi, 4) + 256 * read_reg(pi, 5));
 930                         p = (read_reg(pi, 2) & 3);
 931                         if (p != 0) {
 932                                 pi_disconnect(pi);
 933                                 printk("%s: Phase error on write: %d \n",
 934                                        tape->name, p);
 935                                 return -EIO;
 936                         }
 937
 938                         while (n > 0) {
 939                                 k = n;
 940                                 if (k > PT_BUFSIZE)
 941                                         k = PT_BUFSIZE;
 942                                 b = k;
 943                                 if (b > count)
 944                                         b = count;
 945                                 if (copy_from_user(tape->bufptr, buf + t, b)) {
 946                                         pi_disconnect(pi);
 947                                         return -EFAULT;
 948                                 }
 949                                 pi_write_block(pi, tape->bufptr, k);
 950                                 t += b;
 951                                 count -= b;
 952                                 n -= k;
 953                         }
 954
 955                 }
 956                 pi_disconnect(pi);
 957                 if (tape->flags & PT_EOF)
 958                         break;
 959         }
 960
 961         return t;
 962 }
 963
 964 static int __init pt_init(void)
 965 {
 966         int unit, err = 0;
 967
 968         if (disable) {
 969                 err = -1;
 970                 goto out;
 971         }
 972
 973         if (pt_detect()) {
 974                 err = -1;
 975                 goto out;
 976         }
 977
 978         if (register_chrdev(major, name, &pt_fops)) {
 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                 err = -1;
 984                 goto out;
 985         }
 986         pt_class = class_simple_create(THIS_MODULE, "pt");
 987         if (IS_ERR(pt_class)) {
 988                 err = PTR_ERR(pt_class);
 989                 goto out_chrdev;
 990         }
 991
 992         devfs_mk_dir("pt");
 993         for (unit = 0; unit < PT_UNITS; unit++)
 994                 if (pt[unit].present) {
 995                         class_simple_device_add(pt_class, MKDEV(major, unit),
 996                                         NULL, "pt%d", unit);
 997                         err = devfs_mk_cdev(MKDEV(major, unit),
 998                                       S_IFCHR | S_IRUSR | S_IWUSR,
 999                                       "pt/%d", unit);
1000                         if (err) {
1001                                 class_simple_device_remove(MKDEV(major, unit));
1002                                 goto out_class;
1003                         }
1004                         class_simple_device_add(pt_class, MKDEV(major, unit + 128),
1005                                         NULL, "pt%dn", unit);
1006                         err = devfs_mk_cdev(MKDEV(major, unit + 128),
1007                                       S_IFCHR | S_IRUSR | S_IWUSR,
1008                                       "pt/%dn", unit);
1009                         if (err) {
1010                                 class_simple_device_remove(MKDEV(major, unit + 128));
1011                                 goto out_class;
1012                         }
1013                 }
1014         goto out;
1015
1016 out_class:
1017         class_simple_destroy(pt_class);
1018 out_chrdev:
1019         unregister_chrdev(major, "pt");
1020 out:
1021         return err;
1022 }
1023
1024 static void __exit pt_exit(void)
1025 {
1026         int unit;
1027         for (unit = 0; unit < PT_UNITS; unit++)
1028                 if (pt[unit].present) {
1029                         class_simple_device_remove(MKDEV(major, unit));
1030                         devfs_remove("pt/%d", unit);
1031                         class_simple_device_remove(MKDEV(major, unit + 128));
1032                         devfs_remove("pt/%dn", unit);
1033                 }
1034         class_simple_destroy(pt_class);
1035         devfs_remove("pt");
1036         unregister_chrdev(major, name);
1037         for (unit = 0; unit < PT_UNITS; unit++)
1038                 if (pt[unit].present)
1039                         pi_release(pt[unit].pi);
1040 }
1041
1042 MODULE_LICENSE("GPL");
1043 module_init(pt_init)
1044 module_exit(pt_exit)