Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=0571c7a4f58fc6070fb9d556e4896de864c2a593
Commit:     0571c7a4f58fc6070fb9d556e4896de864c2a593
Parent:     6e5fa7b88c376b9d33228888f2ccd71fc79b2a17
Author:     Borislav Petkov <[EMAIL PROTECTED]>
AuthorDate: Sat Feb 2 19:56:38 2008 +0100
Committer:  Bartlomiej Zolnierkiewicz <[EMAIL PROTECTED]>
CommitDate: Sat Feb 2 19:56:38 2008 +0100

    ide-floppy: fix most of the remaining checkpatch.pl issues
    
    such as
    ERROR: switch and case should be at the same indent
    ERROR: need spaces around that '=' (ctx:VxV)
    ERROR: trailing statements should be on next line
    WARNING: no space between function name and open parenthesis '('
    WARNING: printk() should include KERN_ facility level
    ERROR: That open brace { should be on the previous line
    ERROR: use tabs not spaces
    ERROR: do not use assignment in if condition
    WARNING: braces {} are not necessary for single statement blocks
    ERROR: need space after that ',' (ctx:VxV)
    WARNING: line over 80 characters
    ERROR: do not use assignment in if condition
    ...
    and so on.
    
    Signed-off-by: Borislav Petkov <[EMAIL PROTECTED]>
    Signed-off-by: Bartlomiej Zolnierkiewicz <[EMAIL PROTECTED]>
---
 drivers/ide/ide-floppy.c |  355 +++++++++++++++++++++-------------------------
 1 files changed, 160 insertions(+), 195 deletions(-)

diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index ac66622..864ccd1 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -4,9 +4,7 @@
  * Copyright (C) 1996-1999  Gadi Oxman <[EMAIL PROTECTED]>
  * Copyright (C) 2000-2002  Paul Bristow <[EMAIL PROTECTED]>
  * Copyright (C) 2005       Bartlomiej Zolnierkiewicz
- */
-
-/*
+ *
  * The driver currently doesn't have any fancy features, just the bare
  * minimum read/write support.
  *
@@ -51,57 +49,56 @@
 #define IDEFLOPPY_DEBUG_LOG            0
 
 /* #define IDEFLOPPY_DEBUG(fmt, args...) printk(KERN_INFO fmt, ## args) */
-#define IDEFLOPPY_DEBUG( fmt, args... )
+#define IDEFLOPPY_DEBUG(fmt, args...)
 
 #if IDEFLOPPY_DEBUG_LOG
 #define debug_log(fmt, args...) \
        printk(KERN_INFO "ide-floppy: " fmt, ## args)
 #else
-#define debug_log(fmt, args... ) do {} while(0)
+#define debug_log(fmt, args...) do {} while (0)
 #endif
 
 
-/*
- *     Some drives require a longer irq timeout.
- */
+/* Some drives require a longer irq timeout. */
 #define IDEFLOPPY_WAIT_CMD             (5 * WAIT_CMD)
 
 /*
- *     After each failed packet command we issue a request sense command
- *     and retry the packet command IDEFLOPPY_MAX_PC_RETRIES times.
+ * After each failed packet command we issue a request sense command and retry
+ * the packet command IDEFLOPPY_MAX_PC_RETRIES times.
  */
 #define IDEFLOPPY_MAX_PC_RETRIES       3
 
 /*
- *     With each packet command, we allocate a buffer of
- *     IDEFLOPPY_PC_BUFFER_SIZE bytes.
+ * With each packet command, we allocate a buffer of IDEFLOPPY_PC_BUFFER_SIZE
+ * bytes.
  */
 #define IDEFLOPPY_PC_BUFFER_SIZE       256
 
 /*
- *     In various places in the driver, we need to allocate storage
- *     for packet commands and requests, which will remain valid while
- *     we leave the driver to wait for an interrupt or a timeout event.
+ * In various places in the driver, we need to allocate storage for packet
+ * commands and requests, which will remain valid while        we leave the 
driver to
+ * wait for an interrupt or a timeout event.
  */
 #define IDEFLOPPY_PC_STACK             (10 + IDEFLOPPY_MAX_PC_RETRIES)
 
-/*
- *     Our view of a packet command.
- */
 typedef struct idefloppy_packet_command_s {
        u8 c[12];                               /* Actual packet bytes */
-       int retries;                            /* On each retry, we increment 
retries */
+       int retries;                            /* On each retry, we increment
+                                                  retries */
        int error;                              /* Error code */
        int request_transfer;                   /* Bytes to transfer */
        int actually_transferred;               /* Bytes actually transferred */
        int buffer_size;                        /* Size of our data buffer */
-       int b_count;                            /* Missing/Available data on 
the current buffer */
+       int b_count;                            /* Missing/Available data on
+                                                  the current buffer */
        struct request *rq;                     /* The corresponding request */
        u8 *buffer;                             /* Data buffer */
-       u8 *current_position;                   /* Pointer into the above 
buffer */
-       void (*callback) (ide_drive_t *);       /* Called when this packet 
command is completed */
+       u8 *current_position;                   /* Pointer into above buffer */
+       void (*callback) (ide_drive_t *);       /* Called when this packet
+                                                  command is completed */
        u8 pc_buffer[IDEFLOPPY_PC_BUFFER_SIZE]; /* Temporary buffer */
-       unsigned long flags;                    /* Status/Action bit flags: 
long for set_bit */
+       unsigned long flags;                    /* Status/Action bit flags: long
+                                                  for set_bit */
 } idefloppy_pc_t;
 
 /* Packet command flag bits. */
@@ -125,9 +122,9 @@ enum {
 #define CAPACITY_NO_CARTRIDGE  0x03
 
 /*
- *     Most of our global data which we need to save even as we leave the
- *     driver due to an interrupt or a timer event is stored in a variable
- *     of type idefloppy_floppy_t, defined below.
+ * Most of our global data which we need to save even as we leave the driver
+ * due to an interrupt or a timer event is stored in a variable of type
+ * idefloppy_floppy_t, defined below.
  */
 typedef struct ide_floppy_obj {
        ide_drive_t     *drive;
@@ -148,17 +145,13 @@ typedef struct ide_floppy_obj {
        /* We implement a circular array */
        int rq_stack_index;
 
-       /*
-        *      Last error information
-        */
+       /* Last error information */
        u8 sense_key, asc, ascq;
        /* delay this long before sending packet command */
        u8 ticks;
        int progress_indication;
 
-       /*
-        *      Device information
-        */
+       /* Device information */
        /* Current format */
        int blocks, block_size, bs_factor;
        /* Last format capacity descriptor */
@@ -189,34 +182,26 @@ enum {
        IDEFLOPPY_FLAG_ZIP_DRIVE                = (1 << 4),
 };
 
-/*
- *     Defines for the mode sense command
- */
+/* Defines for the MODE SENSE command */
 #define MODE_SENSE_CURRENT             0x00
 #define MODE_SENSE_CHANGEABLE          0x01
-#define MODE_SENSE_DEFAULT             0x02 
+#define MODE_SENSE_DEFAULT             0x02
 #define MODE_SENSE_SAVED               0x03
 
-/*
- *     IOCTLs used in low-level formatting.
- */
-
+/* IOCTLs used in low-level formatting. */
 #define        IDEFLOPPY_IOCTL_FORMAT_SUPPORTED        0x4600
 #define        IDEFLOPPY_IOCTL_FORMAT_GET_CAPACITY     0x4601
 #define        IDEFLOPPY_IOCTL_FORMAT_START            0x4602
 #define IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS    0x4603
 
-/*
- *     Error codes which are returned in rq->errors to the higher part
- *     of the driver.
- */
+/* Error code returned in rq->errors to the higher part of the driver. */
 #define        IDEFLOPPY_ERROR_GENERAL         101
 
 /*
- *     The following is used to format the general configuration word of
- *     the ATAPI IDENTIFY DEVICE command.
+ * The following is used to format the general configuration word of the
+ * ATAPI IDENTIFY DEVICE command.
  */
-struct idefloppy_id_gcw {      
+struct idefloppy_id_gcw {
 #if defined(__LITTLE_ENDIAN_BITFIELD)
        unsigned packet_size            :2;     /* Packet Size */
        unsigned reserved234            :3;     /* Reserved */
@@ -274,10 +259,10 @@ static void ide_floppy_put(struct ide_floppy_obj *floppy)
 }
 
 /*
- *     Too bad. The drive wants to send us data which we are not ready to 
accept.
- *     Just throw it away.
+ * Too bad. The drive wants to send us data which we are not ready to accept.
+ * Just throw it away.
  */
-static void idefloppy_discard_data (ide_drive_t *drive, unsigned int bcount)
+static void idefloppy_discard_data(ide_drive_t *drive, unsigned int bcount)
 {
        while (bcount--)
                (void) HWIF(drive)->INB(IDE_DATA_REG);
@@ -291,10 +276,8 @@ static void idefloppy_write_zeros(ide_drive_t *drive, 
unsigned int bcount)
 
 
 /*
- *     idefloppy_do_end_request is used to finish servicing a request.
- *
- *     For read/write requests, we will call ide_end_request to pass to the
- *     next buffer.
+ * Used to finish servicing a request. For read/write requests, we will call
+ * ide_end_request to pass to the next buffer.
  */
 static int idefloppy_do_end_request(ide_drive_t *drive, int uptodate, int 
nsecs)
 {
@@ -305,9 +288,9 @@ static int idefloppy_do_end_request(ide_drive_t *drive, int 
uptodate, int nsecs)
        debug_log("Reached %s\n", __func__);
 
        switch (uptodate) {
-               case 0: error = IDEFLOPPY_ERROR_GENERAL; break;
-               case 1: error = 0; break;
-               default: error = uptodate;
+       case 0: error = IDEFLOPPY_ERROR_GENERAL; break;
+       case 1: error = 0; break;
+       default: error = uptodate;
        }
        if (error)
                floppy->failed_pc = NULL;
@@ -366,7 +349,7 @@ static void ide_floppy_io_buffers(ide_drive_t *drive, 
idefloppy_pc_t *pc,
        }
 }
 
-static void idefloppy_update_buffers (ide_drive_t *drive, idefloppy_pc_t *pc)
+static void idefloppy_update_buffers(ide_drive_t *drive, idefloppy_pc_t *pc)
 {
        struct request *rq = pc->rq;
        struct bio *bio = rq->bio;
@@ -376,11 +359,12 @@ static void idefloppy_update_buffers (ide_drive_t *drive, 
idefloppy_pc_t *pc)
 }
 
 /*
- *     idefloppy_queue_pc_head generates a new packet command request in front
- *     of the request queue, before the current request, so that it will be
- *     processed immediately, on the next pass through the driver.
+ * Generate a new packet command request in front of the request queue, before
+ * the current request so that it will be processed immediately, on the next
+ * pass through the driver.
  */
-static void idefloppy_queue_pc_head (ide_drive_t *drive,idefloppy_pc_t 
*pc,struct request *rq)
+static void idefloppy_queue_pc_head(ide_drive_t *drive, idefloppy_pc_t *pc,
+               struct request *rq)
 {
        struct ide_floppy_obj *floppy = drive->driver_data;
 
@@ -391,16 +375,16 @@ static void idefloppy_queue_pc_head (ide_drive_t 
*drive,idefloppy_pc_t *pc,struc
        (void) ide_do_drive_cmd(drive, rq, ide_preempt);
 }
 
-static idefloppy_pc_t *idefloppy_next_pc_storage (ide_drive_t *drive)
+static idefloppy_pc_t *idefloppy_next_pc_storage(ide_drive_t *drive)
 {
        idefloppy_floppy_t *floppy = drive->driver_data;
 
        if (floppy->pc_stack_index == IDEFLOPPY_PC_STACK)
-               floppy->pc_stack_index=0;
+               floppy->pc_stack_index = 0;
        return (&floppy->pc_stack[floppy->pc_stack_index++]);
 }
 
-static struct request *idefloppy_next_rq_storage (ide_drive_t *drive)
+static struct request *idefloppy_next_rq_storage(ide_drive_t *drive)
 {
        idefloppy_floppy_t *floppy = drive->driver_data;
 
@@ -445,10 +429,8 @@ static void idefloppy_request_sense_callback(ide_drive_t 
*drive)
        }
 }
 
-/*
- *     General packet command callback function.
- */
-static void idefloppy_pc_callback (ide_drive_t *drive)
+/* General packet command callback function. */
+static void idefloppy_pc_callback(ide_drive_t *drive)
 {
        idefloppy_floppy_t *floppy = drive->driver_data;
 
@@ -457,10 +439,7 @@ static void idefloppy_pc_callback (ide_drive_t *drive)
        idefloppy_do_end_request(drive, floppy->pc->error ? 0 : 1, 0);
 }
 
-/*
- *     idefloppy_init_pc initializes a packet command.
- */
-static void idefloppy_init_pc (idefloppy_pc_t *pc)
+static void idefloppy_init_pc(idefloppy_pc_t *pc)
 {
        memset(pc->c, 0, 12);
        pc->retries = 0;
@@ -471,7 +450,7 @@ static void idefloppy_init_pc (idefloppy_pc_t *pc)
        pc->callback = &idefloppy_pc_callback;
 }
 
-static void idefloppy_create_request_sense_cmd (idefloppy_pc_t *pc)
+static void idefloppy_create_request_sense_cmd(idefloppy_pc_t *pc)
 {
        idefloppy_init_pc(pc);
        pc->c[0] = GPCMD_REQUEST_SENSE;
@@ -481,11 +460,10 @@ static void idefloppy_create_request_sense_cmd 
(idefloppy_pc_t *pc)
 }
 
 /*
- *     idefloppy_retry_pc is called when an error was detected during the
- *     last packet command. We queue a request sense packet command in
- *     the head of the request list.
+ * Called when an error was detected during the last packet command. We queue a
+ * request sense packet command in the head of the request list.
  */
-static void idefloppy_retry_pc (ide_drive_t *drive)
+static void idefloppy_retry_pc(ide_drive_t *drive)
 {
        idefloppy_pc_t *pc;
        struct request *rq;
@@ -528,7 +506,8 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t 
*drive)
        /* Clear the interrupt */
        stat = drive->hwif->INB(IDE_STATUS_REG);
 
-       if ((stat & DRQ_STAT) == 0) {           /* No more interrupts */
+       /* No more interrupts */
+       if ((stat & DRQ_STAT) == 0) {
                debug_log("Packet command completed, %d bytes transferred\n",
                                pc->actually_transferred);
                pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
@@ -628,7 +607,7 @@ static ide_startstop_t idefloppy_pc_intr (ide_drive_t 
*drive)
  * It fails at high speeds on the Iomega ZIP drive, so there's a slower version
  * for that drive below. The algorithm is chosen based on drive type
  */
-static ide_startstop_t idefloppy_transfer_pc (ide_drive_t *drive)
+static ide_startstop_t idefloppy_transfer_pc(ide_drive_t *drive)
 {
        ide_startstop_t startstop;
        idefloppy_floppy_t *floppy = drive->driver_data;
@@ -655,18 +634,16 @@ static ide_startstop_t idefloppy_transfer_pc (ide_drive_t 
*drive)
 
 
 /*
- * What we have here is a classic case of a top half / bottom half
- * interrupt service routine. In interrupt mode, the device sends
- * an interrupt to signal it's ready to receive a packet. However,
- * we need to delay about 2-3 ticks before issuing the packet or we
- * gets in trouble.
+ * What we have here is a classic case of a top half / bottom half interrupt
+ * service routine. In interrupt mode, the device sends an interrupt to signal
+ * that it is ready to receive a packet. However, we need to delay about 2-3
+ * ticks before issuing the packet or we gets in trouble.
  *
- * So, follow carefully. transfer_pc1 is called as an interrupt (or
- * directly). In either case, when the device says it's ready for a 
- * packet, we schedule the packet transfer to occur about 2-3 ticks
- * later in transfer_pc2.
+ * So, follow carefully. transfer_pc1 is called as an interrupt (or directly).
+ * In either case, when the device says it's ready for a packet, we schedule
+ * the packet transfer to occur about 2-3 ticks later in transfer_pc2.
  */
-static int idefloppy_transfer_pc2 (ide_drive_t *drive)
+static int idefloppy_transfer_pc2(ide_drive_t *drive)
 {
        idefloppy_floppy_t *floppy = drive->driver_data;
 
@@ -676,7 +653,7 @@ static int idefloppy_transfer_pc2 (ide_drive_t *drive)
        return IDEFLOPPY_WAIT_CMD;
 }
 
-static ide_startstop_t idefloppy_transfer_pc1 (ide_drive_t *drive)
+static ide_startstop_t idefloppy_transfer_pc1(ide_drive_t *drive)
 {
        idefloppy_floppy_t *floppy = drive->driver_data;
        ide_startstop_t startstop;
@@ -693,7 +670,7 @@ static ide_startstop_t idefloppy_transfer_pc1 (ide_drive_t 
*drive)
                                "while issuing a packet command\n");
                return ide_do_reset(drive);
        }
-       /* 
+       /*
         * The following delay solves a problem with ATAPI Zip 100 drives
         * where the Busy flag was apparently being deasserted before the
         * unit was ready to receive data. This was happening on a
@@ -702,10 +679,8 @@ static ide_startstop_t idefloppy_transfer_pc1 (ide_drive_t 
*drive)
         * used until after the packet is moved in about 50 msec.
         */
 
-       ide_set_handler(drive, 
-         &idefloppy_pc_intr,           /* service routine for packet command */
-         floppy->ticks,                /* wait this long before "failing" */
-         &idefloppy_transfer_pc2);     /* fail == transfer_pc2 */
+       ide_set_handler(drive, &idefloppy_pc_intr, floppy->ticks,
+                       &idefloppy_transfer_pc2);
        return ide_started;
 }
 
@@ -725,10 +700,8 @@ static void ide_floppy_report_error(idefloppy_floppy_t 
*floppy,
 
 }
 
-/*
- *     Issue a packet command
- */
-static ide_startstop_t idefloppy_issue_pc (ide_drive_t *drive, idefloppy_pc_t 
*pc)
+static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
+               idefloppy_pc_t *pc)
 {
        idefloppy_floppy_t *floppy = drive->driver_data;
        ide_hwif_t *hwif = drive->hwif;
@@ -773,7 +746,8 @@ static ide_startstop_t idefloppy_issue_pc (ide_drive_t 
*drive, idefloppy_pc_t *p
        ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK |
                           IDE_TFLAG_OUT_DEVICE, bcount, dma);
 
-       if (dma) {      /* Begin DMA, if necessary */
+       if (dma) {
+               /* Begin DMA, if necessary */
                pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
                hwif->dma_start(drive);
        }
@@ -801,7 +775,7 @@ static ide_startstop_t idefloppy_issue_pc (ide_drive_t 
*drive, idefloppy_pc_t *p
        }
 }
 
-static void idefloppy_rw_callback (ide_drive_t *drive)
+static void idefloppy_rw_callback(ide_drive_t *drive)
 {
        debug_log("Reached %s\n", __func__);
 
@@ -809,7 +783,7 @@ static void idefloppy_rw_callback (ide_drive_t *drive)
        return;
 }
 
-static void idefloppy_create_prevent_cmd (idefloppy_pc_t *pc, int prevent)
+static void idefloppy_create_prevent_cmd(idefloppy_pc_t *pc, int prevent)
 {
        debug_log("creating prevent removal command, prevent = %d\n", prevent);
 
@@ -818,7 +792,7 @@ static void idefloppy_create_prevent_cmd (idefloppy_pc_t 
*pc, int prevent)
        pc->c[4] = prevent;
 }
 
-static void idefloppy_create_read_capacity_cmd (idefloppy_pc_t *pc)
+static void idefloppy_create_read_capacity_cmd(idefloppy_pc_t *pc)
 {
        idefloppy_init_pc(pc);
        pc->c[0] = GPCMD_READ_FORMAT_CAPACITIES;
@@ -827,7 +801,7 @@ static void idefloppy_create_read_capacity_cmd 
(idefloppy_pc_t *pc)
        pc->request_transfer = 255;
 }
 
-static void idefloppy_create_format_unit_cmd (idefloppy_pc_t *pc, int b, int l,
+static void idefloppy_create_format_unit_cmd(idefloppy_pc_t *pc, int b, int l,
                                              int flags)
 {
        idefloppy_init_pc(pc);
@@ -844,38 +818,37 @@ static void idefloppy_create_format_unit_cmd 
(idefloppy_pc_t *pc, int b, int l,
 
        put_unaligned(cpu_to_be32(b), (unsigned int *)(&pc->buffer[4]));
        put_unaligned(cpu_to_be32(l), (unsigned int *)(&pc->buffer[8]));
-       pc->buffer_size=12;
+       pc->buffer_size = 12;
        pc->flags |= PC_FLAG_WRITING;
 }
 
-/*
- *     A mode sense command is used to "sense" floppy parameters.
- */
-static void idefloppy_create_mode_sense_cmd (idefloppy_pc_t *pc, u8 page_code, 
u8 type)
+/* A mode sense command is used to "sense" floppy parameters. */
+static void idefloppy_create_mode_sense_cmd(idefloppy_pc_t *pc, u8 page_code,
+               u8 type)
 {
        u16 length = 8; /* sizeof(Mode Parameter Header) = 8 Bytes */
-       
+
        idefloppy_init_pc(pc);
        pc->c[0] = GPCMD_MODE_SENSE_10;
        pc->c[1] = 0;
        pc->c[2] = page_code + (type << 6);
 
        switch (page_code) {
-               case IDEFLOPPY_CAPABILITIES_PAGE:
-                       length += 12;
-                       break;
-               case IDEFLOPPY_FLEXIBLE_DISK_PAGE:
-                       length += 32;
-                       break;
-               default:
-                       printk(KERN_ERR "ide-floppy: unsupported page code "
+       case IDEFLOPPY_CAPABILITIES_PAGE:
+               length += 12;
+               break;
+       case IDEFLOPPY_FLEXIBLE_DISK_PAGE:
+               length += 32;
+               break;
+       default:
+               printk(KERN_ERR "ide-floppy: unsupported page code "
                                "in create_mode_sense_cmd\n");
        }
        put_unaligned(cpu_to_be16(length), (u16 *) &pc->c[7]);
        pc->request_transfer = length;
 }
 
-static void idefloppy_create_start_stop_cmd (idefloppy_pc_t *pc, int start)
+static void idefloppy_create_start_stop_cmd(idefloppy_pc_t *pc, int start)
 {
        idefloppy_init_pc(pc);
        pc->c[0] = GPCMD_START_STOP_UNIT;
@@ -914,8 +887,8 @@ static void idefloppy_create_rw_cmd(idefloppy_floppy_t 
*floppy,
        pc->flags |= PC_FLAG_DMA_RECOMMENDED;
 }
 
-static void
-idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy, idefloppy_pc_t *pc, struct 
request *rq)
+static void idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy,
+               idefloppy_pc_t *pc, struct request *rq)
 {
        idefloppy_init_pc(pc);
        pc->callback = &idefloppy_rw_callback;
@@ -934,10 +907,8 @@ idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy, 
idefloppy_pc_t *pc, struct req
        pc->request_transfer = pc->buffer_size = rq->data_len;
 }
 
-/*
- *     idefloppy_do_request is our request handling function.  
- */
-static ide_startstop_t idefloppy_do_request (ide_drive_t *drive, struct 
request *rq, sector_t block_s)
+static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
+               struct request *rq, sector_t block_s)
 {
        idefloppy_floppy_t *floppy = drive->driver_data;
        idefloppy_pc_t *pc;
@@ -962,8 +933,8 @@ static ide_startstop_t idefloppy_do_request (ide_drive_t 
*drive, struct request
        if (blk_fs_request(rq)) {
                if (((long)rq->sector % floppy->bs_factor) ||
                    (rq->nr_sectors % floppy->bs_factor)) {
-                       printk("%s: unsupported r/w request size\n",
-                               drive->name);
+                       printk(KERN_ERR "%s: unsupported r/w request size\n",
+                                       drive->name);
                        idefloppy_do_end_request(drive, 0, 0);
                        return ide_stopped;
                }
@@ -986,15 +957,15 @@ static ide_startstop_t idefloppy_do_request (ide_drive_t 
*drive, struct request
 }
 
 /*
- *     idefloppy_queue_pc_tail adds a special packet command request to the
- *     tail of the request queue, and waits for it to be serviced.
+ * Add a special packet command request to the tail of the request queue,
+ * and wait for it to be serviced.
  */
-static int idefloppy_queue_pc_tail (ide_drive_t *drive,idefloppy_pc_t *pc)
+static int idefloppy_queue_pc_tail(ide_drive_t *drive, idefloppy_pc_t *pc)
 {
        struct ide_floppy_obj *floppy = drive->driver_data;
        struct request rq;
 
-       ide_init_drive_cmd (&rq);
+       ide_init_drive_cmd(&rq);
        rq.buffer = (char *) pc;
        rq.cmd_type = REQ_TYPE_SPECIAL;
        rq.rq_disk = floppy->disk;
@@ -1121,7 +1092,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
                /* Clik! drive returns this instead of CAPACITY_CURRENT */
                case CAPACITY_UNFORMATTED:
                        if (!(floppy->flags & IDEFLOPPY_FLAG_CLIK_DRIVE))
-                                /*
+                               /*
                                 * If it is not a clik drive, break out
                                 * (maintains previous driver behaviour)
                                 */
@@ -1247,14 +1218,14 @@ static int ide_floppy_get_format_capacities(ide_drive_t 
*drive, int __user *arg)
 }
 
 /*
-** Get ATAPI_FORMAT_UNIT progress indication.
-**
-** Userland gives a pointer to an int.  The int is set to a progress
-** indicator 0-65536, with 65536=100%.
-**
-** If the drive does not support format progress indication, we just check
-** the dsc bit, and return either 0 or 65536.
-*/
+ * Get ATAPI_FORMAT_UNIT progress indication.
+ *
+ * Userland gives a pointer to an int.  The int is set to a progress
+ * indicator 0-65536, with 65536=100%.
+ *
+ * If the drive does not support format progress indication, we just check
+ * the dsc bit, and return either 0 or 65536.
+ */
 
 static int idefloppy_get_format_progress(ide_drive_t *drive, int __user *arg)
 {
@@ -1264,17 +1235,15 @@ static int idefloppy_get_format_progress(ide_drive_t 
*drive, int __user *arg)
 
        if (floppy->srfp) {
                idefloppy_create_request_sense_cmd(&pc);
-               if (idefloppy_queue_pc_tail(drive, &pc)) {
+               if (idefloppy_queue_pc_tail(drive, &pc))
                        return (-EIO);
-               }
 
                if (floppy->sense_key == 2 &&
                    floppy->asc == 4 &&
-                   floppy->ascq == 4) {
+                   floppy->ascq == 4)
                        progress_indication = floppy->progress_indication;
-               }
-               /* Else assume format_unit has finished, and we're
-               ** at 0x10000 */
+
+               /* Else assume format_unit has finished, and we're at 0x10000 */
        } else {
                unsigned long flags;
                u8 stat;
@@ -1291,10 +1260,7 @@ static int idefloppy_get_format_progress(ide_drive_t 
*drive, int __user *arg)
        return (0);
 }
 
-/*
- *     Return the current floppy capacity.
- */
-static sector_t idefloppy_capacity (ide_drive_t *drive)
+static sector_t idefloppy_capacity(ide_drive_t *drive)
 {
        idefloppy_floppy_t *floppy = drive->driver_data;
        unsigned long capacity = floppy->blocks * floppy->bs_factor;
@@ -1344,22 +1310,20 @@ static void idefloppy_add_settings(ide_drive_t *drive)
 {
        idefloppy_floppy_t *floppy = drive->driver_data;
 
-/*
- *                     drive   setting name    read/write      data type       
min     max     mul_factor      div_factor      data pointer            set 
function
- */
-       ide_add_setting(drive,  "bios_cyl",     SETTING_RW,     TYPE_INT,       
0,      1023,           1,              1,      &drive->bios_cyl,       NULL);
-       ide_add_setting(drive,  "bios_head",    SETTING_RW,     TYPE_BYTE,      
0,      255,            1,              1,      &drive->bios_head,      NULL);
-       ide_add_setting(drive,  "bios_sect",    SETTING_RW,     TYPE_BYTE,      
0,      63,             1,              1,      &drive->bios_sect,      NULL);
-       ide_add_setting(drive,  "ticks",        SETTING_RW,     TYPE_BYTE,      
0,      255,            1,              1,      &floppy->ticks,         NULL);
+       ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 1023, 1, 1,
+                       &drive->bios_cyl, NULL);
+       ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
+                       &drive->bios_head, NULL);
+       ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0,  63, 1, 1,
+                       &drive->bios_sect, NULL);
+       ide_add_setting(drive, "ticks",    SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
+                       &floppy->ticks,  NULL);
 }
 #else
 static inline void idefloppy_add_settings(ide_drive_t *drive) { ; }
 #endif
 
-/*
- *     Driver initialization.
- */
-static void idefloppy_setup (ide_drive_t *drive, idefloppy_floppy_t *floppy)
+static void idefloppy_setup(ide_drive_t *drive, idefloppy_floppy_t *floppy)
 {
        struct idefloppy_id_gcw gcw;
 
@@ -1368,16 +1332,14 @@ static void idefloppy_setup (ide_drive_t *drive, 
idefloppy_floppy_t *floppy)
        if (gcw.drq_type == 1)
                floppy->flags |= IDEFLOPPY_FLAG_DRQ_INTERRUPT;
        /*
-        *      We used to check revisions here. At this point however
-        *      I'm giving up. Just assume they are all broken, its easier.
+        * We used to check revisions here. At this point however I'm giving up.
+        * Just assume they are all broken, its easier.
         *
-        *      The actual reason for the workarounds was likely
-        *      a driver bug after all rather than a firmware bug,
-        *      and the workaround below used to hide it. It should
-        *      be fixed as of version 1.9, but to be on the safe side
-        *      we'll leave the limitation below for the 2.2.x tree.
+        * The actual reason for the workarounds was likely a driver bug after
+        * all rather than a firmware bug, and the workaround below used to hide
+        * it. It should be fixed as of version 1.9, but to be on the safe side
+        * we'll leave the limitation below for the 2.2.x tree.
         */
-
        if (!strncmp(drive->id->model, "IOMEGA ZIP 100 ATAPI", 20)) {
                floppy->flags |= IDEFLOPPY_FLAG_ZIP_DRIVE;
                /* This value will be visible in the /proc/ide/hdx/settings */
@@ -1386,16 +1348,14 @@ static void idefloppy_setup (ide_drive_t *drive, 
idefloppy_floppy_t *floppy)
        }
 
        /*
-       *      Guess what?  The IOMEGA Clik! drive also needs the
-       *      above fix.  It makes nasty clicking noises without
-       *      it, so please don't remove this.
-       */
+        * Guess what? The IOMEGA Clik! drive also needs the above fix. It makes
+        * nasty clicking noises without it, so please don't remove this.
+        */
        if (strncmp(drive->id->model, "IOMEGA Clik!", 11) == 0) {
                blk_queue_max_sectors(drive->queue, 64);
                floppy->flags |= IDEFLOPPY_FLAG_CLIK_DRIVE;
        }
 
-
        (void) ide_floppy_get_capacity(drive);
        idefloppy_add_settings(drive);
 }
@@ -1425,19 +1385,19 @@ static void idefloppy_cleanup_obj(struct kref *kref)
 }
 
 #ifdef CONFIG_IDE_PROC_FS
-static int proc_idefloppy_read_capacity
-       (char *page, char **start, off_t off, int count, int *eof, void *data)
+static int proc_idefloppy_read_capacity(char *page, char **start, off_t off,
+               int count, int *eof, void *data)
 {
        ide_drive_t*drive = (ide_drive_t *)data;
        int len;
 
-       len = sprintf(page,"%llu\n", (long long)idefloppy_capacity(drive));
-       PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
+       len = sprintf(page, "%llu\n", (long long)idefloppy_capacity(drive));
+       PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
 static ide_proc_entry_t idefloppy_proc[] = {
-       { "capacity",   S_IFREG|S_IRUGO,        proc_idefloppy_read_capacity, 
NULL },
-       { "geometry",   S_IFREG|S_IRUGO,        proc_ide_read_geometry, NULL },
+       { "capacity",   S_IFREG|S_IRUGO, proc_idefloppy_read_capacity,  NULL },
+       { "geometry",   S_IFREG|S_IRUGO, proc_ide_read_geometry,        NULL },
        { NULL, 0, NULL, NULL }
 };
 #endif /* CONFIG_IDE_PROC_FS */
@@ -1474,7 +1434,8 @@ static int idefloppy_open(struct inode *inode, struct 
file *filp)
 
        debug_log("Reached %s\n", __func__);
 
-       if (!(floppy = ide_floppy_get(disk)))
+       floppy = ide_floppy_get(disk);
+       if (!floppy)
                return -ENXIO;
 
        drive = floppy->drive;
@@ -1494,10 +1455,10 @@ static int idefloppy_open(struct inode *inode, struct 
file *filp)
                if (ide_floppy_get_capacity(drive)
                   && (filp->f_flags & O_NDELAY) == 0
                    /*
-                   ** Allow O_NDELAY to open a drive without a disk, or with
-                   ** an unreadable disk, so that we can get the format
-                   ** capacity of the drive or begin the format - Sam
-                   */
+                    * Allow O_NDELAY to open a drive without a disk, or with an
+                    * unreadable disk, so that we can get the format capacity
+                    * of the drive or begin the format - Sam
+                    */
                    ) {
                        ret = -EIO;
                        goto out_put_floppy;
@@ -1726,16 +1687,20 @@ static int ide_floppy_probe(ide_drive_t *drive)
                goto failed;
        if (drive->media != ide_floppy)
                goto failed;
-       if (!idefloppy_identify_device (drive, drive->id)) {
-               printk (KERN_ERR "ide-floppy: %s: not supported by this version 
of ide-floppy\n", drive->name);
+       if (!idefloppy_identify_device(drive, drive->id)) {
+               printk(KERN_ERR "ide-floppy: %s: not supported by this version"
+                               " of ide-floppy\n", drive->name);
                goto failed;
        }
        if (drive->scsi) {
-               printk("ide-floppy: passing drive %s to ide-scsi emulation.\n", 
drive->name);
+               printk(KERN_INFO "ide-floppy: passing drive %s to ide-scsi"
+                               " emulation.\n", drive->name);
                goto failed;
        }
-       if ((floppy = kzalloc(sizeof (idefloppy_floppy_t), GFP_KERNEL)) == 
NULL) {
-               printk (KERN_ERR "ide-floppy: %s: Can't allocate a floppy 
structure\n", drive->name);
+       floppy = kzalloc(sizeof(idefloppy_floppy_t), GFP_KERNEL);
+       if (!floppy) {
+               printk(KERN_ERR "ide-floppy: %s: Can't allocate a floppy"
+                               " structure\n", drive->name);
                goto failed;
        }
 
@@ -1757,7 +1722,7 @@ static int ide_floppy_probe(ide_drive_t *drive)
 
        drive->driver_data = floppy;
 
-       idefloppy_setup (drive, floppy);
+       idefloppy_setup(drive, floppy);
 
        g->minors = 1 << PARTN_BITS;
        g->driverfs_dev = &drive->gendev;
@@ -1773,9 +1738,7 @@ failed:
        return -ENODEV;
 }
 
-MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
-
-static void __exit idefloppy_exit (void)
+static void __exit idefloppy_exit(void)
 {
        driver_unregister(&idefloppy_driver.gen_driver);
 }
@@ -1790,3 +1753,5 @@ MODULE_ALIAS("ide:*m-floppy*");
 module_init(idefloppy_init);
 module_exit(idefloppy_exit);
 MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
+
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to