4 * Copyright (C) 1999-2002 Red Hat Software
6 * Written by Alan Cox, Building Number Three Ltd
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.
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.
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
25 * Multiple device handling error fixes,
26 * Added a queue depth.
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
36 * Independent queues per IOP
37 * Support for dynamic device creation/deletion
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
49 * Markus Lidel <Markus.Lidel@shadowconnect.com>:
50 * Minor bugfixes for 2.6.
53 #include <linux/module.h>
54 #include <linux/i2o.h>
56 #include <linux/mempool.h>
58 #include <linux/genhd.h>
59 #include <linux/blkdev.h>
60 #include <linux/hdreg.h>
62 #include <scsi/scsi.h>
64 #include "i2o_block.h"
66 #define OSM_NAME "block-osm"
67 #define OSM_VERSION "1.325"
68 #define OSM_DESCRIPTION "I2O Block Device OSM"
70 static struct i2o_driver i2o_block_driver
;
72 /* global Block OSM request mempool */
73 static struct i2o_block_mempool i2o_blk_req_pool
;
75 /* Block OSM class handling definition */
76 static struct i2o_class_id i2o_block_class_id
[] = {
77 {I2O_CLASS_RANDOM_BLOCK_STORAGE
},
82 * i2o_block_device_free - free the memory of the I2O Block device
83 * @dev: I2O Block device, which should be cleaned up
85 * Frees the request queue, gendisk and the i2o_block_device structure.
87 static void i2o_block_device_free(struct i2o_block_device
*dev
)
89 blk_cleanup_queue(dev
->gd
->queue
);
97 * i2o_block_remove - remove the I2O Block device from the system again
98 * @dev: I2O Block device which should be removed
100 * Remove gendisk from system and free all allocated memory.
104 static int i2o_block_remove(struct device
*dev
)
106 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
107 struct i2o_block_device
*i2o_blk_dev
= dev_get_drvdata(dev
);
109 osm_info("device removed (TID: %03x): %s\n", i2o_dev
->lct_data
.tid
,
110 i2o_blk_dev
->gd
->disk_name
);
112 i2o_event_register(i2o_dev
, &i2o_block_driver
, 0, 0);
114 del_gendisk(i2o_blk_dev
->gd
);
116 dev_set_drvdata(dev
, NULL
);
118 i2o_device_claim_release(i2o_dev
);
120 i2o_block_device_free(i2o_blk_dev
);
126 * i2o_block_device flush - Flush all dirty data of I2O device dev
127 * @dev: I2O device which should be flushed
129 * Flushes all dirty data on device dev.
131 * Returns 0 on success or negative error code on failure.
133 static int i2o_block_device_flush(struct i2o_device
*dev
)
135 struct i2o_message
*msg
;
137 msg
= i2o_msg_get_wait(dev
->iop
, I2O_TIMEOUT_MESSAGE_GET
);
141 msg
->u
.head
[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE
| SGL_OFFSET_0
);
143 cpu_to_le32(I2O_CMD_BLOCK_CFLUSH
<< 24 | HOST_TID
<< 12 | dev
->
145 msg
->body
[0] = cpu_to_le32(60 << 16);
146 osm_debug("Flushing...\n");
148 return i2o_msg_post_wait(dev
->iop
, msg
, 60);
152 * i2o_block_device_mount - Mount (load) the media of device dev
153 * @dev: I2O device which should receive the mount request
154 * @media_id: Media Identifier
156 * Load a media into drive. Identifier should be set to -1, because the
157 * spec does not support any other value.
159 * Returns 0 on success or negative error code on failure.
161 static int i2o_block_device_mount(struct i2o_device
*dev
, u32 media_id
)
163 struct i2o_message
*msg
;
165 msg
= i2o_msg_get_wait(dev
->iop
, I2O_TIMEOUT_MESSAGE_GET
);
169 msg
->u
.head
[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE
| SGL_OFFSET_0
);
171 cpu_to_le32(I2O_CMD_BLOCK_MMOUNT
<< 24 | HOST_TID
<< 12 | dev
->
173 msg
->body
[0] = cpu_to_le32(-1);
174 msg
->body
[1] = cpu_to_le32(0x00000000);
175 osm_debug("Mounting...\n");
177 return i2o_msg_post_wait(dev
->iop
, msg
, 2);
181 * i2o_block_device_lock - Locks the media of device dev
182 * @dev: I2O device which should receive the lock request
183 * @media_id: Media Identifier
185 * Lock media of device dev to prevent removal. The media identifier
186 * should be set to -1, because the spec does not support any other value.
188 * Returns 0 on success or negative error code on failure.
190 static int i2o_block_device_lock(struct i2o_device
*dev
, u32 media_id
)
192 struct i2o_message
*msg
;
194 msg
= i2o_msg_get_wait(dev
->iop
, I2O_TIMEOUT_MESSAGE_GET
);
198 msg
->u
.head
[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE
| SGL_OFFSET_0
);
200 cpu_to_le32(I2O_CMD_BLOCK_MLOCK
<< 24 | HOST_TID
<< 12 | dev
->
202 msg
->body
[0] = cpu_to_le32(-1);
203 osm_debug("Locking...\n");
205 return i2o_msg_post_wait(dev
->iop
, msg
, 2);
209 * i2o_block_device_unlock - Unlocks the media of device dev
210 * @dev: I2O device which should receive the unlocked request
211 * @media_id: Media Identifier
213 * Unlocks the media in device dev. The media identifier should be set to
214 * -1, because the spec does not support any other value.
216 * Returns 0 on success or negative error code on failure.
218 static int i2o_block_device_unlock(struct i2o_device
*dev
, u32 media_id
)
220 struct i2o_message
*msg
;
222 msg
= i2o_msg_get_wait(dev
->iop
, I2O_TIMEOUT_MESSAGE_GET
);
226 msg
->u
.head
[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE
| SGL_OFFSET_0
);
228 cpu_to_le32(I2O_CMD_BLOCK_MUNLOCK
<< 24 | HOST_TID
<< 12 | dev
->
230 msg
->body
[0] = cpu_to_le32(media_id
);
231 osm_debug("Unlocking...\n");
233 return i2o_msg_post_wait(dev
->iop
, msg
, 2);
237 * i2o_block_device_power - Power management for device dev
238 * @dev: I2O device which should receive the power management request
239 * @op: Operation to send
241 * Send a power management request to the device dev.
243 * Returns 0 on success or negative error code on failure.
245 static int i2o_block_device_power(struct i2o_block_device
*dev
, u8 op
)
247 struct i2o_device
*i2o_dev
= dev
->i2o_dev
;
248 struct i2o_controller
*c
= i2o_dev
->iop
;
249 struct i2o_message
*msg
;
252 msg
= i2o_msg_get_wait(c
, I2O_TIMEOUT_MESSAGE_GET
);
256 msg
->u
.head
[0] = cpu_to_le32(FOUR_WORD_MSG_SIZE
| SGL_OFFSET_0
);
258 cpu_to_le32(I2O_CMD_BLOCK_POWER
<< 24 | HOST_TID
<< 12 | i2o_dev
->
260 msg
->body
[0] = cpu_to_le32(op
<< 24);
261 osm_debug("Power...\n");
263 rc
= i2o_msg_post_wait(c
, msg
, 60);
271 * i2o_block_request_alloc - Allocate an I2O block request struct
273 * Allocates an I2O block request struct and initialize the list.
275 * Returns a i2o_block_request pointer on success or negative error code
278 static inline struct i2o_block_request
*i2o_block_request_alloc(void)
280 struct i2o_block_request
*ireq
;
282 ireq
= mempool_alloc(i2o_blk_req_pool
.pool
, GFP_ATOMIC
);
284 return ERR_PTR(-ENOMEM
);
286 INIT_LIST_HEAD(&ireq
->queue
);
287 sg_init_table(ireq
->sg_table
, I2O_MAX_PHYS_SEGMENTS
);
293 * i2o_block_request_free - Frees a I2O block request
294 * @ireq: I2O block request which should be freed
296 * Frees the allocated memory (give it back to the request mempool).
298 static inline void i2o_block_request_free(struct i2o_block_request
*ireq
)
300 mempool_free(ireq
, i2o_blk_req_pool
.pool
);
304 * i2o_block_sglist_alloc - Allocate the SG list and map it
305 * @c: I2O controller to which the request belongs
306 * @ireq: I2O block request
307 * @mptr: message body pointer
309 * Builds the SG list and map it to be accessable by the controller.
311 * Returns 0 on failure or 1 on success.
313 static inline int i2o_block_sglist_alloc(struct i2o_controller
*c
,
314 struct i2o_block_request
*ireq
,
318 enum dma_data_direction direction
;
320 ireq
->dev
= &c
->pdev
->dev
;
321 nents
= blk_rq_map_sg(ireq
->req
->q
, ireq
->req
, ireq
->sg_table
);
323 if (rq_data_dir(ireq
->req
) == READ
)
324 direction
= PCI_DMA_FROMDEVICE
;
326 direction
= PCI_DMA_TODEVICE
;
328 ireq
->sg_nents
= nents
;
330 return i2o_dma_map_sg(c
, ireq
->sg_table
, nents
, direction
, mptr
);
334 * i2o_block_sglist_free - Frees the SG list
335 * @ireq: I2O block request from which the SG should be freed
337 * Frees the SG list from the I2O block request.
339 static inline void i2o_block_sglist_free(struct i2o_block_request
*ireq
)
341 enum dma_data_direction direction
;
343 if (rq_data_dir(ireq
->req
) == READ
)
344 direction
= PCI_DMA_FROMDEVICE
;
346 direction
= PCI_DMA_TODEVICE
;
348 dma_unmap_sg(ireq
->dev
, ireq
->sg_table
, ireq
->sg_nents
, direction
);
352 * i2o_block_prep_req_fn - Allocates I2O block device specific struct
353 * @q: request queue for the request
354 * @req: the request to prepare
356 * Allocate the necessary i2o_block_request struct and connect it to
357 * the request. This is needed that we not loose the SG list later on.
359 * Returns BLKPREP_OK on success or BLKPREP_DEFER on failure.
361 static int i2o_block_prep_req_fn(struct request_queue
*q
, struct request
*req
)
363 struct i2o_block_device
*i2o_blk_dev
= q
->queuedata
;
364 struct i2o_block_request
*ireq
;
366 if (unlikely(!i2o_blk_dev
)) {
367 osm_err("block device already removed\n");
371 /* connect the i2o_block_request to the request */
373 ireq
= i2o_block_request_alloc();
374 if (unlikely(IS_ERR(ireq
))) {
375 osm_debug("unable to allocate i2o_block_request!\n");
376 return BLKPREP_DEFER
;
379 ireq
->i2o_blk_dev
= i2o_blk_dev
;
383 /* do not come back here */
384 req
->cmd_flags
|= REQ_DONTPREP
;
390 * i2o_block_delayed_request_fn - delayed request queue function
391 * @work: the delayed request with the queue to start
393 * If the request queue is stopped for a disk, and there is no open
394 * request, a new event is created, which calls this function to start
395 * the queue after I2O_BLOCK_REQUEST_TIME. Otherwise the queue will never
398 static void i2o_block_delayed_request_fn(struct work_struct
*work
)
400 struct i2o_block_delayed_request
*dreq
=
401 container_of(work
, struct i2o_block_delayed_request
,
403 struct request_queue
*q
= dreq
->queue
;
406 spin_lock_irqsave(q
->queue_lock
, flags
);
408 spin_unlock_irqrestore(q
->queue_lock
, flags
);
413 * i2o_block_end_request - Post-processing of completed commands
414 * @req: request which should be completed
415 * @uptodate: 1 for success, 0 for I/O error, < 0 for specific error
416 * @nr_bytes: number of bytes to complete
418 * Mark the request as complete. The lock must not be held when entering.
421 static void i2o_block_end_request(struct request
*req
, int uptodate
,
424 struct i2o_block_request
*ireq
= req
->special
;
425 struct i2o_block_device
*dev
= ireq
->i2o_blk_dev
;
426 struct request_queue
*q
= req
->q
;
429 if (end_that_request_chunk(req
, uptodate
, nr_bytes
)) {
430 int leftover
= (req
->hard_nr_sectors
<< KERNEL_SECTOR_SHIFT
);
432 if (blk_pc_request(req
))
433 leftover
= req
->data_len
;
435 if (end_io_error(uptodate
))
436 end_that_request_chunk(req
, 0, leftover
);
439 add_disk_randomness(req
->rq_disk
);
441 spin_lock_irqsave(q
->queue_lock
, flags
);
443 end_that_request_last(req
, uptodate
);
446 dev
->open_queue_depth
--;
447 list_del(&ireq
->queue
);
452 spin_unlock_irqrestore(q
->queue_lock
, flags
);
454 i2o_block_sglist_free(ireq
);
455 i2o_block_request_free(ireq
);
459 * i2o_block_reply - Block OSM reply handler.
460 * @c: I2O controller from which the message arrives
461 * @m: message id of reply
462 * @msg: the actual I2O message reply
464 * This function gets all the message replies.
467 static int i2o_block_reply(struct i2o_controller
*c
, u32 m
,
468 struct i2o_message
*msg
)
473 req
= i2o_cntxt_list_get(c
, le32_to_cpu(msg
->u
.s
.tcntxt
));
474 if (unlikely(!req
)) {
475 osm_err("NULL reply received!\n");
480 * Lets see what is cooking. We stuffed the
481 * request in the context.
484 if ((le32_to_cpu(msg
->body
[0]) >> 24) != 0) {
485 u32 status
= le32_to_cpu(msg
->body
[0]);
487 * Device not ready means two things. One is that the
488 * the thing went offline (but not a removal media)
490 * The second is that you have a SuperTrak 100 and the
491 * firmware got constipated. Unlike standard i2o card
492 * setups the supertrak returns an error rather than
493 * blocking for the timeout in these cases.
495 * Don't stick a supertrak100 into cache aggressive modes
498 osm_err("TID %03x error status: 0x%02x, detailed status: "
499 "0x%04x\n", (le32_to_cpu(msg
->u
.head
[1]) >> 12 & 0xfff),
500 status
>> 24, status
& 0xffff);
507 i2o_block_end_request(req
, uptodate
, le32_to_cpu(msg
->body
[1]));
512 static void i2o_block_event(struct work_struct
*work
)
514 struct i2o_event
*evt
= container_of(work
, struct i2o_event
, work
);
515 osm_debug("event received\n");
520 * SCSI-CAM for ioctl geometry mapping
521 * Duplicated with SCSI - this should be moved into somewhere common
524 * LBA -> CHS mapping table taken from:
526 * "Incorporating the I2O Architecture into BIOS for Intel Architecture
529 * This is an I2O document that is only available to I2O members,
532 * From my understanding, this is how all the I2O cards do this
534 * Disk Size | Sectors | Heads | Cylinders
535 * ---------------+---------+-------+-------------------
536 * 1 < X <= 528M | 63 | 16 | X/(63 * 16 * 512)
537 * 528M < X <= 1G | 63 | 32 | X/(63 * 32 * 512)
538 * 1 < X <528M | 63 | 16 | X/(63 * 16 * 512)
539 * 1 < X <528M | 63 | 16 | X/(63 * 16 * 512)
542 #define BLOCK_SIZE_528M 1081344
543 #define BLOCK_SIZE_1G 2097152
544 #define BLOCK_SIZE_21G 4403200
545 #define BLOCK_SIZE_42G 8806400
546 #define BLOCK_SIZE_84G 17612800
548 static void i2o_block_biosparam(unsigned long capacity
, unsigned short *cyls
,
549 unsigned char *hds
, unsigned char *secs
)
551 unsigned long heads
, sectors
, cylinders
;
553 sectors
= 63L; /* Maximize sectors per track */
554 if (capacity
<= BLOCK_SIZE_528M
)
556 else if (capacity
<= BLOCK_SIZE_1G
)
558 else if (capacity
<= BLOCK_SIZE_21G
)
560 else if (capacity
<= BLOCK_SIZE_42G
)
565 cylinders
= (unsigned long)capacity
/ (heads
* sectors
);
567 *cyls
= (unsigned short)cylinders
; /* Stuff return values */
568 *secs
= (unsigned char)sectors
;
569 *hds
= (unsigned char)heads
;
573 * i2o_block_open - Open the block device
574 * @inode: inode for block device being opened
575 * @file: file to open
577 * Power up the device, mount and lock the media. This function is called,
578 * if the block device is opened for access.
580 * Returns 0 on success or negative error code on failure.
582 static int i2o_block_open(struct inode
*inode
, struct file
*file
)
584 struct i2o_block_device
*dev
= inode
->i_bdev
->bd_disk
->private_data
;
589 if (dev
->power
> 0x1f)
590 i2o_block_device_power(dev
, 0x02);
592 i2o_block_device_mount(dev
->i2o_dev
, -1);
594 i2o_block_device_lock(dev
->i2o_dev
, -1);
596 osm_debug("Ready.\n");
602 * i2o_block_release - Release the I2O block device
603 * @inode: inode for block device being released
604 * @file: file to close
606 * Unlock and unmount the media, and power down the device. Gets called if
607 * the block device is closed.
609 * Returns 0 on success or negative error code on failure.
611 static int i2o_block_release(struct inode
*inode
, struct file
*file
)
613 struct gendisk
*disk
= inode
->i_bdev
->bd_disk
;
614 struct i2o_block_device
*dev
= disk
->private_data
;
618 * This is to deail with the case of an application
619 * opening a device and then the device dissapears while
620 * it's in use, and then the application tries to release
621 * it. ex: Unmounting a deleted RAID volume at reboot.
622 * If we send messages, it will just cause FAILs since
623 * the TID no longer exists.
628 i2o_block_device_flush(dev
->i2o_dev
);
630 i2o_block_device_unlock(dev
->i2o_dev
, -1);
632 if (dev
->flags
& (1 << 3 | 1 << 4)) /* Removable */
637 i2o_block_device_power(dev
, operation
);
642 static int i2o_block_getgeo(struct block_device
*bdev
, struct hd_geometry
*geo
)
644 i2o_block_biosparam(get_capacity(bdev
->bd_disk
),
645 &geo
->cylinders
, &geo
->heads
, &geo
->sectors
);
650 * i2o_block_ioctl - Issue device specific ioctl calls.
651 * @inode: inode for block device ioctl
652 * @file: file for ioctl
653 * @cmd: ioctl command
656 * Handles ioctl request for the block device.
658 * Return 0 on success or negative error on failure.
660 static int i2o_block_ioctl(struct inode
*inode
, struct file
*file
,
661 unsigned int cmd
, unsigned long arg
)
663 struct gendisk
*disk
= inode
->i_bdev
->bd_disk
;
664 struct i2o_block_device
*dev
= disk
->private_data
;
666 /* Anyone capable of this syscall can do *real bad* things */
668 if (!capable(CAP_SYS_ADMIN
))
673 return put_user(dev
->rcache
, (int __user
*)arg
);
675 return put_user(dev
->wcache
, (int __user
*)arg
);
677 if (arg
< 0 || arg
> CACHE_SMARTFETCH
)
683 && (arg
< CACHE_WRITETHROUGH
|| arg
> CACHE_SMARTBACK
))
692 * i2o_block_media_changed - Have we seen a media change?
693 * @disk: gendisk which should be verified
695 * Verifies if the media has changed.
697 * Returns 1 if the media was changed or 0 otherwise.
699 static int i2o_block_media_changed(struct gendisk
*disk
)
701 struct i2o_block_device
*p
= disk
->private_data
;
703 if (p
->media_change_flag
) {
704 p
->media_change_flag
= 0;
711 * i2o_block_transfer - Transfer a request to/from the I2O controller
712 * @req: the request which should be transfered
714 * This function converts the request into a I2O message. The necessary
715 * DMA buffers are allocated and after everything is setup post the message
716 * to the I2O controller. No cleanup is done by this function. It is done
717 * on the interrupt side when the reply arrives.
719 * Return 0 on success or negative error code on failure.
721 static int i2o_block_transfer(struct request
*req
)
723 struct i2o_block_device
*dev
= req
->rq_disk
->private_data
;
724 struct i2o_controller
*c
;
725 u32 tid
= dev
->i2o_dev
->lct_data
.tid
;
726 struct i2o_message
*msg
;
728 struct i2o_block_request
*ireq
= req
->special
;
730 u32 sgl_offset
= SGL_OFFSET_8
;
731 u32 ctl_flags
= 0x00000000;
735 if (unlikely(!dev
->i2o_dev
)) {
736 osm_err("transfer to removed drive\n");
741 c
= dev
->i2o_dev
->iop
;
743 msg
= i2o_msg_get(c
);
749 tcntxt
= i2o_cntxt_list_add(c
, req
);
755 msg
->u
.s
.icntxt
= cpu_to_le32(i2o_block_driver
.context
);
756 msg
->u
.s
.tcntxt
= cpu_to_le32(tcntxt
);
758 mptr
= &msg
->body
[0];
760 if (rq_data_dir(req
) == READ
) {
761 cmd
= I2O_CMD_BLOCK_READ
<< 24;
763 switch (dev
->rcache
) {
765 ctl_flags
= 0x201F0008;
768 case CACHE_SMARTFETCH
:
769 if (req
->nr_sectors
> 16)
770 ctl_flags
= 0x201F0008;
772 ctl_flags
= 0x001F0000;
779 cmd
= I2O_CMD_BLOCK_WRITE
<< 24;
781 switch (dev
->wcache
) {
782 case CACHE_WRITETHROUGH
:
783 ctl_flags
= 0x001F0008;
785 case CACHE_WRITEBACK
:
786 ctl_flags
= 0x001F0010;
788 case CACHE_SMARTBACK
:
789 if (req
->nr_sectors
> 16)
790 ctl_flags
= 0x001F0004;
792 ctl_flags
= 0x001F0010;
794 case CACHE_SMARTTHROUGH
:
795 if (req
->nr_sectors
> 16)
796 ctl_flags
= 0x001F0004;
798 ctl_flags
= 0x001F0010;
804 #ifdef CONFIG_I2O_EXT_ADAPTEC
808 u16 hwsec
= queue_hardsect_size(req
->q
) >> KERNEL_SECTOR_SHIFT
;
812 sgl_offset
= SGL_OFFSET_12
;
815 cpu_to_le32(I2O_CMD_PRIVATE
<< 24 | HOST_TID
<< 12 | tid
);
817 *mptr
++ = cpu_to_le32(I2O_VENDOR_DPT
<< 16 | I2O_CMD_SCSI_EXEC
);
818 *mptr
++ = cpu_to_le32(tid
);
823 * RETURN_SENSE_DATA_IN_REPLY_MESSAGE_FRAME
825 if (rq_data_dir(req
) == READ
) {
827 scsi_flags
= 0x60a0000a;
830 scsi_flags
= 0xa0a0000a;
833 *mptr
++ = cpu_to_le32(scsi_flags
);
835 *((u32
*) & cmd
[2]) = cpu_to_be32(req
->sector
* hwsec
);
836 *((u16
*) & cmd
[7]) = cpu_to_be16(req
->nr_sectors
* hwsec
);
838 memcpy(mptr
, cmd
, 10);
840 *mptr
++ = cpu_to_le32(req
->nr_sectors
<< KERNEL_SECTOR_SHIFT
);
844 msg
->u
.head
[1] = cpu_to_le32(cmd
| HOST_TID
<< 12 | tid
);
845 *mptr
++ = cpu_to_le32(ctl_flags
);
846 *mptr
++ = cpu_to_le32(req
->nr_sectors
<< KERNEL_SECTOR_SHIFT
);
848 cpu_to_le32((u32
) (req
->sector
<< KERNEL_SECTOR_SHIFT
));
850 cpu_to_le32(req
->sector
>> (32 - KERNEL_SECTOR_SHIFT
));
853 if (!i2o_block_sglist_alloc(c
, ireq
, &mptr
)) {
859 cpu_to_le32(I2O_MESSAGE_SIZE(mptr
- &msg
->u
.head
[0]) | sgl_offset
);
861 list_add_tail(&ireq
->queue
, &dev
->open_queue
);
862 dev
->open_queue_depth
++;
864 i2o_msg_post(c
, msg
);
869 i2o_cntxt_list_remove(c
, req
);
879 * i2o_block_request_fn - request queue handling function
880 * @q: request queue from which the request could be fetched
882 * Takes the next request from the queue, transfers it and if no error
883 * occurs dequeue it from the queue. On arrival of the reply the message
884 * will be processed further. If an error occurs requeue the request.
886 static void i2o_block_request_fn(struct request_queue
*q
)
890 while (!blk_queue_plugged(q
)) {
891 req
= elv_next_request(q
);
895 if (blk_fs_request(req
)) {
896 struct i2o_block_delayed_request
*dreq
;
897 struct i2o_block_request
*ireq
= req
->special
;
898 unsigned int queue_depth
;
900 queue_depth
= ireq
->i2o_blk_dev
->open_queue_depth
;
902 if (queue_depth
< I2O_BLOCK_MAX_OPEN_REQUESTS
) {
903 if (!i2o_block_transfer(req
)) {
904 blkdev_dequeue_request(req
);
907 osm_info("transfer error\n");
913 /* stop the queue and retry later */
914 dreq
= kmalloc(sizeof(*dreq
), GFP_ATOMIC
);
919 INIT_DELAYED_WORK(&dreq
->work
,
920 i2o_block_delayed_request_fn
);
922 if (!queue_delayed_work(i2o_block_driver
.event_queue
,
924 I2O_BLOCK_RETRY_TIME
))
935 /* I2O Block device operations definition */
936 static struct block_device_operations i2o_block_fops
= {
937 .owner
= THIS_MODULE
,
938 .open
= i2o_block_open
,
939 .release
= i2o_block_release
,
940 .ioctl
= i2o_block_ioctl
,
941 .getgeo
= i2o_block_getgeo
,
942 .media_changed
= i2o_block_media_changed
946 * i2o_block_device_alloc - Allocate memory for a I2O Block device
948 * Allocate memory for the i2o_block_device struct, gendisk and request
949 * queue and initialize them as far as no additional information is needed.
951 * Returns a pointer to the allocated I2O Block device on succes or a
952 * negative error code on failure.
954 static struct i2o_block_device
*i2o_block_device_alloc(void)
956 struct i2o_block_device
*dev
;
958 struct request_queue
*queue
;
961 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
963 osm_err("Insufficient memory to allocate I2O Block disk.\n");
968 INIT_LIST_HEAD(&dev
->open_queue
);
969 spin_lock_init(&dev
->lock
);
970 dev
->rcache
= CACHE_PREFETCH
;
971 dev
->wcache
= CACHE_WRITEBACK
;
973 /* allocate a gendisk with 16 partitions */
976 osm_err("Insufficient memory to allocate gendisk.\n");
981 /* initialize the request queue */
982 queue
= blk_init_queue(i2o_block_request_fn
, &dev
->lock
);
984 osm_err("Insufficient memory to allocate request queue.\n");
989 blk_queue_prep_rq(queue
, i2o_block_prep_req_fn
);
991 gd
->major
= I2O_MAJOR
;
993 gd
->fops
= &i2o_block_fops
;
994 gd
->private_data
= dev
;
1011 * i2o_block_probe - verify if dev is a I2O Block device and install it
1012 * @dev: device to verify if it is a I2O Block device
1014 * We only verify if the user_tid of the device is 0xfff and then install
1015 * the device. Otherwise it is used by some other device (e. g. RAID).
1017 * Returns 0 on success or negative error code on failure.
1019 static int i2o_block_probe(struct device
*dev
)
1021 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
1022 struct i2o_controller
*c
= i2o_dev
->iop
;
1023 struct i2o_block_device
*i2o_blk_dev
;
1025 struct request_queue
*queue
;
1026 static int unit
= 0;
1032 unsigned short max_sectors
;
1034 #ifdef CONFIG_I2O_EXT_ADAPTEC
1039 if (c
->limit_sectors
)
1040 max_sectors
= I2O_MAX_SECTORS_LIMITED
;
1042 max_sectors
= I2O_MAX_SECTORS
;
1044 /* skip devices which are used by IOP */
1045 if (i2o_dev
->lct_data
.user_tid
!= 0xfff) {
1046 osm_debug("skipping used device %03x\n", i2o_dev
->lct_data
.tid
);
1050 if (i2o_device_claim(i2o_dev
)) {
1051 osm_warn("Unable to claim device. Installation aborted\n");
1056 i2o_blk_dev
= i2o_block_device_alloc();
1057 if (IS_ERR(i2o_blk_dev
)) {
1058 osm_err("could not alloc a new I2O block device");
1059 rc
= PTR_ERR(i2o_blk_dev
);
1063 i2o_blk_dev
->i2o_dev
= i2o_dev
;
1064 dev_set_drvdata(dev
, i2o_blk_dev
);
1067 gd
= i2o_blk_dev
->gd
;
1068 gd
->first_minor
= unit
<< 4;
1069 sprintf(gd
->disk_name
, "i2o/hd%c", 'a' + unit
);
1070 gd
->driverfs_dev
= &i2o_dev
->device
;
1072 /* setup request queue */
1074 queue
->queuedata
= i2o_blk_dev
;
1076 blk_queue_max_phys_segments(queue
, I2O_MAX_PHYS_SEGMENTS
);
1077 blk_queue_max_sectors(queue
, max_sectors
);
1078 blk_queue_max_hw_segments(queue
, i2o_sg_tablesize(c
, body_size
));
1080 osm_debug("max sectors = %d\n", queue
->max_phys_segments
);
1081 osm_debug("phys segments = %d\n", queue
->max_sectors
);
1082 osm_debug("max hw segments = %d\n", queue
->max_hw_segments
);
1085 * Ask for the current media data. If that isn't supported
1086 * then we ask for the device capacity data
1088 if (!i2o_parm_field_get(i2o_dev
, 0x0004, 1, &blocksize
, 4) ||
1089 !i2o_parm_field_get(i2o_dev
, 0x0000, 3, &blocksize
, 4)) {
1090 blk_queue_hardsect_size(queue
, le32_to_cpu(blocksize
));
1092 osm_warn("unable to get blocksize of %s\n", gd
->disk_name
);
1094 if (!i2o_parm_field_get(i2o_dev
, 0x0004, 0, &size
, 8) ||
1095 !i2o_parm_field_get(i2o_dev
, 0x0000, 4, &size
, 8)) {
1096 set_capacity(gd
, le64_to_cpu(size
) >> KERNEL_SECTOR_SHIFT
);
1098 osm_warn("could not get size of %s\n", gd
->disk_name
);
1100 if (!i2o_parm_field_get(i2o_dev
, 0x0000, 2, &power
, 2))
1101 i2o_blk_dev
->power
= power
;
1103 i2o_event_register(i2o_dev
, &i2o_block_driver
, 0, 0xffffffff);
1109 osm_info("device added (TID: %03x): %s\n", i2o_dev
->lct_data
.tid
,
1110 i2o_blk_dev
->gd
->disk_name
);
1115 i2o_device_claim_release(i2o_dev
);
1121 /* Block OSM driver struct */
1122 static struct i2o_driver i2o_block_driver
= {
1124 .event
= i2o_block_event
,
1125 .reply
= i2o_block_reply
,
1126 .classes
= i2o_block_class_id
,
1128 .probe
= i2o_block_probe
,
1129 .remove
= i2o_block_remove
,
1134 * i2o_block_init - Block OSM initialization function
1136 * Allocate the slab and mempool for request structs, registers i2o_block
1137 * block device and finally register the Block OSM in the I2O core.
1139 * Returns 0 on success or negative error code on failure.
1141 static int __init
i2o_block_init(void)
1146 printk(KERN_INFO OSM_DESCRIPTION
" v" OSM_VERSION
"\n");
1148 /* Allocate request mempool and slab */
1149 size
= sizeof(struct i2o_block_request
);
1150 i2o_blk_req_pool
.slab
= kmem_cache_create("i2o_block_req", size
, 0,
1151 SLAB_HWCACHE_ALIGN
, NULL
);
1152 if (!i2o_blk_req_pool
.slab
) {
1153 osm_err("can't init request slab\n");
1158 i2o_blk_req_pool
.pool
=
1159 mempool_create_slab_pool(I2O_BLOCK_REQ_MEMPOOL_SIZE
,
1160 i2o_blk_req_pool
.slab
);
1161 if (!i2o_blk_req_pool
.pool
) {
1162 osm_err("can't init request mempool\n");
1167 /* Register the block device interfaces */
1168 rc
= register_blkdev(I2O_MAJOR
, "i2o_block");
1170 osm_err("unable to register block device\n");
1174 osm_info("registered device at major %d\n", I2O_MAJOR
);
1177 /* Register Block OSM into I2O core */
1178 rc
= i2o_driver_register(&i2o_block_driver
);
1180 osm_err("Could not register Block driver\n");
1181 goto unregister_blkdev
;
1187 unregister_blkdev(I2O_MAJOR
, "i2o_block");
1190 mempool_destroy(i2o_blk_req_pool
.pool
);
1193 kmem_cache_destroy(i2o_blk_req_pool
.slab
);
1200 * i2o_block_exit - Block OSM exit function
1202 * Unregisters Block OSM from I2O core, unregisters i2o_block block device
1203 * and frees the mempool and slab.
1205 static void __exit
i2o_block_exit(void)
1207 /* Unregister I2O Block OSM from I2O core */
1208 i2o_driver_unregister(&i2o_block_driver
);
1210 /* Unregister block device */
1211 unregister_blkdev(I2O_MAJOR
, "i2o_block");
1213 /* Free request mempool and slab */
1214 mempool_destroy(i2o_blk_req_pool
.pool
);
1215 kmem_cache_destroy(i2o_blk_req_pool
.slab
);
1218 MODULE_AUTHOR("Red Hat");
1219 MODULE_LICENSE("GPL");
1220 MODULE_DESCRIPTION(OSM_DESCRIPTION
);
1221 MODULE_VERSION(OSM_VERSION
);
1223 module_init(i2o_block_init
);
1224 module_exit(i2o_block_exit
);