2 * This program is free software; you can redistribute it and/or modify it
3 * under the terms of the GNU General Public License as published by the
4 * Free Software Foundation; either version 2, or (at your option) any
7 * This program is distributed in the hope that it will be useful, but
8 * WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
10 * General Public License for more details.
12 * For the avoidance of doubt the "preferred form" of this code is one which
13 * is in an open non patent encumbered format. Where cryptographic key signing
14 * forms part of the process of creating an executable the information
15 * including keys needed to generate an equivalently functional executable
16 * are deemed to be part of the source code.
18 * Complications for I2O scsi
20 * o Each (bus,lun) is a logical device in I2O. We keep a map
21 * table. We spoof failed selection for unmapped units
22 * o Request sense buffers can come back for free.
23 * o Scatter gather is a bit dynamic. We have to investigate at
25 * o Some of our resources are dynamically shared. The i2o core
26 * needs a message reservation protocol to avoid swap v net
27 * deadlocking. We need to back off queue requests.
29 * In general the firmware wants to help. Where its help isn't performance
30 * useful we just ignore the aid. Its not worth the code in truth.
34 * Scatter gather now works
35 * Markus Lidel <Markus.Lidel@shadowconnect.com>:
36 * Minor fixes for 2.6.
40 * Fix the resource management problems.
43 #include <linux/module.h>
44 #include <linux/kernel.h>
45 #include <linux/types.h>
46 #include <linux/string.h>
47 #include <linux/ioport.h>
48 #include <linux/jiffies.h>
49 #include <linux/interrupt.h>
50 #include <linux/timer.h>
51 #include <linux/delay.h>
52 #include <linux/proc_fs.h>
53 #include <linux/prefetch.h>
54 #include <linux/pci.h>
55 #include <linux/blkdev.h>
56 #include <linux/i2o.h>
57 #include <linux/scatterlist.h>
60 #include <asm/system.h>
62 #include <asm/atomic.h>
64 #include <scsi/scsi.h>
65 #include <scsi/scsi_host.h>
66 #include <scsi/scsi_device.h>
67 #include <scsi/scsi_cmnd.h>
68 #include <scsi/scsi_request.h>
70 #include <scsi/sg_request.h>
72 #define OSM_NAME "scsi-osm"
73 #define OSM_VERSION "1.316"
74 #define OSM_DESCRIPTION "I2O SCSI Peripheral OSM"
76 static struct i2o_driver i2o_scsi_driver
;
78 static unsigned int i2o_scsi_max_id
= 16;
79 static unsigned int i2o_scsi_max_lun
= 255;
81 struct i2o_scsi_host
{
82 struct Scsi_Host
*scsi_host
; /* pointer to the SCSI host */
83 struct i2o_controller
*iop
; /* pointer to the I2O controller */
84 unsigned int lun
; /* lun's used for block devices */
85 struct i2o_device
*channel
[0]; /* channel->i2o_dev mapping table */
88 static struct scsi_host_template i2o_scsi_host_template
;
90 #define I2O_SCSI_CAN_QUEUE 4
92 /* SCSI OSM class handling definition */
93 static struct i2o_class_id i2o_scsi_class_id
[] = {
94 {I2O_CLASS_SCSI_PERIPHERAL
},
98 static struct i2o_scsi_host
*i2o_scsi_host_alloc(struct i2o_controller
*c
)
100 struct i2o_scsi_host
*i2o_shost
;
101 struct i2o_device
*i2o_dev
;
102 struct Scsi_Host
*scsi_host
;
109 #ifdef CONFIG_I2O_EXT_ADAPTEC
114 list_for_each_entry(i2o_dev
, &c
->devices
, list
)
115 if (i2o_dev
->lct_data
.class_id
== I2O_CLASS_BUS_ADAPTER
) {
116 if (!i2o_parm_field_get(i2o_dev
, 0x0000, 0, &type
, 1)
117 && (type
== 0x01)) /* SCSI bus */
122 osm_warn("no channels found on %s\n", c
->name
);
123 return ERR_PTR(-EFAULT
);
126 size
= max_channel
* sizeof(struct i2o_device
*)
127 + sizeof(struct i2o_scsi_host
);
129 scsi_host
= scsi_host_alloc(&i2o_scsi_host_template
, size
);
131 osm_warn("Could not allocate SCSI host\n");
132 return ERR_PTR(-ENOMEM
);
135 scsi_host
->max_channel
= max_channel
- 1;
136 scsi_host
->max_id
= i2o_scsi_max_id
;
137 scsi_host
->max_lun
= i2o_scsi_max_lun
;
138 scsi_host
->this_id
= c
->unit
;
139 scsi_host
->sg_tablesize
= i2o_sg_tablesize(c
, body_size
);
141 i2o_shost
= (struct i2o_scsi_host
*)scsi_host
->hostdata
;
142 i2o_shost
->scsi_host
= scsi_host
;
147 list_for_each_entry(i2o_dev
, &c
->devices
, list
)
148 if (i2o_dev
->lct_data
.class_id
== I2O_CLASS_BUS_ADAPTER
) {
149 if (!i2o_parm_field_get(i2o_dev
, 0x0000, 0, &type
, 1)
150 && (type
== 0x01)) /* only SCSI bus */
151 i2o_shost
->channel
[i
++] = i2o_dev
;
153 if (i
>= max_channel
)
161 * i2o_scsi_get_host - Get an I2O SCSI host
162 * @c: I2O controller to for which to get the SCSI host
164 * If the I2O controller already exists as SCSI host, the SCSI host
165 * is returned, otherwise the I2O controller is added to the SCSI
168 * Returns pointer to the I2O SCSI host on success or NULL on failure.
170 static struct i2o_scsi_host
*i2o_scsi_get_host(struct i2o_controller
*c
)
172 return c
->driver_data
[i2o_scsi_driver
.context
];
176 * i2o_scsi_remove - Remove I2O device from SCSI core
177 * @dev: device which should be removed
179 * Removes the I2O device from the SCSI core again.
181 * Returns 0 on success.
183 static int i2o_scsi_remove(struct device
*dev
)
185 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
186 struct i2o_controller
*c
= i2o_dev
->iop
;
187 struct i2o_scsi_host
*i2o_shost
;
188 struct scsi_device
*scsi_dev
;
190 osm_info("device removed (TID: %03x)\n", i2o_dev
->lct_data
.tid
);
192 i2o_shost
= i2o_scsi_get_host(c
);
194 shost_for_each_device(scsi_dev
, i2o_shost
->scsi_host
)
195 if (scsi_dev
->hostdata
== i2o_dev
) {
196 sysfs_remove_link(&i2o_dev
->device
.kobj
, "scsi");
197 scsi_remove_device(scsi_dev
);
198 scsi_device_put(scsi_dev
);
206 * i2o_scsi_probe - verify if dev is a I2O SCSI device and install it
207 * @dev: device to verify if it is a I2O SCSI device
209 * Retrieve channel, id and lun for I2O device. If everthing goes well
210 * register the I2O device as SCSI device on the I2O SCSI controller.
212 * Returns 0 on success or negative error code on failure.
214 static int i2o_scsi_probe(struct device
*dev
)
216 struct i2o_device
*i2o_dev
= to_i2o_device(dev
);
217 struct i2o_controller
*c
= i2o_dev
->iop
;
218 struct i2o_scsi_host
*i2o_shost
;
219 struct Scsi_Host
*scsi_host
;
220 struct i2o_device
*parent
;
221 struct scsi_device
*scsi_dev
;
227 i2o_shost
= i2o_scsi_get_host(c
);
231 scsi_host
= i2o_shost
->scsi_host
;
233 switch (i2o_dev
->lct_data
.class_id
) {
234 case I2O_CLASS_RANDOM_BLOCK_STORAGE
:
235 case I2O_CLASS_EXECUTIVE
:
236 #ifdef CONFIG_I2O_EXT_ADAPTEC
239 struct i2o_device
*d
= i2o_shost
->channel
[0];
241 if (!i2o_parm_field_get(d
, 0x0000, 0, &type
, 1)
242 && (type
== 0x01)) /* SCSI bus */
243 if (!i2o_parm_field_get(d
, 0x0200, 4, &id
, 4)) {
245 if (i2o_dev
->lct_data
.class_id
==
246 I2O_CLASS_RANDOM_BLOCK_STORAGE
)
248 cpu_to_le64(i2o_shost
->
257 case I2O_CLASS_SCSI_PERIPHERAL
:
258 if (i2o_parm_field_get(i2o_dev
, 0x0000, 3, &id
, 4))
261 if (i2o_parm_field_get(i2o_dev
, 0x0000, 4, &lun
, 8))
264 parent
= i2o_iop_find_device(c
, i2o_dev
->lct_data
.parent_tid
);
266 osm_warn("can not find parent of device %03x\n",
267 i2o_dev
->lct_data
.tid
);
271 for (i
= 0; i
<= i2o_shost
->scsi_host
->max_channel
; i
++)
272 if (i2o_shost
->channel
[i
] == parent
)
281 osm_warn("can not find channel of device %03x\n",
282 i2o_dev
->lct_data
.tid
);
286 if (le32_to_cpu(id
) >= scsi_host
->max_id
) {
287 osm_warn("SCSI device id (%d) >= max_id of I2O host (%d)",
288 le32_to_cpu(id
), scsi_host
->max_id
);
292 if (le64_to_cpu(lun
) >= scsi_host
->max_lun
) {
293 osm_warn("SCSI device lun (%lu) >= max_lun of I2O host (%d)",
294 (long unsigned int)le64_to_cpu(lun
),
300 __scsi_add_device(i2o_shost
->scsi_host
, channel
, le32_to_cpu(id
),
301 le64_to_cpu(lun
), i2o_dev
);
303 if (IS_ERR(scsi_dev
)) {
304 osm_warn("can not add SCSI device %03x\n",
305 i2o_dev
->lct_data
.tid
);
306 return PTR_ERR(scsi_dev
);
309 sysfs_create_link(&i2o_dev
->device
.kobj
, &scsi_dev
->sdev_gendev
.kobj
,
312 osm_info("device added (TID: %03x) channel: %d, id: %d, lun: %ld\n",
313 i2o_dev
->lct_data
.tid
, channel
, le32_to_cpu(id
),
314 (long unsigned int)le64_to_cpu(lun
));
319 static const char *i2o_scsi_info(struct Scsi_Host
*SChost
)
321 struct i2o_scsi_host
*hostdata
;
322 hostdata
= (struct i2o_scsi_host
*)SChost
->hostdata
;
323 return hostdata
->iop
->name
;
327 * i2o_scsi_reply - SCSI OSM message reply handler
328 * @c: controller issuing the reply
329 * @m: message id for flushing
330 * @msg: the message from the controller
332 * Process reply messages (interrupts in normal scsi controller think).
333 * We can get a variety of messages to process. The normal path is
334 * scsi command completions. We must also deal with IOP failures,
335 * the reply to a bus reset and the reply to a LUN query.
337 * Returns 0 on success and if the reply should not be flushed or > 0
338 * on success and if the reply should be flushed. Returns negative error
339 * code on failure and if the reply should be flushed.
341 static int i2o_scsi_reply(struct i2o_controller
*c
, u32 m
,
342 struct i2o_message
*msg
)
344 struct scsi_cmnd
*cmd
;
348 cmd
= i2o_cntxt_list_get(c
, le32_to_cpu(msg
->u
.s
.tcntxt
));
349 if (unlikely(!cmd
)) {
350 osm_err("NULL reply received!\n");
355 * Low byte is device status, next is adapter status,
356 * (then one byte reserved), then request status.
358 error
= le32_to_cpu(msg
->body
[0]);
360 osm_debug("Completed %ld\n", cmd
->serial_number
);
362 cmd
->result
= error
& 0xff;
364 * if DeviceStatus is not SCSI_SUCCESS copy over the sense data and let
365 * the SCSI layer handle the error
368 memcpy(cmd
->sense_buffer
, &msg
->body
[3],
369 min(sizeof(cmd
->sense_buffer
), (size_t) 40));
371 /* only output error code if AdapterStatus is not HBA_SUCCESS */
372 if ((error
>> 8) & 0xff)
373 osm_err("SCSI error %08x\n", error
);
377 dma_unmap_sg(dev
, cmd
->request_buffer
, cmd
->use_sg
,
378 cmd
->sc_data_direction
);
379 else if (cmd
->SCp
.dma_handle
)
380 dma_unmap_single(dev
, cmd
->SCp
.dma_handle
, cmd
->request_bufflen
,
381 cmd
->sc_data_direction
);
389 * i2o_scsi_notify_device_add - Retrieve notifications of added devices
390 * @i2o_dev: the I2O device which was added
392 * If a I2O device is added we catch the notification, because I2O classes
393 * other then SCSI peripheral will not be received through
396 static void i2o_scsi_notify_device_add(struct i2o_device
*i2o_dev
)
398 switch (i2o_dev
->lct_data
.class_id
) {
399 case I2O_CLASS_EXECUTIVE
:
400 case I2O_CLASS_RANDOM_BLOCK_STORAGE
:
401 i2o_scsi_probe(&i2o_dev
->device
);
410 * i2o_scsi_notify_device_remove - Retrieve notifications of removed
412 * @i2o_dev: the I2O device which was removed
414 * If a I2O device is removed, we catch the notification to remove the
415 * corresponding SCSI device.
417 static void i2o_scsi_notify_device_remove(struct i2o_device
*i2o_dev
)
419 switch (i2o_dev
->lct_data
.class_id
) {
420 case I2O_CLASS_EXECUTIVE
:
421 case I2O_CLASS_RANDOM_BLOCK_STORAGE
:
422 i2o_scsi_remove(&i2o_dev
->device
);
431 * i2o_scsi_notify_controller_add - Retrieve notifications of added
433 * @c: the controller which was added
435 * If a I2O controller is added, we catch the notification to add a
436 * corresponding Scsi_Host.
438 static void i2o_scsi_notify_controller_add(struct i2o_controller
*c
)
440 struct i2o_scsi_host
*i2o_shost
;
443 i2o_shost
= i2o_scsi_host_alloc(c
);
444 if (IS_ERR(i2o_shost
)) {
445 osm_err("Could not initialize SCSI host\n");
449 rc
= scsi_add_host(i2o_shost
->scsi_host
, &c
->device
);
451 osm_err("Could not add SCSI host\n");
452 scsi_host_put(i2o_shost
->scsi_host
);
456 c
->driver_data
[i2o_scsi_driver
.context
] = i2o_shost
;
458 osm_debug("new I2O SCSI host added\n");
462 * i2o_scsi_notify_controller_remove - Retrieve notifications of removed
464 * @c: the controller which was removed
466 * If a I2O controller is removed, we catch the notification to remove the
467 * corresponding Scsi_Host.
469 static void i2o_scsi_notify_controller_remove(struct i2o_controller
*c
)
471 struct i2o_scsi_host
*i2o_shost
;
472 i2o_shost
= i2o_scsi_get_host(c
);
476 c
->driver_data
[i2o_scsi_driver
.context
] = NULL
;
478 scsi_remove_host(i2o_shost
->scsi_host
);
479 scsi_host_put(i2o_shost
->scsi_host
);
480 osm_debug("I2O SCSI host removed\n");
483 /* SCSI OSM driver struct */
484 static struct i2o_driver i2o_scsi_driver
= {
486 .reply
= i2o_scsi_reply
,
487 .classes
= i2o_scsi_class_id
,
488 .notify_device_add
= i2o_scsi_notify_device_add
,
489 .notify_device_remove
= i2o_scsi_notify_device_remove
,
490 .notify_controller_add
= i2o_scsi_notify_controller_add
,
491 .notify_controller_remove
= i2o_scsi_notify_controller_remove
,
493 .probe
= i2o_scsi_probe
,
494 .remove
= i2o_scsi_remove
,
499 * i2o_scsi_queuecommand - queue a SCSI command
500 * @SCpnt: scsi command pointer
501 * @done: callback for completion
503 * Issue a scsi command asynchronously. Return 0 on success or 1 if
504 * we hit an error (normally message queue congestion). The only
505 * minor complication here is that I2O deals with the device addressing
506 * so we have to map the bus/dev/lun back to an I2O handle as well
507 * as faking absent devices ourself.
509 * Locks: takes the controller lock on error path only
512 static int i2o_scsi_queuecommand(struct scsi_cmnd
*SCpnt
,
513 void (*done
) (struct scsi_cmnd
*))
515 struct i2o_controller
*c
;
516 struct i2o_device
*i2o_dev
;
518 struct i2o_message
*msg
;
522 * RETURN_SENSE_DATA_IN_REPLY_MESSAGE_FRAME
524 u32 scsi_flags
= 0x20a00000;
527 u32 cmd
= I2O_CMD_SCSI_EXEC
<< 24;
531 * Do the incoming paperwork
533 i2o_dev
= SCpnt
->device
->hostdata
;
536 SCpnt
->scsi_done
= done
;
538 if (unlikely(!i2o_dev
)) {
539 osm_warn("no I2O device in request\n");
540 SCpnt
->result
= DID_NO_CONNECT
<< 16;
545 tid
= i2o_dev
->lct_data
.tid
;
547 osm_debug("qcmd: Tid = %03x\n", tid
);
548 osm_debug("Real scsi messages.\n");
551 * Put together a scsi execscb message
553 switch (SCpnt
->sc_data_direction
) {
556 sgl_offset
= SGL_OFFSET_0
;
559 case PCI_DMA_TODEVICE
:
560 /* DATA OUT (iop-->dev) */
561 scsi_flags
|= 0x80000000;
562 sgl_offset
= SGL_OFFSET_10
;
565 case PCI_DMA_FROMDEVICE
:
566 /* DATA IN (iop<--dev) */
567 scsi_flags
|= 0x40000000;
568 sgl_offset
= SGL_OFFSET_10
;
572 /* Unknown - kill the command */
573 SCpnt
->result
= DID_NO_CONNECT
<< 16;
579 * Obtain an I2O message. If there are none free then
580 * throw it back to the scsi layer
583 msg
= i2o_msg_get(c
);
585 rc
= SCSI_MLQUEUE_HOST_BUSY
;
589 mptr
= &msg
->body
[0];
591 #ifdef CONFIG_I2O_EXT_ADAPTEC
595 if (SCpnt
->sc_request
&& SCpnt
->sc_request
->upper_private_data
) {
596 i2o_sg_io_hdr_t __user
*usr_ptr
=
597 ((Sg_request
*) (SCpnt
->sc_request
->
598 upper_private_data
))->header
.
602 get_user(adpt_flags
, &usr_ptr
->flags
);
605 switch (i2o_dev
->lct_data
.class_id
) {
606 case I2O_CLASS_EXECUTIVE
:
607 case I2O_CLASS_RANDOM_BLOCK_STORAGE
:
608 /* interpret flag has to be set for executive */
609 adpt_flags
^= I2O_DPT_SG_FLAG_INTERPRET
;
617 * for Adaptec controllers we use the PRIVATE command, because
618 * the normal SCSI EXEC doesn't support all SCSI commands on
619 * all controllers (for example READ CAPACITY).
621 if (sgl_offset
== SGL_OFFSET_10
)
622 sgl_offset
= SGL_OFFSET_12
;
623 cmd
= I2O_CMD_PRIVATE
<< 24;
624 *mptr
++ = cpu_to_le32(I2O_VENDOR_DPT
<< 16 | I2O_CMD_SCSI_EXEC
);
625 *mptr
++ = cpu_to_le32(adpt_flags
| tid
);
629 msg
->u
.head
[1] = cpu_to_le32(cmd
| HOST_TID
<< 12 | tid
);
630 msg
->u
.s
.icntxt
= cpu_to_le32(i2o_scsi_driver
.context
);
632 /* We want the SCSI control block back */
633 msg
->u
.s
.tcntxt
= cpu_to_le32(i2o_cntxt_list_add(c
, SCpnt
));
637 * Intermittant observations of msg frame word data corruption
638 * observed on msg[4] after:
639 * WRITE, READ-MODIFY-WRITE
640 * operations. 19990606 -sralston
642 * (Hence we build this word via tag. Its good practice anyway
643 * we don't want fetches over PCI needlessly)
646 /* Attach tags to the devices */
648 if(SCpnt->device->tagged_supported) {
649 if(SCpnt->tag == HEAD_OF_QUEUE_TAG)
650 scsi_flags |= 0x01000000;
651 else if(SCpnt->tag == ORDERED_QUEUE_TAG)
652 scsi_flags |= 0x01800000;
656 *mptr
++ = cpu_to_le32(scsi_flags
| SCpnt
->cmd_len
);
658 /* Write SCSI command into the message - always 16 byte block */
659 memcpy(mptr
, SCpnt
->cmnd
, 16);
662 if (sgl_offset
!= SGL_OFFSET_0
) {
663 /* write size of data addressed by SGL */
664 *mptr
++ = cpu_to_le32(SCpnt
->request_bufflen
);
666 /* Now fill in the SGList and command */
668 if (!i2o_dma_map_sg(c
, SCpnt
->request_buffer
,
670 SCpnt
->sc_data_direction
, &mptr
))
673 SCpnt
->SCp
.dma_handle
=
674 i2o_dma_map_single(c
, SCpnt
->request_buffer
,
675 SCpnt
->request_bufflen
,
676 SCpnt
->sc_data_direction
, &mptr
);
677 if (dma_mapping_error(SCpnt
->SCp
.dma_handle
))
682 /* Stick the headers on */
684 cpu_to_le32(I2O_MESSAGE_SIZE(mptr
- &msg
->u
.head
[0]) | sgl_offset
);
686 /* Queue the message */
687 i2o_msg_post(c
, msg
);
689 osm_debug("Issued %ld\n", SCpnt
->serial_number
);
702 * i2o_scsi_abort - abort a running command
703 * @SCpnt: command to abort
705 * Ask the I2O controller to abort a command. This is an asynchrnous
706 * process and our callback handler will see the command complete with an
707 * aborted message if it succeeds.
709 * Returns 0 if the command is successfully aborted or negative error code
712 static int i2o_scsi_abort(struct scsi_cmnd
*SCpnt
)
714 struct i2o_device
*i2o_dev
;
715 struct i2o_controller
*c
;
716 struct i2o_message
*msg
;
720 osm_warn("Aborting command block.\n");
722 i2o_dev
= SCpnt
->device
->hostdata
;
724 tid
= i2o_dev
->lct_data
.tid
;
726 msg
= i2o_msg_get_wait(c
, I2O_TIMEOUT_MESSAGE_GET
);
728 return SCSI_MLQUEUE_HOST_BUSY
;
730 msg
->u
.head
[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE
| SGL_OFFSET_0
);
732 cpu_to_le32(I2O_CMD_SCSI_ABORT
<< 24 | HOST_TID
<< 12 | tid
);
733 msg
->body
[0] = cpu_to_le32(i2o_cntxt_list_get_ptr(c
, SCpnt
));
735 if (!i2o_msg_post_wait(c
, msg
, I2O_TIMEOUT_SCSI_SCB_ABORT
))
742 * i2o_scsi_bios_param - Invent disk geometry
744 * @dev: block layer device
745 * @capacity: size in sectors
746 * @ip: geometry array
748 * This is anyones guess quite frankly. We use the same rules everyone
749 * else appears to and hope. It seems to work.
752 static int i2o_scsi_bios_param(struct scsi_device
*sdev
,
753 struct block_device
*dev
, sector_t capacity
,
759 ip
[0] = 64; /* heads */
760 ip
[1] = 32; /* sectors */
761 if ((ip
[2] = size
>> 11) > 1024) { /* cylinders, test for big disk */
762 ip
[0] = 255; /* heads */
763 ip
[1] = 63; /* sectors */
764 ip
[2] = size
/ (255 * 63); /* cylinders */
769 static struct scsi_host_template i2o_scsi_host_template
= {
770 .proc_name
= OSM_NAME
,
771 .name
= OSM_DESCRIPTION
,
772 .info
= i2o_scsi_info
,
773 .queuecommand
= i2o_scsi_queuecommand
,
774 .eh_abort_handler
= i2o_scsi_abort
,
775 .bios_param
= i2o_scsi_bios_param
,
776 .can_queue
= I2O_SCSI_CAN_QUEUE
,
779 .use_clustering
= ENABLE_CLUSTERING
,
783 * i2o_scsi_init - SCSI OSM initialization function
785 * Register SCSI OSM into I2O core.
787 * Returns 0 on success or negative error code on failure.
789 static int __init
i2o_scsi_init(void)
793 printk(KERN_INFO OSM_DESCRIPTION
" v" OSM_VERSION
"\n");
795 /* Register SCSI OSM into I2O core */
796 rc
= i2o_driver_register(&i2o_scsi_driver
);
798 osm_err("Could not register SCSI driver\n");
806 * i2o_scsi_exit - SCSI OSM exit function
808 * Unregisters SCSI OSM from I2O core.
810 static void __exit
i2o_scsi_exit(void)
812 /* Unregister I2O SCSI OSM from I2O core */
813 i2o_driver_unregister(&i2o_scsi_driver
);
816 MODULE_AUTHOR("Red Hat Software");
817 MODULE_LICENSE("GPL");
818 MODULE_DESCRIPTION(OSM_DESCRIPTION
);
819 MODULE_VERSION(OSM_VERSION
);
821 module_init(i2o_scsi_init
);
822 module_exit(i2o_scsi_exit
);