drivers/s390/char/tape.c

   1
   2 /***********************************************************************
   3  *  drivers/s390/char/tape.c
   4  *    tape device driver for S/390 and zSeries tapes.
   5  *
   6  *  S390 and zSeries version
   7  *    Copyright (C) 2001 IBM Corporation
   8  *    Author(s): Carsten Otte <cotte@de.ibm.com>
   9  *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
  10  *
  11  ***********************************************************************
  12  */
  13
  14 #include "tapedefs.h"
  15
  16 #include <linux/config.h>
  17 #include <linux/stddef.h>
  18 #include <linux/kernel.h>
  19 #include <linux/version.h>
  20 #include <linux/proc_fs.h>
  21 #include <linux/init.h>
  22 #include <asm/types.h>
  23 #include <asm/ccwcache.h>
  24 #include <asm/idals.h>
  25 #include <asm/ebcdic.h>
  26 #include <linux/compatmac.h>
  27 #ifdef MODULE
  28 #include <linux/module.h>
  29 #endif
  30 #include <asm/debug.h>
  31 #ifdef CONFIG_S390_TAPE_DYNAMIC
  32 #include <asm/s390dyn.h>
  33 #endif
  34 #include "tape.h"
  35 #ifdef CONFIG_S390_TAPE_3490
  36 #include "tape3490.h"
  37 #endif
  38 #ifdef CONFIG_S390_TAPE_3480
  39 #include "tape3480.h"
  40 #endif
  41 #ifdef CONFIG_S390_TAPE_BLOCK
  42 #include "tapeblock.h"
  43 #endif
  44 #ifdef CONFIG_S390_TAPE_CHAR
  45 #include "tapechar.h"
  46 #endif
  47 #ifdef CONFIG_PROC_FS
  48 #include <linux/vmalloc.h>
  49 #endif
  50 #define PRINTK_HEADER "T390:"
  51
  52
  53 /* state handling routines */
  54 inline void tapestate_set (tape_info_t * ti, int newstate);
  55 inline int tapestate_get (tape_info_t * ti);
  56 void tapestate_event (tape_info_t * ti, int event);
  57
  58 /* our globals */
  59 tape_info_t *first_tape_info = NULL;
  60 tape_discipline_t *first_discipline = NULL;
  61 tape_frontend_t *first_frontend = NULL;
  62 devreg_t* tape_devreg[128];
  63 int devregct=0;
  64
  65 #ifdef TAPE_DEBUG
  66 debug_info_t *tape_debug_area = NULL;
  67 #endif
  68
  69 char* state_verbose[TS_SIZE]={
  70     "TS_UNUSED",  "TS_IDLE", "TS_DONE", "TS_FAILED",
  71     "TS_BLOCK_INIT",
  72     "TS_BSB_INIT",
  73     "TS_BSF_INIT",
  74     "TS_DSE_INIT",
  75     "TS_EGA_INIT",
  76     "TS_FSB_INIT",
  77     "TS_FSF_INIT",
  78     "TS_LDI_INIT",
  79     "TS_LBL_INIT",
  80     "TS_MSE_INIT",
  81     "TS_NOP_INIT",
  82     "TS_RBA_INIT",
  83     "TS_RBI_INIT",
  84     "TS_RBU_INIT",
  85     "TS_RBL_INIT",
  86     "TS_RDC_INIT",
  87     "TS_RFO_INIT",
  88     "TS_RSD_INIT",
  89     "TS_REW_INIT",
  90     "TS_REW_RELEASE_INIT",
  91     "TS_RUN_INIT",
  92     "TS_SEN_INIT",
  93     "TS_SID_INIT",
  94     "TS_SNP_INIT",
  95     "TS_SPG_INIT",
  96     "TS_SWI_INIT",
  97     "TS_SMR_INIT",
  98     "TS_SYN_INIT",
  99     "TS_TIO_INIT",
 100     "TS_UNA_INIT",
 101     "TS_WRI_INIT",
 102     "TS_WTM_INIT",
 103     "TS_NOT_OPER"};
 104
 105 char* event_verbose[TE_SIZE]= {
 106     "TE_START", "TE_DONE", "TE_FAILED", "TE_ERROR", "TE_OTHER"};
 107
 108 /* our root devfs handle */
 109 #ifdef CONFIG_DEVFS_FS
 110 devfs_handle_t tape_devfs_root_entry;
 111
 112 inline void
 113 tape_mkdevfsroots (tape_info_t* ti)
 114 {
 115     char devno [5];
 116     sprintf (devno,"%04x",ti->devinfo.devno);
 117     ti->devfs_dir=devfs_mk_dir (tape_devfs_root_entry, devno, ti);
 118 }
 119
 120 inline void
 121 tape_rmdevfsroots (tape_info_t* ti)
 122 {
 123     devfs_unregister (ti->devfs_dir);
 124 }
 125 #endif
 126
 127 #ifdef CONFIG_PROC_FS
 128 /* our proc tapedevices entry */
 129 static struct proc_dir_entry *tape_devices_entry;
 130
 131 typedef struct {
 132         char *data;
 133         int len;
 134 } tempinfo_t;
 135
 136
 137 static int
 138 tape_devices_open (struct inode *inode, struct file *file)
 139 {
 140     int size=80;
 141     tape_info_t* ti;
 142     tempinfo_t* tempinfo;
 143     char* data;
 144     int pos=0;
 145     tempinfo = kmalloc (sizeof(tempinfo_t),GFP_KERNEL);
 146     if (!tempinfo)
 147         return -ENOMEM;
 148     for (ti=first_tape_info;ti!=NULL;ti=ti->next)
 149         size+=80; // FIXME: Guess better!
 150     data=vmalloc(size);
 151     if (!data) {
 152         kfree (tempinfo);
 153         return -ENOMEM;
 154     }
 155     pos+=sprintf(data+pos,"TapeNo\tDevNo\tCuType\tCuModel\tDevType\tDevModel\tState\n");
 156     for (ti=first_tape_info;ti!=NULL;ti=ti->next) {
 157         pos+=sprintf(data+pos,"%d\t%04X\t%04X\t%02X\t%04X\t%02X\t\t%s\n",ti->rew_minor/2,
 158                      ti->devinfo.devno,ti->devinfo.sid_data.cu_type,
 159                      ti->devinfo.sid_data.cu_model,ti->devinfo.sid_data.dev_type,
 160                      ti->devinfo.sid_data.dev_model,((tapestate_get(ti) >= 0) &&
 161                                                        (tapestate_get(ti) < TS_SIZE)) ?
 162                      state_verbose[tapestate_get (ti)] : "TS UNKNOWN");
 163     }
 164     tempinfo->len=pos;
 165     tempinfo->data=data;
 166     file->private_data= (void*) tempinfo;
 167 #ifdef MODULE
 168     MOD_INC_USE_COUNT;
 169 #endif
 170     return 0;
 171 }
 172
 173 static ssize_t
 174 tape_devices_read (struct file *file, char *user_buf, size_t user_len, loff_t * offset)
 175 {
 176         loff_t len;
 177         tempinfo_t *p_info = (tempinfo_t *) file->private_data;
 178
 179         if (*offset >= p_info->len) {
 180                 return 0;       /* EOF */
 181         } else {
 182                 len =  user_len<(p_info->len - *offset)?user_len:(p_info->len - *offset);
 183                 if (copy_to_user (user_buf, &(p_info->data[*offset]), len))
 184                         return -EFAULT;
 185                 (*offset) += len;
 186                 return len;     /* number of bytes "read" */
 187         }
 188 }
 189
 190 static int
 191 tape_devices_release (struct inode *inode, struct file *file)
 192 {
 193         int rc = 0;
 194         tempinfo_t *p_info = (tempinfo_t *) file->private_data;
 195         if (p_info) {
 196                 if (p_info->data)
 197                         vfree (p_info->data);
 198                 kfree (p_info);
 199         }
 200 #ifdef MODULE
 201         MOD_DEC_USE_COUNT;
 202 #endif
 203         return rc;
 204 }
 205
 206 static struct file_operations tape_devices_file_ops =
 207 {
 208         read:tape_devices_read, /* read */
 209         open:tape_devices_open, /* open */
 210         release:tape_devices_release,   /* close */
 211 };
 212
 213 static struct inode_operations tape_devices_inode_ops =
 214 {
 215 #if !(LINUX_VERSION_CODE > KERNEL_VERSION(2,3,98))
 216         default_file_ops:&tape_devices_file_ops         /* file ops */
 217 #endif                          /* LINUX_IS_24 */
 218 };
 219 #endif /* CONFIG_PROC_FS */
 220
 221 /* SECTION: Parameters for tape */
 222 char *tape[256] = { NULL, };
 223
 224 #ifndef MODULE
 225 static char tape_parm_string[1024] __initdata = { 0, };
 226 static void
 227 tape_split_parm_string (char *str)
 228 {
 229         char *tmp = str;
 230         int count = 0;
 231         while (tmp != NULL && *tmp != '\0') {
 232                 char *end;
 233                 int len;
 234                 end = strchr (tmp, ',');
 235                 if (end == NULL) {
 236                         len = strlen (tmp) + 1;
 237                 } else {
 238                         len = (long) end - (long) tmp + 1;
 239                         *end = '\0';
 240                         end++;
 241                 }
 242                 tape[count] = kmalloc (len * sizeof (char), GFP_ATOMIC);
 243                 if (tape[count] == NULL) {
 244                         printk (KERN_WARNING PRINTK_HEADER
 245                                 "can't store tape= parameter no %d\n",
 246                                 count + 1);
 247                         break;
 248                 }
 249                 memset (tape[count], 0, len * sizeof (char));
 250                 memcpy (tape[count], tmp, len * sizeof (char));
 251                 count++;
 252                 tmp = end;
 253         };
 254 }
 255
 256 void __init
 257 tape_parm_setup (char *str, int *ints)
 258 {
 259         int len = strlen (tape_parm_string);
 260         if (len != 0) {
 261                 strcat (tape_parm_string, ",");
 262         }
 263         strcat (tape_parm_string, str);
 264 }
 265
 266 int __init
 267 tape_parm_call_setup (char *str)
 268 {
 269         int dummy;
 270         tape_parm_setup (str, &dummy);
 271         return 1;
 272 }
 273
 274 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,2,16))
 275 __setup("tape=", tape_parm_call_setup);
 276 #endif   /* kernel <2.2.19 */
 277 #endif   /* not defined MODULE */
 278
 279 static inline int
 280 tape_parm_strtoul (char *str, char **stra)
 281 {
 282         char *temp = str;
 283         int val;
 284         if (*temp == '0') {
 285                 temp++;         /* strip leading zero */
 286                 if (*temp == 'x')
 287                         temp++; /* strip leading x */
 288         }
 289         val = simple_strtoul (temp, &temp, 16); /* interpret anything as hex */
 290         *stra = temp;
 291         return val;
 292 }
 293
 294 static inline devreg_t *
 295 tape_create_devreg (int devno)
 296 {
 297         devreg_t *devreg = kmalloc (sizeof (devreg_t), GFP_KERNEL);
 298         if (devreg != NULL) {
 299                 memset (devreg, 0, sizeof (devreg_t));
 300                 devreg->ci.devno = devno;
 301                 devreg->flag = DEVREG_TYPE_DEVNO;
 302                 devreg->oper_func = tape_oper_handler;
 303         }
 304         return devreg;
 305 }
 306
 307 static inline void
 308 tape_parm_parse (char **str)
 309 {
 310         char *temp;
 311         int from, to,i,irq=0,rc,retries=0,tape_num=0;
 312         s390_dev_info_t dinfo;
 313         tape_info_t* ti,*tempti;
 314         tape_discipline_t* disc;
 315         long lockflags;
 316         if (*str==NULL) {
 317             /* no params present -> leave */
 318             return;
 319         }
 320         while (*str) {
 321                 temp = *str;
 322                 from = 0;
 323                 to = 0;
 324
 325                 /* turn off autodetect mode, if any range is present */
 326                 from = tape_parm_strtoul (temp, &temp);
 327                 to = from;
 328                 if (*temp == '-') {
 329                     temp++;
 330                     to = tape_parm_strtoul (temp, &temp);
 331                 }
 332                 for (i=from;i<=to;i++) {
 333                     retries=0;
 334                     // register for attch/detach of a devno
 335                     tape_devreg[devregct]=tape_create_devreg(i);
 336                     if (tape_devreg[devregct]==NULL) {
 337                         PRINT_WARN ("Could not create devreg for devno %04x, dyn. attach for this devno deactivated.\n",i);
 338                     } else {
 339                         s390_device_register (tape_devreg[devregct++]);
 340                     }
 341                     // we are activating a device if it is present
 342                     for (irq = get_irq_first(); irq!=-ENODEV; irq=get_irq_next(irq)) {
 343                         rc = get_dev_info_by_irq (irq, &dinfo);
 344
 345                         disc = first_discipline;
 346                         while ((dinfo.devno == i) && (disc != NULL) && (disc->cu_type != dinfo.sid_data.cu_type))
 347                             disc = (tape_discipline_t *) (disc->next);
 348                         if ((disc == NULL) || (rc == -ENODEV) || (i!=dinfo.devno)) {
 349                             continue;
 350                         }
 351 #ifdef TAPE_DEBUG
 352                         debug_text_event (tape_debug_area,3,"det irq:  ");
 353                         debug_int_event (tape_debug_area,3,irq);
 354                         debug_text_event (tape_debug_area,3,"cu:       ");
 355                         debug_int_event (tape_debug_area,3,disc->cu_type);
 356 #endif /* TAPE_DEBUG */
 357                         PRINT_INFO ("using devno %04x with discipline %04x on irq %d as tape device %d\n",dinfo.devno,dinfo.sid_data.cu_type,irq,tape_num/2);
 358                         /* Allocate tape structure  */
 359                         ti = kmalloc (sizeof (tape_info_t), GFP_ATOMIC);
 360                         if (ti == NULL) {
 361 #ifdef TAPE_DEBUG
 362                             debug_text_exception (tape_debug_area,3,"ti:no mem ");
 363 #endif /* TAPE_DEBUG */
 364                             PRINT_INFO ("tape: can't allocate memory for "
 365                                         "tape info structure\n");
 366                             continue;
 367                         }
 368                         memset(ti,0,sizeof(tape_info_t));
 369                         ti->discipline = disc;
 370                         disc->tape = ti;
 371                         rc = tape_setup (ti, irq, tape_num);
 372                         if (rc) {
 373 #ifdef TAPE_DEBUG
 374                             debug_text_event (tape_debug_area,3,"tsetup err");
 375                             debug_int_exception (tape_debug_area,3,rc);
 376 #endif /* TAPE_DEBUG */
 377                             kfree (ti);
 378                         } else {
 379                             s390irq_spin_lock_irqsave (irq, lockflags);
 380                             if (first_tape_info == NULL) {
 381                                 first_tape_info = ti;
 382                             } else {
 383                                 tempti = first_tape_info;
 384                                 while (tempti->next != NULL)
 385                                     tempti = tempti->next;
 386                                 tempti->next = ti;
 387                             }
 388                             s390irq_spin_unlock_irqrestore (irq, lockflags);
 389                         }
 390                     }
 391                     tape_num+=2;
 392                 }
 393                 str++;
 394         }
 395 }
 396
 397
 398 /* SECTION: Managing wrappers for ccwcache */
 399
 400 #define TAPE_EMERGENCY_REQUESTS 16
 401
 402 static ccw_req_t *tape_emergency_req[TAPE_EMERGENCY_REQUESTS] =
 403 {NULL,};
 404 static spinlock_t tape_emergency_req_lock = SPIN_LOCK_UNLOCKED;
 405
 406 static void
 407 tape_init_emergency_req (void)
 408 {
 409         int i;
 410         for (i = 0; i < TAPE_EMERGENCY_REQUESTS; i++) {
 411                 tape_emergency_req[i] = (ccw_req_t *) get_free_page (GFP_KERNEL);
 412         }
 413 }
 414
 415 #ifdef MODULE // We only cleanup the emergency requests on module unload.
 416 static void
 417 tape_cleanup_emergency_req (void)
 418 {
 419         int i;
 420         for (i = 0; i < TAPE_EMERGENCY_REQUESTS; i++) {
 421                 if (tape_emergency_req[i])
 422                         free_page ((long) (tape_emergency_req[i]));
 423                 else
 424                         printk (KERN_WARNING PRINTK_HEADER "losing one page for 'in-use' emergency request\n");
 425         }
 426 }
 427 #endif
 428
 429 ccw_req_t *
 430 tape_alloc_request (char *magic, int cplength, int datasize)
 431 {
 432         ccw_req_t *rv = NULL;
 433         int i;
 434         if ((rv = ccw_alloc_request (magic, cplength, datasize)) != NULL) {
 435                 return rv;
 436         }
 437         if (cplength * sizeof (ccw1_t) + datasize + sizeof (ccw_req_t) > PAGE_SIZE) {
 438                 return NULL;
 439         }
 440         spin_lock (&tape_emergency_req_lock);
 441         for (i = 0; i < TAPE_EMERGENCY_REQUESTS; i++) {
 442                 if (tape_emergency_req[i] != NULL) {
 443                         rv = tape_emergency_req[i];
 444                         tape_emergency_req[i] = NULL;
 445                 }
 446         }
 447         spin_unlock (&tape_emergency_req_lock);
 448         if (rv) {
 449                 memset (rv, 0, PAGE_SIZE);
 450                 rv->cache = (kmem_cache_t *) (tape_emergency_req + i);
 451                 strncpy ((char *) (&rv->magic), magic, 4);
 452                 ASCEBC ((char *) (&rv->magic), 4);
 453                 rv->cplength = cplength;
 454                 rv->datasize = datasize;
 455                 rv->data = (void *) ((long) rv + PAGE_SIZE - datasize);
 456                 rv->cpaddr = (ccw1_t *) ((long) rv + sizeof (ccw_req_t));
 457         }
 458         return rv;
 459 }
 460
 461 void
 462 tape_free_request (ccw_req_t * request)
 463 {
 464         if (request->cache >= (kmem_cache_t *) tape_emergency_req &&
 465             request->cache <= (kmem_cache_t *) (tape_emergency_req + TAPE_EMERGENCY_REQUESTS)) {
 466                 *((ccw_req_t **) (request->cache)) = request;
 467         } else {
 468                 clear_normalized_cda ((ccw1_t *) (request->cpaddr));    // avoid memory leak caused by modeset_byte
 469                 ccw_free_request (request);
 470         }
 471 }
 472
 473 /*
 474  * Allocate a ccw request and reserve it for tape driver
 475  */
 476 inline
 477  ccw_req_t *
 478 tape_alloc_ccw_req (tape_info_t * ti, int cplength, int datasize)
 479 {
 480         char tape_magic_id[] = "tape";
 481         ccw_req_t *cqr = NULL;
 482
 483         if (!ti)
 484                 return NULL;
 485         cqr = tape_alloc_request (tape_magic_id, cplength, datasize);
 486
 487         if (!cqr) {
 488 #ifdef TAPE_DEBUG
 489                 PRINT_WARN ("empty CQR generated\n");
 490 #endif
 491         }
 492         cqr->magic = TAPE_MAGIC;        /* sets an identifier for tape driver   */
 493         cqr->device = ti;       /* save pointer to tape info    */
 494         return cqr;
 495 }
 496
 497 /*
 498  * Find the tape_info_t structure associated with irq
 499  */
 500 static inline tape_info_t *
 501 tapedev_find_info (int irq)
 502 {
 503         tape_info_t *ti;
 504
 505         ti = first_tape_info;
 506         if (ti != NULL)
 507                 do {
 508                         if (ti->devinfo.irq == irq)
 509                                 break;
 510                 } while ((ti = (tape_info_t *) ti->next) != NULL);
 511         return ti;
 512 }
 513
 514 #define QUEUE_THRESHOLD 5
 515
 516 /*
 517  * Tape interrupt routine, called from Ingo's I/O layer
 518  */
 519 void
 520 tape_irq (int irq, void *int_parm, struct pt_regs *regs)
 521 {
 522         tape_info_t *ti = tapedev_find_info (irq);
 523
 524         /* analyse devstat and fire event */
 525         if (ti->devstat.dstat & DEV_STAT_UNIT_CHECK) {
 526                 tapestate_event (ti, TE_ERROR);
 527         } else if (ti->devstat.dstat & (DEV_STAT_DEV_END)) {
 528                 tapestate_event (ti, TE_DONE);
 529         } else
 530                 tapestate_event (ti, TE_OTHER);
 531 }
 532
 533 int
 534 tape_oper_handler ( int irq, struct _devreg *dreg) {
 535     tape_info_t* ti=first_tape_info;
 536     tape_info_t* newtape;
 537     int rc,tape_num,retries=0,i;
 538     s390_dev_info_t dinfo;
 539     tape_discipline_t* disc;
 540 #ifdef CONFIG_DEVFS_FS
 541     tape_frontend_t* frontend;
 542 #endif
 543     long lockflags;
 544     while ((ti!=NULL) && (ti->devinfo.irq!=irq))
 545         ti=ti->next;
 546     if (ti!=NULL) {
 547         // irq is (still) used by tape. tell ingo to try again later
 548         PRINT_WARN ("Oper handler for irq %d called while irq still (internaly?) used.\n",irq);
 549         return -EAGAIN;
 550     }
 551     // irq is not used by tape
 552     rc = get_dev_info_by_irq (irq, &dinfo);
 553     if (rc == -ENODEV) {
 554         retries++;
 555         rc = get_dev_info_by_irq (irq, &dinfo);
 556         if (retries > 5) {
 557             PRINT_WARN ("No device information for new dev. could be retrieved.\n");
 558             return -ENODEV;
 559         }
 560     }
 561     disc = first_discipline;
 562     while ((disc != NULL) && (disc->cu_type != dinfo.sid_data.cu_type))
 563         disc = (tape_discipline_t *) (disc->next);
 564     if (disc == NULL)
 565         PRINT_WARN ("No matching discipline for cu_type %x found, ignoring device %04x.\n",dinfo.sid_data.cu_type,dinfo.devno);
 566     if (rc == -ENODEV)
 567         PRINT_WARN ("No device information for new dev. could be retrieved.\n");
 568     if ((disc == NULL) || (rc == -ENODEV))
 569         return -ENODEV;
 570
 571     /* Allocate tape structure  */
 572     ti = kmalloc (sizeof (tape_info_t), GFP_ATOMIC);
 573     if (ti == NULL) {
 574         PRINT_INFO ( "tape: can't allocate memory for "
 575                     "tape info structure\n");
 576         return -ENOBUFS;
 577     }
 578     memset(ti,0,sizeof(tape_info_t));
 579     ti->discipline = disc;
 580     disc->tape = ti;
 581     tape_num=0;
 582     if (*tape) {
 583         // we have static device ranges, so fingure out the tape_num of the attached tape
 584         for (i=0;i<devregct;i++)
 585             if (tape_devreg[i]->ci.devno==dinfo.devno) {
 586                 tape_num=2*i;
 587                 break;
 588             }
 589     } else {
 590         // we are running in autoprobe mode, find a free tape_num
 591         newtape=first_tape_info;
 592         while (newtape!=NULL) {
 593             if (newtape->rew_minor==tape_num) {
 594                 // tape num in use. try next one
 595                 tape_num+=2;
 596                 newtape=first_tape_info;
 597             } else {
 598                 // tape num not used by newtape. look at next tape info
 599                 newtape=newtape->next;
 600             }
 601         }
 602     }
 603     rc = tape_setup (ti, irq, tape_num);
 604     if (rc) {
 605         kfree (ti);
 606         return -ENOBUFS;
 607     }
 608 #ifdef CONFIG_DEVFS_FS
 609     for (frontend=first_frontend;frontend!=NULL;frontend=frontend->next)
 610         frontend->mkdevfstree(ti);
 611 #endif
 612     s390irq_spin_lock_irqsave (irq,lockflags);
 613     if (first_tape_info == NULL) {
 614         first_tape_info = ti;
 615     } else {
 616         newtape = first_tape_info;
 617         while (newtape->next != NULL)
 618             newtape = newtape->next;
 619         newtape->next = ti;
 620     }
 621     s390irq_spin_unlock_irqrestore (irq, lockflags);
 622     return 0;
 623 }
 624
 625
 626 static void
 627 tape_noper_handler ( int irq, int status ) {
 628     tape_info_t *ti=first_tape_info;
 629     tape_info_t *lastti;
 630 #ifdef CONFIG_DEVFS_FS
 631     tape_frontend_t *frontend;
 632 #endif
 633     long lockflags;
 634     s390irq_spin_lock_irqsave(irq,lockflags);
 635     while (ti!=NULL && ti->devinfo.irq!=irq) ti=ti->next;
 636     if (ti==NULL) return;
 637     if (tapestate_get(ti)!=TS_UNUSED) {
 638         // device is in use!
 639         PRINT_WARN ("Tape #%d was detached while it was busy. Expect errors!",ti->blk_minor/2);
 640         tapestate_set(ti,TS_NOT_OPER);
 641         ti->rc=-ENODEV;
 642         ti->wanna_wakeup=1;
 643         switch (tapestate_get(ti)) {
 644         case TS_REW_RELEASE_INIT:
 645             tapestate_set(ti,TS_NOT_OPER);
 646             wake_up (&ti->wq);
 647             break;
 648 #ifdef CONFIG_S390_TAPE_BLOCK
 649         case TS_BLOCK_INIT:
 650             tapestate_set(ti,TS_NOT_OPER);
 651             schedule_tapeblock_exec_IO(ti);
 652             break;
 653 #endif
 654         default:
 655             tapestate_set(ti,TS_NOT_OPER);
 656             wake_up_interruptible (&ti->wq);
 657         }
 658     } else {
 659         // device is unused!
 660         PRINT_WARN ("Tape #%d was detached.\n",ti->blk_minor/2);
 661         if (ti==first_tape_info) {
 662             first_tape_info=ti->next;
 663         } else {
 664             lastti=first_tape_info;
 665             while (lastti->next!=ti) lastti=lastti->next;
 666             lastti->next=ti->next;
 667         }
 668 #ifdef CONFIG_DEVFS_FS
 669         for (frontend=first_frontend;frontend!=NULL;frontend=frontend->next)
 670             frontend->rmdevfstree(ti);
 671         tape_rmdevfsroots(ti);
 672 #endif
 673         kfree(ti);
 674     }
 675     s390irq_spin_unlock_irqrestore(irq,lockflags);
 676     return;
 677 }
 678
 679
 680 void
 681 tape_dump_sense (devstat_t * stat)
 682 {
 683 #ifdef TAPE_DEBUG
 684         int sl;
 685 #endif
 686 #if 0
 687
 688         PRINT_WARN ("------------I/O resulted in unit check:-----------\n");
 689         for (sl = 0; sl < 4; sl++) {
 690                 PRINT_WARN ("Sense:");
 691                 for (sct = 0; sct < 8; sct++) {
 692                         PRINT_WARN (" %2d:0x%02X", 8 * sl + sct,
 693                                     stat->ii.sense.data[8 * sl + sct]);
 694                 }
 695                 PRINT_WARN ("\n");
 696         }
 697         PRINT_INFO ("Sense data: %02X%02X%02X%02X %02X%02X%02X%02X "
 698                     " %02X%02X%02X%02X %02X%02X%02X%02X \n",
 699                     stat->ii.sense.data[0], stat->ii.sense.data[1],
 700                     stat->ii.sense.data[2], stat->ii.sense.data[3],
 701                     stat->ii.sense.data[4], stat->ii.sense.data[5],
 702                     stat->ii.sense.data[6], stat->ii.sense.data[7],
 703                     stat->ii.sense.data[8], stat->ii.sense.data[9],
 704                     stat->ii.sense.data[10], stat->ii.sense.data[11],
 705                     stat->ii.sense.data[12], stat->ii.sense.data[13],
 706                     stat->ii.sense.data[14], stat->ii.sense.data[15]);
 707         PRINT_INFO ("Sense data: %02X%02X%02X%02X %02X%02X%02X%02X "
 708                     " %02X%02X%02X%02X %02X%02X%02X%02X \n",
 709                     stat->ii.sense.data[16], stat->ii.sense.data[17],
 710                     stat->ii.sense.data[18], stat->ii.sense.data[19],
 711                     stat->ii.sense.data[20], stat->ii.sense.data[21],
 712                     stat->ii.sense.data[22], stat->ii.sense.data[23],
 713                     stat->ii.sense.data[24], stat->ii.sense.data[25],
 714                     stat->ii.sense.data[26], stat->ii.sense.data[27],
 715                     stat->ii.sense.data[28], stat->ii.sense.data[29],
 716                     stat->ii.sense.data[30], stat->ii.sense.data[31]);
 717 #endif
 718 #ifdef TAPE_DEBUG
 719         debug_text_event (tape_debug_area,3,"SENSE:");
 720         for (sl=0;sl<31;sl++) {
 721             debug_int_event (tape_debug_area,3,stat->ii.sense.data[sl]);
 722         }
 723         debug_int_exception (tape_debug_area,3,stat->ii.sense.data[31]);
 724 #endif
 725 }
 726
 727 /*
 728  * Setup tape_info_t structure of a tape device
 729  */
 730 int
 731 tape_setup (tape_info_t * ti, int irq, int minor)
 732 {
 733         long lockflags;
 734         int rc = 0;
 735
 736         if (minor>254) {
 737             PRINT_WARN ("Device id %d on irq %d will not be accessible since this driver is restricted to 128 devices.\n",minor/2,irq);
 738             return -EINVAL;
 739         }
 740         rc = get_dev_info_by_irq (irq, &(ti->devinfo));
 741         if (rc == -ENODEV) {    /* end of device list */
 742                 return rc;
 743         }
 744         ti->rew_minor = minor;
 745         ti->nor_minor = minor + 1;
 746         ti->blk_minor = minor;
 747 #ifdef CONFIG_DEVFS_FS
 748         tape_mkdevfsroots(ti);
 749 #endif
 750         /* Register IRQ */
 751 #ifdef CONFIG_S390_TAPE_DYNAMIC
 752         rc = s390_request_irq_special (irq, tape_irq, tape_noper_handler,0, "tape", &(ti->devstat));
 753 #else
 754         rc = s390_request_irq (irq, tape_irq, 0, "tape", &(ti->devstat));
 755 #endif
 756         s390irq_spin_lock_irqsave (irq, lockflags);
 757         ti->next = NULL;
 758         if (rc)
 759             PRINT_WARN ("Cannot register irq %d, rc=%d\n", irq, rc);
 760         init_waitqueue_head (&ti->wq);
 761         ti->kernbuf = ti->userbuf = ti->discdata = NULL;
 762         tapestate_set (ti, TS_UNUSED);
 763         ti->discdata=NULL;
 764         ti->discipline->setup_assist (ti);
 765         ti->wanna_wakeup=0;
 766         s390irq_spin_unlock_irqrestore (irq, lockflags);
 767         return rc;
 768 }
 769
 770 /*
 771  *      tape_init will register the driver for each tape.
 772  */
 773 int
 774 tape_init (void)
 775 {
 776         long lockflags;
 777         s390_dev_info_t dinfo;
 778         tape_discipline_t *disc;
 779         tape_info_t *ti = NULL, *tempti = NULL;
 780         char *opt_char,*opt_block,*opt_3490,*opt_3480;
 781         int irq = 0, rc, retries = 0, tape_num = 0;
 782         static int initialized=0;
 783
 784         if (initialized) // Only init the devices once
 785             return 0;
 786         initialized=1;
 787
 788 #ifdef TAPE_DEBUG
 789         tape_debug_area = debug_register ( "tape", 3, 2, 10);
 790         debug_register_view(tape_debug_area,&debug_hex_ascii_view);
 791         debug_text_event (tape_debug_area,3,"begin init");
 792 #endif /* TAPE_DEBUG */
 793
 794         /* print banner */
 795         PRINT_WARN ("IBM S/390 Tape Device Driver (v1.01).\n");
 796         PRINT_WARN ("(C) IBM Deutschland Entwicklung GmbH, 2000\n");
 797         opt_char=opt_block=opt_3480=opt_3490="not present";
 798 #ifdef CONFIG_S390_TAPE_CHAR
 799         opt_char="built in";
 800 #endif
 801 #ifdef CONFIG_S390_TAPE_BLOCK
 802         opt_block="built in";
 803 #endif
 804 #ifdef CONFIG_S390_TAPE_3480
 805         opt_3480="built in";
 806 #endif
 807 #ifdef CONFIG_S390_TAPE_3490
 808         opt_3490="built in";
 809 #endif
 810         /* print feature info */
 811         PRINT_WARN ("character device frontend   : %s\n",opt_char);
 812         PRINT_WARN ("block device frontend       : %s\n",opt_block);
 813         PRINT_WARN ("support for 3480 compatible : %s\n",opt_3480);
 814         PRINT_WARN ("support for 3490 compatible : %s\n",opt_3490);
 815
 816 #ifndef MODULE
 817         tape_split_parm_string(tape_parm_string);
 818 #endif
 819         if (*tape)
 820             PRINT_INFO ("Using ranges supplied in parameters, disabling autoprobe mode.\n");
 821         else
 822             PRINT_INFO ("No parameters supplied, enabling autoprobe mode for all supported devices.\n");
 823 #ifdef CONFIG_S390_TAPE_3490
 824         if (*tape)
 825             first_discipline = tape3490_init (0); // no autoprobe for devices
 826         else
 827             first_discipline = tape3490_init (1); // do autoprobe since no parm specified
 828         first_discipline->next = NULL;
 829 #endif
 830
 831 #ifdef CONFIG_S390_TAPE_3480
 832         if (first_discipline == NULL) {
 833             if (*tape)
 834                 first_discipline = tape3480_init (0); // no autoprobe for devices
 835             else
 836                 first_discipline = tape3480_init (1); // do autoprobe since no parm specified
 837             first_discipline->next = NULL;
 838         } else {
 839             if (*tape)
 840                 first_discipline->next = tape3480_init (0); // no autoprobe for devices
 841             else
 842                 first_discipline->next = tape3480_init (1); // do autoprobe since no parm specified
 843             ((tape_discipline_t*) (first_discipline->next))->next=NULL;
 844         }
 845 #endif
 846 #ifdef CONFIG_DEVFS_FS
 847         tape_devfs_root_entry=devfs_mk_dir (NULL, "tape", NULL);
 848 #endif CONFIG_DEVFS_FS
 849
 850 #ifdef TAPE_DEBUG
 851         debug_text_event (tape_debug_area,3,"dev detect");
 852 #endif /* TAPE_DEBUG */
 853         /* Allocate the tape structures */
 854         if (*tape!=NULL) {
 855             // we have parameters, continue with parsing the parameters and set the devices online
 856             tape_parm_parse (tape);
 857         } else {
 858             // we are running in autodetect mode, search all devices for compatibles
 859             for (irq = get_irq_first(); irq!=-ENODEV; irq=get_irq_next(irq)) {
 860                 rc = get_dev_info_by_irq (irq, &dinfo);
 861                 disc = first_discipline;
 862                 while ((disc != NULL) && (disc->cu_type != dinfo.sid_data.cu_type))
 863                     disc = (tape_discipline_t *) (disc->next);
 864                 if ((disc == NULL) || (rc == -ENODEV))
 865                     continue;
 866 #ifdef TAPE_DEBUG
 867                 debug_text_event (tape_debug_area,3,"det irq:  ");
 868                 debug_int_event (tape_debug_area,3,irq);
 869                 debug_text_event (tape_debug_area,3,"cu:       ");
 870                 debug_int_event (tape_debug_area,3,disc->cu_type);
 871 #endif /* TAPE_DEBUG */
 872                 PRINT_INFO ("using devno %04x with discipline %04x on irq %d as tape device %d\n",dinfo.devno,dinfo.sid_data.cu_type,irq,tape_num/2);
 873                 /* Allocate tape structure  */
 874                 ti = kmalloc (sizeof (tape_info_t), GFP_ATOMIC);
 875                 if (ti == NULL) {
 876 #ifdef TAPE_DEBUG
 877                     debug_text_exception (tape_debug_area,3,"ti:no mem ");
 878 #endif /* TAPE_DEBUG */
 879                     PRINT_INFO ("tape: can't allocate memory for "
 880                                     "tape info structure\n");
 881                     continue;
 882                 }
 883                 memset(ti,0,sizeof(tape_info_t));
 884                 ti->discipline = disc;
 885                 disc->tape = ti;
 886                 rc = tape_setup (ti, irq, tape_num);
 887                 if (rc) {
 888 #ifdef TAPE_DEBUG
 889                     debug_text_event (tape_debug_area,3,"tsetup err");
 890                     debug_int_exception (tape_debug_area,3,rc);
 891 #endif /* TAPE_DEBUG */
 892                     kfree (ti);
 893                 } else {
 894                     s390irq_spin_lock_irqsave (irq, lockflags);
 895                     if (first_tape_info == NULL) {
 896                         first_tape_info = ti;
 897                     } else {
 898                         tempti = first_tape_info;
 899                         while (tempti->next != NULL)
 900                             tempti = tempti->next;
 901                         tempti->next = ti;
 902                     }
 903                     tape_num += 2;
 904                     s390irq_spin_unlock_irqrestore (irq, lockflags);
 905                 }
 906             }
 907         }
 908
 909         /* Allocate local buffer for the ccwcache       */
 910         tape_init_emergency_req ();
 911 #ifdef CONFIG_PROC_FS
 912 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,3,98))
 913         tape_devices_entry = create_proc_entry ("tapedevices",
 914                                                 S_IFREG | S_IRUGO | S_IWUSR,
 915                                                 &proc_root);
 916         tape_devices_entry->proc_fops = &tape_devices_file_ops;
 917         tape_devices_entry->proc_iops = &tape_devices_inode_ops;
 918 #else
 919         tape_devices_entry = (struct proc_dir_entry *) kmalloc
 920             (sizeof (struct proc_dir_entry), GFP_ATOMIC);
 921         if (tape_devices_entry) {
 922             memset (tape_devices_entry, 0, sizeof (struct proc_dir_entry));
 923             tape_devices_entry->name = "tapedevices";
 924             tape_devices_entry->namelen = strlen ("tapedevices");
 925             tape_devices_entry->low_ino = 0;
 926             tape_devices_entry->mode = (S_IFREG | S_IRUGO | S_IWUSR);
 927             tape_devices_entry->nlink = 1;
 928             tape_devices_entry->uid = 0;
 929             tape_devices_entry->gid = 0;
 930             tape_devices_entry->size = 0;
 931             tape_devices_entry->get_info = NULL;
 932             tape_devices_entry->ops = &tape_devices_inode_ops;
 933             proc_register (&proc_root, tape_devices_entry);
 934         }
 935 #endif
 936 #endif /* CONFIG_PROC_FS */
 937
 938         return 0;
 939 }
 940
 941 #ifdef MODULE
 942 MODULE_AUTHOR("(C) 2001 IBM Deutschland Entwicklung GmbH by Carsten Otte (cotte@de.ibm.com)");
 943 MODULE_DESCRIPTION("Linux for S/390 channel attached tape device driver");
 944 MODULE_PARM (tape, "1-" __MODULE_STRING (256) "s");
 945
 946 int
 947 init_module (void)
 948 {
 949 #ifdef CONFIG_S390_TAPE_CHAR
 950         tapechar_init ();
 951 #endif
 952 #ifdef CONFIG_S390_TAPE_BLOCK
 953         tapeblock_init ();
 954 #endif
 955         return 0;
 956 }
 957
 958 void
 959 cleanup_module (void)
 960 {
 961         tape_info_t *ti ,*temp;
 962         tape_frontend_t* frontend, *tempfe;
 963         tape_discipline_t* disc ,*tempdi;
 964         int i;
 965 #ifdef TAPE_DEBUG
 966         debug_text_event (tape_debug_area,6,"cleaup mod");
 967 #endif /* TAPE_DEBUG */
 968
 969         if (*tape) {
 970             // we are running with parameters. we'll now deregister from our devno's
 971             for (i=0;i<devregct;i++) {
 972                 s390_device_unregister(tape_devreg[devregct]);
 973             }
 974         }
 975         ti = first_tape_info;
 976         while (ti != NULL) {
 977                 temp = ti;
 978                 ti = ti->next;
 979                 //cleanup a device
 980 #ifdef TAPE_DEBUG
 981                 debug_text_event (tape_debug_area,6,"free irq:");
 982                 debug_int_event (tape_debug_area,6,temp->devinfo.irq);
 983 #endif /* TAPE_DEBUG */
 984                 free_irq (temp->devinfo.irq, &(temp->devstat));
 985                 if (temp->discdata) kfree (temp->discdata);
 986                 if (temp->kernbuf) kfree (temp->kernbuf);
 987                 if (temp->cqr) tape_free_request(temp->cqr);
 988 #ifdef CONFIG_DEVFS_FS
 989                 for (frontend=first_frontend;frontend!=NULL;frontend=frontend->next)
 990                     frontend->rmdevfstree(temp);
 991                 tape_rmdevfsroots(temp);
 992 #endif
 993                 kfree (temp);
 994         }
 995 #ifdef CONFIG_DEVFS_FS
 996         devfs_unregister (tape_devfs_root_entry);
 997 #endif CONFIG_DEVFS_FS
 998 #ifdef CONFIG_PROC_FS
 999 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,3,98))
1000         remove_proc_entry ("tapedevices", &proc_root);
1001 #else
1002         proc_unregister (&proc_root, tape_devices_entry->low_ino);
1003         kfree (tape_devices_entry);
1004 #endif                          /* LINUX_IS_24 */
1005 #endif
1006 #ifdef CONFIG_S390_TAPE_CHAR
1007         tapechar_uninit();
1008 #endif
1009 #ifdef CONFIG_S390_TAPE_BLOCK
1010         tapeblock_uninit();
1011 #endif
1012         frontend=first_frontend;
1013         while (frontend != NULL) {
1014                 tempfe = frontend;
1015                 frontend = frontend->next;
1016                 kfree (tempfe);
1017         }
1018         disc=first_discipline;
1019         while (disc != NULL) {
1020                 if (*tape)
1021                     disc->shutdown(0);
1022                 else
1023                     disc->shutdown(1);
1024                 tempdi = disc;
1025                 disc = disc->next;
1026                 kfree (tempdi);
1027         }
1028         /* Deallocate the local buffer for the ccwcache         */
1029         tape_cleanup_emergency_req ();
1030 #ifdef TAPE_DEBUG
1031         debug_unregister (tape_debug_area);
1032 #endif /* TAPE_DEBUG */
1033 }
1034 #endif                          /* MODULE */
1035
1036 inline void
1037 tapestate_set (tape_info_t * ti, int newstate)
1038 {
1039     if (ti->tape_state == TS_NOT_OPER) {
1040 #ifdef TAPE_DEBUG
1041         debug_text_event (tape_debug_area,3,"ts_set err");
1042         debug_text_exception (tape_debug_area,3,"dev n.oper");
1043 #endif /* TAPE_DEBUG */
1044     } else {
1045 #ifdef TAPE_DEBUG
1046         debug_text_event (tape_debug_area,4,"ts. dev:  ");
1047         debug_int_event (tape_debug_area,4,ti->blk_minor);
1048         debug_text_event (tape_debug_area,4,"old ts:   ");
1049         debug_text_event (tape_debug_area,4,(((tapestate_get (ti) < TS_SIZE) &&
1050                                              (tapestate_get (ti) >=0 )) ?
1051                                             state_verbose[tapestate_get (ti)] :
1052                                             "UNKNOWN TS"));
1053         debug_text_event (tape_debug_area,4,"new ts:   ");
1054         debug_text_event (tape_debug_area,4,(((newstate < TS_SIZE) &&
1055                                               (newstate >= 0)) ?
1056                                              state_verbose[newstate] :
1057                                              "UNKNOWN TS"));
1058 #endif /* TAPE_DEBUG */
1059         ti->tape_state = newstate;
1060     }
1061 }
1062
1063 inline int
1064 tapestate_get (tape_info_t * ti)
1065 {
1066         return (ti->tape_state);
1067 }
1068
1069 void
1070 tapestate_event (tape_info_t * ti, int event)
1071 {
1072 #ifdef TAPE_DEBUG
1073         debug_text_event (tape_debug_area,6,"te! dev:  ");
1074         debug_int_event (tape_debug_area,6,ti->blk_minor);
1075         debug_text_event (tape_debug_area,6,"event:");
1076         debug_text_event (tape_debug_area,6,((event >=0) &&
1077                                             (event < TE_SIZE)) ?
1078                          event_verbose[event] : "TE UNKNOWN");
1079         debug_text_event (tape_debug_area,6,"state:");
1080         debug_text_event (tape_debug_area,6,((tapestate_get(ti) >= 0) &&
1081                                             (tapestate_get(ti) < TS_SIZE)) ?
1082                          state_verbose[tapestate_get (ti)] :
1083                          "TS UNKNOWN");
1084 #endif /* TAPE_DEBUG */
1085         if (event == TE_ERROR) {
1086             ti->discipline->error_recovery(ti);
1087         } else {
1088             if ((event >= 0) &&
1089                 (event < TE_SIZE) &&
1090                 (tapestate_get (ti) >= 0) &&
1091                 (tapestate_get (ti) < TS_SIZE) &&
1092                 ((*(ti->discipline->event_table))[tapestate_get (ti)][event] != NULL))
1093                 ((*(ti->discipline->event_table))[tapestate_get (ti)][event]) (ti);
1094             else {
1095 #ifdef TAPE_DEBUG
1096                 debug_text_exception (tape_debug_area,3,"TE UNEXPEC");
1097 #endif /* TAPE_DEBUG */
1098                 ti->discipline->default_handler (ti);
1099             }
1100         }
1101 }
1102
1103 /*
1104  * Overrides for Emacs so that we follow Linus's tabbing style.
1105  * Emacs will notice this stuff at the end of the file and automatically
1106  * adjust the settings for this buffer only.  This must remain at the end
1107  * of the file.
1108  * ---------------------------------------------------------------------------
1109  * Local variables:
1110  * c-indent-level: 4
1111  * c-brace-imaginary-offset: 0
1112  * c-brace-offset: -4
1113  * c-argdecl-indent: 4
1114  * c-label-offset: -4
1115  * c-continued-statement-offset: 4
1116  * c-continued-brace-offset: 0
1117  * indent-tabs-mode: nil
1118  * tab-width: 8
1119  * End:
1120  */