1 /* 2 * Basic HP/COMPAQ MSA 1000 support. This is only needed if your HW cannot be 3 * upgraded. 4 * 5 * Copyright (C) 2006 Red Hat, Inc. All rights reserved. 6 * Copyright (C) 2006 Mike Christie 7 * Copyright (C) 2008 Hannes Reinecke <hare@suse.de> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2, or (at your option) 12 * any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; see the file COPYING. If not, write to 21 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 22 */ 23 24 #include <linux/slab.h> 25 #include <linux/module.h> 26 #include <scsi/scsi.h> 27 #include <scsi/scsi_dbg.h> 28 #include <scsi/scsi_eh.h> 29 #include <scsi/scsi_dh.h> 30 31 #define HP_SW_NAME "hp_sw" 32 33 #define HP_SW_TIMEOUT (60 * HZ) 34 #define HP_SW_RETRIES 3 35 36 #define HP_SW_PATH_UNINITIALIZED -1 37 #define HP_SW_PATH_ACTIVE 0 38 #define HP_SW_PATH_PASSIVE 1 39 40 struct hp_sw_dh_data { 41 struct scsi_dh_data dh_data; 42 unsigned char sense[SCSI_SENSE_BUFFERSIZE]; 43 int path_state; 44 int retries; 45 int retry_cnt; 46 struct scsi_device *sdev; 47 activate_complete callback_fn; 48 void *callback_data; 49 }; 50 51 static int hp_sw_start_stop(struct hp_sw_dh_data *); 52 53 static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev) 54 { 55 return container_of(sdev->scsi_dh_data, struct hp_sw_dh_data, dh_data); 56 } 57 58 /* 59 * tur_done - Handle TEST UNIT READY return status 60 * @sdev: sdev the command has been sent to 61 * @errors: blk error code 62 * 63 * Returns SCSI_DH_DEV_OFFLINED if the sdev is on the passive path 64 */ 65 static int tur_done(struct scsi_device *sdev, unsigned char *sense) 66 { 67 struct scsi_sense_hdr sshdr; 68 int ret; 69 70 ret = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr); 71 if (!ret) { 72 sdev_printk(KERN_WARNING, sdev, 73 "%s: sending tur failed, no sense available\n", 74 HP_SW_NAME); 75 ret = SCSI_DH_IO; 76 goto done; 77 } 78 switch (sshdr.sense_key) { 79 case UNIT_ATTENTION: 80 ret = SCSI_DH_IMM_RETRY; 81 break; 82 case NOT_READY: 83 if ((sshdr.asc == 0x04) && (sshdr.ascq == 2)) { 84 /* 85 * LUN not ready - Initialization command required 86 * 87 * This is the passive path 88 */ 89 ret = SCSI_DH_DEV_OFFLINED; 90 break; 91 } 92 /* Fallthrough */ 93 default: 94 sdev_printk(KERN_WARNING, sdev, 95 "%s: sending tur failed, sense %x/%x/%x\n", 96 HP_SW_NAME, sshdr.sense_key, sshdr.asc, 97 sshdr.ascq); 98 break; 99 } 100 101 done: 102 return ret; 103 } 104 105 /* 106 * hp_sw_tur - Send TEST UNIT READY 107 * @sdev: sdev command should be sent to 108 * 109 * Use the TEST UNIT READY command to determine 110 * the path state. 111 */ 112 static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h) 113 { 114 struct request *req; 115 int ret; 116 117 retry: 118 req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO); 119 if (IS_ERR(req)) 120 return SCSI_DH_RES_TEMP_UNAVAIL; 121 122 blk_rq_set_block_pc(req); 123 req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | 124 REQ_FAILFAST_DRIVER; 125 req->cmd_len = COMMAND_SIZE(TEST_UNIT_READY); 126 req->cmd[0] = TEST_UNIT_READY; 127 req->timeout = HP_SW_TIMEOUT; 128 req->sense = h->sense; 129 memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE); 130 req->sense_len = 0; 131 132 ret = blk_execute_rq(req->q, NULL, req, 1); 133 if (ret == -EIO) { 134 if (req->sense_len > 0) { 135 ret = tur_done(sdev, h->sense); 136 } else { 137 sdev_printk(KERN_WARNING, sdev, 138 "%s: sending tur failed with %x\n", 139 HP_SW_NAME, req->errors); 140 ret = SCSI_DH_IO; 141 } 142 } else { 143 h->path_state = HP_SW_PATH_ACTIVE; 144 ret = SCSI_DH_OK; 145 } 146 if (ret == SCSI_DH_IMM_RETRY) { 147 blk_put_request(req); 148 goto retry; 149 } 150 if (ret == SCSI_DH_DEV_OFFLINED) { 151 h->path_state = HP_SW_PATH_PASSIVE; 152 ret = SCSI_DH_OK; 153 } 154 155 blk_put_request(req); 156 157 return ret; 158 } 159 160 /* 161 * start_done - Handle START STOP UNIT return status 162 * @sdev: sdev the command has been sent to 163 * @errors: blk error code 164 */ 165 static int start_done(struct scsi_device *sdev, unsigned char *sense) 166 { 167 struct scsi_sense_hdr sshdr; 168 int rc; 169 170 rc = scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr); 171 if (!rc) { 172 sdev_printk(KERN_WARNING, sdev, 173 "%s: sending start_stop_unit failed, " 174 "no sense available\n", 175 HP_SW_NAME); 176 return SCSI_DH_IO; 177 } 178 switch (sshdr.sense_key) { 179 case NOT_READY: 180 if ((sshdr.asc == 0x04) && (sshdr.ascq == 3)) { 181 /* 182 * LUN not ready - manual intervention required 183 * 184 * Switch-over in progress, retry. 185 */ 186 rc = SCSI_DH_RETRY; 187 break; 188 } 189 /* fall through */ 190 default: 191 sdev_printk(KERN_WARNING, sdev, 192 "%s: sending start_stop_unit failed, sense %x/%x/%x\n", 193 HP_SW_NAME, sshdr.sense_key, sshdr.asc, 194 sshdr.ascq); 195 rc = SCSI_DH_IO; 196 } 197 198 return rc; 199 } 200 201 static void start_stop_endio(struct request *req, int error) 202 { 203 struct hp_sw_dh_data *h = req->end_io_data; 204 unsigned err = SCSI_DH_OK; 205 206 if (error || host_byte(req->errors) != DID_OK || 207 msg_byte(req->errors) != COMMAND_COMPLETE) { 208 sdev_printk(KERN_WARNING, h->sdev, 209 "%s: sending start_stop_unit failed with %x\n", 210 HP_SW_NAME, req->errors); 211 err = SCSI_DH_IO; 212 goto done; 213 } 214 215 if (req->sense_len > 0) { 216 err = start_done(h->sdev, h->sense); 217 if (err == SCSI_DH_RETRY) { 218 err = SCSI_DH_IO; 219 if (--h->retry_cnt) { 220 blk_put_request(req); 221 err = hp_sw_start_stop(h); 222 if (err == SCSI_DH_OK) 223 return; 224 } 225 } 226 } 227 done: 228 req->end_io_data = NULL; 229 __blk_put_request(req->q, req); 230 if (h->callback_fn) { 231 h->callback_fn(h->callback_data, err); 232 h->callback_fn = h->callback_data = NULL; 233 } 234 return; 235 236 } 237 238 /* 239 * hp_sw_start_stop - Send START STOP UNIT command 240 * @sdev: sdev command should be sent to 241 * 242 * Sending START STOP UNIT activates the SP. 243 */ 244 static int hp_sw_start_stop(struct hp_sw_dh_data *h) 245 { 246 struct request *req; 247 248 req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC); 249 if (IS_ERR(req)) 250 return SCSI_DH_RES_TEMP_UNAVAIL; 251 252 blk_rq_set_block_pc(req); 253 req->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | 254 REQ_FAILFAST_DRIVER; 255 req->cmd_len = COMMAND_SIZE(START_STOP); 256 req->cmd[0] = START_STOP; 257 req->cmd[4] = 1; /* Start spin cycle */ 258 req->timeout = HP_SW_TIMEOUT; 259 req->sense = h->sense; 260 memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE); 261 req->sense_len = 0; 262 req->end_io_data = h; 263 264 blk_execute_rq_nowait(req->q, NULL, req, 1, start_stop_endio); 265 return SCSI_DH_OK; 266 } 267 268 static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req) 269 { 270 struct hp_sw_dh_data *h = get_hp_sw_data(sdev); 271 int ret = BLKPREP_OK; 272 273 if (h->path_state != HP_SW_PATH_ACTIVE) { 274 ret = BLKPREP_KILL; 275 req->cmd_flags |= REQ_QUIET; 276 } 277 return ret; 278 279 } 280 281 /* 282 * hp_sw_activate - Activate a path 283 * @sdev: sdev on the path to be activated 284 * 285 * The HP Active/Passive firmware is pretty simple; 286 * the passive path reports NOT READY with sense codes 287 * 0x04/0x02; a START STOP UNIT command will then 288 * activate the passive path (and deactivate the 289 * previously active one). 290 */ 291 static int hp_sw_activate(struct scsi_device *sdev, 292 activate_complete fn, void *data) 293 { 294 int ret = SCSI_DH_OK; 295 struct hp_sw_dh_data *h = get_hp_sw_data(sdev); 296 297 ret = hp_sw_tur(sdev, h); 298 299 if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE) { 300 h->retry_cnt = h->retries; 301 h->callback_fn = fn; 302 h->callback_data = data; 303 ret = hp_sw_start_stop(h); 304 if (ret == SCSI_DH_OK) 305 return 0; 306 h->callback_fn = h->callback_data = NULL; 307 } 308 309 if (fn) 310 fn(data, ret); 311 return 0; 312 } 313 314 static const struct { 315 char *vendor; 316 char *model; 317 } hp_sw_dh_data_list[] = { 318 {"COMPAQ", "MSA1000 VOLUME"}, 319 {"COMPAQ", "HSV110"}, 320 {"HP", "HSV100"}, 321 {"DEC", "HSG80"}, 322 {NULL, NULL}, 323 }; 324 325 static bool hp_sw_match(struct scsi_device *sdev) 326 { 327 int i; 328 329 if (scsi_device_tpgs(sdev)) 330 return false; 331 332 for (i = 0; hp_sw_dh_data_list[i].vendor; i++) { 333 if (!strncmp(sdev->vendor, hp_sw_dh_data_list[i].vendor, 334 strlen(hp_sw_dh_data_list[i].vendor)) && 335 !strncmp(sdev->model, hp_sw_dh_data_list[i].model, 336 strlen(hp_sw_dh_data_list[i].model))) { 337 return true; 338 } 339 } 340 return false; 341 } 342 343 static struct scsi_dh_data *hp_sw_bus_attach(struct scsi_device *sdev) 344 { 345 struct hp_sw_dh_data *h; 346 int ret; 347 348 h = kzalloc(sizeof(*h), GFP_KERNEL); 349 if (!h) 350 return ERR_PTR(-ENOMEM); 351 h->path_state = HP_SW_PATH_UNINITIALIZED; 352 h->retries = HP_SW_RETRIES; 353 h->sdev = sdev; 354 355 ret = hp_sw_tur(sdev, h); 356 if (ret != SCSI_DH_OK || h->path_state == HP_SW_PATH_UNINITIALIZED) 357 goto failed; 358 359 sdev_printk(KERN_INFO, sdev, "%s: attached to %s path\n", 360 HP_SW_NAME, h->path_state == HP_SW_PATH_ACTIVE? 361 "active":"passive"); 362 return &h->dh_data; 363 failed: 364 kfree(h); 365 return ERR_PTR(-EINVAL); 366 } 367 368 static void hp_sw_bus_detach( struct scsi_device *sdev ) 369 { 370 struct hp_sw_dh_data *h = get_hp_sw_data(sdev); 371 372 kfree(h); 373 } 374 375 static struct scsi_device_handler hp_sw_dh = { 376 .name = HP_SW_NAME, 377 .module = THIS_MODULE, 378 .attach = hp_sw_bus_attach, 379 .detach = hp_sw_bus_detach, 380 .activate = hp_sw_activate, 381 .prep_fn = hp_sw_prep_fn, 382 .match = hp_sw_match, 383 }; 384 385 static int __init hp_sw_init(void) 386 { 387 return scsi_register_device_handler(&hp_sw_dh); 388 } 389 390 static void __exit hp_sw_exit(void) 391 { 392 scsi_unregister_device_handler(&hp_sw_dh); 393 } 394 395 module_init(hp_sw_init); 396 module_exit(hp_sw_exit); 397 398 MODULE_DESCRIPTION("HP Active/Passive driver"); 399 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu"); 400 MODULE_LICENSE("GPL"); 401