2 * sbp2.c - SBP-2 protocol driver for IEEE-1394
4 * Copyright (C) 2000 James Goodwin, Filanet Corporation (www.filanet.com)
5 * jamesg@filanet.com (JSG)
7 * Copyright (C) 2003 Ben Collins <bcollins@debian.org>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software Foundation,
21 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27 * This driver implements the Serial Bus Protocol 2 (SBP-2) over IEEE-1394
28 * under Linux. The SBP-2 driver is implemented as an IEEE-1394 high-level
29 * driver. It also registers as a SCSI lower-level driver in order to accept
30 * SCSI commands for transport using SBP-2.
32 * You may access any attached SBP-2 storage devices as if they were SCSI
33 * devices (e.g. mount /dev/sda1, fdisk, mkfs, etc.).
37 * - Error Handling: SCSI aborts and bus reset requests are handled somewhat
38 * but the code needs additional debugging.
41 #include <linux/config.h>
42 #include <linux/kernel.h>
43 #include <linux/list.h>
44 #include <linux/string.h>
45 #include <linux/slab.h>
46 #include <linux/interrupt.h>
48 #include <linux/poll.h>
49 #include <linux/module.h>
50 #include <linux/moduleparam.h>
51 #include <linux/types.h>
52 #include <linux/delay.h>
53 #include <linux/sched.h>
54 #include <linux/blkdev.h>
55 #include <linux/smp_lock.h>
56 #include <linux/init.h>
57 #include <linux/pci.h>
59 #include <asm/current.h>
60 #include <asm/uaccess.h>
62 #include <asm/byteorder.h>
63 #include <asm/atomic.h>
64 #include <asm/system.h>
65 #include <asm/scatterlist.h>
67 #include <scsi/scsi.h>
68 #include <scsi/scsi_cmnd.h>
69 #include <scsi/scsi_dbg.h>
70 #include <scsi/scsi_device.h>
71 #include <scsi/scsi_host.h>
75 #include "ieee1394_types.h"
76 #include "ieee1394_core.h"
79 #include "highlevel.h"
80 #include "ieee1394_transactions.h"
83 static char version
[] __devinitdata
=
84 "$Rev: 1306 $ Ben Collins <bcollins@debian.org>";
87 * Module load parameter definitions
91 * Change max_speed on module load if you have a bad IEEE-1394
92 * controller that has trouble running 2KB packets at 400mb.
94 * NOTE: On certain OHCI parts I have seen short packets on async transmit
95 * (probably due to PCI latency/throughput issues with the part). You can
96 * bump down the speed if you are running into problems.
98 static int max_speed
= IEEE1394_SPEED_MAX
;
99 module_param(max_speed
, int, 0644);
100 MODULE_PARM_DESC(max_speed
, "Force max speed (3 = 800mb, 2 = 400mb, 1 = 200mb, 0 = 100mb)");
103 * Set serialize_io to 1 if you'd like only one scsi command sent
104 * down to us at a time (debugging). This might be necessary for very
105 * badly behaved sbp2 devices.
107 * TODO: Make this configurable per device.
109 static int serialize_io
= 1;
110 module_param(serialize_io
, int, 0444);
111 MODULE_PARM_DESC(serialize_io
, "Serialize I/O coming from scsi drivers (default = 1, faster = 0)");
114 * Bump up max_sectors if you'd like to support very large sized
115 * transfers. Please note that some older sbp2 bridge chips are broken for
116 * transfers greater or equal to 128KB. Default is a value of 255
117 * sectors, or just under 128KB (at 512 byte sector size). I can note that
118 * the Oxsemi sbp2 chipsets have no problems supporting very large
121 static int max_sectors
= SBP2_MAX_SECTORS
;
122 module_param(max_sectors
, int, 0444);
123 MODULE_PARM_DESC(max_sectors
, "Change max sectors per I/O supported (default = 255)");
126 * Exclusive login to sbp2 device? In most cases, the sbp2 driver should
127 * do an exclusive login, as it's generally unsafe to have two hosts
128 * talking to a single sbp2 device at the same time (filesystem coherency,
129 * etc.). If you're running an sbp2 device that supports multiple logins,
130 * and you're either running read-only filesystems or some sort of special
131 * filesystem supporting multiple hosts (one such filesystem is OpenGFS,
132 * see opengfs.sourceforge.net for more info), then set exclusive_login
133 * to zero. Note: The Oxsemi OXFW911 sbp2 chipset supports up to four
136 static int exclusive_login
= 1;
137 module_param(exclusive_login
, int, 0644);
138 MODULE_PARM_DESC(exclusive_login
, "Exclusive login to sbp2 device (default = 1)");
141 * SCSI inquiry hack for really badly behaved sbp2 devices. Turn this on
142 * if your sbp2 device is not properly handling the SCSI inquiry command.
143 * This hack makes the inquiry look more like a typical MS Windows
146 * If force_inquiry_hack=1 is required for your device to work,
147 * please submit the logged sbp2_firmware_revision value of this device to
148 * the linux1394-devel mailing list.
150 static int force_inquiry_hack
;
151 module_param(force_inquiry_hack
, int, 0444);
152 MODULE_PARM_DESC(force_inquiry_hack
, "Force SCSI inquiry hack (default = 0)");
155 * Export information about protocols/devices supported by this driver.
157 static struct ieee1394_device_id sbp2_id_table
[] = {
159 .match_flags
= IEEE1394_MATCH_SPECIFIER_ID
| IEEE1394_MATCH_VERSION
,
160 .specifier_id
= SBP2_UNIT_SPEC_ID_ENTRY
& 0xffffff,
161 .version
= SBP2_SW_VERSION_ENTRY
& 0xffffff},
165 MODULE_DEVICE_TABLE(ieee1394
, sbp2_id_table
);
168 * Debug levels, configured via kernel config, or enable here.
171 #define CONFIG_IEEE1394_SBP2_DEBUG 0
172 /* #define CONFIG_IEEE1394_SBP2_DEBUG_ORBS */
173 /* #define CONFIG_IEEE1394_SBP2_DEBUG_DMA */
174 /* #define CONFIG_IEEE1394_SBP2_DEBUG 1 */
175 /* #define CONFIG_IEEE1394_SBP2_DEBUG 2 */
176 /* #define CONFIG_IEEE1394_SBP2_PACKET_DUMP */
178 #ifdef CONFIG_IEEE1394_SBP2_DEBUG_ORBS
179 #define SBP2_ORB_DEBUG(fmt, args...) HPSB_ERR("sbp2(%s): "fmt, __FUNCTION__, ## args)
180 static u32 global_outstanding_command_orbs
= 0;
181 #define outstanding_orb_incr global_outstanding_command_orbs++
182 #define outstanding_orb_decr global_outstanding_command_orbs--
184 #define SBP2_ORB_DEBUG(fmt, args...)
185 #define outstanding_orb_incr
186 #define outstanding_orb_decr
189 #ifdef CONFIG_IEEE1394_SBP2_DEBUG_DMA
190 #define SBP2_DMA_ALLOC(fmt, args...) \
191 HPSB_ERR("sbp2(%s)alloc(%d): "fmt, __FUNCTION__, \
192 ++global_outstanding_dmas, ## args)
193 #define SBP2_DMA_FREE(fmt, args...) \
194 HPSB_ERR("sbp2(%s)free(%d): "fmt, __FUNCTION__, \
195 --global_outstanding_dmas, ## args)
196 static u32 global_outstanding_dmas
= 0;
198 #define SBP2_DMA_ALLOC(fmt, args...)
199 #define SBP2_DMA_FREE(fmt, args...)
202 #if CONFIG_IEEE1394_SBP2_DEBUG >= 2
203 #define SBP2_DEBUG(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args)
204 #define SBP2_INFO(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args)
205 #define SBP2_NOTICE(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args)
206 #define SBP2_WARN(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args)
207 #elif CONFIG_IEEE1394_SBP2_DEBUG == 1
208 #define SBP2_DEBUG(fmt, args...) HPSB_DEBUG("sbp2: "fmt, ## args)
209 #define SBP2_INFO(fmt, args...) HPSB_INFO("sbp2: "fmt, ## args)
210 #define SBP2_NOTICE(fmt, args...) HPSB_NOTICE("sbp2: "fmt, ## args)
211 #define SBP2_WARN(fmt, args...) HPSB_WARN("sbp2: "fmt, ## args)
213 #define SBP2_DEBUG(fmt, args...)
214 #define SBP2_INFO(fmt, args...) HPSB_INFO("sbp2: "fmt, ## args)
215 #define SBP2_NOTICE(fmt, args...) HPSB_NOTICE("sbp2: "fmt, ## args)
216 #define SBP2_WARN(fmt, args...) HPSB_WARN("sbp2: "fmt, ## args)
219 #define SBP2_ERR(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args)
225 static void sbp2scsi_complete_all_commands(struct scsi_id_instance_data
*scsi_id
,
228 static void sbp2scsi_complete_command(struct scsi_id_instance_data
*scsi_id
,
229 u32 scsi_status
, struct scsi_cmnd
*SCpnt
,
230 void (*done
)(struct scsi_cmnd
*));
232 static struct scsi_host_template scsi_driver_template
;
234 static const u8 sbp2_speedto_max_payload
[] = { 0x7, 0x8, 0x9, 0xA, 0xB, 0xC };
236 static void sbp2_host_reset(struct hpsb_host
*host
);
238 static int sbp2_probe(struct device
*dev
);
239 static int sbp2_remove(struct device
*dev
);
240 static int sbp2_update(struct unit_directory
*ud
);
242 static struct hpsb_highlevel sbp2_highlevel
= {
243 .name
= SBP2_DEVICE_NAME
,
244 .host_reset
= sbp2_host_reset
,
247 static struct hpsb_address_ops sbp2_ops
= {
248 .write
= sbp2_handle_status_write
251 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
252 static struct hpsb_address_ops sbp2_physdma_ops
= {
253 .read
= sbp2_handle_physdma_read
,
254 .write
= sbp2_handle_physdma_write
,
258 static struct hpsb_protocol_driver sbp2_driver
= {
259 .name
= "SBP2 Driver",
260 .id_table
= sbp2_id_table
,
261 .update
= sbp2_update
,
263 .name
= SBP2_DEVICE_NAME
,
264 .bus
= &ieee1394_bus_type
,
266 .remove
= sbp2_remove
,
271 /* List of device firmware's that require a forced 36 byte inquiry. */
272 static u32 sbp2_broken_inquiry_list
[] = {
273 0x00002800, /* Stefan Richter <richtest@bauwesen.tu-cottbus.de> */
274 /* DViCO Momobay CX-1 */
275 0x00000200 /* Andreas Plesch <plesch@fas.harvard.edu> */
276 /* QPS Fire DVDBurner */
279 #define NUM_BROKEN_INQUIRY_DEVS \
280 (sizeof(sbp2_broken_inquiry_list)/sizeof(*sbp2_broken_inquiry_list))
282 /**************************************
283 * General utility functions
284 **************************************/
288 * Converts a buffer from be32 to cpu byte ordering. Length is in bytes.
290 static __inline__
void sbp2util_be32_to_cpu_buffer(void *buffer
, int length
)
294 for (length
= (length
>> 2); length
--; )
295 temp
[length
] = be32_to_cpu(temp
[length
]);
301 * Converts a buffer from cpu to be32 byte ordering. Length is in bytes.
303 static __inline__
void sbp2util_cpu_to_be32_buffer(void *buffer
, int length
)
307 for (length
= (length
>> 2); length
--; )
308 temp
[length
] = cpu_to_be32(temp
[length
]);
312 #else /* BIG_ENDIAN */
313 /* Why waste the cpu cycles? */
314 #define sbp2util_be32_to_cpu_buffer(x,y)
315 #define sbp2util_cpu_to_be32_buffer(x,y)
318 #ifdef CONFIG_IEEE1394_SBP2_PACKET_DUMP
320 * Debug packet dump routine. Length is in bytes.
322 static void sbp2util_packet_dump(void *buffer
, int length
, char *dump_name
,
326 unsigned char *dump
= buffer
;
328 if (!dump
|| !length
|| !dump_name
)
332 printk("[%s, 0x%x]", dump_name
, dump_phys_addr
);
334 printk("[%s]", dump_name
);
335 for (i
= 0; i
< length
; i
++) {
344 printk("%02x ", (int)dump
[i
]);
351 #define sbp2util_packet_dump(w,x,y,z)
355 * Goofy routine that basically does a down_timeout function.
357 static int sbp2util_down_timeout(atomic_t
*done
, int timeout
)
361 for (i
= timeout
; (i
> 0 && atomic_read(done
) == 0); i
-= HZ
/10) {
362 if (msleep_interruptible(100)) /* 100ms */
365 return (i
> 0) ? 0 : 1;
368 /* Free's an allocated packet */
369 static void sbp2_free_packet(struct hpsb_packet
*packet
)
371 hpsb_free_tlabel(packet
);
372 hpsb_free_packet(packet
);
375 /* This is much like hpsb_node_write(), except it ignores the response
376 * subaction and returns immediately. Can be used from interrupts.
378 static int sbp2util_node_write_no_wait(struct node_entry
*ne
, u64 addr
,
379 quadlet_t
*buffer
, size_t length
)
381 struct hpsb_packet
*packet
;
383 packet
= hpsb_make_writepacket(ne
->host
, ne
->nodeid
,
384 addr
, buffer
, length
);
388 hpsb_set_packet_complete_task(packet
,
389 (void (*)(void *))sbp2_free_packet
,
392 hpsb_node_fill_packet(ne
, packet
);
394 if (hpsb_send_packet(packet
) < 0) {
395 sbp2_free_packet(packet
);
403 * This function is called to create a pool of command orbs used for
404 * command processing. It is called when a new sbp2 device is detected.
406 static int sbp2util_create_command_orb_pool(struct scsi_id_instance_data
*scsi_id
)
408 struct sbp2scsi_host_info
*hi
= scsi_id
->hi
;
410 unsigned long flags
, orbs
;
411 struct sbp2_command_info
*command
;
413 orbs
= serialize_io
? 2 : SBP2_MAX_CMDS
;
415 spin_lock_irqsave(&scsi_id
->sbp2_command_orb_lock
, flags
);
416 for (i
= 0; i
< orbs
; i
++) {
417 command
= (struct sbp2_command_info
*)
418 kmalloc(sizeof(struct sbp2_command_info
), GFP_ATOMIC
);
420 spin_unlock_irqrestore(&scsi_id
->sbp2_command_orb_lock
,
424 memset(command
, '\0', sizeof(struct sbp2_command_info
));
425 command
->command_orb_dma
=
426 pci_map_single(hi
->host
->pdev
, &command
->command_orb
,
427 sizeof(struct sbp2_command_orb
),
428 PCI_DMA_BIDIRECTIONAL
);
429 SBP2_DMA_ALLOC("single command orb DMA");
431 pci_map_single(hi
->host
->pdev
,
432 &command
->scatter_gather_element
,
433 sizeof(command
->scatter_gather_element
),
434 PCI_DMA_BIDIRECTIONAL
);
435 SBP2_DMA_ALLOC("scatter_gather_element");
436 INIT_LIST_HEAD(&command
->list
);
437 list_add_tail(&command
->list
, &scsi_id
->sbp2_command_orb_completed
);
439 spin_unlock_irqrestore(&scsi_id
->sbp2_command_orb_lock
, flags
);
444 * This function is called to delete a pool of command orbs.
446 static void sbp2util_remove_command_orb_pool(struct scsi_id_instance_data
*scsi_id
)
448 struct hpsb_host
*host
= scsi_id
->hi
->host
;
449 struct list_head
*lh
, *next
;
450 struct sbp2_command_info
*command
;
453 spin_lock_irqsave(&scsi_id
->sbp2_command_orb_lock
, flags
);
454 if (!list_empty(&scsi_id
->sbp2_command_orb_completed
)) {
455 list_for_each_safe(lh
, next
, &scsi_id
->sbp2_command_orb_completed
) {
456 command
= list_entry(lh
, struct sbp2_command_info
, list
);
458 /* Release our generic DMA's */
459 pci_unmap_single(host
->pdev
, command
->command_orb_dma
,
460 sizeof(struct sbp2_command_orb
),
461 PCI_DMA_BIDIRECTIONAL
);
462 SBP2_DMA_FREE("single command orb DMA");
463 pci_unmap_single(host
->pdev
, command
->sge_dma
,
464 sizeof(command
->scatter_gather_element
),
465 PCI_DMA_BIDIRECTIONAL
);
466 SBP2_DMA_FREE("scatter_gather_element");
471 spin_unlock_irqrestore(&scsi_id
->sbp2_command_orb_lock
, flags
);
476 * This function finds the sbp2_command for a given outstanding command
477 * orb.Only looks at the inuse list.
479 static struct sbp2_command_info
*sbp2util_find_command_for_orb(
480 struct scsi_id_instance_data
*scsi_id
, dma_addr_t orb
)
482 struct sbp2_command_info
*command
;
485 spin_lock_irqsave(&scsi_id
->sbp2_command_orb_lock
, flags
);
486 if (!list_empty(&scsi_id
->sbp2_command_orb_inuse
)) {
487 list_for_each_entry(command
, &scsi_id
->sbp2_command_orb_inuse
, list
) {
488 if (command
->command_orb_dma
== orb
) {
489 spin_unlock_irqrestore(&scsi_id
->sbp2_command_orb_lock
, flags
);
494 spin_unlock_irqrestore(&scsi_id
->sbp2_command_orb_lock
, flags
);
496 SBP2_ORB_DEBUG("could not match command orb %x", (unsigned int)orb
);
502 * This function finds the sbp2_command for a given outstanding SCpnt.
503 * Only looks at the inuse list.
505 static struct sbp2_command_info
*sbp2util_find_command_for_SCpnt(struct scsi_id_instance_data
*scsi_id
, void *SCpnt
)
507 struct sbp2_command_info
*command
;
510 spin_lock_irqsave(&scsi_id
->sbp2_command_orb_lock
, flags
);
511 if (!list_empty(&scsi_id
->sbp2_command_orb_inuse
)) {
512 list_for_each_entry(command
, &scsi_id
->sbp2_command_orb_inuse
, list
) {
513 if (command
->Current_SCpnt
== SCpnt
) {
514 spin_unlock_irqrestore(&scsi_id
->sbp2_command_orb_lock
, flags
);
519 spin_unlock_irqrestore(&scsi_id
->sbp2_command_orb_lock
, flags
);
524 * This function allocates a command orb used to send a scsi command.
526 static struct sbp2_command_info
*sbp2util_allocate_command_orb(
527 struct scsi_id_instance_data
*scsi_id
,
528 struct scsi_cmnd
*Current_SCpnt
,
529 void (*Current_done
)(struct scsi_cmnd
*))
531 struct list_head
*lh
;
532 struct sbp2_command_info
*command
= NULL
;
535 spin_lock_irqsave(&scsi_id
->sbp2_command_orb_lock
, flags
);
536 if (!list_empty(&scsi_id
->sbp2_command_orb_completed
)) {
537 lh
= scsi_id
->sbp2_command_orb_completed
.next
;
539 command
= list_entry(lh
, struct sbp2_command_info
, list
);
540 command
->Current_done
= Current_done
;
541 command
->Current_SCpnt
= Current_SCpnt
;
542 list_add_tail(&command
->list
, &scsi_id
->sbp2_command_orb_inuse
);
544 SBP2_ERR("sbp2util_allocate_command_orb - No orbs available!");
546 spin_unlock_irqrestore(&scsi_id
->sbp2_command_orb_lock
, flags
);
551 static void sbp2util_free_command_dma(struct sbp2_command_info
*command
)
553 struct scsi_id_instance_data
*scsi_id
=
554 (struct scsi_id_instance_data
*)command
->Current_SCpnt
->device
->host
->hostdata
[0];
555 struct hpsb_host
*host
;
558 printk(KERN_ERR
"%s: scsi_id == NULL\n", __FUNCTION__
);
562 host
= scsi_id
->ud
->ne
->host
;
564 if (command
->cmd_dma
) {
565 if (command
->dma_type
== CMD_DMA_SINGLE
) {
566 pci_unmap_single(host
->pdev
, command
->cmd_dma
,
567 command
->dma_size
, command
->dma_dir
);
568 SBP2_DMA_FREE("single bulk");
569 } else if (command
->dma_type
== CMD_DMA_PAGE
) {
570 pci_unmap_page(host
->pdev
, command
->cmd_dma
,
571 command
->dma_size
, command
->dma_dir
);
572 SBP2_DMA_FREE("single page");
573 } /* XXX: Check for CMD_DMA_NONE bug */
574 command
->dma_type
= CMD_DMA_NONE
;
575 command
->cmd_dma
= 0;
578 if (command
->sge_buffer
) {
579 pci_unmap_sg(host
->pdev
, command
->sge_buffer
,
580 command
->dma_size
, command
->dma_dir
);
581 SBP2_DMA_FREE("scatter list");
582 command
->sge_buffer
= NULL
;
587 * This function moves a command to the completed orb list.
589 static void sbp2util_mark_command_completed(struct scsi_id_instance_data
*scsi_id
,
590 struct sbp2_command_info
*command
)
594 spin_lock_irqsave(&scsi_id
->sbp2_command_orb_lock
, flags
);
595 list_del(&command
->list
);
596 sbp2util_free_command_dma(command
);
597 list_add_tail(&command
->list
, &scsi_id
->sbp2_command_orb_completed
);
598 spin_unlock_irqrestore(&scsi_id
->sbp2_command_orb_lock
, flags
);
602 * Is scsi_id valid? Is the 1394 node still present?
604 static inline int sbp2util_node_is_available(struct scsi_id_instance_data
*scsi_id
)
606 return scsi_id
&& scsi_id
->ne
&& !scsi_id
->ne
->in_limbo
;
609 /*********************************************
610 * IEEE-1394 core driver stack related section
611 *********************************************/
612 static struct scsi_id_instance_data
*sbp2_alloc_device(struct unit_directory
*ud
);
614 static int sbp2_probe(struct device
*dev
)
616 struct unit_directory
*ud
;
617 struct scsi_id_instance_data
*scsi_id
;
619 SBP2_DEBUG("sbp2_probe");
621 ud
= container_of(dev
, struct unit_directory
, device
);
623 /* Don't probe UD's that have the LUN flag. We'll probe the LUN(s)
625 if (ud
->flags
& UNIT_DIRECTORY_HAS_LUN_DIRECTORY
)
628 scsi_id
= sbp2_alloc_device(ud
);
633 sbp2_parse_unit_directory(scsi_id
, ud
);
635 return sbp2_start_device(scsi_id
);
638 static int sbp2_remove(struct device
*dev
)
640 struct unit_directory
*ud
;
641 struct scsi_id_instance_data
*scsi_id
;
642 struct scsi_device
*sdev
;
644 SBP2_DEBUG("sbp2_remove");
646 ud
= container_of(dev
, struct unit_directory
, device
);
647 scsi_id
= ud
->device
.driver_data
;
651 /* Trigger shutdown functions in scsi's highlevel. */
652 if (scsi_id
->scsi_host
)
653 scsi_unblock_requests(scsi_id
->scsi_host
);
654 sdev
= scsi_id
->sdev
;
656 scsi_id
->sdev
= NULL
;
657 scsi_remove_device(sdev
);
660 sbp2_logout_device(scsi_id
);
661 sbp2_remove_device(scsi_id
);
666 static int sbp2_update(struct unit_directory
*ud
)
668 struct scsi_id_instance_data
*scsi_id
= ud
->device
.driver_data
;
670 SBP2_DEBUG("sbp2_update");
672 if (sbp2_reconnect_device(scsi_id
)) {
675 * Ok, reconnect has failed. Perhaps we didn't
676 * reconnect fast enough. Try doing a regular login, but
677 * first do a logout just in case of any weirdness.
679 sbp2_logout_device(scsi_id
);
681 if (sbp2_login_device(scsi_id
)) {
682 /* Login failed too, just fail, and the backend
683 * will call our sbp2_remove for us */
684 SBP2_ERR("Failed to reconnect to sbp2 device!");
689 /* Set max retries to something large on the device. */
690 sbp2_set_busy_timeout(scsi_id
);
692 /* Do a SBP-2 fetch agent reset. */
693 sbp2_agent_reset(scsi_id
, 1);
695 /* Get the max speed and packet size that we can use. */
696 sbp2_max_speed_and_size(scsi_id
);
698 /* Complete any pending commands with busy (so they get
699 * retried) and remove them from our queue
701 sbp2scsi_complete_all_commands(scsi_id
, DID_BUS_BUSY
);
703 /* Make sure we unblock requests (since this is likely after a bus
705 scsi_unblock_requests(scsi_id
->scsi_host
);
710 /* This functions is called by the sbp2_probe, for each new device. We now
711 * allocate one scsi host for each scsi_id (unit directory). */
712 static struct scsi_id_instance_data
*sbp2_alloc_device(struct unit_directory
*ud
)
714 struct sbp2scsi_host_info
*hi
;
715 struct Scsi_Host
*scsi_host
= NULL
;
716 struct scsi_id_instance_data
*scsi_id
= NULL
;
718 SBP2_DEBUG("sbp2_alloc_device");
720 scsi_id
= kmalloc(sizeof(*scsi_id
), GFP_KERNEL
);
722 SBP2_ERR("failed to create scsi_id");
725 memset(scsi_id
, 0, sizeof(*scsi_id
));
727 scsi_id
->ne
= ud
->ne
;
729 scsi_id
->speed_code
= IEEE1394_SPEED_100
;
730 scsi_id
->max_payload_size
= sbp2_speedto_max_payload
[IEEE1394_SPEED_100
];
731 atomic_set(&scsi_id
->sbp2_login_complete
, 0);
732 INIT_LIST_HEAD(&scsi_id
->sbp2_command_orb_inuse
);
733 INIT_LIST_HEAD(&scsi_id
->sbp2_command_orb_completed
);
734 INIT_LIST_HEAD(&scsi_id
->scsi_list
);
735 spin_lock_init(&scsi_id
->sbp2_command_orb_lock
);
736 scsi_id
->sbp2_lun
= 0;
738 ud
->device
.driver_data
= scsi_id
;
740 hi
= hpsb_get_hostinfo(&sbp2_highlevel
, ud
->ne
->host
);
742 hi
= hpsb_create_hostinfo(&sbp2_highlevel
, ud
->ne
->host
, sizeof(*hi
));
744 SBP2_ERR("failed to allocate hostinfo");
747 SBP2_DEBUG("sbp2_alloc_device: allocated hostinfo");
748 hi
->host
= ud
->ne
->host
;
749 INIT_LIST_HEAD(&hi
->scsi_ids
);
751 /* Register our sbp2 status address space... */
752 hpsb_register_addrspace(&sbp2_highlevel
, ud
->ne
->host
, &sbp2_ops
,
753 SBP2_STATUS_FIFO_ADDRESS
,
754 SBP2_STATUS_FIFO_ADDRESS
+
755 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(SBP2_MAX_UDS_PER_NODE
+1));
756 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
757 /* Handle data movement if physical dma is not
758 * enabled/supportedon host controller */
759 hpsb_register_addrspace(&sbp2_highlevel
, ud
->ne
->host
, &sbp2_physdma_ops
,
760 0x0ULL
, 0xfffffffcULL
);
766 list_add_tail(&scsi_id
->scsi_list
, &hi
->scsi_ids
);
768 /* Register our host with the SCSI stack. */
769 scsi_host
= scsi_host_alloc(&scsi_driver_template
,
770 sizeof(unsigned long));
772 SBP2_ERR("failed to register scsi host");
776 scsi_host
->hostdata
[0] = (unsigned long)scsi_id
;
778 if (!scsi_add_host(scsi_host
, &ud
->device
)) {
779 scsi_id
->scsi_host
= scsi_host
;
783 SBP2_ERR("failed to add scsi host");
784 scsi_host_put(scsi_host
);
787 sbp2_remove_device(scsi_id
);
791 static void sbp2_host_reset(struct hpsb_host
*host
)
793 struct sbp2scsi_host_info
*hi
;
794 struct scsi_id_instance_data
*scsi_id
;
796 hi
= hpsb_get_hostinfo(&sbp2_highlevel
, host
);
799 list_for_each_entry(scsi_id
, &hi
->scsi_ids
, scsi_list
)
800 scsi_block_requests(scsi_id
->scsi_host
);
805 * This function is where we first pull the node unique ids, and then
806 * allocate memory and register a SBP-2 device.
808 static int sbp2_start_device(struct scsi_id_instance_data
*scsi_id
)
810 struct sbp2scsi_host_info
*hi
= scsi_id
->hi
;
813 SBP2_DEBUG("sbp2_start_device");
816 scsi_id
->login_response
=
817 pci_alloc_consistent(hi
->host
->pdev
,
818 sizeof(struct sbp2_login_response
),
819 &scsi_id
->login_response_dma
);
820 if (!scsi_id
->login_response
)
822 SBP2_DMA_ALLOC("consistent DMA region for login FIFO");
824 /* Query logins ORB DMA */
825 scsi_id
->query_logins_orb
=
826 pci_alloc_consistent(hi
->host
->pdev
,
827 sizeof(struct sbp2_query_logins_orb
),
828 &scsi_id
->query_logins_orb_dma
);
829 if (!scsi_id
->query_logins_orb
)
831 SBP2_DMA_ALLOC("consistent DMA region for query logins ORB");
833 /* Query logins response DMA */
834 scsi_id
->query_logins_response
=
835 pci_alloc_consistent(hi
->host
->pdev
,
836 sizeof(struct sbp2_query_logins_response
),
837 &scsi_id
->query_logins_response_dma
);
838 if (!scsi_id
->query_logins_response
)
840 SBP2_DMA_ALLOC("consistent DMA region for query logins response");
842 /* Reconnect ORB DMA */
843 scsi_id
->reconnect_orb
=
844 pci_alloc_consistent(hi
->host
->pdev
,
845 sizeof(struct sbp2_reconnect_orb
),
846 &scsi_id
->reconnect_orb_dma
);
847 if (!scsi_id
->reconnect_orb
)
849 SBP2_DMA_ALLOC("consistent DMA region for reconnect ORB");
852 scsi_id
->logout_orb
=
853 pci_alloc_consistent(hi
->host
->pdev
,
854 sizeof(struct sbp2_logout_orb
),
855 &scsi_id
->logout_orb_dma
);
856 if (!scsi_id
->logout_orb
)
858 SBP2_DMA_ALLOC("consistent DMA region for logout ORB");
862 pci_alloc_consistent(hi
->host
->pdev
,
863 sizeof(struct sbp2_login_orb
),
864 &scsi_id
->login_orb_dma
);
865 if (!scsi_id
->login_orb
) {
867 if (scsi_id
->query_logins_response
) {
868 pci_free_consistent(hi
->host
->pdev
,
869 sizeof(struct sbp2_query_logins_response
),
870 scsi_id
->query_logins_response
,
871 scsi_id
->query_logins_response_dma
);
872 SBP2_DMA_FREE("query logins response DMA");
875 if (scsi_id
->query_logins_orb
) {
876 pci_free_consistent(hi
->host
->pdev
,
877 sizeof(struct sbp2_query_logins_orb
),
878 scsi_id
->query_logins_orb
,
879 scsi_id
->query_logins_orb_dma
);
880 SBP2_DMA_FREE("query logins ORB DMA");
883 if (scsi_id
->logout_orb
) {
884 pci_free_consistent(hi
->host
->pdev
,
885 sizeof(struct sbp2_logout_orb
),
887 scsi_id
->logout_orb_dma
);
888 SBP2_DMA_FREE("logout ORB DMA");
891 if (scsi_id
->reconnect_orb
) {
892 pci_free_consistent(hi
->host
->pdev
,
893 sizeof(struct sbp2_reconnect_orb
),
894 scsi_id
->reconnect_orb
,
895 scsi_id
->reconnect_orb_dma
);
896 SBP2_DMA_FREE("reconnect ORB DMA");
899 if (scsi_id
->login_response
) {
900 pci_free_consistent(hi
->host
->pdev
,
901 sizeof(struct sbp2_login_response
),
902 scsi_id
->login_response
,
903 scsi_id
->login_response_dma
);
904 SBP2_DMA_FREE("login FIFO DMA");
907 list_del(&scsi_id
->scsi_list
);
911 SBP2_ERR("Could not allocate memory for scsi_id");
915 SBP2_DMA_ALLOC("consistent DMA region for login ORB");
917 SBP2_DEBUG("New SBP-2 device inserted, SCSI ID = %x", scsi_id
->ud
->id
);
920 * Create our command orb pool
922 if (sbp2util_create_command_orb_pool(scsi_id
)) {
923 SBP2_ERR("sbp2util_create_command_orb_pool failed!");
924 sbp2_remove_device(scsi_id
);
928 /* Schedule a timeout here. The reason is that we may be so close
929 * to a bus reset, that the device is not available for logins.
930 * This can happen when the bus reset is caused by the host
931 * connected to the sbp2 device being removed. That host would
932 * have a certain amount of time to relogin before the sbp2 device
933 * allows someone else to login instead. One second makes sense. */
934 msleep_interruptible(1000);
935 if (signal_pending(current
)) {
936 SBP2_WARN("aborting sbp2_start_device due to event");
937 sbp2_remove_device(scsi_id
);
942 * Login to the sbp-2 device
944 if (sbp2_login_device(scsi_id
)) {
945 /* Login failed, just remove the device. */
946 sbp2_remove_device(scsi_id
);
951 * Set max retries to something large on the device
953 sbp2_set_busy_timeout(scsi_id
);
956 * Do a SBP-2 fetch agent reset
958 sbp2_agent_reset(scsi_id
, 1);
961 * Get the max speed and packet size that we can use
963 sbp2_max_speed_and_size(scsi_id
);
965 /* Add this device to the scsi layer now */
966 error
= scsi_add_device(scsi_id
->scsi_host
, 0, scsi_id
->ud
->id
, 0);
968 SBP2_ERR("scsi_add_device failed");
976 * This function removes an sbp2 device from the sbp2scsi_host_info struct.
978 static void sbp2_remove_device(struct scsi_id_instance_data
*scsi_id
)
980 struct sbp2scsi_host_info
*hi
;
982 SBP2_DEBUG("sbp2_remove_device");
989 /* This will remove our scsi device aswell */
990 if (scsi_id
->scsi_host
) {
991 scsi_remove_host(scsi_id
->scsi_host
);
992 scsi_host_put(scsi_id
->scsi_host
);
995 sbp2util_remove_command_orb_pool(scsi_id
);
997 list_del(&scsi_id
->scsi_list
);
999 if (scsi_id
->login_response
) {
1000 pci_free_consistent(hi
->host
->pdev
,
1001 sizeof(struct sbp2_login_response
),
1002 scsi_id
->login_response
,
1003 scsi_id
->login_response_dma
);
1004 SBP2_DMA_FREE("single login FIFO");
1007 if (scsi_id
->login_orb
) {
1008 pci_free_consistent(hi
->host
->pdev
,
1009 sizeof(struct sbp2_login_orb
),
1011 scsi_id
->login_orb_dma
);
1012 SBP2_DMA_FREE("single login ORB");
1015 if (scsi_id
->reconnect_orb
) {
1016 pci_free_consistent(hi
->host
->pdev
,
1017 sizeof(struct sbp2_reconnect_orb
),
1018 scsi_id
->reconnect_orb
,
1019 scsi_id
->reconnect_orb_dma
);
1020 SBP2_DMA_FREE("single reconnect orb");
1023 if (scsi_id
->logout_orb
) {
1024 pci_free_consistent(hi
->host
->pdev
,
1025 sizeof(struct sbp2_logout_orb
),
1026 scsi_id
->logout_orb
,
1027 scsi_id
->logout_orb_dma
);
1028 SBP2_DMA_FREE("single logout orb");
1031 if (scsi_id
->query_logins_orb
) {
1032 pci_free_consistent(hi
->host
->pdev
,
1033 sizeof(struct sbp2_query_logins_orb
),
1034 scsi_id
->query_logins_orb
,
1035 scsi_id
->query_logins_orb_dma
);
1036 SBP2_DMA_FREE("single query logins orb");
1039 if (scsi_id
->query_logins_response
) {
1040 pci_free_consistent(hi
->host
->pdev
,
1041 sizeof(struct sbp2_query_logins_response
),
1042 scsi_id
->query_logins_response
,
1043 scsi_id
->query_logins_response_dma
);
1044 SBP2_DMA_FREE("single query logins data");
1047 scsi_id
->ud
->device
.driver_data
= NULL
;
1049 SBP2_DEBUG("SBP-2 device removed, SCSI ID = %d", scsi_id
->ud
->id
);
1054 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
1056 * This function deals with physical dma write requests (for adapters that do not support
1057 * physical dma in hardware). Mostly just here for debugging...
1059 static int sbp2_handle_physdma_write(struct hpsb_host
*host
, int nodeid
,
1060 int destid
, quadlet_t
*data
, u64 addr
,
1061 size_t length
, u16 flags
)
1065 * Manually put the data in the right place.
1067 memcpy(bus_to_virt((u32
) addr
), data
, length
);
1068 sbp2util_packet_dump(data
, length
, "sbp2 phys dma write by device",
1070 return RCODE_COMPLETE
;
1074 * This function deals with physical dma read requests (for adapters that do not support
1075 * physical dma in hardware). Mostly just here for debugging...
1077 static int sbp2_handle_physdma_read(struct hpsb_host
*host
, int nodeid
,
1078 quadlet_t
*data
, u64 addr
, size_t length
,
1083 * Grab data from memory and send a read response.
1085 memcpy(data
, bus_to_virt((u32
) addr
), length
);
1086 sbp2util_packet_dump(data
, length
, "sbp2 phys dma read by device",
1088 return RCODE_COMPLETE
;
1092 /**************************************
1093 * SBP-2 protocol related section
1094 **************************************/
1097 * This function queries the device for the maximum concurrent logins it
1100 static int sbp2_query_logins(struct scsi_id_instance_data
*scsi_id
)
1102 struct sbp2scsi_host_info
*hi
= scsi_id
->hi
;
1107 SBP2_DEBUG("sbp2_query_logins");
1109 scsi_id
->query_logins_orb
->reserved1
= 0x0;
1110 scsi_id
->query_logins_orb
->reserved2
= 0x0;
1112 scsi_id
->query_logins_orb
->query_response_lo
= scsi_id
->query_logins_response_dma
;
1113 scsi_id
->query_logins_orb
->query_response_hi
= ORB_SET_NODE_ID(hi
->host
->node_id
);
1114 SBP2_DEBUG("sbp2_query_logins: query_response_hi/lo initialized");
1116 scsi_id
->query_logins_orb
->lun_misc
= ORB_SET_FUNCTION(SBP2_QUERY_LOGINS_REQUEST
);
1117 scsi_id
->query_logins_orb
->lun_misc
|= ORB_SET_NOTIFY(1);
1118 scsi_id
->query_logins_orb
->lun_misc
|= ORB_SET_LUN(scsi_id
->sbp2_lun
);
1119 SBP2_DEBUG("sbp2_query_logins: lun_misc initialized");
1121 scsi_id
->query_logins_orb
->reserved_resp_length
=
1122 ORB_SET_QUERY_LOGINS_RESP_LENGTH(sizeof(struct sbp2_query_logins_response
));
1123 SBP2_DEBUG("sbp2_query_logins: reserved_resp_length initialized");
1125 scsi_id
->query_logins_orb
->status_FIFO_lo
= SBP2_STATUS_FIFO_ADDRESS_LO
+
1126 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id
->ud
->id
);
1127 scsi_id
->query_logins_orb
->status_FIFO_hi
= (ORB_SET_NODE_ID(hi
->host
->node_id
) |
1128 SBP2_STATUS_FIFO_ADDRESS_HI
);
1129 SBP2_DEBUG("sbp2_query_logins: status FIFO initialized");
1131 sbp2util_cpu_to_be32_buffer(scsi_id
->query_logins_orb
, sizeof(struct sbp2_query_logins_orb
));
1133 SBP2_DEBUG("sbp2_query_logins: orb byte-swapped");
1135 sbp2util_packet_dump(scsi_id
->query_logins_orb
, sizeof(struct sbp2_query_logins_orb
),
1136 "sbp2 query logins orb", scsi_id
->query_logins_orb_dma
);
1138 memset(scsi_id
->query_logins_response
, 0, sizeof(struct sbp2_query_logins_response
));
1139 memset(&scsi_id
->status_block
, 0, sizeof(struct sbp2_status_block
));
1141 SBP2_DEBUG("sbp2_query_logins: query_logins_response/status FIFO memset");
1143 data
[0] = ORB_SET_NODE_ID(hi
->host
->node_id
);
1144 data
[1] = scsi_id
->query_logins_orb_dma
;
1145 sbp2util_cpu_to_be32_buffer(data
, 8);
1147 atomic_set(&scsi_id
->sbp2_login_complete
, 0);
1149 SBP2_DEBUG("sbp2_query_logins: prepared to write");
1150 hpsb_node_write(scsi_id
->ne
, scsi_id
->sbp2_management_agent_addr
, data
, 8);
1151 SBP2_DEBUG("sbp2_query_logins: written");
1153 if (sbp2util_down_timeout(&scsi_id
->sbp2_login_complete
, 2*HZ
)) {
1154 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
1158 if (scsi_id
->status_block
.ORB_offset_lo
!= scsi_id
->query_logins_orb_dma
) {
1159 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
1163 if (STATUS_GET_RESP(scsi_id
->status_block
.ORB_offset_hi_misc
) ||
1164 STATUS_GET_DEAD_BIT(scsi_id
->status_block
.ORB_offset_hi_misc
) ||
1165 STATUS_GET_SBP_STATUS(scsi_id
->status_block
.ORB_offset_hi_misc
)) {
1167 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
1171 sbp2util_cpu_to_be32_buffer(scsi_id
->query_logins_response
, sizeof(struct sbp2_query_logins_response
));
1173 SBP2_DEBUG("length_max_logins = %x",
1174 (unsigned int)scsi_id
->query_logins_response
->length_max_logins
);
1176 SBP2_DEBUG("Query logins to SBP-2 device successful");
1178 max_logins
= RESPONSE_GET_MAX_LOGINS(scsi_id
->query_logins_response
->length_max_logins
);
1179 SBP2_DEBUG("Maximum concurrent logins supported: %d", max_logins
);
1181 active_logins
= RESPONSE_GET_ACTIVE_LOGINS(scsi_id
->query_logins_response
->length_max_logins
);
1182 SBP2_DEBUG("Number of active logins: %d", active_logins
);
1184 if (active_logins
>= max_logins
) {
1192 * This function is called in order to login to a particular SBP-2 device,
1193 * after a bus reset.
1195 static int sbp2_login_device(struct scsi_id_instance_data
*scsi_id
)
1197 struct sbp2scsi_host_info
*hi
= scsi_id
->hi
;
1200 SBP2_DEBUG("sbp2_login_device");
1202 if (!scsi_id
->login_orb
) {
1203 SBP2_DEBUG("sbp2_login_device: login_orb not alloc'd!");
1207 if (!exclusive_login
) {
1208 if (sbp2_query_logins(scsi_id
)) {
1209 SBP2_INFO("Device does not support any more concurrent logins");
1214 /* Set-up login ORB, assume no password */
1215 scsi_id
->login_orb
->password_hi
= 0;
1216 scsi_id
->login_orb
->password_lo
= 0;
1217 SBP2_DEBUG("sbp2_login_device: password_hi/lo initialized");
1219 scsi_id
->login_orb
->login_response_lo
= scsi_id
->login_response_dma
;
1220 scsi_id
->login_orb
->login_response_hi
= ORB_SET_NODE_ID(hi
->host
->node_id
);
1221 SBP2_DEBUG("sbp2_login_device: login_response_hi/lo initialized");
1223 scsi_id
->login_orb
->lun_misc
= ORB_SET_FUNCTION(SBP2_LOGIN_REQUEST
);
1224 scsi_id
->login_orb
->lun_misc
|= ORB_SET_RECONNECT(0); /* One second reconnect time */
1225 scsi_id
->login_orb
->lun_misc
|= ORB_SET_EXCLUSIVE(exclusive_login
); /* Exclusive access to device */
1226 scsi_id
->login_orb
->lun_misc
|= ORB_SET_NOTIFY(1); /* Notify us of login complete */
1227 scsi_id
->login_orb
->lun_misc
|= ORB_SET_LUN(scsi_id
->sbp2_lun
);
1228 SBP2_DEBUG("sbp2_login_device: lun_misc initialized");
1230 scsi_id
->login_orb
->passwd_resp_lengths
=
1231 ORB_SET_LOGIN_RESP_LENGTH(sizeof(struct sbp2_login_response
));
1232 SBP2_DEBUG("sbp2_login_device: passwd_resp_lengths initialized");
1234 scsi_id
->login_orb
->status_FIFO_lo
= SBP2_STATUS_FIFO_ADDRESS_LO
+
1235 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id
->ud
->id
);
1236 scsi_id
->login_orb
->status_FIFO_hi
= (ORB_SET_NODE_ID(hi
->host
->node_id
) |
1237 SBP2_STATUS_FIFO_ADDRESS_HI
);
1238 SBP2_DEBUG("sbp2_login_device: status FIFO initialized");
1241 * Byte swap ORB if necessary
1243 sbp2util_cpu_to_be32_buffer(scsi_id
->login_orb
, sizeof(struct sbp2_login_orb
));
1245 SBP2_DEBUG("sbp2_login_device: orb byte-swapped");
1247 sbp2util_packet_dump(scsi_id
->login_orb
, sizeof(struct sbp2_login_orb
),
1248 "sbp2 login orb", scsi_id
->login_orb_dma
);
1251 * Initialize login response and status fifo
1253 memset(scsi_id
->login_response
, 0, sizeof(struct sbp2_login_response
));
1254 memset(&scsi_id
->status_block
, 0, sizeof(struct sbp2_status_block
));
1256 SBP2_DEBUG("sbp2_login_device: login_response/status FIFO memset");
1259 * Ok, let's write to the target's management agent register
1261 data
[0] = ORB_SET_NODE_ID(hi
->host
->node_id
);
1262 data
[1] = scsi_id
->login_orb_dma
;
1263 sbp2util_cpu_to_be32_buffer(data
, 8);
1265 atomic_set(&scsi_id
->sbp2_login_complete
, 0);
1267 SBP2_DEBUG("sbp2_login_device: prepared to write to %08x",
1268 (unsigned int)scsi_id
->sbp2_management_agent_addr
);
1269 hpsb_node_write(scsi_id
->ne
, scsi_id
->sbp2_management_agent_addr
, data
, 8);
1270 SBP2_DEBUG("sbp2_login_device: written");
1273 * Wait for login status (up to 20 seconds)...
1275 if (sbp2util_down_timeout(&scsi_id
->sbp2_login_complete
, 20*HZ
)) {
1276 SBP2_ERR("Error logging into SBP-2 device - login timed-out");
1281 * Sanity. Make sure status returned matches login orb.
1283 if (scsi_id
->status_block
.ORB_offset_lo
!= scsi_id
->login_orb_dma
) {
1284 SBP2_ERR("Error logging into SBP-2 device - login timed-out");
1291 if (STATUS_GET_RESP(scsi_id
->status_block
.ORB_offset_hi_misc
) ||
1292 STATUS_GET_DEAD_BIT(scsi_id
->status_block
.ORB_offset_hi_misc
) ||
1293 STATUS_GET_SBP_STATUS(scsi_id
->status_block
.ORB_offset_hi_misc
)) {
1295 SBP2_ERR("Error logging into SBP-2 device - login failed");
1300 * Byte swap the login response, for use when reconnecting or
1303 sbp2util_cpu_to_be32_buffer(scsi_id
->login_response
, sizeof(struct sbp2_login_response
));
1306 * Grab our command block agent address from the login response.
1308 SBP2_DEBUG("command_block_agent_hi = %x",
1309 (unsigned int)scsi_id
->login_response
->command_block_agent_hi
);
1310 SBP2_DEBUG("command_block_agent_lo = %x",
1311 (unsigned int)scsi_id
->login_response
->command_block_agent_lo
);
1313 scsi_id
->sbp2_command_block_agent_addr
=
1314 ((u64
)scsi_id
->login_response
->command_block_agent_hi
) << 32;
1315 scsi_id
->sbp2_command_block_agent_addr
|= ((u64
)scsi_id
->login_response
->command_block_agent_lo
);
1316 scsi_id
->sbp2_command_block_agent_addr
&= 0x0000ffffffffffffULL
;
1318 SBP2_INFO("Logged into SBP-2 device");
1325 * This function is called in order to logout from a particular SBP-2
1326 * device, usually called during driver unload.
1328 static int sbp2_logout_device(struct scsi_id_instance_data
*scsi_id
)
1330 struct sbp2scsi_host_info
*hi
= scsi_id
->hi
;
1334 SBP2_DEBUG("sbp2_logout_device");
1339 scsi_id
->logout_orb
->reserved1
= 0x0;
1340 scsi_id
->logout_orb
->reserved2
= 0x0;
1341 scsi_id
->logout_orb
->reserved3
= 0x0;
1342 scsi_id
->logout_orb
->reserved4
= 0x0;
1344 scsi_id
->logout_orb
->login_ID_misc
= ORB_SET_FUNCTION(SBP2_LOGOUT_REQUEST
);
1345 scsi_id
->logout_orb
->login_ID_misc
|= ORB_SET_LOGIN_ID(scsi_id
->login_response
->length_login_ID
);
1347 /* Notify us when complete */
1348 scsi_id
->logout_orb
->login_ID_misc
|= ORB_SET_NOTIFY(1);
1350 scsi_id
->logout_orb
->reserved5
= 0x0;
1351 scsi_id
->logout_orb
->status_FIFO_lo
= SBP2_STATUS_FIFO_ADDRESS_LO
+
1352 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id
->ud
->id
);
1353 scsi_id
->logout_orb
->status_FIFO_hi
= (ORB_SET_NODE_ID(hi
->host
->node_id
) |
1354 SBP2_STATUS_FIFO_ADDRESS_HI
);
1357 * Byte swap ORB if necessary
1359 sbp2util_cpu_to_be32_buffer(scsi_id
->logout_orb
, sizeof(struct sbp2_logout_orb
));
1361 sbp2util_packet_dump(scsi_id
->logout_orb
, sizeof(struct sbp2_logout_orb
),
1362 "sbp2 logout orb", scsi_id
->logout_orb_dma
);
1365 * Ok, let's write to the target's management agent register
1367 data
[0] = ORB_SET_NODE_ID(hi
->host
->node_id
);
1368 data
[1] = scsi_id
->logout_orb_dma
;
1369 sbp2util_cpu_to_be32_buffer(data
, 8);
1371 atomic_set(&scsi_id
->sbp2_login_complete
, 0);
1373 error
= hpsb_node_write(scsi_id
->ne
,
1374 scsi_id
->sbp2_management_agent_addr
, data
, 8);
1378 /* Wait for device to logout...1 second. */
1379 if (sbp2util_down_timeout(&scsi_id
->sbp2_login_complete
, HZ
))
1382 SBP2_INFO("Logged out of SBP-2 device");
1389 * This function is called in order to reconnect to a particular SBP-2
1390 * device, after a bus reset.
1392 static int sbp2_reconnect_device(struct scsi_id_instance_data
*scsi_id
)
1394 struct sbp2scsi_host_info
*hi
= scsi_id
->hi
;
1398 SBP2_DEBUG("sbp2_reconnect_device");
1401 * Set-up reconnect ORB
1403 scsi_id
->reconnect_orb
->reserved1
= 0x0;
1404 scsi_id
->reconnect_orb
->reserved2
= 0x0;
1405 scsi_id
->reconnect_orb
->reserved3
= 0x0;
1406 scsi_id
->reconnect_orb
->reserved4
= 0x0;
1408 scsi_id
->reconnect_orb
->login_ID_misc
= ORB_SET_FUNCTION(SBP2_RECONNECT_REQUEST
);
1409 scsi_id
->reconnect_orb
->login_ID_misc
|=
1410 ORB_SET_LOGIN_ID(scsi_id
->login_response
->length_login_ID
);
1412 /* Notify us when complete */
1413 scsi_id
->reconnect_orb
->login_ID_misc
|= ORB_SET_NOTIFY(1);
1415 scsi_id
->reconnect_orb
->reserved5
= 0x0;
1416 scsi_id
->reconnect_orb
->status_FIFO_lo
= SBP2_STATUS_FIFO_ADDRESS_LO
+
1417 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id
->ud
->id
);
1418 scsi_id
->reconnect_orb
->status_FIFO_hi
=
1419 (ORB_SET_NODE_ID(hi
->host
->node_id
) | SBP2_STATUS_FIFO_ADDRESS_HI
);
1422 * Byte swap ORB if necessary
1424 sbp2util_cpu_to_be32_buffer(scsi_id
->reconnect_orb
, sizeof(struct sbp2_reconnect_orb
));
1426 sbp2util_packet_dump(scsi_id
->reconnect_orb
, sizeof(struct sbp2_reconnect_orb
),
1427 "sbp2 reconnect orb", scsi_id
->reconnect_orb_dma
);
1430 * Initialize status fifo
1432 memset(&scsi_id
->status_block
, 0, sizeof(struct sbp2_status_block
));
1435 * Ok, let's write to the target's management agent register
1437 data
[0] = ORB_SET_NODE_ID(hi
->host
->node_id
);
1438 data
[1] = scsi_id
->reconnect_orb_dma
;
1439 sbp2util_cpu_to_be32_buffer(data
, 8);
1441 atomic_set(&scsi_id
->sbp2_login_complete
, 0);
1443 error
= hpsb_node_write(scsi_id
->ne
,
1444 scsi_id
->sbp2_management_agent_addr
, data
, 8);
1449 * Wait for reconnect status (up to 1 second)...
1451 if (sbp2util_down_timeout(&scsi_id
->sbp2_login_complete
, HZ
)) {
1452 SBP2_ERR("Error reconnecting to SBP-2 device - reconnect timed-out");
1457 * Sanity. Make sure status returned matches reconnect orb.
1459 if (scsi_id
->status_block
.ORB_offset_lo
!= scsi_id
->reconnect_orb_dma
) {
1460 SBP2_ERR("Error reconnecting to SBP-2 device - reconnect timed-out");
1467 if (STATUS_GET_RESP(scsi_id
->status_block
.ORB_offset_hi_misc
) ||
1468 STATUS_GET_DEAD_BIT(scsi_id
->status_block
.ORB_offset_hi_misc
) ||
1469 STATUS_GET_SBP_STATUS(scsi_id
->status_block
.ORB_offset_hi_misc
)) {
1471 SBP2_ERR("Error reconnecting to SBP-2 device - reconnect failed");
1475 HPSB_DEBUG("Reconnected to SBP-2 device");
1482 * This function is called in order to set the busy timeout (number of
1483 * retries to attempt) on the sbp2 device.
1485 static int sbp2_set_busy_timeout(struct scsi_id_instance_data
*scsi_id
)
1489 SBP2_DEBUG("sbp2_set_busy_timeout");
1492 * Ok, let's write to the target's busy timeout register
1494 data
= cpu_to_be32(SBP2_BUSY_TIMEOUT_VALUE
);
1496 if (hpsb_node_write(scsi_id
->ne
, SBP2_BUSY_TIMEOUT_ADDRESS
, &data
, 4)) {
1497 SBP2_ERR("sbp2_set_busy_timeout error");
1504 * This function is called to parse sbp2 device's config rom unit
1505 * directory. Used to determine things like sbp2 management agent offset,
1506 * and command set used (SCSI or RBC).
1508 static void sbp2_parse_unit_directory(struct scsi_id_instance_data
*scsi_id
,
1509 struct unit_directory
*ud
)
1511 struct csr1212_keyval
*kv
;
1512 struct csr1212_dentry
*dentry
;
1513 u64 management_agent_addr
;
1514 u32 command_set_spec_id
, command_set
, unit_characteristics
,
1515 firmware_revision
, workarounds
;
1518 SBP2_DEBUG("sbp2_parse_unit_directory");
1520 management_agent_addr
= 0x0;
1521 command_set_spec_id
= 0x0;
1523 unit_characteristics
= 0x0;
1524 firmware_revision
= 0x0;
1526 /* Handle different fields in the unit directory, based on keys */
1527 csr1212_for_each_dir_entry(ud
->ne
->csr
, kv
, ud
->ud_kv
, dentry
) {
1528 switch (kv
->key
.id
) {
1529 case CSR1212_KV_ID_DEPENDENT_INFO
:
1530 if (kv
->key
.type
== CSR1212_KV_TYPE_CSR_OFFSET
) {
1531 /* Save off the management agent address */
1532 management_agent_addr
=
1533 CSR1212_REGISTER_SPACE_BASE
+
1534 (kv
->value
.csr_offset
<< 2);
1536 SBP2_DEBUG("sbp2_management_agent_addr = %x",
1537 (unsigned int)management_agent_addr
);
1538 } else if (kv
->key
.type
== CSR1212_KV_TYPE_IMMEDIATE
) {
1540 ORB_SET_LUN(kv
->value
.immediate
);
1544 case SBP2_COMMAND_SET_SPEC_ID_KEY
:
1545 /* Command spec organization */
1546 command_set_spec_id
= kv
->value
.immediate
;
1547 SBP2_DEBUG("sbp2_command_set_spec_id = %x",
1548 (unsigned int)command_set_spec_id
);
1551 case SBP2_COMMAND_SET_KEY
:
1552 /* Command set used by sbp2 device */
1553 command_set
= kv
->value
.immediate
;
1554 SBP2_DEBUG("sbp2_command_set = %x",
1555 (unsigned int)command_set
);
1558 case SBP2_UNIT_CHARACTERISTICS_KEY
:
1560 * Unit characterisitcs (orb related stuff
1561 * that I'm not yet paying attention to)
1563 unit_characteristics
= kv
->value
.immediate
;
1564 SBP2_DEBUG("sbp2_unit_characteristics = %x",
1565 (unsigned int)unit_characteristics
);
1568 case SBP2_FIRMWARE_REVISION_KEY
:
1569 /* Firmware revision */
1570 firmware_revision
= kv
->value
.immediate
;
1571 if (force_inquiry_hack
)
1572 SBP2_INFO("sbp2_firmware_revision = %x",
1573 (unsigned int)firmware_revision
);
1575 SBP2_DEBUG("sbp2_firmware_revision = %x",
1576 (unsigned int)firmware_revision
);
1584 /* This is the start of our broken device checking. We try to hack
1585 * around oddities and known defects. */
1588 /* If the vendor id is 0xa0b8 (Symbios vendor id), then we have a
1589 * bridge with 128KB max transfer size limitation. For sanity, we
1590 * only voice this when the current max_sectors setting
1591 * exceeds the 128k limit. By default, that is not the case.
1593 * It would be really nice if we could detect this before the scsi
1594 * host gets initialized. That way we can down-force the
1595 * max_sectors to account for it. That is not currently
1597 if ((firmware_revision
& 0xffff00) ==
1598 SBP2_128KB_BROKEN_FIRMWARE
&&
1599 (max_sectors
* 512) > (128*1024)) {
1600 SBP2_WARN("Node " NODE_BUS_FMT
": Bridge only supports 128KB max transfer size.",
1601 NODE_BUS_ARGS(ud
->ne
->host
, ud
->ne
->nodeid
));
1602 SBP2_WARN("WARNING: Current max_sectors setting is larger than 128KB (%d sectors)!",
1604 workarounds
|= SBP2_BREAKAGE_128K_MAX_TRANSFER
;
1607 /* Check for a blacklisted set of devices that require us to force
1608 * a 36 byte host inquiry. This can be overriden as a module param
1609 * (to force all hosts). */
1610 for (i
= 0; i
< NUM_BROKEN_INQUIRY_DEVS
; i
++) {
1611 if ((firmware_revision
& 0xffff00) ==
1612 sbp2_broken_inquiry_list
[i
]) {
1613 SBP2_WARN("Node " NODE_BUS_FMT
": Using 36byte inquiry workaround",
1614 NODE_BUS_ARGS(ud
->ne
->host
, ud
->ne
->nodeid
));
1615 workarounds
|= SBP2_BREAKAGE_INQUIRY_HACK
;
1616 break; /* No need to continue. */
1620 /* If this is a logical unit directory entry, process the parent
1621 * to get the values. */
1622 if (ud
->flags
& UNIT_DIRECTORY_LUN_DIRECTORY
) {
1623 struct unit_directory
*parent_ud
=
1624 container_of(ud
->device
.parent
, struct unit_directory
, device
);
1625 sbp2_parse_unit_directory(scsi_id
, parent_ud
);
1627 scsi_id
->sbp2_management_agent_addr
= management_agent_addr
;
1628 scsi_id
->sbp2_command_set_spec_id
= command_set_spec_id
;
1629 scsi_id
->sbp2_command_set
= command_set
;
1630 scsi_id
->sbp2_unit_characteristics
= unit_characteristics
;
1631 scsi_id
->sbp2_firmware_revision
= firmware_revision
;
1632 scsi_id
->workarounds
= workarounds
;
1633 if (ud
->flags
& UNIT_DIRECTORY_HAS_LUN
)
1634 scsi_id
->sbp2_lun
= ORB_SET_LUN(ud
->lun
);
1639 * This function is called in order to determine the max speed and packet
1640 * size we can use in our ORBs. Note, that we (the driver and host) only
1641 * initiate the transaction. The SBP-2 device actually transfers the data
1642 * (by reading from the DMA area we tell it). This means that the SBP-2
1643 * device decides the actual maximum data it can transfer. We just tell it
1644 * the speed that it needs to use, and the max_rec the host supports, and
1645 * it takes care of the rest.
1647 static int sbp2_max_speed_and_size(struct scsi_id_instance_data
*scsi_id
)
1649 struct sbp2scsi_host_info
*hi
= scsi_id
->hi
;
1651 SBP2_DEBUG("sbp2_max_speed_and_size");
1653 /* Initial setting comes from the hosts speed map */
1654 scsi_id
->speed_code
=
1655 hi
->host
->speed_map
[NODEID_TO_NODE(hi
->host
->node_id
) * 64 +
1656 NODEID_TO_NODE(scsi_id
->ne
->nodeid
)];
1658 /* Bump down our speed if the user requested it */
1659 if (scsi_id
->speed_code
> max_speed
) {
1660 scsi_id
->speed_code
= max_speed
;
1661 SBP2_ERR("Forcing SBP-2 max speed down to %s",
1662 hpsb_speedto_str
[scsi_id
->speed_code
]);
1665 /* Payload size is the lesser of what our speed supports and what
1666 * our host supports. */
1667 scsi_id
->max_payload_size
=
1668 min(sbp2_speedto_max_payload
[scsi_id
->speed_code
],
1669 (u8
) (hi
->host
->csr
.max_rec
- 1));
1671 HPSB_DEBUG("Node " NODE_BUS_FMT
": Max speed [%s] - Max payload [%u]",
1672 NODE_BUS_ARGS(hi
->host
, scsi_id
->ne
->nodeid
),
1673 hpsb_speedto_str
[scsi_id
->speed_code
],
1674 1 << ((u32
) scsi_id
->max_payload_size
+ 2));
1680 * This function is called in order to perform a SBP-2 agent reset.
1682 static int sbp2_agent_reset(struct scsi_id_instance_data
*scsi_id
, int wait
)
1688 SBP2_DEBUG("sbp2_agent_reset");
1691 * Ok, let's write to the target's management agent register
1693 data
= ntohl(SBP2_AGENT_RESET_DATA
);
1694 addr
= scsi_id
->sbp2_command_block_agent_addr
+ SBP2_AGENT_RESET_OFFSET
;
1697 retval
= hpsb_node_write(scsi_id
->ne
, addr
, &data
, 4);
1699 retval
= sbp2util_node_write_no_wait(scsi_id
->ne
, addr
, &data
, 4);
1702 SBP2_ERR("hpsb_node_write failed.\n");
1707 * Need to make sure orb pointer is written on next command
1709 scsi_id
->last_orb
= NULL
;
1715 * This function is called to create the actual command orb and s/g list
1716 * out of the scsi command itself.
1718 static int sbp2_create_command_orb(struct scsi_id_instance_data
*scsi_id
,
1719 struct sbp2_command_info
*command
,
1721 unsigned int scsi_use_sg
,
1722 unsigned int scsi_request_bufflen
,
1723 void *scsi_request_buffer
,
1724 enum dma_data_direction dma_dir
)
1726 struct sbp2scsi_host_info
*hi
= scsi_id
->hi
;
1727 struct scatterlist
*sgpnt
= (struct scatterlist
*)scsi_request_buffer
;
1728 struct sbp2_command_orb
*command_orb
= &command
->command_orb
;
1729 struct sbp2_unrestricted_page_table
*scatter_gather_element
=
1730 &command
->scatter_gather_element
[0];
1731 u32 sg_count
, sg_len
, orb_direction
;
1736 * Set-up our command ORB..
1738 * NOTE: We're doing unrestricted page tables (s/g), as this is
1739 * best performance (at least with the devices I have). This means
1740 * that data_size becomes the number of s/g elements, and
1741 * page_size should be zero (for unrestricted).
1743 command_orb
->next_ORB_hi
= ORB_SET_NULL_PTR(1);
1744 command_orb
->next_ORB_lo
= 0x0;
1745 command_orb
->misc
= ORB_SET_MAX_PAYLOAD(scsi_id
->max_payload_size
);
1746 command_orb
->misc
|= ORB_SET_SPEED(scsi_id
->speed_code
);
1747 command_orb
->misc
|= ORB_SET_NOTIFY(1); /* Notify us when complete */
1750 * Get the direction of the transfer. If the direction is unknown, then use our
1751 * goofy table as a back-up.
1755 orb_direction
= ORB_DIRECTION_NO_DATA_TRANSFER
;
1758 orb_direction
= ORB_DIRECTION_WRITE_TO_MEDIA
;
1760 case DMA_FROM_DEVICE
:
1761 orb_direction
= ORB_DIRECTION_READ_FROM_MEDIA
;
1763 case DMA_BIDIRECTIONAL
:
1765 SBP2_ERR("SCSI data transfer direction not specified. "
1766 "Update the SBP2 direction table in sbp2.h if "
1767 "necessary for your application");
1768 __scsi_print_command(scsi_cmd
);
1769 orb_direction
= sbp2scsi_direction_table
[*scsi_cmd
];
1774 * Set-up our pagetable stuff... unfortunately, this has become
1775 * messier than I'd like. Need to clean this up a bit. ;-)
1777 if (orb_direction
== ORB_DIRECTION_NO_DATA_TRANSFER
) {
1779 SBP2_DEBUG("No data transfer");
1782 * Handle no data transfer
1784 command_orb
->data_descriptor_hi
= 0x0;
1785 command_orb
->data_descriptor_lo
= 0x0;
1786 command_orb
->misc
|= ORB_SET_DIRECTION(1);
1788 } else if (scsi_use_sg
) {
1790 SBP2_DEBUG("Use scatter/gather");
1793 * Special case if only one element (and less than 64KB in size)
1795 if ((scsi_use_sg
== 1) && (sgpnt
[0].length
<= SBP2_MAX_SG_ELEMENT_LENGTH
)) {
1797 SBP2_DEBUG("Only one s/g element");
1798 command
->dma_dir
= dma_dir
;
1799 command
->dma_size
= sgpnt
[0].length
;
1800 command
->dma_type
= CMD_DMA_PAGE
;
1801 command
->cmd_dma
= pci_map_page(hi
->host
->pdev
,
1806 SBP2_DMA_ALLOC("single page scatter element");
1808 command_orb
->data_descriptor_hi
= ORB_SET_NODE_ID(hi
->host
->node_id
);
1809 command_orb
->data_descriptor_lo
= command
->cmd_dma
;
1810 command_orb
->misc
|= ORB_SET_DATA_SIZE(command
->dma_size
);
1811 command_orb
->misc
|= ORB_SET_DIRECTION(orb_direction
);
1814 int count
= pci_map_sg(hi
->host
->pdev
, sgpnt
, scsi_use_sg
, dma_dir
);
1815 SBP2_DMA_ALLOC("scatter list");
1817 command
->dma_size
= scsi_use_sg
;
1818 command
->dma_dir
= dma_dir
;
1819 command
->sge_buffer
= sgpnt
;
1821 /* use page tables (s/g) */
1822 command_orb
->misc
|= ORB_SET_PAGE_TABLE_PRESENT(0x1);
1823 command_orb
->misc
|= ORB_SET_DIRECTION(orb_direction
);
1824 command_orb
->data_descriptor_hi
= ORB_SET_NODE_ID(hi
->host
->node_id
);
1825 command_orb
->data_descriptor_lo
= command
->sge_dma
;
1828 * Loop through and fill out our sbp-2 page tables
1829 * (and split up anything too large)
1831 for (i
= 0, sg_count
= 0 ; i
< count
; i
++, sgpnt
++) {
1832 sg_len
= sg_dma_len(sgpnt
);
1833 sg_addr
= sg_dma_address(sgpnt
);
1835 scatter_gather_element
[sg_count
].segment_base_lo
= sg_addr
;
1836 if (sg_len
> SBP2_MAX_SG_ELEMENT_LENGTH
) {
1837 scatter_gather_element
[sg_count
].length_segment_base_hi
=
1838 PAGE_TABLE_SET_SEGMENT_LENGTH(SBP2_MAX_SG_ELEMENT_LENGTH
);
1839 sg_addr
+= SBP2_MAX_SG_ELEMENT_LENGTH
;
1840 sg_len
-= SBP2_MAX_SG_ELEMENT_LENGTH
;
1842 scatter_gather_element
[sg_count
].length_segment_base_hi
=
1843 PAGE_TABLE_SET_SEGMENT_LENGTH(sg_len
);
1850 /* Number of page table (s/g) elements */
1851 command_orb
->misc
|= ORB_SET_DATA_SIZE(sg_count
);
1853 sbp2util_packet_dump(scatter_gather_element
,
1854 (sizeof(struct sbp2_unrestricted_page_table
)) * sg_count
,
1855 "sbp2 s/g list", command
->sge_dma
);
1858 * Byte swap page tables if necessary
1860 sbp2util_cpu_to_be32_buffer(scatter_gather_element
,
1861 (sizeof(struct sbp2_unrestricted_page_table
)) *
1868 SBP2_DEBUG("No scatter/gather");
1870 command
->dma_dir
= dma_dir
;
1871 command
->dma_size
= scsi_request_bufflen
;
1872 command
->dma_type
= CMD_DMA_SINGLE
;
1874 pci_map_single(hi
->host
->pdev
, scsi_request_buffer
,
1875 command
->dma_size
, command
->dma_dir
);
1876 SBP2_DMA_ALLOC("single bulk");
1879 * Handle case where we get a command w/o s/g enabled (but
1880 * check for transfers larger than 64K)
1882 if (scsi_request_bufflen
<= SBP2_MAX_SG_ELEMENT_LENGTH
) {
1884 command_orb
->data_descriptor_hi
= ORB_SET_NODE_ID(hi
->host
->node_id
);
1885 command_orb
->data_descriptor_lo
= command
->cmd_dma
;
1886 command_orb
->misc
|= ORB_SET_DATA_SIZE(scsi_request_bufflen
);
1887 command_orb
->misc
|= ORB_SET_DIRECTION(orb_direction
);
1890 * Sanity, in case our direction table is not
1893 if (!scsi_request_bufflen
) {
1894 command_orb
->data_descriptor_hi
= 0x0;
1895 command_orb
->data_descriptor_lo
= 0x0;
1896 command_orb
->misc
|= ORB_SET_DIRECTION(1);
1901 * Need to turn this into page tables, since the
1902 * buffer is too large.
1904 command_orb
->data_descriptor_hi
= ORB_SET_NODE_ID(hi
->host
->node_id
);
1905 command_orb
->data_descriptor_lo
= command
->sge_dma
;
1907 /* Use page tables (s/g) */
1908 command_orb
->misc
|= ORB_SET_PAGE_TABLE_PRESENT(0x1);
1909 command_orb
->misc
|= ORB_SET_DIRECTION(orb_direction
);
1912 * fill out our sbp-2 page tables (and split up
1916 sg_len
= scsi_request_bufflen
;
1917 sg_addr
= command
->cmd_dma
;
1919 scatter_gather_element
[sg_count
].segment_base_lo
= sg_addr
;
1920 if (sg_len
> SBP2_MAX_SG_ELEMENT_LENGTH
) {
1921 scatter_gather_element
[sg_count
].length_segment_base_hi
=
1922 PAGE_TABLE_SET_SEGMENT_LENGTH(SBP2_MAX_SG_ELEMENT_LENGTH
);
1923 sg_addr
+= SBP2_MAX_SG_ELEMENT_LENGTH
;
1924 sg_len
-= SBP2_MAX_SG_ELEMENT_LENGTH
;
1926 scatter_gather_element
[sg_count
].length_segment_base_hi
=
1927 PAGE_TABLE_SET_SEGMENT_LENGTH(sg_len
);
1933 /* Number of page table (s/g) elements */
1934 command_orb
->misc
|= ORB_SET_DATA_SIZE(sg_count
);
1936 sbp2util_packet_dump(scatter_gather_element
,
1937 (sizeof(struct sbp2_unrestricted_page_table
)) * sg_count
,
1938 "sbp2 s/g list", command
->sge_dma
);
1941 * Byte swap page tables if necessary
1943 sbp2util_cpu_to_be32_buffer(scatter_gather_element
,
1944 (sizeof(struct sbp2_unrestricted_page_table
)) *
1952 * Byte swap command ORB if necessary
1954 sbp2util_cpu_to_be32_buffer(command_orb
, sizeof(struct sbp2_command_orb
));
1957 * Put our scsi command in the command ORB
1959 memset(command_orb
->cdb
, 0, 12);
1960 memcpy(command_orb
->cdb
, scsi_cmd
, COMMAND_SIZE(*scsi_cmd
));
1966 * This function is called in order to begin a regular SBP-2 command.
1968 static int sbp2_link_orb_command(struct scsi_id_instance_data
*scsi_id
,
1969 struct sbp2_command_info
*command
)
1971 struct sbp2scsi_host_info
*hi
= scsi_id
->hi
;
1972 struct sbp2_command_orb
*command_orb
= &command
->command_orb
;
1973 struct node_entry
*ne
= scsi_id
->ne
;
1976 outstanding_orb_incr
;
1977 SBP2_ORB_DEBUG("sending command orb %p, total orbs = %x",
1978 command_orb
, global_outstanding_command_orbs
);
1980 pci_dma_sync_single_for_device(hi
->host
->pdev
, command
->command_orb_dma
,
1981 sizeof(struct sbp2_command_orb
),
1982 PCI_DMA_BIDIRECTIONAL
);
1983 pci_dma_sync_single_for_device(hi
->host
->pdev
, command
->sge_dma
,
1984 sizeof(command
->scatter_gather_element
),
1985 PCI_DMA_BIDIRECTIONAL
);
1987 * Check to see if there are any previous orbs to use
1989 if (scsi_id
->last_orb
== NULL
) {
1993 * Ok, let's write to the target's management agent register
1995 addr
= scsi_id
->sbp2_command_block_agent_addr
+ SBP2_ORB_POINTER_OFFSET
;
1996 data
[0] = ORB_SET_NODE_ID(hi
->host
->node_id
);
1997 data
[1] = command
->command_orb_dma
;
1998 sbp2util_cpu_to_be32_buffer(data
, 8);
2000 SBP2_ORB_DEBUG("write command agent, command orb %p", command_orb
);
2002 if (sbp2util_node_write_no_wait(ne
, addr
, data
, 8) < 0) {
2003 SBP2_ERR("sbp2util_node_write_no_wait failed.\n");
2007 SBP2_ORB_DEBUG("write command agent complete");
2009 scsi_id
->last_orb
= command_orb
;
2010 scsi_id
->last_orb_dma
= command
->command_orb_dma
;
2016 * We have an orb already sent (maybe or maybe not
2017 * processed) that we can append this orb to. So do so,
2018 * and ring the doorbell. Have to be very careful
2019 * modifying these next orb pointers, as they are accessed
2020 * both by the sbp2 device and us.
2022 scsi_id
->last_orb
->next_ORB_lo
=
2023 cpu_to_be32(command
->command_orb_dma
);
2024 /* Tells hardware that this pointer is valid */
2025 scsi_id
->last_orb
->next_ORB_hi
= 0x0;
2026 pci_dma_sync_single_for_device(hi
->host
->pdev
,
2027 scsi_id
->last_orb_dma
,
2028 sizeof(struct sbp2_command_orb
),
2029 PCI_DMA_BIDIRECTIONAL
);
2034 data
= cpu_to_be32(command
->command_orb_dma
);
2035 addr
= scsi_id
->sbp2_command_block_agent_addr
+ SBP2_DOORBELL_OFFSET
;
2037 SBP2_ORB_DEBUG("ring doorbell, command orb %p", command_orb
);
2039 if (sbp2util_node_write_no_wait(ne
, addr
, &data
, 4) < 0) {
2040 SBP2_ERR("sbp2util_node_write_no_wait failed");
2044 scsi_id
->last_orb
= command_orb
;
2045 scsi_id
->last_orb_dma
= command
->command_orb_dma
;
2052 * This function is called in order to begin a regular SBP-2 command.
2054 static int sbp2_send_command(struct scsi_id_instance_data
*scsi_id
,
2055 struct scsi_cmnd
*SCpnt
,
2056 void (*done
)(struct scsi_cmnd
*))
2058 unchar
*cmd
= (unchar
*) SCpnt
->cmnd
;
2059 unsigned int request_bufflen
= SCpnt
->request_bufflen
;
2060 struct sbp2_command_info
*command
;
2062 SBP2_DEBUG("sbp2_send_command");
2063 #if (CONFIG_IEEE1394_SBP2_DEBUG >= 2) || defined(CONFIG_IEEE1394_SBP2_PACKET_DUMP)
2064 printk("[scsi command]\n ");
2065 scsi_print_command(SCpnt
);
2067 SBP2_DEBUG("SCSI transfer size = %x", request_bufflen
);
2068 SBP2_DEBUG("SCSI s/g elements = %x", (unsigned int)SCpnt
->use_sg
);
2071 * Allocate a command orb and s/g structure
2073 command
= sbp2util_allocate_command_orb(scsi_id
, SCpnt
, done
);
2079 * The scsi stack sends down a request_bufflen which does not match the
2080 * length field in the scsi cdb. This causes some sbp2 devices to
2081 * reject this inquiry command. Fix the request_bufflen.
2083 if (*cmd
== INQUIRY
) {
2084 if (force_inquiry_hack
|| scsi_id
->workarounds
& SBP2_BREAKAGE_INQUIRY_HACK
)
2085 request_bufflen
= cmd
[4] = 0x24;
2087 request_bufflen
= cmd
[4];
2091 * Now actually fill in the comamnd orb and sbp2 s/g list
2093 sbp2_create_command_orb(scsi_id
, command
, cmd
, SCpnt
->use_sg
,
2094 request_bufflen
, SCpnt
->request_buffer
,
2095 SCpnt
->sc_data_direction
);
2097 sbp2util_packet_dump(&command
->command_orb
, sizeof(struct sbp2_command_orb
),
2098 "sbp2 command orb", command
->command_orb_dma
);
2101 * Initialize status fifo
2103 memset(&scsi_id
->status_block
, 0, sizeof(struct sbp2_status_block
));
2106 * Link up the orb, and ring the doorbell if needed
2108 sbp2_link_orb_command(scsi_id
, command
);
2114 * Translates SBP-2 status into SCSI sense data for check conditions
2116 static unsigned int sbp2_status_to_sense_data(unchar
*sbp2_status
, unchar
*sense_data
)
2118 SBP2_DEBUG("sbp2_status_to_sense_data");
2121 * Ok, it's pretty ugly... ;-)
2123 sense_data
[0] = 0x70;
2124 sense_data
[1] = 0x0;
2125 sense_data
[2] = sbp2_status
[9];
2126 sense_data
[3] = sbp2_status
[12];
2127 sense_data
[4] = sbp2_status
[13];
2128 sense_data
[5] = sbp2_status
[14];
2129 sense_data
[6] = sbp2_status
[15];
2131 sense_data
[8] = sbp2_status
[16];
2132 sense_data
[9] = sbp2_status
[17];
2133 sense_data
[10] = sbp2_status
[18];
2134 sense_data
[11] = sbp2_status
[19];
2135 sense_data
[12] = sbp2_status
[10];
2136 sense_data
[13] = sbp2_status
[11];
2137 sense_data
[14] = sbp2_status
[20];
2138 sense_data
[15] = sbp2_status
[21];
2140 return sbp2_status
[8] & 0x3f; /* return scsi status */
2144 * This function is called after a command is completed, in order to do any necessary SBP-2
2145 * response data translations for the SCSI stack
2147 static void sbp2_check_sbp2_response(struct scsi_id_instance_data
*scsi_id
,
2148 struct scsi_cmnd
*SCpnt
)
2150 u8
*scsi_buf
= SCpnt
->request_buffer
;
2152 SBP2_DEBUG("sbp2_check_sbp2_response");
2154 switch (SCpnt
->cmnd
[0]) {
2158 * Make sure data length is ok. Minimum length is 36 bytes
2160 if (scsi_buf
[4] == 0) {
2161 scsi_buf
[4] = 36 - 5;
2165 * Fix ansi revision and response data format
2168 scsi_buf
[3] = (scsi_buf
[3] & 0xf0) | 2;
2179 * This function deals with status writes from the SBP-2 device
2181 static int sbp2_handle_status_write(struct hpsb_host
*host
, int nodeid
, int destid
,
2182 quadlet_t
*data
, u64 addr
, size_t length
, u16 fl
)
2184 struct sbp2scsi_host_info
*hi
;
2185 struct scsi_id_instance_data
*scsi_id
= NULL
, *scsi_id_tmp
;
2187 struct scsi_cmnd
*SCpnt
= NULL
;
2188 u32 scsi_status
= SBP2_SCSI_STATUS_GOOD
;
2189 struct sbp2_command_info
*command
;
2190 unsigned long flags
;
2192 SBP2_DEBUG("sbp2_handle_status_write");
2194 sbp2util_packet_dump(data
, length
, "sbp2 status write by device", (u32
)addr
);
2197 SBP2_ERR("host is NULL - this is bad!");
2198 return RCODE_ADDRESS_ERROR
;
2201 hi
= hpsb_get_hostinfo(&sbp2_highlevel
, host
);
2204 SBP2_ERR("host info is NULL - this is bad!");
2205 return RCODE_ADDRESS_ERROR
;
2209 * Find our scsi_id structure by looking at the status fifo address written to by
2212 id
= SBP2_STATUS_FIFO_OFFSET_TO_ENTRY((u32
)(addr
- SBP2_STATUS_FIFO_ADDRESS
));
2213 list_for_each_entry(scsi_id_tmp
, &hi
->scsi_ids
, scsi_list
) {
2214 if (scsi_id_tmp
->ne
->nodeid
== nodeid
&& scsi_id_tmp
->ud
->id
== id
) {
2215 scsi_id
= scsi_id_tmp
;
2221 SBP2_ERR("scsi_id is NULL - device is gone?");
2222 return RCODE_ADDRESS_ERROR
;
2226 * Put response into scsi_id status fifo...
2228 memcpy(&scsi_id
->status_block
, data
, length
);
2231 * Byte swap first two quadlets (8 bytes) of status for processing
2233 sbp2util_be32_to_cpu_buffer(&scsi_id
->status_block
, 8);
2236 * Handle command ORB status here if necessary. First, need to match status with command.
2238 command
= sbp2util_find_command_for_orb(scsi_id
, scsi_id
->status_block
.ORB_offset_lo
);
2241 SBP2_DEBUG("Found status for command ORB");
2242 pci_dma_sync_single_for_cpu(hi
->host
->pdev
, command
->command_orb_dma
,
2243 sizeof(struct sbp2_command_orb
),
2244 PCI_DMA_BIDIRECTIONAL
);
2245 pci_dma_sync_single_for_cpu(hi
->host
->pdev
, command
->sge_dma
,
2246 sizeof(command
->scatter_gather_element
),
2247 PCI_DMA_BIDIRECTIONAL
);
2249 SBP2_ORB_DEBUG("matched command orb %p", &command
->command_orb
);
2250 outstanding_orb_decr
;
2253 * Matched status with command, now grab scsi command pointers and check status
2255 SCpnt
= command
->Current_SCpnt
;
2256 sbp2util_mark_command_completed(scsi_id
, command
);
2261 * See if the target stored any scsi status information
2263 if (STATUS_GET_LENGTH(scsi_id
->status_block
.ORB_offset_hi_misc
) > 1) {
2265 * Translate SBP-2 status to SCSI sense data
2267 SBP2_DEBUG("CHECK CONDITION");
2268 scsi_status
= sbp2_status_to_sense_data((unchar
*)&scsi_id
->status_block
, SCpnt
->sense_buffer
);
2272 * Check to see if the dead bit is set. If so, we'll have to initiate
2273 * a fetch agent reset.
2275 if (STATUS_GET_DEAD_BIT(scsi_id
->status_block
.ORB_offset_hi_misc
)) {
2278 * Initiate a fetch agent reset.
2280 SBP2_DEBUG("Dead bit set - initiating fetch agent reset");
2281 sbp2_agent_reset(scsi_id
, 0);
2284 SBP2_ORB_DEBUG("completing command orb %p", &command
->command_orb
);
2288 * Check here to see if there are no commands in-use. If there are none, we can
2289 * null out last orb so that next time around we write directly to the orb pointer...
2290 * Quick start saves one 1394 bus transaction.
2292 spin_lock_irqsave(&scsi_id
->sbp2_command_orb_lock
, flags
);
2293 if (list_empty(&scsi_id
->sbp2_command_orb_inuse
)) {
2294 scsi_id
->last_orb
= NULL
;
2296 spin_unlock_irqrestore(&scsi_id
->sbp2_command_orb_lock
, flags
);
2301 * It's probably a login/logout/reconnect status.
2303 if ((scsi_id
->login_orb_dma
== scsi_id
->status_block
.ORB_offset_lo
) ||
2304 (scsi_id
->query_logins_orb_dma
== scsi_id
->status_block
.ORB_offset_lo
) ||
2305 (scsi_id
->reconnect_orb_dma
== scsi_id
->status_block
.ORB_offset_lo
) ||
2306 (scsi_id
->logout_orb_dma
== scsi_id
->status_block
.ORB_offset_lo
)) {
2307 atomic_set(&scsi_id
->sbp2_login_complete
, 1);
2313 /* Complete the SCSI command. */
2314 SBP2_DEBUG("Completing SCSI command");
2315 sbp2scsi_complete_command(scsi_id
, scsi_status
, SCpnt
,
2316 command
->Current_done
);
2317 SBP2_ORB_DEBUG("command orb completed");
2320 return RCODE_COMPLETE
;
2323 /**************************************
2324 * SCSI interface related section
2325 **************************************/
2328 * This routine is the main request entry routine for doing I/O. It is
2329 * called from the scsi stack directly.
2331 static int sbp2scsi_queuecommand(struct scsi_cmnd
*SCpnt
,
2332 void (*done
)(struct scsi_cmnd
*))
2334 struct scsi_id_instance_data
*scsi_id
=
2335 (struct scsi_id_instance_data
*)SCpnt
->device
->host
->hostdata
[0];
2336 struct sbp2scsi_host_info
*hi
;
2337 int result
= DID_NO_CONNECT
<< 16;
2339 SBP2_DEBUG("sbp2scsi_queuecommand");
2341 if (!sbp2util_node_is_available(scsi_id
))
2347 SBP2_ERR("sbp2scsi_host_info is NULL - this is bad!");
2352 * Until we handle multiple luns, just return selection time-out
2353 * to any IO directed at non-zero LUNs
2355 if (SCpnt
->device
->lun
)
2359 * Check for request sense command, and handle it here
2360 * (autorequest sense)
2362 if (SCpnt
->cmnd
[0] == REQUEST_SENSE
) {
2363 SBP2_DEBUG("REQUEST_SENSE");
2364 memcpy(SCpnt
->request_buffer
, SCpnt
->sense_buffer
, SCpnt
->request_bufflen
);
2365 memset(SCpnt
->sense_buffer
, 0, sizeof(SCpnt
->sense_buffer
));
2366 sbp2scsi_complete_command(scsi_id
, SBP2_SCSI_STATUS_GOOD
, SCpnt
, done
);
2371 * Check to see if we are in the middle of a bus reset.
2373 if (!hpsb_node_entry_valid(scsi_id
->ne
)) {
2374 SBP2_ERR("Bus reset in progress - rejecting command");
2375 result
= DID_BUS_BUSY
<< 16;
2380 * Try and send our SCSI command
2382 if (sbp2_send_command(scsi_id
, SCpnt
, done
)) {
2383 SBP2_ERR("Error sending SCSI command");
2384 sbp2scsi_complete_command(scsi_id
, SBP2_SCSI_STATUS_SELECTION_TIMEOUT
,
2390 SCpnt
->result
= result
;
2396 * This function is called in order to complete all outstanding SBP-2
2397 * commands (in case of resets, etc.).
2399 static void sbp2scsi_complete_all_commands(struct scsi_id_instance_data
*scsi_id
,
2402 struct sbp2scsi_host_info
*hi
= scsi_id
->hi
;
2403 struct list_head
*lh
;
2404 struct sbp2_command_info
*command
;
2405 unsigned long flags
;
2407 SBP2_DEBUG("sbp2scsi_complete_all_commands");
2409 spin_lock_irqsave(&scsi_id
->sbp2_command_orb_lock
, flags
);
2410 while (!list_empty(&scsi_id
->sbp2_command_orb_inuse
)) {
2411 SBP2_DEBUG("Found pending command to complete");
2412 lh
= scsi_id
->sbp2_command_orb_inuse
.next
;
2413 command
= list_entry(lh
, struct sbp2_command_info
, list
);
2414 pci_dma_sync_single_for_cpu(hi
->host
->pdev
, command
->command_orb_dma
,
2415 sizeof(struct sbp2_command_orb
),
2416 PCI_DMA_BIDIRECTIONAL
);
2417 pci_dma_sync_single_for_cpu(hi
->host
->pdev
, command
->sge_dma
,
2418 sizeof(command
->scatter_gather_element
),
2419 PCI_DMA_BIDIRECTIONAL
);
2420 sbp2util_mark_command_completed(scsi_id
, command
);
2421 if (command
->Current_SCpnt
) {
2422 command
->Current_SCpnt
->result
= status
<< 16;
2423 command
->Current_done(command
->Current_SCpnt
);
2426 spin_unlock_irqrestore(&scsi_id
->sbp2_command_orb_lock
, flags
);
2432 * This function is called in order to complete a regular SBP-2 command.
2434 * This can be called in interrupt context.
2436 static void sbp2scsi_complete_command(struct scsi_id_instance_data
*scsi_id
,
2437 u32 scsi_status
, struct scsi_cmnd
*SCpnt
,
2438 void (*done
)(struct scsi_cmnd
*))
2440 SBP2_DEBUG("sbp2scsi_complete_command");
2446 SBP2_ERR("SCpnt is NULL");
2451 * If a bus reset is in progress and there was an error, don't
2452 * complete the command, just let it get retried at the end of the
2455 if (!hpsb_node_entry_valid(scsi_id
->ne
)
2456 && (scsi_status
!= SBP2_SCSI_STATUS_GOOD
)) {
2457 SBP2_ERR("Bus reset in progress - retry command later");
2462 * Switch on scsi status
2464 switch (scsi_status
) {
2465 case SBP2_SCSI_STATUS_GOOD
:
2466 SCpnt
->result
= DID_OK
;
2469 case SBP2_SCSI_STATUS_BUSY
:
2470 SBP2_ERR("SBP2_SCSI_STATUS_BUSY");
2471 SCpnt
->result
= DID_BUS_BUSY
<< 16;
2474 case SBP2_SCSI_STATUS_CHECK_CONDITION
:
2475 SBP2_DEBUG("SBP2_SCSI_STATUS_CHECK_CONDITION");
2476 SCpnt
->result
= CHECK_CONDITION
<< 1;
2481 #if CONFIG_IEEE1394_SBP2_DEBUG >= 1
2482 scsi_print_command(SCpnt
);
2483 scsi_print_sense("bh", SCpnt
);
2488 case SBP2_SCSI_STATUS_SELECTION_TIMEOUT
:
2489 SBP2_ERR("SBP2_SCSI_STATUS_SELECTION_TIMEOUT");
2490 SCpnt
->result
= DID_NO_CONNECT
<< 16;
2491 scsi_print_command(SCpnt
);
2494 case SBP2_SCSI_STATUS_CONDITION_MET
:
2495 case SBP2_SCSI_STATUS_RESERVATION_CONFLICT
:
2496 case SBP2_SCSI_STATUS_COMMAND_TERMINATED
:
2497 SBP2_ERR("Bad SCSI status = %x", scsi_status
);
2498 SCpnt
->result
= DID_ERROR
<< 16;
2499 scsi_print_command(SCpnt
);
2503 SBP2_ERR("Unsupported SCSI status = %x", scsi_status
);
2504 SCpnt
->result
= DID_ERROR
<< 16;
2508 * Take care of any sbp2 response data mucking here (RBC stuff, etc.)
2510 if (SCpnt
->result
== DID_OK
) {
2511 sbp2_check_sbp2_response(scsi_id
, SCpnt
);
2515 * If a bus reset is in progress and there was an error, complete
2516 * the command as busy so that it will get retried.
2518 if (!hpsb_node_entry_valid(scsi_id
->ne
)
2519 && (scsi_status
!= SBP2_SCSI_STATUS_GOOD
)) {
2520 SBP2_ERR("Completing command with busy (bus reset)");
2521 SCpnt
->result
= DID_BUS_BUSY
<< 16;
2525 * If a unit attention occurs, return busy status so it gets
2526 * retried... it could have happened because of a 1394 bus reset
2530 if ((scsi_status
== SBP2_SCSI_STATUS_CHECK_CONDITION
) &&
2531 (SCpnt
->sense_buffer
[2] == UNIT_ATTENTION
)) {
2532 SBP2_DEBUG("UNIT ATTENTION - return busy");
2533 SCpnt
->result
= DID_BUS_BUSY
<< 16;
2538 * Tell scsi stack that we're done with this command
2543 static int sbp2scsi_slave_alloc(struct scsi_device
*sdev
)
2545 ((struct scsi_id_instance_data
*)sdev
->host
->hostdata
[0])->sdev
= sdev
;
2549 static int sbp2scsi_slave_configure(struct scsi_device
*sdev
)
2551 blk_queue_dma_alignment(sdev
->request_queue
, (512 - 1));
2552 sdev
->use_10_for_rw
= 1;
2553 sdev
->use_10_for_ms
= 1;
2557 static void sbp2scsi_slave_destroy(struct scsi_device
*sdev
)
2559 ((struct scsi_id_instance_data
*)sdev
->host
->hostdata
[0])->sdev
= NULL
;
2564 * Called by scsi stack when something has really gone wrong. Usually
2565 * called when a command has timed-out for some reason.
2567 static int sbp2scsi_abort(struct scsi_cmnd
*SCpnt
)
2569 struct scsi_id_instance_data
*scsi_id
=
2570 (struct scsi_id_instance_data
*)SCpnt
->device
->host
->hostdata
[0];
2571 struct sbp2scsi_host_info
*hi
= scsi_id
->hi
;
2572 struct sbp2_command_info
*command
;
2574 SBP2_ERR("aborting sbp2 command");
2575 scsi_print_command(SCpnt
);
2577 if (sbp2util_node_is_available(scsi_id
)) {
2580 * Right now, just return any matching command structures
2583 command
= sbp2util_find_command_for_SCpnt(scsi_id
, SCpnt
);
2585 SBP2_DEBUG("Found command to abort");
2586 pci_dma_sync_single_for_cpu(hi
->host
->pdev
,
2587 command
->command_orb_dma
,
2588 sizeof(struct sbp2_command_orb
),
2589 PCI_DMA_BIDIRECTIONAL
);
2590 pci_dma_sync_single_for_cpu(hi
->host
->pdev
,
2592 sizeof(command
->scatter_gather_element
),
2593 PCI_DMA_BIDIRECTIONAL
);
2594 sbp2util_mark_command_completed(scsi_id
, command
);
2595 if (command
->Current_SCpnt
) {
2596 command
->Current_SCpnt
->result
= DID_ABORT
<< 16;
2597 command
->Current_done(command
->Current_SCpnt
);
2602 * Initiate a fetch agent reset.
2604 sbp2_agent_reset(scsi_id
, 0);
2605 sbp2scsi_complete_all_commands(scsi_id
, DID_BUS_BUSY
);
2612 * Called by scsi stack when something has really gone wrong.
2614 static int sbp2scsi_reset(struct scsi_cmnd
*SCpnt
)
2616 struct scsi_id_instance_data
*scsi_id
=
2617 (struct scsi_id_instance_data
*)SCpnt
->device
->host
->hostdata
[0];
2618 unsigned long flags
;
2620 SBP2_ERR("reset requested");
2622 spin_lock_irqsave(SCpnt
->device
->host
->host_lock
, flags
);
2624 if (sbp2util_node_is_available(scsi_id
)) {
2625 SBP2_ERR("Generating sbp2 fetch agent reset");
2626 sbp2_agent_reset(scsi_id
, 0);
2629 spin_unlock_irqrestore(SCpnt
->device
->host
->host_lock
, flags
);
2634 static const char *sbp2scsi_info(struct Scsi_Host
*host
)
2636 return "SCSI emulation for IEEE-1394 SBP-2 Devices";
2639 static ssize_t
sbp2_sysfs_ieee1394_id_show(struct device
*dev
,
2640 struct device_attribute
*attr
,
2643 struct scsi_device
*sdev
;
2644 struct scsi_id_instance_data
*scsi_id
;
2647 if (!(sdev
= to_scsi_device(dev
)))
2650 if (!(scsi_id
= (struct scsi_id_instance_data
*)sdev
->host
->hostdata
[0]))
2653 lun
= ORB_SET_LUN(scsi_id
->sbp2_lun
);
2655 return sprintf(buf
, "%016Lx:%d:%d\n", (unsigned long long)scsi_id
->ne
->guid
,
2656 scsi_id
->ud
->id
, lun
);
2658 static DEVICE_ATTR(ieee1394_id
, S_IRUGO
, sbp2_sysfs_ieee1394_id_show
, NULL
);
2660 static struct device_attribute
*sbp2_sysfs_sdev_attrs
[] = {
2661 &dev_attr_ieee1394_id
,
2665 MODULE_AUTHOR("Ben Collins <bcollins@debian.org>");
2666 MODULE_DESCRIPTION("IEEE-1394 SBP-2 protocol driver");
2667 MODULE_SUPPORTED_DEVICE(SBP2_DEVICE_NAME
);
2668 MODULE_LICENSE("GPL");
2670 /* SCSI host template */
2671 static struct scsi_host_template scsi_driver_template
= {
2672 .module
= THIS_MODULE
,
2673 .name
= "SBP-2 IEEE-1394",
2674 .proc_name
= SBP2_DEVICE_NAME
,
2675 .info
= sbp2scsi_info
,
2676 .queuecommand
= sbp2scsi_queuecommand
,
2677 .eh_abort_handler
= sbp2scsi_abort
,
2678 .eh_device_reset_handler
= sbp2scsi_reset
,
2679 .eh_bus_reset_handler
= sbp2scsi_reset
,
2680 .eh_host_reset_handler
= sbp2scsi_reset
,
2681 .slave_alloc
= sbp2scsi_slave_alloc
,
2682 .slave_configure
= sbp2scsi_slave_configure
,
2683 .slave_destroy
= sbp2scsi_slave_destroy
,
2685 .sg_tablesize
= SG_ALL
,
2686 .use_clustering
= ENABLE_CLUSTERING
,
2687 .cmd_per_lun
= SBP2_MAX_CMDS
,
2688 .can_queue
= SBP2_MAX_CMDS
,
2690 .sdev_attrs
= sbp2_sysfs_sdev_attrs
,
2693 static int sbp2_module_init(void)
2697 SBP2_DEBUG("sbp2_module_init");
2699 printk(KERN_INFO
"sbp2: %s\n", version
);
2701 /* Module load debug option to force one command at a time (serializing I/O) */
2703 SBP2_INFO("Driver forced to serialize I/O (serialize_io=1)");
2704 SBP2_INFO("Try serialize_io=0 for better performance");
2705 scsi_driver_template
.can_queue
= 1;
2706 scsi_driver_template
.cmd_per_lun
= 1;
2709 /* Set max sectors (module load option). Default is 255 sectors. */
2710 scsi_driver_template
.max_sectors
= max_sectors
;
2712 /* Register our high level driver with 1394 stack */
2713 hpsb_register_highlevel(&sbp2_highlevel
);
2715 ret
= hpsb_register_protocol(&sbp2_driver
);
2717 SBP2_ERR("Failed to register protocol");
2718 hpsb_unregister_highlevel(&sbp2_highlevel
);
2725 static void __exit
sbp2_module_exit(void)
2727 SBP2_DEBUG("sbp2_module_exit");
2729 hpsb_unregister_protocol(&sbp2_driver
);
2731 hpsb_unregister_highlevel(&sbp2_highlevel
);
2734 module_init(sbp2_module_init
);
2735 module_exit(sbp2_module_exit
);