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_issue_flush - device-flush interface for block-layer
153 * @queue: the request queue of the device which should be flushed
155 * @error_sector: error offset
157 * Helper function to provide flush functionality to block-layer.
159 * Returns 0 on success or negative error code on failure.
162 static int i2o_block_issue_flush(request_queue_t
* queue
, struct gendisk
*disk
,
163 sector_t
* error_sector
)
165 struct i2o_block_device
*i2o_blk_dev
= queue
->queuedata
;
168 if (likely(i2o_blk_dev
))
169 rc
= i2o_block_device_flush(i2o_blk_dev
->i2o_dev
);
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
179 * Load a media into drive. Identifier should be set to -1, because the
180 * spec does not support any other value.
182 * Returns 0 on success or negative error code on failure.
184 static int i2o_block_device_mount(struct i2o_device
*dev
, u32 media_id
)
186 struct i2o_message
*msg
;
188 msg
= i2o_msg_get_wait(dev
->iop
, I2O_TIMEOUT_MESSAGE_GET
);
192 msg
->u
.head
[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE
| SGL_OFFSET_0
);
194 cpu_to_le32(I2O_CMD_BLOCK_MMOUNT
<< 24 | HOST_TID
<< 12 | dev
->
196 msg
->body
[0] = cpu_to_le32(-1);
197 msg
->body
[1] = cpu_to_le32(0x00000000);
198 osm_debug("Mounting...\n");
200 return i2o_msg_post_wait(dev
->iop
, msg
, 2);
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
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.
211 * Returns 0 on success or negative error code on failure.
213 static int i2o_block_device_lock(struct i2o_device
*dev
, u32 media_id
)
215 struct i2o_message
*msg
;
217 msg
= i2o_msg_get_wait(dev
->iop
, I2O_TIMEOUT_MESSAGE_GET
);
218 if (IS_ERR(msg
) == I2O_QUEUE_EMPTY
)
221 msg
->u
.head
[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE
| SGL_OFFSET_0
);
223 cpu_to_le32(I2O_CMD_BLOCK_MLOCK
<< 24 | HOST_TID
<< 12 | dev
->
225 msg
->body
[0] = cpu_to_le32(-1);
226 osm_debug("Locking...\n");
228 return i2o_msg_post_wait(dev
->iop
, msg
, 2);
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
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.
239 * Returns 0 on success or negative error code on failure.
241 static int i2o_block_device_unlock(struct i2o_device
*dev
, u32 media_id
)
243 struct i2o_message
*msg
;
245 msg
= i2o_msg_get_wait(dev
->iop
, I2O_TIMEOUT_MESSAGE_GET
);
249 msg
->u
.head
[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE
| SGL_OFFSET_0
);
251 cpu_to_le32(I2O_CMD_BLOCK_MUNLOCK
<< 24 | HOST_TID
<< 12 | dev
->
253 msg
->body
[0] = cpu_to_le32(media_id
);
254 osm_debug("Unlocking...\n");
256 return i2o_msg_post_wait(dev
->iop
, msg
, 2);
260 * i2o_block_device_power - Power management for device dev
261 * @dev: I2O device which should receive the power management request
262 * @operation: Operation which should be send
264 * Send a power management request to the device dev.
266 * Returns 0 on success or negative error code on failure.
268 static int i2o_block_device_power(struct i2o_block_device
*dev
, u8 op
)
270 struct i2o_device
*i2o_dev
= dev
->i2o_dev
;
271 struct i2o_controller
*c
= i2o_dev
->iop
;
272 struct i2o_message
*msg
;
275 msg
= i2o_msg_get_wait(c
, I2O_TIMEOUT_MESSAGE_GET
);
279 msg
->u
.head
[0] = cpu_to_le32(FOUR_WORD_MSG_SIZE
| SGL_OFFSET_0
);
281 cpu_to_le32(I2O_CMD_BLOCK_POWER
<< 24 | HOST_TID
<< 12 | i2o_dev
->
283 msg
->body
[0] = cpu_to_le32(op
<< 24);
284 osm_debug("Power...\n");
286 rc
= i2o_msg_post_wait(c
, msg
, 60);
294 * i2o_block_request_alloc - Allocate an I2O block request struct
296 * Allocates an I2O block request struct and initialize the list.
298 * Returns a i2o_block_request pointer on success or negative error code
301 static inline struct i2o_block_request
*i2o_block_request_alloc(void)
303 struct i2o_block_request
*ireq
;
305 ireq
= mempool_alloc(i2o_blk_req_pool
.pool
, GFP_ATOMIC
);
307 return ERR_PTR(-ENOMEM
);
309 INIT_LIST_HEAD(&ireq
->queue
);
315 * i2o_block_request_free - Frees a I2O block request
316 * @ireq: I2O block request which should be freed
318 * Fres the allocated memory (give it back to the request mempool).
320 static inline void i2o_block_request_free(struct i2o_block_request
*ireq
)
322 mempool_free(ireq
, i2o_blk_req_pool
.pool
);
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
330 * Builds the SG list and map it to be accessable by the controller.
332 * Returns 0 on failure or 1 on success.
334 static inline int i2o_block_sglist_alloc(struct i2o_controller
*c
,
335 struct i2o_block_request
*ireq
,
339 enum dma_data_direction direction
;
341 ireq
->dev
= &c
->pdev
->dev
;
342 nents
= blk_rq_map_sg(ireq
->req
->q
, ireq
->req
, ireq
->sg_table
);
344 if (rq_data_dir(ireq
->req
) == READ
)
345 direction
= PCI_DMA_FROMDEVICE
;
347 direction
= PCI_DMA_TODEVICE
;
349 ireq
->sg_nents
= nents
;
351 return i2o_dma_map_sg(c
, ireq
->sg_table
, nents
, direction
, mptr
);
355 * i2o_block_sglist_free - Frees the SG list
356 * @ireq: I2O block request from which the SG should be freed
358 * Frees the SG list from the I2O block request.
360 static inline void i2o_block_sglist_free(struct i2o_block_request
*ireq
)
362 enum dma_data_direction direction
;
364 if (rq_data_dir(ireq
->req
) == READ
)
365 direction
= PCI_DMA_FROMDEVICE
;
367 direction
= PCI_DMA_TODEVICE
;
369 dma_unmap_sg(ireq
->dev
, ireq
->sg_table
, ireq
->sg_nents
, direction
);
373 * i2o_block_prep_req_fn - Allocates I2O block device specific struct
374 * @q: request queue for the request
375 * @req: the request to prepare
377 * Allocate the necessary i2o_block_request struct and connect it to
378 * the request. This is needed that we not loose the SG list later on.
380 * Returns BLKPREP_OK on success or BLKPREP_DEFER on failure.
382 static int i2o_block_prep_req_fn(struct request_queue
*q
, struct request
*req
)
384 struct i2o_block_device
*i2o_blk_dev
= q
->queuedata
;
385 struct i2o_block_request
*ireq
;
387 if (unlikely(!i2o_blk_dev
)) {
388 osm_err("block device already removed\n");
392 /* request is already processed by us, so return */
393 if (blk_special_request(req
)) {
394 osm_debug("REQ_SPECIAL already set!\n");
395 req
->cmd_flags
|= REQ_DONTPREP
;
399 /* connect the i2o_block_request to the request */
401 ireq
= i2o_block_request_alloc();
402 if (unlikely(IS_ERR(ireq
))) {
403 osm_debug("unable to allocate i2o_block_request!\n");
404 return BLKPREP_DEFER
;
407 ireq
->i2o_blk_dev
= i2o_blk_dev
;
413 /* do not come back here */
414 req
->cmd_type
= REQ_TYPE_SPECIAL
;
415 req
->cmd_flags
|= REQ_DONTPREP
;
421 * i2o_block_delayed_request_fn - delayed request queue function
422 * @work: the delayed request with the queue to start
424 * If the request queue is stopped for a disk, and there is no open
425 * request, a new event is created, which calls this function to start
426 * the queue after I2O_BLOCK_REQUEST_TIME. Otherwise the queue will never
429 static void i2o_block_delayed_request_fn(struct work_struct
*work
)
431 struct i2o_block_delayed_request
*dreq
=
432 container_of(work
, struct i2o_block_delayed_request
,
434 struct request_queue
*q
= dreq
->queue
;
437 spin_lock_irqsave(q
->queue_lock
, flags
);
439 spin_unlock_irqrestore(q
->queue_lock
, flags
);
444 * i2o_block_end_request - Post-processing of completed commands
445 * @req: request which should be completed
446 * @uptodate: 1 for success, 0 for I/O error, < 0 for specific error
447 * @nr_bytes: number of bytes to complete
449 * Mark the request as complete. The lock must not be held when entering.
452 static void i2o_block_end_request(struct request
*req
, int uptodate
,
455 struct i2o_block_request
*ireq
= req
->special
;
456 struct i2o_block_device
*dev
= ireq
->i2o_blk_dev
;
457 request_queue_t
*q
= req
->q
;
460 if (end_that_request_chunk(req
, uptodate
, nr_bytes
)) {
461 int leftover
= (req
->hard_nr_sectors
<< KERNEL_SECTOR_SHIFT
);
463 if (blk_pc_request(req
))
464 leftover
= req
->data_len
;
466 if (end_io_error(uptodate
))
467 end_that_request_chunk(req
, 0, leftover
);
470 add_disk_randomness(req
->rq_disk
);
472 spin_lock_irqsave(q
->queue_lock
, flags
);
474 end_that_request_last(req
, uptodate
);
477 dev
->open_queue_depth
--;
478 list_del(&ireq
->queue
);
483 spin_unlock_irqrestore(q
->queue_lock
, flags
);
485 i2o_block_sglist_free(ireq
);
486 i2o_block_request_free(ireq
);
490 * i2o_block_reply - Block OSM reply handler.
491 * @c: I2O controller from which the message arrives
492 * @m: message id of reply
493 * qmsg: the actuall I2O message reply
495 * This function gets all the message replies.
498 static int i2o_block_reply(struct i2o_controller
*c
, u32 m
,
499 struct i2o_message
*msg
)
504 req
= i2o_cntxt_list_get(c
, le32_to_cpu(msg
->u
.s
.tcntxt
));
505 if (unlikely(!req
)) {
506 osm_err("NULL reply received!\n");
511 * Lets see what is cooking. We stuffed the
512 * request in the context.
515 if ((le32_to_cpu(msg
->body
[0]) >> 24) != 0) {
516 u32 status
= le32_to_cpu(msg
->body
[0]);
518 * Device not ready means two things. One is that the
519 * the thing went offline (but not a removal media)
521 * The second is that you have a SuperTrak 100 and the
522 * firmware got constipated. Unlike standard i2o card
523 * setups the supertrak returns an error rather than
524 * blocking for the timeout in these cases.
526 * Don't stick a supertrak100 into cache aggressive modes
529 osm_err("TID %03x error status: 0x%02x, detailed status: "
530 "0x%04x\n", (le32_to_cpu(msg
->u
.head
[1]) >> 12 & 0xfff),
531 status
>> 24, status
& 0xffff);
538 i2o_block_end_request(req
, uptodate
, le32_to_cpu(msg
->body
[1]));
543 static void i2o_block_event(struct work_struct
*work
)
545 struct i2o_event
*evt
= container_of(work
, struct i2o_event
, work
);
546 osm_debug("event received\n");
551 * SCSI-CAM for ioctl geometry mapping
552 * Duplicated with SCSI - this should be moved into somewhere common
555 * LBA -> CHS mapping table taken from:
557 * "Incorporating the I2O Architecture into BIOS for Intel Architecture
560 * This is an I2O document that is only available to I2O members,
563 * From my understanding, this is how all the I2O cards do this
565 * Disk Size | Sectors | Heads | Cylinders
566 * ---------------+---------+-------+-------------------
567 * 1 < X <= 528M | 63 | 16 | X/(63 * 16 * 512)
568 * 528M < X <= 1G | 63 | 32 | X/(63 * 32 * 512)
569 * 1 < X <528M | 63 | 16 | X/(63 * 16 * 512)
570 * 1 < X <528M | 63 | 16 | X/(63 * 16 * 512)
573 #define BLOCK_SIZE_528M 1081344
574 #define BLOCK_SIZE_1G 2097152
575 #define BLOCK_SIZE_21G 4403200
576 #define BLOCK_SIZE_42G 8806400
577 #define BLOCK_SIZE_84G 17612800
579 static void i2o_block_biosparam(unsigned long capacity
, unsigned short *cyls
,
580 unsigned char *hds
, unsigned char *secs
)
582 unsigned long heads
, sectors
, cylinders
;
584 sectors
= 63L; /* Maximize sectors per track */
585 if (capacity
<= BLOCK_SIZE_528M
)
587 else if (capacity
<= BLOCK_SIZE_1G
)
589 else if (capacity
<= BLOCK_SIZE_21G
)
591 else if (capacity
<= BLOCK_SIZE_42G
)
596 cylinders
= (unsigned long)capacity
/ (heads
* sectors
);
598 *cyls
= (unsigned short)cylinders
; /* Stuff return values */
599 *secs
= (unsigned char)sectors
;
600 *hds
= (unsigned char)heads
;
604 * i2o_block_open - Open the block device
606 * Power up the device, mount and lock the media. This function is called,
607 * if the block device is opened for access.
609 * Returns 0 on success or negative error code on failure.
611 static int i2o_block_open(struct inode
*inode
, struct file
*file
)
613 struct i2o_block_device
*dev
= inode
->i_bdev
->bd_disk
->private_data
;
618 if (dev
->power
> 0x1f)
619 i2o_block_device_power(dev
, 0x02);
621 i2o_block_device_mount(dev
->i2o_dev
, -1);
623 i2o_block_device_lock(dev
->i2o_dev
, -1);
625 osm_debug("Ready.\n");
631 * i2o_block_release - Release the I2O block device
633 * Unlock and unmount the media, and power down the device. Gets called if
634 * the block device is closed.
636 * Returns 0 on success or negative error code on failure.
638 static int i2o_block_release(struct inode
*inode
, struct file
*file
)
640 struct gendisk
*disk
= inode
->i_bdev
->bd_disk
;
641 struct i2o_block_device
*dev
= disk
->private_data
;
645 * This is to deail with the case of an application
646 * opening a device and then the device dissapears while
647 * it's in use, and then the application tries to release
648 * it. ex: Unmounting a deleted RAID volume at reboot.
649 * If we send messages, it will just cause FAILs since
650 * the TID no longer exists.
655 i2o_block_device_flush(dev
->i2o_dev
);
657 i2o_block_device_unlock(dev
->i2o_dev
, -1);
659 if (dev
->flags
& (1 << 3 | 1 << 4)) /* Removable */
664 i2o_block_device_power(dev
, operation
);
669 static int i2o_block_getgeo(struct block_device
*bdev
, struct hd_geometry
*geo
)
671 i2o_block_biosparam(get_capacity(bdev
->bd_disk
),
672 &geo
->cylinders
, &geo
->heads
, &geo
->sectors
);
677 * i2o_block_ioctl - Issue device specific ioctl calls.
678 * @cmd: ioctl command
681 * Handles ioctl request for the block device.
683 * Return 0 on success or negative error on failure.
685 static int i2o_block_ioctl(struct inode
*inode
, struct file
*file
,
686 unsigned int cmd
, unsigned long arg
)
688 struct gendisk
*disk
= inode
->i_bdev
->bd_disk
;
689 struct i2o_block_device
*dev
= disk
->private_data
;
691 /* Anyone capable of this syscall can do *real bad* things */
693 if (!capable(CAP_SYS_ADMIN
))
698 return put_user(dev
->rcache
, (int __user
*)arg
);
700 return put_user(dev
->wcache
, (int __user
*)arg
);
702 if (arg
< 0 || arg
> CACHE_SMARTFETCH
)
708 && (arg
< CACHE_WRITETHROUGH
|| arg
> CACHE_SMARTBACK
))
717 * i2o_block_media_changed - Have we seen a media change?
718 * @disk: gendisk which should be verified
720 * Verifies if the media has changed.
722 * Returns 1 if the media was changed or 0 otherwise.
724 static int i2o_block_media_changed(struct gendisk
*disk
)
726 struct i2o_block_device
*p
= disk
->private_data
;
728 if (p
->media_change_flag
) {
729 p
->media_change_flag
= 0;
736 * i2o_block_transfer - Transfer a request to/from the I2O controller
737 * @req: the request which should be transfered
739 * This function converts the request into a I2O message. The necessary
740 * DMA buffers are allocated and after everything is setup post the message
741 * to the I2O controller. No cleanup is done by this function. It is done
742 * on the interrupt side when the reply arrives.
744 * Return 0 on success or negative error code on failure.
746 static int i2o_block_transfer(struct request
*req
)
748 struct i2o_block_device
*dev
= req
->rq_disk
->private_data
;
749 struct i2o_controller
*c
;
750 int tid
= dev
->i2o_dev
->lct_data
.tid
;
751 struct i2o_message
*msg
;
753 struct i2o_block_request
*ireq
= req
->special
;
755 u32 sgl_offset
= SGL_OFFSET_8
;
756 u32 ctl_flags
= 0x00000000;
760 if (unlikely(!dev
->i2o_dev
)) {
761 osm_err("transfer to removed drive\n");
766 c
= dev
->i2o_dev
->iop
;
768 msg
= i2o_msg_get(c
);
774 tcntxt
= i2o_cntxt_list_add(c
, req
);
780 msg
->u
.s
.icntxt
= cpu_to_le32(i2o_block_driver
.context
);
781 msg
->u
.s
.tcntxt
= cpu_to_le32(tcntxt
);
783 mptr
= &msg
->body
[0];
785 if (rq_data_dir(req
) == READ
) {
786 cmd
= I2O_CMD_BLOCK_READ
<< 24;
788 switch (dev
->rcache
) {
790 ctl_flags
= 0x201F0008;
793 case CACHE_SMARTFETCH
:
794 if (req
->nr_sectors
> 16)
795 ctl_flags
= 0x201F0008;
797 ctl_flags
= 0x001F0000;
804 cmd
= I2O_CMD_BLOCK_WRITE
<< 24;
806 switch (dev
->wcache
) {
807 case CACHE_WRITETHROUGH
:
808 ctl_flags
= 0x001F0008;
810 case CACHE_WRITEBACK
:
811 ctl_flags
= 0x001F0010;
813 case CACHE_SMARTBACK
:
814 if (req
->nr_sectors
> 16)
815 ctl_flags
= 0x001F0004;
817 ctl_flags
= 0x001F0010;
819 case CACHE_SMARTTHROUGH
:
820 if (req
->nr_sectors
> 16)
821 ctl_flags
= 0x001F0004;
823 ctl_flags
= 0x001F0010;
829 #ifdef CONFIG_I2O_EXT_ADAPTEC
833 u16 hwsec
= queue_hardsect_size(req
->q
) >> KERNEL_SECTOR_SHIFT
;
837 sgl_offset
= SGL_OFFSET_12
;
840 cpu_to_le32(I2O_CMD_PRIVATE
<< 24 | HOST_TID
<< 12 | tid
);
842 *mptr
++ = cpu_to_le32(I2O_VENDOR_DPT
<< 16 | I2O_CMD_SCSI_EXEC
);
843 *mptr
++ = cpu_to_le32(tid
);
848 * RETURN_SENSE_DATA_IN_REPLY_MESSAGE_FRAME
850 if (rq_data_dir(req
) == READ
) {
852 scsi_flags
= 0x60a0000a;
855 scsi_flags
= 0xa0a0000a;
858 *mptr
++ = cpu_to_le32(scsi_flags
);
860 *((u32
*) & cmd
[2]) = cpu_to_be32(req
->sector
* hwsec
);
861 *((u16
*) & cmd
[7]) = cpu_to_be16(req
->nr_sectors
* hwsec
);
863 memcpy(mptr
, cmd
, 10);
865 *mptr
++ = cpu_to_le32(req
->nr_sectors
<< KERNEL_SECTOR_SHIFT
);
869 msg
->u
.head
[1] = cpu_to_le32(cmd
| HOST_TID
<< 12 | tid
);
870 *mptr
++ = cpu_to_le32(ctl_flags
);
871 *mptr
++ = cpu_to_le32(req
->nr_sectors
<< KERNEL_SECTOR_SHIFT
);
873 cpu_to_le32((u32
) (req
->sector
<< KERNEL_SECTOR_SHIFT
));
875 cpu_to_le32(req
->sector
>> (32 - KERNEL_SECTOR_SHIFT
));
878 if (!i2o_block_sglist_alloc(c
, ireq
, &mptr
)) {
884 cpu_to_le32(I2O_MESSAGE_SIZE(mptr
- &msg
->u
.head
[0]) | sgl_offset
);
886 list_add_tail(&ireq
->queue
, &dev
->open_queue
);
887 dev
->open_queue_depth
++;
889 i2o_msg_post(c
, msg
);
894 i2o_cntxt_list_remove(c
, req
);
904 * i2o_block_request_fn - request queue handling function
905 * q: request queue from which the request could be fetched
907 * Takes the next request from the queue, transfers it and if no error
908 * occurs dequeue it from the queue. On arrival of the reply the message
909 * will be processed further. If an error occurs requeue the request.
911 static void i2o_block_request_fn(struct request_queue
*q
)
915 while (!blk_queue_plugged(q
)) {
916 req
= elv_next_request(q
);
920 if (blk_fs_request(req
)) {
921 struct i2o_block_delayed_request
*dreq
;
922 struct i2o_block_request
*ireq
= req
->special
;
923 unsigned int queue_depth
;
925 queue_depth
= ireq
->i2o_blk_dev
->open_queue_depth
;
927 if (queue_depth
< I2O_BLOCK_MAX_OPEN_REQUESTS
) {
928 if (!i2o_block_transfer(req
)) {
929 blkdev_dequeue_request(req
);
932 osm_info("transfer error\n");
938 /* stop the queue and retry later */
939 dreq
= kmalloc(sizeof(*dreq
), GFP_ATOMIC
);
944 INIT_DELAYED_WORK(&dreq
->work
,
945 i2o_block_delayed_request_fn
);
947 if (!queue_delayed_work(i2o_block_driver
.event_queue
,
949 I2O_BLOCK_RETRY_TIME
))
960 /* I2O Block device operations definition */
961 static struct block_device_operations i2o_block_fops
= {
962 .owner
= THIS_MODULE
,
963 .open
= i2o_block_open
,
964 .release
= i2o_block_release
,
965 .ioctl
= i2o_block_ioctl
,
966 .getgeo
= i2o_block_getgeo
,
967 .media_changed
= i2o_block_media_changed
971 * i2o_block_device_alloc - Allocate memory for a I2O Block device
973 * Allocate memory for the i2o_block_device struct, gendisk and request
974 * queue and initialize them as far as no additional information is needed.
976 * Returns a pointer to the allocated I2O Block device on succes or a
977 * negative error code on failure.
979 static struct i2o_block_device
*i2o_block_device_alloc(void)
981 struct i2o_block_device
*dev
;
983 struct request_queue
*queue
;
986 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
988 osm_err("Insufficient memory to allocate I2O Block disk.\n");
993 INIT_LIST_HEAD(&dev
->open_queue
);
994 spin_lock_init(&dev
->lock
);
995 dev
->rcache
= CACHE_PREFETCH
;
996 dev
->wcache
= CACHE_WRITEBACK
;
998 /* allocate a gendisk with 16 partitions */
1001 osm_err("Insufficient memory to allocate gendisk.\n");
1006 /* initialize the request queue */
1007 queue
= blk_init_queue(i2o_block_request_fn
, &dev
->lock
);
1009 osm_err("Insufficient memory to allocate request queue.\n");
1014 blk_queue_prep_rq(queue
, i2o_block_prep_req_fn
);
1015 blk_queue_issue_flush_fn(queue
, i2o_block_issue_flush
);
1017 gd
->major
= I2O_MAJOR
;
1019 gd
->fops
= &i2o_block_fops
;
1020 gd
->private_data
= dev
;
1037 * i2o_block_probe - verify if dev is a I2O Block device and install it
1038 * @dev: device to verify if it is a I2O Block device
1040 * We only verify if the user_tid of the device is 0xfff and then install
1041 * the device. Otherwise it is used by some other device (e. g. RAID).
1043 * Returns 0 on success or negative error code on failure.
1045 static int i2o_block_probe(struct device
*dev
)
1047 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
1048 struct i2o_controller
*c
= i2o_dev
->iop
;
1049 struct i2o_block_device
*i2o_blk_dev
;
1051 struct request_queue
*queue
;
1052 static int unit
= 0;
1058 unsigned short max_sectors
;
1060 #ifdef CONFIG_I2O_EXT_ADAPTEC
1065 if (c
->limit_sectors
)
1066 max_sectors
= I2O_MAX_SECTORS_LIMITED
;
1068 max_sectors
= I2O_MAX_SECTORS
;
1070 /* skip devices which are used by IOP */
1071 if (i2o_dev
->lct_data
.user_tid
!= 0xfff) {
1072 osm_debug("skipping used device %03x\n", i2o_dev
->lct_data
.tid
);
1076 if (i2o_device_claim(i2o_dev
)) {
1077 osm_warn("Unable to claim device. Installation aborted\n");
1082 i2o_blk_dev
= i2o_block_device_alloc();
1083 if (IS_ERR(i2o_blk_dev
)) {
1084 osm_err("could not alloc a new I2O block device");
1085 rc
= PTR_ERR(i2o_blk_dev
);
1089 i2o_blk_dev
->i2o_dev
= i2o_dev
;
1090 dev_set_drvdata(dev
, i2o_blk_dev
);
1093 gd
= i2o_blk_dev
->gd
;
1094 gd
->first_minor
= unit
<< 4;
1095 sprintf(gd
->disk_name
, "i2o/hd%c", 'a' + unit
);
1096 gd
->driverfs_dev
= &i2o_dev
->device
;
1098 /* setup request queue */
1100 queue
->queuedata
= i2o_blk_dev
;
1102 blk_queue_max_phys_segments(queue
, I2O_MAX_PHYS_SEGMENTS
);
1103 blk_queue_max_sectors(queue
, max_sectors
);
1104 blk_queue_max_hw_segments(queue
, i2o_sg_tablesize(c
, body_size
));
1106 osm_debug("max sectors = %d\n", queue
->max_phys_segments
);
1107 osm_debug("phys segments = %d\n", queue
->max_sectors
);
1108 osm_debug("max hw segments = %d\n", queue
->max_hw_segments
);
1111 * Ask for the current media data. If that isn't supported
1112 * then we ask for the device capacity data
1114 if (!i2o_parm_field_get(i2o_dev
, 0x0004, 1, &blocksize
, 4) ||
1115 !i2o_parm_field_get(i2o_dev
, 0x0000, 3, &blocksize
, 4)) {
1116 blk_queue_hardsect_size(queue
, le32_to_cpu(blocksize
));
1118 osm_warn("unable to get blocksize of %s\n", gd
->disk_name
);
1120 if (!i2o_parm_field_get(i2o_dev
, 0x0004, 0, &size
, 8) ||
1121 !i2o_parm_field_get(i2o_dev
, 0x0000, 4, &size
, 8)) {
1122 set_capacity(gd
, le64_to_cpu(size
) >> KERNEL_SECTOR_SHIFT
);
1124 osm_warn("could not get size of %s\n", gd
->disk_name
);
1126 if (!i2o_parm_field_get(i2o_dev
, 0x0000, 2, &power
, 2))
1127 i2o_blk_dev
->power
= power
;
1129 i2o_event_register(i2o_dev
, &i2o_block_driver
, 0, 0xffffffff);
1135 osm_info("device added (TID: %03x): %s\n", i2o_dev
->lct_data
.tid
,
1136 i2o_blk_dev
->gd
->disk_name
);
1141 i2o_device_claim_release(i2o_dev
);
1147 /* Block OSM driver struct */
1148 static struct i2o_driver i2o_block_driver
= {
1150 .event
= i2o_block_event
,
1151 .reply
= i2o_block_reply
,
1152 .classes
= i2o_block_class_id
,
1154 .probe
= i2o_block_probe
,
1155 .remove
= i2o_block_remove
,
1160 * i2o_block_init - Block OSM initialization function
1162 * Allocate the slab and mempool for request structs, registers i2o_block
1163 * block device and finally register the Block OSM in the I2O core.
1165 * Returns 0 on success or negative error code on failure.
1167 static int __init
i2o_block_init(void)
1172 printk(KERN_INFO OSM_DESCRIPTION
" v" OSM_VERSION
"\n");
1174 /* Allocate request mempool and slab */
1175 size
= sizeof(struct i2o_block_request
);
1176 i2o_blk_req_pool
.slab
= kmem_cache_create("i2o_block_req", size
, 0,
1177 SLAB_HWCACHE_ALIGN
, NULL
,
1179 if (!i2o_blk_req_pool
.slab
) {
1180 osm_err("can't init request slab\n");
1185 i2o_blk_req_pool
.pool
=
1186 mempool_create_slab_pool(I2O_BLOCK_REQ_MEMPOOL_SIZE
,
1187 i2o_blk_req_pool
.slab
);
1188 if (!i2o_blk_req_pool
.pool
) {
1189 osm_err("can't init request mempool\n");
1194 /* Register the block device interfaces */
1195 rc
= register_blkdev(I2O_MAJOR
, "i2o_block");
1197 osm_err("unable to register block device\n");
1201 osm_info("registered device at major %d\n", I2O_MAJOR
);
1204 /* Register Block OSM into I2O core */
1205 rc
= i2o_driver_register(&i2o_block_driver
);
1207 osm_err("Could not register Block driver\n");
1208 goto unregister_blkdev
;
1214 unregister_blkdev(I2O_MAJOR
, "i2o_block");
1217 mempool_destroy(i2o_blk_req_pool
.pool
);
1220 kmem_cache_destroy(i2o_blk_req_pool
.slab
);
1227 * i2o_block_exit - Block OSM exit function
1229 * Unregisters Block OSM from I2O core, unregisters i2o_block block device
1230 * and frees the mempool and slab.
1232 static void __exit
i2o_block_exit(void)
1234 /* Unregister I2O Block OSM from I2O core */
1235 i2o_driver_unregister(&i2o_block_driver
);
1237 /* Unregister block device */
1238 unregister_blkdev(I2O_MAJOR
, "i2o_block");
1240 /* Free request mempool and slab */
1241 mempool_destroy(i2o_blk_req_pool
.pool
);
1242 kmem_cache_destroy(i2o_blk_req_pool
.slab
);
1245 MODULE_AUTHOR("Red Hat");
1246 MODULE_LICENSE("GPL");
1247 MODULE_DESCRIPTION(OSM_DESCRIPTION
);
1248 MODULE_VERSION(OSM_VERSION
);
1250 module_init(i2o_block_init
);
1251 module_exit(i2o_block_exit
);