Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Mike Miller | bd4f36d | 2007-10-24 10:30:34 +0200 | [diff] [blame] | 2 | * Disk Array driver for HP Smart Array controllers, SCSI Tape module. |
| 3 | * (C) Copyright 2001, 2007 Hewlett-Packard Development Company, L.P. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify |
| 6 | * it under the terms of the GNU General Public License as published by |
Mike Miller | bd4f36d | 2007-10-24 10:30:34 +0200 | [diff] [blame] | 7 | * the Free Software Foundation; version 2 of the License. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 8 | * |
| 9 | * This program is distributed in the hope that it will be useful, |
| 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
Mike Miller | bd4f36d | 2007-10-24 10:30:34 +0200 | [diff] [blame] | 11 | * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 12 | * General Public License for more details. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | * |
| 14 | * You should have received a copy of the GNU General Public License |
| 15 | * along with this program; if not, write to the Free Software |
Mike Miller | bd4f36d | 2007-10-24 10:30:34 +0200 | [diff] [blame] | 16 | * Foundation, Inc., 59 Temple Place, Suite 300, Boston, MA |
| 17 | * 02111-1307, USA. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | * |
| 19 | * Questions/Comments/Bugfixes to iss_storagedev@hp.com |
| 20 | * |
| 21 | * Author: Stephen M. Cameron |
| 22 | */ |
| 23 | #ifdef CONFIG_CISS_SCSI_TAPE |
| 24 | |
| 25 | /* Here we have code to present the driver as a scsi driver |
| 26 | as it is simultaneously presented as a block driver. The |
| 27 | reason for doing this is to allow access to SCSI tape drives |
| 28 | through the array controller. Note in particular, neither |
| 29 | physical nor logical disks are presented through the scsi layer. */ |
| 30 | |
Tim Schmielau | 4e57b68 | 2005-10-30 15:03:48 -0800 | [diff] [blame] | 31 | #include <linux/timer.h> |
| 32 | #include <linux/completion.h> |
| 33 | #include <linux/slab.h> |
| 34 | #include <linux/string.h> |
| 35 | |
Arun Sharma | 6006349 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 36 | #include <linux/atomic.h> |
Tim Schmielau | 4e57b68 | 2005-10-30 15:03:48 -0800 | [diff] [blame] | 37 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | #include <scsi/scsi_cmnd.h> |
| 39 | #include <scsi/scsi_device.h> |
| 40 | #include <scsi/scsi_host.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | |
| 42 | #include "cciss_scsi.h" |
| 43 | |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 44 | #define CCISS_ABORT_MSG 0x00 |
| 45 | #define CCISS_RESET_MSG 0x01 |
| 46 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 47 | static int fill_cmd(ctlr_info_t *h, CommandList_struct *c, __u8 cmd, void *buff, |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 48 | size_t size, |
scameron@beardog.cca.cpqcorp.net | b57695f | 2009-06-08 16:02:17 -0500 | [diff] [blame] | 49 | __u8 page_code, unsigned char *scsi3addr, |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 50 | int cmd_type); |
| 51 | |
Stephen M. Cameron | 6b4d96b | 2010-07-19 13:46:43 -0500 | [diff] [blame] | 52 | static CommandList_struct *cmd_alloc(ctlr_info_t *h); |
| 53 | static CommandList_struct *cmd_special_alloc(ctlr_info_t *h); |
| 54 | static void cmd_free(ctlr_info_t *h, CommandList_struct *c); |
| 55 | static void cmd_special_free(ctlr_info_t *h, CommandList_struct *c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 56 | |
| 57 | static int cciss_scsi_proc_info( |
| 58 | struct Scsi_Host *sh, |
| 59 | char *buffer, /* data buffer */ |
| 60 | char **start, /* where data in buffer starts */ |
| 61 | off_t offset, /* offset from start of imaginary file */ |
| 62 | int length, /* length of data in buffer */ |
| 63 | int func); /* 0 == read, 1 == write */ |
| 64 | |
Jeff Garzik | f281233 | 2010-11-16 02:10:29 -0500 | [diff] [blame] | 65 | static int cciss_scsi_queue_command (struct Scsi_Host *h, |
| 66 | struct scsi_cmnd *cmd); |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 67 | static int cciss_eh_device_reset_handler(struct scsi_cmnd *); |
| 68 | static int cciss_eh_abort_handler(struct scsi_cmnd *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | |
| 70 | static struct cciss_scsi_hba_t ccissscsi[MAX_CTLR] = { |
| 71 | { .name = "cciss0", .ndevices = 0 }, |
| 72 | { .name = "cciss1", .ndevices = 0 }, |
| 73 | { .name = "cciss2", .ndevices = 0 }, |
| 74 | { .name = "cciss3", .ndevices = 0 }, |
| 75 | { .name = "cciss4", .ndevices = 0 }, |
| 76 | { .name = "cciss5", .ndevices = 0 }, |
| 77 | { .name = "cciss6", .ndevices = 0 }, |
| 78 | { .name = "cciss7", .ndevices = 0 }, |
| 79 | }; |
| 80 | |
| 81 | static struct scsi_host_template cciss_driver_template = { |
| 82 | .module = THIS_MODULE, |
| 83 | .name = "cciss", |
| 84 | .proc_name = "cciss", |
| 85 | .proc_info = cciss_scsi_proc_info, |
| 86 | .queuecommand = cciss_scsi_queue_command, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | .this_id = 7, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | .cmd_per_lun = 1, |
| 89 | .use_clustering = DISABLE_CLUSTERING, |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 90 | /* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */ |
| 91 | .eh_device_reset_handler= cciss_eh_device_reset_handler, |
| 92 | .eh_abort_handler = cciss_eh_abort_handler, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | }; |
| 94 | |
| 95 | #pragma pack(1) |
Stephen M. Cameron | 1b7d0d2 | 2010-02-26 16:01:17 -0600 | [diff] [blame] | 96 | |
Mike Miller | 5e21615 | 2010-06-02 12:58:06 -0700 | [diff] [blame] | 97 | #define SCSI_PAD_32 8 |
| 98 | #define SCSI_PAD_64 8 |
Stephen M. Cameron | 1b7d0d2 | 2010-02-26 16:01:17 -0600 | [diff] [blame] | 99 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | struct cciss_scsi_cmd_stack_elem_t { |
| 101 | CommandList_struct cmd; |
| 102 | ErrorInfo_struct Err; |
| 103 | __u32 busaddr; |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 104 | int cmdindex; |
Stephen M. Cameron | 1b7d0d2 | 2010-02-26 16:01:17 -0600 | [diff] [blame] | 105 | u8 pad[IS_32_BIT * SCSI_PAD_32 + IS_64_BIT * SCSI_PAD_64]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | }; |
| 107 | |
| 108 | #pragma pack() |
| 109 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | #pragma pack(1) |
| 111 | struct cciss_scsi_cmd_stack_t { |
| 112 | struct cciss_scsi_cmd_stack_elem_t *pool; |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 113 | struct cciss_scsi_cmd_stack_elem_t **elem; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | dma_addr_t cmd_pool_handle; |
| 115 | int top; |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 116 | int nelems; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | }; |
| 118 | #pragma pack() |
| 119 | |
| 120 | struct cciss_scsi_adapter_data_t { |
| 121 | struct Scsi_Host *scsi_host; |
| 122 | struct cciss_scsi_cmd_stack_t cmd_stack; |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 123 | SGDescriptor_struct **cmd_sg_list; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | int registered; |
| 125 | spinlock_t lock; // to protect ccissscsi[ctlr]; |
| 126 | }; |
| 127 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 128 | #define CPQ_TAPE_LOCK(h, flags) spin_lock_irqsave( \ |
| 129 | &h->scsi_ctlr->lock, flags); |
| 130 | #define CPQ_TAPE_UNLOCK(h, flags) spin_unlock_irqrestore( \ |
| 131 | &h->scsi_ctlr->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | |
| 133 | static CommandList_struct * |
| 134 | scsi_cmd_alloc(ctlr_info_t *h) |
| 135 | { |
| 136 | /* assume only one process in here at a time, locking done by caller. */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 137 | /* use h->lock */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | /* might be better to rewrite how we allocate scsi commands in a way that */ |
| 139 | /* needs no locking at all. */ |
| 140 | |
| 141 | /* take the top memory chunk off the stack and return it, if any. */ |
| 142 | struct cciss_scsi_cmd_stack_elem_t *c; |
| 143 | struct cciss_scsi_adapter_data_t *sa; |
| 144 | struct cciss_scsi_cmd_stack_t *stk; |
| 145 | u64bit temp64; |
| 146 | |
Stephen M. Cameron | aad9fb6 | 2010-02-26 16:01:42 -0600 | [diff] [blame] | 147 | sa = h->scsi_ctlr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | stk = &sa->cmd_stack; |
| 149 | |
| 150 | if (stk->top < 0) |
| 151 | return NULL; |
| 152 | c = stk->elem[stk->top]; |
| 153 | /* memset(c, 0, sizeof(*c)); */ |
| 154 | memset(&c->cmd, 0, sizeof(c->cmd)); |
| 155 | memset(&c->Err, 0, sizeof(c->Err)); |
| 156 | /* set physical addr of cmd and addr of scsi parameters */ |
| 157 | c->cmd.busaddr = c->busaddr; |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 158 | c->cmd.cmdindex = c->cmdindex; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | /* (__u32) (stk->cmd_pool_handle + |
| 160 | (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */ |
| 161 | |
| 162 | temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct)); |
| 163 | /* (__u64) (stk->cmd_pool_handle + |
| 164 | (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) + |
| 165 | sizeof(CommandList_struct)); */ |
| 166 | stk->top--; |
| 167 | c->cmd.ErrDesc.Addr.lower = temp64.val32.lower; |
| 168 | c->cmd.ErrDesc.Addr.upper = temp64.val32.upper; |
| 169 | c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct); |
| 170 | |
| 171 | c->cmd.ctlr = h->ctlr; |
| 172 | c->cmd.err_info = &c->Err; |
| 173 | |
| 174 | return (CommandList_struct *) c; |
| 175 | } |
| 176 | |
| 177 | static void |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 178 | scsi_cmd_free(ctlr_info_t *h, CommandList_struct *c) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | { |
| 180 | /* assume only one process in here at a time, locking done by caller. */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 181 | /* use h->lock */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | /* drop the free memory chunk on top of the stack. */ |
| 183 | |
| 184 | struct cciss_scsi_adapter_data_t *sa; |
| 185 | struct cciss_scsi_cmd_stack_t *stk; |
| 186 | |
Stephen M. Cameron | aad9fb6 | 2010-02-26 16:01:42 -0600 | [diff] [blame] | 187 | sa = h->scsi_ctlr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | stk = &sa->cmd_stack; |
Dan Carpenter | 713b686 | 2010-06-01 12:17:48 +0200 | [diff] [blame] | 189 | stk->top++; |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 190 | if (stk->top >= stk->nelems) { |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 191 | dev_err(&h->pdev->dev, |
| 192 | "scsi_cmd_free called too many times.\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 193 | BUG(); |
| 194 | } |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 195 | stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) c; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | static int |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 199 | scsi_cmd_stack_setup(ctlr_info_t *h, struct cciss_scsi_adapter_data_t *sa) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | { |
| 201 | int i; |
| 202 | struct cciss_scsi_cmd_stack_t *stk; |
| 203 | size_t size; |
| 204 | |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 205 | stk = &sa->cmd_stack; |
| 206 | stk->nelems = cciss_tape_cmds + 2; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 207 | sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(h, |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 208 | h->chainsize, stk->nelems); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 209 | if (!sa->cmd_sg_list && h->chainsize > 0) |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 210 | return -ENOMEM; |
| 211 | |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 212 | size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * stk->nelems; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 213 | |
Stephen M. Cameron | 1b7d0d2 | 2010-02-26 16:01:17 -0600 | [diff] [blame] | 214 | /* Check alignment, see cciss_cmd.h near CommandList_struct def. */ |
| 215 | BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0); |
| 216 | /* pci_alloc_consistent guarantees 32-bit DMA address will be used */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | stk->pool = (struct cciss_scsi_cmd_stack_elem_t *) |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 218 | pci_alloc_consistent(h->pdev, size, &stk->cmd_pool_handle); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | |
| 220 | if (stk->pool == NULL) { |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 221 | cciss_free_sg_chain_blocks(sa->cmd_sg_list, stk->nelems); |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 222 | sa->cmd_sg_list = NULL; |
| 223 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 224 | } |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 225 | stk->elem = kmalloc(sizeof(stk->elem[0]) * stk->nelems, GFP_KERNEL); |
| 226 | if (!stk->elem) { |
| 227 | pci_free_consistent(h->pdev, size, stk->pool, |
| 228 | stk->cmd_pool_handle); |
| 229 | return -1; |
| 230 | } |
| 231 | for (i = 0; i < stk->nelems; i++) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | stk->elem[i] = &stk->pool[i]; |
| 233 | stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle + |
| 234 | (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i)); |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 235 | stk->elem[i]->cmdindex = i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | } |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 237 | stk->top = stk->nelems-1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | return 0; |
| 239 | } |
| 240 | |
| 241 | static void |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 242 | scsi_cmd_stack_free(ctlr_info_t *h) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | { |
| 244 | struct cciss_scsi_adapter_data_t *sa; |
| 245 | struct cciss_scsi_cmd_stack_t *stk; |
| 246 | size_t size; |
| 247 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 248 | sa = h->scsi_ctlr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | stk = &sa->cmd_stack; |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 250 | if (stk->top != stk->nelems-1) { |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 251 | dev_warn(&h->pdev->dev, |
| 252 | "bug: %d scsi commands are still outstanding.\n", |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 253 | stk->nelems - stk->top); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | } |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 255 | size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * stk->nelems; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 257 | pci_free_consistent(h->pdev, size, stk->pool, stk->cmd_pool_handle); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 258 | stk->pool = NULL; |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 259 | cciss_free_sg_chain_blocks(sa->cmd_sg_list, stk->nelems); |
| 260 | kfree(stk->elem); |
| 261 | stk->elem = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | } |
| 263 | |
Grant Coady | 400bb23 | 2005-11-15 00:09:20 -0800 | [diff] [blame] | 264 | #if 0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | static int xmargin=8; |
| 266 | static int amargin=60; |
| 267 | |
| 268 | static void |
| 269 | print_bytes (unsigned char *c, int len, int hex, int ascii) |
| 270 | { |
| 271 | |
| 272 | int i; |
| 273 | unsigned char *x; |
| 274 | |
| 275 | if (hex) |
| 276 | { |
| 277 | x = c; |
| 278 | for (i=0;i<len;i++) |
| 279 | { |
| 280 | if ((i % xmargin) == 0 && i>0) printk("\n"); |
| 281 | if ((i % xmargin) == 0) printk("0x%04x:", i); |
| 282 | printk(" %02x", *x); |
| 283 | x++; |
| 284 | } |
| 285 | printk("\n"); |
| 286 | } |
| 287 | if (ascii) |
| 288 | { |
| 289 | x = c; |
| 290 | for (i=0;i<len;i++) |
| 291 | { |
| 292 | if ((i % amargin) == 0 && i>0) printk("\n"); |
| 293 | if ((i % amargin) == 0) printk("0x%04x:", i); |
| 294 | if (*x > 26 && *x < 128) printk("%c", *x); |
| 295 | else printk("."); |
| 296 | x++; |
| 297 | } |
| 298 | printk("\n"); |
| 299 | } |
| 300 | } |
| 301 | |
| 302 | static void |
| 303 | print_cmd(CommandList_struct *cp) |
| 304 | { |
| 305 | printk("queue:%d\n", cp->Header.ReplyQueue); |
| 306 | printk("sglist:%d\n", cp->Header.SGList); |
| 307 | printk("sgtot:%d\n", cp->Header.SGTotal); |
| 308 | printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper, |
| 309 | cp->Header.Tag.lower); |
| 310 | printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n", |
| 311 | cp->Header.LUN.LunAddrBytes[0], |
| 312 | cp->Header.LUN.LunAddrBytes[1], |
| 313 | cp->Header.LUN.LunAddrBytes[2], |
| 314 | cp->Header.LUN.LunAddrBytes[3], |
| 315 | cp->Header.LUN.LunAddrBytes[4], |
| 316 | cp->Header.LUN.LunAddrBytes[5], |
| 317 | cp->Header.LUN.LunAddrBytes[6], |
| 318 | cp->Header.LUN.LunAddrBytes[7]); |
| 319 | printk("CDBLen:%d\n", cp->Request.CDBLen); |
| 320 | printk("Type:%d\n",cp->Request.Type.Type); |
| 321 | printk("Attr:%d\n",cp->Request.Type.Attribute); |
| 322 | printk(" Dir:%d\n",cp->Request.Type.Direction); |
| 323 | printk("Timeout:%d\n",cp->Request.Timeout); |
| 324 | printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x" |
| 325 | " %02x %02x %02x %02x %02x %02x %02x %02x\n", |
| 326 | cp->Request.CDB[0], cp->Request.CDB[1], |
| 327 | cp->Request.CDB[2], cp->Request.CDB[3], |
| 328 | cp->Request.CDB[4], cp->Request.CDB[5], |
| 329 | cp->Request.CDB[6], cp->Request.CDB[7], |
| 330 | cp->Request.CDB[8], cp->Request.CDB[9], |
| 331 | cp->Request.CDB[10], cp->Request.CDB[11], |
| 332 | cp->Request.CDB[12], cp->Request.CDB[13], |
| 333 | cp->Request.CDB[14], cp->Request.CDB[15]), |
| 334 | printk("edesc.Addr: 0x%08x/0%08x, Len = %d\n", |
| 335 | cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower, |
| 336 | cp->ErrDesc.Len); |
| 337 | printk("sgs..........Errorinfo:\n"); |
| 338 | printk("scsistatus:%d\n", cp->err_info->ScsiStatus); |
| 339 | printk("senselen:%d\n", cp->err_info->SenseLen); |
| 340 | printk("cmd status:%d\n", cp->err_info->CommandStatus); |
| 341 | printk("resid cnt:%d\n", cp->err_info->ResidualCnt); |
| 342 | printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size); |
| 343 | printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num); |
| 344 | printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value); |
| 345 | |
| 346 | } |
| 347 | |
| 348 | #endif |
| 349 | |
| 350 | static int |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 351 | find_bus_target_lun(ctlr_info_t *h, int *bus, int *target, int *lun) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 352 | { |
| 353 | /* finds an unused bus, target, lun for a new device */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 354 | /* assumes h->scsi_ctlr->lock is held */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | int i, found=0; |
| 356 | unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA]; |
| 357 | |
| 358 | memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA); |
| 359 | |
| 360 | target_taken[SELF_SCSI_ID] = 1; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 361 | for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) |
| 362 | target_taken[ccissscsi[h->ctlr].dev[i].target] = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 363 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 364 | for (i = 0; i < CCISS_MAX_SCSI_DEVS_PER_HBA; i++) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 365 | if (!target_taken[i]) { |
| 366 | *bus = 0; *target=i; *lun = 0; found=1; |
| 367 | break; |
| 368 | } |
| 369 | } |
| 370 | return (!found); |
| 371 | } |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 372 | struct scsi2map { |
| 373 | char scsi3addr[8]; |
| 374 | int bus, target, lun; |
| 375 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 376 | |
| 377 | static int |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 378 | cciss_scsi_add_entry(ctlr_info_t *h, int hostno, |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 379 | struct cciss_scsi_dev_t *device, |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 380 | struct scsi2map *added, int *nadded) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 381 | { |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 382 | /* assumes h->scsi_ctlr->lock is held */ |
| 383 | int n = ccissscsi[h->ctlr].ndevices; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 384 | struct cciss_scsi_dev_t *sd; |
Mike Miller | 935dc8d | 2008-08-04 11:54:54 +0200 | [diff] [blame] | 385 | int i, bus, target, lun; |
| 386 | unsigned char addr1[8], addr2[8]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 387 | |
| 388 | if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) { |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 389 | dev_warn(&h->pdev->dev, "Too many devices, " |
| 390 | "some will be inaccessible.\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 391 | return -1; |
| 392 | } |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 393 | |
Mike Miller | 935dc8d | 2008-08-04 11:54:54 +0200 | [diff] [blame] | 394 | bus = target = -1; |
| 395 | lun = 0; |
| 396 | /* Is this device a non-zero lun of a multi-lun device */ |
| 397 | /* byte 4 of the 8-byte LUN addr will contain the logical unit no. */ |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 398 | if (device->scsi3addr[4] != 0) { |
Mike Miller | 935dc8d | 2008-08-04 11:54:54 +0200 | [diff] [blame] | 399 | /* Search through our list and find the device which */ |
| 400 | /* has the same 8 byte LUN address, excepting byte 4. */ |
| 401 | /* Assign the same bus and target for this new LUN. */ |
| 402 | /* Use the logical unit number from the firmware. */ |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 403 | memcpy(addr1, device->scsi3addr, 8); |
Mike Miller | 935dc8d | 2008-08-04 11:54:54 +0200 | [diff] [blame] | 404 | addr1[4] = 0; |
| 405 | for (i = 0; i < n; i++) { |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 406 | sd = &ccissscsi[h->ctlr].dev[i]; |
Mike Miller | 935dc8d | 2008-08-04 11:54:54 +0200 | [diff] [blame] | 407 | memcpy(addr2, sd->scsi3addr, 8); |
| 408 | addr2[4] = 0; |
| 409 | /* differ only in byte 4? */ |
| 410 | if (memcmp(addr1, addr2, 8) == 0) { |
| 411 | bus = sd->bus; |
| 412 | target = sd->target; |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 413 | lun = device->scsi3addr[4]; |
Mike Miller | 935dc8d | 2008-08-04 11:54:54 +0200 | [diff] [blame] | 414 | break; |
| 415 | } |
| 416 | } |
| 417 | } |
| 418 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 419 | sd = &ccissscsi[h->ctlr].dev[n]; |
Mike Miller | 935dc8d | 2008-08-04 11:54:54 +0200 | [diff] [blame] | 420 | if (lun == 0) { |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 421 | if (find_bus_target_lun(h, |
Mike Miller | 935dc8d | 2008-08-04 11:54:54 +0200 | [diff] [blame] | 422 | &sd->bus, &sd->target, &sd->lun) != 0) |
| 423 | return -1; |
| 424 | } else { |
| 425 | sd->bus = bus; |
| 426 | sd->target = target; |
| 427 | sd->lun = lun; |
| 428 | } |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 429 | added[*nadded].bus = sd->bus; |
| 430 | added[*nadded].target = sd->target; |
| 431 | added[*nadded].lun = sd->lun; |
| 432 | (*nadded)++; |
| 433 | |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 434 | memcpy(sd->scsi3addr, device->scsi3addr, 8); |
| 435 | memcpy(sd->vendor, device->vendor, sizeof(sd->vendor)); |
| 436 | memcpy(sd->revision, device->revision, sizeof(sd->revision)); |
| 437 | memcpy(sd->device_id, device->device_id, sizeof(sd->device_id)); |
| 438 | sd->devtype = device->devtype; |
| 439 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 440 | ccissscsi[h->ctlr].ndevices++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 441 | |
| 442 | /* initially, (before registering with scsi layer) we don't |
| 443 | know our hostno and we don't want to print anything first |
| 444 | time anyway (the scsi layer's inquiries will show that info) */ |
| 445 | if (hostno != -1) |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 446 | dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d added.\n", |
| 447 | scsi_device_type(sd->devtype), hostno, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 448 | sd->bus, sd->target, sd->lun); |
| 449 | return 0; |
| 450 | } |
| 451 | |
| 452 | static void |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 453 | cciss_scsi_remove_entry(ctlr_info_t *h, int hostno, int entry, |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 454 | struct scsi2map *removed, int *nremoved) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 455 | { |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 456 | /* assumes h->ctlr]->scsi_ctlr->lock is held */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 457 | int i; |
| 458 | struct cciss_scsi_dev_t sd; |
| 459 | |
| 460 | if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 461 | sd = ccissscsi[h->ctlr].dev[entry]; |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 462 | removed[*nremoved].bus = sd.bus; |
| 463 | removed[*nremoved].target = sd.target; |
| 464 | removed[*nremoved].lun = sd.lun; |
| 465 | (*nremoved)++; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 466 | for (i = entry; i < ccissscsi[h->ctlr].ndevices-1; i++) |
| 467 | ccissscsi[h->ctlr].dev[i] = ccissscsi[h->ctlr].dev[i+1]; |
| 468 | ccissscsi[h->ctlr].ndevices--; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 469 | dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d removed.\n", |
| 470 | scsi_device_type(sd.devtype), hostno, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 471 | sd.bus, sd.target, sd.lun); |
| 472 | } |
| 473 | |
| 474 | |
| 475 | #define SCSI3ADDR_EQ(a,b) ( \ |
| 476 | (a)[7] == (b)[7] && \ |
| 477 | (a)[6] == (b)[6] && \ |
| 478 | (a)[5] == (b)[5] && \ |
| 479 | (a)[4] == (b)[4] && \ |
| 480 | (a)[3] == (b)[3] && \ |
| 481 | (a)[2] == (b)[2] && \ |
| 482 | (a)[1] == (b)[1] && \ |
| 483 | (a)[0] == (b)[0]) |
| 484 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 485 | static void fixup_botched_add(ctlr_info_t *h, char *scsi3addr) |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 486 | { |
| 487 | /* called when scsi_add_device fails in order to re-adjust */ |
| 488 | /* ccissscsi[] to match the mid layer's view. */ |
| 489 | unsigned long flags; |
| 490 | int i, j; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 491 | CPQ_TAPE_LOCK(h, flags); |
| 492 | for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) { |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 493 | if (memcmp(scsi3addr, |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 494 | ccissscsi[h->ctlr].dev[i].scsi3addr, 8) == 0) { |
| 495 | for (j = i; j < ccissscsi[h->ctlr].ndevices-1; j++) |
| 496 | ccissscsi[h->ctlr].dev[j] = |
| 497 | ccissscsi[h->ctlr].dev[j+1]; |
| 498 | ccissscsi[h->ctlr].ndevices--; |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 499 | break; |
| 500 | } |
| 501 | } |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 502 | CPQ_TAPE_UNLOCK(h, flags); |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 503 | } |
| 504 | |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 505 | static int device_is_the_same(struct cciss_scsi_dev_t *dev1, |
| 506 | struct cciss_scsi_dev_t *dev2) |
| 507 | { |
| 508 | return dev1->devtype == dev2->devtype && |
| 509 | memcmp(dev1->scsi3addr, dev2->scsi3addr, |
| 510 | sizeof(dev1->scsi3addr)) == 0 && |
| 511 | memcmp(dev1->device_id, dev2->device_id, |
| 512 | sizeof(dev1->device_id)) == 0 && |
| 513 | memcmp(dev1->vendor, dev2->vendor, |
| 514 | sizeof(dev1->vendor)) == 0 && |
| 515 | memcmp(dev1->model, dev2->model, |
| 516 | sizeof(dev1->model)) == 0 && |
| 517 | memcmp(dev1->revision, dev2->revision, |
| 518 | sizeof(dev1->revision)) == 0; |
| 519 | } |
| 520 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 521 | static int |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 522 | adjust_cciss_scsi_table(ctlr_info_t *h, int hostno, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 523 | struct cciss_scsi_dev_t sd[], int nsds) |
| 524 | { |
| 525 | /* sd contains scsi3 addresses and devtypes, but |
| 526 | bus target and lun are not filled in. This funciton |
| 527 | takes what's in sd to be the current and adjusts |
| 528 | ccissscsi[] to be in line with what's in sd. */ |
| 529 | |
| 530 | int i,j, found, changes=0; |
| 531 | struct cciss_scsi_dev_t *csd; |
| 532 | unsigned long flags; |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 533 | struct scsi2map *added, *removed; |
| 534 | int nadded, nremoved; |
| 535 | struct Scsi_Host *sh = NULL; |
| 536 | |
| 537 | added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA, |
| 538 | GFP_KERNEL); |
| 539 | removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA, |
| 540 | GFP_KERNEL); |
| 541 | |
| 542 | if (!added || !removed) { |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 543 | dev_warn(&h->pdev->dev, |
| 544 | "Out of memory in adjust_cciss_scsi_table\n"); |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 545 | goto free_and_out; |
| 546 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 547 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 548 | CPQ_TAPE_LOCK(h, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 549 | |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 550 | if (hostno != -1) /* if it's not the first time... */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 551 | sh = h->scsi_ctlr->scsi_host; |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 552 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 553 | /* find any devices in ccissscsi[] that are not in |
| 554 | sd[] and remove them from ccissscsi[] */ |
| 555 | |
| 556 | i = 0; |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 557 | nremoved = 0; |
| 558 | nadded = 0; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 559 | while (i < ccissscsi[h->ctlr].ndevices) { |
| 560 | csd = &ccissscsi[h->ctlr].dev[i]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 561 | found=0; |
| 562 | for (j=0;j<nsds;j++) { |
| 563 | if (SCSI3ADDR_EQ(sd[j].scsi3addr, |
| 564 | csd->scsi3addr)) { |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 565 | if (device_is_the_same(&sd[j], csd)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 566 | found=2; |
| 567 | else |
| 568 | found=1; |
| 569 | break; |
| 570 | } |
| 571 | } |
| 572 | |
| 573 | if (found == 0) { /* device no longer present. */ |
| 574 | changes++; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 575 | cciss_scsi_remove_entry(h, hostno, i, |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 576 | removed, &nremoved); |
| 577 | /* remove ^^^, hence i not incremented */ |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 578 | } else if (found == 1) { /* device is different in some way */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 579 | changes++; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 580 | dev_info(&h->pdev->dev, |
| 581 | "device c%db%dt%dl%d has changed.\n", |
| 582 | hostno, csd->bus, csd->target, csd->lun); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 583 | cciss_scsi_remove_entry(h, hostno, i, |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 584 | removed, &nremoved); |
| 585 | /* remove ^^^, hence i not incremented */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 586 | if (cciss_scsi_add_entry(h, hostno, &sd[j], |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 587 | added, &nadded) != 0) |
| 588 | /* we just removed one, so add can't fail. */ |
| 589 | BUG(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 590 | csd->devtype = sd[j].devtype; |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 591 | memcpy(csd->device_id, sd[j].device_id, |
| 592 | sizeof(csd->device_id)); |
| 593 | memcpy(csd->vendor, sd[j].vendor, |
| 594 | sizeof(csd->vendor)); |
| 595 | memcpy(csd->model, sd[j].model, |
| 596 | sizeof(csd->model)); |
| 597 | memcpy(csd->revision, sd[j].revision, |
| 598 | sizeof(csd->revision)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 599 | } else /* device is same as it ever was, */ |
| 600 | i++; /* so just move along. */ |
| 601 | } |
| 602 | |
| 603 | /* Now, make sure every device listed in sd[] is also |
| 604 | listed in ccissscsi[], adding them if they aren't found */ |
| 605 | |
| 606 | for (i=0;i<nsds;i++) { |
| 607 | found=0; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 608 | for (j = 0; j < ccissscsi[h->ctlr].ndevices; j++) { |
| 609 | csd = &ccissscsi[h->ctlr].dev[j]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 610 | if (SCSI3ADDR_EQ(sd[i].scsi3addr, |
| 611 | csd->scsi3addr)) { |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 612 | if (device_is_the_same(&sd[i], csd)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 613 | found=2; /* found device */ |
| 614 | else |
| 615 | found=1; /* found a bug. */ |
| 616 | break; |
| 617 | } |
| 618 | } |
| 619 | if (!found) { |
| 620 | changes++; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 621 | if (cciss_scsi_add_entry(h, hostno, &sd[i], |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 622 | added, &nadded) != 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 623 | break; |
| 624 | } else if (found == 1) { |
| 625 | /* should never happen... */ |
| 626 | changes++; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 627 | dev_warn(&h->pdev->dev, |
| 628 | "device unexpectedly changed\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 629 | /* but if it does happen, we just ignore that device */ |
| 630 | } |
| 631 | } |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 632 | CPQ_TAPE_UNLOCK(h, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 633 | |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 634 | /* Don't notify scsi mid layer of any changes the first time through */ |
| 635 | /* (or if there are no changes) scsi_scan_host will do it later the */ |
| 636 | /* first time through. */ |
| 637 | if (hostno == -1 || !changes) |
| 638 | goto free_and_out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 639 | |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 640 | /* Notify scsi mid layer of any removed devices */ |
| 641 | for (i = 0; i < nremoved; i++) { |
| 642 | struct scsi_device *sdev = |
| 643 | scsi_device_lookup(sh, removed[i].bus, |
| 644 | removed[i].target, removed[i].lun); |
| 645 | if (sdev != NULL) { |
| 646 | scsi_remove_device(sdev); |
| 647 | scsi_device_put(sdev); |
| 648 | } else { |
| 649 | /* We don't expect to get here. */ |
| 650 | /* future cmds to this device will get selection */ |
| 651 | /* timeout as if the device was gone. */ |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 652 | dev_warn(&h->pdev->dev, "didn't find " |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 653 | "c%db%dt%dl%d\n for removal.", |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 654 | hostno, removed[i].bus, |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 655 | removed[i].target, removed[i].lun); |
| 656 | } |
| 657 | } |
| 658 | |
| 659 | /* Notify scsi mid layer of any added devices */ |
| 660 | for (i = 0; i < nadded; i++) { |
| 661 | int rc; |
| 662 | rc = scsi_add_device(sh, added[i].bus, |
| 663 | added[i].target, added[i].lun); |
| 664 | if (rc == 0) |
| 665 | continue; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 666 | dev_warn(&h->pdev->dev, "scsi_add_device " |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 667 | "c%db%dt%dl%d failed, device not added.\n", |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 668 | hostno, added[i].bus, added[i].target, added[i].lun); |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 669 | /* now we have to remove it from ccissscsi, */ |
| 670 | /* since it didn't get added to scsi mid layer */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 671 | fixup_botched_add(h, added[i].scsi3addr); |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 672 | } |
| 673 | |
| 674 | free_and_out: |
| 675 | kfree(added); |
| 676 | kfree(removed); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 677 | return 0; |
| 678 | } |
| 679 | |
| 680 | static int |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 681 | lookup_scsi3addr(ctlr_info_t *h, int bus, int target, int lun, char *scsi3addr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 682 | { |
| 683 | int i; |
| 684 | struct cciss_scsi_dev_t *sd; |
| 685 | unsigned long flags; |
| 686 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 687 | CPQ_TAPE_LOCK(h, flags); |
| 688 | for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) { |
| 689 | sd = &ccissscsi[h->ctlr].dev[i]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 690 | if (sd->bus == bus && |
| 691 | sd->target == target && |
| 692 | sd->lun == lun) { |
| 693 | memcpy(scsi3addr, &sd->scsi3addr[0], 8); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 694 | CPQ_TAPE_UNLOCK(h, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 695 | return 0; |
| 696 | } |
| 697 | } |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 698 | CPQ_TAPE_UNLOCK(h, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 699 | return -1; |
| 700 | } |
| 701 | |
| 702 | static void |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 703 | cciss_scsi_setup(ctlr_info_t *h) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 704 | { |
| 705 | struct cciss_scsi_adapter_data_t * shba; |
| 706 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 707 | ccissscsi[h->ctlr].ndevices = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 708 | shba = (struct cciss_scsi_adapter_data_t *) |
| 709 | kmalloc(sizeof(*shba), GFP_KERNEL); |
| 710 | if (shba == NULL) |
| 711 | return; |
| 712 | shba->scsi_host = NULL; |
| 713 | spin_lock_init(&shba->lock); |
| 714 | shba->registered = 0; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 715 | if (scsi_cmd_stack_setup(h, shba) != 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 716 | kfree(shba); |
| 717 | shba = NULL; |
| 718 | } |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 719 | h->scsi_ctlr = shba; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 720 | return; |
| 721 | } |
| 722 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 723 | static void complete_scsi_command(CommandList_struct *c, int timeout, |
| 724 | __u32 tag) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 725 | { |
| 726 | struct scsi_cmnd *cmd; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 727 | ctlr_info_t *h; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 728 | ErrorInfo_struct *ei; |
| 729 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 730 | ei = c->err_info; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 731 | |
| 732 | /* First, see if it was a message rather than a command */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 733 | if (c->Request.Type.Type == TYPE_MSG) { |
| 734 | c->cmd_type = CMD_MSG_DONE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 735 | return; |
| 736 | } |
| 737 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 738 | cmd = (struct scsi_cmnd *) c->scsi_cmd; |
| 739 | h = hba[c->ctlr]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 740 | |
FUJITA Tomonori | 41ce639 | 2007-05-26 02:45:17 +0900 | [diff] [blame] | 741 | scsi_dma_unmap(cmd); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 742 | if (c->Header.SGTotal > h->max_cmd_sgentries) |
| 743 | cciss_unmap_sg_chain_block(h, c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 744 | |
| 745 | cmd->result = (DID_OK << 16); /* host byte */ |
| 746 | cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */ |
| 747 | /* cmd->result |= (GOOD < 1); */ /* status byte */ |
| 748 | |
| 749 | cmd->result |= (ei->ScsiStatus); |
| 750 | /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus); */ |
| 751 | |
| 752 | /* copy the sense data whether we need to or not. */ |
| 753 | |
| 754 | memcpy(cmd->sense_buffer, ei->SenseInfo, |
| 755 | ei->SenseLen > SCSI_SENSE_BUFFERSIZE ? |
| 756 | SCSI_SENSE_BUFFERSIZE : |
| 757 | ei->SenseLen); |
FUJITA Tomonori | 41ce639 | 2007-05-26 02:45:17 +0900 | [diff] [blame] | 758 | scsi_set_resid(cmd, ei->ResidualCnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 759 | |
| 760 | if(ei->CommandStatus != 0) |
| 761 | { /* an error has occurred */ |
| 762 | switch(ei->CommandStatus) |
| 763 | { |
| 764 | case CMD_TARGET_STATUS: |
| 765 | /* Pass it up to the upper layers... */ |
| 766 | if( ei->ScsiStatus) |
| 767 | { |
| 768 | #if 0 |
| 769 | printk(KERN_WARNING "cciss: cmd %p " |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 770 | "has SCSI Status = %x\n", |
| 771 | c, ei->ScsiStatus); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 772 | #endif |
Stephen M. Cameron | b0e15f6 | 2009-11-12 12:49:45 -0600 | [diff] [blame] | 773 | cmd->result |= (ei->ScsiStatus << 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 774 | } |
| 775 | else { /* scsi status is zero??? How??? */ |
| 776 | |
| 777 | /* Ordinarily, this case should never happen, but there is a bug |
| 778 | in some released firmware revisions that allows it to happen |
| 779 | if, for example, a 4100 backplane loses power and the tape |
| 780 | drive is in it. We assume that it's a fatal error of some |
| 781 | kind because we can't show that it wasn't. We will make it |
| 782 | look like selection timeout since that is the most common |
| 783 | reason for this to occur, and it's severe enough. */ |
| 784 | |
| 785 | cmd->result = DID_NO_CONNECT << 16; |
| 786 | } |
| 787 | break; |
| 788 | case CMD_DATA_UNDERRUN: /* let mid layer handle it. */ |
| 789 | break; |
| 790 | case CMD_DATA_OVERRUN: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 791 | dev_warn(&h->pdev->dev, "%p has" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 792 | " completed with data overrun " |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 793 | "reported\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 794 | break; |
| 795 | case CMD_INVALID: { |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 796 | /* print_bytes(c, sizeof(*c), 1, 0); |
| 797 | print_cmd(c); */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 798 | /* We get CMD_INVALID if you address a non-existent tape drive instead |
| 799 | of a selection timeout (no response). You will see this if you yank |
| 800 | out a tape drive, then try to access it. This is kind of a shame |
| 801 | because it means that any other CMD_INVALID (e.g. driver bug) will |
| 802 | get interpreted as a missing target. */ |
| 803 | cmd->result = DID_NO_CONNECT << 16; |
| 804 | } |
| 805 | break; |
| 806 | case CMD_PROTOCOL_ERR: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 807 | dev_warn(&h->pdev->dev, |
| 808 | "%p has protocol error\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 809 | break; |
| 810 | case CMD_HARDWARE_ERR: |
| 811 | cmd->result = DID_ERROR << 16; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 812 | dev_warn(&h->pdev->dev, |
| 813 | "%p had hardware error\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 814 | break; |
| 815 | case CMD_CONNECTION_LOST: |
| 816 | cmd->result = DID_ERROR << 16; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 817 | dev_warn(&h->pdev->dev, |
| 818 | "%p had connection lost\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 819 | break; |
| 820 | case CMD_ABORTED: |
| 821 | cmd->result = DID_ABORT << 16; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 822 | dev_warn(&h->pdev->dev, "%p was aborted\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 823 | break; |
| 824 | case CMD_ABORT_FAILED: |
| 825 | cmd->result = DID_ERROR << 16; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 826 | dev_warn(&h->pdev->dev, |
| 827 | "%p reports abort failed\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 828 | break; |
| 829 | case CMD_UNSOLICITED_ABORT: |
| 830 | cmd->result = DID_ABORT << 16; |
Stephen M. Cameron | 6d9a4f9 | 2011-03-12 10:02:30 +0100 | [diff] [blame] | 831 | dev_warn(&h->pdev->dev, "%p aborted due to an " |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 832 | "unsolicited abort\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 833 | break; |
| 834 | case CMD_TIMEOUT: |
| 835 | cmd->result = DID_TIME_OUT << 16; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 836 | dev_warn(&h->pdev->dev, "%p timedout\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 837 | break; |
Stephen M. Cameron | 6d9a4f9 | 2011-03-12 10:02:30 +0100 | [diff] [blame] | 838 | case CMD_UNABORTABLE: |
| 839 | cmd->result = DID_ERROR << 16; |
| 840 | dev_warn(&h->pdev->dev, "c %p command " |
| 841 | "unabortable\n", c); |
| 842 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 843 | default: |
| 844 | cmd->result = DID_ERROR << 16; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 845 | dev_warn(&h->pdev->dev, |
| 846 | "%p returned unknown status %x\n", c, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 847 | ei->CommandStatus); |
| 848 | } |
| 849 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 850 | cmd->scsi_done(cmd); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 851 | scsi_cmd_free(h, c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 852 | } |
| 853 | |
| 854 | static int |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 855 | cciss_scsi_detect(ctlr_info_t *h) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 856 | { |
| 857 | struct Scsi_Host *sh; |
| 858 | int error; |
| 859 | |
| 860 | sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *)); |
| 861 | if (sh == NULL) |
| 862 | goto fail; |
| 863 | sh->io_port = 0; // good enough? FIXME, |
| 864 | sh->n_io_port = 0; // I don't think we use these two... |
| 865 | sh->this_id = SELF_SCSI_ID; |
Stephen M. Cameron | 8a4ec67 | 2011-05-03 14:54:12 -0500 | [diff] [blame] | 866 | sh->can_queue = cciss_tape_cmds; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 867 | sh->sg_tablesize = h->maxsgentries; |
Stephen M. Cameron | 79600aa | 2010-06-15 08:12:34 +0200 | [diff] [blame] | 868 | sh->max_cmd_len = MAX_COMMAND_SIZE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 869 | |
| 870 | ((struct cciss_scsi_adapter_data_t *) |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 871 | h->scsi_ctlr)->scsi_host = sh; |
| 872 | sh->hostdata[0] = (unsigned long) h; |
| 873 | sh->irq = h->intr[SIMPLE_MODE_INT]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 874 | sh->unique_id = sh->irq; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 875 | error = scsi_add_host(sh, &h->pdev->dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 876 | if (error) |
| 877 | goto fail_host_put; |
| 878 | scsi_scan_host(sh); |
| 879 | return 1; |
| 880 | |
| 881 | fail_host_put: |
| 882 | scsi_host_put(sh); |
| 883 | fail: |
| 884 | return 0; |
| 885 | } |
| 886 | |
| 887 | static void |
| 888 | cciss_unmap_one(struct pci_dev *pdev, |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 889 | CommandList_struct *c, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 890 | size_t buflen, |
| 891 | int data_direction) |
| 892 | { |
| 893 | u64bit addr64; |
| 894 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 895 | addr64.val32.lower = c->SG[0].Addr.lower; |
| 896 | addr64.val32.upper = c->SG[0].Addr.upper; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 897 | pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction); |
| 898 | } |
| 899 | |
| 900 | static void |
| 901 | cciss_map_one(struct pci_dev *pdev, |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 902 | CommandList_struct *c, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 903 | unsigned char *buf, |
| 904 | size_t buflen, |
| 905 | int data_direction) |
| 906 | { |
| 907 | __u64 addr64; |
| 908 | |
| 909 | addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 910 | c->SG[0].Addr.lower = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 911 | (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 912 | c->SG[0].Addr.upper = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 913 | (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 914 | c->SG[0].Len = buflen; |
| 915 | c->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */ |
| 916 | c->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 917 | } |
| 918 | |
| 919 | static int |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 920 | cciss_scsi_do_simple_cmd(ctlr_info_t *h, |
| 921 | CommandList_struct *c, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 922 | unsigned char *scsi3addr, |
| 923 | unsigned char *cdb, |
| 924 | unsigned char cdblen, |
| 925 | unsigned char *buf, int bufsize, |
| 926 | int direction) |
| 927 | { |
Peter Zijlstra | 6e9a473 | 2006-09-30 23:28:10 -0700 | [diff] [blame] | 928 | DECLARE_COMPLETION_ONSTACK(wait); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 929 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 930 | c->cmd_type = CMD_IOCTL_PEND; /* treat this like an ioctl */ |
| 931 | c->scsi_cmd = NULL; |
| 932 | c->Header.ReplyQueue = 0; /* unused in simple mode */ |
| 933 | memcpy(&c->Header.LUN, scsi3addr, sizeof(c->Header.LUN)); |
| 934 | c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 935 | // Fill in the request block... |
| 936 | |
| 937 | /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n", |
| 938 | scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3], |
| 939 | scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */ |
| 940 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 941 | memset(c->Request.CDB, 0, sizeof(c->Request.CDB)); |
| 942 | memcpy(c->Request.CDB, cdb, cdblen); |
| 943 | c->Request.Timeout = 0; |
| 944 | c->Request.CDBLen = cdblen; |
| 945 | c->Request.Type.Type = TYPE_CMD; |
| 946 | c->Request.Type.Attribute = ATTR_SIMPLE; |
| 947 | c->Request.Type.Direction = direction; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 948 | |
| 949 | /* Fill in the SG list and do dma mapping */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 950 | cciss_map_one(h->pdev, c, (unsigned char *) buf, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 951 | bufsize, DMA_FROM_DEVICE); |
| 952 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 953 | c->waiting = &wait; |
| 954 | enqueue_cmd_and_start_io(h, c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 955 | wait_for_completion(&wait); |
| 956 | |
| 957 | /* undo the dma mapping */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 958 | cciss_unmap_one(h->pdev, c, bufsize, DMA_FROM_DEVICE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 959 | return(0); |
| 960 | } |
| 961 | |
| 962 | static void |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 963 | cciss_scsi_interpret_error(ctlr_info_t *h, CommandList_struct *c) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 964 | { |
| 965 | ErrorInfo_struct *ei; |
| 966 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 967 | ei = c->err_info; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 968 | switch(ei->CommandStatus) |
| 969 | { |
| 970 | case CMD_TARGET_STATUS: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 971 | dev_warn(&h->pdev->dev, |
| 972 | "cmd %p has completed with errors\n", c); |
| 973 | dev_warn(&h->pdev->dev, |
| 974 | "cmd %p has SCSI Status = %x\n", |
| 975 | c, ei->ScsiStatus); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 976 | if (ei->ScsiStatus == 0) |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 977 | dev_warn(&h->pdev->dev, |
| 978 | "SCSI status is abnormally zero. " |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 979 | "(probably indicates selection timeout " |
| 980 | "reported incorrectly due to a known " |
| 981 | "firmware bug, circa July, 2001.)\n"); |
| 982 | break; |
| 983 | case CMD_DATA_UNDERRUN: /* let mid layer handle it. */ |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 984 | dev_info(&h->pdev->dev, "UNDERRUN\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 985 | break; |
| 986 | case CMD_DATA_OVERRUN: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 987 | dev_warn(&h->pdev->dev, "%p has" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 988 | " completed with data overrun " |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 989 | "reported\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 990 | break; |
| 991 | case CMD_INVALID: { |
| 992 | /* controller unfortunately reports SCSI passthru's */ |
| 993 | /* to non-existent targets as invalid commands. */ |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 994 | dev_warn(&h->pdev->dev, |
| 995 | "%p is reported invalid (probably means " |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 996 | "target device no longer present)\n", c); |
| 997 | /* print_bytes((unsigned char *) c, sizeof(*c), 1, 0); |
| 998 | print_cmd(c); */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 999 | } |
| 1000 | break; |
| 1001 | case CMD_PROTOCOL_ERR: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1002 | dev_warn(&h->pdev->dev, "%p has protocol error\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1003 | break; |
| 1004 | case CMD_HARDWARE_ERR: |
| 1005 | /* cmd->result = DID_ERROR << 16; */ |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1006 | dev_warn(&h->pdev->dev, "%p had hardware error\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1007 | break; |
| 1008 | case CMD_CONNECTION_LOST: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1009 | dev_warn(&h->pdev->dev, "%p had connection lost\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1010 | break; |
| 1011 | case CMD_ABORTED: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1012 | dev_warn(&h->pdev->dev, "%p was aborted\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1013 | break; |
| 1014 | case CMD_ABORT_FAILED: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1015 | dev_warn(&h->pdev->dev, |
| 1016 | "%p reports abort failed\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1017 | break; |
| 1018 | case CMD_UNSOLICITED_ABORT: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1019 | dev_warn(&h->pdev->dev, |
Stephen M. Cameron | 6d9a4f9 | 2011-03-12 10:02:30 +0100 | [diff] [blame] | 1020 | "%p aborted due to an unsolicited abort\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1021 | break; |
| 1022 | case CMD_TIMEOUT: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1023 | dev_warn(&h->pdev->dev, "%p timedout\n", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1024 | break; |
Stephen M. Cameron | 6d9a4f9 | 2011-03-12 10:02:30 +0100 | [diff] [blame] | 1025 | case CMD_UNABORTABLE: |
| 1026 | dev_warn(&h->pdev->dev, |
| 1027 | "%p unabortable\n", c); |
| 1028 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1029 | default: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1030 | dev_warn(&h->pdev->dev, |
| 1031 | "%p returned unknown status %x\n", |
| 1032 | c, ei->CommandStatus); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1033 | } |
| 1034 | } |
| 1035 | |
| 1036 | static int |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1037 | cciss_scsi_do_inquiry(ctlr_info_t *h, unsigned char *scsi3addr, |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1038 | unsigned char page, unsigned char *buf, |
| 1039 | unsigned char bufsize) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1040 | { |
| 1041 | int rc; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1042 | CommandList_struct *c; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1043 | char cdb[6]; |
| 1044 | ErrorInfo_struct *ei; |
| 1045 | unsigned long flags; |
| 1046 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1047 | spin_lock_irqsave(&h->lock, flags); |
| 1048 | c = scsi_cmd_alloc(h); |
| 1049 | spin_unlock_irqrestore(&h->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1050 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1051 | if (c == NULL) { /* trouble... */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1052 | printk("cmd_alloc returned NULL!\n"); |
| 1053 | return -1; |
| 1054 | } |
| 1055 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1056 | ei = c->err_info; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1057 | |
| 1058 | cdb[0] = CISS_INQUIRY; |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1059 | cdb[1] = (page != 0); |
| 1060 | cdb[2] = page; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1061 | cdb[3] = 0; |
Mike Miller | 47922d0 | 2005-09-13 01:25:25 -0700 | [diff] [blame] | 1062 | cdb[4] = bufsize; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1063 | cdb[5] = 0; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1064 | rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, cdb, |
Mike Miller | 47922d0 | 2005-09-13 01:25:25 -0700 | [diff] [blame] | 1065 | 6, buf, bufsize, XFER_READ); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1066 | |
| 1067 | if (rc != 0) return rc; /* something went wrong */ |
| 1068 | |
| 1069 | if (ei->CommandStatus != 0 && |
| 1070 | ei->CommandStatus != CMD_DATA_UNDERRUN) { |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1071 | cciss_scsi_interpret_error(h, c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1072 | rc = -1; |
| 1073 | } |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1074 | spin_lock_irqsave(&h->lock, flags); |
| 1075 | scsi_cmd_free(h, c); |
| 1076 | spin_unlock_irqrestore(&h->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1077 | return rc; |
| 1078 | } |
| 1079 | |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1080 | /* Get the device id from inquiry page 0x83 */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1081 | static int cciss_scsi_get_device_id(ctlr_info_t *h, unsigned char *scsi3addr, |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1082 | unsigned char *device_id, int buflen) |
| 1083 | { |
| 1084 | int rc; |
| 1085 | unsigned char *buf; |
| 1086 | |
| 1087 | if (buflen > 16) |
| 1088 | buflen = 16; |
| 1089 | buf = kzalloc(64, GFP_KERNEL); |
| 1090 | if (!buf) |
| 1091 | return -1; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1092 | rc = cciss_scsi_do_inquiry(h, scsi3addr, 0x83, buf, 64); |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1093 | if (rc == 0) |
| 1094 | memcpy(device_id, &buf[8], buflen); |
| 1095 | kfree(buf); |
| 1096 | return rc != 0; |
| 1097 | } |
| 1098 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1099 | static int |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1100 | cciss_scsi_do_report_phys_luns(ctlr_info_t *h, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1101 | ReportLunData_struct *buf, int bufsize) |
| 1102 | { |
| 1103 | int rc; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1104 | CommandList_struct *c; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1105 | unsigned char cdb[12]; |
| 1106 | unsigned char scsi3addr[8]; |
| 1107 | ErrorInfo_struct *ei; |
| 1108 | unsigned long flags; |
| 1109 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1110 | spin_lock_irqsave(&h->lock, flags); |
| 1111 | c = scsi_cmd_alloc(h); |
| 1112 | spin_unlock_irqrestore(&h->lock, flags); |
| 1113 | if (c == NULL) { /* trouble... */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1114 | printk("cmd_alloc returned NULL!\n"); |
| 1115 | return -1; |
| 1116 | } |
| 1117 | |
| 1118 | memset(&scsi3addr[0], 0, 8); /* address the controller */ |
| 1119 | cdb[0] = CISS_REPORT_PHYS; |
| 1120 | cdb[1] = 0; |
| 1121 | cdb[2] = 0; |
| 1122 | cdb[3] = 0; |
| 1123 | cdb[4] = 0; |
| 1124 | cdb[5] = 0; |
| 1125 | cdb[6] = (bufsize >> 24) & 0xFF; //MSB |
| 1126 | cdb[7] = (bufsize >> 16) & 0xFF; |
| 1127 | cdb[8] = (bufsize >> 8) & 0xFF; |
| 1128 | cdb[9] = bufsize & 0xFF; |
| 1129 | cdb[10] = 0; |
| 1130 | cdb[11] = 0; |
| 1131 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1132 | rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1133 | cdb, 12, |
| 1134 | (unsigned char *) buf, |
| 1135 | bufsize, XFER_READ); |
| 1136 | |
| 1137 | if (rc != 0) return rc; /* something went wrong */ |
| 1138 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1139 | ei = c->err_info; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1140 | if (ei->CommandStatus != 0 && |
| 1141 | ei->CommandStatus != CMD_DATA_UNDERRUN) { |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1142 | cciss_scsi_interpret_error(h, c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1143 | rc = -1; |
| 1144 | } |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1145 | spin_lock_irqsave(&h->lock, flags); |
| 1146 | scsi_cmd_free(h, c); |
| 1147 | spin_unlock_irqrestore(&h->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1148 | return rc; |
| 1149 | } |
| 1150 | |
| 1151 | static void |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1152 | cciss_update_non_disk_devices(ctlr_info_t *h, int hostno) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1153 | { |
| 1154 | /* the idea here is we could get notified from /proc |
| 1155 | that some devices have changed, so we do a report |
| 1156 | physical luns cmd, and adjust our list of devices |
| 1157 | accordingly. (We can't rely on the scsi-mid layer just |
| 1158 | doing inquiries, because the "busses" that the scsi |
| 1159 | mid-layer probes are totally fabricated by this driver, |
| 1160 | so new devices wouldn't show up. |
| 1161 | |
| 1162 | the scsi3addr's of devices won't change so long as the |
| 1163 | adapter is not reset. That means we can rescan and |
| 1164 | tell which devices we already know about, vs. new |
| 1165 | devices, vs. disappearing devices. |
| 1166 | |
| 1167 | Also, if you yank out a tape drive, then put in a disk |
| 1168 | in it's place, (say, a configured volume from another |
| 1169 | array controller for instance) _don't_ poke this driver |
| 1170 | (so it thinks it's still a tape, but _do_ poke the scsi |
| 1171 | mid layer, so it does an inquiry... the scsi mid layer |
| 1172 | will see the physical disk. This would be bad. Need to |
| 1173 | think about how to prevent that. One idea would be to |
| 1174 | snoop all scsi responses and if an inquiry repsonse comes |
| 1175 | back that reports a disk, chuck it an return selection |
| 1176 | timeout instead and adjust our table... Not sure i like |
| 1177 | that though. |
| 1178 | |
| 1179 | */ |
Mike Miller | 47922d0 | 2005-09-13 01:25:25 -0700 | [diff] [blame] | 1180 | #define OBDR_TAPE_INQ_SIZE 49 |
| 1181 | #define OBDR_TAPE_SIG "$DR-10" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1182 | ReportLunData_struct *ld_buff; |
Mike Miller | 47922d0 | 2005-09-13 01:25:25 -0700 | [diff] [blame] | 1183 | unsigned char *inq_buff; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1184 | unsigned char scsi3addr[8]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1185 | __u32 num_luns=0; |
| 1186 | unsigned char *ch; |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1187 | struct cciss_scsi_dev_t *currentsd, *this_device; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1188 | int ncurrent=0; |
| 1189 | int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8; |
| 1190 | int i; |
| 1191 | |
Eric Sesterhenn | 06ff37f | 2006-03-08 11:21:52 +0100 | [diff] [blame] | 1192 | ld_buff = kzalloc(reportlunsize, GFP_KERNEL); |
Mike Miller | 47922d0 | 2005-09-13 01:25:25 -0700 | [diff] [blame] | 1193 | inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL); |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1194 | currentsd = kzalloc(sizeof(*currentsd) * |
| 1195 | (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL); |
| 1196 | if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) { |
| 1197 | printk(KERN_ERR "cciss: out of memory\n"); |
| 1198 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1199 | } |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1200 | this_device = ¤tsd[CCISS_MAX_SCSI_DEVS_PER_HBA]; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1201 | if (cciss_scsi_do_report_phys_luns(h, ld_buff, reportlunsize) == 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1202 | ch = &ld_buff->LUNListLength[0]; |
| 1203 | num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8; |
| 1204 | if (num_luns > CISS_MAX_PHYS_LUN) { |
| 1205 | printk(KERN_WARNING |
| 1206 | "cciss: Maximum physical LUNs (%d) exceeded. " |
| 1207 | "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN, |
| 1208 | num_luns - CISS_MAX_PHYS_LUN); |
| 1209 | num_luns = CISS_MAX_PHYS_LUN; |
| 1210 | } |
| 1211 | } |
| 1212 | else { |
| 1213 | printk(KERN_ERR "cciss: Report physical LUNs failed.\n"); |
| 1214 | goto out; |
| 1215 | } |
| 1216 | |
| 1217 | |
| 1218 | /* adjust our table of devices */ |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1219 | for (i = 0; i < num_luns; i++) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1220 | /* for each physical lun, do an inquiry */ |
| 1221 | if (ld_buff->LUN[i][3] & 0xC0) continue; |
Mike Miller | 47922d0 | 2005-09-13 01:25:25 -0700 | [diff] [blame] | 1222 | memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1223 | memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8); |
| 1224 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1225 | if (cciss_scsi_do_inquiry(h, scsi3addr, 0, inq_buff, |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1226 | (unsigned char) OBDR_TAPE_INQ_SIZE) != 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1227 | /* Inquiry failed (msg printed already) */ |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1228 | continue; /* so we will skip this device. */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1229 | |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1230 | this_device->devtype = (inq_buff[0] & 0x1f); |
| 1231 | this_device->bus = -1; |
| 1232 | this_device->target = -1; |
| 1233 | this_device->lun = -1; |
| 1234 | memcpy(this_device->scsi3addr, scsi3addr, 8); |
| 1235 | memcpy(this_device->vendor, &inq_buff[8], |
| 1236 | sizeof(this_device->vendor)); |
| 1237 | memcpy(this_device->model, &inq_buff[16], |
| 1238 | sizeof(this_device->model)); |
| 1239 | memcpy(this_device->revision, &inq_buff[32], |
| 1240 | sizeof(this_device->revision)); |
| 1241 | memset(this_device->device_id, 0, |
| 1242 | sizeof(this_device->device_id)); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1243 | cciss_scsi_get_device_id(h, scsi3addr, |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1244 | this_device->device_id, sizeof(this_device->device_id)); |
| 1245 | |
| 1246 | switch (this_device->devtype) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1247 | { |
Mike Miller | 47922d0 | 2005-09-13 01:25:25 -0700 | [diff] [blame] | 1248 | case 0x05: /* CD-ROM */ { |
| 1249 | |
| 1250 | /* We don't *really* support actual CD-ROM devices, |
| 1251 | * just this "One Button Disaster Recovery" tape drive |
| 1252 | * which temporarily pretends to be a CD-ROM drive. |
| 1253 | * So we check that the device is really an OBDR tape |
| 1254 | * device by checking for "$DR-10" in bytes 43-48 of |
| 1255 | * the inquiry data. |
| 1256 | */ |
| 1257 | char obdr_sig[7]; |
| 1258 | |
| 1259 | strncpy(obdr_sig, &inq_buff[43], 6); |
| 1260 | obdr_sig[6] = '\0'; |
| 1261 | if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0) |
| 1262 | /* Not OBDR device, ignore it. */ |
| 1263 | break; |
| 1264 | } |
| 1265 | /* fall through . . . */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1266 | case 0x01: /* sequential access, (tape) */ |
| 1267 | case 0x08: /* medium changer */ |
| 1268 | if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) { |
| 1269 | printk(KERN_INFO "cciss%d: %s ignored, " |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1270 | "too many devices.\n", h->ctlr, |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1271 | scsi_device_type(this_device->devtype)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1272 | break; |
| 1273 | } |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1274 | currentsd[ncurrent] = *this_device; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1275 | ncurrent++; |
| 1276 | break; |
| 1277 | default: |
| 1278 | break; |
| 1279 | } |
| 1280 | } |
| 1281 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1282 | adjust_cciss_scsi_table(h, hostno, currentsd, ncurrent); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1283 | out: |
| 1284 | kfree(inq_buff); |
| 1285 | kfree(ld_buff); |
scameron@beardog.cca.cpqcorp.net | 905bd78 | 2008-09-19 18:27:47 -0700 | [diff] [blame] | 1286 | kfree(currentsd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1287 | return; |
| 1288 | } |
| 1289 | |
| 1290 | static int |
| 1291 | is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c |
| 1292 | { |
| 1293 | int verb_len = strlen(verb); |
| 1294 | if (len >= verb_len && !memcmp(verb,ptr,verb_len)) |
| 1295 | return verb_len; |
| 1296 | else |
| 1297 | return 0; |
| 1298 | } |
| 1299 | |
| 1300 | static int |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1301 | cciss_scsi_user_command(ctlr_info_t *h, int hostno, char *buffer, int length) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1302 | { |
| 1303 | int arg_len; |
| 1304 | |
| 1305 | if ((arg_len = is_keyword(buffer, length, "rescan")) != 0) |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1306 | cciss_update_non_disk_devices(h, hostno); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1307 | else |
| 1308 | return -EINVAL; |
| 1309 | return length; |
| 1310 | } |
| 1311 | |
| 1312 | |
| 1313 | static int |
| 1314 | cciss_scsi_proc_info(struct Scsi_Host *sh, |
| 1315 | char *buffer, /* data buffer */ |
| 1316 | char **start, /* where data in buffer starts */ |
| 1317 | off_t offset, /* offset from start of imaginary file */ |
| 1318 | int length, /* length of data in buffer */ |
| 1319 | int func) /* 0 == read, 1 == write */ |
| 1320 | { |
| 1321 | |
| 1322 | int buflen, datalen; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1323 | ctlr_info_t *h; |
Mike Miller | b9f0bd0 | 2005-09-13 01:25:26 -0700 | [diff] [blame] | 1324 | int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1325 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1326 | h = (ctlr_info_t *) sh->hostdata[0]; |
| 1327 | if (h == NULL) /* This really shouldn't ever happen. */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1328 | return -EINVAL; |
| 1329 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1330 | if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */ |
Mike Miller | b9f0bd0 | 2005-09-13 01:25:26 -0700 | [diff] [blame] | 1331 | buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n", |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1332 | h->ctlr, sh->host_no); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1333 | |
Mike Miller | b9f0bd0 | 2005-09-13 01:25:26 -0700 | [diff] [blame] | 1334 | /* this information is needed by apps to know which cciss |
| 1335 | device corresponds to which scsi host number without |
| 1336 | having to open a scsi target device node. The device |
| 1337 | information is not a duplicate of /proc/scsi/scsi because |
| 1338 | the two may be out of sync due to scsi hotplug, rather |
| 1339 | this info is for an app to be able to use to know how to |
| 1340 | get them back in sync. */ |
| 1341 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1342 | for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) { |
| 1343 | struct cciss_scsi_dev_t *sd = |
| 1344 | &ccissscsi[h->ctlr].dev[i]; |
Mike Miller | b9f0bd0 | 2005-09-13 01:25:26 -0700 | [diff] [blame] | 1345 | buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d " |
| 1346 | "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", |
| 1347 | sh->host_no, sd->bus, sd->target, sd->lun, |
| 1348 | sd->devtype, |
| 1349 | sd->scsi3addr[0], sd->scsi3addr[1], |
| 1350 | sd->scsi3addr[2], sd->scsi3addr[3], |
| 1351 | sd->scsi3addr[4], sd->scsi3addr[5], |
| 1352 | sd->scsi3addr[6], sd->scsi3addr[7]); |
| 1353 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1354 | datalen = buflen - offset; |
| 1355 | if (datalen < 0) { /* they're reading past EOF. */ |
| 1356 | datalen = 0; |
| 1357 | *start = buffer+buflen; |
| 1358 | } else |
| 1359 | *start = buffer + offset; |
| 1360 | return(datalen); |
| 1361 | } else /* User is writing to /proc/scsi/cciss*?/?* ... */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1362 | return cciss_scsi_user_command(h, sh->host_no, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1363 | buffer, length); |
| 1364 | } |
| 1365 | |
| 1366 | /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci |
| 1367 | dma mapping and fills in the scatter gather entries of the |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1368 | cciss command, c. */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1369 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1370 | static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *c, |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1371 | struct scsi_cmnd *cmd) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1372 | { |
FUJITA Tomonori | 41ce639 | 2007-05-26 02:45:17 +0900 | [diff] [blame] | 1373 | unsigned int len; |
| 1374 | struct scatterlist *sg; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1375 | __u64 addr64; |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1376 | int request_nsgs, i, chained, sg_index; |
| 1377 | struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr; |
| 1378 | SGDescriptor_struct *curr_sg; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1379 | |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1380 | BUG_ON(scsi_sg_count(cmd) > h->maxsgentries); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1381 | |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1382 | chained = 0; |
| 1383 | sg_index = 0; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1384 | curr_sg = c->SG; |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1385 | request_nsgs = scsi_dma_map(cmd); |
| 1386 | if (request_nsgs) { |
| 1387 | scsi_for_each_sg(cmd, sg, request_nsgs, i) { |
| 1388 | if (sg_index + 1 == h->max_cmd_sgentries && |
| 1389 | !chained && request_nsgs - i > 1) { |
| 1390 | chained = 1; |
| 1391 | sg_index = 0; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1392 | curr_sg = sa->cmd_sg_list[c->cmdindex]; |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1393 | } |
FUJITA Tomonori | 41ce639 | 2007-05-26 02:45:17 +0900 | [diff] [blame] | 1394 | addr64 = (__u64) sg_dma_address(sg); |
| 1395 | len = sg_dma_len(sg); |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1396 | curr_sg[sg_index].Addr.lower = |
| 1397 | (__u32) (addr64 & 0x0FFFFFFFFULL); |
| 1398 | curr_sg[sg_index].Addr.upper = |
| 1399 | (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL); |
| 1400 | curr_sg[sg_index].Len = len; |
| 1401 | curr_sg[sg_index].Ext = 0; |
| 1402 | ++sg_index; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1403 | } |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1404 | if (chained) |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1405 | cciss_map_sg_chain_block(h, c, |
| 1406 | sa->cmd_sg_list[c->cmdindex], |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1407 | (request_nsgs - (h->max_cmd_sgentries - 1)) * |
| 1408 | sizeof(SGDescriptor_struct)); |
FUJITA Tomonori | 41ce639 | 2007-05-26 02:45:17 +0900 | [diff] [blame] | 1409 | } |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1410 | /* track how many SG entries we are using */ |
| 1411 | if (request_nsgs > h->maxSG) |
| 1412 | h->maxSG = request_nsgs; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1413 | c->Header.SGTotal = (__u8) request_nsgs + chained; |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1414 | if (request_nsgs > h->max_cmd_sgentries) |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1415 | c->Header.SGList = h->max_cmd_sgentries; |
Stephen M. Cameron | 87c3a92 | 2010-02-26 16:01:53 -0600 | [diff] [blame] | 1416 | else |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1417 | c->Header.SGList = c->Header.SGTotal; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1418 | return; |
| 1419 | } |
| 1420 | |
| 1421 | |
| 1422 | static int |
Jeff Garzik | f281233 | 2010-11-16 02:10:29 -0500 | [diff] [blame] | 1423 | cciss_scsi_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1424 | { |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1425 | ctlr_info_t *h; |
| 1426 | int rc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1427 | unsigned char scsi3addr[8]; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1428 | CommandList_struct *c; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1429 | unsigned long flags; |
| 1430 | |
| 1431 | // Get the ptr to our adapter structure (hba[i]) out of cmd->host. |
| 1432 | // We violate cmd->host privacy here. (Is there another way?) |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1433 | h = (ctlr_info_t *) cmd->device->host->hostdata[0]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1434 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1435 | rc = lookup_scsi3addr(h, cmd->device->channel, cmd->device->id, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1436 | cmd->device->lun, scsi3addr); |
| 1437 | if (rc != 0) { |
| 1438 | /* the scsi nexus does not match any that we presented... */ |
| 1439 | /* pretend to mid layer that we got selection timeout */ |
| 1440 | cmd->result = DID_NO_CONNECT << 16; |
| 1441 | done(cmd); |
| 1442 | /* we might want to think about registering controller itself |
| 1443 | as a processor device on the bus so sg binds to it. */ |
| 1444 | return 0; |
| 1445 | } |
| 1446 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1447 | /* Ok, we have a reasonable scsi nexus, so send the cmd down, and |
| 1448 | see what the device thinks of it. */ |
| 1449 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1450 | spin_lock_irqsave(&h->lock, flags); |
| 1451 | c = scsi_cmd_alloc(h); |
| 1452 | spin_unlock_irqrestore(&h->lock, flags); |
| 1453 | if (c == NULL) { /* trouble... */ |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1454 | dev_warn(&h->pdev->dev, "scsi_cmd_alloc returned NULL!\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1455 | /* FIXME: next 3 lines are -> BAD! <- */ |
| 1456 | cmd->result = DID_NO_CONNECT << 16; |
| 1457 | done(cmd); |
| 1458 | return 0; |
| 1459 | } |
| 1460 | |
| 1461 | // Fill in the command list header |
| 1462 | |
| 1463 | cmd->scsi_done = done; // save this for use by completion code |
| 1464 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1465 | /* save c in case we have to abort it */ |
| 1466 | cmd->host_scribble = (unsigned char *) c; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1467 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1468 | c->cmd_type = CMD_SCSI; |
| 1469 | c->scsi_cmd = cmd; |
| 1470 | c->Header.ReplyQueue = 0; /* unused in simple mode */ |
| 1471 | memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8); |
| 1472 | c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1473 | |
| 1474 | // Fill in the request block... |
| 1475 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1476 | c->Request.Timeout = 0; |
| 1477 | memset(c->Request.CDB, 0, sizeof(c->Request.CDB)); |
| 1478 | BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB)); |
| 1479 | c->Request.CDBLen = cmd->cmd_len; |
| 1480 | memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len); |
| 1481 | c->Request.Type.Type = TYPE_CMD; |
| 1482 | c->Request.Type.Attribute = ATTR_SIMPLE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1483 | switch(cmd->sc_data_direction) |
| 1484 | { |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1485 | case DMA_TO_DEVICE: |
| 1486 | c->Request.Type.Direction = XFER_WRITE; |
| 1487 | break; |
| 1488 | case DMA_FROM_DEVICE: |
| 1489 | c->Request.Type.Direction = XFER_READ; |
| 1490 | break; |
| 1491 | case DMA_NONE: |
| 1492 | c->Request.Type.Direction = XFER_NONE; |
| 1493 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1494 | case DMA_BIDIRECTIONAL: |
| 1495 | // This can happen if a buggy application does a scsi passthru |
| 1496 | // and sets both inlen and outlen to non-zero. ( see |
| 1497 | // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() ) |
| 1498 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1499 | c->Request.Type.Direction = XFER_RSVD; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1500 | // This is technically wrong, and cciss controllers should |
| 1501 | // reject it with CMD_INVALID, which is the most correct |
| 1502 | // response, but non-fibre backends appear to let it |
| 1503 | // slide by, and give the same results as if this field |
| 1504 | // were set correctly. Either way is acceptable for |
| 1505 | // our purposes here. |
| 1506 | |
| 1507 | break; |
| 1508 | |
| 1509 | default: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1510 | dev_warn(&h->pdev->dev, "unknown data direction: %d\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1511 | cmd->sc_data_direction); |
| 1512 | BUG(); |
| 1513 | break; |
| 1514 | } |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1515 | cciss_scatter_gather(h, c, cmd); |
| 1516 | enqueue_cmd_and_start_io(h, c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1517 | /* the cmd'll come back via intr handler in complete_scsi_command() */ |
| 1518 | return 0; |
| 1519 | } |
| 1520 | |
Jeff Garzik | f281233 | 2010-11-16 02:10:29 -0500 | [diff] [blame] | 1521 | static DEF_SCSI_QCMD(cciss_scsi_queue_command) |
| 1522 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1523 | static void cciss_unregister_scsi(ctlr_info_t *h) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1524 | { |
| 1525 | struct cciss_scsi_adapter_data_t *sa; |
| 1526 | struct cciss_scsi_cmd_stack_t *stk; |
| 1527 | unsigned long flags; |
| 1528 | |
| 1529 | /* we are being forcibly unloaded, and may not refuse. */ |
| 1530 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1531 | spin_lock_irqsave(&h->lock, flags); |
| 1532 | sa = h->scsi_ctlr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1533 | stk = &sa->cmd_stack; |
| 1534 | |
| 1535 | /* if we weren't ever actually registered, don't unregister */ |
| 1536 | if (sa->registered) { |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1537 | spin_unlock_irqrestore(&h->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1538 | scsi_remove_host(sa->scsi_host); |
| 1539 | scsi_host_put(sa->scsi_host); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1540 | spin_lock_irqsave(&h->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1541 | } |
| 1542 | |
| 1543 | /* set scsi_host to NULL so our detect routine will |
| 1544 | find us on register */ |
| 1545 | sa->scsi_host = NULL; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1546 | spin_unlock_irqrestore(&h->lock, flags); |
| 1547 | scsi_cmd_stack_free(h); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1548 | kfree(sa); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1549 | } |
| 1550 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1551 | static int cciss_engage_scsi(ctlr_info_t *h) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1552 | { |
| 1553 | struct cciss_scsi_adapter_data_t *sa; |
| 1554 | struct cciss_scsi_cmd_stack_t *stk; |
| 1555 | unsigned long flags; |
| 1556 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1557 | spin_lock_irqsave(&h->lock, flags); |
| 1558 | sa = h->scsi_ctlr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1559 | stk = &sa->cmd_stack; |
| 1560 | |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 1561 | if (sa->registered) { |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1562 | dev_info(&h->pdev->dev, "SCSI subsystem already engaged.\n"); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1563 | spin_unlock_irqrestore(&h->lock, flags); |
Stephen M. Cameron | 8721c81 | 2009-11-12 12:50:06 -0600 | [diff] [blame] | 1564 | return -ENXIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1565 | } |
Mike Miller | f4a93bc | 2008-08-04 11:54:53 +0200 | [diff] [blame] | 1566 | sa->registered = 1; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1567 | spin_unlock_irqrestore(&h->lock, flags); |
| 1568 | cciss_update_non_disk_devices(h, -1); |
| 1569 | cciss_scsi_detect(h); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1570 | return 0; |
| 1571 | } |
| 1572 | |
| 1573 | static void |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1574 | cciss_seq_tape_report(struct seq_file *seq, ctlr_info_t *h) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1575 | { |
| 1576 | unsigned long flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1577 | |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1578 | CPQ_TAPE_LOCK(h, flags); |
Mike Miller | 89b6e74 | 2008-02-21 08:54:03 +0100 | [diff] [blame] | 1579 | seq_printf(seq, |
Mike Miller | b9f0bd0 | 2005-09-13 01:25:26 -0700 | [diff] [blame] | 1580 | "Sequential access devices: %d\n\n", |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1581 | ccissscsi[h->ctlr].ndevices); |
| 1582 | CPQ_TAPE_UNLOCK(h, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1583 | } |
| 1584 | |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1585 | static int wait_for_device_to_become_ready(ctlr_info_t *h, |
| 1586 | unsigned char lunaddr[]) |
| 1587 | { |
| 1588 | int rc; |
| 1589 | int count = 0; |
| 1590 | int waittime = HZ; |
| 1591 | CommandList_struct *c; |
| 1592 | |
Stephen M. Cameron | 6b4d96b | 2010-07-19 13:46:43 -0500 | [diff] [blame] | 1593 | c = cmd_alloc(h); |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1594 | if (!c) { |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1595 | dev_warn(&h->pdev->dev, "out of memory in " |
| 1596 | "wait_for_device_to_become_ready.\n"); |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1597 | return IO_ERROR; |
| 1598 | } |
| 1599 | |
| 1600 | /* Send test unit ready until device ready, or give up. */ |
| 1601 | while (count < 20) { |
| 1602 | |
| 1603 | /* Wait for a bit. do this first, because if we send |
| 1604 | * the TUR right away, the reset will just abort it. |
| 1605 | */ |
scameron@beardog.cca.cpqcorp.net | 40df6ae | 2009-06-08 15:59:38 -0500 | [diff] [blame] | 1606 | schedule_timeout_uninterruptible(waittime); |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1607 | count++; |
| 1608 | |
| 1609 | /* Increase wait time with each try, up to a point. */ |
| 1610 | if (waittime < (HZ * 30)) |
| 1611 | waittime = waittime * 2; |
| 1612 | |
| 1613 | /* Send the Test Unit Ready */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1614 | rc = fill_cmd(h, c, TEST_UNIT_READY, NULL, 0, 0, |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1615 | lunaddr, TYPE_CMD); |
scameron@beardog.cca.cpqcorp.net | 85cc61a | 2009-06-08 16:07:45 -0500 | [diff] [blame] | 1616 | if (rc == 0) |
| 1617 | rc = sendcmd_withirq_core(h, c, 0); |
| 1618 | |
| 1619 | (void) process_sendcmd_error(h, c); |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1620 | |
scameron@beardog.cca.cpqcorp.net | 3969251 | 2009-06-08 16:10:57 -0500 | [diff] [blame] | 1621 | if (rc != 0) |
| 1622 | goto retry_tur; |
| 1623 | |
| 1624 | if (c->err_info->CommandStatus == CMD_SUCCESS) |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1625 | break; |
| 1626 | |
scameron@beardog.cca.cpqcorp.net | 3969251 | 2009-06-08 16:10:57 -0500 | [diff] [blame] | 1627 | if (c->err_info->CommandStatus == CMD_TARGET_STATUS && |
| 1628 | c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) { |
| 1629 | if (c->err_info->SenseInfo[2] == NO_SENSE) |
| 1630 | break; |
| 1631 | if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) { |
| 1632 | unsigned char asc; |
| 1633 | asc = c->err_info->SenseInfo[12]; |
| 1634 | check_for_unit_attention(h, c); |
| 1635 | if (asc == POWER_OR_RESET) |
| 1636 | break; |
| 1637 | } |
| 1638 | } |
| 1639 | retry_tur: |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1640 | dev_warn(&h->pdev->dev, "Waiting %d secs " |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1641 | "for device to become ready.\n", |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1642 | waittime / HZ); |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1643 | rc = 1; /* device not ready. */ |
| 1644 | } |
| 1645 | |
| 1646 | if (rc) |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1647 | dev_warn(&h->pdev->dev, "giving up on device.\n"); |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1648 | else |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1649 | dev_warn(&h->pdev->dev, "device is ready.\n"); |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1650 | |
Stephen M. Cameron | 6b4d96b | 2010-07-19 13:46:43 -0500 | [diff] [blame] | 1651 | cmd_free(h, c); |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1652 | return rc; |
| 1653 | } |
Mike Miller | 89b6e74 | 2008-02-21 08:54:03 +0100 | [diff] [blame] | 1654 | |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1655 | /* Need at least one of these error handlers to keep ../scsi/hosts.c from |
| 1656 | * complaining. Doing a host- or bus-reset can't do anything good here. |
| 1657 | * Despite what it might say in scsi_error.c, there may well be commands |
| 1658 | * on the controller, as the cciss driver registers twice, once as a block |
| 1659 | * device for the logical drives, and once as a scsi device, for any tape |
| 1660 | * drives. So we know there are no commands out on the tape drives, but we |
| 1661 | * don't know there are no commands on the controller, and it is likely |
| 1662 | * that there probably are, as the cciss block device is most commonly used |
| 1663 | * as a boot device (embedded controller on HP/Compaq systems.) |
| 1664 | */ |
| 1665 | |
| 1666 | static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd) |
| 1667 | { |
| 1668 | int rc; |
| 1669 | CommandList_struct *cmd_in_trouble; |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1670 | unsigned char lunaddr[8]; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1671 | ctlr_info_t *h; |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1672 | |
| 1673 | /* find the controller to which the command to be aborted was sent */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1674 | h = (ctlr_info_t *) scsicmd->device->host->hostdata[0]; |
| 1675 | if (h == NULL) /* paranoia */ |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1676 | return FAILED; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1677 | dev_warn(&h->pdev->dev, "resetting tape drive or medium changer.\n"); |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1678 | /* find the command that's giving us trouble */ |
| 1679 | cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble; |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1680 | if (cmd_in_trouble == NULL) /* paranoia */ |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1681 | return FAILED; |
Stephen M. Cameron | 88f627a | 2009-06-02 14:48:11 +0200 | [diff] [blame] | 1682 | memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8); |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1683 | /* send a reset to the SCSI LUN which the command was sent to */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1684 | rc = sendcmd_withirq(h, CCISS_RESET_MSG, NULL, 0, 0, lunaddr, |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1685 | TYPE_MSG); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1686 | if (rc == 0 && wait_for_device_to_become_ready(h, lunaddr) == 0) |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1687 | return SUCCESS; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1688 | dev_warn(&h->pdev->dev, "resetting device failed.\n"); |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1689 | return FAILED; |
| 1690 | } |
| 1691 | |
| 1692 | static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd) |
| 1693 | { |
| 1694 | int rc; |
| 1695 | CommandList_struct *cmd_to_abort; |
scameron@beardog.cca.cpqcorp.net | 85cc61a | 2009-06-08 16:07:45 -0500 | [diff] [blame] | 1696 | unsigned char lunaddr[8]; |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1697 | ctlr_info_t *h; |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1698 | |
| 1699 | /* find the controller to which the command to be aborted was sent */ |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1700 | h = (ctlr_info_t *) scsicmd->device->host->hostdata[0]; |
| 1701 | if (h == NULL) /* paranoia */ |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1702 | return FAILED; |
Stephen M. Cameron | b2a4a43 | 2010-07-19 13:46:48 -0500 | [diff] [blame] | 1703 | dev_warn(&h->pdev->dev, "aborting tardy SCSI cmd\n"); |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1704 | |
| 1705 | /* find the command to be aborted */ |
| 1706 | cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble; |
| 1707 | if (cmd_to_abort == NULL) /* paranoia */ |
| 1708 | return FAILED; |
scameron@beardog.cca.cpqcorp.net | 85cc61a | 2009-06-08 16:07:45 -0500 | [diff] [blame] | 1709 | memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8); |
Stephen M. Cameron | f70dba8 | 2010-07-19 13:46:38 -0500 | [diff] [blame] | 1710 | rc = sendcmd_withirq(h, CCISS_ABORT_MSG, &cmd_to_abort->Header.Tag, |
scameron@beardog.cca.cpqcorp.net | 85cc61a | 2009-06-08 16:07:45 -0500 | [diff] [blame] | 1711 | 0, 0, lunaddr, TYPE_MSG); |
mike.miller@hp.com | 3da8b71 | 2005-11-04 12:30:37 -0600 | [diff] [blame] | 1712 | if (rc == 0) |
| 1713 | return SUCCESS; |
| 1714 | return FAILED; |
| 1715 | |
| 1716 | } |
| 1717 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1718 | #else /* no CONFIG_CISS_SCSI_TAPE */ |
| 1719 | |
| 1720 | /* If no tape support, then these become defined out of existence */ |
| 1721 | |
| 1722 | #define cciss_scsi_setup(cntl_num) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1723 | |
| 1724 | #endif /* CONFIG_CISS_SCSI_TAPE */ |