[PATCH] s390: dasd device identifiers
[linux-2.6.git] / 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         struct dasd_uid uid;
49 };
50
51 /*
52  * Parameter parsing functions for dasd= parameter. The syntax is:
53  *   <devno>            : (0x)?[0-9a-fA-F]+
54  *   <busid>            : [0-0a-f]\.[0-9a-f]\.(0x)?[0-9a-fA-F]+
55  *   <feature>          : ro
56  *   <feature_list>     : \(<feature>(:<feature>)*\)
57  *   <devno-range>      : <devno>(-<devno>)?<feature_list>?
58  *   <busid-range>      : <busid>(-<busid>)?<feature_list>?
59  *   <devices>          : <devno-range>|<busid-range>
60  *   <dasd_module>      : dasd_diag_mod|dasd_eckd_mod|dasd_fba_mod
61  *
62  *   <dasd>             : autodetect|probeonly|<devices>(,<devices>)*
63  */
64
65 int dasd_probeonly =  0;        /* is true, when probeonly mode is active */
66 int dasd_autodetect = 0;        /* is true, when autodetection is active */
67
68 /*
69  * char *dasd[] is intended to hold the ranges supplied by the dasd= statement
70  * it is named 'dasd' to directly be filled by insmod with the comma separated
71  * strings when running as a module.
72  */
73 static char *dasd[256];
74 module_param_array(dasd, charp, NULL, 0);
75
76 /*
77  * Single spinlock to protect devmap structures and lists.
78  */
79 static DEFINE_SPINLOCK(dasd_devmap_lock);
80
81 /*
82  * Hash lists for devmap structures.
83  */
84 static struct list_head dasd_hashlists[256];
85 int dasd_max_devindex;
86
87 static struct dasd_devmap *dasd_add_busid(char *, int);
88
89 static inline int
90 dasd_hash_busid(char *bus_id)
91 {
92         int hash, i;
93
94         hash = 0;
95         for (i = 0; (i < BUS_ID_SIZE) && *bus_id; i++, bus_id++)
96                 hash += *bus_id;
97         return hash & 0xff;
98 }
99
100 #ifndef MODULE
101 /*
102  * The parameter parsing functions for builtin-drivers are called
103  * before kmalloc works. Store the pointers to the parameters strings
104  * into dasd[] for later processing.
105  */
106 static int __init
107 dasd_call_setup(char *str)
108 {
109         static int count = 0;
110
111         if (count < 256)
112                 dasd[count++] = str;
113         return 1;
114 }
115
116 __setup ("dasd=", dasd_call_setup);
117 #endif  /* #ifndef MODULE */
118
119 /*
120  * Read a device busid/devno from a string.
121  */
122 static inline int
123 dasd_busid(char **str, int *id0, int *id1, int *devno)
124 {
125         int val, old_style;
126  
127         /* check for leading '0x' */
128         old_style = 0;
129         if ((*str)[0] == '0' && (*str)[1] == 'x') {
130                 *str += 2;
131                 old_style = 1;
132         }
133         if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
134                 return -EINVAL;
135         val = simple_strtoul(*str, str, 16);
136         if (old_style || (*str)[0] != '.') {
137                 *id0 = *id1 = 0;
138                 if (val < 0 || val > 0xffff)
139                         return -EINVAL;
140                 *devno = val;
141                 return 0;
142         }
143         /* New style x.y.z busid */
144         if (val < 0 || val > 0xff)
145                 return -EINVAL;
146         *id0 = val;
147         (*str)++;
148         if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
149                 return -EINVAL;
150         val = simple_strtoul(*str, str, 16);
151         if (val < 0 || val > 0xff || (*str)++[0] != '.')
152                 return -EINVAL;
153         *id1 = val;
154         if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
155                 return -EINVAL;
156         val = simple_strtoul(*str, str, 16);
157         if (val < 0 || val > 0xffff)
158                 return -EINVAL;
159         *devno = val;
160         return 0;
161 }
162
163 /*
164  * Read colon separated list of dasd features. Currently there is
165  * only one: "ro" for read-only devices. The default feature set
166  * is empty (value 0).
167  */
168 static inline int
169 dasd_feature_list(char *str, char **endp)
170 {
171         int features, len, rc;
172
173         rc = 0;
174         if (*str != '(') {
175                 *endp = str;
176                 return DASD_FEATURE_DEFAULT;
177         }
178         str++;
179         features = 0;
180
181         while (1) {
182                 for (len = 0; 
183                      str[len] && str[len] != ':' && str[len] != ')'; len++);
184                 if (len == 2 && !strncmp(str, "ro", 2))
185                         features |= DASD_FEATURE_READONLY;
186                 else if (len == 4 && !strncmp(str, "diag", 4))
187                         features |= DASD_FEATURE_USEDIAG;
188                 else {
189                         MESSAGE(KERN_WARNING,
190                                 "unsupported feature: %*s, "
191                                 "ignoring setting", len, str);
192                         rc = -EINVAL;
193                 }
194                 str += len;
195                 if (*str != ':')
196                         break;
197                 str++;
198         }
199         if (*str != ')') {
200                 MESSAGE(KERN_WARNING, "%s",
201                         "missing ')' in dasd parameter string\n");
202                 rc = -EINVAL;
203         } else
204                 str++;
205         *endp = str;
206         if (rc != 0)
207                 return rc;
208         return features;
209 }
210
211 /*
212  * Try to match the first element on the comma separated parse string
213  * with one of the known keywords. If a keyword is found, take the approprate
214  * action and return a pointer to the residual string. If the first element
215  * could not be matched to any keyword then return an error code.
216  */
217 static char *
218 dasd_parse_keyword( char *parsestring ) {
219
220         char *nextcomma, *residual_str;
221         int length;
222
223         nextcomma = strchr(parsestring,',');
224         if (nextcomma) {
225                 length = nextcomma - parsestring;
226                 residual_str = nextcomma + 1;
227         } else {
228                 length = strlen(parsestring);
229                 residual_str = parsestring + length;
230         }
231         if (strncmp ("autodetect", parsestring, length) == 0) {
232                 dasd_autodetect = 1;
233                 MESSAGE (KERN_INFO, "%s",
234                          "turning to autodetection mode");
235                 return residual_str;
236         }
237         if (strncmp ("probeonly", parsestring, length) == 0) {
238                 dasd_probeonly = 1;
239                 MESSAGE(KERN_INFO, "%s",
240                         "turning to probeonly mode");
241                 return residual_str;
242         }
243         if (strncmp ("fixedbuffers", parsestring, length) == 0) {
244                 if (dasd_page_cache)
245                         return residual_str;
246                 dasd_page_cache =
247                         kmem_cache_create("dasd_page_cache", PAGE_SIZE, 0,
248                                           SLAB_CACHE_DMA, NULL, NULL );
249                 if (!dasd_page_cache)
250                         MESSAGE(KERN_WARNING, "%s", "Failed to create slab, "
251                                 "fixed buffer mode disabled.");
252                 else
253                         MESSAGE (KERN_INFO, "%s",
254                                  "turning on fixed buffer mode");
255                 return residual_str;
256         }
257         return ERR_PTR(-EINVAL);
258 }
259
260 /*
261  * Try to interprete the first element on the comma separated parse string
262  * as a device number or a range of devices. If the interpretation is
263  * successfull, create the matching dasd_devmap entries and return a pointer
264  * to the residual string.
265  * If interpretation fails or in case of an error, return an error code.
266  */
267 static char *
268 dasd_parse_range( char *parsestring ) {
269
270         struct dasd_devmap *devmap;
271         int from, from_id0, from_id1;
272         int to, to_id0, to_id1;
273         int features, rc;
274         char bus_id[BUS_ID_SIZE+1], *str;
275
276         str = parsestring;
277         rc = dasd_busid(&str, &from_id0, &from_id1, &from);
278         if (rc == 0) {
279                 to = from;
280                 to_id0 = from_id0;
281                 to_id1 = from_id1;
282                 if (*str == '-') {
283                         str++;
284                         rc = dasd_busid(&str, &to_id0, &to_id1, &to);
285                 }
286         }
287         if (rc == 0 &&
288             (from_id0 != to_id0 || from_id1 != to_id1 || from > to))
289                 rc = -EINVAL;
290         if (rc) {
291                 MESSAGE(KERN_ERR, "Invalid device range %s", parsestring);
292                 return ERR_PTR(rc);
293         }
294         features = dasd_feature_list(str, &str);
295         if (features < 0)
296                 return ERR_PTR(-EINVAL);
297         while (from <= to) {
298                 sprintf(bus_id, "%01x.%01x.%04x",
299                         from_id0, from_id1, from++);
300                 devmap = dasd_add_busid(bus_id, features);
301                 if (IS_ERR(devmap))
302                         return (char *)devmap;
303         }
304         if (*str == ',')
305                 return str + 1;
306         if (*str == '\0')
307                 return str;
308         MESSAGE(KERN_WARNING,
309                 "junk at end of dasd parameter string: %s\n", str);
310         return ERR_PTR(-EINVAL);
311 }
312
313 static inline char *
314 dasd_parse_next_element( char *parsestring ) {
315         char * residual_str;
316         residual_str = dasd_parse_keyword(parsestring);
317         if (!IS_ERR(residual_str))
318                 return residual_str;
319         residual_str = dasd_parse_range(parsestring);
320         return residual_str;
321 }
322
323 /*
324  * Parse parameters stored in dasd[]
325  * The 'dasd=...' parameter allows to specify a comma separated list of
326  * keywords and device ranges. When the dasd driver is build into the kernel,
327  * the complete list will be stored as one element of the dasd[] array.
328  * When the dasd driver is build as a module, then the list is broken into
329  * it's elements and each dasd[] entry contains one element.
330  */
331 int
332 dasd_parse(void)
333 {
334         int rc, i;
335         char *parsestring;
336
337         rc = 0;
338         for (i = 0; i < 256; i++) {
339                 if (dasd[i] == NULL)
340                         break;
341                 parsestring = dasd[i];
342                 /* loop over the comma separated list in the parsestring */
343                 while (*parsestring) {
344                         parsestring = dasd_parse_next_element(parsestring);
345                         if(IS_ERR(parsestring)) {
346                                 rc = PTR_ERR(parsestring);
347                                 break;
348                         }
349                 }
350                 if (rc) {
351                         DBF_EVENT(DBF_ALERT, "%s", "invalid range found");
352                         break;
353                 }
354         }
355         return rc;
356 }
357
358 /*
359  * Add a devmap for the device specified by busid. It is possible that
360  * the devmap already exists (dasd= parameter). The order of the devices
361  * added through this function will define the kdevs for the individual
362  * devices. 
363  */
364 static struct dasd_devmap *
365 dasd_add_busid(char *bus_id, int features)
366 {
367         struct dasd_devmap *devmap, *new, *tmp;
368         int hash;
369
370         new = (struct dasd_devmap *)
371                 kmalloc(sizeof(struct dasd_devmap), GFP_KERNEL);
372         if (!new)
373                 return ERR_PTR(-ENOMEM);
374         spin_lock(&dasd_devmap_lock);
375         devmap = 0;
376         hash = dasd_hash_busid(bus_id);
377         list_for_each_entry(tmp, &dasd_hashlists[hash], list)
378                 if (strncmp(tmp->bus_id, bus_id, BUS_ID_SIZE) == 0) {
379                         devmap = tmp;
380                         break;
381                 }
382         if (!devmap) {
383                 /* This bus_id is new. */
384                 new->devindex = dasd_max_devindex++;
385                 strncpy(new->bus_id, bus_id, BUS_ID_SIZE);
386                 new->features = features;
387                 new->device = 0;
388                 list_add(&new->list, &dasd_hashlists[hash]);
389                 devmap = new;
390                 new = 0;
391         }
392         spin_unlock(&dasd_devmap_lock);
393         kfree(new);
394         return devmap;
395 }
396
397 /*
398  * Find devmap for device with given bus_id.
399  */
400 static struct dasd_devmap *
401 dasd_find_busid(char *bus_id)
402 {
403         struct dasd_devmap *devmap, *tmp;
404         int hash;
405
406         spin_lock(&dasd_devmap_lock);
407         devmap = ERR_PTR(-ENODEV);
408         hash = dasd_hash_busid(bus_id);
409         list_for_each_entry(tmp, &dasd_hashlists[hash], list) {
410                 if (strncmp(tmp->bus_id, bus_id, BUS_ID_SIZE) == 0) {
411                         devmap = tmp;
412                         break;
413                 }
414         }
415         spin_unlock(&dasd_devmap_lock);
416         return devmap;
417 }
418
419 /*
420  * Check if busid has been added to the list of dasd ranges.
421  */
422 int
423 dasd_busid_known(char *bus_id)
424 {
425         return IS_ERR(dasd_find_busid(bus_id)) ? -ENOENT : 0;
426 }
427
428 /*
429  * Forget all about the device numbers added so far.
430  * This may only be called at module unload or system shutdown.
431  */
432 static void
433 dasd_forget_ranges(void)
434 {
435         struct dasd_devmap *devmap, *n;
436         int i;
437
438         spin_lock(&dasd_devmap_lock);
439         for (i = 0; i < 256; i++) {
440                 list_for_each_entry_safe(devmap, n, &dasd_hashlists[i], list) {
441                         BUG_ON(devmap->device != NULL);
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         BUG_ON(IS_ERR(devmap));
551         spin_lock(&dasd_devmap_lock);
552         if (devmap->device != device) {
553                 spin_unlock(&dasd_devmap_lock);
554                 dasd_put_device(device);
555                 return;
556         }
557         devmap->device = NULL;
558         spin_unlock(&dasd_devmap_lock);
559
560         /* Drop ref_count by 2, one for the devmap reference and
561          * one for the passed reference. */
562         atomic_sub(2, &device->ref_count);
563
564         /* Wait for reference counter to drop to zero. */
565         wait_event(dasd_delete_wq, atomic_read(&device->ref_count) == 0);
566
567         /* Disconnect dasd_device structure from ccw_device structure. */
568         cdev = device->cdev;
569         device->cdev = NULL;
570
571         /* Disconnect dasd_devmap structure from ccw_device structure. */
572         cdev->dev.driver_data = NULL;
573
574         /* Put ccw_device structure. */
575         put_device(&cdev->dev);
576
577         /* Now the device structure can be freed. */
578         dasd_free_device(device);
579 }
580
581 /*
582  * Reference counter dropped to zero. Wake up waiter
583  * in dasd_delete_device.
584  */
585 void
586 dasd_put_device_wake(struct dasd_device *device)
587 {
588         wake_up(&dasd_delete_wq);
589 }
590
591 /*
592  * Return dasd_device structure associated with cdev.
593  */
594 struct dasd_device *
595 dasd_device_from_cdev(struct ccw_device *cdev)
596 {
597         struct dasd_devmap *devmap;
598         struct dasd_device *device;
599
600         device = ERR_PTR(-ENODEV);
601         spin_lock(&dasd_devmap_lock);
602         devmap = cdev->dev.driver_data;
603         if (devmap && devmap->device) {
604                 device = devmap->device;
605                 dasd_get_device(device);
606         }
607         spin_unlock(&dasd_devmap_lock);
608         return device;
609 }
610
611 /*
612  * SECTION: files in sysfs
613  */
614
615 /*
616  * readonly controls the readonly status of a dasd
617  */
618 static ssize_t
619 dasd_ro_show(struct device *dev, struct device_attribute *attr, char *buf)
620 {
621         struct dasd_devmap *devmap;
622         int ro_flag;
623
624         devmap = dasd_find_busid(dev->bus_id);
625         if (!IS_ERR(devmap))
626                 ro_flag = (devmap->features & DASD_FEATURE_READONLY) != 0;
627         else
628                 ro_flag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_READONLY) != 0;
629         return snprintf(buf, PAGE_SIZE, ro_flag ? "1\n" : "0\n");
630 }
631
632 static ssize_t
633 dasd_ro_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
634 {
635         struct dasd_devmap *devmap;
636         int ro_flag;
637
638         devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
639         if (IS_ERR(devmap))
640                 return PTR_ERR(devmap);
641         ro_flag = buf[0] == '1';
642         spin_lock(&dasd_devmap_lock);
643         if (ro_flag)
644                 devmap->features |= DASD_FEATURE_READONLY;
645         else
646                 devmap->features &= ~DASD_FEATURE_READONLY;
647         if (devmap->device)
648                 devmap->device->features = devmap->features;
649         if (devmap->device && devmap->device->gdp)
650                 set_disk_ro(devmap->device->gdp, ro_flag);
651         spin_unlock(&dasd_devmap_lock);
652         return count;
653 }
654
655 static DEVICE_ATTR(readonly, 0644, dasd_ro_show, dasd_ro_store);
656
657 /*
658  * use_diag controls whether the driver should use diag rather than ssch
659  * to talk to the device
660  */
661 static ssize_t 
662 dasd_use_diag_show(struct device *dev, struct device_attribute *attr, char *buf)
663 {
664         struct dasd_devmap *devmap;
665         int use_diag;
666
667         devmap = dasd_find_busid(dev->bus_id);
668         if (!IS_ERR(devmap))
669                 use_diag = (devmap->features & DASD_FEATURE_USEDIAG) != 0;
670         else
671                 use_diag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_USEDIAG) != 0;
672         return sprintf(buf, use_diag ? "1\n" : "0\n");
673 }
674
675 static ssize_t
676 dasd_use_diag_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
677 {
678         struct dasd_devmap *devmap;
679         ssize_t rc;
680         int use_diag;
681
682         devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
683         if (IS_ERR(devmap))
684                 return PTR_ERR(devmap);
685         use_diag = buf[0] == '1';
686         spin_lock(&dasd_devmap_lock);
687         /* Changing diag discipline flag is only allowed in offline state. */
688         rc = count;
689         if (!devmap->device) {
690                 if (use_diag)
691                         devmap->features |= DASD_FEATURE_USEDIAG;
692                 else
693                         devmap->features &= ~DASD_FEATURE_USEDIAG;
694         } else
695                 rc = -EPERM;
696         spin_unlock(&dasd_devmap_lock);
697         return rc;
698 }
699
700 static
701 DEVICE_ATTR(use_diag, 0644, dasd_use_diag_show, dasd_use_diag_store);
702
703 static ssize_t
704 dasd_discipline_show(struct device *dev, struct device_attribute *attr, char *buf)
705 {
706         struct dasd_devmap *devmap;
707         char *dname;
708
709         spin_lock(&dasd_devmap_lock);
710         dname = "none";
711         devmap = dev->driver_data;
712         if (devmap && devmap->device && devmap->device->discipline)
713                 dname = devmap->device->discipline->name;
714         spin_unlock(&dasd_devmap_lock);
715         return snprintf(buf, PAGE_SIZE, "%s\n", dname);
716 }
717
718 static DEVICE_ATTR(discipline, 0444, dasd_discipline_show, NULL);
719
720 static ssize_t
721 dasd_alias_show(struct device *dev, struct device_attribute *attr, char *buf)
722 {
723         struct dasd_devmap *devmap;
724         int alias;
725
726         devmap = dasd_find_busid(dev->bus_id);
727         spin_lock(&dasd_devmap_lock);
728         if (!IS_ERR(devmap))
729                 alias = devmap->uid.alias;
730         else
731                 alias = 0;
732         spin_unlock(&dasd_devmap_lock);
733
734         return sprintf(buf, alias ? "1\n" : "0\n");
735 }
736
737 static DEVICE_ATTR(alias, 0444, dasd_alias_show, NULL);
738
739 static ssize_t
740 dasd_vendor_show(struct device *dev, struct device_attribute *attr, char *buf)
741 {
742         struct dasd_devmap *devmap;
743         char *vendor;
744
745         devmap = dasd_find_busid(dev->bus_id);
746         spin_lock(&dasd_devmap_lock);
747         if (!IS_ERR(devmap) && strlen(devmap->uid.vendor) > 0)
748                 vendor = devmap->uid.vendor;
749         else
750                 vendor = "";
751         spin_unlock(&dasd_devmap_lock);
752
753         return snprintf(buf, PAGE_SIZE, "%s\n", vendor);
754 }
755
756 static DEVICE_ATTR(vendor, 0444, dasd_vendor_show, NULL);
757
758 #define UID_STRLEN ( /* vendor */ 3 + 1 + /* serial    */ 14 + 1 +\
759                      /* SSID   */ 4 + 1 + /* unit addr */ 2 + 1)
760
761 static ssize_t
762 dasd_uid_show(struct device *dev, struct device_attribute *attr, char *buf)
763 {
764         struct dasd_devmap *devmap;
765         char uid[UID_STRLEN];
766
767         devmap = dasd_find_busid(dev->bus_id);
768         spin_lock(&dasd_devmap_lock);
769         if (!IS_ERR(devmap) && strlen(devmap->uid.vendor) > 0)
770                 snprintf(uid, sizeof(uid), "%s.%s.%04x.%02x",
771                          devmap->uid.vendor, devmap->uid.serial,
772                          devmap->uid.ssid, devmap->uid.unit_addr);
773         else
774                 uid[0] = 0;
775         spin_unlock(&dasd_devmap_lock);
776
777         return snprintf(buf, PAGE_SIZE, "%s\n", uid);
778 }
779
780 static DEVICE_ATTR(uid, 0444, dasd_uid_show, NULL);
781
782 /*
783  * extended error-reporting
784  */
785 static ssize_t
786 dasd_eer_show(struct device *dev, struct device_attribute *attr, char *buf)
787 {
788         struct dasd_devmap *devmap;
789         int eer_flag;
790
791         devmap = dasd_find_busid(dev->bus_id);
792         if (!IS_ERR(devmap) && devmap->device)
793                 eer_flag = dasd_eer_enabled(devmap->device);
794         else
795                 eer_flag = 0;
796         return snprintf(buf, PAGE_SIZE, eer_flag ? "1\n" : "0\n");
797 }
798
799 static ssize_t
800 dasd_eer_store(struct device *dev, struct device_attribute *attr,
801                const char *buf, size_t count)
802 {
803         struct dasd_devmap *devmap;
804         int rc;
805
806         devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
807         if (IS_ERR(devmap))
808                 return PTR_ERR(devmap);
809         if (!devmap->device)
810                 return count;
811         if (buf[0] == '1') {
812                 rc = dasd_eer_enable(devmap->device);
813                 if (rc)
814                         return rc;
815         } else
816                 dasd_eer_disable(devmap->device);
817         return count;
818 }
819
820 static DEVICE_ATTR(eer_enabled, 0644, dasd_eer_show, dasd_eer_store);
821
822 static struct attribute * dasd_attrs[] = {
823         &dev_attr_readonly.attr,
824         &dev_attr_discipline.attr,
825         &dev_attr_alias.attr,
826         &dev_attr_vendor.attr,
827         &dev_attr_uid.attr,
828         &dev_attr_use_diag.attr,
829         &dev_attr_eer_enabled.attr,
830         NULL,
831 };
832
833 static struct attribute_group dasd_attr_group = {
834         .attrs = dasd_attrs,
835 };
836
837
838 /*
839  * Return copy of the device unique identifier.
840  */
841 int
842 dasd_get_uid(struct ccw_device *cdev, struct dasd_uid *uid)
843 {
844         struct dasd_devmap *devmap;
845
846         devmap = dasd_find_busid(cdev->dev.bus_id);
847         if (IS_ERR(devmap))
848                 return PTR_ERR(devmap);
849         spin_lock(&dasd_devmap_lock);
850         *uid = devmap->uid;
851         spin_unlock(&dasd_devmap_lock);
852         return 0;
853 }
854
855 /*
856  * Register the given device unique identifier into devmap struct.
857  */
858 int
859 dasd_set_uid(struct ccw_device *cdev, struct dasd_uid *uid)
860 {
861         struct dasd_devmap *devmap;
862
863         devmap = dasd_find_busid(cdev->dev.bus_id);
864         if (IS_ERR(devmap))
865                 return PTR_ERR(devmap);
866         spin_lock(&dasd_devmap_lock);
867         devmap->uid = *uid;
868         spin_unlock(&dasd_devmap_lock);
869         return 0;
870 }
871 EXPORT_SYMBOL(dasd_set_uid);
872
873 /*
874  * Return value of the specified feature.
875  */
876 int
877 dasd_get_feature(struct ccw_device *cdev, int feature)
878 {
879         struct dasd_devmap *devmap;
880
881         devmap = dasd_find_busid(cdev->dev.bus_id);
882         if (IS_ERR(devmap))
883                 return (int) PTR_ERR(devmap);
884
885         return ((devmap->features & feature) != 0);
886 }
887
888 /*
889  * Set / reset given feature.
890  * Flag indicates wether to set (!=0) or the reset (=0) the feature.
891  */
892 int
893 dasd_set_feature(struct ccw_device *cdev, int feature, int flag)
894 {
895         struct dasd_devmap *devmap;
896
897         devmap = dasd_find_busid(cdev->dev.bus_id);
898         if (IS_ERR(devmap))
899                 return (int) PTR_ERR(devmap);
900
901         spin_lock(&dasd_devmap_lock);
902         if (flag)
903                 devmap->features |= feature;
904         else
905                 devmap->features &= ~feature;
906         if (devmap->device)
907                 devmap->device->features = devmap->features;
908         spin_unlock(&dasd_devmap_lock);
909         return 0;
910 }
911
912
913 int
914 dasd_add_sysfs_files(struct ccw_device *cdev)
915 {
916         return sysfs_create_group(&cdev->dev.kobj, &dasd_attr_group);
917 }
918
919 void
920 dasd_remove_sysfs_files(struct ccw_device *cdev)
921 {
922         sysfs_remove_group(&cdev->dev.kobj, &dasd_attr_group);
923 }
924
925
926 int
927 dasd_devmap_init(void)
928 {
929         int i;
930
931         /* Initialize devmap structures. */
932         dasd_max_devindex = 0;
933         for (i = 0; i < 256; i++)
934                 INIT_LIST_HEAD(&dasd_hashlists[i]);
935         return 0;
936
937 }
938
939 void
940 dasd_devmap_exit(void)
941 {
942         dasd_forget_ranges();
943 }