mlx4_core: Change capability decoding: SRC->XRC

[linux-2.6-omap-h63xx.git] / drivers / scsi / sg.c

diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 3f8b93188567909201b12d209030990495405804..85d38940a6c91e2b0d5b546bb0705bdd3ab37f8a 100644 (file)
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -41,7 +41,6 @@ static int sg_version_num = 30534;    /* 2 digits for each component */
 #include <linux/fcntl.h>
 #include <linux/init.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
 #include <linux/moduleparam.h>
 #include <linux/cdev.h>
 #include <linux/seq_file.h>
@@ -60,7 +59,7 @@ static int sg_version_num = 30534;    /* 2 digits for each component */
 
 #ifdef CONFIG_SCSI_PROC_FS
 #include <linux/proc_fs.h>
-static char *sg_version_date = "20060920";
+static char *sg_version_date = "20061027";
 
 static int sg_proc_init(void);
 static void sg_proc_cleanup(void);
@@ -710,12 +709,12 @@ sg_common_write(Sg_fd * sfp, Sg_request * srp,
                          (int) cmnd[0], (int) hp->cmd_len));
 
        if ((k = sg_start_req(srp))) {
-               SCSI_LOG_TIMEOUT(1, printk("sg_write: start_req err=%d\n", k));
+               SCSI_LOG_TIMEOUT(1, printk("sg_common_write: start_req err=%d\n", k));
                sg_finish_rem_req(srp);
                return k;       /* probably out of space --> ENOMEM */
        }
        if ((k = sg_write_xfer(srp))) {
-               SCSI_LOG_TIMEOUT(1, printk("sg_write: write_xfer, bad address\n"));
+               SCSI_LOG_TIMEOUT(1, printk("sg_common_write: write_xfer, bad address\n"));
                sg_finish_rem_req(srp);
                return k;
        }
@@ -746,7 +745,7 @@ sg_common_write(Sg_fd * sfp, Sg_request * srp,
                                hp->dxfer_len, srp->data.k_use_sg, timeout,
                                SG_DEFAULT_RETRIES, srp, sg_cmd_done,
                                GFP_ATOMIC)) {
-               SCSI_LOG_TIMEOUT(1, printk("sg_write: scsi_execute_async failed\n"));
+               SCSI_LOG_TIMEOUT(1, printk("sg_common_write: scsi_execute_async failed\n"));
                /*
                 * most likely out of mem, but could also be a bad map
                 */
@@ -917,6 +916,8 @@ sg_ioctl(struct inode *inode, struct file *filp,
                        return result;
                 if (val < 0)
                         return -EINVAL;
+               val = min_t(int, val,
+                               sdp->device->request_queue->max_sectors * 512);
                if (val != sfp->reserve.bufflen) {
                        if (sg_res_in_use(sfp) || sfp->mmap_called)
                                return -EBUSY;
@@ -925,7 +926,8 @@ sg_ioctl(struct inode *inode, struct file *filp,
                }
                return 0;
        case SG_GET_RESERVED_SIZE:
-               val = (int) sfp->reserve.bufflen;
+               val = min_t(int, sfp->reserve.bufflen,
+                               sdp->device->request_queue->max_sectors * 512);
                return put_user(val, ip);
        case SG_SET_COMMAND_Q:
                result = get_user(val, ip);
@@ -1061,6 +1063,9 @@ sg_ioctl(struct inode *inode, struct file *filp,
                if (sdp->detached)
                        return -ENODEV;
                return scsi_ioctl(sdp->device, cmd_in, p);
+       case BLKSECTGET:
+               return put_user(sdp->device->request_queue->max_sectors * 512,
+                               ip);
        default:
                if (read_only)
                        return -EPERM;  /* don't know so take safe approach */
@@ -1283,7 +1288,7 @@ sg_cmd_done(void *data, char *sense, int result, int resid)
                sg_finish_rem_req(srp);
                srp = NULL;
                if (NULL == sfp->headrp) {
-                       SCSI_LOG_TIMEOUT(1, printk("sg...bh: already closed, final cleanup\n"));
+                       SCSI_LOG_TIMEOUT(1, printk("sg_cmd_done: already closed, final cleanup\n"));
                        if (0 == sg_remove_sfp(sdp, sfp)) {     /* device still present */
                                scsi_device_put(sdp->device);
                        }
@@ -1512,12 +1517,12 @@ sg_remove(struct class_device *cl_dev, struct class_interface *cl_intf)
                                                    POLL_HUP);
                                }
                        }
-                       SCSI_LOG_TIMEOUT(3, printk("sg_detach: dev=%d, dirty\n", k));
+                       SCSI_LOG_TIMEOUT(3, printk("sg_remove: dev=%d, dirty\n", k));
                        if (NULL == sdp->headfp) {
                                sg_dev_arr[k] = NULL;
                        }
                } else {        /* nothing active, simple case */
-                       SCSI_LOG_TIMEOUT(3, printk("sg_detach: dev=%d\n", k));
+                       SCSI_LOG_TIMEOUT(3, printk("sg_remove: dev=%d\n", k));
                        sg_dev_arr[k] = NULL;
                }
                sg_nr_dev--;
@@ -1837,7 +1842,7 @@ sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
        int blk_size = buff_size;
        struct page *p = NULL;
 
-       if ((blk_size < 0) || (!sfp))
+       if (blk_size < 0)
                return -EFAULT;
        if (0 == blk_size)
                ++blk_size;     /* don't know why */
@@ -1876,14 +1881,15 @@ sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
                        }
                }
                sg->page = p;
-               sg->length = ret_sz;
+               sg->length = (ret_sz > num) ? num : ret_sz;
 
-               SCSI_LOG_TIMEOUT(5, printk("sg_build_build: k=%d, a=0x%p, len=%d\n",
-                                 k, p, ret_sz));
+               SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k=%d, num=%d, "
+                                "ret_sz=%d\n", k, num, ret_sz));
        }               /* end of for loop */
 
        schp->k_use_sg = k;
-       SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k_use_sg=%d, rem_sz=%d\n", k, rem_sz));
+       SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k_use_sg=%d, "
+                        "rem_sz=%d\n", k, rem_sz));
 
        schp->bufflen = blk_size;
        if (rem_sz > 0) /* must have failed */
@@ -2014,7 +2020,7 @@ sg_remove_scat(Sg_scatter_hold * schp)
                        for (k = 0; (k < schp->k_use_sg) && sg->page;
                             ++k, ++sg) {
                                SCSI_LOG_TIMEOUT(5, printk(
-                                   "sg_remove_scat: k=%d, a=0x%p, len=%d\n",
+                                   "sg_remove_scat: k=%d, pg=0x%p, len=%d\n",
                                    k, sg->page, sg->length));
                                sg_page_free(sg->page, sg->length);
                        }
@@ -2338,6 +2344,7 @@ sg_add_sfp(Sg_device * sdp, int dev)
 {
        Sg_fd *sfp;
        unsigned long iflags;
+       int bufflen;
 
        sfp = kzalloc(sizeof(*sfp), GFP_ATOMIC | __GFP_NOWARN);
        if (!sfp)
@@ -2368,7 +2375,9 @@ sg_add_sfp(Sg_device * sdp, int dev)
        if (unlikely(sg_big_buff != def_reserved_size))
                sg_big_buff = def_reserved_size;
 
-       sg_build_reserve(sfp, sg_big_buff);
+       bufflen = min_t(int, sg_big_buff,
+                       sdp->device->request_queue->max_sectors * 512);
+       sg_build_reserve(sfp, bufflen);
        SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp:   bufflen=%d, k_use_sg=%d\n",
                           sfp->reserve.bufflen, sfp->reserve.k_use_sg));
        return sfp;