SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/s390/block/dasd_devmap.c

   1 /*
   2  * File...........: linux/drivers/s390/block/dasd_devmap.c
   3  * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
   4  *                  Horst Hummel <Horst.Hummel@de.ibm.com>
   5  *                  Carsten Otte <Cotte@de.ibm.com>
   6  *                  Martin Schwidefsky <schwidefsky@de.ibm.com>
   7  * Bugreports.to..: <Linux390@de.ibm.com>
   8  * (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 1999-2001
   9  *
  10  * Device mapping and dasd= parameter parsing functions. All devmap
  11  * functions may not be called from interrupt context. In particular
  12  * dasd_get_device is a no-no from interrupt context.
  13  *
  14  */
  15
  16 #include <linux/config.h>
  17 #include <linux/ctype.h>
  18 #include <linux/init.h>
  19 #include <linux/module.h>
  20
  21 #include <asm/debug.h>
  22 #include <asm/uaccess.h>
  23
  24 /* This is ugly... */
  25 #define PRINTK_HEADER "dasd_devmap:"
  26
  27 #include "dasd_int.h"
  28
  29 kmem_cache_t *dasd_page_cache;
  30 EXPORT_SYMBOL(dasd_page_cache);
  31
  32 /*
  33  * dasd_devmap_t is used to store the features and the relation
  34  * between device number and device index. To find a dasd_devmap_t
  35  * that corresponds to a device number of a device index each
  36  * dasd_devmap_t is added to two linked lists, one to search by
  37  * the device number and one to search by the device index. As
  38  * soon as big minor numbers are available the device index list
  39  * can be removed since the device number will then be identical
  40  * to the device index.
  41  */
  42 struct dasd_devmap {
  43         struct list_head list;
  44         char bus_id[BUS_ID_SIZE];
  45         unsigned int devindex;
  46         unsigned short features;
  47         struct dasd_device *device;
  48 };
  49
  50 /*
  51  * Parameter parsing functions for dasd= parameter. The syntax is:
  52  *   <devno>            : (0x)?[0-9a-fA-F]+
  53  *   <busid>            : [0-0a-f]\.[0-9a-f]\.(0x)?[0-9a-fA-F]+
  54  *   <feature>          : ro
  55  *   <feature_list>     : \(<feature>(:<feature>)*\)
  56  *   <devno-range>      : <devno>(-<devno>)?<feature_list>?
  57  *   <busid-range>      : <busid>(-<busid>)?<feature_list>?
  58  *   <devices>          : <devno-range>|<busid-range>
  59  *   <dasd_module>      : dasd_diag_mod|dasd_eckd_mod|dasd_fba_mod
  60  *
  61  *   <dasd>             : autodetect|probeonly|<devices>(,<devices>)*
  62  */
  63
  64 int dasd_probeonly =  0;        /* is true, when probeonly mode is active */
  65 int dasd_autodetect = 0;        /* is true, when autodetection is active */
  66
  67 /*
  68  * char *dasd[] is intended to hold the ranges supplied by the dasd= statement
  69  * it is named 'dasd' to directly be filled by insmod with the comma separated
  70  * strings when running as a module.
  71  */
  72 static char *dasd[256];
  73 module_param_array(dasd, charp, NULL, 0);
  74
  75 /*
  76  * Single spinlock to protect devmap structures and lists.
  77  */
  78 static DEFINE_SPINLOCK(dasd_devmap_lock);
  79
  80 /*
  81  * Hash lists for devmap structures.
  82  */
  83 static struct list_head dasd_hashlists[256];
  84 int dasd_max_devindex;
  85
  86 static struct dasd_devmap *dasd_add_busid(char *, int);
  87
  88 static inline int
  89 dasd_hash_busid(char *bus_id)
  90 {
  91         int hash, i;
  92
  93         hash = 0;
  94         for (i = 0; (i < BUS_ID_SIZE) && *bus_id; i++, bus_id++)
  95                 hash += *bus_id;
  96         return hash & 0xff;
  97 }
  98
  99 #ifndef MODULE
 100 /*
 101  * The parameter parsing functions for builtin-drivers are called
 102  * before kmalloc works. Store the pointers to the parameters strings
 103  * into dasd[] for later processing.
 104  */
 105 static int __init
 106 dasd_call_setup(char *str)
 107 {
 108         static int count = 0;
 109
 110         if (count < 256)
 111                 dasd[count++] = str;
 112         return 1;
 113 }
 114
 115 __setup ("dasd=", dasd_call_setup);
 116 #endif  /* #ifndef MODULE */
 117
 118 /*
 119  * Read a device busid/devno from a string.
 120  */
 121 static inline int
 122 dasd_busid(char **str, int *id0, int *id1, int *devno)
 123 {
 124         int val, old_style;
 125
 126         /* check for leading '0x' */
 127         old_style = 0;
 128         if ((*str)[0] == '0' && (*str)[1] == 'x') {
 129                 *str += 2;
 130                 old_style = 1;
 131         }
 132         if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
 133                 return -EINVAL;
 134         val = simple_strtoul(*str, str, 16);
 135         if (old_style || (*str)[0] != '.') {
 136                 *id0 = *id1 = 0;
 137                 if (val < 0 || val > 0xffff)
 138                         return -EINVAL;
 139                 *devno = val;
 140                 return 0;
 141         }
 142         /* New style x.y.z busid */
 143         if (val < 0 || val > 0xff)
 144                 return -EINVAL;
 145         *id0 = val;
 146         (*str)++;
 147         if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
 148                 return -EINVAL;
 149         val = simple_strtoul(*str, str, 16);
 150         if (val < 0 || val > 0xff || (*str)++[0] != '.')
 151                 return -EINVAL;
 152         *id1 = val;
 153         if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
 154                 return -EINVAL;
 155         val = simple_strtoul(*str, str, 16);
 156         if (val < 0 || val > 0xffff)
 157                 return -EINVAL;
 158         *devno = val;
 159         return 0;
 160 }
 161
 162 /*
 163  * Read colon separated list of dasd features. Currently there is
 164  * only one: "ro" for read-only devices. The default feature set
 165  * is empty (value 0).
 166  */
 167 static inline int
 168 dasd_feature_list(char *str, char **endp)
 169 {
 170         int features, len, rc;
 171
 172         rc = 0;
 173         if (*str != '(') {
 174                 *endp = str;
 175                 return DASD_FEATURE_DEFAULT;
 176         }
 177         str++;
 178         features = 0;
 179
 180         while (1) {
 181                 for (len = 0;
 182                      str[len] && str[len] != ':' && str[len] != ')'; len++);
 183                 if (len == 2 && !strncmp(str, "ro", 2))
 184                         features |= DASD_FEATURE_READONLY;
 185                 else if (len == 4 && !strncmp(str, "diag", 4))
 186                         features |= DASD_FEATURE_USEDIAG;
 187                 else {
 188                         MESSAGE(KERN_WARNING,
 189                                 "unsupported feature: %*s, "
 190                                 "ignoring setting", len, str);
 191                         rc = -EINVAL;
 192                 }
 193                 str += len;
 194                 if (*str != ':')
 195                         break;
 196                 str++;
 197         }
 198         if (*str != ')') {
 199                 MESSAGE(KERN_WARNING, "%s",
 200                         "missing ')' in dasd parameter string\n");
 201                 rc = -EINVAL;
 202         } else
 203                 str++;
 204         *endp = str;
 205         if (rc != 0)
 206                 return rc;
 207         return features;
 208 }
 209
 210 /*
 211  * Try to match the first element on the comma separated parse string
 212  * with one of the known keywords. If a keyword is found, take the approprate
 213  * action and return a pointer to the residual string. If the first element
 214  * could not be matched to any keyword then return an error code.
 215  */
 216 static char *
 217 dasd_parse_keyword( char *parsestring ) {
 218
 219         char *nextcomma, *residual_str;
 220         int length;
 221
 222         nextcomma = strchr(parsestring,',');
 223         if (nextcomma) {
 224                 length = nextcomma - parsestring;
 225                 residual_str = nextcomma + 1;
 226         } else {
 227                 length = strlen(parsestring);
 228                 residual_str = parsestring + length;
 229         }
 230         if (strncmp ("autodetect", parsestring, length) == 0) {
 231                 dasd_autodetect = 1;
 232                 MESSAGE (KERN_INFO, "%s",
 233                          "turning to autodetection mode");
 234                 return residual_str;
 235         }
 236         if (strncmp ("probeonly", parsestring, length) == 0) {
 237                 dasd_probeonly = 1;
 238                 MESSAGE(KERN_INFO, "%s",
 239                         "turning to probeonly mode");
 240                 return residual_str;
 241         }
 242         if (strncmp ("fixedbuffers", parsestring, length) == 0) {
 243                 if (dasd_page_cache)
 244                         return residual_str;
 245                 dasd_page_cache =
 246                         kmem_cache_create("dasd_page_cache", PAGE_SIZE, 0,
 247                                           SLAB_CACHE_DMA, NULL, NULL );
 248                 if (!dasd_page_cache)
 249                         MESSAGE(KERN_WARNING, "%s", "Failed to create slab, "
 250                                 "fixed buffer mode disabled.");
 251                 else
 252                         MESSAGE (KERN_INFO, "%s",
 253                                  "turning on fixed buffer mode");
 254                 return residual_str;
 255         }
 256         return ERR_PTR(-EINVAL);
 257 }
 258
 259 /*
 260  * Try to interprete the first element on the comma separated parse string
 261  * as a device number or a range of devices. If the interpretation is
 262  * successfull, create the matching dasd_devmap entries and return a pointer
 263  * to the residual string.
 264  * If interpretation fails or in case of an error, return an error code.
 265  */
 266 static char *
 267 dasd_parse_range( char *parsestring ) {
 268
 269         struct dasd_devmap *devmap;
 270         int from, from_id0, from_id1;
 271         int to, to_id0, to_id1;
 272         int features, rc;
 273         char bus_id[BUS_ID_SIZE+1], *str;
 274
 275         str = parsestring;
 276         rc = dasd_busid(&str, &from_id0, &from_id1, &from);
 277         if (rc == 0) {
 278                 to = from;
 279                 to_id0 = from_id0;
 280                 to_id1 = from_id1;
 281                 if (*str == '-') {
 282                         str++;
 283                         rc = dasd_busid(&str, &to_id0, &to_id1, &to);
 284                 }
 285         }
 286         if (rc == 0 &&
 287             (from_id0 != to_id0 || from_id1 != to_id1 || from > to))
 288                 rc = -EINVAL;
 289         if (rc) {
 290                 MESSAGE(KERN_ERR, "Invalid device range %s", parsestring);
 291                 return ERR_PTR(rc);
 292         }
 293         features = dasd_feature_list(str, &str);
 294         if (features < 0)
 295                 return ERR_PTR(-EINVAL);
 296         while (from <= to) {
 297                 sprintf(bus_id, "%01x.%01x.%04x",
 298                         from_id0, from_id1, from++);
 299                 devmap = dasd_add_busid(bus_id, features);
 300                 if (IS_ERR(devmap))
 301                         return (char *)devmap;
 302         }
 303         if (*str == ',')
 304                 return str + 1;
 305         if (*str == '\0')
 306                 return str;
 307         MESSAGE(KERN_WARNING,
 308                 "junk at end of dasd parameter string: %s\n", str);
 309         return ERR_PTR(-EINVAL);
 310 }
 311
 312 static inline char *
 313 dasd_parse_next_element( char *parsestring ) {
 314         char * residual_str;
 315         residual_str = dasd_parse_keyword(parsestring);
 316         if (!IS_ERR(residual_str))
 317                 return residual_str;
 318         residual_str = dasd_parse_range(parsestring);
 319         return residual_str;
 320 }
 321
 322 /*
 323  * Parse parameters stored in dasd[]
 324  * The 'dasd=...' parameter allows to specify a comma separated list of
 325  * keywords and device ranges. When the dasd driver is build into the kernel,
 326  * the complete list will be stored as one element of the dasd[] array.
 327  * When the dasd driver is build as a module, then the list is broken into
 328  * it's elements and each dasd[] entry contains one element.
 329  */
 330 int
 331 dasd_parse(void)
 332 {
 333         int rc, i;
 334         char *parsestring;
 335
 336         rc = 0;
 337         for (i = 0; i < 256; i++) {
 338                 if (dasd[i] == NULL)
 339                         break;
 340                 parsestring = dasd[i];
 341                 /* loop over the comma separated list in the parsestring */
 342                 while (*parsestring) {
 343                         parsestring = dasd_parse_next_element(parsestring);
 344                         if(IS_ERR(parsestring)) {
 345                                 rc = PTR_ERR(parsestring);
 346                                 break;
 347                         }
 348                 }
 349                 if (rc) {
 350                         DBF_EVENT(DBF_ALERT, "%s", "invalid range found");
 351                         break;
 352                 }
 353         }
 354         return rc;
 355 }
 356
 357 /*
 358  * Add a devmap for the device specified by busid. It is possible that
 359  * the devmap already exists (dasd= parameter). The order of the devices
 360  * added through this function will define the kdevs for the individual
 361  * devices.
 362  */
 363 static struct dasd_devmap *
 364 dasd_add_busid(char *bus_id, int features)
 365 {
 366         struct dasd_devmap *devmap, *new, *tmp;
 367         int hash;
 368
 369         new = (struct dasd_devmap *)
 370                 kmalloc(sizeof(struct dasd_devmap), GFP_KERNEL);
 371         if (!new)
 372                 return ERR_PTR(-ENOMEM);
 373         spin_lock(&dasd_devmap_lock);
 374         devmap = 0;
 375         hash = dasd_hash_busid(bus_id);
 376         list_for_each_entry(tmp, &dasd_hashlists[hash], list)
 377                 if (strncmp(tmp->bus_id, bus_id, BUS_ID_SIZE) == 0) {
 378                         devmap = tmp;
 379                         break;
 380                 }
 381         if (!devmap) {
 382                 /* This bus_id is new. */
 383                 new->devindex = dasd_max_devindex++;
 384                 strncpy(new->bus_id, bus_id, BUS_ID_SIZE);
 385                 new->features = features;
 386                 new->device = 0;
 387                 list_add(&new->list, &dasd_hashlists[hash]);
 388                 devmap = new;
 389                 new = 0;
 390         }
 391         spin_unlock(&dasd_devmap_lock);
 392         kfree(new);
 393         return devmap;
 394 }
 395
 396 /*
 397  * Find devmap for device with given bus_id.
 398  */
 399 static struct dasd_devmap *
 400 dasd_find_busid(char *bus_id)
 401 {
 402         struct dasd_devmap *devmap, *tmp;
 403         int hash;
 404
 405         spin_lock(&dasd_devmap_lock);
 406         devmap = ERR_PTR(-ENODEV);
 407         hash = dasd_hash_busid(bus_id);
 408         list_for_each_entry(tmp, &dasd_hashlists[hash], list) {
 409                 if (strncmp(tmp->bus_id, bus_id, BUS_ID_SIZE) == 0) {
 410                         devmap = tmp;
 411                         break;
 412                 }
 413         }
 414         spin_unlock(&dasd_devmap_lock);
 415         return devmap;
 416 }
 417
 418 /*
 419  * Check if busid has been added to the list of dasd ranges.
 420  */
 421 int
 422 dasd_busid_known(char *bus_id)
 423 {
 424         return IS_ERR(dasd_find_busid(bus_id)) ? -ENOENT : 0;
 425 }
 426
 427 /*
 428  * Forget all about the device numbers added so far.
 429  * This may only be called at module unload or system shutdown.
 430  */
 431 static void
 432 dasd_forget_ranges(void)
 433 {
 434         struct dasd_devmap *devmap, *n;
 435         int i;
 436
 437         spin_lock(&dasd_devmap_lock);
 438         for (i = 0; i < 256; i++) {
 439                 list_for_each_entry_safe(devmap, n, &dasd_hashlists[i], list) {
 440                         if (devmap->device != NULL)
 441                                 BUG();
 442                         list_del(&devmap->list);
 443                         kfree(devmap);
 444                 }
 445         }
 446         spin_unlock(&dasd_devmap_lock);
 447 }
 448
 449 /*
 450  * Find the device struct by its device index.
 451  */
 452 struct dasd_device *
 453 dasd_device_from_devindex(int devindex)
 454 {
 455         struct dasd_devmap *devmap, *tmp;
 456         struct dasd_device *device;
 457         int i;
 458
 459         spin_lock(&dasd_devmap_lock);
 460         devmap = 0;
 461         for (i = 0; (i < 256) && !devmap; i++)
 462                 list_for_each_entry(tmp, &dasd_hashlists[i], list)
 463                         if (tmp->devindex == devindex) {
 464                                 /* Found the devmap for the device. */
 465                                 devmap = tmp;
 466                                 break;
 467                         }
 468         if (devmap && devmap->device) {
 469                 device = devmap->device;
 470                 dasd_get_device(device);
 471         } else
 472                 device = ERR_PTR(-ENODEV);
 473         spin_unlock(&dasd_devmap_lock);
 474         return device;
 475 }
 476
 477 /*
 478  * Return devmap for cdev. If no devmap exists yet, create one and
 479  * connect it to the cdev.
 480  */
 481 static struct dasd_devmap *
 482 dasd_devmap_from_cdev(struct ccw_device *cdev)
 483 {
 484         struct dasd_devmap *devmap;
 485
 486         devmap = dasd_find_busid(cdev->dev.bus_id);
 487         if (IS_ERR(devmap))
 488                 devmap = dasd_add_busid(cdev->dev.bus_id,
 489                                         DASD_FEATURE_DEFAULT);
 490         return devmap;
 491 }
 492
 493 /*
 494  * Create a dasd device structure for cdev.
 495  */
 496 struct dasd_device *
 497 dasd_create_device(struct ccw_device *cdev)
 498 {
 499         struct dasd_devmap *devmap;
 500         struct dasd_device *device;
 501         int rc;
 502
 503         devmap = dasd_devmap_from_cdev(cdev);
 504         if (IS_ERR(devmap))
 505                 return (void *) devmap;
 506         cdev->dev.driver_data = devmap;
 507
 508         device = dasd_alloc_device();
 509         if (IS_ERR(device))
 510                 return device;
 511         atomic_set(&device->ref_count, 2);
 512
 513         spin_lock(&dasd_devmap_lock);
 514         if (!devmap->device) {
 515                 devmap->device = device;
 516                 device->devindex = devmap->devindex;
 517                 device->features = devmap->features;
 518                 get_device(&cdev->dev);
 519                 device->cdev = cdev;
 520                 rc = 0;
 521         } else
 522                 /* Someone else was faster. */
 523                 rc = -EBUSY;
 524         spin_unlock(&dasd_devmap_lock);
 525
 526         if (rc) {
 527                 dasd_free_device(device);
 528                 return ERR_PTR(rc);
 529         }
 530         return device;
 531 }
 532
 533 /*
 534  * Wait queue for dasd_delete_device waits.
 535  */
 536 static DECLARE_WAIT_QUEUE_HEAD(dasd_delete_wq);
 537
 538 /*
 539  * Remove a dasd device structure. The passed referenced
 540  * is destroyed.
 541  */
 542 void
 543 dasd_delete_device(struct dasd_device *device)
 544 {
 545         struct ccw_device *cdev;
 546         struct dasd_devmap *devmap;
 547
 548         /* First remove device pointer from devmap. */
 549         devmap = dasd_find_busid(device->cdev->dev.bus_id);
 550         if (IS_ERR(devmap))
 551                 BUG();
 552         spin_lock(&dasd_devmap_lock);
 553         if (devmap->device != device) {
 554                 spin_unlock(&dasd_devmap_lock);
 555                 dasd_put_device(device);
 556                 return;
 557         }
 558         devmap->device = NULL;
 559         spin_unlock(&dasd_devmap_lock);
 560
 561         /* Drop ref_count by 2, one for the devmap reference and
 562          * one for the passed reference. */
 563         atomic_sub(2, &device->ref_count);
 564
 565         /* Wait for reference counter to drop to zero. */
 566         wait_event(dasd_delete_wq, atomic_read(&device->ref_count) == 0);
 567
 568         /* Disconnect dasd_device structure from ccw_device structure. */
 569         cdev = device->cdev;
 570         device->cdev = NULL;
 571
 572         /* Disconnect dasd_devmap structure from ccw_device structure. */
 573         cdev->dev.driver_data = NULL;
 574
 575         /* Put ccw_device structure. */
 576         put_device(&cdev->dev);
 577
 578         /* Now the device structure can be freed. */
 579         dasd_free_device(device);
 580 }
 581
 582 /*
 583  * Reference counter dropped to zero. Wake up waiter
 584  * in dasd_delete_device.
 585  */
 586 void
 587 dasd_put_device_wake(struct dasd_device *device)
 588 {
 589         wake_up(&dasd_delete_wq);
 590 }
 591
 592 /*
 593  * Return dasd_device structure associated with cdev.
 594  */
 595 struct dasd_device *
 596 dasd_device_from_cdev(struct ccw_device *cdev)
 597 {
 598         struct dasd_devmap *devmap;
 599         struct dasd_device *device;
 600
 601         device = ERR_PTR(-ENODEV);
 602         spin_lock(&dasd_devmap_lock);
 603         devmap = cdev->dev.driver_data;
 604         if (devmap && devmap->device) {
 605                 device = devmap->device;
 606                 dasd_get_device(device);
 607         }
 608         spin_unlock(&dasd_devmap_lock);
 609         return device;
 610 }
 611
 612 /*
 613  * SECTION: files in sysfs
 614  */
 615
 616 /*
 617  * readonly controls the readonly status of a dasd
 618  */
 619 static ssize_t
 620 dasd_ro_show(struct device *dev, struct device_attribute *attr, char *buf)
 621 {
 622         struct dasd_devmap *devmap;
 623         int ro_flag;
 624
 625         devmap = dasd_find_busid(dev->bus_id);
 626         if (!IS_ERR(devmap))
 627                 ro_flag = (devmap->features & DASD_FEATURE_READONLY) != 0;
 628         else
 629                 ro_flag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_READONLY) != 0;
 630         return snprintf(buf, PAGE_SIZE, ro_flag ? "1\n" : "0\n");
 631 }
 632
 633 static ssize_t
 634 dasd_ro_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 635 {
 636         struct dasd_devmap *devmap;
 637         int ro_flag;
 638
 639         devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
 640         if (IS_ERR(devmap))
 641                 return PTR_ERR(devmap);
 642         ro_flag = buf[0] == '1';
 643         spin_lock(&dasd_devmap_lock);
 644         if (ro_flag)
 645                 devmap->features |= DASD_FEATURE_READONLY;
 646         else
 647                 devmap->features &= ~DASD_FEATURE_READONLY;
 648         if (devmap->device)
 649                 devmap->device->features = devmap->features;
 650         if (devmap->device && devmap->device->gdp)
 651                 set_disk_ro(devmap->device->gdp, ro_flag);
 652         spin_unlock(&dasd_devmap_lock);
 653         return count;
 654 }
 655
 656 static DEVICE_ATTR(readonly, 0644, dasd_ro_show, dasd_ro_store);
 657
 658 /*
 659  * use_diag controls whether the driver should use diag rather than ssch
 660  * to talk to the device
 661  */
 662 static ssize_t
 663 dasd_use_diag_show(struct device *dev, struct device_attribute *attr, char *buf)
 664 {
 665         struct dasd_devmap *devmap;
 666         int use_diag;
 667
 668         devmap = dasd_find_busid(dev->bus_id);
 669         if (!IS_ERR(devmap))
 670                 use_diag = (devmap->features & DASD_FEATURE_USEDIAG) != 0;
 671         else
 672                 use_diag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_USEDIAG) != 0;
 673         return sprintf(buf, use_diag ? "1\n" : "0\n");
 674 }
 675
 676 static ssize_t
 677 dasd_use_diag_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 678 {
 679         struct dasd_devmap *devmap;
 680         ssize_t rc;
 681         int use_diag;
 682
 683         devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
 684         if (IS_ERR(devmap))
 685                 return PTR_ERR(devmap);
 686         use_diag = buf[0] == '1';
 687         spin_lock(&dasd_devmap_lock);
 688         /* Changing diag discipline flag is only allowed in offline state. */
 689         rc = count;
 690         if (!devmap->device) {
 691                 if (use_diag)
 692                         devmap->features |= DASD_FEATURE_USEDIAG;
 693                 else
 694                         devmap->features &= ~DASD_FEATURE_USEDIAG;
 695         } else
 696                 rc = -EPERM;
 697         spin_unlock(&dasd_devmap_lock);
 698         return rc;
 699 }
 700
 701 static
 702 DEVICE_ATTR(use_diag, 0644, dasd_use_diag_show, dasd_use_diag_store);
 703
 704 static ssize_t
 705 dasd_discipline_show(struct device *dev, struct device_attribute *attr, char *buf)
 706 {
 707         struct dasd_devmap *devmap;
 708         char *dname;
 709
 710         spin_lock(&dasd_devmap_lock);
 711         dname = "none";
 712         devmap = dev->driver_data;
 713         if (devmap && devmap->device && devmap->device->discipline)
 714                 dname = devmap->device->discipline->name;
 715         spin_unlock(&dasd_devmap_lock);
 716         return snprintf(buf, PAGE_SIZE, "%s\n", dname);
 717 }
 718
 719 static DEVICE_ATTR(discipline, 0444, dasd_discipline_show, NULL);
 720
 721 /*
 722  * extended error-reporting
 723  */
 724 static ssize_t
 725 dasd_eer_show(struct device *dev, struct device_attribute *attr, char *buf)
 726 {
 727         struct dasd_devmap *devmap;
 728         int eer_flag;
 729
 730         devmap = dasd_find_busid(dev->bus_id);
 731         if (!IS_ERR(devmap) && devmap->device)
 732                 eer_flag = dasd_eer_enabled(devmap->device);
 733         else
 734                 eer_flag = 0;
 735         return snprintf(buf, PAGE_SIZE, eer_flag ? "1\n" : "0\n");
 736 }
 737
 738 static ssize_t
 739 dasd_eer_store(struct device *dev, struct device_attribute *attr,
 740                const char *buf, size_t count)
 741 {
 742         struct dasd_devmap *devmap;
 743         int rc;
 744
 745         devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
 746         if (IS_ERR(devmap))
 747                 return PTR_ERR(devmap);
 748         if (!devmap->device)
 749                 return count;
 750         if (buf[0] == '1') {
 751                 rc = dasd_eer_enable(devmap->device);
 752                 if (rc)
 753                         return rc;
 754         } else
 755                 dasd_eer_disable(devmap->device);
 756         return count;
 757 }
 758
 759 static DEVICE_ATTR(eer_enabled, 0644, dasd_eer_show, dasd_eer_store);
 760
 761 static struct attribute * dasd_attrs[] = {
 762         &dev_attr_readonly.attr,
 763         &dev_attr_discipline.attr,
 764         &dev_attr_use_diag.attr,
 765         &dev_attr_eer_enabled.attr,
 766         NULL,
 767 };
 768
 769 static struct attribute_group dasd_attr_group = {
 770         .attrs = dasd_attrs,
 771 };
 772
 773 /*
 774  * Return value of the specified feature.
 775  */
 776 int
 777 dasd_get_feature(struct ccw_device *cdev, int feature)
 778 {
 779         struct dasd_devmap *devmap;
 780
 781         devmap = dasd_find_busid(cdev->dev.bus_id);
 782         if (IS_ERR(devmap))
 783                 return (int) PTR_ERR(devmap);
 784
 785         return ((devmap->features & feature) != 0);
 786 }
 787
 788 /*
 789  * Set / reset given feature.
 790  * Flag indicates wether to set (!=0) or the reset (=0) the feature.
 791  */
 792 int
 793 dasd_set_feature(struct ccw_device *cdev, int feature, int flag)
 794 {
 795         struct dasd_devmap *devmap;
 796
 797         devmap = dasd_find_busid(cdev->dev.bus_id);
 798         if (IS_ERR(devmap))
 799                 return (int) PTR_ERR(devmap);
 800
 801         spin_lock(&dasd_devmap_lock);
 802         if (flag)
 803                 devmap->features |= feature;
 804         else
 805                 devmap->features &= ~feature;
 806         if (devmap->device)
 807                 devmap->device->features = devmap->features;
 808         spin_unlock(&dasd_devmap_lock);
 809         return 0;
 810 }
 811
 812
 813 int
 814 dasd_add_sysfs_files(struct ccw_device *cdev)
 815 {
 816         return sysfs_create_group(&cdev->dev.kobj, &dasd_attr_group);
 817 }
 818
 819 void
 820 dasd_remove_sysfs_files(struct ccw_device *cdev)
 821 {
 822         sysfs_remove_group(&cdev->dev.kobj, &dasd_attr_group);
 823 }
 824
 825
 826 int
 827 dasd_devmap_init(void)
 828 {
 829         int i;
 830
 831         /* Initialize devmap structures. */
 832         dasd_max_devindex = 0;
 833         for (i = 0; i < 256; i++)
 834                 INIT_LIST_HEAD(&dasd_hashlists[i]);
 835         return 0;
 836
 837 }
 838
 839 void
 840 dasd_devmap_exit(void)
 841 {
 842         dasd_forget_ranges();
 843 }