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