1/* 2 * This program is free software; you can redistribute it and/or modify it 3 * under the terms of the GNU General Public License as published by the 4 * Free Software Foundation; either version 2, or (at your option) any 5 * later version. 6 * 7 * This program is distributed in the hope that it will be useful, but 8 * WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 10 * General Public License for more details. 11 * 12 * For the avoidance of doubt the "preferred form" of this code is one which 13 * is in an open non patent encumbered format. Where cryptographic key signing 14 * forms part of the process of creating an executable the information 15 * including keys needed to generate an equivalently functional executable 16 * are deemed to be part of the source code. 17 * 18 * Complications for I2O scsi 19 * 20 * o Each (bus,lun) is a logical device in I2O. We keep a map 21 * table. We spoof failed selection for unmapped units 22 * o Request sense buffers can come back for free. 23 * o Scatter gather is a bit dynamic. We have to investigate at 24 * setup time. 25 * o Some of our resources are dynamically shared. The i2o core 26 * needs a message reservation protocol to avoid swap v net 27 * deadlocking. We need to back off queue requests. 28 * 29 * In general the firmware wants to help. Where its help isn't performance 30 * useful we just ignore the aid. Its not worth the code in truth. 31 * 32 * Fixes/additions: 33 * Steve Ralston: 34 * Scatter gather now works 35 * Markus Lidel <Markus.Lidel@shadowconnect.com>: 36 * Minor fixes for 2.6. 37 * 38 * To Do: 39 * 64bit cleanups 40 * Fix the resource management problems. 41 */ 42 43#include <linux/module.h> 44#include <linux/kernel.h> 45#include <linux/types.h> 46#include <linux/string.h> 47#include <linux/ioport.h> 48#include <linux/jiffies.h> 49#include <linux/interrupt.h> 50#include <linux/timer.h> 51#include <linux/delay.h> 52#include <linux/proc_fs.h> 53#include <linux/prefetch.h> 54#include <linux/pci.h> 55#include <linux/blkdev.h> 56#include <linux/i2o.h> 57#include <linux/scatterlist.h> 58 59#include <asm/dma.h> 60#include <asm/system.h> 61#include <asm/io.h> 62#include <asm/atomic.h> 63 64#include <scsi/scsi.h> 65#include <scsi/scsi_host.h> 66#include <scsi/scsi_device.h> 67#include <scsi/scsi_cmnd.h> 68#include <scsi/sg.h> 69 70#define OSM_NAME "scsi-osm" 71#define OSM_VERSION "1.316" 72#define OSM_DESCRIPTION "I2O SCSI Peripheral OSM" 73 74static struct i2o_driver i2o_scsi_driver; 75 76static unsigned int i2o_scsi_max_id = 16; 77static unsigned int i2o_scsi_max_lun = 255; 78 79struct i2o_scsi_host { 80 struct Scsi_Host *scsi_host; /* pointer to the SCSI host */ 81 struct i2o_controller *iop; /* pointer to the I2O controller */ 82 unsigned int lun; /* lun's used for block devices */ 83 struct i2o_device *channel[0]; /* channel->i2o_dev mapping table */ 84}; 85 86static struct scsi_host_template i2o_scsi_host_template; 87 88#define I2O_SCSI_CAN_QUEUE 4 89 90/* SCSI OSM class handling definition */ 91static struct i2o_class_id i2o_scsi_class_id[] = { 92 {I2O_CLASS_SCSI_PERIPHERAL}, 93 {I2O_CLASS_END} 94}; 95 96static struct i2o_scsi_host *i2o_scsi_host_alloc(struct i2o_controller *c) 97{ 98 struct i2o_scsi_host *i2o_shost; 99 struct i2o_device *i2o_dev; 100 struct Scsi_Host *scsi_host; 101 int max_channel = 0; 102 u8 type; 103 int i; 104 size_t size; 105 u16 body_size = 6; 106 107#ifdef CONFIG_I2O_EXT_ADAPTEC 108 if (c->adaptec) 109 body_size = 8; 110#endif 111 112 list_for_each_entry(i2o_dev, &c->devices, list) 113 if (i2o_dev->lct_data.class_id == I2O_CLASS_BUS_ADAPTER) { 114 if (!i2o_parm_field_get(i2o_dev, 0x0000, 0, &type, 1) 115 && (type == 0x01)) /* SCSI bus */ 116 max_channel++; 117 } 118 119 if (!max_channel) { 120 osm_warn("no channels found on %s\n", c->name); 121 return ERR_PTR(-EFAULT); 122 } 123 124 size = max_channel * sizeof(struct i2o_device *) 125 + sizeof(struct i2o_scsi_host); 126 127 scsi_host = scsi_host_alloc(&i2o_scsi_host_template, size); 128 if (!scsi_host) { 129 osm_warn("Could not allocate SCSI host\n"); 130 return ERR_PTR(-ENOMEM); 131 } 132 133 scsi_host->max_channel = max_channel - 1; 134 scsi_host->max_id = i2o_scsi_max_id; 135 scsi_host->max_lun = i2o_scsi_max_lun; 136 scsi_host->this_id = c->unit; 137 scsi_host->sg_tablesize = i2o_sg_tablesize(c, body_size); 138 139 i2o_shost = (struct i2o_scsi_host *)scsi_host->hostdata; 140 i2o_shost->scsi_host = scsi_host; 141 i2o_shost->iop = c; 142 i2o_shost->lun = 1; 143 144 i = 0; 145 list_for_each_entry(i2o_dev, &c->devices, list) 146 if (i2o_dev->lct_data.class_id == I2O_CLASS_BUS_ADAPTER) { 147 if (!i2o_parm_field_get(i2o_dev, 0x0000, 0, &type, 1) 148 && (type == 0x01)) /* only SCSI bus */ 149 i2o_shost->channel[i++] = i2o_dev; 150 151 if (i >= max_channel) 152 break; 153 } 154 155 return i2o_shost; 156}; 157 158/** 159 * i2o_scsi_get_host - Get an I2O SCSI host 160 * @c: I2O controller to for which to get the SCSI host 161 * 162 * If the I2O controller already exists as SCSI host, the SCSI host 163 * is returned, otherwise the I2O controller is added to the SCSI 164 * core. 165 * 166 * Returns pointer to the I2O SCSI host on success or NULL on failure. 167 */ 168static struct i2o_scsi_host *i2o_scsi_get_host(struct i2o_controller *c) 169{ 170 return c->driver_data[i2o_scsi_driver.context]; 171}; 172 173/** 174 * i2o_scsi_remove - Remove I2O device from SCSI core 175 * @dev: device which should be removed 176 * 177 * Removes the I2O device from the SCSI core again. 178 * 179 * Returns 0 on success. 180 */ 181static int i2o_scsi_remove(struct device *dev) 182{ 183 struct i2o_device *i2o_dev = to_i2o_device(dev); 184 struct i2o_controller *c = i2o_dev->iop; 185 struct i2o_scsi_host *i2o_shost; 186 struct scsi_device *scsi_dev; 187 188 osm_info("device removed (TID: %03x)\n", i2o_dev->lct_data.tid); 189 190 i2o_shost = i2o_scsi_get_host(c); 191 192 shost_for_each_device(scsi_dev, i2o_shost->scsi_host) 193 if (scsi_dev->hostdata == i2o_dev) { 194 sysfs_remove_link(&i2o_dev->device.kobj, "scsi"); 195 scsi_remove_device(scsi_dev); 196 scsi_device_put(scsi_dev); 197 break; 198 } 199 200 return 0; 201}; 202 203/** 204 * i2o_scsi_probe - verify if dev is a I2O SCSI device and install it 205 * @dev: device to verify if it is a I2O SCSI device 206 * 207 * Retrieve channel, id and lun for I2O device. If everthing goes well 208 * register the I2O device as SCSI device on the I2O SCSI controller. 209 * 210 * Returns 0 on success or negative error code on failure. 211 */ 212static int i2o_scsi_probe(struct device *dev) 213{ 214 struct i2o_device *i2o_dev = to_i2o_device(dev); 215 struct i2o_controller *c = i2o_dev->iop; 216 struct i2o_scsi_host *i2o_shost; 217 struct Scsi_Host *scsi_host; 218 struct i2o_device *parent; 219 struct scsi_device *scsi_dev; 220 u32 id = -1; 221 u64 lun = -1; 222 int channel = -1; 223 int i, rc; 224 225 i2o_shost = i2o_scsi_get_host(c); 226 if (!i2o_shost) 227 return -EFAULT; 228 229 scsi_host = i2o_shost->scsi_host; 230 231 switch (i2o_dev->lct_data.class_id) { 232 case I2O_CLASS_RANDOM_BLOCK_STORAGE: 233 case I2O_CLASS_EXECUTIVE: 234#ifdef CONFIG_I2O_EXT_ADAPTEC 235 if (c->adaptec) { 236 u8 type; 237 struct i2o_device *d = i2o_shost->channel[0]; 238 239 if (!i2o_parm_field_get(d, 0x0000, 0, &type, 1) 240 && (type == 0x01)) /* SCSI bus */ 241 if (!i2o_parm_field_get(d, 0x0200, 4, &id, 4)) { 242 channel = 0; 243 if (i2o_dev->lct_data.class_id == 244 I2O_CLASS_RANDOM_BLOCK_STORAGE) 245 lun = 246 cpu_to_le64(i2o_shost-> 247 lun++); 248 else 249 lun = 0; 250 } 251 } 252#endif 253 break; 254 255 case I2O_CLASS_SCSI_PERIPHERAL: 256 if (i2o_parm_field_get(i2o_dev, 0x0000, 3, &id, 4)) 257 return -EFAULT; 258 259 if (i2o_parm_field_get(i2o_dev, 0x0000, 4, &lun, 8)) 260 return -EFAULT; 261 262 parent = i2o_iop_find_device(c, i2o_dev->lct_data.parent_tid); 263 if (!parent) { 264 osm_warn("can not find parent of device %03x\n", 265 i2o_dev->lct_data.tid); 266 return -EFAULT; 267 } 268 269 for (i = 0; i <= i2o_shost->scsi_host->max_channel; i++) 270 if (i2o_shost->channel[i] == parent) 271 channel = i; 272 break; 273 274 default: 275 return -EFAULT; 276 } 277 278 if (channel == -1) { 279 osm_warn("can not find channel of device %03x\n", 280 i2o_dev->lct_data.tid); 281 return -EFAULT; 282 } 283 284 if (le32_to_cpu(id) >= scsi_host->max_id) { 285 osm_warn("SCSI device id (%d) >= max_id of I2O host (%d)", 286 le32_to_cpu(id), scsi_host->max_id); 287 return -EFAULT; 288 } 289 290 if (le64_to_cpu(lun) >= scsi_host->max_lun) { 291 osm_warn("SCSI device lun (%lu) >= max_lun of I2O host (%d)", 292 (long unsigned int)le64_to_cpu(lun), 293 scsi_host->max_lun); 294 return -EFAULT; 295 } 296 297 scsi_dev = 298 __scsi_add_device(i2o_shost->scsi_host, channel, le32_to_cpu(id), 299 le64_to_cpu(lun), i2o_dev); 300 301 if (IS_ERR(scsi_dev)) { 302 osm_warn("can not add SCSI device %03x\n", 303 i2o_dev->lct_data.tid); 304 return PTR_ERR(scsi_dev); 305 } 306 307 rc = sysfs_create_link(&i2o_dev->device.kobj, 308 &scsi_dev->sdev_gendev.kobj, "scsi"); 309 if (rc) 310 goto err; 311 312 osm_info("device added (TID: %03x) channel: %d, id: %d, lun: %ld\n", 313 i2o_dev->lct_data.tid, channel, le32_to_cpu(id), 314 (long unsigned int)le64_to_cpu(lun)); 315 316 return 0; 317 318err: 319 scsi_remove_device(scsi_dev); 320 return rc; 321}; 322 323static const char *i2o_scsi_info(struct Scsi_Host *SChost) 324{ 325 struct i2o_scsi_host *hostdata; 326 hostdata = (struct i2o_scsi_host *)SChost->hostdata; 327 return hostdata->iop->name; 328} 329 330/** 331 * i2o_scsi_reply - SCSI OSM message reply handler 332 * @c: controller issuing the reply 333 * @m: message id for flushing 334 * @msg: the message from the controller 335 * 336 * Process reply messages (interrupts in normal scsi controller think). 337 * We can get a variety of messages to process. The normal path is 338 * scsi command completions. We must also deal with IOP failures, 339 * the reply to a bus reset and the reply to a LUN query. 340 * 341 * Returns 0 on success and if the reply should not be flushed or > 0 342 * on success and if the reply should be flushed. Returns negative error 343 * code on failure and if the reply should be flushed. 344 */ 345static int i2o_scsi_reply(struct i2o_controller *c, u32 m, 346 struct i2o_message *msg) 347{ 348 struct scsi_cmnd *cmd; 349 u32 error; 350 struct device *dev; 351 352 cmd = i2o_cntxt_list_get(c, le32_to_cpu(msg->u.s.tcntxt)); 353 if (unlikely(!cmd)) { 354 osm_err("NULL reply received!\n"); 355 return -1; 356 } 357 358 /* 359 * Low byte is device status, next is adapter status, 360 * (then one byte reserved), then request status. 361 */ 362 error = le32_to_cpu(msg->body[0]); 363 364 osm_debug("Completed %ld\n", cmd->serial_number); 365 366 cmd->result = error & 0xff; 367 /* 368 * if DeviceStatus is not SCSI_SUCCESS copy over the sense data and let 369 * the SCSI layer handle the error 370 */ 371 if (cmd->result) 372 memcpy(cmd->sense_buffer, &msg->body[3], 373 min(SCSI_SENSE_BUFFERSIZE, 40)); 374 375 /* only output error code if AdapterStatus is not HBA_SUCCESS */ 376 if ((error >> 8) & 0xff) 377 osm_err("SCSI error %08x\n", error); 378 379 dev = &c->pdev->dev; 380 381 scsi_dma_unmap(cmd); 382 383 cmd->scsi_done(cmd); 384 385 return 1; 386}; 387 388/** 389 * i2o_scsi_notify_device_add - Retrieve notifications of added devices 390 * @i2o_dev: the I2O device which was added 391 * 392 * If a I2O device is added we catch the notification, because I2O classes 393 * other than SCSI peripheral will not be received through 394 * i2o_scsi_probe(). 395 */ 396static void i2o_scsi_notify_device_add(struct i2o_device *i2o_dev) 397{ 398 switch (i2o_dev->lct_data.class_id) { 399 case I2O_CLASS_EXECUTIVE: 400 case I2O_CLASS_RANDOM_BLOCK_STORAGE: 401 i2o_scsi_probe(&i2o_dev->device); 402 break; 403 404 default: 405 break; 406 } 407}; 408 409/** 410 * i2o_scsi_notify_device_remove - Retrieve notifications of removed devices 411 * @i2o_dev: the I2O device which was removed 412 * 413 * If a I2O device is removed, we catch the notification to remove the 414 * corresponding SCSI device. 415 */ 416static void i2o_scsi_notify_device_remove(struct i2o_device *i2o_dev) 417{ 418 switch (i2o_dev->lct_data.class_id) { 419 case I2O_CLASS_EXECUTIVE: 420 case I2O_CLASS_RANDOM_BLOCK_STORAGE: 421 i2o_scsi_remove(&i2o_dev->device); 422 break; 423 424 default: 425 break; 426 } 427}; 428 429/** 430 * i2o_scsi_notify_controller_add - Retrieve notifications of added controllers 431 * @c: the controller which was added 432 * 433 * If a I2O controller is added, we catch the notification to add a 434 * corresponding Scsi_Host. 435 */ 436static void i2o_scsi_notify_controller_add(struct i2o_controller *c) 437{ 438 struct i2o_scsi_host *i2o_shost; 439 int rc; 440 441 i2o_shost = i2o_scsi_host_alloc(c); 442 if (IS_ERR(i2o_shost)) { 443 osm_err("Could not initialize SCSI host\n"); 444 return; 445 } 446 447 rc = scsi_add_host(i2o_shost->scsi_host, &c->device); 448 if (rc) { 449 osm_err("Could not add SCSI host\n"); 450 scsi_host_put(i2o_shost->scsi_host); 451 return; 452 } 453 454 c->driver_data[i2o_scsi_driver.context] = i2o_shost; 455 456 osm_debug("new I2O SCSI host added\n"); 457}; 458 459/** 460 * i2o_scsi_notify_controller_remove - Retrieve notifications of removed controllers 461 * @c: the controller which was removed 462 * 463 * If a I2O controller is removed, we catch the notification to remove the 464 * corresponding Scsi_Host. 465 */ 466static void i2o_scsi_notify_controller_remove(struct i2o_controller *c) 467{ 468 struct i2o_scsi_host *i2o_shost; 469 i2o_shost = i2o_scsi_get_host(c); 470 if (!i2o_shost) 471 return; 472 473 c->driver_data[i2o_scsi_driver.context] = NULL; 474 475 scsi_remove_host(i2o_shost->scsi_host); 476 scsi_host_put(i2o_shost->scsi_host); 477 osm_debug("I2O SCSI host removed\n"); 478}; 479 480/* SCSI OSM driver struct */ 481static struct i2o_driver i2o_scsi_driver = { 482 .name = OSM_NAME, 483 .reply = i2o_scsi_reply, 484 .classes = i2o_scsi_class_id, 485 .notify_device_add = i2o_scsi_notify_device_add, 486 .notify_device_remove = i2o_scsi_notify_device_remove, 487 .notify_controller_add = i2o_scsi_notify_controller_add, 488 .notify_controller_remove = i2o_scsi_notify_controller_remove, 489 .driver = { 490 .probe = i2o_scsi_probe, 491 .remove = i2o_scsi_remove, 492 }, 493}; 494 495/** 496 * i2o_scsi_queuecommand - queue a SCSI command 497 * @SCpnt: scsi command pointer 498 * @done: callback for completion 499 * 500 * Issue a scsi command asynchronously. Return 0 on success or 1 if 501 * we hit an error (normally message queue congestion). The only 502 * minor complication here is that I2O deals with the device addressing 503 * so we have to map the bus/dev/lun back to an I2O handle as well 504 * as faking absent devices ourself. 505 * 506 * Locks: takes the controller lock on error path only 507 */ 508 509static int i2o_scsi_queuecommand(struct scsi_cmnd *SCpnt, 510 void (*done) (struct scsi_cmnd *)) 511{ 512 struct i2o_controller *c; 513 struct i2o_device *i2o_dev; 514 int tid; 515 struct i2o_message *msg; 516 /* 517 * ENABLE_DISCONNECT 518 * SIMPLE_TAG 519 * RETURN_SENSE_DATA_IN_REPLY_MESSAGE_FRAME 520 */ 521 u32 scsi_flags = 0x20a00000; 522 u32 sgl_offset; 523 u32 *mptr; 524 u32 cmd = I2O_CMD_SCSI_EXEC << 24; 525 int rc = 0; 526 527 /* 528 * Do the incoming paperwork 529 */ 530 i2o_dev = SCpnt->device->hostdata; 531 532 SCpnt->scsi_done = done; 533 534 if (unlikely(!i2o_dev)) { 535 osm_warn("no I2O device in request\n"); 536 SCpnt->result = DID_NO_CONNECT << 16; 537 done(SCpnt); 538 goto exit; 539 } 540 c = i2o_dev->iop; 541 tid = i2o_dev->lct_data.tid; 542 543 osm_debug("qcmd: Tid = %03x\n", tid); 544 osm_debug("Real scsi messages.\n"); 545 546 /* 547 * Put together a scsi execscb message 548 */ 549 switch (SCpnt->sc_data_direction) { 550 case PCI_DMA_NONE: 551 /* DATA NO XFER */ 552 sgl_offset = SGL_OFFSET_0; 553 break; 554 555 case PCI_DMA_TODEVICE: 556 /* DATA OUT (iop-->dev) */ 557 scsi_flags |= 0x80000000; 558 sgl_offset = SGL_OFFSET_10; 559 break; 560 561 case PCI_DMA_FROMDEVICE: 562 /* DATA IN (iop<--dev) */ 563 scsi_flags |= 0x40000000; 564 sgl_offset = SGL_OFFSET_10; 565 break; 566 567 default: 568 /* Unknown - kill the command */ 569 SCpnt->result = DID_NO_CONNECT << 16; 570 done(SCpnt); 571 goto exit; 572 } 573 574 /* 575 * Obtain an I2O message. If there are none free then 576 * throw it back to the scsi layer 577 */ 578 579 msg = i2o_msg_get(c); 580 if (IS_ERR(msg)) { 581 rc = SCSI_MLQUEUE_HOST_BUSY; 582 goto exit; 583 } 584 585 mptr = &msg->body[0]; 586 587 588 msg->u.head[1] = cpu_to_le32(cmd | HOST_TID << 12 | tid); 589 msg->u.s.icntxt = cpu_to_le32(i2o_scsi_driver.context); 590 591 /* We want the SCSI control block back */ 592 msg->u.s.tcntxt = cpu_to_le32(i2o_cntxt_list_add(c, SCpnt)); 593 594 /* LSI_920_PCI_QUIRK 595 * 596 * Intermittant observations of msg frame word data corruption 597 * observed on msg[4] after: 598 * WRITE, READ-MODIFY-WRITE 599 * operations. 19990606 -sralston 600 * 601 * (Hence we build this word via tag. Its good practice anyway 602 * we don't want fetches over PCI needlessly) 603 */ 604 605 /* Attach tags to the devices */ 606 607 *mptr++ = cpu_to_le32(scsi_flags | SCpnt->cmd_len); 608 609 /* Write SCSI command into the message - always 16 byte block */ 610 memcpy(mptr, SCpnt->cmnd, 16); 611 mptr += 4; 612 613 if (sgl_offset != SGL_OFFSET_0) { 614 /* write size of data addressed by SGL */ 615 *mptr++ = cpu_to_le32(scsi_bufflen(SCpnt)); 616 617 /* Now fill in the SGList and command */ 618 619 if (scsi_sg_count(SCpnt)) { 620 if (!i2o_dma_map_sg(c, scsi_sglist(SCpnt), 621 scsi_sg_count(SCpnt), 622 SCpnt->sc_data_direction, &mptr)) 623 goto nomem; 624 } 625 } 626 627 /* Stick the headers on */ 628 msg->u.head[0] = 629 cpu_to_le32(I2O_MESSAGE_SIZE(mptr - &msg->u.head[0]) | sgl_offset); 630 631 /* Queue the message */ 632 i2o_msg_post(c, msg); 633 634 osm_debug("Issued %ld\n", SCpnt->serial_number); 635 636 return 0; 637 638 nomem: 639 rc = -ENOMEM; 640 i2o_msg_nop(c, msg); 641 642 exit: 643 return rc; 644}; 645 646/** 647 * i2o_scsi_abort - abort a running command 648 * @SCpnt: command to abort 649 * 650 * Ask the I2O controller to abort a command. This is an asynchrnous 651 * process and our callback handler will see the command complete with an 652 * aborted message if it succeeds. 653 * 654 * Returns 0 if the command is successfully aborted or negative error code 655 * on failure. 656 */ 657static int i2o_scsi_abort(struct scsi_cmnd *SCpnt) 658{ 659 struct i2o_device *i2o_dev; 660 struct i2o_controller *c; 661 struct i2o_message *msg; 662 int tid; 663 int status = FAILED; 664 665 osm_warn("Aborting command block.\n"); 666 667 i2o_dev = SCpnt->device->hostdata; 668 c = i2o_dev->iop; 669 tid = i2o_dev->lct_data.tid; 670 671 msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET); 672 if (IS_ERR(msg)) 673 return SCSI_MLQUEUE_HOST_BUSY; 674 675 msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0); 676 msg->u.head[1] = 677 cpu_to_le32(I2O_CMD_SCSI_ABORT << 24 | HOST_TID << 12 | tid); 678 msg->body[0] = cpu_to_le32(i2o_cntxt_list_get_ptr(c, SCpnt)); 679 680 if (!i2o_msg_post_wait(c, msg, I2O_TIMEOUT_SCSI_SCB_ABORT)) 681 status = SUCCESS; 682 683 return status; 684} 685 686/** 687 * i2o_scsi_bios_param - Invent disk geometry 688 * @sdev: scsi device 689 * @dev: block layer device 690 * @capacity: size in sectors 691 * @ip: geometry array 692 * 693 * This is anyone's guess quite frankly. We use the same rules everyone 694 * else appears to and hope. It seems to work. 695 */ 696 697static int i2o_scsi_bios_param(struct scsi_device *sdev, 698 struct block_device *dev, sector_t capacity, 699 int *ip) 700{ 701 int size; 702 703 size = capacity; 704 ip[0] = 64; /* heads */ 705 ip[1] = 32; /* sectors */ 706 if ((ip[2] = size >> 11) > 1024) { /* cylinders, test for big disk */ 707 ip[0] = 255; /* heads */ 708 ip[1] = 63; /* sectors */ 709 ip[2] = size / (255 * 63); /* cylinders */ 710 } 711 return 0; 712} 713 714static struct scsi_host_template i2o_scsi_host_template = { 715 .proc_name = OSM_NAME, 716 .name = OSM_DESCRIPTION, 717 .info = i2o_scsi_info, 718 .queuecommand = i2o_scsi_queuecommand, 719 .eh_abort_handler = i2o_scsi_abort, 720 .bios_param = i2o_scsi_bios_param, 721 .can_queue = I2O_SCSI_CAN_QUEUE, 722 .sg_tablesize = 8, 723 .cmd_per_lun = 6, 724 .use_clustering = ENABLE_CLUSTERING, 725}; 726 727/** 728 * i2o_scsi_init - SCSI OSM initialization function 729 * 730 * Register SCSI OSM into I2O core. 731 * 732 * Returns 0 on success or negative error code on failure. 733 */ 734static int __init i2o_scsi_init(void) 735{ 736 int rc; 737 738 printk(KERN_INFO OSM_DESCRIPTION " v" OSM_VERSION "\n"); 739 740 /* Register SCSI OSM into I2O core */ 741 rc = i2o_driver_register(&i2o_scsi_driver); 742 if (rc) { 743 osm_err("Could not register SCSI driver\n"); 744 return rc; 745 } 746 747 return 0; 748}; 749 750/** 751 * i2o_scsi_exit - SCSI OSM exit function 752 * 753 * Unregisters SCSI OSM from I2O core. 754 */ 755static void __exit i2o_scsi_exit(void) 756{ 757 /* Unregister I2O SCSI OSM from I2O core */ 758 i2o_driver_unregister(&i2o_scsi_driver); 759}; 760 761MODULE_AUTHOR("Red Hat Software"); 762MODULE_LICENSE("GPL"); 763MODULE_DESCRIPTION(OSM_DESCRIPTION); 764MODULE_VERSION(OSM_VERSION); 765 766module_init(i2o_scsi_init); 767module_exit(i2o_scsi_exit); 768