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