drivers/block/paride/pt.c

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

DEFINITIONS
