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