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