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