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
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.
16 #include <linux/ctype.h>
17 #include <linux/init.h>
18 #include <linux/module.h>
20 #include <asm/debug.h>
21 #include <asm/uaccess.h>
24 #define PRINTK_HEADER "dasd_devmap:"
28 kmem_cache_t *dasd_page_cache;
29 EXPORT_SYMBOL_GPL(dasd_page_cache);
32 * dasd_devmap_t is used to store the features and the relation
33 * between device number and device index. To find a dasd_devmap_t
34 * that corresponds to a device number of a device index each
35 * dasd_devmap_t is added to two linked lists, one to search by
36 * the device number and one to search by the device index. As
37 * soon as big minor numbers are available the device index list
38 * can be removed since the device number will then be identical
39 * to the device index.
42 struct list_head list;
43 char bus_id[BUS_ID_SIZE];
44 unsigned int devindex;
45 unsigned short features;
46 struct dasd_device *device;
51 * dasd_server_ssid_map contains a globally unique storage server subsystem ID.
52 * dasd_server_ssid_list contains the list of all subsystem IDs accessed by
53 * the DASD device driver.
55 struct dasd_server_ssid_map {
56 struct list_head list;
64 static struct list_head dasd_server_ssid_list;
67 * Parameter parsing functions for dasd= parameter. The syntax is:
68 * <devno> : (0x)?[0-9a-fA-F]+
69 * <busid> : [0-0a-f]\.[0-9a-f]\.(0x)?[0-9a-fA-F]+
71 * <feature_list> : \(<feature>(:<feature>)*\)
72 * <devno-range> : <devno>(-<devno>)?<feature_list>?
73 * <busid-range> : <busid>(-<busid>)?<feature_list>?
74 * <devices> : <devno-range>|<busid-range>
75 * <dasd_module> : dasd_diag_mod|dasd_eckd_mod|dasd_fba_mod
77 * <dasd> : autodetect|probeonly|<devices>(,<devices>)*
80 int dasd_probeonly = 0; /* is true, when probeonly mode is active */
81 int dasd_autodetect = 0; /* is true, when autodetection is active */
82 int dasd_nopav = 0; /* is true, when PAV is disabled */
83 EXPORT_SYMBOL_GPL(dasd_nopav);
86 * char *dasd[] is intended to hold the ranges supplied by the dasd= statement
87 * it is named 'dasd' to directly be filled by insmod with the comma separated
88 * strings when running as a module.
90 static char *dasd[256];
91 module_param_array(dasd, charp, NULL, 0);
94 * Single spinlock to protect devmap and servermap structures and lists.
96 static DEFINE_SPINLOCK(dasd_devmap_lock);
99 * Hash lists for devmap structures.
101 static struct list_head dasd_hashlists[256];
102 int dasd_max_devindex;
104 static struct dasd_devmap *dasd_add_busid(char *, int);
107 dasd_hash_busid(char *bus_id)
112 for (i = 0; (i < BUS_ID_SIZE) && *bus_id; i++, bus_id++)
119 * The parameter parsing functions for builtin-drivers are called
120 * before kmalloc works. Store the pointers to the parameters strings
121 * into dasd[] for later processing.
124 dasd_call_setup(char *str)
126 static int count = 0;
133 __setup ("dasd=", dasd_call_setup);
134 #endif /* #ifndef MODULE */
137 * Read a device busid/devno from a string.
140 dasd_busid(char **str, int *id0, int *id1, int *devno)
144 /* check for leading '0x' */
146 if ((*str)[0] == '0' && (*str)[1] == 'x') {
150 if (!isxdigit((*str)[0])) /* We require at least one hex digit */
152 val = simple_strtoul(*str, str, 16);
153 if (old_style || (*str)[0] != '.') {
155 if (val < 0 || val > 0xffff)
160 /* New style x.y.z busid */
161 if (val < 0 || val > 0xff)
165 if (!isxdigit((*str)[0])) /* We require at least one hex digit */
167 val = simple_strtoul(*str, str, 16);
168 if (val < 0 || val > 0xff || (*str)++[0] != '.')
171 if (!isxdigit((*str)[0])) /* We require at least one hex digit */
173 val = simple_strtoul(*str, str, 16);
174 if (val < 0 || val > 0xffff)
181 * Read colon separated list of dasd features. Currently there is
182 * only one: "ro" for read-only devices. The default feature set
183 * is empty (value 0).
186 dasd_feature_list(char *str, char **endp)
188 int features, len, rc;
193 return DASD_FEATURE_DEFAULT;
200 str[len] && str[len] != ':' && str[len] != ')'; len++);
201 if (len == 2 && !strncmp(str, "ro", 2))
202 features |= DASD_FEATURE_READONLY;
203 else if (len == 4 && !strncmp(str, "diag", 4))
204 features |= DASD_FEATURE_USEDIAG;
206 MESSAGE(KERN_WARNING,
207 "unsupported feature: %*s, "
208 "ignoring setting", len, str);
217 MESSAGE(KERN_WARNING, "%s",
218 "missing ')' in dasd parameter string\n");
229 * Try to match the first element on the comma separated parse string
230 * with one of the known keywords. If a keyword is found, take the approprate
231 * action and return a pointer to the residual string. If the first element
232 * could not be matched to any keyword then return an error code.
235 dasd_parse_keyword( char *parsestring ) {
237 char *nextcomma, *residual_str;
240 nextcomma = strchr(parsestring,',');
242 length = nextcomma - parsestring;
243 residual_str = nextcomma + 1;
245 length = strlen(parsestring);
246 residual_str = parsestring + length;
248 if (strncmp("autodetect", parsestring, length) == 0) {
250 MESSAGE (KERN_INFO, "%s",
251 "turning to autodetection mode");
254 if (strncmp("probeonly", parsestring, length) == 0) {
256 MESSAGE(KERN_INFO, "%s",
257 "turning to probeonly mode");
260 if (strncmp("nopav", parsestring, length) == 0) {
262 MESSAGE(KERN_INFO, "%s", "'nopav' not supported on VM");
265 MESSAGE(KERN_INFO, "%s", "disable PAV mode");
269 if (strncmp("fixedbuffers", parsestring, length) == 0) {
273 kmem_cache_create("dasd_page_cache", PAGE_SIZE,
274 PAGE_SIZE, SLAB_CACHE_DMA,
276 if (!dasd_page_cache)
277 MESSAGE(KERN_WARNING, "%s", "Failed to create slab, "
278 "fixed buffer mode disabled.");
280 MESSAGE (KERN_INFO, "%s",
281 "turning on fixed buffer mode");
284 return ERR_PTR(-EINVAL);
288 * Try to interprete the first element on the comma separated parse string
289 * as a device number or a range of devices. If the interpretation is
290 * successfull, create the matching dasd_devmap entries and return a pointer
291 * to the residual string.
292 * If interpretation fails or in case of an error, return an error code.
295 dasd_parse_range( char *parsestring ) {
297 struct dasd_devmap *devmap;
298 int from, from_id0, from_id1;
299 int to, to_id0, to_id1;
301 char bus_id[BUS_ID_SIZE+1], *str;
304 rc = dasd_busid(&str, &from_id0, &from_id1, &from);
311 rc = dasd_busid(&str, &to_id0, &to_id1, &to);
315 (from_id0 != to_id0 || from_id1 != to_id1 || from > to))
318 MESSAGE(KERN_ERR, "Invalid device range %s", parsestring);
321 features = dasd_feature_list(str, &str);
323 return ERR_PTR(-EINVAL);
324 /* each device in dasd= parameter should be set initially online */
325 features |= DASD_FEATURE_INITIAL_ONLINE;
327 sprintf(bus_id, "%01x.%01x.%04x",
328 from_id0, from_id1, from++);
329 devmap = dasd_add_busid(bus_id, features);
331 return (char *)devmap;
337 MESSAGE(KERN_WARNING,
338 "junk at end of dasd parameter string: %s\n", str);
339 return ERR_PTR(-EINVAL);
343 dasd_parse_next_element( char *parsestring ) {
345 residual_str = dasd_parse_keyword(parsestring);
346 if (!IS_ERR(residual_str))
348 residual_str = dasd_parse_range(parsestring);
353 * Parse parameters stored in dasd[]
354 * The 'dasd=...' parameter allows to specify a comma separated list of
355 * keywords and device ranges. When the dasd driver is build into the kernel,
356 * the complete list will be stored as one element of the dasd[] array.
357 * When the dasd driver is build as a module, then the list is broken into
358 * it's elements and each dasd[] entry contains one element.
367 for (i = 0; i < 256; i++) {
370 parsestring = dasd[i];
371 /* loop over the comma separated list in the parsestring */
372 while (*parsestring) {
373 parsestring = dasd_parse_next_element(parsestring);
374 if(IS_ERR(parsestring)) {
375 rc = PTR_ERR(parsestring);
380 DBF_EVENT(DBF_ALERT, "%s", "invalid range found");
388 * Add a devmap for the device specified by busid. It is possible that
389 * the devmap already exists (dasd= parameter). The order of the devices
390 * added through this function will define the kdevs for the individual
393 static struct dasd_devmap *
394 dasd_add_busid(char *bus_id, int features)
396 struct dasd_devmap *devmap, *new, *tmp;
399 new = (struct dasd_devmap *)
400 kzalloc(sizeof(struct dasd_devmap), GFP_KERNEL);
402 return ERR_PTR(-ENOMEM);
403 spin_lock(&dasd_devmap_lock);
405 hash = dasd_hash_busid(bus_id);
406 list_for_each_entry(tmp, &dasd_hashlists[hash], list)
407 if (strncmp(tmp->bus_id, bus_id, BUS_ID_SIZE) == 0) {
412 /* This bus_id is new. */
413 new->devindex = dasd_max_devindex++;
414 strncpy(new->bus_id, bus_id, BUS_ID_SIZE);
415 new->features = features;
417 list_add(&new->list, &dasd_hashlists[hash]);
421 spin_unlock(&dasd_devmap_lock);
427 * Find devmap for device with given bus_id.
429 static struct dasd_devmap *
430 dasd_find_busid(char *bus_id)
432 struct dasd_devmap *devmap, *tmp;
435 spin_lock(&dasd_devmap_lock);
436 devmap = ERR_PTR(-ENODEV);
437 hash = dasd_hash_busid(bus_id);
438 list_for_each_entry(tmp, &dasd_hashlists[hash], list) {
439 if (strncmp(tmp->bus_id, bus_id, BUS_ID_SIZE) == 0) {
444 spin_unlock(&dasd_devmap_lock);
449 * Check if busid has been added to the list of dasd ranges.
452 dasd_busid_known(char *bus_id)
454 return IS_ERR(dasd_find_busid(bus_id)) ? -ENOENT : 0;
458 * Forget all about the device numbers added so far.
459 * This may only be called at module unload or system shutdown.
462 dasd_forget_ranges(void)
464 struct dasd_devmap *devmap, *n;
467 spin_lock(&dasd_devmap_lock);
468 for (i = 0; i < 256; i++) {
469 list_for_each_entry_safe(devmap, n, &dasd_hashlists[i], list) {
470 BUG_ON(devmap->device != NULL);
471 list_del(&devmap->list);
475 spin_unlock(&dasd_devmap_lock);
479 * Find the device struct by its device index.
482 dasd_device_from_devindex(int devindex)
484 struct dasd_devmap *devmap, *tmp;
485 struct dasd_device *device;
488 spin_lock(&dasd_devmap_lock);
490 for (i = 0; (i < 256) && !devmap; i++)
491 list_for_each_entry(tmp, &dasd_hashlists[i], list)
492 if (tmp->devindex == devindex) {
493 /* Found the devmap for the device. */
497 if (devmap && devmap->device) {
498 device = devmap->device;
499 dasd_get_device(device);
501 device = ERR_PTR(-ENODEV);
502 spin_unlock(&dasd_devmap_lock);
507 * Return devmap for cdev. If no devmap exists yet, create one and
508 * connect it to the cdev.
510 static struct dasd_devmap *
511 dasd_devmap_from_cdev(struct ccw_device *cdev)
513 struct dasd_devmap *devmap;
515 devmap = dasd_find_busid(cdev->dev.bus_id);
517 devmap = dasd_add_busid(cdev->dev.bus_id,
518 DASD_FEATURE_DEFAULT);
523 * Create a dasd device structure for cdev.
526 dasd_create_device(struct ccw_device *cdev)
528 struct dasd_devmap *devmap;
529 struct dasd_device *device;
533 devmap = dasd_devmap_from_cdev(cdev);
535 return (void *) devmap;
537 device = dasd_alloc_device();
540 atomic_set(&device->ref_count, 3);
542 spin_lock(&dasd_devmap_lock);
543 if (!devmap->device) {
544 devmap->device = device;
545 device->devindex = devmap->devindex;
546 device->features = devmap->features;
547 get_device(&cdev->dev);
551 /* Someone else was faster. */
553 spin_unlock(&dasd_devmap_lock);
556 dasd_free_device(device);
560 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
561 cdev->dev.driver_data = device;
562 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
568 * Wait queue for dasd_delete_device waits.
570 static DECLARE_WAIT_QUEUE_HEAD(dasd_delete_wq);
573 * Remove a dasd device structure. The passed referenced
577 dasd_delete_device(struct dasd_device *device)
579 struct ccw_device *cdev;
580 struct dasd_devmap *devmap;
583 /* First remove device pointer from devmap. */
584 devmap = dasd_find_busid(device->cdev->dev.bus_id);
585 BUG_ON(IS_ERR(devmap));
586 spin_lock(&dasd_devmap_lock);
587 if (devmap->device != device) {
588 spin_unlock(&dasd_devmap_lock);
589 dasd_put_device(device);
592 devmap->device = NULL;
593 spin_unlock(&dasd_devmap_lock);
595 /* Disconnect dasd_device structure from ccw_device structure. */
596 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
597 device->cdev->dev.driver_data = NULL;
598 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
601 * Drop ref_count by 3, one for the devmap reference, one for
602 * the cdev reference and one for the passed reference.
604 atomic_sub(3, &device->ref_count);
606 /* Wait for reference counter to drop to zero. */
607 wait_event(dasd_delete_wq, atomic_read(&device->ref_count) == 0);
609 /* Disconnect dasd_device structure from ccw_device structure. */
613 /* Put ccw_device structure. */
614 put_device(&cdev->dev);
616 /* Now the device structure can be freed. */
617 dasd_free_device(device);
621 * Reference counter dropped to zero. Wake up waiter
622 * in dasd_delete_device.
625 dasd_put_device_wake(struct dasd_device *device)
627 wake_up(&dasd_delete_wq);
631 * Return dasd_device structure associated with cdev.
632 * This function needs to be called with the ccw device
633 * lock held. It can be used from interrupt context.
636 dasd_device_from_cdev_locked(struct ccw_device *cdev)
638 struct dasd_device *device = cdev->dev.driver_data;
641 return ERR_PTR(-ENODEV);
642 dasd_get_device(device);
647 * Return dasd_device structure associated with cdev.
650 dasd_device_from_cdev(struct ccw_device *cdev)
652 struct dasd_device *device;
655 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
656 device = dasd_device_from_cdev_locked(cdev);
657 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
662 * SECTION: files in sysfs
666 * readonly controls the readonly status of a dasd
669 dasd_ro_show(struct device *dev, struct device_attribute *attr, char *buf)
671 struct dasd_devmap *devmap;
674 devmap = dasd_find_busid(dev->bus_id);
676 ro_flag = (devmap->features & DASD_FEATURE_READONLY) != 0;
678 ro_flag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_READONLY) != 0;
679 return snprintf(buf, PAGE_SIZE, ro_flag ? "1\n" : "0\n");
683 dasd_ro_store(struct device *dev, struct device_attribute *attr,
684 const char *buf, size_t count)
686 struct dasd_devmap *devmap;
690 devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
692 return PTR_ERR(devmap);
694 val = simple_strtoul(buf, &endp, 0);
695 if (((endp + 1) < (buf + count)) || (val > 1))
698 spin_lock(&dasd_devmap_lock);
700 devmap->features |= DASD_FEATURE_READONLY;
702 devmap->features &= ~DASD_FEATURE_READONLY;
704 devmap->device->features = devmap->features;
705 if (devmap->device && devmap->device->gdp)
706 set_disk_ro(devmap->device->gdp, val);
707 spin_unlock(&dasd_devmap_lock);
711 static DEVICE_ATTR(readonly, 0644, dasd_ro_show, dasd_ro_store);
714 * use_diag controls whether the driver should use diag rather than ssch
715 * to talk to the device
718 dasd_use_diag_show(struct device *dev, struct device_attribute *attr, char *buf)
720 struct dasd_devmap *devmap;
723 devmap = dasd_find_busid(dev->bus_id);
725 use_diag = (devmap->features & DASD_FEATURE_USEDIAG) != 0;
727 use_diag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_USEDIAG) != 0;
728 return sprintf(buf, use_diag ? "1\n" : "0\n");
732 dasd_use_diag_store(struct device *dev, struct device_attribute *attr,
733 const char *buf, size_t count)
735 struct dasd_devmap *devmap;
740 devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
742 return PTR_ERR(devmap);
744 val = simple_strtoul(buf, &endp, 0);
745 if (((endp + 1) < (buf + count)) || (val > 1))
748 spin_lock(&dasd_devmap_lock);
749 /* Changing diag discipline flag is only allowed in offline state. */
751 if (!devmap->device) {
753 devmap->features |= DASD_FEATURE_USEDIAG;
755 devmap->features &= ~DASD_FEATURE_USEDIAG;
758 spin_unlock(&dasd_devmap_lock);
762 static DEVICE_ATTR(use_diag, 0644, dasd_use_diag_show, dasd_use_diag_store);
765 dasd_discipline_show(struct device *dev, struct device_attribute *attr,
768 struct dasd_device *device;
771 device = dasd_device_from_cdev(to_ccwdev(dev));
772 if (!IS_ERR(device) && device->discipline) {
773 len = snprintf(buf, PAGE_SIZE, "%s\n",
774 device->discipline->name);
775 dasd_put_device(device);
777 len = snprintf(buf, PAGE_SIZE, "none\n");
781 static DEVICE_ATTR(discipline, 0444, dasd_discipline_show, NULL);
784 dasd_alias_show(struct device *dev, struct device_attribute *attr, char *buf)
786 struct dasd_devmap *devmap;
789 devmap = dasd_find_busid(dev->bus_id);
790 spin_lock(&dasd_devmap_lock);
792 alias = devmap->uid.alias;
795 spin_unlock(&dasd_devmap_lock);
797 return sprintf(buf, alias ? "1\n" : "0\n");
800 static DEVICE_ATTR(alias, 0444, dasd_alias_show, NULL);
803 dasd_vendor_show(struct device *dev, struct device_attribute *attr, char *buf)
805 struct dasd_devmap *devmap;
808 devmap = dasd_find_busid(dev->bus_id);
809 spin_lock(&dasd_devmap_lock);
810 if (!IS_ERR(devmap) && strlen(devmap->uid.vendor) > 0)
811 vendor = devmap->uid.vendor;
814 spin_unlock(&dasd_devmap_lock);
816 return snprintf(buf, PAGE_SIZE, "%s\n", vendor);
819 static DEVICE_ATTR(vendor, 0444, dasd_vendor_show, NULL);
821 #define UID_STRLEN ( /* vendor */ 3 + 1 + /* serial */ 14 + 1 +\
822 /* SSID */ 4 + 1 + /* unit addr */ 2 + 1)
825 dasd_uid_show(struct device *dev, struct device_attribute *attr, char *buf)
827 struct dasd_devmap *devmap;
828 char uid[UID_STRLEN];
830 devmap = dasd_find_busid(dev->bus_id);
831 spin_lock(&dasd_devmap_lock);
832 if (!IS_ERR(devmap) && strlen(devmap->uid.vendor) > 0)
833 snprintf(uid, sizeof(uid), "%s.%s.%04x.%02x",
834 devmap->uid.vendor, devmap->uid.serial,
835 devmap->uid.ssid, devmap->uid.unit_addr);
838 spin_unlock(&dasd_devmap_lock);
840 return snprintf(buf, PAGE_SIZE, "%s\n", uid);
843 static DEVICE_ATTR(uid, 0444, dasd_uid_show, NULL);
846 * extended error-reporting
849 dasd_eer_show(struct device *dev, struct device_attribute *attr, char *buf)
851 struct dasd_devmap *devmap;
854 devmap = dasd_find_busid(dev->bus_id);
855 if (!IS_ERR(devmap) && devmap->device)
856 eer_flag = dasd_eer_enabled(devmap->device);
859 return snprintf(buf, PAGE_SIZE, eer_flag ? "1\n" : "0\n");
863 dasd_eer_store(struct device *dev, struct device_attribute *attr,
864 const char *buf, size_t count)
866 struct dasd_devmap *devmap;
870 devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
872 return PTR_ERR(devmap);
876 val = simple_strtoul(buf, &endp, 0);
877 if (((endp + 1) < (buf + count)) || (val > 1))
881 rc = dasd_eer_enable(devmap->device);
885 dasd_eer_disable(devmap->device);
889 static DEVICE_ATTR(eer_enabled, 0644, dasd_eer_show, dasd_eer_store);
891 static struct attribute * dasd_attrs[] = {
892 &dev_attr_readonly.attr,
893 &dev_attr_discipline.attr,
894 &dev_attr_alias.attr,
895 &dev_attr_vendor.attr,
897 &dev_attr_use_diag.attr,
898 &dev_attr_eer_enabled.attr,
902 static struct attribute_group dasd_attr_group = {
907 * Return copy of the device unique identifier.
910 dasd_get_uid(struct ccw_device *cdev, struct dasd_uid *uid)
912 struct dasd_devmap *devmap;
914 devmap = dasd_find_busid(cdev->dev.bus_id);
916 return PTR_ERR(devmap);
917 spin_lock(&dasd_devmap_lock);
919 spin_unlock(&dasd_devmap_lock);
924 * Register the given device unique identifier into devmap struct.
925 * In addition check if the related storage server subsystem ID is already
926 * contained in the dasd_server_ssid_list. If subsystem ID is not contained,
928 * Return 0 if server was already in serverlist,
929 * 1 if the server was added successful
930 * <0 in case of error.
933 dasd_set_uid(struct ccw_device *cdev, struct dasd_uid *uid)
935 struct dasd_devmap *devmap;
936 struct dasd_server_ssid_map *srv, *tmp;
938 devmap = dasd_find_busid(cdev->dev.bus_id);
940 return PTR_ERR(devmap);
942 /* generate entry for server_ssid_map */
943 srv = (struct dasd_server_ssid_map *)
944 kzalloc(sizeof(struct dasd_server_ssid_map), GFP_KERNEL);
947 strncpy(srv->sid.vendor, uid->vendor, sizeof(srv->sid.vendor) - 1);
948 strncpy(srv->sid.serial, uid->serial, sizeof(srv->sid.serial) - 1);
949 srv->sid.ssid = uid->ssid;
951 /* server is already contained ? */
952 spin_lock(&dasd_devmap_lock);
954 list_for_each_entry(tmp, &dasd_server_ssid_list, list) {
955 if (!memcmp(&srv->sid, &tmp->sid,
956 sizeof(struct system_id))) {
963 /* add servermap to serverlist */
965 list_add(&srv->list, &dasd_server_ssid_list);
966 spin_unlock(&dasd_devmap_lock);
968 return (srv ? 1 : 0);
970 EXPORT_SYMBOL_GPL(dasd_set_uid);
973 * Return value of the specified feature.
976 dasd_get_feature(struct ccw_device *cdev, int feature)
978 struct dasd_devmap *devmap;
980 devmap = dasd_find_busid(cdev->dev.bus_id);
982 return PTR_ERR(devmap);
984 return ((devmap->features & feature) != 0);
988 * Set / reset given feature.
989 * Flag indicates wether to set (!=0) or the reset (=0) the feature.
992 dasd_set_feature(struct ccw_device *cdev, int feature, int flag)
994 struct dasd_devmap *devmap;
996 devmap = dasd_find_busid(cdev->dev.bus_id);
998 return PTR_ERR(devmap);
1000 spin_lock(&dasd_devmap_lock);
1002 devmap->features |= feature;
1004 devmap->features &= ~feature;
1006 devmap->device->features = devmap->features;
1007 spin_unlock(&dasd_devmap_lock);
1013 dasd_add_sysfs_files(struct ccw_device *cdev)
1015 return sysfs_create_group(&cdev->dev.kobj, &dasd_attr_group);
1019 dasd_remove_sysfs_files(struct ccw_device *cdev)
1021 sysfs_remove_group(&cdev->dev.kobj, &dasd_attr_group);
1026 dasd_devmap_init(void)
1030 /* Initialize devmap structures. */
1031 dasd_max_devindex = 0;
1032 for (i = 0; i < 256; i++)
1033 INIT_LIST_HEAD(&dasd_hashlists[i]);
1035 /* Initialize servermap structure. */
1036 INIT_LIST_HEAD(&dasd_server_ssid_list);
1041 dasd_devmap_exit(void)
1043 dasd_forget_ranges();