Merge branch 'for-4.5/for-jens' of git://git.kernel.org/pub/scm/linux/kernel/git...

[cascardo/linux.git] / drivers / block / floppy.c

diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index c1aacca..b206115 100644 (file)
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -2351,7 +2351,7 @@ static void rw_interrupt(void)
        }
 
        if (CT(COMMAND) != FD_READ ||
-           raw_cmd->kernel_data == current_req->buffer) {
+           raw_cmd->kernel_data == bio_data(current_req->bio)) {
                /* transfer directly from buffer */
                cont->done(1);
        } else if (CT(COMMAND) == FD_READ) {
@@ -2640,7 +2640,7 @@ static int make_raw_rw_request(void)
                raw_cmd->flags &= ~FD_RAW_WRITE;
                raw_cmd->flags |= FD_RAW_READ;
                COMMAND = FM_MODE(_floppy, FD_READ);
-       } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
+       } else if ((unsigned long)bio_data(current_req->bio) < MAX_DMA_ADDRESS) {
                unsigned long dma_limit;
                int direct, indirect;
 
@@ -2654,13 +2654,13 @@ static int make_raw_rw_request(void)
                 */
                max_size = buffer_chain_size();
                dma_limit = (MAX_DMA_ADDRESS -
-                            ((unsigned long)current_req->buffer)) >> 9;
+                            ((unsigned long)bio_data(current_req->bio))) >> 9;
                if ((unsigned long)max_size > dma_limit)
                        max_size = dma_limit;
                /* 64 kb boundaries */
-               if (CROSS_64KB(current_req->buffer, max_size << 9))
+               if (CROSS_64KB(bio_data(current_req->bio), max_size << 9))
                        max_size = (K_64 -
-                                   ((unsigned long)current_req->buffer) %
+                                   ((unsigned long)bio_data(current_req->bio)) %
                                    K_64) >> 9;
                direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
                /*
@@ -2677,7 +2677,7 @@ static int make_raw_rw_request(void)
                       (DP->read_track & (1 << DRS->probed_format)))))) {
                        max_size = blk_rq_sectors(current_req);
                } else {
-                       raw_cmd->kernel_data = current_req->buffer;
+                       raw_cmd->kernel_data = bio_data(current_req->bio);
                        raw_cmd->length = current_count_sectors << 9;
                        if (raw_cmd->length == 0) {
                                DPRINT("%s: zero dma transfer attempted\n", __func__);
@@ -2731,7 +2731,7 @@ static int make_raw_rw_request(void)
        raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
        raw_cmd->length <<= 9;
        if ((raw_cmd->length < current_count_sectors << 9) ||
-           (raw_cmd->kernel_data != current_req->buffer &&
+           (raw_cmd->kernel_data != bio_data(current_req->bio) &&
             CT(COMMAND) == FD_WRITE &&
             (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
              aligned_sector_t < buffer_min)) ||
@@ -2739,7 +2739,7 @@ static int make_raw_rw_request(void)
            raw_cmd->length <= 0 || current_count_sectors <= 0) {
                DPRINT("fractionary current count b=%lx s=%lx\n",
                       raw_cmd->length, current_count_sectors);
-               if (raw_cmd->kernel_data != current_req->buffer)
+               if (raw_cmd->kernel_data != bio_data(current_req->bio))
                        pr_info("addr=%d, length=%ld\n",
                                (int)((raw_cmd->kernel_data -
                                       floppy_track_buffer) >> 9),
@@ -2756,7 +2756,7 @@ static int make_raw_rw_request(void)
                return 0;
        }
 
-       if (raw_cmd->kernel_data != current_req->buffer) {
+       if (raw_cmd->kernel_data != bio_data(current_req->bio)) {
                if (raw_cmd->kernel_data < floppy_track_buffer ||
                    current_count_sectors < 0 ||
                    raw_cmd->length < 0 ||
@@ -3585,7 +3585,7 @@ static void __init config_types(void)
                unsigned int type = UDP->cmos;
                struct floppy_drive_params *params;
                const char *name = NULL;
-               static char temparea[32];
+               char temparea[32];
 
                if (type < ARRAY_SIZE(default_drive_params)) {
                        params = &default_drive_params[type].params;
@@ -3596,7 +3596,8 @@ static void __init config_types(void)
                                allowed_drive_mask &= ~(1 << drive);
                } else {
                        params = &default_drive_params[0].params;
-                       sprintf(temparea, "unknown type %d (usb?)", type);
+                       snprintf(temparea, sizeof(temparea),
+                                "unknown type %d (usb?)", type);
                        name = temparea;
                }
                if (name) {
@@ -3772,13 +3773,14 @@ struct rb0_cbdata {
        struct completion complete;
 };
 
-static void floppy_rb0_cb(struct bio *bio, int err)
+static void floppy_rb0_cb(struct bio *bio)
 {
        struct rb0_cbdata *cbdata = (struct rb0_cbdata *)bio->bi_private;
        int drive = cbdata->drive;
 
-       if (err) {
-               pr_info("floppy: error %d while reading block 0", err);
+       if (bio->bi_error) {
+               pr_info("floppy: error %d while reading block 0\n",
+                       bio->bi_error);
                set_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags);
        }
        complete(&cbdata->complete);
@@ -3813,7 +3815,7 @@ static int __floppy_read_block_0(struct block_device *bdev, int drive)
        bio.bi_iter.bi_size = size;
        bio.bi_bdev = bdev;
        bio.bi_iter.bi_sector = 0;
-       bio.bi_flags = (1 << BIO_QUIET);
+       bio.bi_flags |= (1 << BIO_QUIET);
        bio.bi_private = &cbdata;
        bio.bi_end_io = floppy_rb0_cb;
 
@@ -4115,6 +4117,13 @@ static ssize_t floppy_cmos_show(struct device *dev,
 
 static DEVICE_ATTR(cmos, S_IRUGO, floppy_cmos_show, NULL);
 
+static struct attribute *floppy_dev_attrs[] = {
+       &dev_attr_cmos.attr,
+       NULL
+};
+
+ATTRIBUTE_GROUPS(floppy_dev);
+
 static void floppy_device_release(struct device *dev)
 {
 }
@@ -4327,16 +4336,12 @@ static int __init do_floppy_init(void)
                floppy_device[drive].name = floppy_device_name;
                floppy_device[drive].id = drive;
                floppy_device[drive].dev.release = floppy_device_release;
+               floppy_device[drive].dev.groups = floppy_dev_groups;
 
                err = platform_device_register(&floppy_device[drive]);
                if (err)
                        goto out_remove_drives;
 
-               err = device_create_file(&floppy_device[drive].dev,
-                                        &dev_attr_cmos);
-               if (err)
-                       goto out_unreg_platform_dev;
-
                /* to be cleaned up... */
                disks[drive]->private_data = (void *)(long)drive;
                disks[drive]->flags |= GENHD_FL_REMOVABLE;
@@ -4346,13 +4351,10 @@ static int __init do_floppy_init(void)
 
        return 0;
 
-out_unreg_platform_dev:
-       platform_device_unregister(&floppy_device[drive]);
 out_remove_drives:
        while (drive--) {
                if (floppy_available(drive)) {
                        del_gendisk(disks[drive]);
-                       device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
                        platform_device_unregister(&floppy_device[drive]);
                }
        }
@@ -4597,7 +4599,6 @@ static void __exit floppy_module_exit(void)
 
                if (floppy_available(drive)) {
                        del_gendisk(disks[drive]);
-                       device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
                        platform_device_unregister(&floppy_device[drive]);
                }
                blk_cleanup_queue(disks[drive]->queue);