drivers/char/viotape.c

   1 /* -*- linux-c -*-
   2  *  drivers/char/viotape.c
   3  *
   4  *  iSeries Virtual Tape
   5  *
   6  *  Authors: Dave Boutcher <boutcher@us.ibm.com>
   7  *           Ryan Arnold <ryanarn@us.ibm.com>
   8  *           Colin Devilbiss <devilbis@us.ibm.com>
   9  *           Stephen Rothwell
  10  *
  11  * (C) Copyright 2000-2004 IBM Corporation
  12  *
  13  * This program is free software;  you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License as
  15  * published by the Free Software Foundation; either version 2 of the
  16  * License, or (at your option) anyu later version.
  17  *
  18  * This program is distributed in the hope that it will be useful, but
  19  * WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software Foundation,
  25  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  26  *
  27  * This routine provides access to tape drives owned and managed by an OS/400
  28  * partition running on the same box as this Linux partition.
  29  *
  30  * All tape operations are performed by sending messages back and forth to
  31  * the OS/400 partition.  The format of the messages is defined in
  32  * iseries/vio.h
  33  */
  34 #include <linux/module.h>
  35 #include <linux/kernel.h>
  36 #include <linux/errno.h>
  37 #include <linux/init.h>
  38 #include <linux/wait.h>
  39 #include <linux/spinlock.h>
  40 #include <linux/mtio.h>
  41 #include <linux/device.h>
  42 #include <linux/dma-mapping.h>
  43 #include <linux/fs.h>
  44 #include <linux/cdev.h>
  45 #include <linux/major.h>
  46 #include <linux/completion.h>
  47 #include <linux/proc_fs.h>
  48 #include <linux/seq_file.h>
  49
  50 #include <asm/uaccess.h>
  51 #include <asm/ioctls.h>
  52 #include <asm/firmware.h>
  53 #include <asm/vio.h>
  54 #include <asm/iseries/vio.h>
  55 #include <asm/iseries/hv_lp_event.h>
  56 #include <asm/iseries/hv_call_event.h>
  57 #include <asm/iseries/hv_lp_config.h>
  58
  59 #define VIOTAPE_VERSION         "1.2"
  60 #define VIOTAPE_MAXREQ          1
  61
  62 #define VIOTAPE_KERN_WARN       KERN_WARNING "viotape: "
  63 #define VIOTAPE_KERN_INFO       KERN_INFO "viotape: "
  64
  65 static int viotape_numdev;
  66
  67 /*
  68  * The minor number follows the conventions of the SCSI tape drives.  The
  69  * rewind and mode are encoded in the minor #.  We use this struct to break
  70  * them out
  71  */
  72 struct viot_devinfo_struct {
  73         int devno;
  74         int mode;
  75         int rewind;
  76 };
  77
  78 #define VIOTAPOP_RESET          0
  79 #define VIOTAPOP_FSF            1
  80 #define VIOTAPOP_BSF            2
  81 #define VIOTAPOP_FSR            3
  82 #define VIOTAPOP_BSR            4
  83 #define VIOTAPOP_WEOF           5
  84 #define VIOTAPOP_REW            6
  85 #define VIOTAPOP_NOP            7
  86 #define VIOTAPOP_EOM            8
  87 #define VIOTAPOP_ERASE          9
  88 #define VIOTAPOP_SETBLK        10
  89 #define VIOTAPOP_SETDENSITY    11
  90 #define VIOTAPOP_SETPOS        12
  91 #define VIOTAPOP_GETPOS        13
  92 #define VIOTAPOP_SETPART       14
  93 #define VIOTAPOP_UNLOAD        15
  94
  95 enum viotaperc {
  96         viotape_InvalidRange = 0x0601,
  97         viotape_InvalidToken = 0x0602,
  98         viotape_DMAError = 0x0603,
  99         viotape_UseError = 0x0604,
 100         viotape_ReleaseError = 0x0605,
 101         viotape_InvalidTape = 0x0606,
 102         viotape_InvalidOp = 0x0607,
 103         viotape_TapeErr = 0x0608,
 104
 105         viotape_AllocTimedOut = 0x0640,
 106         viotape_BOTEnc = 0x0641,
 107         viotape_BlankTape = 0x0642,
 108         viotape_BufferEmpty = 0x0643,
 109         viotape_CleanCartFound = 0x0644,
 110         viotape_CmdNotAllowed = 0x0645,
 111         viotape_CmdNotSupported = 0x0646,
 112         viotape_DataCheck = 0x0647,
 113         viotape_DecompressErr = 0x0648,
 114         viotape_DeviceTimeout = 0x0649,
 115         viotape_DeviceUnavail = 0x064a,
 116         viotape_DeviceBusy = 0x064b,
 117         viotape_EndOfMedia = 0x064c,
 118         viotape_EndOfTape = 0x064d,
 119         viotape_EquipCheck = 0x064e,
 120         viotape_InsufficientRs = 0x064f,
 121         viotape_InvalidLogBlk = 0x0650,
 122         viotape_LengthError = 0x0651,
 123         viotape_LibDoorOpen = 0x0652,
 124         viotape_LoadFailure = 0x0653,
 125         viotape_NotCapable = 0x0654,
 126         viotape_NotOperational = 0x0655,
 127         viotape_NotReady = 0x0656,
 128         viotape_OpCancelled = 0x0657,
 129         viotape_PhyLinkErr = 0x0658,
 130         viotape_RdyNotBOT = 0x0659,
 131         viotape_TapeMark = 0x065a,
 132         viotape_WriteProt = 0x065b
 133 };
 134
 135 static const struct vio_error_entry viotape_err_table[] = {
 136         { viotape_InvalidRange, EIO, "Internal error" },
 137         { viotape_InvalidToken, EIO, "Internal error" },
 138         { viotape_DMAError, EIO, "DMA error" },
 139         { viotape_UseError, EIO, "Internal error" },
 140         { viotape_ReleaseError, EIO, "Internal error" },
 141         { viotape_InvalidTape, EIO, "Invalid tape device" },
 142         { viotape_InvalidOp, EIO, "Invalid operation" },
 143         { viotape_TapeErr, EIO, "Tape error" },
 144         { viotape_AllocTimedOut, EBUSY, "Allocate timed out" },
 145         { viotape_BOTEnc, EIO, "Beginning of tape encountered" },
 146         { viotape_BlankTape, EIO, "Blank tape" },
 147         { viotape_BufferEmpty, EIO, "Buffer empty" },
 148         { viotape_CleanCartFound, ENOMEDIUM, "Cleaning cartridge found" },
 149         { viotape_CmdNotAllowed, EIO, "Command not allowed" },
 150         { viotape_CmdNotSupported, EIO, "Command not supported" },
 151         { viotape_DataCheck, EIO, "Data check" },
 152         { viotape_DecompressErr, EIO, "Decompression error" },
 153         { viotape_DeviceTimeout, EBUSY, "Device timeout" },
 154         { viotape_DeviceUnavail, EIO, "Device unavailable" },
 155         { viotape_DeviceBusy, EBUSY, "Device busy" },
 156         { viotape_EndOfMedia, ENOSPC, "End of media" },
 157         { viotape_EndOfTape, ENOSPC, "End of tape" },
 158         { viotape_EquipCheck, EIO, "Equipment check" },
 159         { viotape_InsufficientRs, EOVERFLOW, "Insufficient tape resources" },
 160         { viotape_InvalidLogBlk, EIO, "Invalid logical block location" },
 161         { viotape_LengthError, EOVERFLOW, "Length error" },
 162         { viotape_LibDoorOpen, EBUSY, "Door open" },
 163         { viotape_LoadFailure, ENOMEDIUM, "Load failure" },
 164         { viotape_NotCapable, EIO, "Not capable" },
 165         { viotape_NotOperational, EIO, "Not operational" },
 166         { viotape_NotReady, EIO, "Not ready" },
 167         { viotape_OpCancelled, EIO, "Operation cancelled" },
 168         { viotape_PhyLinkErr, EIO, "Physical link error" },
 169         { viotape_RdyNotBOT, EIO, "Ready but not beginning of tape" },
 170         { viotape_TapeMark, EIO, "Tape mark" },
 171         { viotape_WriteProt, EROFS, "Write protection error" },
 172         { 0, 0, NULL },
 173 };
 174
 175 /* Maximum number of tapes we support */
 176 #define VIOTAPE_MAX_TAPE        HVMAXARCHITECTEDVIRTUALTAPES
 177 #define MAX_PARTITIONS          4
 178
 179 /* defines for current tape state */
 180 #define VIOT_IDLE               0
 181 #define VIOT_READING            1
 182 #define VIOT_WRITING            2
 183
 184 /* Our info on the tapes */
 185 static struct {
 186         const char *rsrcname;
 187         const char *type;
 188         const char *model;
 189 } viotape_unitinfo[VIOTAPE_MAX_TAPE];
 190
 191 static struct mtget viomtget[VIOTAPE_MAX_TAPE];
 192
 193 static struct class *tape_class;
 194
 195 static struct device *tape_device[VIOTAPE_MAX_TAPE];
 196
 197 /*
 198  * maintain the current state of each tape (and partition)
 199  * so that we know when to write EOF marks.
 200  */
 201 static struct {
 202         unsigned char   cur_part;
 203         unsigned char   part_stat_rwi[MAX_PARTITIONS];
 204 } state[VIOTAPE_MAX_TAPE];
 205
 206 /* We single-thread */
 207 static struct semaphore reqSem;
 208
 209 /*
 210  * When we send a request, we use this struct to get the response back
 211  * from the interrupt handler
 212  */
 213 struct op_struct {
 214         void                    *buffer;
 215         dma_addr_t              dmaaddr;
 216         size_t                  count;
 217         int                     rc;
 218         int                     non_blocking;
 219         struct completion       com;
 220         struct device           *dev;
 221         struct op_struct        *next;
 222 };
 223
 224 static spinlock_t       op_struct_list_lock;
 225 static struct op_struct *op_struct_list;
 226
 227 /* forward declaration to resolve interdependence */
 228 static int chg_state(int index, unsigned char new_state, struct file *file);
 229
 230 /* procfs support */
 231 static int proc_viotape_show(struct seq_file *m, void *v)
 232 {
 233         int i;
 234
 235         seq_printf(m, "viotape driver version " VIOTAPE_VERSION "\n");
 236         for (i = 0; i < viotape_numdev; i++) {
 237                 seq_printf(m, "viotape device %d is iSeries resource %10.10s"
 238                                 "type %4.4s, model %3.3s\n",
 239                                 i, viotape_unitinfo[i].rsrcname,
 240                                 viotape_unitinfo[i].type,
 241                                 viotape_unitinfo[i].model);
 242         }
 243         return 0;
 244 }
 245
 246 static int proc_viotape_open(struct inode *inode, struct file *file)
 247 {
 248         return single_open(file, proc_viotape_show, NULL);
 249 }
 250
 251 static const struct file_operations proc_viotape_operations = {
 252         .owner          = THIS_MODULE,
 253         .open           = proc_viotape_open,
 254         .read           = seq_read,
 255         .llseek         = seq_lseek,
 256         .release        = single_release,
 257 };
 258
 259 /* Decode the device minor number into its parts */
 260 void get_dev_info(struct inode *ino, struct viot_devinfo_struct *devi)
 261 {
 262         devi->devno = iminor(ino) & 0x1F;
 263         devi->mode = (iminor(ino) & 0x60) >> 5;
 264         /* if bit is set in the minor, do _not_ rewind automatically */
 265         devi->rewind = (iminor(ino) & 0x80) == 0;
 266 }
 267
 268 /* This is called only from the exit and init paths, so no need for locking */
 269 static void clear_op_struct_pool(void)
 270 {
 271         while (op_struct_list) {
 272                 struct op_struct *toFree = op_struct_list;
 273                 op_struct_list = op_struct_list->next;
 274                 kfree(toFree);
 275         }
 276 }
 277
 278 /* Likewise, this is only called from the init path */
 279 static int add_op_structs(int structs)
 280 {
 281         int i;
 282
 283         for (i = 0; i < structs; ++i) {
 284                 struct op_struct *new_struct =
 285                         kmalloc(sizeof(*new_struct), GFP_KERNEL);
 286                 if (!new_struct) {
 287                         clear_op_struct_pool();
 288                         return -ENOMEM;
 289                 }
 290                 new_struct->next = op_struct_list;
 291                 op_struct_list = new_struct;
 292         }
 293         return 0;
 294 }
 295
 296 /* Allocate an op structure from our pool */
 297 static struct op_struct *get_op_struct(void)
 298 {
 299         struct op_struct *retval;
 300         unsigned long flags;
 301
 302         spin_lock_irqsave(&op_struct_list_lock, flags);
 303         retval = op_struct_list;
 304         if (retval)
 305                 op_struct_list = retval->next;
 306         spin_unlock_irqrestore(&op_struct_list_lock, flags);
 307         if (retval) {
 308                 memset(retval, 0, sizeof(*retval));
 309                 init_completion(&retval->com);
 310         }
 311
 312         return retval;
 313 }
 314
 315 /* Return an op structure to our pool */
 316 static void free_op_struct(struct op_struct *op_struct)
 317 {
 318         unsigned long flags;
 319
 320         spin_lock_irqsave(&op_struct_list_lock, flags);
 321         op_struct->next = op_struct_list;
 322         op_struct_list = op_struct;
 323         spin_unlock_irqrestore(&op_struct_list_lock, flags);
 324 }
 325
 326 /* Map our tape return codes to errno values */
 327 int tape_rc_to_errno(int tape_rc, char *operation, int tapeno)
 328 {
 329         const struct vio_error_entry *err;
 330
 331         if (tape_rc == 0)
 332                 return 0;
 333
 334         err = vio_lookup_rc(viotape_err_table, tape_rc);
 335         printk(VIOTAPE_KERN_WARN "error(%s) 0x%04x on Device %d (%-10s): %s\n",
 336                         operation, tape_rc, tapeno,
 337                         viotape_unitinfo[tapeno].rsrcname, err->msg);
 338         return -err->errno;
 339 }
 340
 341 /* Write */
 342 static ssize_t viotap_write(struct file *file, const char *buf,
 343                 size_t count, loff_t * ppos)
 344 {
 345         HvLpEvent_Rc hvrc;
 346         unsigned short flags = file->f_flags;
 347         int noblock = ((flags & O_NONBLOCK) != 0);
 348         ssize_t ret;
 349         struct viot_devinfo_struct devi;
 350         struct op_struct *op = get_op_struct();
 351
 352         if (op == NULL)
 353                 return -ENOMEM;
 354
 355         get_dev_info(file->f_path.dentry->d_inode, &devi);
 356
 357         /*
 358          * We need to make sure we can send a request.  We use
 359          * a semaphore to keep track of # requests in use.  If
 360          * we are non-blocking, make sure we don't block on the
 361          * semaphore
 362          */
 363         if (noblock) {
 364                 if (down_trylock(&reqSem)) {
 365                         ret = -EWOULDBLOCK;
 366                         goto free_op;
 367                 }
 368         } else
 369                 down(&reqSem);
 370
 371         /* Allocate a DMA buffer */
 372         op->dev = tape_device[devi.devno];
 373         op->buffer = dma_alloc_coherent(op->dev, count, &op->dmaaddr,
 374                         GFP_ATOMIC);
 375
 376         if (op->buffer == NULL) {
 377                 printk(VIOTAPE_KERN_WARN
 378                                 "error allocating dma buffer for len %ld\n",
 379                                 count);
 380                 ret = -EFAULT;
 381                 goto up_sem;
 382         }
 383
 384         /* Copy the data into the buffer */
 385         if (copy_from_user(op->buffer, buf, count)) {
 386                 printk(VIOTAPE_KERN_WARN "tape: error on copy from user\n");
 387                 ret = -EFAULT;
 388                 goto free_dma;
 389         }
 390
 391         op->non_blocking = noblock;
 392         init_completion(&op->com);
 393         op->count = count;
 394
 395         hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
 396                         HvLpEvent_Type_VirtualIo,
 397                         viomajorsubtype_tape | viotapewrite,
 398                         HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
 399                         viopath_sourceinst(viopath_hostLp),
 400                         viopath_targetinst(viopath_hostLp),
 401                         (u64)(unsigned long)op, VIOVERSION << 16,
 402                         ((u64)devi.devno << 48) | op->dmaaddr, count, 0, 0);
 403         if (hvrc != HvLpEvent_Rc_Good) {
 404                 printk(VIOTAPE_KERN_WARN "hv error on op %d\n",
 405                                 (int)hvrc);
 406                 ret = -EIO;
 407                 goto free_dma;
 408         }
 409
 410         if (noblock)
 411                 return count;
 412
 413         wait_for_completion(&op->com);
 414
 415         if (op->rc)
 416                 ret = tape_rc_to_errno(op->rc, "write", devi.devno);
 417         else {
 418                 chg_state(devi.devno, VIOT_WRITING, file);
 419                 ret = op->count;
 420         }
 421
 422 free_dma:
 423         dma_free_coherent(op->dev, count, op->buffer, op->dmaaddr);
 424 up_sem:
 425         up(&reqSem);
 426 free_op:
 427         free_op_struct(op);
 428         return ret;
 429 }
 430
 431 /* read */
 432 static ssize_t viotap_read(struct file *file, char *buf, size_t count,
 433                 loff_t *ptr)
 434 {
 435         HvLpEvent_Rc hvrc;
 436         unsigned short flags = file->f_flags;
 437         struct op_struct *op = get_op_struct();
 438         int noblock = ((flags & O_NONBLOCK) != 0);
 439         ssize_t ret;
 440         struct viot_devinfo_struct devi;
 441
 442         if (op == NULL)
 443                 return -ENOMEM;
 444
 445         get_dev_info(file->f_path.dentry->d_inode, &devi);
 446
 447         /*
 448          * We need to make sure we can send a request.  We use
 449          * a semaphore to keep track of # requests in use.  If
 450          * we are non-blocking, make sure we don't block on the
 451          * semaphore
 452          */
 453         if (noblock) {
 454                 if (down_trylock(&reqSem)) {
 455                         ret = -EWOULDBLOCK;
 456                         goto free_op;
 457                 }
 458         } else
 459                 down(&reqSem);
 460
 461         chg_state(devi.devno, VIOT_READING, file);
 462
 463         /* Allocate a DMA buffer */
 464         op->dev = tape_device[devi.devno];
 465         op->buffer = dma_alloc_coherent(op->dev, count, &op->dmaaddr,
 466                         GFP_ATOMIC);
 467         if (op->buffer == NULL) {
 468                 ret = -EFAULT;
 469                 goto up_sem;
 470         }
 471
 472         op->count = count;
 473         init_completion(&op->com);
 474
 475         hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
 476                         HvLpEvent_Type_VirtualIo,
 477                         viomajorsubtype_tape | viotaperead,
 478                         HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
 479                         viopath_sourceinst(viopath_hostLp),
 480                         viopath_targetinst(viopath_hostLp),
 481                         (u64)(unsigned long)op, VIOVERSION << 16,
 482                         ((u64)devi.devno << 48) | op->dmaaddr, count, 0, 0);
 483         if (hvrc != HvLpEvent_Rc_Good) {
 484                 printk(VIOTAPE_KERN_WARN "tape hv error on op %d\n",
 485                                 (int)hvrc);
 486                 ret = -EIO;
 487                 goto free_dma;
 488         }
 489
 490         wait_for_completion(&op->com);
 491
 492         if (op->rc)
 493                 ret = tape_rc_to_errno(op->rc, "read", devi.devno);
 494         else {
 495                 ret = op->count;
 496                 if (ret && copy_to_user(buf, op->buffer, ret)) {
 497                         printk(VIOTAPE_KERN_WARN "error on copy_to_user\n");
 498                         ret = -EFAULT;
 499                 }
 500         }
 501
 502 free_dma:
 503         dma_free_coherent(op->dev, count, op->buffer, op->dmaaddr);
 504 up_sem:
 505         up(&reqSem);
 506 free_op:
 507         free_op_struct(op);
 508         return ret;
 509 }
 510
 511 /* ioctl */
 512 static int viotap_ioctl(struct inode *inode, struct file *file,
 513                 unsigned int cmd, unsigned long arg)
 514 {
 515         HvLpEvent_Rc hvrc;
 516         int ret;
 517         struct viot_devinfo_struct devi;
 518         struct mtop mtc;
 519         u32 myOp;
 520         struct op_struct *op = get_op_struct();
 521
 522         if (op == NULL)
 523                 return -ENOMEM;
 524
 525         get_dev_info(file->f_path.dentry->d_inode, &devi);
 526
 527         down(&reqSem);
 528
 529         ret = -EINVAL;
 530
 531         switch (cmd) {
 532         case MTIOCTOP:
 533                 ret = -EFAULT;
 534                 /*
 535                  * inode is null if and only if we (the kernel)
 536                  * made the request
 537                  */
 538                 if (inode == NULL)
 539                         memcpy(&mtc, (void *) arg, sizeof(struct mtop));
 540                 else if (copy_from_user((char *)&mtc, (char *)arg,
 541                                         sizeof(struct mtop)))
 542                         goto free_op;
 543
 544                 ret = -EIO;
 545                 switch (mtc.mt_op) {
 546                 case MTRESET:
 547                         myOp = VIOTAPOP_RESET;
 548                         break;
 549                 case MTFSF:
 550                         myOp = VIOTAPOP_FSF;
 551                         break;
 552                 case MTBSF:
 553                         myOp = VIOTAPOP_BSF;
 554                         break;
 555                 case MTFSR:
 556                         myOp = VIOTAPOP_FSR;
 557                         break;
 558                 case MTBSR:
 559                         myOp = VIOTAPOP_BSR;
 560                         break;
 561                 case MTWEOF:
 562                         myOp = VIOTAPOP_WEOF;
 563                         break;
 564                 case MTREW:
 565                         myOp = VIOTAPOP_REW;
 566                         break;
 567                 case MTNOP:
 568                         myOp = VIOTAPOP_NOP;
 569                         break;
 570                 case MTEOM:
 571                         myOp = VIOTAPOP_EOM;
 572                         break;
 573                 case MTERASE:
 574                         myOp = VIOTAPOP_ERASE;
 575                         break;
 576                 case MTSETBLK:
 577                         myOp = VIOTAPOP_SETBLK;
 578                         break;
 579                 case MTSETDENSITY:
 580                         myOp = VIOTAPOP_SETDENSITY;
 581                         break;
 582                 case MTTELL:
 583                         myOp = VIOTAPOP_GETPOS;
 584                         break;
 585                 case MTSEEK:
 586                         myOp = VIOTAPOP_SETPOS;
 587                         break;
 588                 case MTSETPART:
 589                         myOp = VIOTAPOP_SETPART;
 590                         break;
 591                 case MTOFFL:
 592                         myOp = VIOTAPOP_UNLOAD;
 593                         break;
 594                 default:
 595                         printk(VIOTAPE_KERN_WARN "MTIOCTOP called "
 596                                         "with invalid op 0x%x\n", mtc.mt_op);
 597                         goto free_op;
 598                 }
 599
 600                 /*
 601                  * if we moved the head, we are no longer
 602                  * reading or writing
 603                  */
 604                 switch (mtc.mt_op) {
 605                 case MTFSF:
 606                 case MTBSF:
 607                 case MTFSR:
 608                 case MTBSR:
 609                 case MTTELL:
 610                 case MTSEEK:
 611                 case MTREW:
 612                         chg_state(devi.devno, VIOT_IDLE, file);
 613                 }
 614
 615                 init_completion(&op->com);
 616                 hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
 617                                 HvLpEvent_Type_VirtualIo,
 618                                 viomajorsubtype_tape | viotapeop,
 619                                 HvLpEvent_AckInd_DoAck,
 620                                 HvLpEvent_AckType_ImmediateAck,
 621                                 viopath_sourceinst(viopath_hostLp),
 622                                 viopath_targetinst(viopath_hostLp),
 623                                 (u64)(unsigned long)op,
 624                                 VIOVERSION << 16,
 625                                 ((u64)devi.devno << 48), 0,
 626                                 (((u64)myOp) << 32) | mtc.mt_count, 0);
 627                 if (hvrc != HvLpEvent_Rc_Good) {
 628                         printk(VIOTAPE_KERN_WARN "hv error on op %d\n",
 629                                         (int)hvrc);
 630                         goto free_op;
 631                 }
 632                 wait_for_completion(&op->com);
 633                 ret = tape_rc_to_errno(op->rc, "tape operation", devi.devno);
 634                 goto free_op;
 635
 636         case MTIOCGET:
 637                 ret = -EIO;
 638                 init_completion(&op->com);
 639                 hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
 640                                 HvLpEvent_Type_VirtualIo,
 641                                 viomajorsubtype_tape | viotapegetstatus,
 642                                 HvLpEvent_AckInd_DoAck,
 643                                 HvLpEvent_AckType_ImmediateAck,
 644                                 viopath_sourceinst(viopath_hostLp),
 645                                 viopath_targetinst(viopath_hostLp),
 646                                 (u64)(unsigned long)op, VIOVERSION << 16,
 647                                 ((u64)devi.devno << 48), 0, 0, 0);
 648                 if (hvrc != HvLpEvent_Rc_Good) {
 649                         printk(VIOTAPE_KERN_WARN "hv error on op %d\n",
 650                                         (int)hvrc);
 651                         goto free_op;
 652                 }
 653                 wait_for_completion(&op->com);
 654
 655                 /* Operation is complete - grab the error code */
 656                 ret = tape_rc_to_errno(op->rc, "get status", devi.devno);
 657                 free_op_struct(op);
 658                 up(&reqSem);
 659
 660                 if ((ret == 0) && copy_to_user((void *)arg,
 661                                         &viomtget[devi.devno],
 662                                         sizeof(viomtget[0])))
 663                         ret = -EFAULT;
 664                 return ret;
 665         case MTIOCPOS:
 666                 printk(VIOTAPE_KERN_WARN "Got an (unsupported) MTIOCPOS\n");
 667                 break;
 668         default:
 669                 printk(VIOTAPE_KERN_WARN "got an unsupported ioctl 0x%0x\n",
 670                                 cmd);
 671                 break;
 672         }
 673
 674 free_op:
 675         free_op_struct(op);
 676         up(&reqSem);
 677         return ret;
 678 }
 679
 680 static int viotap_open(struct inode *inode, struct file *file)
 681 {
 682         HvLpEvent_Rc hvrc;
 683         struct viot_devinfo_struct devi;
 684         int ret;
 685         struct op_struct *op = get_op_struct();
 686
 687         if (op == NULL)
 688                 return -ENOMEM;
 689
 690         get_dev_info(file->f_path.dentry->d_inode, &devi);
 691
 692         /* Note: We currently only support one mode! */
 693         if ((devi.devno >= viotape_numdev) || (devi.mode)) {
 694                 ret = -ENODEV;
 695                 goto free_op;
 696         }
 697
 698         init_completion(&op->com);
 699
 700         hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
 701                         HvLpEvent_Type_VirtualIo,
 702                         viomajorsubtype_tape | viotapeopen,
 703                         HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
 704                         viopath_sourceinst(viopath_hostLp),
 705                         viopath_targetinst(viopath_hostLp),
 706                         (u64)(unsigned long)op, VIOVERSION << 16,
 707                         ((u64)devi.devno << 48), 0, 0, 0);
 708         if (hvrc != 0) {
 709                 printk(VIOTAPE_KERN_WARN "bad rc on signalLpEvent %d\n",
 710                                 (int) hvrc);
 711                 ret = -EIO;
 712                 goto free_op;
 713         }
 714
 715         wait_for_completion(&op->com);
 716         ret = tape_rc_to_errno(op->rc, "open", devi.devno);
 717
 718 free_op:
 719         free_op_struct(op);
 720         return ret;
 721 }
 722
 723
 724 static int viotap_release(struct inode *inode, struct file *file)
 725 {
 726         HvLpEvent_Rc hvrc;
 727         struct viot_devinfo_struct devi;
 728         int ret = 0;
 729         struct op_struct *op = get_op_struct();
 730
 731         if (op == NULL)
 732                 return -ENOMEM;
 733         init_completion(&op->com);
 734
 735         get_dev_info(file->f_path.dentry->d_inode, &devi);
 736
 737         if (devi.devno >= viotape_numdev) {
 738                 ret = -ENODEV;
 739                 goto free_op;
 740         }
 741
 742         chg_state(devi.devno, VIOT_IDLE, file);
 743
 744         if (devi.rewind) {
 745                 hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
 746                                 HvLpEvent_Type_VirtualIo,
 747                                 viomajorsubtype_tape | viotapeop,
 748                                 HvLpEvent_AckInd_DoAck,
 749                                 HvLpEvent_AckType_ImmediateAck,
 750                                 viopath_sourceinst(viopath_hostLp),
 751                                 viopath_targetinst(viopath_hostLp),
 752                                 (u64)(unsigned long)op, VIOVERSION << 16,
 753                                 ((u64)devi.devno << 48), 0,
 754                                 ((u64)VIOTAPOP_REW) << 32, 0);
 755                 wait_for_completion(&op->com);
 756
 757                 tape_rc_to_errno(op->rc, "rewind", devi.devno);
 758         }
 759
 760         hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
 761                         HvLpEvent_Type_VirtualIo,
 762                         viomajorsubtype_tape | viotapeclose,
 763                         HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
 764                         viopath_sourceinst(viopath_hostLp),
 765                         viopath_targetinst(viopath_hostLp),
 766                         (u64)(unsigned long)op, VIOVERSION << 16,
 767                         ((u64)devi.devno << 48), 0, 0, 0);
 768         if (hvrc != 0) {
 769                 printk(VIOTAPE_KERN_WARN "bad rc on signalLpEvent %d\n",
 770                                 (int) hvrc);
 771                 ret = -EIO;
 772                 goto free_op;
 773         }
 774
 775         wait_for_completion(&op->com);
 776
 777         if (op->rc)
 778                 printk(VIOTAPE_KERN_WARN "close failed\n");
 779
 780 free_op:
 781         free_op_struct(op);
 782         return ret;
 783 }
 784
 785 const struct file_operations viotap_fops = {
 786         .owner =        THIS_MODULE,
 787         .read =         viotap_read,
 788         .write =        viotap_write,
 789         .ioctl =        viotap_ioctl,
 790         .open =         viotap_open,
 791         .release =      viotap_release,
 792 };
 793
 794 /* Handle interrupt events for tape */
 795 static void vioHandleTapeEvent(struct HvLpEvent *event)
 796 {
 797         int tapeminor;
 798         struct op_struct *op;
 799         struct viotapelpevent *tevent = (struct viotapelpevent *)event;
 800
 801         if (event == NULL) {
 802                 /* Notification that a partition went away! */
 803                 if (!viopath_isactive(viopath_hostLp)) {
 804                         /* TODO! Clean up */
 805                 }
 806                 return;
 807         }
 808
 809         tapeminor = event->xSubtype & VIOMINOR_SUBTYPE_MASK;
 810         op = (struct op_struct *)event->xCorrelationToken;
 811         switch (tapeminor) {
 812         case viotapeopen:
 813         case viotapeclose:
 814                 op->rc = tevent->sub_type_result;
 815                 complete(&op->com);
 816                 break;
 817         case viotaperead:
 818                 op->rc = tevent->sub_type_result;
 819                 op->count = tevent->len;
 820                 complete(&op->com);
 821                 break;
 822         case viotapewrite:
 823                 if (op->non_blocking) {
 824                         dma_free_coherent(op->dev, op->count,
 825                                         op->buffer, op->dmaaddr);
 826                         free_op_struct(op);
 827                         up(&reqSem);
 828                 } else {
 829                         op->rc = tevent->sub_type_result;
 830                         op->count = tevent->len;
 831                         complete(&op->com);
 832                 }
 833                 break;
 834         case viotapeop:
 835         case viotapegetpos:
 836         case viotapesetpos:
 837         case viotapegetstatus:
 838                 if (op) {
 839                         op->count = tevent->u.op.count;
 840                         op->rc = tevent->sub_type_result;
 841                         if (!op->non_blocking)
 842                                 complete(&op->com);
 843                 }
 844                 break;
 845         default:
 846                 printk(VIOTAPE_KERN_WARN "weird ack\n");
 847         }
 848 }
 849
 850 static int viotape_probe(struct vio_dev *vdev, const struct vio_device_id *id)
 851 {
 852         int i = vdev->unit_address;
 853         int j;
 854         struct device_node *node = vdev->dev.archdata.of_node;
 855
 856         if (i > VIOTAPE_MAX_TAPE)
 857                 return -ENODEV;
 858         if (!node)
 859                 return -ENODEV;
 860
 861         if (i >= viotape_numdev)
 862                 viotape_numdev = i + 1;
 863
 864         tape_device[i] = &vdev->dev;
 865         viotape_unitinfo[i].rsrcname = of_get_property(node,
 866                                         "linux,vio_rsrcname", NULL);
 867         viotape_unitinfo[i].type = of_get_property(node, "linux,vio_type",
 868                                         NULL);
 869         viotape_unitinfo[i].model = of_get_property(node, "linux,vio_model",
 870                                         NULL);
 871
 872         state[i].cur_part = 0;
 873         for (j = 0; j < MAX_PARTITIONS; ++j)
 874                 state[i].part_stat_rwi[j] = VIOT_IDLE;
 875         device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i),
 876                         "iseries!vt%d", i);
 877         device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i | 0x80),
 878                         "iseries!nvt%d", i);
 879         printk(VIOTAPE_KERN_INFO "tape iseries/vt%d is iSeries "
 880                         "resource %10.10s type %4.4s, model %3.3s\n",
 881                         i, viotape_unitinfo[i].rsrcname,
 882                         viotape_unitinfo[i].type, viotape_unitinfo[i].model);
 883         return 0;
 884 }
 885
 886 static int viotape_remove(struct vio_dev *vdev)
 887 {
 888         int i = vdev->unit_address;
 889
 890         device_destroy(tape_class, MKDEV(VIOTAPE_MAJOR, i | 0x80));
 891         device_destroy(tape_class, MKDEV(VIOTAPE_MAJOR, i));
 892         return 0;
 893 }
 894
 895 /**
 896  * viotape_device_table: Used by vio.c to match devices that we
 897  * support.
 898  */
 899 static struct vio_device_id viotape_device_table[] __devinitdata = {
 900         { "byte", "IBM,iSeries-viotape" },
 901         { "", "" }
 902 };
 903 MODULE_DEVICE_TABLE(vio, viotape_device_table);
 904
 905 static struct vio_driver viotape_driver = {
 906         .id_table = viotape_device_table,
 907         .probe = viotape_probe,
 908         .remove = viotape_remove,
 909         .driver = {
 910                 .name = "viotape",
 911                 .owner = THIS_MODULE,
 912         }
 913 };
 914
 915
 916 int __init viotap_init(void)
 917 {
 918         int ret;
 919
 920         if (!firmware_has_feature(FW_FEATURE_ISERIES))
 921                 return -ENODEV;
 922
 923         op_struct_list = NULL;
 924         if ((ret = add_op_structs(VIOTAPE_MAXREQ)) < 0) {
 925                 printk(VIOTAPE_KERN_WARN "couldn't allocate op structs\n");
 926                 return ret;
 927         }
 928         spin_lock_init(&op_struct_list_lock);
 929
 930         sema_init(&reqSem, VIOTAPE_MAXREQ);
 931
 932         if (viopath_hostLp == HvLpIndexInvalid) {
 933                 vio_set_hostlp();
 934                 if (viopath_hostLp == HvLpIndexInvalid) {
 935                         ret = -ENODEV;
 936                         goto clear_op;
 937                 }
 938         }
 939
 940         ret = viopath_open(viopath_hostLp, viomajorsubtype_tape,
 941                         VIOTAPE_MAXREQ + 2);
 942         if (ret) {
 943                 printk(VIOTAPE_KERN_WARN
 944                                 "error on viopath_open to hostlp %d\n", ret);
 945                 ret = -EIO;
 946                 goto clear_op;
 947         }
 948
 949         printk(VIOTAPE_KERN_INFO "vers " VIOTAPE_VERSION
 950                         ", hosting partition %d\n", viopath_hostLp);
 951
 952         vio_setHandler(viomajorsubtype_tape, vioHandleTapeEvent);
 953
 954         ret = register_chrdev(VIOTAPE_MAJOR, "viotape", &viotap_fops);
 955         if (ret < 0) {
 956                 printk(VIOTAPE_KERN_WARN "Error registering viotape device\n");
 957                 goto clear_handler;
 958         }
 959
 960         tape_class = class_create(THIS_MODULE, "tape");
 961         if (IS_ERR(tape_class)) {
 962                 printk(VIOTAPE_KERN_WARN "Unable to allocat class\n");
 963                 ret = PTR_ERR(tape_class);
 964                 goto unreg_chrdev;
 965         }
 966
 967         ret = vio_register_driver(&viotape_driver);
 968         if (ret)
 969                 goto unreg_class;
 970
 971         proc_create("iSeries/viotape", S_IFREG|S_IRUGO, NULL,
 972                     &proc_viotape_operations);
 973
 974         return 0;
 975
 976 unreg_class:
 977         class_destroy(tape_class);
 978 unreg_chrdev:
 979         unregister_chrdev(VIOTAPE_MAJOR, "viotape");
 980 clear_handler:
 981         vio_clearHandler(viomajorsubtype_tape);
 982         viopath_close(viopath_hostLp, viomajorsubtype_tape, VIOTAPE_MAXREQ + 2);
 983 clear_op:
 984         clear_op_struct_pool();
 985         return ret;
 986 }
 987
 988 /* Give a new state to the tape object */
 989 static int chg_state(int index, unsigned char new_state, struct file *file)
 990 {
 991         unsigned char *cur_state =
 992             &state[index].part_stat_rwi[state[index].cur_part];
 993         int rc = 0;
 994
 995         /* if the same state, don't bother */
 996         if (*cur_state == new_state)
 997                 return 0;
 998
 999         /* write an EOF if changing from writing to some other state */
1000         if (*cur_state == VIOT_WRITING) {
1001                 struct mtop write_eof = { MTWEOF, 1 };
1002
1003                 rc = viotap_ioctl(NULL, file, MTIOCTOP,
1004                                   (unsigned long)&write_eof);
1005         }
1006         *cur_state = new_state;
1007         return rc;
1008 }
1009
1010 /* Cleanup */
1011 static void __exit viotap_exit(void)
1012 {
1013         remove_proc_entry("iSeries/viotape", NULL);
1014         vio_unregister_driver(&viotape_driver);
1015         class_destroy(tape_class);
1016         unregister_chrdev(VIOTAPE_MAJOR, "viotape");
1017         viopath_close(viopath_hostLp, viomajorsubtype_tape, VIOTAPE_MAXREQ + 2);
1018         vio_clearHandler(viomajorsubtype_tape);
1019         clear_op_struct_pool();
1020 }
1021
1022 MODULE_LICENSE("GPL");
1023 module_init(viotap_init);
1024 module_exit(viotap_exit);