Merge git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6
[linux-2.6] / drivers / s390 / block / dcssblk.c
1 /*
2  * dcssblk.c -- the S/390 block driver for dcss memory
3  *
4  * Authors: Carsten Otte, Stefan Weinhuber, Gerald Schaefer
5  */
6
7 #include <linux/module.h>
8 #include <linux/moduleparam.h>
9 #include <linux/ctype.h>
10 #include <linux/errno.h>
11 #include <linux/init.h>
12 #include <linux/slab.h>
13 #include <linux/blkdev.h>
14 #include <asm/extmem.h>
15 #include <asm/io.h>
16 #include <linux/completion.h>
17 #include <linux/interrupt.h>
18 #include <asm/s390_rdev.h>
19
20 //#define DCSSBLK_DEBUG         /* Debug messages on/off */
21 #define DCSSBLK_NAME "dcssblk"
22 #define DCSSBLK_MINORS_PER_DISK 1
23 #define DCSSBLK_PARM_LEN 400
24
25 #ifdef DCSSBLK_DEBUG
26 #define PRINT_DEBUG(x...) printk(KERN_DEBUG DCSSBLK_NAME " debug: " x)
27 #else
28 #define PRINT_DEBUG(x...) do {} while (0)
29 #endif
30 #define PRINT_INFO(x...)  printk(KERN_INFO DCSSBLK_NAME " info: " x)
31 #define PRINT_WARN(x...)  printk(KERN_WARNING DCSSBLK_NAME " warning: " x)
32 #define PRINT_ERR(x...)   printk(KERN_ERR DCSSBLK_NAME " error: " x)
33
34
35 static int dcssblk_open(struct inode *inode, struct file *filp);
36 static int dcssblk_release(struct inode *inode, struct file *filp);
37 static int dcssblk_make_request(struct request_queue *q, struct bio *bio);
38 static int dcssblk_direct_access(struct block_device *bdev, sector_t secnum,
39                                  void **kaddr, unsigned long *pfn);
40
41 static char dcssblk_segments[DCSSBLK_PARM_LEN] = "\0";
42
43 static int dcssblk_major;
44 static struct block_device_operations dcssblk_devops = {
45         .owner          = THIS_MODULE,
46         .open           = dcssblk_open,
47         .release        = dcssblk_release,
48         .direct_access  = dcssblk_direct_access,
49 };
50
51 static ssize_t dcssblk_add_store(struct device * dev, struct device_attribute *attr, const char * buf,
52                                   size_t count);
53 static ssize_t dcssblk_remove_store(struct device * dev, struct device_attribute *attr, const char * buf,
54                                   size_t count);
55 static ssize_t dcssblk_save_store(struct device * dev, struct device_attribute *attr, const char * buf,
56                                   size_t count);
57 static ssize_t dcssblk_save_show(struct device *dev, struct device_attribute *attr, char *buf);
58 static ssize_t dcssblk_shared_store(struct device * dev, struct device_attribute *attr, const char * buf,
59                                   size_t count);
60 static ssize_t dcssblk_shared_show(struct device *dev, struct device_attribute *attr, char *buf);
61
62 static DEVICE_ATTR(add, S_IWUSR, NULL, dcssblk_add_store);
63 static DEVICE_ATTR(remove, S_IWUSR, NULL, dcssblk_remove_store);
64 static DEVICE_ATTR(save, S_IWUSR | S_IRUGO, dcssblk_save_show,
65                    dcssblk_save_store);
66 static DEVICE_ATTR(shared, S_IWUSR | S_IRUGO, dcssblk_shared_show,
67                    dcssblk_shared_store);
68
69 static struct device *dcssblk_root_dev;
70
71 struct dcssblk_dev_info {
72         struct list_head lh;
73         struct device dev;
74         char segment_name[BUS_ID_SIZE];
75         atomic_t use_count;
76         struct gendisk *gd;
77         unsigned long start;
78         unsigned long end;
79         int segment_type;
80         unsigned char save_pending;
81         unsigned char is_shared;
82         struct request_queue *dcssblk_queue;
83 };
84
85 static LIST_HEAD(dcssblk_devices);
86 static struct rw_semaphore dcssblk_devices_sem;
87
88 /*
89  * release function for segment device.
90  */
91 static void
92 dcssblk_release_segment(struct device *dev)
93 {
94         PRINT_DEBUG("segment release fn called for %s\n", dev->bus_id);
95         kfree(container_of(dev, struct dcssblk_dev_info, dev));
96         module_put(THIS_MODULE);
97 }
98
99 /*
100  * get a minor number. needs to be called with
101  * down_write(&dcssblk_devices_sem) and the
102  * device needs to be enqueued before the semaphore is
103  * freed.
104  */
105 static int
106 dcssblk_assign_free_minor(struct dcssblk_dev_info *dev_info)
107 {
108         int minor, found;
109         struct dcssblk_dev_info *entry;
110
111         if (dev_info == NULL)
112                 return -EINVAL;
113         for (minor = 0; minor < (1<<MINORBITS); minor++) {
114                 found = 0;
115                 // test if minor available
116                 list_for_each_entry(entry, &dcssblk_devices, lh)
117                         if (minor == entry->gd->first_minor)
118                                 found++;
119                 if (!found) break; // got unused minor
120         }
121         if (found)
122                 return -EBUSY;
123         dev_info->gd->first_minor = minor;
124         return 0;
125 }
126
127 /*
128  * get the struct dcssblk_dev_info from dcssblk_devices
129  * for the given name.
130  * down_read(&dcssblk_devices_sem) must be held.
131  */
132 static struct dcssblk_dev_info *
133 dcssblk_get_device_by_name(char *name)
134 {
135         struct dcssblk_dev_info *entry;
136
137         list_for_each_entry(entry, &dcssblk_devices, lh) {
138                 if (!strcmp(name, entry->segment_name)) {
139                         return entry;
140                 }
141         }
142         return NULL;
143 }
144
145 static void dcssblk_unregister_callback(struct device *dev)
146 {
147         device_unregister(dev);
148         put_device(dev);
149 }
150
151 /*
152  * device attribute for switching shared/nonshared (exclusive)
153  * operation (show + store)
154  */
155 static ssize_t
156 dcssblk_shared_show(struct device *dev, struct device_attribute *attr, char *buf)
157 {
158         struct dcssblk_dev_info *dev_info;
159
160         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
161         return sprintf(buf, dev_info->is_shared ? "1\n" : "0\n");
162 }
163
164 static ssize_t
165 dcssblk_shared_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count)
166 {
167         struct dcssblk_dev_info *dev_info;
168         int rc;
169
170         if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0'))
171                 return -EINVAL;
172         down_write(&dcssblk_devices_sem);
173         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
174         if (atomic_read(&dev_info->use_count)) {
175                 PRINT_ERR("share: segment %s is busy!\n",
176                           dev_info->segment_name);
177                 rc = -EBUSY;
178                 goto out;
179         }
180         if (inbuf[0] == '1') {
181                 // reload segment in shared mode
182                 rc = segment_modify_shared(dev_info->segment_name,
183                                            SEGMENT_SHARED);
184                 if (rc < 0) {
185                         BUG_ON(rc == -EINVAL);
186                         if (rc != -EAGAIN)
187                                 goto removeseg;
188                 } else {
189                         dev_info->is_shared = 1;
190                         switch (dev_info->segment_type) {
191                                 case SEG_TYPE_SR:
192                                 case SEG_TYPE_ER:
193                                 case SEG_TYPE_SC:
194                                         set_disk_ro(dev_info->gd,1);
195                         }
196                 }
197         } else if (inbuf[0] == '0') {
198                 // reload segment in exclusive mode
199                 if (dev_info->segment_type == SEG_TYPE_SC) {
200                         PRINT_ERR("Segment type SC (%s) cannot be loaded in "
201                                   "non-shared mode\n", dev_info->segment_name);
202                         rc = -EINVAL;
203                         goto out;
204                 }
205                 rc = segment_modify_shared(dev_info->segment_name,
206                                            SEGMENT_EXCLUSIVE);
207                 if (rc < 0) {
208                         BUG_ON(rc == -EINVAL);
209                         if (rc != -EAGAIN)
210                                 goto removeseg;
211                 } else {
212                         dev_info->is_shared = 0;
213                         set_disk_ro(dev_info->gd, 0);
214                 }
215         } else {
216                 rc = -EINVAL;
217                 goto out;
218         }
219         rc = count;
220         goto out;
221
222 removeseg:
223         PRINT_ERR("Could not reload segment %s, removing it now!\n",
224                         dev_info->segment_name);
225         list_del(&dev_info->lh);
226
227         del_gendisk(dev_info->gd);
228         blk_cleanup_queue(dev_info->dcssblk_queue);
229         dev_info->gd->queue = NULL;
230         put_disk(dev_info->gd);
231         rc = device_schedule_callback(dev, dcssblk_unregister_callback);
232 out:
233         up_write(&dcssblk_devices_sem);
234         return rc;
235 }
236
237 /*
238  * device attribute for save operation on current copy
239  * of the segment. If the segment is busy, saving will
240  * become pending until it gets released, which can be
241  * undone by storing a non-true value to this entry.
242  * (show + store)
243  */
244 static ssize_t
245 dcssblk_save_show(struct device *dev, struct device_attribute *attr, char *buf)
246 {
247         struct dcssblk_dev_info *dev_info;
248
249         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
250         return sprintf(buf, dev_info->save_pending ? "1\n" : "0\n");
251 }
252
253 static ssize_t
254 dcssblk_save_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count)
255 {
256         struct dcssblk_dev_info *dev_info;
257
258         if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0'))
259                 return -EINVAL;
260         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
261
262         down_write(&dcssblk_devices_sem);
263         if (inbuf[0] == '1') {
264                 if (atomic_read(&dev_info->use_count) == 0) {
265                         // device is idle => we save immediately
266                         PRINT_INFO("Saving segment %s\n",
267                                    dev_info->segment_name);
268                         segment_save(dev_info->segment_name);
269                 }  else {
270                         // device is busy => we save it when it becomes
271                         // idle in dcssblk_release
272                         PRINT_INFO("Segment %s is currently busy, it will "
273                                    "be saved when it becomes idle...\n",
274                                    dev_info->segment_name);
275                         dev_info->save_pending = 1;
276                 }
277         } else if (inbuf[0] == '0') {
278                 if (dev_info->save_pending) {
279                         // device is busy & the user wants to undo his save
280                         // request
281                         dev_info->save_pending = 0;
282                         PRINT_INFO("Pending save for segment %s deactivated\n",
283                                         dev_info->segment_name);
284                 }
285         } else {
286                 up_write(&dcssblk_devices_sem);
287                 return -EINVAL;
288         }
289         up_write(&dcssblk_devices_sem);
290         return count;
291 }
292
293 /*
294  * device attribute for adding devices
295  */
296 static ssize_t
297 dcssblk_add_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
298 {
299         int rc, i;
300         struct dcssblk_dev_info *dev_info;
301         char *local_buf;
302         unsigned long seg_byte_size;
303
304         dev_info = NULL;
305         if (dev != dcssblk_root_dev) {
306                 rc = -EINVAL;
307                 goto out_nobuf;
308         }
309         local_buf = kmalloc(count + 1, GFP_KERNEL);
310         if (local_buf == NULL) {
311                 rc = -ENOMEM;
312                 goto out_nobuf;
313         }
314         /*
315          * parse input
316          */
317         for (i = 0; ((buf[i] != '\0') && (buf[i] != '\n') && i < count); i++) {
318                 local_buf[i] = toupper(buf[i]);
319         }
320         local_buf[i] = '\0';
321         if ((i == 0) || (i > 8)) {
322                 rc = -ENAMETOOLONG;
323                 goto out;
324         }
325         /*
326          * already loaded?
327          */
328         down_read(&dcssblk_devices_sem);
329         dev_info = dcssblk_get_device_by_name(local_buf);
330         up_read(&dcssblk_devices_sem);
331         if (dev_info != NULL) {
332                 PRINT_WARN("Segment %s already loaded!\n", local_buf);
333                 rc = -EEXIST;
334                 goto out;
335         }
336         /*
337          * get a struct dcssblk_dev_info
338          */
339         dev_info = kzalloc(sizeof(struct dcssblk_dev_info), GFP_KERNEL);
340         if (dev_info == NULL) {
341                 rc = -ENOMEM;
342                 goto out;
343         }
344
345         strcpy(dev_info->segment_name, local_buf);
346         strlcpy(dev_info->dev.bus_id, local_buf, BUS_ID_SIZE);
347         dev_info->dev.release = dcssblk_release_segment;
348         INIT_LIST_HEAD(&dev_info->lh);
349
350         dev_info->gd = alloc_disk(DCSSBLK_MINORS_PER_DISK);
351         if (dev_info->gd == NULL) {
352                 rc = -ENOMEM;
353                 goto free_dev_info;
354         }
355         dev_info->gd->major = dcssblk_major;
356         dev_info->gd->fops = &dcssblk_devops;
357         dev_info->dcssblk_queue = blk_alloc_queue(GFP_KERNEL);
358         dev_info->gd->queue = dev_info->dcssblk_queue;
359         dev_info->gd->private_data = dev_info;
360         dev_info->gd->driverfs_dev = &dev_info->dev;
361         blk_queue_make_request(dev_info->dcssblk_queue, dcssblk_make_request);
362         blk_queue_hardsect_size(dev_info->dcssblk_queue, 4096);
363         /*
364          * load the segment
365          */
366         rc = segment_load(local_buf, SEGMENT_SHARED,
367                                 &dev_info->start, &dev_info->end);
368         if (rc < 0) {
369                 segment_warning(rc, dev_info->segment_name);
370                 goto dealloc_gendisk;
371         }
372         seg_byte_size = (dev_info->end - dev_info->start + 1);
373         set_capacity(dev_info->gd, seg_byte_size >> 9); // size in sectors
374         PRINT_INFO("Loaded segment %s, size = %lu Byte, "
375                    "capacity = %lu (512 Byte) sectors\n", local_buf,
376                    seg_byte_size, seg_byte_size >> 9);
377
378         dev_info->segment_type = rc;
379         dev_info->save_pending = 0;
380         dev_info->is_shared = 1;
381         dev_info->dev.parent = dcssblk_root_dev;
382
383         /*
384          * get minor, add to list
385          */
386         down_write(&dcssblk_devices_sem);
387         rc = dcssblk_assign_free_minor(dev_info);
388         if (rc) {
389                 up_write(&dcssblk_devices_sem);
390                 PRINT_ERR("No free minor number available! "
391                           "Unloading segment...\n");
392                 goto unload_seg;
393         }
394         sprintf(dev_info->gd->disk_name, "dcssblk%d",
395                 dev_info->gd->first_minor);
396         list_add_tail(&dev_info->lh, &dcssblk_devices);
397
398         if (!try_module_get(THIS_MODULE)) {
399                 rc = -ENODEV;
400                 goto list_del;
401         }
402         /*
403          * register the device
404          */
405         rc = device_register(&dev_info->dev);
406         if (rc) {
407                 PRINT_ERR("Segment %s could not be registered RC=%d\n",
408                                 local_buf, rc);
409                 module_put(THIS_MODULE);
410                 goto list_del;
411         }
412         get_device(&dev_info->dev);
413         rc = device_create_file(&dev_info->dev, &dev_attr_shared);
414         if (rc)
415                 goto unregister_dev;
416         rc = device_create_file(&dev_info->dev, &dev_attr_save);
417         if (rc)
418                 goto unregister_dev;
419
420         add_disk(dev_info->gd);
421
422         switch (dev_info->segment_type) {
423                 case SEG_TYPE_SR:
424                 case SEG_TYPE_ER:
425                 case SEG_TYPE_SC:
426                         set_disk_ro(dev_info->gd,1);
427                         break;
428                 default:
429                         set_disk_ro(dev_info->gd,0);
430                         break;
431         }
432         PRINT_DEBUG("Segment %s loaded successfully\n", local_buf);
433         up_write(&dcssblk_devices_sem);
434         rc = count;
435         goto out;
436
437 unregister_dev:
438         list_del(&dev_info->lh);
439         blk_cleanup_queue(dev_info->dcssblk_queue);
440         dev_info->gd->queue = NULL;
441         put_disk(dev_info->gd);
442         device_unregister(&dev_info->dev);
443         segment_unload(dev_info->segment_name);
444         put_device(&dev_info->dev);
445         up_write(&dcssblk_devices_sem);
446         goto out;
447 list_del:
448         list_del(&dev_info->lh);
449         up_write(&dcssblk_devices_sem);
450 unload_seg:
451         segment_unload(local_buf);
452 dealloc_gendisk:
453         blk_cleanup_queue(dev_info->dcssblk_queue);
454         dev_info->gd->queue = NULL;
455         put_disk(dev_info->gd);
456 free_dev_info:
457         kfree(dev_info);
458 out:
459         kfree(local_buf);
460 out_nobuf:
461         return rc;
462 }
463
464 /*
465  * device attribute for removing devices
466  */
467 static ssize_t
468 dcssblk_remove_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
469 {
470         struct dcssblk_dev_info *dev_info;
471         int rc, i;
472         char *local_buf;
473
474         if (dev != dcssblk_root_dev) {
475                 return -EINVAL;
476         }
477         local_buf = kmalloc(count + 1, GFP_KERNEL);
478         if (local_buf == NULL) {
479                 return -ENOMEM;
480         }
481         /*
482          * parse input
483          */
484         for (i = 0; ((*(buf+i)!='\0') && (*(buf+i)!='\n') && i < count); i++) {
485                 local_buf[i] = toupper(buf[i]);
486         }
487         local_buf[i] = '\0';
488         if ((i == 0) || (i > 8)) {
489                 rc = -ENAMETOOLONG;
490                 goto out_buf;
491         }
492
493         down_write(&dcssblk_devices_sem);
494         dev_info = dcssblk_get_device_by_name(local_buf);
495         if (dev_info == NULL) {
496                 up_write(&dcssblk_devices_sem);
497                 PRINT_WARN("Segment %s is not loaded!\n", local_buf);
498                 rc = -ENODEV;
499                 goto out_buf;
500         }
501         if (atomic_read(&dev_info->use_count) != 0) {
502                 up_write(&dcssblk_devices_sem);
503                 PRINT_WARN("Segment %s is in use!\n", local_buf);
504                 rc = -EBUSY;
505                 goto out_buf;
506         }
507         list_del(&dev_info->lh);
508
509         del_gendisk(dev_info->gd);
510         blk_cleanup_queue(dev_info->dcssblk_queue);
511         dev_info->gd->queue = NULL;
512         put_disk(dev_info->gd);
513         device_unregister(&dev_info->dev);
514         segment_unload(dev_info->segment_name);
515         PRINT_DEBUG("Segment %s unloaded successfully\n",
516                         dev_info->segment_name);
517         put_device(&dev_info->dev);
518         up_write(&dcssblk_devices_sem);
519
520         rc = count;
521 out_buf:
522         kfree(local_buf);
523         return rc;
524 }
525
526 static int
527 dcssblk_open(struct inode *inode, struct file *filp)
528 {
529         struct dcssblk_dev_info *dev_info;
530         int rc;
531
532         dev_info = inode->i_bdev->bd_disk->private_data;
533         if (NULL == dev_info) {
534                 rc = -ENODEV;
535                 goto out;
536         }
537         atomic_inc(&dev_info->use_count);
538         inode->i_bdev->bd_block_size = 4096;
539         rc = 0;
540 out:
541         return rc;
542 }
543
544 static int
545 dcssblk_release(struct inode *inode, struct file *filp)
546 {
547         struct dcssblk_dev_info *dev_info;
548         int rc;
549
550         dev_info = inode->i_bdev->bd_disk->private_data;
551         if (NULL == dev_info) {
552                 rc = -ENODEV;
553                 goto out;
554         }
555         down_write(&dcssblk_devices_sem);
556         if (atomic_dec_and_test(&dev_info->use_count)
557             && (dev_info->save_pending)) {
558                 PRINT_INFO("Segment %s became idle and is being saved now\n",
559                             dev_info->segment_name);
560                 segment_save(dev_info->segment_name);
561                 dev_info->save_pending = 0;
562         }
563         up_write(&dcssblk_devices_sem);
564         rc = 0;
565 out:
566         return rc;
567 }
568
569 static int
570 dcssblk_make_request(struct request_queue *q, struct bio *bio)
571 {
572         struct dcssblk_dev_info *dev_info;
573         struct bio_vec *bvec;
574         unsigned long index;
575         unsigned long page_addr;
576         unsigned long source_addr;
577         unsigned long bytes_done;
578         int i;
579
580         bytes_done = 0;
581         dev_info = bio->bi_bdev->bd_disk->private_data;
582         if (dev_info == NULL)
583                 goto fail;
584         if ((bio->bi_sector & 7) != 0 || (bio->bi_size & 4095) != 0)
585                 /* Request is not page-aligned. */
586                 goto fail;
587         if (((bio->bi_size >> 9) + bio->bi_sector)
588                         > get_capacity(bio->bi_bdev->bd_disk)) {
589                 /* Request beyond end of DCSS segment. */
590                 goto fail;
591         }
592         /* verify data transfer direction */
593         if (dev_info->is_shared) {
594                 switch (dev_info->segment_type) {
595                 case SEG_TYPE_SR:
596                 case SEG_TYPE_ER:
597                 case SEG_TYPE_SC:
598                         /* cannot write to these segments */
599                         if (bio_data_dir(bio) == WRITE) {
600                                 PRINT_WARN("rejecting write to ro segment %s\n", dev_info->dev.bus_id);
601                                 goto fail;
602                         }
603                 }
604         }
605
606         index = (bio->bi_sector >> 3);
607         bio_for_each_segment(bvec, bio, i) {
608                 page_addr = (unsigned long)
609                         page_address(bvec->bv_page) + bvec->bv_offset;
610                 source_addr = dev_info->start + (index<<12) + bytes_done;
611                 if (unlikely((page_addr & 4095) != 0) || (bvec->bv_len & 4095) != 0)
612                         // More paranoia.
613                         goto fail;
614                 if (bio_data_dir(bio) == READ) {
615                         memcpy((void*)page_addr, (void*)source_addr,
616                                 bvec->bv_len);
617                 } else {
618                         memcpy((void*)source_addr, (void*)page_addr,
619                                 bvec->bv_len);
620                 }
621                 bytes_done += bvec->bv_len;
622         }
623         bio_endio(bio, 0);
624         return 0;
625 fail:
626         bio_io_error(bio);
627         return 0;
628 }
629
630 static int
631 dcssblk_direct_access (struct block_device *bdev, sector_t secnum,
632                         void **kaddr, unsigned long *pfn)
633 {
634         struct dcssblk_dev_info *dev_info;
635         unsigned long pgoff;
636
637         dev_info = bdev->bd_disk->private_data;
638         if (!dev_info)
639                 return -ENODEV;
640         if (secnum % (PAGE_SIZE/512))
641                 return -EINVAL;
642         pgoff = secnum / (PAGE_SIZE / 512);
643         if ((pgoff+1)*PAGE_SIZE-1 > dev_info->end - dev_info->start)
644                 return -ERANGE;
645         *kaddr = (void *) (dev_info->start+pgoff*PAGE_SIZE);
646         *pfn = virt_to_phys(*kaddr) >> PAGE_SHIFT;
647
648         return 0;
649 }
650
651 static void
652 dcssblk_check_params(void)
653 {
654         int rc, i, j, k;
655         char buf[9];
656         struct dcssblk_dev_info *dev_info;
657
658         for (i = 0; (i < DCSSBLK_PARM_LEN) && (dcssblk_segments[i] != '\0');
659              i++) {
660                 for (j = i; (dcssblk_segments[j] != ',')  &&
661                             (dcssblk_segments[j] != '\0') &&
662                             (dcssblk_segments[j] != '(')  &&
663                             (j - i) < 8; j++)
664                 {
665                         buf[j-i] = dcssblk_segments[j];
666                 }
667                 buf[j-i] = '\0';
668                 rc = dcssblk_add_store(dcssblk_root_dev, NULL, buf, j-i);
669                 if ((rc >= 0) && (dcssblk_segments[j] == '(')) {
670                         for (k = 0; buf[k] != '\0'; k++)
671                                 buf[k] = toupper(buf[k]);
672                         if (!strncmp(&dcssblk_segments[j], "(local)", 7)) {
673                                 down_read(&dcssblk_devices_sem);
674                                 dev_info = dcssblk_get_device_by_name(buf);
675                                 up_read(&dcssblk_devices_sem);
676                                 if (dev_info)
677                                         dcssblk_shared_store(&dev_info->dev,
678                                                              NULL, "0\n", 2);
679                         }
680                 }
681                 while ((dcssblk_segments[j] != ',') &&
682                        (dcssblk_segments[j] != '\0'))
683                 {
684                         j++;
685                 }
686                 if (dcssblk_segments[j] == '\0')
687                         break;
688                 i = j;
689         }
690 }
691
692 /*
693  * The init/exit functions.
694  */
695 static void __exit
696 dcssblk_exit(void)
697 {
698         s390_root_dev_unregister(dcssblk_root_dev);
699         unregister_blkdev(dcssblk_major, DCSSBLK_NAME);
700 }
701
702 static int __init
703 dcssblk_init(void)
704 {
705         int rc;
706
707         dcssblk_root_dev = s390_root_dev_register("dcssblk");
708         if (IS_ERR(dcssblk_root_dev))
709                 return PTR_ERR(dcssblk_root_dev);
710         rc = device_create_file(dcssblk_root_dev, &dev_attr_add);
711         if (rc) {
712                 s390_root_dev_unregister(dcssblk_root_dev);
713                 return rc;
714         }
715         rc = device_create_file(dcssblk_root_dev, &dev_attr_remove);
716         if (rc) {
717                 s390_root_dev_unregister(dcssblk_root_dev);
718                 return rc;
719         }
720         rc = register_blkdev(0, DCSSBLK_NAME);
721         if (rc < 0) {
722                 s390_root_dev_unregister(dcssblk_root_dev);
723                 return rc;
724         }
725         dcssblk_major = rc;
726         init_rwsem(&dcssblk_devices_sem);
727
728         dcssblk_check_params();
729
730         return 0;
731 }
732
733 module_init(dcssblk_init);
734 module_exit(dcssblk_exit);
735
736 module_param_string(segments, dcssblk_segments, DCSSBLK_PARM_LEN, 0444);
737 MODULE_PARM_DESC(segments, "Name of DCSS segment(s) to be loaded, "
738                  "comma-separated list, each name max. 8 chars.\n"
739                  "Adding \"(local)\" to segment name equals echoing 0 to "
740                  "/sys/devices/dcssblk/<segment name>/shared after loading "
741                  "the segment - \n"
742                  "e.g. segments=\"mydcss1,mydcss2,mydcss3(local)\"");
743
744 MODULE_LICENSE("GPL");