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();