1/* 2 * Block OSM 3 * 4 * Copyright (C) 1999-2002 Red Hat Software 5 * 6 * Written by Alan Cox, Building Number Three Ltd 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the 10 * Free Software Foundation; either version 2 of the License, or (at your 11 * option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * For the purpose of avoiding doubt the preferred form of the work 19 * for making modifications shall be a standards compliant form such 20 * gzipped tar and not one requiring a proprietary or patent encumbered 21 * tool to unpack. 22 * 23 * Fixes/additions: 24 * Steve Ralston: 25 * Multiple device handling error fixes, 26 * Added a queue depth. 27 * Alan Cox: 28 * FC920 has an rmw bug. Dont or in the end marker. 29 * Removed queue walk, fixed for 64bitness. 30 * Rewrote much of the code over time 31 * Added indirect block lists 32 * Handle 64K limits on many controllers 33 * Don't use indirects on the Promise (breaks) 34 * Heavily chop down the queue depths 35 * Deepak Saxena: 36 * Independent queues per IOP 37 * Support for dynamic device creation/deletion 38 * Code cleanup 39 * Support for larger I/Os through merge* functions 40 * (taken from DAC960 driver) 41 * Boji T Kannanthanam: 42 * Set the I2O Block devices to be detected in increasing 43 * order of TIDs during boot. 44 * Search and set the I2O block device that we boot off 45 * from as the first device to be claimed (as /dev/i2o/hda) 46 * Properly attach/detach I2O gendisk structure from the 47 * system gendisk list. The I2O block devices now appear in 48 * /proc/partitions. 49 * Markus Lidel <Markus.Lidel@shadowconnect.com>: 50 * Minor bugfixes for 2.6. 51 */ 52 53#include <linux/module.h> 54#include <linux/i2o.h> 55 56#include <linux/mempool.h> 57 58#include <linux/genhd.h> 59#include <linux/blkdev.h> 60#include <linux/hdreg.h> 61 62#include <scsi/scsi.h> 63 64#include "i2o_block.h" 65 66#define OSM_NAME "block-osm" 67#define OSM_VERSION "1.325" 68#define OSM_DESCRIPTION "I2O Block Device OSM" 69 70static struct i2o_driver i2o_block_driver; 71 72/* global Block OSM request mempool */ 73static struct i2o_block_mempool i2o_blk_req_pool; 74 75/* Block OSM class handling definition */ 76static struct i2o_class_id i2o_block_class_id[] = { 77 {I2O_CLASS_RANDOM_BLOCK_STORAGE}, 78 {I2O_CLASS_END} 79}; 80 81/** 82 * i2o_block_device_free - free the memory of the I2O Block device 83 * @dev: I2O Block device, which should be cleaned up 84 * 85 * Frees the request queue, gendisk and the i2o_block_device structure. 86 */ 87static void i2o_block_device_free(struct i2o_block_device *dev) 88{ 89 blk_cleanup_queue(dev->gd->queue); 90 91 put_disk(dev->gd); 92 93 kfree(dev); 94}; 95 96/** 97 * i2o_block_remove - remove the I2O Block device from the system again 98 * @dev: I2O Block device which should be removed 99 * 100 * Remove gendisk from system and free all allocated memory. 101 * 102 * Always returns 0. 103 */ 104static int i2o_block_remove(struct device *dev) 105{ 106 struct i2o_device *i2o_dev = to_i2o_device(dev); 107 struct i2o_block_device *i2o_blk_dev = dev_get_drvdata(dev); 108 109 osm_info("device removed (TID: %03x): %s\n", i2o_dev->lct_data.tid, 110 i2o_blk_dev->gd->disk_name); 111 112 i2o_event_register(i2o_dev, &i2o_block_driver, 0, 0); 113 114 del_gendisk(i2o_blk_dev->gd); 115 116 dev_set_drvdata(dev, NULL); 117 118 i2o_device_claim_release(i2o_dev); 119 120 i2o_block_device_free(i2o_blk_dev); 121 122 return 0; 123}; 124 125/** 126 * i2o_block_device flush - Flush all dirty data of I2O device dev 127 * @dev: I2O device which should be flushed 128 * 129 * Flushes all dirty data on device dev. 130 * 131 * Returns 0 on success or negative error code on failure. 132 */ 133static int i2o_block_device_flush(struct i2o_device *dev) 134{ 135 struct i2o_message *msg; 136 137 msg = i2o_msg_get_wait(dev->iop, I2O_TIMEOUT_MESSAGE_GET); 138 if (IS_ERR(msg)) 139 return PTR_ERR(msg); 140 141 msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0); 142 msg->u.head[1] = 143 cpu_to_le32(I2O_CMD_BLOCK_CFLUSH << 24 | HOST_TID << 12 | dev-> 144 lct_data.tid); 145 msg->body[0] = cpu_to_le32(60 << 16); 146 osm_debug("Flushing...\n"); 147 148 return i2o_msg_post_wait(dev->iop, msg, 60); 149}; 150 151/** 152 * i2o_block_issue_flush - device-flush interface for block-layer 153 * @queue: the request queue of the device which should be flushed 154 * @disk: gendisk 155 * @error_sector: error offset 156 * 157 * Helper function to provide flush functionality to block-layer. 158 * 159 * Returns 0 on success or negative error code on failure. 160 */ 161 162static int i2o_block_issue_flush(request_queue_t * queue, struct gendisk *disk, 163 sector_t * error_sector) 164{ 165 struct i2o_block_device *i2o_blk_dev = queue->queuedata; 166 int rc = -ENODEV; 167 168 if (likely(i2o_blk_dev)) 169 rc = i2o_block_device_flush(i2o_blk_dev->i2o_dev); 170 171 return rc; 172} 173 174/** 175 * i2o_block_device_mount - Mount (load) the media of device dev 176 * @dev: I2O device which should receive the mount request 177 * @media_id: Media Identifier 178 * 179 * Load a media into drive. Identifier should be set to -1, because the 180 * spec does not support any other value. 181 * 182 * Returns 0 on success or negative error code on failure. 183 */ 184static int i2o_block_device_mount(struct i2o_device *dev, u32 media_id) 185{ 186 struct i2o_message *msg; 187 188 msg = i2o_msg_get_wait(dev->iop, I2O_TIMEOUT_MESSAGE_GET); 189 if (IS_ERR(msg)) 190 return PTR_ERR(msg); 191 192 msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0); 193 msg->u.head[1] = 194 cpu_to_le32(I2O_CMD_BLOCK_MMOUNT << 24 | HOST_TID << 12 | dev-> 195 lct_data.tid); 196 msg->body[0] = cpu_to_le32(-1); 197 msg->body[1] = cpu_to_le32(0x00000000); 198 osm_debug("Mounting...\n"); 199 200 return i2o_msg_post_wait(dev->iop, msg, 2); 201}; 202 203/** 204 * i2o_block_device_lock - Locks the media of device dev 205 * @dev: I2O device which should receive the lock request 206 * @media_id: Media Identifier 207 * 208 * Lock media of device dev to prevent removal. The media identifier 209 * should be set to -1, because the spec does not support any other value. 210 * 211 * Returns 0 on success or negative error code on failure. 212 */ 213static int i2o_block_device_lock(struct i2o_device *dev, u32 media_id) 214{ 215 struct i2o_message *msg; 216 217 msg = i2o_msg_get_wait(dev->iop, I2O_TIMEOUT_MESSAGE_GET); 218 if (IS_ERR(msg) == I2O_QUEUE_EMPTY) 219 return PTR_ERR(msg); 220 221 msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0); 222 msg->u.head[1] = 223 cpu_to_le32(I2O_CMD_BLOCK_MLOCK << 24 | HOST_TID << 12 | dev-> 224 lct_data.tid); 225 msg->body[0] = cpu_to_le32(-1); 226 osm_debug("Locking...\n"); 227 228 return i2o_msg_post_wait(dev->iop, msg, 2); 229}; 230 231/** 232 * i2o_block_device_unlock - Unlocks the media of device dev 233 * @dev: I2O device which should receive the unlocked request 234 * @media_id: Media Identifier 235 * 236 * Unlocks the media in device dev. The media identifier should be set to 237 * -1, because the spec does not support any other value. 238 * 239 * Returns 0 on success or negative error code on failure. 240 */ 241static int i2o_block_device_unlock(struct i2o_device *dev, u32 media_id) 242{ 243 struct i2o_message *msg; 244 245 msg = i2o_msg_get_wait(dev->iop, I2O_TIMEOUT_MESSAGE_GET); 246 if (IS_ERR(msg)) 247 return PTR_ERR(msg); 248 249 msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0); 250 msg->u.head[1] = 251 cpu_to_le32(I2O_CMD_BLOCK_MUNLOCK << 24 | HOST_TID << 12 | dev-> 252 lct_data.tid); 253 msg->body[0] = cpu_to_le32(media_id); 254 osm_debug("Unlocking...\n"); 255 256 return i2o_msg_post_wait(dev->iop, msg, 2); 257}; 258 259/** 260 * i2o_block_device_power - Power management for device dev 261 * @dev: I2O device which should receive the power management request 262 * @op: Operation to send 263 * 264 * Send a power management request to the device dev. 265 * 266 * Returns 0 on success or negative error code on failure. 267 */ 268static int i2o_block_device_power(struct i2o_block_device *dev, u8 op) 269{ 270 struct i2o_device *i2o_dev = dev->i2o_dev; 271 struct i2o_controller *c = i2o_dev->iop; 272 struct i2o_message *msg; 273 int rc; 274 275 msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET); 276 if (IS_ERR(msg)) 277 return PTR_ERR(msg); 278 279 msg->u.head[0] = cpu_to_le32(FOUR_WORD_MSG_SIZE | SGL_OFFSET_0); 280 msg->u.head[1] = 281 cpu_to_le32(I2O_CMD_BLOCK_POWER << 24 | HOST_TID << 12 | i2o_dev-> 282 lct_data.tid); 283 msg->body[0] = cpu_to_le32(op << 24); 284 osm_debug("Power...\n"); 285 286 rc = i2o_msg_post_wait(c, msg, 60); 287 if (!rc) 288 dev->power = op; 289 290 return rc; 291}; 292 293/** 294 * i2o_block_request_alloc - Allocate an I2O block request struct 295 * 296 * Allocates an I2O block request struct and initialize the list. 297 * 298 * Returns a i2o_block_request pointer on success or negative error code 299 * on failure. 300 */ 301static inline struct i2o_block_request *i2o_block_request_alloc(void) 302{ 303 struct i2o_block_request *ireq; 304 305 ireq = mempool_alloc(i2o_blk_req_pool.pool, GFP_ATOMIC); 306 if (!ireq) 307 return ERR_PTR(-ENOMEM); 308 309 INIT_LIST_HEAD(&ireq->queue); 310 311 return ireq; 312}; 313 314/** 315 * i2o_block_request_free - Frees a I2O block request 316 * @ireq: I2O block request which should be freed 317 * 318 * Frees the allocated memory (give it back to the request mempool). 319 */ 320static inline void i2o_block_request_free(struct i2o_block_request *ireq) 321{ 322 mempool_free(ireq, i2o_blk_req_pool.pool); 323}; 324 325/** 326 * i2o_block_sglist_alloc - Allocate the SG list and map it 327 * @c: I2O controller to which the request belongs 328 * @ireq: I2O block request 329 * @mptr: message body pointer 330 * 331 * Builds the SG list and map it to be accessable by the controller. 332 * 333 * Returns 0 on failure or 1 on success. 334 */ 335static inline int i2o_block_sglist_alloc(struct i2o_controller *c, 336 struct i2o_block_request *ireq, 337 u32 ** mptr) 338{ 339 int nents; 340 enum dma_data_direction direction; 341 342 ireq->dev = &c->pdev->dev; 343 nents = blk_rq_map_sg(ireq->req->q, ireq->req, ireq->sg_table); 344 345 if (rq_data_dir(ireq->req) == READ) 346 direction = PCI_DMA_FROMDEVICE; 347 else 348 direction = PCI_DMA_TODEVICE; 349 350 ireq->sg_nents = nents; 351 352 return i2o_dma_map_sg(c, ireq->sg_table, nents, direction, mptr); 353}; 354 355/** 356 * i2o_block_sglist_free - Frees the SG list 357 * @ireq: I2O block request from which the SG should be freed 358 * 359 * Frees the SG list from the I2O block request. 360 */ 361static inline void i2o_block_sglist_free(struct i2o_block_request *ireq) 362{ 363 enum dma_data_direction direction; 364 365 if (rq_data_dir(ireq->req) == READ) 366 direction = PCI_DMA_FROMDEVICE; 367 else 368 direction = PCI_DMA_TODEVICE; 369 370 dma_unmap_sg(ireq->dev, ireq->sg_table, ireq->sg_nents, direction); 371}; 372 373/** 374 * i2o_block_prep_req_fn - Allocates I2O block device specific struct 375 * @q: request queue for the request 376 * @req: the request to prepare 377 * 378 * Allocate the necessary i2o_block_request struct and connect it to 379 * the request. This is needed that we not loose the SG list later on. 380 * 381 * Returns BLKPREP_OK on success or BLKPREP_DEFER on failure. 382 */ 383static int i2o_block_prep_req_fn(struct request_queue *q, struct request *req) 384{ 385 struct i2o_block_device *i2o_blk_dev = q->queuedata; 386 struct i2o_block_request *ireq; 387 388 if (unlikely(!i2o_blk_dev)) { 389 osm_err("block device already removed\n"); 390 return BLKPREP_KILL; 391 } 392 393 /* connect the i2o_block_request to the request */ 394 if (!req->special) { 395 ireq = i2o_block_request_alloc(); 396 if (unlikely(IS_ERR(ireq))) { 397 osm_debug("unable to allocate i2o_block_request!\n"); 398 return BLKPREP_DEFER; 399 } 400 401 ireq->i2o_blk_dev = i2o_blk_dev; 402 req->special = ireq; 403 ireq->req = req; 404 } 405 /* do not come back here */ 406 req->cmd_flags |= REQ_DONTPREP; 407 408 return BLKPREP_OK; 409}; 410 411/** 412 * i2o_block_delayed_request_fn - delayed request queue function 413 * @work: the delayed request with the queue to start 414 * 415 * If the request queue is stopped for a disk, and there is no open 416 * request, a new event is created, which calls this function to start 417 * the queue after I2O_BLOCK_REQUEST_TIME. Otherwise the queue will never 418 * be started again. 419 */ 420static void i2o_block_delayed_request_fn(struct work_struct *work) 421{ 422 struct i2o_block_delayed_request *dreq = 423 container_of(work, struct i2o_block_delayed_request, 424 work.work); 425 struct request_queue *q = dreq->queue; 426 unsigned long flags; 427 428 spin_lock_irqsave(q->queue_lock, flags); 429 blk_start_queue(q); 430 spin_unlock_irqrestore(q->queue_lock, flags); 431 kfree(dreq); 432}; 433 434/** 435 * i2o_block_end_request - Post-processing of completed commands 436 * @req: request which should be completed 437 * @uptodate: 1 for success, 0 for I/O error, < 0 for specific error 438 * @nr_bytes: number of bytes to complete 439 * 440 * Mark the request as complete. The lock must not be held when entering. 441 * 442 */ 443static void i2o_block_end_request(struct request *req, int uptodate, 444 int nr_bytes) 445{ 446 struct i2o_block_request *ireq = req->special; 447 struct i2o_block_device *dev = ireq->i2o_blk_dev; 448 request_queue_t *q = req->q; 449 unsigned long flags; 450 451 if (end_that_request_chunk(req, uptodate, nr_bytes)) { 452 int leftover = (req->hard_nr_sectors << KERNEL_SECTOR_SHIFT); 453 454 if (blk_pc_request(req)) 455 leftover = req->data_len; 456 457 if (end_io_error(uptodate)) 458 end_that_request_chunk(req, 0, leftover); 459 } 460 461 add_disk_randomness(req->rq_disk); 462 463 spin_lock_irqsave(q->queue_lock, flags); 464 465 end_that_request_last(req, uptodate); 466 467 if (likely(dev)) { 468 dev->open_queue_depth--; 469 list_del(&ireq->queue); 470 } 471 472 blk_start_queue(q); 473 474 spin_unlock_irqrestore(q->queue_lock, flags); 475 476 i2o_block_sglist_free(ireq); 477 i2o_block_request_free(ireq); 478}; 479 480/** 481 * i2o_block_reply - Block OSM reply handler. 482 * @c: I2O controller from which the message arrives 483 * @m: message id of reply 484 * @msg: the actual I2O message reply 485 * 486 * This function gets all the message replies. 487 * 488 */ 489static int i2o_block_reply(struct i2o_controller *c, u32 m, 490 struct i2o_message *msg) 491{ 492 struct request *req; 493 int uptodate = 1; 494 495 req = i2o_cntxt_list_get(c, le32_to_cpu(msg->u.s.tcntxt)); 496 if (unlikely(!req)) { 497 osm_err("NULL reply received!\n"); 498 return -1; 499 } 500 501 /* 502 * Lets see what is cooking. We stuffed the 503 * request in the context. 504 */ 505 506 if ((le32_to_cpu(msg->body[0]) >> 24) != 0) { 507 u32 status = le32_to_cpu(msg->body[0]); 508 /* 509 * Device not ready means two things. One is that the 510 * the thing went offline (but not a removal media) 511 * 512 * The second is that you have a SuperTrak 100 and the 513 * firmware got constipated. Unlike standard i2o card 514 * setups the supertrak returns an error rather than 515 * blocking for the timeout in these cases. 516 * 517 * Don't stick a supertrak100 into cache aggressive modes 518 */ 519 520 osm_err("TID %03x error status: 0x%02x, detailed status: " 521 "0x%04x\n", (le32_to_cpu(msg->u.head[1]) >> 12 & 0xfff), 522 status >> 24, status & 0xffff); 523 524 req->errors++; 525 526 uptodate = 0; 527 } 528 529 i2o_block_end_request(req, uptodate, le32_to_cpu(msg->body[1])); 530 531 return 1; 532}; 533 534static void i2o_block_event(struct work_struct *work) 535{ 536 struct i2o_event *evt = container_of(work, struct i2o_event, work); 537 osm_debug("event received\n"); 538 kfree(evt); 539}; 540 541/* 542 * SCSI-CAM for ioctl geometry mapping 543 * Duplicated with SCSI - this should be moved into somewhere common 544 * perhaps genhd ? 545 * 546 * LBA -> CHS mapping table taken from: 547 * 548 * "Incorporating the I2O Architecture into BIOS for Intel Architecture 549 * Platforms" 550 * 551 * This is an I2O document that is only available to I2O members, 552 * not developers. 553 * 554 * From my understanding, this is how all the I2O cards do this 555 * 556 * Disk Size | Sectors | Heads | Cylinders 557 * ---------------+---------+-------+------------------- 558 * 1 < X <= 528M | 63 | 16 | X/(63 * 16 * 512) 559 * 528M < X <= 1G | 63 | 32 | X/(63 * 32 * 512) 560 * 1 < X <528M | 63 | 16 | X/(63 * 16 * 512) 561 * 1 < X <528M | 63 | 16 | X/(63 * 16 * 512) 562 * 563 */ 564#define BLOCK_SIZE_528M 1081344 565#define BLOCK_SIZE_1G 2097152 566#define BLOCK_SIZE_21G 4403200 567#define BLOCK_SIZE_42G 8806400 568#define BLOCK_SIZE_84G 17612800 569 570static void i2o_block_biosparam(unsigned long capacity, unsigned short *cyls, 571 unsigned char *hds, unsigned char *secs) 572{ 573 unsigned long heads, sectors, cylinders; 574 575 sectors = 63L; /* Maximize sectors per track */ 576 if (capacity <= BLOCK_SIZE_528M) 577 heads = 16; 578 else if (capacity <= BLOCK_SIZE_1G) 579 heads = 32; 580 else if (capacity <= BLOCK_SIZE_21G) 581 heads = 64; 582 else if (capacity <= BLOCK_SIZE_42G) 583 heads = 128; 584 else 585 heads = 255; 586 587 cylinders = (unsigned long)capacity / (heads * sectors); 588 589 *cyls = (unsigned short)cylinders; /* Stuff return values */ 590 *secs = (unsigned char)sectors; 591 *hds = (unsigned char)heads; 592} 593 594/** 595 * i2o_block_open - Open the block device 596 * @inode: inode for block device being opened 597 * @file: file to open 598 * 599 * Power up the device, mount and lock the media. This function is called, 600 * if the block device is opened for access. 601 * 602 * Returns 0 on success or negative error code on failure. 603 */ 604static int i2o_block_open(struct inode *inode, struct file *file) 605{ 606 struct i2o_block_device *dev = inode->i_bdev->bd_disk->private_data; 607 608 if (!dev->i2o_dev) 609 return -ENODEV; 610 611 if (dev->power > 0x1f) 612 i2o_block_device_power(dev, 0x02); 613 614 i2o_block_device_mount(dev->i2o_dev, -1); 615 616 i2o_block_device_lock(dev->i2o_dev, -1); 617 618 osm_debug("Ready.\n"); 619 620 return 0; 621}; 622 623/** 624 * i2o_block_release - Release the I2O block device 625 * @inode: inode for block device being released 626 * @file: file to close 627 * 628 * Unlock and unmount the media, and power down the device. Gets called if 629 * the block device is closed. 630 * 631 * Returns 0 on success or negative error code on failure. 632 */ 633static int i2o_block_release(struct inode *inode, struct file *file) 634{ 635 struct gendisk *disk = inode->i_bdev->bd_disk; 636 struct i2o_block_device *dev = disk->private_data; 637 u8 operation; 638 639 /* 640 * This is to deail with the case of an application 641 * opening a device and then the device dissapears while 642 * it's in use, and then the application tries to release 643 * it. ex: Unmounting a deleted RAID volume at reboot. 644 * If we send messages, it will just cause FAILs since 645 * the TID no longer exists. 646 */ 647 if (!dev->i2o_dev) 648 return 0; 649 650 i2o_block_device_flush(dev->i2o_dev); 651 652 i2o_block_device_unlock(dev->i2o_dev, -1); 653 654 if (dev->flags & (1 << 3 | 1 << 4)) /* Removable */ 655 operation = 0x21; 656 else 657 operation = 0x24; 658 659 i2o_block_device_power(dev, operation); 660 661 return 0; 662} 663 664static int i2o_block_getgeo(struct block_device *bdev, struct hd_geometry *geo) 665{ 666 i2o_block_biosparam(get_capacity(bdev->bd_disk), 667 &geo->cylinders, &geo->heads, &geo->sectors); 668 return 0; 669} 670 671/** 672 * i2o_block_ioctl - Issue device specific ioctl calls. 673 * @inode: inode for block device ioctl 674 * @file: file for ioctl 675 * @cmd: ioctl command 676 * @arg: arg 677 * 678 * Handles ioctl request for the block device. 679 * 680 * Return 0 on success or negative error on failure. 681 */ 682static int i2o_block_ioctl(struct inode *inode, struct file *file, 683 unsigned int cmd, unsigned long arg) 684{ 685 struct gendisk *disk = inode->i_bdev->bd_disk; 686 struct i2o_block_device *dev = disk->private_data; 687 688 /* Anyone capable of this syscall can do *real bad* things */ 689 690 if (!capable(CAP_SYS_ADMIN)) 691 return -EPERM; 692 693 switch (cmd) { 694 case BLKI2OGRSTRAT: 695 return put_user(dev->rcache, (int __user *)arg); 696 case BLKI2OGWSTRAT: 697 return put_user(dev->wcache, (int __user *)arg); 698 case BLKI2OSRSTRAT: 699 if (arg < 0 || arg > CACHE_SMARTFETCH) 700 return -EINVAL; 701 dev->rcache = arg; 702 break; 703 case BLKI2OSWSTRAT: 704 if (arg != 0 705 && (arg < CACHE_WRITETHROUGH || arg > CACHE_SMARTBACK)) 706 return -EINVAL; 707 dev->wcache = arg; 708 break; 709 } 710 return -ENOTTY; 711}; 712 713/** 714 * i2o_block_media_changed - Have we seen a media change? 715 * @disk: gendisk which should be verified 716 * 717 * Verifies if the media has changed. 718 * 719 * Returns 1 if the media was changed or 0 otherwise. 720 */ 721static int i2o_block_media_changed(struct gendisk *disk) 722{ 723 struct i2o_block_device *p = disk->private_data; 724 725 if (p->media_change_flag) { 726 p->media_change_flag = 0; 727 return 1; 728 } 729 return 0; 730} 731 732/** 733 * i2o_block_transfer - Transfer a request to/from the I2O controller 734 * @req: the request which should be transfered 735 * 736 * This function converts the request into a I2O message. The necessary 737 * DMA buffers are allocated and after everything is setup post the message 738 * to the I2O controller. No cleanup is done by this function. It is done 739 * on the interrupt side when the reply arrives. 740 * 741 * Return 0 on success or negative error code on failure. 742 */ 743static int i2o_block_transfer(struct request *req) 744{ 745 struct i2o_block_device *dev = req->rq_disk->private_data; 746 struct i2o_controller *c; 747 int tid = dev->i2o_dev->lct_data.tid; 748 struct i2o_message *msg; 749 u32 *mptr; 750 struct i2o_block_request *ireq = req->special; 751 u32 tcntxt; 752 u32 sgl_offset = SGL_OFFSET_8; 753 u32 ctl_flags = 0x00000000; 754 int rc; 755 u32 cmd; 756 757 if (unlikely(!dev->i2o_dev)) { 758 osm_err("transfer to removed drive\n"); 759 rc = -ENODEV; 760 goto exit; 761 } 762 763 c = dev->i2o_dev->iop; 764 765 msg = i2o_msg_get(c); 766 if (IS_ERR(msg)) { 767 rc = PTR_ERR(msg); 768 goto exit; 769 } 770 771 tcntxt = i2o_cntxt_list_add(c, req); 772 if (!tcntxt) { 773 rc = -ENOMEM; 774 goto nop_msg; 775 } 776 777 msg->u.s.icntxt = cpu_to_le32(i2o_block_driver.context); 778 msg->u.s.tcntxt = cpu_to_le32(tcntxt); 779 780 mptr = &msg->body[0]; 781 782 if (rq_data_dir(req) == READ) { 783 cmd = I2O_CMD_BLOCK_READ << 24; 784 785 switch (dev->rcache) { 786 case CACHE_PREFETCH: 787 ctl_flags = 0x201F0008; 788 break; 789 790 case CACHE_SMARTFETCH: 791 if (req->nr_sectors > 16) 792 ctl_flags = 0x201F0008; 793 else 794 ctl_flags = 0x001F0000; 795 break; 796 797 default: 798 break; 799 } 800 } else { 801 cmd = I2O_CMD_BLOCK_WRITE << 24; 802 803 switch (dev->wcache) { 804 case CACHE_WRITETHROUGH: 805 ctl_flags = 0x001F0008; 806 break; 807 case CACHE_WRITEBACK: 808 ctl_flags = 0x001F0010; 809 break; 810 case CACHE_SMARTBACK: 811 if (req->nr_sectors > 16) 812 ctl_flags = 0x001F0004; 813 else 814 ctl_flags = 0x001F0010; 815 break; 816 case CACHE_SMARTTHROUGH: 817 if (req->nr_sectors > 16) 818 ctl_flags = 0x001F0004; 819 else 820 ctl_flags = 0x001F0010; 821 default: 822 break; 823 } 824 } 825 826#ifdef CONFIG_I2O_EXT_ADAPTEC 827 if (c->adaptec) { 828 u8 cmd[10]; 829 u32 scsi_flags; 830 u16 hwsec = queue_hardsect_size(req->q) >> KERNEL_SECTOR_SHIFT; 831 832 memset(cmd, 0, 10); 833 834 sgl_offset = SGL_OFFSET_12; 835 836 msg->u.head[1] = 837 cpu_to_le32(I2O_CMD_PRIVATE << 24 | HOST_TID << 12 | tid); 838 839 *mptr++ = cpu_to_le32(I2O_VENDOR_DPT << 16 | I2O_CMD_SCSI_EXEC); 840 *mptr++ = cpu_to_le32(tid); 841 842 /* 843 * ENABLE_DISCONNECT 844 * SIMPLE_TAG 845 * RETURN_SENSE_DATA_IN_REPLY_MESSAGE_FRAME 846 */ 847 if (rq_data_dir(req) == READ) { 848 cmd[0] = READ_10; 849 scsi_flags = 0x60a0000a; 850 } else { 851 cmd[0] = WRITE_10; 852 scsi_flags = 0xa0a0000a; 853 } 854 855 *mptr++ = cpu_to_le32(scsi_flags); 856 857 *((u32 *) & cmd[2]) = cpu_to_be32(req->sector * hwsec); 858 *((u16 *) & cmd[7]) = cpu_to_be16(req->nr_sectors * hwsec); 859 860 memcpy(mptr, cmd, 10); 861 mptr += 4; 862 *mptr++ = cpu_to_le32(req->nr_sectors << KERNEL_SECTOR_SHIFT); 863 } else 864#endif 865 { 866 msg->u.head[1] = cpu_to_le32(cmd | HOST_TID << 12 | tid); 867 *mptr++ = cpu_to_le32(ctl_flags); 868 *mptr++ = cpu_to_le32(req->nr_sectors << KERNEL_SECTOR_SHIFT); 869 *mptr++ = 870 cpu_to_le32((u32) (req->sector << KERNEL_SECTOR_SHIFT)); 871 *mptr++ = 872 cpu_to_le32(req->sector >> (32 - KERNEL_SECTOR_SHIFT)); 873 } 874 875 if (!i2o_block_sglist_alloc(c, ireq, &mptr)) { 876 rc = -ENOMEM; 877 goto context_remove; 878 } 879 880 msg->u.head[0] = 881 cpu_to_le32(I2O_MESSAGE_SIZE(mptr - &msg->u.head[0]) | sgl_offset); 882 883 list_add_tail(&ireq->queue, &dev->open_queue); 884 dev->open_queue_depth++; 885 886 i2o_msg_post(c, msg); 887 888 return 0; 889 890 context_remove: 891 i2o_cntxt_list_remove(c, req); 892 893 nop_msg: 894 i2o_msg_nop(c, msg); 895 896 exit: 897 return rc; 898}; 899 900/** 901 * i2o_block_request_fn - request queue handling function 902 * @q: request queue from which the request could be fetched 903 * 904 * Takes the next request from the queue, transfers it and if no error 905 * occurs dequeue it from the queue. On arrival of the reply the message 906 * will be processed further. If an error occurs requeue the request. 907 */ 908static void i2o_block_request_fn(struct request_queue *q) 909{ 910 struct request *req; 911 912 while (!blk_queue_plugged(q)) { 913 req = elv_next_request(q); 914 if (!req) 915 break; 916 917 if (blk_fs_request(req)) { 918 struct i2o_block_delayed_request *dreq; 919 struct i2o_block_request *ireq = req->special; 920 unsigned int queue_depth; 921 922 queue_depth = ireq->i2o_blk_dev->open_queue_depth; 923 924 if (queue_depth < I2O_BLOCK_MAX_OPEN_REQUESTS) { 925 if (!i2o_block_transfer(req)) { 926 blkdev_dequeue_request(req); 927 continue; 928 } else 929 osm_info("transfer error\n"); 930 } 931 932 if (queue_depth) 933 break; 934 935 /* stop the queue and retry later */ 936 dreq = kmalloc(sizeof(*dreq), GFP_ATOMIC); 937 if (!dreq) 938 continue; 939 940 dreq->queue = q; 941 INIT_DELAYED_WORK(&dreq->work, 942 i2o_block_delayed_request_fn); 943 944 if (!queue_delayed_work(i2o_block_driver.event_queue, 945 &dreq->work, 946 I2O_BLOCK_RETRY_TIME)) 947 kfree(dreq); 948 else { 949 blk_stop_queue(q); 950 break; 951 } 952 } else 953 end_request(req, 0); 954 } 955}; 956 957/* I2O Block device operations definition */ 958static struct block_device_operations i2o_block_fops = { 959 .owner = THIS_MODULE, 960 .open = i2o_block_open, 961 .release = i2o_block_release, 962 .ioctl = i2o_block_ioctl, 963 .getgeo = i2o_block_getgeo, 964 .media_changed = i2o_block_media_changed 965}; 966 967/** 968 * i2o_block_device_alloc - Allocate memory for a I2O Block device 969 * 970 * Allocate memory for the i2o_block_device struct, gendisk and request 971 * queue and initialize them as far as no additional information is needed. 972 * 973 * Returns a pointer to the allocated I2O Block device on succes or a 974 * negative error code on failure. 975 */ 976static struct i2o_block_device *i2o_block_device_alloc(void) 977{ 978 struct i2o_block_device *dev; 979 struct gendisk *gd; 980 struct request_queue *queue; 981 int rc; 982 983 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 984 if (!dev) { 985 osm_err("Insufficient memory to allocate I2O Block disk.\n"); 986 rc = -ENOMEM; 987 goto exit; 988 } 989 990 INIT_LIST_HEAD(&dev->open_queue); 991 spin_lock_init(&dev->lock); 992 dev->rcache = CACHE_PREFETCH; 993 dev->wcache = CACHE_WRITEBACK; 994 995 /* allocate a gendisk with 16 partitions */ 996 gd = alloc_disk(16); 997 if (!gd) { 998 osm_err("Insufficient memory to allocate gendisk.\n"); 999 rc = -ENOMEM; 1000 goto cleanup_dev; 1001 } 1002 1003 /* initialize the request queue */ 1004 queue = blk_init_queue(i2o_block_request_fn, &dev->lock); 1005 if (!queue) { 1006 osm_err("Insufficient memory to allocate request queue.\n"); 1007 rc = -ENOMEM; 1008 goto cleanup_queue; 1009 } 1010 1011 blk_queue_prep_rq(queue, i2o_block_prep_req_fn); 1012 blk_queue_issue_flush_fn(queue, i2o_block_issue_flush); 1013 1014 gd->major = I2O_MAJOR; 1015 gd->queue = queue; 1016 gd->fops = &i2o_block_fops; 1017 gd->private_data = dev; 1018 1019 dev->gd = gd; 1020 1021 return dev; 1022 1023 cleanup_queue: 1024 put_disk(gd); 1025 1026 cleanup_dev: 1027 kfree(dev); 1028 1029 exit: 1030 return ERR_PTR(rc); 1031}; 1032 1033/** 1034 * i2o_block_probe - verify if dev is a I2O Block device and install it 1035 * @dev: device to verify if it is a I2O Block device 1036 * 1037 * We only verify if the user_tid of the device is 0xfff and then install 1038 * the device. Otherwise it is used by some other device (e. g. RAID). 1039 * 1040 * Returns 0 on success or negative error code on failure. 1041 */ 1042static int i2o_block_probe(struct device *dev) 1043{ 1044 struct i2o_device *i2o_dev = to_i2o_device(dev); 1045 struct i2o_controller *c = i2o_dev->iop; 1046 struct i2o_block_device *i2o_blk_dev; 1047 struct gendisk *gd; 1048 struct request_queue *queue; 1049 static int unit = 0; 1050 int rc; 1051 u64 size; 1052 u32 blocksize; 1053 u16 body_size = 4; 1054 u16 power; 1055 unsigned short max_sectors; 1056 1057#ifdef CONFIG_I2O_EXT_ADAPTEC 1058 if (c->adaptec) 1059 body_size = 8; 1060#endif 1061 1062 if (c->limit_sectors) 1063 max_sectors = I2O_MAX_SECTORS_LIMITED; 1064 else 1065 max_sectors = I2O_MAX_SECTORS; 1066 1067 /* skip devices which are used by IOP */ 1068 if (i2o_dev->lct_data.user_tid != 0xfff) { 1069 osm_debug("skipping used device %03x\n", i2o_dev->lct_data.tid); 1070 return -ENODEV; 1071 } 1072 1073 if (i2o_device_claim(i2o_dev)) { 1074 osm_warn("Unable to claim device. Installation aborted\n"); 1075 rc = -EFAULT; 1076 goto exit; 1077 } 1078 1079 i2o_blk_dev = i2o_block_device_alloc(); 1080 if (IS_ERR(i2o_blk_dev)) { 1081 osm_err("could not alloc a new I2O block device"); 1082 rc = PTR_ERR(i2o_blk_dev); 1083 goto claim_release; 1084 } 1085 1086 i2o_blk_dev->i2o_dev = i2o_dev; 1087 dev_set_drvdata(dev, i2o_blk_dev); 1088 1089 /* setup gendisk */ 1090 gd = i2o_blk_dev->gd; 1091 gd->first_minor = unit << 4; 1092 sprintf(gd->disk_name, "i2o/hd%c", 'a' + unit); 1093 gd->driverfs_dev = &i2o_dev->device; 1094 1095 /* setup request queue */ 1096 queue = gd->queue; 1097 queue->queuedata = i2o_blk_dev; 1098 1099 blk_queue_max_phys_segments(queue, I2O_MAX_PHYS_SEGMENTS); 1100 blk_queue_max_sectors(queue, max_sectors); 1101 blk_queue_max_hw_segments(queue, i2o_sg_tablesize(c, body_size)); 1102 1103 osm_debug("max sectors = %d\n", queue->max_phys_segments); 1104 osm_debug("phys segments = %d\n", queue->max_sectors); 1105 osm_debug("max hw segments = %d\n", queue->max_hw_segments); 1106 1107 /* 1108 * Ask for the current media data. If that isn't supported 1109 * then we ask for the device capacity data 1110 */ 1111 if (!i2o_parm_field_get(i2o_dev, 0x0004, 1, &blocksize, 4) || 1112 !i2o_parm_field_get(i2o_dev, 0x0000, 3, &blocksize, 4)) { 1113 blk_queue_hardsect_size(queue, le32_to_cpu(blocksize)); 1114 } else 1115 osm_warn("unable to get blocksize of %s\n", gd->disk_name); 1116 1117 if (!i2o_parm_field_get(i2o_dev, 0x0004, 0, &size, 8) || 1118 !i2o_parm_field_get(i2o_dev, 0x0000, 4, &size, 8)) { 1119 set_capacity(gd, le64_to_cpu(size) >> KERNEL_SECTOR_SHIFT); 1120 } else 1121 osm_warn("could not get size of %s\n", gd->disk_name); 1122 1123 if (!i2o_parm_field_get(i2o_dev, 0x0000, 2, &power, 2)) 1124 i2o_blk_dev->power = power; 1125 1126 i2o_event_register(i2o_dev, &i2o_block_driver, 0, 0xffffffff); 1127 1128 add_disk(gd); 1129 1130 unit++; 1131 1132 osm_info("device added (TID: %03x): %s\n", i2o_dev->lct_data.tid, 1133 i2o_blk_dev->gd->disk_name); 1134 1135 return 0; 1136 1137 claim_release: 1138 i2o_device_claim_release(i2o_dev); 1139 1140 exit: 1141 return rc; 1142}; 1143 1144/* Block OSM driver struct */ 1145static struct i2o_driver i2o_block_driver = { 1146 .name = OSM_NAME, 1147 .event = i2o_block_event, 1148 .reply = i2o_block_reply, 1149 .classes = i2o_block_class_id, 1150 .driver = { 1151 .probe = i2o_block_probe, 1152 .remove = i2o_block_remove, 1153 }, 1154}; 1155 1156/** 1157 * i2o_block_init - Block OSM initialization function 1158 * 1159 * Allocate the slab and mempool for request structs, registers i2o_block 1160 * block device and finally register the Block OSM in the I2O core. 1161 * 1162 * Returns 0 on success or negative error code on failure. 1163 */ 1164static int __init i2o_block_init(void) 1165{ 1166 int rc; 1167 int size; 1168 1169 printk(KERN_INFO OSM_DESCRIPTION " v" OSM_VERSION "\n"); 1170 1171 /* Allocate request mempool and slab */ 1172 size = sizeof(struct i2o_block_request); 1173 i2o_blk_req_pool.slab = kmem_cache_create("i2o_block_req", size, 0, 1174 SLAB_HWCACHE_ALIGN, NULL, 1175 NULL); 1176 if (!i2o_blk_req_pool.slab) { 1177 osm_err("can't init request slab\n"); 1178 rc = -ENOMEM; 1179 goto exit; 1180 } 1181 1182 i2o_blk_req_pool.pool = 1183 mempool_create_slab_pool(I2O_BLOCK_REQ_MEMPOOL_SIZE, 1184 i2o_blk_req_pool.slab); 1185 if (!i2o_blk_req_pool.pool) { 1186 osm_err("can't init request mempool\n"); 1187 rc = -ENOMEM; 1188 goto free_slab; 1189 } 1190 1191 /* Register the block device interfaces */ 1192 rc = register_blkdev(I2O_MAJOR, "i2o_block"); 1193 if (rc) { 1194 osm_err("unable to register block device\n"); 1195 goto free_mempool; 1196 } 1197#ifdef MODULE 1198 osm_info("registered device at major %d\n", I2O_MAJOR); 1199#endif 1200 1201 /* Register Block OSM into I2O core */ 1202 rc = i2o_driver_register(&i2o_block_driver); 1203 if (rc) { 1204 osm_err("Could not register Block driver\n"); 1205 goto unregister_blkdev; 1206 } 1207 1208 return 0; 1209 1210 unregister_blkdev: 1211 unregister_blkdev(I2O_MAJOR, "i2o_block"); 1212 1213 free_mempool: 1214 mempool_destroy(i2o_blk_req_pool.pool); 1215 1216 free_slab: 1217 kmem_cache_destroy(i2o_blk_req_pool.slab); 1218 1219 exit: 1220 return rc; 1221}; 1222 1223/** 1224 * i2o_block_exit - Block OSM exit function 1225 * 1226 * Unregisters Block OSM from I2O core, unregisters i2o_block block device 1227 * and frees the mempool and slab. 1228 */ 1229static void __exit i2o_block_exit(void) 1230{ 1231 /* Unregister I2O Block OSM from I2O core */ 1232 i2o_driver_unregister(&i2o_block_driver); 1233 1234 /* Unregister block device */ 1235 unregister_blkdev(I2O_MAJOR, "i2o_block"); 1236 1237 /* Free request mempool and slab */ 1238 mempool_destroy(i2o_blk_req_pool.pool); 1239 kmem_cache_destroy(i2o_blk_req_pool.slab); 1240}; 1241 1242MODULE_AUTHOR("Red Hat"); 1243MODULE_LICENSE("GPL"); 1244MODULE_DESCRIPTION(OSM_DESCRIPTION); 1245MODULE_VERSION(OSM_VERSION); 1246 1247module_init(i2o_block_init); 1248module_exit(i2o_block_exit); 1249