projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
sbp2: split sbp2_create_command_orb() for better readability
[linux-2.6-block.git] / drivers / ieee1394 / sbp2.c
CommitLineData
1da177e4
LT		 1/*
2 * sbp2.c - SBP-2 protocol driver for IEEE-1394
3 *
4 * Copyright (C) 2000 James Goodwin, Filanet Corporation (www.filanet.com)
5 * jamesg@filanet.com (JSG)
6 *
7 * Copyright (C) 2003 Ben Collins <bcollins@debian.org>
8 *
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.
13 *
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.
18 *
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.
22 */
23
24/*
25 * Brief Description:
26 *
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.
31 *
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.).
34 *
35 * Current Issues:
36 *
37 * - Error Handling: SCSI aborts and bus reset requests are handled somewhat
38 * but the code needs additional debugging.
39 */
40
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>
47#include <linux/fs.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>
58
59#include <asm/current.h>
60#include <asm/uaccess.h>
61#include <asm/io.h>
62#include <asm/byteorder.h>
63#include <asm/atomic.h>
64#include <asm/system.h>
65#include <asm/scatterlist.h>
66
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>
72
73#include "csr1212.h"
74#include "ieee1394.h"
75#include "ieee1394_types.h"
76#include "ieee1394_core.h"
77#include "nodemgr.h"
78#include "hosts.h"
79#include "highlevel.h"
80#include "ieee1394_transactions.h"
81#include "sbp2.h"
82
1da177e4
LT		 83/*
84 * Module load parameter definitions
85 */
86
87/*
88 * Change max_speed on module load if you have a bad IEEE-1394
89 * controller that has trouble running 2KB packets at 400mb.
90 *
91 * NOTE: On certain OHCI parts I have seen short packets on async transmit
92 * (probably due to PCI latency/throughput issues with the part). You can
93 * bump down the speed if you are running into problems.
94 */
95static int max_speed = IEEE1394_SPEED_MAX;
96module_param(max_speed, int, 0644);
2bab359a 97MODULE_PARM_DESC(max_speed, "Force max speed (3 = 800mb, 2 = 400mb, 1 = 200mb, 0 = 100mb)");
1da177e4
LT		 98
99/*
100 * Set serialize_io to 1 if you'd like only one scsi command sent
101 * down to us at a time (debugging). This might be necessary for very
102 * badly behaved sbp2 devices.
2bab359a
JM		 103 *
104 * TODO: Make this configurable per device.
1da177e4 105 */
2bab359a 106static int serialize_io = 1;
1da177e4 107module_param(serialize_io, int, 0444);
2bab359a 108MODULE_PARM_DESC(serialize_io, "Serialize I/O coming from scsi drivers (default = 1, faster = 0)");
1da177e4
LT		 109
110/*
111 * Bump up max_sectors if you'd like to support very large sized
112 * transfers. Please note that some older sbp2 bridge chips are broken for
113 * transfers greater or equal to 128KB. Default is a value of 255
114 * sectors, or just under 128KB (at 512 byte sector size). I can note that
115 * the Oxsemi sbp2 chipsets have no problems supporting very large
116 * transfer sizes.
117 */
118static int max_sectors = SBP2_MAX_SECTORS;
119module_param(max_sectors, int, 0444);
120MODULE_PARM_DESC(max_sectors, "Change max sectors per I/O supported (default = 255)");
121
122/*
123 * Exclusive login to sbp2 device? In most cases, the sbp2 driver should
124 * do an exclusive login, as it's generally unsafe to have two hosts
125 * talking to a single sbp2 device at the same time (filesystem coherency,
126 * etc.). If you're running an sbp2 device that supports multiple logins,
127 * and you're either running read-only filesystems or some sort of special
128 * filesystem supporting multiple hosts (one such filesystem is OpenGFS,
129 * see opengfs.sourceforge.net for more info), then set exclusive_login
130 * to zero. Note: The Oxsemi OXFW911 sbp2 chipset supports up to four
131 * concurrent logins.
132 */
133static int exclusive_login = 1;
134module_param(exclusive_login, int, 0644);
135MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device (default = 1)");
136
137/*
138 * SCSI inquiry hack for really badly behaved sbp2 devices. Turn this on
139 * if your sbp2 device is not properly handling the SCSI inquiry command.
140 * This hack makes the inquiry look more like a typical MS Windows
141 * inquiry.
142 *
143 * If force_inquiry_hack=1 is required for your device to work,
144 * please submit the logged sbp2_firmware_revision value of this device to
145 * the linux1394-devel mailing list.
146 */
1934b8b6 147static int force_inquiry_hack;
1da177e4
LT		 148module_param(force_inquiry_hack, int, 0444);
149MODULE_PARM_DESC(force_inquiry_hack, "Force SCSI inquiry hack (default = 0)");
150
1da177e4
LT		 151/*
152 * Export information about protocols/devices supported by this driver.
153 */
154static struct ieee1394_device_id sbp2_id_table[] = {
155 {
a237f35f
SR		 156 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
157 .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY & 0xffffff,
158 .version = SBP2_SW_VERSION_ENTRY & 0xffffff},
159 {}
1da177e4
LT		 160};
161
162MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
163
164/*
165 * Debug levels, configured via kernel config, or enable here.
166 */
167
44456d37 168#define CONFIG_IEEE1394_SBP2_DEBUG 0
1da177e4
LT		 169/* #define CONFIG_IEEE1394_SBP2_DEBUG_ORBS */
170/* #define CONFIG_IEEE1394_SBP2_DEBUG_DMA */
171/* #define CONFIG_IEEE1394_SBP2_DEBUG 1 */
172/* #define CONFIG_IEEE1394_SBP2_DEBUG 2 */
173/* #define CONFIG_IEEE1394_SBP2_PACKET_DUMP */
174
175#ifdef CONFIG_IEEE1394_SBP2_DEBUG_ORBS
176#define SBP2_ORB_DEBUG(fmt, args...) HPSB_ERR("sbp2(%s): "fmt, __FUNCTION__, ## args)
177static u32 global_outstanding_command_orbs = 0;
178#define outstanding_orb_incr global_outstanding_command_orbs++
179#define outstanding_orb_decr global_outstanding_command_orbs--
180#else
181#define SBP2_ORB_DEBUG(fmt, args...)
182#define outstanding_orb_incr
183#define outstanding_orb_decr
184#endif
185
186#ifdef CONFIG_IEEE1394_SBP2_DEBUG_DMA
187#define SBP2_DMA_ALLOC(fmt, args...) \
188 HPSB_ERR("sbp2(%s)alloc(%d): "fmt, __FUNCTION__, \
189 ++global_outstanding_dmas, ## args)
190#define SBP2_DMA_FREE(fmt, args...) \
191 HPSB_ERR("sbp2(%s)free(%d): "fmt, __FUNCTION__, \
192 --global_outstanding_dmas, ## args)
193static u32 global_outstanding_dmas = 0;
194#else
195#define SBP2_DMA_ALLOC(fmt, args...)
196#define SBP2_DMA_FREE(fmt, args...)
197#endif
198
199#if CONFIG_IEEE1394_SBP2_DEBUG >= 2
200#define SBP2_DEBUG(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args)
201#define SBP2_INFO(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args)
202#define SBP2_NOTICE(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args)
203#define SBP2_WARN(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args)
204#elif CONFIG_IEEE1394_SBP2_DEBUG == 1
205#define SBP2_DEBUG(fmt, args...) HPSB_DEBUG("sbp2: "fmt, ## args)
206#define SBP2_INFO(fmt, args...) HPSB_INFO("sbp2: "fmt, ## args)
207#define SBP2_NOTICE(fmt, args...) HPSB_NOTICE("sbp2: "fmt, ## args)
208#define SBP2_WARN(fmt, args...) HPSB_WARN("sbp2: "fmt, ## args)
209#else
210#define SBP2_DEBUG(fmt, args...)
211#define SBP2_INFO(fmt, args...) HPSB_INFO("sbp2: "fmt, ## args)
212#define SBP2_NOTICE(fmt, args...) HPSB_NOTICE("sbp2: "fmt, ## args)
213#define SBP2_WARN(fmt, args...) HPSB_WARN("sbp2: "fmt, ## args)
214#endif
215
216#define SBP2_ERR(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args)
217
1da177e4
LT		 218/*
219 * Globals
220 */
221
222static void sbp2scsi_complete_all_commands(struct scsi_id_instance_data *scsi_id,
223 u32 status);
224
225static void sbp2scsi_complete_command(struct scsi_id_instance_data *scsi_id,
226 u32 scsi_status, struct scsi_cmnd *SCpnt,
227 void (*done)(struct scsi_cmnd *));
228
229static struct scsi_host_template scsi_driver_template;
230
231static const u8 sbp2_speedto_max_payload[] = { 0x7, 0x8, 0x9, 0xA, 0xB, 0xC };
232
233static void sbp2_host_reset(struct hpsb_host *host);
234
235static int sbp2_probe(struct device *dev);
236static int sbp2_remove(struct device *dev);
237static int sbp2_update(struct unit_directory *ud);
238
239static struct hpsb_highlevel sbp2_highlevel = {
240 .name = SBP2_DEVICE_NAME,
241 .host_reset = sbp2_host_reset,
242};
243
244static struct hpsb_address_ops sbp2_ops = {
245 .write = sbp2_handle_status_write
246};
247
248#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
249static struct hpsb_address_ops sbp2_physdma_ops = {
a237f35f
SR		 250 .read = sbp2_handle_physdma_read,
251 .write = sbp2_handle_physdma_write,
1da177e4
LT		 252};
253#endif
254
255static struct hpsb_protocol_driver sbp2_driver = {
256 .name = "SBP2 Driver",
257 .id_table = sbp2_id_table,
258 .update = sbp2_update,
259 .driver = {
260 .name = SBP2_DEVICE_NAME,
261 .bus = &ieee1394_bus_type,
262 .probe = sbp2_probe,
263 .remove = sbp2_remove,
264 },
265};
266
267
268/* List of device firmware's that require a forced 36 byte inquiry. */
269static u32 sbp2_broken_inquiry_list[] = {
270 0x00002800, /* Stefan Richter <richtest@bauwesen.tu-cottbus.de> */
271 /* DViCO Momobay CX-1 */
272 0x00000200 /* Andreas Plesch <plesch@fas.harvard.edu> */
273 /* QPS Fire DVDBurner */
274};
275
276#define NUM_BROKEN_INQUIRY_DEVS \
277 (sizeof(sbp2_broken_inquiry_list)/sizeof(*sbp2_broken_inquiry_list))
278
279/**************************************
280 * General utility functions
281 **************************************/
282
1da177e4
LT		 283#ifndef __BIG_ENDIAN
284/*
285 * Converts a buffer from be32 to cpu byte ordering. Length is in bytes.
286 */
287static __inline__ void sbp2util_be32_to_cpu_buffer(void *buffer, int length)
288{
289 u32 *temp = buffer;
290
291 for (length = (length >> 2); length--; )
292 temp[length] = be32_to_cpu(temp[length]);
293
294 return;
295}
296
297/*
298 * Converts a buffer from cpu to be32 byte ordering. Length is in bytes.
299 */
300static __inline__ void sbp2util_cpu_to_be32_buffer(void *buffer, int length)
301{
302 u32 *temp = buffer;
303
304 for (length = (length >> 2); length--; )
305 temp[length] = cpu_to_be32(temp[length]);
306
307 return;
308}
309#else /* BIG_ENDIAN */
310/* Why waste the cpu cycles? */
311#define sbp2util_be32_to_cpu_buffer(x,y)
312#define sbp2util_cpu_to_be32_buffer(x,y)
313#endif
314
315#ifdef CONFIG_IEEE1394_SBP2_PACKET_DUMP
316/*
317 * Debug packet dump routine. Length is in bytes.
318 */
a237f35f
SR		 319static void sbp2util_packet_dump(void *buffer, int length, char *dump_name,
320 u32 dump_phys_addr)
1da177e4
LT		 321{
322 int i;
323 unsigned char *dump = buffer;
324
325 if (!dump || !length || !dump_name)
326 return;
327
328 if (dump_phys_addr)
329 printk("[%s, 0x%x]", dump_name, dump_phys_addr);
330 else
331 printk("[%s]", dump_name);
332 for (i = 0; i < length; i++) {
333 if (i > 0x3f) {
334 printk("\n ...");
335 break;
336 }
337 if ((i & 0x3) == 0)
338 printk(" ");
339 if ((i & 0xf) == 0)
340 printk("\n ");
a237f35f 341 printk("%02x ", (int)dump[i]);
1da177e4
LT		 342 }
343 printk("\n");
344
345 return;
346}
347#else
348#define sbp2util_packet_dump(w,x,y,z)
349#endif
350
351/*
352 * Goofy routine that basically does a down_timeout function.
353 */
354static int sbp2util_down_timeout(atomic_t *done, int timeout)
355{
356 int i;
357
358 for (i = timeout; (i > 0 && atomic_read(done) == 0); i-= HZ/10) {
359 if (msleep_interruptible(100)) /* 100ms */
a237f35f 360 return 1;
1da177e4 361 }
a237f35f 362 return (i > 0) ? 0 : 1;
1da177e4
LT		 363}
364
365/* Free's an allocated packet */
366static void sbp2_free_packet(struct hpsb_packet *packet)
367{
368 hpsb_free_tlabel(packet);
369 hpsb_free_packet(packet);
370}
371
372/* This is much like hpsb_node_write(), except it ignores the response
373 * subaction and returns immediately. Can be used from interrupts.
374 */
375static int sbp2util_node_write_no_wait(struct node_entry *ne, u64 addr,
a237f35f 376 quadlet_t *buffer, size_t length)
1da177e4
LT		 377{
378 struct hpsb_packet *packet;
379
380 packet = hpsb_make_writepacket(ne->host, ne->nodeid,
381 addr, buffer, length);
a237f35f
SR		 382 if (!packet)
383 return -ENOMEM;
1da177e4 384
a237f35f
SR		 385 hpsb_set_packet_complete_task(packet,
386 (void (*)(void *))sbp2_free_packet,
1da177e4
LT		 387 packet);
388
389 hpsb_node_fill_packet(ne, packet);
390
a237f35f 391 if (hpsb_send_packet(packet) < 0) {
1da177e4
LT		 392 sbp2_free_packet(packet);
393 return -EIO;
394 }
395
396 return 0;
397}
398
399/*
400 * This function is called to create a pool of command orbs used for
401 * command processing. It is called when a new sbp2 device is detected.
402 */
403static int sbp2util_create_command_orb_pool(struct scsi_id_instance_data *scsi_id)
404{
405 struct sbp2scsi_host_info *hi = scsi_id->hi;
406 int i;
407 unsigned long flags, orbs;
408 struct sbp2_command_info *command;
409
410 orbs = serialize_io ? 2 : SBP2_MAX_CMDS;
411
412 spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
413 for (i = 0; i < orbs; i++) {
8551158a 414 command = kzalloc(sizeof(*command), GFP_ATOMIC);
1da177e4 415 if (!command) {
a237f35f
SR		 416 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock,
417 flags);
418 return -ENOMEM;
1da177e4 419 }
1da177e4 420 command->command_orb_dma =
a237f35f
SR		 421 pci_map_single(hi->host->pdev, &command->command_orb,
422 sizeof(struct sbp2_command_orb),
423 PCI_DMA_BIDIRECTIONAL);
1da177e4
LT		 424 SBP2_DMA_ALLOC("single command orb DMA");
425 command->sge_dma =
a237f35f
SR		 426 pci_map_single(hi->host->pdev,
427 &command->scatter_gather_element,
428 sizeof(command->scatter_gather_element),
429 PCI_DMA_BIDIRECTIONAL);
1da177e4
LT		 430 SBP2_DMA_ALLOC("scatter_gather_element");
431 INIT_LIST_HEAD(&command->list);
432 list_add_tail(&command->list, &scsi_id->sbp2_command_orb_completed);
433 }
434 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
435 return 0;
436}
437
438/*
439 * This function is called to delete a pool of command orbs.
440 */
441static void sbp2util_remove_command_orb_pool(struct scsi_id_instance_data *scsi_id)
442{
443 struct hpsb_host *host = scsi_id->hi->host;
444 struct list_head *lh, *next;
445 struct sbp2_command_info *command;
446 unsigned long flags;
447
448 spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
449 if (!list_empty(&scsi_id->sbp2_command_orb_completed)) {
450 list_for_each_safe(lh, next, &scsi_id->sbp2_command_orb_completed) {
451 command = list_entry(lh, struct sbp2_command_info, list);
452
453 /* Release our generic DMA's */
454 pci_unmap_single(host->pdev, command->command_orb_dma,
455 sizeof(struct sbp2_command_orb),
456 PCI_DMA_BIDIRECTIONAL);
457 SBP2_DMA_FREE("single command orb DMA");
458 pci_unmap_single(host->pdev, command->sge_dma,
459 sizeof(command->scatter_gather_element),
460 PCI_DMA_BIDIRECTIONAL);
461 SBP2_DMA_FREE("scatter_gather_element");
462
463 kfree(command);
464 }
465 }
466 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
467 return;
468}
469
470/*
471 * This function finds the sbp2_command for a given outstanding command
472 * orb.Only looks at the inuse list.
473 */
474static struct sbp2_command_info *sbp2util_find_command_for_orb(
475 struct scsi_id_instance_data *scsi_id, dma_addr_t orb)
476{
477 struct sbp2_command_info *command;
478 unsigned long flags;
479
480 spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
481 if (!list_empty(&scsi_id->sbp2_command_orb_inuse)) {
482 list_for_each_entry(command, &scsi_id->sbp2_command_orb_inuse, list) {
483 if (command->command_orb_dma == orb) {
484 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
a237f35f 485 return command;
1da177e4
LT		 486 }
487 }
488 }
489 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
490
491 SBP2_ORB_DEBUG("could not match command orb %x", (unsigned int)orb);
492
a237f35f 493 return NULL;
1da177e4
LT		 494}
495
496/*
497 * This function finds the sbp2_command for a given outstanding SCpnt.
498 * Only looks at the inuse list.
499 */
500static struct sbp2_command_info *sbp2util_find_command_for_SCpnt(struct scsi_id_instance_data *scsi_id, void *SCpnt)
501{
502 struct sbp2_command_info *command;
503 unsigned long flags;
504
505 spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
506 if (!list_empty(&scsi_id->sbp2_command_orb_inuse)) {
507 list_for_each_entry(command, &scsi_id->sbp2_command_orb_inuse, list) {
508 if (command->Current_SCpnt == SCpnt) {
509 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
a237f35f 510 return command;
1da177e4
LT		 511 }
512 }
513 }
514 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
a237f35f 515 return NULL;
1da177e4
LT		 516}
517
518/*
519 * This function allocates a command orb used to send a scsi command.
520 */
521static struct sbp2_command_info *sbp2util_allocate_command_orb(
522 struct scsi_id_instance_data *scsi_id,
523 struct scsi_cmnd *Current_SCpnt,
524 void (*Current_done)(struct scsi_cmnd *))
525{
526 struct list_head *lh;
527 struct sbp2_command_info *command = NULL;
528 unsigned long flags;
529
530 spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
531 if (!list_empty(&scsi_id->sbp2_command_orb_completed)) {
532 lh = scsi_id->sbp2_command_orb_completed.next;
533 list_del(lh);
534 command = list_entry(lh, struct sbp2_command_info, list);
535 command->Current_done = Current_done;
536 command->Current_SCpnt = Current_SCpnt;
537 list_add_tail(&command->list, &scsi_id->sbp2_command_orb_inuse);
538 } else {
539 SBP2_ERR("sbp2util_allocate_command_orb - No orbs available!");
540 }
541 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
a237f35f 542 return command;
1da177e4
LT		 543}
544
545/* Free our DMA's */
546static void sbp2util_free_command_dma(struct sbp2_command_info *command)
547{
548 struct scsi_id_instance_data *scsi_id =
549 (struct scsi_id_instance_data *)command->Current_SCpnt->device->host->hostdata[0];
550 struct hpsb_host *host;
551
552 if (!scsi_id) {
553 printk(KERN_ERR "%s: scsi_id == NULL\n", __FUNCTION__);
554 return;
555 }
556
557 host = scsi_id->ud->ne->host;
558
559 if (command->cmd_dma) {
560 if (command->dma_type == CMD_DMA_SINGLE) {
561 pci_unmap_single(host->pdev, command->cmd_dma,
562 command->dma_size, command->dma_dir);
563 SBP2_DMA_FREE("single bulk");
564 } else if (command->dma_type == CMD_DMA_PAGE) {
565 pci_unmap_page(host->pdev, command->cmd_dma,
566 command->dma_size, command->dma_dir);
567 SBP2_DMA_FREE("single page");
568 } /* XXX: Check for CMD_DMA_NONE bug */
569 command->dma_type = CMD_DMA_NONE;
570 command->cmd_dma = 0;
571 }
572
573 if (command->sge_buffer) {
574 pci_unmap_sg(host->pdev, command->sge_buffer,
575 command->dma_size, command->dma_dir);
576 SBP2_DMA_FREE("scatter list");
577 command->sge_buffer = NULL;
578 }
579}
580
581/*
582 * This function moves a command to the completed orb list.
583 */
a237f35f
SR		 584static void sbp2util_mark_command_completed(struct scsi_id_instance_data *scsi_id,
585 struct sbp2_command_info *command)
1da177e4
LT		 586{
587 unsigned long flags;
588
589 spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
590 list_del(&command->list);
591 sbp2util_free_command_dma(command);
592 list_add_tail(&command->list, &scsi_id->sbp2_command_orb_completed);
593 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
594}
595
abd559b1
JM		 596/*
597 * Is scsi_id valid? Is the 1394 node still present?
598 */
599static inline int sbp2util_node_is_available(struct scsi_id_instance_data *scsi_id)
600{
601 return scsi_id && scsi_id->ne && !scsi_id->ne->in_limbo;
602}
603
1da177e4
LT		 604/*********************************************
605 * IEEE-1394 core driver stack related section
606 *********************************************/
607static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud);
608
609static int sbp2_probe(struct device *dev)
610{
611 struct unit_directory *ud;
612 struct scsi_id_instance_data *scsi_id;
613
614 SBP2_DEBUG("sbp2_probe");
615
616 ud = container_of(dev, struct unit_directory, device);
617
618 /* Don't probe UD's that have the LUN flag. We'll probe the LUN(s)
619 * instead. */
620 if (ud->flags & UNIT_DIRECTORY_HAS_LUN_DIRECTORY)
621 return -ENODEV;
622
a237f35f 623 scsi_id = sbp2_alloc_device(ud);
1da177e4 624
a237f35f
SR		 625 if (!scsi_id)
626 return -ENOMEM;
1da177e4 627
a237f35f 628 sbp2_parse_unit_directory(scsi_id, ud);
1da177e4 629
a237f35f 630 return sbp2_start_device(scsi_id);
1da177e4
LT		 631}
632
633static int sbp2_remove(struct device *dev)
634{
635 struct unit_directory *ud;
636 struct scsi_id_instance_data *scsi_id;
abd559b1 637 struct scsi_device *sdev;
1da177e4
LT		 638
639 SBP2_DEBUG("sbp2_remove");
640
641 ud = container_of(dev, struct unit_directory, device);
642 scsi_id = ud->device.driver_data;
abd559b1
JM		 643 if (!scsi_id)
644 return 0;
645
646 /* Trigger shutdown functions in scsi's highlevel. */
647 if (scsi_id->scsi_host)
648 scsi_unblock_requests(scsi_id->scsi_host);
649 sdev = scsi_id->sdev;
650 if (sdev) {
651 scsi_id->sdev = NULL;
652 scsi_remove_device(sdev);
653 }
1da177e4
LT		 654
655 sbp2_logout_device(scsi_id);
656 sbp2_remove_device(scsi_id);
657
658 return 0;
659}
660
661static int sbp2_update(struct unit_directory *ud)
662{
663 struct scsi_id_instance_data *scsi_id = ud->device.driver_data;
664
665 SBP2_DEBUG("sbp2_update");
666
667 if (sbp2_reconnect_device(scsi_id)) {
668
669 /*
670 * Ok, reconnect has failed. Perhaps we didn't
671 * reconnect fast enough. Try doing a regular login, but
672 * first do a logout just in case of any weirdness.
673 */
674 sbp2_logout_device(scsi_id);
675
676 if (sbp2_login_device(scsi_id)) {
677 /* Login failed too, just fail, and the backend
678 * will call our sbp2_remove for us */
679 SBP2_ERR("Failed to reconnect to sbp2 device!");
680 return -EBUSY;
681 }
682 }
683
684 /* Set max retries to something large on the device. */
685 sbp2_set_busy_timeout(scsi_id);
686
687 /* Do a SBP-2 fetch agent reset. */
688 sbp2_agent_reset(scsi_id, 1);
689
690 /* Get the max speed and packet size that we can use. */
691 sbp2_max_speed_and_size(scsi_id);
692
693 /* Complete any pending commands with busy (so they get
694 * retried) and remove them from our queue
695 */
696 sbp2scsi_complete_all_commands(scsi_id, DID_BUS_BUSY);
697
698 /* Make sure we unblock requests (since this is likely after a bus
699 * reset). */
700 scsi_unblock_requests(scsi_id->scsi_host);
701
702 return 0;
703}
704
705/* This functions is called by the sbp2_probe, for each new device. We now
706 * allocate one scsi host for each scsi_id (unit directory). */
707static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud)
708{
709 struct sbp2scsi_host_info *hi;
710 struct Scsi_Host *scsi_host = NULL;
711 struct scsi_id_instance_data *scsi_id = NULL;
712
713 SBP2_DEBUG("sbp2_alloc_device");
714
8551158a 715 scsi_id = kzalloc(sizeof(*scsi_id), GFP_KERNEL);
1da177e4
LT		 716 if (!scsi_id) {
717 SBP2_ERR("failed to create scsi_id");
718 goto failed_alloc;
719 }
1da177e4
LT		 720
721 scsi_id->ne = ud->ne;
722 scsi_id->ud = ud;
723 scsi_id->speed_code = IEEE1394_SPEED_100;
724 scsi_id->max_payload_size = sbp2_speedto_max_payload[IEEE1394_SPEED_100];
725 atomic_set(&scsi_id->sbp2_login_complete, 0);
726 INIT_LIST_HEAD(&scsi_id->sbp2_command_orb_inuse);
727 INIT_LIST_HEAD(&scsi_id->sbp2_command_orb_completed);
728 INIT_LIST_HEAD(&scsi_id->scsi_list);
729 spin_lock_init(&scsi_id->sbp2_command_orb_lock);
e309fc6d 730 scsi_id->sbp2_lun = 0;
1da177e4
LT		 731
732 ud->device.driver_data = scsi_id;
733
734 hi = hpsb_get_hostinfo(&sbp2_highlevel, ud->ne->host);
735 if (!hi) {
736 hi = hpsb_create_hostinfo(&sbp2_highlevel, ud->ne->host, sizeof(*hi));
737 if (!hi) {
738 SBP2_ERR("failed to allocate hostinfo");
739 goto failed_alloc;
740 }
741 SBP2_DEBUG("sbp2_alloc_device: allocated hostinfo");
742 hi->host = ud->ne->host;
743 INIT_LIST_HEAD(&hi->scsi_ids);
744
745 /* Register our sbp2 status address space... */
746 hpsb_register_addrspace(&sbp2_highlevel, ud->ne->host, &sbp2_ops,
747 SBP2_STATUS_FIFO_ADDRESS,
748 SBP2_STATUS_FIFO_ADDRESS +
749 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(SBP2_MAX_UDS_PER_NODE+1));
750#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
751 /* Handle data movement if physical dma is not
752 * enabled/supportedon host controller */
753 hpsb_register_addrspace(&sbp2_highlevel, ud->ne->host, &sbp2_physdma_ops,
754 0x0ULL, 0xfffffffcULL);
755#endif
756 }
757
758 scsi_id->hi = hi;
759
760 list_add_tail(&scsi_id->scsi_list, &hi->scsi_ids);
761
762 /* Register our host with the SCSI stack. */
a2ef79e1 763 scsi_host = scsi_host_alloc(&scsi_driver_template,
a237f35f 764 sizeof(unsigned long));
1da177e4
LT		 765 if (!scsi_host) {
766 SBP2_ERR("failed to register scsi host");
767 goto failed_alloc;
768 }
769
770 scsi_host->hostdata[0] = (unsigned long)scsi_id;
771
772 if (!scsi_add_host(scsi_host, &ud->device)) {
773 scsi_id->scsi_host = scsi_host;
774 return scsi_id;
775 }
776
777 SBP2_ERR("failed to add scsi host");
778 scsi_host_put(scsi_host);
779
780failed_alloc:
781 sbp2_remove_device(scsi_id);
782 return NULL;
783}
784
1da177e4
LT		 785static void sbp2_host_reset(struct hpsb_host *host)
786{
787 struct sbp2scsi_host_info *hi;
788 struct scsi_id_instance_data *scsi_id;
789
790 hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
791
792 if (hi) {
793 list_for_each_entry(scsi_id, &hi->scsi_ids, scsi_list)
794 scsi_block_requests(scsi_id->scsi_host);
795 }
796}
797
1da177e4
LT		 798/*
799 * This function is where we first pull the node unique ids, and then
800 * allocate memory and register a SBP-2 device.
801 */
802static int sbp2_start_device(struct scsi_id_instance_data *scsi_id)
803{
804 struct sbp2scsi_host_info *hi = scsi_id->hi;
146f7262 805 int error;
1da177e4
LT		 806
807 SBP2_DEBUG("sbp2_start_device");
808
809 /* Login FIFO DMA */
810 scsi_id->login_response =
a237f35f
SR		 811 pci_alloc_consistent(hi->host->pdev,
812 sizeof(struct sbp2_login_response),
1da177e4
LT		 813 &scsi_id->login_response_dma);
814 if (!scsi_id->login_response)
815 goto alloc_fail;
816 SBP2_DMA_ALLOC("consistent DMA region for login FIFO");
817
818 /* Query logins ORB DMA */
819 scsi_id->query_logins_orb =
a237f35f
SR		 820 pci_alloc_consistent(hi->host->pdev,
821 sizeof(struct sbp2_query_logins_orb),
1da177e4
LT		 822 &scsi_id->query_logins_orb_dma);
823 if (!scsi_id->query_logins_orb)
824 goto alloc_fail;
825 SBP2_DMA_ALLOC("consistent DMA region for query logins ORB");
826
827 /* Query logins response DMA */
828 scsi_id->query_logins_response =
a237f35f
SR		 829 pci_alloc_consistent(hi->host->pdev,
830 sizeof(struct sbp2_query_logins_response),
1da177e4
LT		 831 &scsi_id->query_logins_response_dma);
832 if (!scsi_id->query_logins_response)
833 goto alloc_fail;
834 SBP2_DMA_ALLOC("consistent DMA region for query logins response");
835
836 /* Reconnect ORB DMA */
837 scsi_id->reconnect_orb =
a237f35f
SR		 838 pci_alloc_consistent(hi->host->pdev,
839 sizeof(struct sbp2_reconnect_orb),
1da177e4
LT		 840 &scsi_id->reconnect_orb_dma);
841 if (!scsi_id->reconnect_orb)
842 goto alloc_fail;
843 SBP2_DMA_ALLOC("consistent DMA region for reconnect ORB");
844
845 /* Logout ORB DMA */
846 scsi_id->logout_orb =
a237f35f
SR		 847 pci_alloc_consistent(hi->host->pdev,
848 sizeof(struct sbp2_logout_orb),
1da177e4
LT		 849 &scsi_id->logout_orb_dma);
850 if (!scsi_id->logout_orb)
851 goto alloc_fail;
852 SBP2_DMA_ALLOC("consistent DMA region for logout ORB");
853
854 /* Login ORB DMA */
855 scsi_id->login_orb =
a237f35f
SR		 856 pci_alloc_consistent(hi->host->pdev,
857 sizeof(struct sbp2_login_orb),
1da177e4
LT		 858 &scsi_id->login_orb_dma);
859 if (!scsi_id->login_orb) {
860alloc_fail:
861 if (scsi_id->query_logins_response) {
862 pci_free_consistent(hi->host->pdev,
863 sizeof(struct sbp2_query_logins_response),
864 scsi_id->query_logins_response,
865 scsi_id->query_logins_response_dma);
866 SBP2_DMA_FREE("query logins response DMA");
867 }
868
869 if (scsi_id->query_logins_orb) {
870 pci_free_consistent(hi->host->pdev,
871 sizeof(struct sbp2_query_logins_orb),
872 scsi_id->query_logins_orb,
873 scsi_id->query_logins_orb_dma);
874 SBP2_DMA_FREE("query logins ORB DMA");
875 }
876
877 if (scsi_id->logout_orb) {
878 pci_free_consistent(hi->host->pdev,
a237f35f
SR		 879 sizeof(struct sbp2_logout_orb),
880 scsi_id->logout_orb,
881 scsi_id->logout_orb_dma);
1da177e4
LT		 882 SBP2_DMA_FREE("logout ORB DMA");
883 }
884
885 if (scsi_id->reconnect_orb) {
886 pci_free_consistent(hi->host->pdev,
a237f35f
SR		 887 sizeof(struct sbp2_reconnect_orb),
888 scsi_id->reconnect_orb,
889 scsi_id->reconnect_orb_dma);
1da177e4
LT		 890 SBP2_DMA_FREE("reconnect ORB DMA");
891 }
892
893 if (scsi_id->login_response) {
894 pci_free_consistent(hi->host->pdev,
a237f35f
SR		 895 sizeof(struct sbp2_login_response),
896 scsi_id->login_response,
897 scsi_id->login_response_dma);
1da177e4
LT		 898 SBP2_DMA_FREE("login FIFO DMA");
899 }
900
901 list_del(&scsi_id->scsi_list);
902
903 kfree(scsi_id);
904
a237f35f 905 SBP2_ERR("Could not allocate memory for scsi_id");
1da177e4
LT		 906
907 return -ENOMEM;
908 }
909 SBP2_DMA_ALLOC("consistent DMA region for login ORB");
910
911 SBP2_DEBUG("New SBP-2 device inserted, SCSI ID = %x", scsi_id->ud->id);
912
913 /*
914 * Create our command orb pool
915 */
916 if (sbp2util_create_command_orb_pool(scsi_id)) {
917 SBP2_ERR("sbp2util_create_command_orb_pool failed!");
918 sbp2_remove_device(scsi_id);
919 return -ENOMEM;
920 }
921
922 /* Schedule a timeout here. The reason is that we may be so close
923 * to a bus reset, that the device is not available for logins.
924 * This can happen when the bus reset is caused by the host
925 * connected to the sbp2 device being removed. That host would
926 * have a certain amount of time to relogin before the sbp2 device
927 * allows someone else to login instead. One second makes sense. */
928 msleep_interruptible(1000);
929 if (signal_pending(current)) {
930 SBP2_WARN("aborting sbp2_start_device due to event");
931 sbp2_remove_device(scsi_id);
932 return -EINTR;
933 }
a237f35f 934
1da177e4
LT		 935 /*
936 * Login to the sbp-2 device
937 */
938 if (sbp2_login_device(scsi_id)) {
939 /* Login failed, just remove the device. */
940 sbp2_remove_device(scsi_id);
941 return -EBUSY;
942 }
943
944 /*
945 * Set max retries to something large on the device
946 */
947 sbp2_set_busy_timeout(scsi_id);
948
949 /*
950 * Do a SBP-2 fetch agent reset
951 */
952 sbp2_agent_reset(scsi_id, 1);
953
954 /*
955 * Get the max speed and packet size that we can use
956 */
957 sbp2_max_speed_and_size(scsi_id);
958
959 /* Add this device to the scsi layer now */
146f7262
JB		 960 error = scsi_add_device(scsi_id->scsi_host, 0, scsi_id->ud->id, 0);
961 if (error) {
1da177e4 962 SBP2_ERR("scsi_add_device failed");
dc3edd54
SR		 963 sbp2_logout_device(scsi_id);
964 sbp2_remove_device(scsi_id);
146f7262 965 return error;
1da177e4
LT		 966 }
967
968 return 0;
969}
970
971/*
972 * This function removes an sbp2 device from the sbp2scsi_host_info struct.
973 */
974static void sbp2_remove_device(struct scsi_id_instance_data *scsi_id)
975{
976 struct sbp2scsi_host_info *hi;
977
978 SBP2_DEBUG("sbp2_remove_device");
979
980 if (!scsi_id)
981 return;
982
983 hi = scsi_id->hi;
984
985 /* This will remove our scsi device aswell */
986 if (scsi_id->scsi_host) {
987 scsi_remove_host(scsi_id->scsi_host);
988 scsi_host_put(scsi_id->scsi_host);
989 }
990
991 sbp2util_remove_command_orb_pool(scsi_id);
992
993 list_del(&scsi_id->scsi_list);
994
995 if (scsi_id->login_response) {
996 pci_free_consistent(hi->host->pdev,
997 sizeof(struct sbp2_login_response),
998 scsi_id->login_response,
999 scsi_id->login_response_dma);
1000 SBP2_DMA_FREE("single login FIFO");
1001 }
1002
1003 if (scsi_id->login_orb) {
1004 pci_free_consistent(hi->host->pdev,
1005 sizeof(struct sbp2_login_orb),
1006 scsi_id->login_orb,
1007 scsi_id->login_orb_dma);
1008 SBP2_DMA_FREE("single login ORB");
1009 }
1010
1011 if (scsi_id->reconnect_orb) {
1012 pci_free_consistent(hi->host->pdev,
1013 sizeof(struct sbp2_reconnect_orb),
1014 scsi_id->reconnect_orb,
1015 scsi_id->reconnect_orb_dma);
1016 SBP2_DMA_FREE("single reconnect orb");
1017 }
1018
1019 if (scsi_id->logout_orb) {
1020 pci_free_consistent(hi->host->pdev,
1021 sizeof(struct sbp2_logout_orb),
1022 scsi_id->logout_orb,
1023 scsi_id->logout_orb_dma);
1024 SBP2_DMA_FREE("single logout orb");
1025 }
1026
1027 if (scsi_id->query_logins_orb) {
1028 pci_free_consistent(hi->host->pdev,
1029 sizeof(struct sbp2_query_logins_orb),
1030 scsi_id->query_logins_orb,
1031 scsi_id->query_logins_orb_dma);
1032 SBP2_DMA_FREE("single query logins orb");
1033 }
1034
1035 if (scsi_id->query_logins_response) {
1036 pci_free_consistent(hi->host->pdev,
1037 sizeof(struct sbp2_query_logins_response),
1038 scsi_id->query_logins_response,
1039 scsi_id->query_logins_response_dma);
1040 SBP2_DMA_FREE("single query logins data");
1041 }
1042
1043 scsi_id->ud->device.driver_data = NULL;
1044
1045 SBP2_DEBUG("SBP-2 device removed, SCSI ID = %d", scsi_id->ud->id);
1046
1047 kfree(scsi_id);
1048}
1049
1050#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
1051/*
1052 * This function deals with physical dma write requests (for adapters that do not support
1053 * physical dma in hardware). Mostly just here for debugging...
1054 */
a237f35f
SR		 1055static int sbp2_handle_physdma_write(struct hpsb_host *host, int nodeid,
1056 int destid, quadlet_t *data, u64 addr,
1057 size_t length, u16 flags)
1da177e4
LT		 1058{
1059
a237f35f
SR		 1060 /*
1061 * Manually put the data in the right place.
1062 */
1063 memcpy(bus_to_virt((u32) addr), data, length);
1064 sbp2util_packet_dump(data, length, "sbp2 phys dma write by device",
1065 (u32) addr);
1066 return RCODE_COMPLETE;
1da177e4
LT		 1067}
1068
1069/*
1070 * This function deals with physical dma read requests (for adapters that do not support
1071 * physical dma in hardware). Mostly just here for debugging...
1072 */
a237f35f
SR		 1073static int sbp2_handle_physdma_read(struct hpsb_host *host, int nodeid,
1074 quadlet_t *data, u64 addr, size_t length,
1075 u16 flags)
1da177e4
LT		 1076{
1077
a237f35f
SR		 1078 /*
1079 * Grab data from memory and send a read response.
1080 */
1081 memcpy(data, bus_to_virt((u32) addr), length);
1082 sbp2util_packet_dump(data, length, "sbp2 phys dma read by device",
1083 (u32) addr);
1084 return RCODE_COMPLETE;
1da177e4
LT		 1085}
1086#endif
1087
1da177e4
LT		 1088/**************************************
1089 * SBP-2 protocol related section
1090 **************************************/
1091
1da177e4
LT		 1092/*
1093 * This function queries the device for the maximum concurrent logins it
1094 * supports.
1095 */
1096static int sbp2_query_logins(struct scsi_id_instance_data *scsi_id)
1097{
1098 struct sbp2scsi_host_info *hi = scsi_id->hi;
1099 quadlet_t data[2];
1100 int max_logins;
1101 int active_logins;
1102
1103 SBP2_DEBUG("sbp2_query_logins");
1104
1105 scsi_id->query_logins_orb->reserved1 = 0x0;
1106 scsi_id->query_logins_orb->reserved2 = 0x0;
1107
1108 scsi_id->query_logins_orb->query_response_lo = scsi_id->query_logins_response_dma;
1109 scsi_id->query_logins_orb->query_response_hi = ORB_SET_NODE_ID(hi->host->node_id);
1110 SBP2_DEBUG("sbp2_query_logins: query_response_hi/lo initialized");
1111
1112 scsi_id->query_logins_orb->lun_misc = ORB_SET_FUNCTION(SBP2_QUERY_LOGINS_REQUEST);
1113 scsi_id->query_logins_orb->lun_misc |= ORB_SET_NOTIFY(1);
e309fc6d 1114 scsi_id->query_logins_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_lun);
1da177e4
LT		 1115 SBP2_DEBUG("sbp2_query_logins: lun_misc initialized");
1116
1117 scsi_id->query_logins_orb->reserved_resp_length =
1118 ORB_SET_QUERY_LOGINS_RESP_LENGTH(sizeof(struct sbp2_query_logins_response));
1119 SBP2_DEBUG("sbp2_query_logins: reserved_resp_length initialized");
1120
1121 scsi_id->query_logins_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
1122 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
1123 scsi_id->query_logins_orb->status_FIFO_hi = (ORB_SET_NODE_ID(hi->host->node_id) |
1124 SBP2_STATUS_FIFO_ADDRESS_HI);
1125 SBP2_DEBUG("sbp2_query_logins: status FIFO initialized");
1126
1127 sbp2util_cpu_to_be32_buffer(scsi_id->query_logins_orb, sizeof(struct sbp2_query_logins_orb));
1128
1129 SBP2_DEBUG("sbp2_query_logins: orb byte-swapped");
1130
1131 sbp2util_packet_dump(scsi_id->query_logins_orb, sizeof(struct sbp2_query_logins_orb),
1132 "sbp2 query logins orb", scsi_id->query_logins_orb_dma);
1133
1134 memset(scsi_id->query_logins_response, 0, sizeof(struct sbp2_query_logins_response));
1135 memset(&scsi_id->status_block, 0, sizeof(struct sbp2_status_block));
1136
1137 SBP2_DEBUG("sbp2_query_logins: query_logins_response/status FIFO memset");
1138
1139 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1140 data[1] = scsi_id->query_logins_orb_dma;
1141 sbp2util_cpu_to_be32_buffer(data, 8);
1142
1143 atomic_set(&scsi_id->sbp2_login_complete, 0);
1144
1145 SBP2_DEBUG("sbp2_query_logins: prepared to write");
1146 hpsb_node_write(scsi_id->ne, scsi_id->sbp2_management_agent_addr, data, 8);
1147 SBP2_DEBUG("sbp2_query_logins: written");
1148
1149 if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, 2*HZ)) {
1150 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
a237f35f 1151 return -EIO;
1da177e4
LT		 1152 }
1153
1154 if (scsi_id->status_block.ORB_offset_lo != scsi_id->query_logins_orb_dma) {
1155 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
a237f35f 1156 return -EIO;
1da177e4
LT		 1157 }
1158
1159 if (STATUS_GET_RESP(scsi_id->status_block.ORB_offset_hi_misc) ||
1160 STATUS_GET_DEAD_BIT(scsi_id->status_block.ORB_offset_hi_misc) ||
1161 STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) {
1162
1163 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
a237f35f 1164 return -EIO;
1da177e4
LT		 1165 }
1166
1167 sbp2util_cpu_to_be32_buffer(scsi_id->query_logins_response, sizeof(struct sbp2_query_logins_response));
1168
1169 SBP2_DEBUG("length_max_logins = %x",
1170 (unsigned int)scsi_id->query_logins_response->length_max_logins);
1171
1172 SBP2_DEBUG("Query logins to SBP-2 device successful");
1173
1174 max_logins = RESPONSE_GET_MAX_LOGINS(scsi_id->query_logins_response->length_max_logins);
1175 SBP2_DEBUG("Maximum concurrent logins supported: %d", max_logins);
1176
1177 active_logins = RESPONSE_GET_ACTIVE_LOGINS(scsi_id->query_logins_response->length_max_logins);
1178 SBP2_DEBUG("Number of active logins: %d", active_logins);
1179
1180 if (active_logins >= max_logins) {
a237f35f 1181 return -EIO;
1da177e4
LT		 1182 }
1183
1184 return 0;
1185}
1186
1187/*
1188 * This function is called in order to login to a particular SBP-2 device,
1189 * after a bus reset.
1190 */
1191static int sbp2_login_device(struct scsi_id_instance_data *scsi_id)
1192{
1193 struct sbp2scsi_host_info *hi = scsi_id->hi;
1194 quadlet_t data[2];
1195
1196 SBP2_DEBUG("sbp2_login_device");
1197
1198 if (!scsi_id->login_orb) {
1199 SBP2_DEBUG("sbp2_login_device: login_orb not alloc'd!");
a237f35f 1200 return -EIO;
1da177e4
LT		 1201 }
1202
1203 if (!exclusive_login) {
1204 if (sbp2_query_logins(scsi_id)) {
1205 SBP2_INFO("Device does not support any more concurrent logins");
a237f35f 1206 return -EIO;
1da177e4
LT		 1207 }
1208 }
1209
1210 /* Set-up login ORB, assume no password */
1211 scsi_id->login_orb->password_hi = 0;
1212 scsi_id->login_orb->password_lo = 0;
1213 SBP2_DEBUG("sbp2_login_device: password_hi/lo initialized");
1214
1215 scsi_id->login_orb->login_response_lo = scsi_id->login_response_dma;
1216 scsi_id->login_orb->login_response_hi = ORB_SET_NODE_ID(hi->host->node_id);
1217 SBP2_DEBUG("sbp2_login_device: login_response_hi/lo initialized");
1218
1219 scsi_id->login_orb->lun_misc = ORB_SET_FUNCTION(SBP2_LOGIN_REQUEST);
1220 scsi_id->login_orb->lun_misc |= ORB_SET_RECONNECT(0); /* One second reconnect time */
1221 scsi_id->login_orb->lun_misc |= ORB_SET_EXCLUSIVE(exclusive_login); /* Exclusive access to device */
1222 scsi_id->login_orb->lun_misc |= ORB_SET_NOTIFY(1); /* Notify us of login complete */
e309fc6d 1223 scsi_id->login_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_lun);
1da177e4
LT		 1224 SBP2_DEBUG("sbp2_login_device: lun_misc initialized");
1225
1226 scsi_id->login_orb->passwd_resp_lengths =
1227 ORB_SET_LOGIN_RESP_LENGTH(sizeof(struct sbp2_login_response));
1228 SBP2_DEBUG("sbp2_login_device: passwd_resp_lengths initialized");
1229
1230 scsi_id->login_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
1231 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
1232 scsi_id->login_orb->status_FIFO_hi = (ORB_SET_NODE_ID(hi->host->node_id) |
1233 SBP2_STATUS_FIFO_ADDRESS_HI);
1234 SBP2_DEBUG("sbp2_login_device: status FIFO initialized");
1235
1236 /*
1237 * Byte swap ORB if necessary
1238 */
1239 sbp2util_cpu_to_be32_buffer(scsi_id->login_orb, sizeof(struct sbp2_login_orb));
1240
1241 SBP2_DEBUG("sbp2_login_device: orb byte-swapped");
1242
1243 sbp2util_packet_dump(scsi_id->login_orb, sizeof(struct sbp2_login_orb),
1244 "sbp2 login orb", scsi_id->login_orb_dma);
1245
1246 /*
1247 * Initialize login response and status fifo
1248 */
1249 memset(scsi_id->login_response, 0, sizeof(struct sbp2_login_response));
1250 memset(&scsi_id->status_block, 0, sizeof(struct sbp2_status_block));
1251
1252 SBP2_DEBUG("sbp2_login_device: login_response/status FIFO memset");
1253
1254 /*
1255 * Ok, let's write to the target's management agent register
1256 */
1257 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1258 data[1] = scsi_id->login_orb_dma;
1259 sbp2util_cpu_to_be32_buffer(data, 8);
1260
1261 atomic_set(&scsi_id->sbp2_login_complete, 0);
1262
1263 SBP2_DEBUG("sbp2_login_device: prepared to write to %08x",
1264 (unsigned int)scsi_id->sbp2_management_agent_addr);
1265 hpsb_node_write(scsi_id->ne, scsi_id->sbp2_management_agent_addr, data, 8);
1266 SBP2_DEBUG("sbp2_login_device: written");
1267
1268 /*
1269 * Wait for login status (up to 20 seconds)...
1270 */
1271 if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, 20*HZ)) {
1272 SBP2_ERR("Error logging into SBP-2 device - login timed-out");
a237f35f 1273 return -EIO;
1da177e4
LT		 1274 }
1275
1276 /*
1277 * Sanity. Make sure status returned matches login orb.
1278 */
1279 if (scsi_id->status_block.ORB_offset_lo != scsi_id->login_orb_dma) {
1280 SBP2_ERR("Error logging into SBP-2 device - login timed-out");
a237f35f 1281 return -EIO;
1da177e4
LT		 1282 }
1283
1284 /*
1285 * Check status
1286 */
1287 if (STATUS_GET_RESP(scsi_id->status_block.ORB_offset_hi_misc) ||
1288 STATUS_GET_DEAD_BIT(scsi_id->status_block.ORB_offset_hi_misc) ||
1289 STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) {
1290
1291 SBP2_ERR("Error logging into SBP-2 device - login failed");
a237f35f 1292 return -EIO;
1da177e4
LT		 1293 }
1294
1295 /*
1296 * Byte swap the login response, for use when reconnecting or
1297 * logging out.
1298 */
1299 sbp2util_cpu_to_be32_buffer(scsi_id->login_response, sizeof(struct sbp2_login_response));
1300
1301 /*
1302 * Grab our command block agent address from the login response.
1303 */
1304 SBP2_DEBUG("command_block_agent_hi = %x",
1305 (unsigned int)scsi_id->login_response->command_block_agent_hi);
1306 SBP2_DEBUG("command_block_agent_lo = %x",
1307 (unsigned int)scsi_id->login_response->command_block_agent_lo);
1308
1309 scsi_id->sbp2_command_block_agent_addr =
1310 ((u64)scsi_id->login_response->command_block_agent_hi) << 32;
1311 scsi_id->sbp2_command_block_agent_addr |= ((u64)scsi_id->login_response->command_block_agent_lo);
1312 scsi_id->sbp2_command_block_agent_addr &= 0x0000ffffffffffffULL;
1313
1314 SBP2_INFO("Logged into SBP-2 device");
1315
a237f35f 1316 return 0;
1da177e4
LT		 1317
1318}
1319
1320/*
1321 * This function is called in order to logout from a particular SBP-2
1322 * device, usually called during driver unload.
1323 */
1324static int sbp2_logout_device(struct scsi_id_instance_data *scsi_id)
1325{
1326 struct sbp2scsi_host_info *hi = scsi_id->hi;
1327 quadlet_t data[2];
1328 int error;
1329
1330 SBP2_DEBUG("sbp2_logout_device");
1331
1332 /*
1333 * Set-up logout ORB
1334 */
1335 scsi_id->logout_orb->reserved1 = 0x0;
1336 scsi_id->logout_orb->reserved2 = 0x0;
1337 scsi_id->logout_orb->reserved3 = 0x0;
1338 scsi_id->logout_orb->reserved4 = 0x0;
1339
1340 scsi_id->logout_orb->login_ID_misc = ORB_SET_FUNCTION(SBP2_LOGOUT_REQUEST);
1341 scsi_id->logout_orb->login_ID_misc |= ORB_SET_LOGIN_ID(scsi_id->login_response->length_login_ID);
1342
1343 /* Notify us when complete */
1344 scsi_id->logout_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
1345
1346 scsi_id->logout_orb->reserved5 = 0x0;
1347 scsi_id->logout_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
1348 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
1349 scsi_id->logout_orb->status_FIFO_hi = (ORB_SET_NODE_ID(hi->host->node_id) |
1350 SBP2_STATUS_FIFO_ADDRESS_HI);
1351
1352 /*
1353 * Byte swap ORB if necessary
1354 */
1355 sbp2util_cpu_to_be32_buffer(scsi_id->logout_orb, sizeof(struct sbp2_logout_orb));
1356
1357 sbp2util_packet_dump(scsi_id->logout_orb, sizeof(struct sbp2_logout_orb),
1358 "sbp2 logout orb", scsi_id->logout_orb_dma);
1359
1360 /*
1361 * Ok, let's write to the target's management agent register
1362 */
1363 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1364 data[1] = scsi_id->logout_orb_dma;
1365 sbp2util_cpu_to_be32_buffer(data, 8);
1366
1367 atomic_set(&scsi_id->sbp2_login_complete, 0);
1368
1369 error = hpsb_node_write(scsi_id->ne,
a237f35f 1370 scsi_id->sbp2_management_agent_addr, data, 8);
1da177e4
LT		 1371 if (error)
1372 return error;
1373
1374 /* Wait for device to logout...1 second. */
1375 if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, HZ))
1376 return -EIO;
1377
1378 SBP2_INFO("Logged out of SBP-2 device");
1379
a237f35f 1380 return 0;
1da177e4
LT		 1381
1382}
1383
1384/*
1385 * This function is called in order to reconnect to a particular SBP-2
1386 * device, after a bus reset.
1387 */
1388static int sbp2_reconnect_device(struct scsi_id_instance_data *scsi_id)
1389{
1390 struct sbp2scsi_host_info *hi = scsi_id->hi;
1391 quadlet_t data[2];
1392 int error;
1393
1394 SBP2_DEBUG("sbp2_reconnect_device");
1395
1396 /*
1397 * Set-up reconnect ORB
1398 */
1399 scsi_id->reconnect_orb->reserved1 = 0x0;
1400 scsi_id->reconnect_orb->reserved2 = 0x0;
1401 scsi_id->reconnect_orb->reserved3 = 0x0;
1402 scsi_id->reconnect_orb->reserved4 = 0x0;
1403
1404 scsi_id->reconnect_orb->login_ID_misc = ORB_SET_FUNCTION(SBP2_RECONNECT_REQUEST);
1405 scsi_id->reconnect_orb->login_ID_misc |=
1406 ORB_SET_LOGIN_ID(scsi_id->login_response->length_login_ID);
1407
1408 /* Notify us when complete */
1409 scsi_id->reconnect_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
1410
1411 scsi_id->reconnect_orb->reserved5 = 0x0;
1412 scsi_id->reconnect_orb->status_FIFO_lo = SBP2_STATUS_FIFO_ADDRESS_LO +
1413 SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(scsi_id->ud->id);
1414 scsi_id->reconnect_orb->status_FIFO_hi =
1415 (ORB_SET_NODE_ID(hi->host->node_id) | SBP2_STATUS_FIFO_ADDRESS_HI);
1416
1417 /*
1418 * Byte swap ORB if necessary
1419 */
1420 sbp2util_cpu_to_be32_buffer(scsi_id->reconnect_orb, sizeof(struct sbp2_reconnect_orb));
1421
1422 sbp2util_packet_dump(scsi_id->reconnect_orb, sizeof(struct sbp2_reconnect_orb),
1423 "sbp2 reconnect orb", scsi_id->reconnect_orb_dma);
1424
1425 /*
1426 * Initialize status fifo
1427 */
1428 memset(&scsi_id->status_block, 0, sizeof(struct sbp2_status_block));
1429
1430 /*
1431 * Ok, let's write to the target's management agent register
1432 */
1433 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1434 data[1] = scsi_id->reconnect_orb_dma;
1435 sbp2util_cpu_to_be32_buffer(data, 8);
1436
1437 atomic_set(&scsi_id->sbp2_login_complete, 0);
1438
1439 error = hpsb_node_write(scsi_id->ne,
a237f35f 1440 scsi_id->sbp2_management_agent_addr, data, 8);
1da177e4
LT		 1441 if (error)
1442 return error;
1443
1444 /*
1445 * Wait for reconnect status (up to 1 second)...
1446 */
1447 if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, HZ)) {
1448 SBP2_ERR("Error reconnecting to SBP-2 device - reconnect timed-out");
a237f35f 1449 return -EIO;
1da177e4
LT		 1450 }
1451
1452 /*
1453 * Sanity. Make sure status returned matches reconnect orb.
1454 */
1455 if (scsi_id->status_block.ORB_offset_lo != scsi_id->reconnect_orb_dma) {
1456 SBP2_ERR("Error reconnecting to SBP-2 device - reconnect timed-out");
a237f35f 1457 return -EIO;
1da177e4
LT		 1458 }
1459
1460 /*
1461 * Check status
1462 */
1463 if (STATUS_GET_RESP(scsi_id->status_block.ORB_offset_hi_misc) ||
1464 STATUS_GET_DEAD_BIT(scsi_id->status_block.ORB_offset_hi_misc) ||
1465 STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) {
1466
1467 SBP2_ERR("Error reconnecting to SBP-2 device - reconnect failed");
a237f35f 1468 return -EIO;
1da177e4
LT		 1469 }
1470
1471 HPSB_DEBUG("Reconnected to SBP-2 device");
1472
a237f35f 1473 return 0;
1da177e4
LT		 1474
1475}
1476
1477/*
1478 * This function is called in order to set the busy timeout (number of
1479 * retries to attempt) on the sbp2 device.
1480 */
1481static int sbp2_set_busy_timeout(struct scsi_id_instance_data *scsi_id)
1482{
1483 quadlet_t data;
1484
1485 SBP2_DEBUG("sbp2_set_busy_timeout");
1486
1487 /*
1488 * Ok, let's write to the target's busy timeout register
1489 */
1490 data = cpu_to_be32(SBP2_BUSY_TIMEOUT_VALUE);
1491
1492 if (hpsb_node_write(scsi_id->ne, SBP2_BUSY_TIMEOUT_ADDRESS, &data, 4)) {
1493 SBP2_ERR("sbp2_set_busy_timeout error");
1494 }
1495
a237f35f 1496 return 0;
1da177e4
LT		 1497}
1498
1da177e4
LT		 1499/*
1500 * This function is called to parse sbp2 device's config rom unit
1501 * directory. Used to determine things like sbp2 management agent offset,
1502 * and command set used (SCSI or RBC).
1503 */
1504static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id,
1505 struct unit_directory *ud)
1506{
1507 struct csr1212_keyval *kv;
1508 struct csr1212_dentry *dentry;
1509 u64 management_agent_addr;
1510 u32 command_set_spec_id, command_set, unit_characteristics,
a237f35f 1511 firmware_revision, workarounds;
1da177e4
LT		 1512 int i;
1513
1514 SBP2_DEBUG("sbp2_parse_unit_directory");
1515
1516 management_agent_addr = 0x0;
1517 command_set_spec_id = 0x0;
1518 command_set = 0x0;
1519 unit_characteristics = 0x0;
1520 firmware_revision = 0x0;
1521
1522 /* Handle different fields in the unit directory, based on keys */
1523 csr1212_for_each_dir_entry(ud->ne->csr, kv, ud->ud_kv, dentry) {
1524 switch (kv->key.id) {
1525 case CSR1212_KV_ID_DEPENDENT_INFO:
1526 if (kv->key.type == CSR1212_KV_TYPE_CSR_OFFSET) {
1527 /* Save off the management agent address */
1528 management_agent_addr =
a237f35f
SR		 1529 CSR1212_REGISTER_SPACE_BASE +
1530 (kv->value.csr_offset << 2);
1da177e4
LT		 1531
1532 SBP2_DEBUG("sbp2_management_agent_addr = %x",
a237f35f 1533 (unsigned int)management_agent_addr);
1da177e4 1534 } else if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE) {
a237f35f
SR		 1535 scsi_id->sbp2_lun =
1536 ORB_SET_LUN(kv->value.immediate);
1da177e4
LT		 1537 }
1538 break;
1539
1540 case SBP2_COMMAND_SET_SPEC_ID_KEY:
1541 /* Command spec organization */
1542 command_set_spec_id = kv->value.immediate;
1543 SBP2_DEBUG("sbp2_command_set_spec_id = %x",
a237f35f 1544 (unsigned int)command_set_spec_id);
1da177e4
LT		 1545 break;
1546
1547 case SBP2_COMMAND_SET_KEY:
1548 /* Command set used by sbp2 device */
1549 command_set = kv->value.immediate;
1550 SBP2_DEBUG("sbp2_command_set = %x",
a237f35f 1551 (unsigned int)command_set);
1da177e4
LT		 1552 break;
1553
1554 case SBP2_UNIT_CHARACTERISTICS_KEY:
1555 /*
1556 * Unit characterisitcs (orb related stuff
1557 * that I'm not yet paying attention to)
1558 */
1559 unit_characteristics = kv->value.immediate;
1560 SBP2_DEBUG("sbp2_unit_characteristics = %x",
a237f35f 1561 (unsigned int)unit_characteristics);
1da177e4
LT		 1562 break;
1563
1564 case SBP2_FIRMWARE_REVISION_KEY:
1565 /* Firmware revision */
1566 firmware_revision = kv->value.immediate;
1567 if (force_inquiry_hack)
1568 SBP2_INFO("sbp2_firmware_revision = %x",
a237f35f
SR		 1569 (unsigned int)firmware_revision);
1570 else
1571 SBP2_DEBUG("sbp2_firmware_revision = %x",
1572 (unsigned int)firmware_revision);
1da177e4
LT		 1573 break;
1574
1575 default:
1576 break;
1577 }
1578 }
1579
1580 /* This is the start of our broken device checking. We try to hack
1581 * around oddities and known defects. */
1582 workarounds = 0x0;
1583
1584 /* If the vendor id is 0xa0b8 (Symbios vendor id), then we have a
1585 * bridge with 128KB max transfer size limitation. For sanity, we
1586 * only voice this when the current max_sectors setting
1587 * exceeds the 128k limit. By default, that is not the case.
1588 *
1589 * It would be really nice if we could detect this before the scsi
1590 * host gets initialized. That way we can down-force the
1591 * max_sectors to account for it. That is not currently
1592 * possible. */
1593 if ((firmware_revision & 0xffff00) ==
1594 SBP2_128KB_BROKEN_FIRMWARE &&
1595 (max_sectors * 512) > (128*1024)) {
1596 SBP2_WARN("Node " NODE_BUS_FMT ": Bridge only supports 128KB max transfer size.",
1597 NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid));
1598 SBP2_WARN("WARNING: Current max_sectors setting is larger than 128KB (%d sectors)!",
1599 max_sectors);
1600 workarounds |= SBP2_BREAKAGE_128K_MAX_TRANSFER;
1601 }
1602
1603 /* Check for a blacklisted set of devices that require us to force
1604 * a 36 byte host inquiry. This can be overriden as a module param
1605 * (to force all hosts). */
1606 for (i = 0; i < NUM_BROKEN_INQUIRY_DEVS; i++) {
1607 if ((firmware_revision & 0xffff00) ==
1608 sbp2_broken_inquiry_list[i]) {
1609 SBP2_WARN("Node " NODE_BUS_FMT ": Using 36byte inquiry workaround",
1610 NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid));
1611 workarounds |= SBP2_BREAKAGE_INQUIRY_HACK;
1612 break; /* No need to continue. */
1613 }
1614 }
1615
1616 /* If this is a logical unit directory entry, process the parent
1617 * to get the values. */
1618 if (ud->flags & UNIT_DIRECTORY_LUN_DIRECTORY) {
1619 struct unit_directory *parent_ud =
1620 container_of(ud->device.parent, struct unit_directory, device);
1621 sbp2_parse_unit_directory(scsi_id, parent_ud);
1622 } else {
1623 scsi_id->sbp2_management_agent_addr = management_agent_addr;
1624 scsi_id->sbp2_command_set_spec_id = command_set_spec_id;
1625 scsi_id->sbp2_command_set = command_set;
1626 scsi_id->sbp2_unit_characteristics = unit_characteristics;
1627 scsi_id->sbp2_firmware_revision = firmware_revision;
1628 scsi_id->workarounds = workarounds;
1629 if (ud->flags & UNIT_DIRECTORY_HAS_LUN)
e309fc6d 1630 scsi_id->sbp2_lun = ORB_SET_LUN(ud->lun);
1da177e4
LT		 1631 }
1632}
1633
1634/*
1635 * This function is called in order to determine the max speed and packet
1636 * size we can use in our ORBs. Note, that we (the driver and host) only
1637 * initiate the transaction. The SBP-2 device actually transfers the data
1638 * (by reading from the DMA area we tell it). This means that the SBP-2
1639 * device decides the actual maximum data it can transfer. We just tell it
1640 * the speed that it needs to use, and the max_rec the host supports, and
1641 * it takes care of the rest.
1642 */
1643static int sbp2_max_speed_and_size(struct scsi_id_instance_data *scsi_id)
1644{
1645 struct sbp2scsi_host_info *hi = scsi_id->hi;
1646
1647 SBP2_DEBUG("sbp2_max_speed_and_size");
1648
1649 /* Initial setting comes from the hosts speed map */
a237f35f
SR		 1650 scsi_id->speed_code =
1651 hi->host->speed_map[NODEID_TO_NODE(hi->host->node_id) * 64 +
1652 NODEID_TO_NODE(scsi_id->ne->nodeid)];
1da177e4
LT		 1653
1654 /* Bump down our speed if the user requested it */
1655 if (scsi_id->speed_code > max_speed) {
1656 scsi_id->speed_code = max_speed;
1657 SBP2_ERR("Forcing SBP-2 max speed down to %s",
1658 hpsb_speedto_str[scsi_id->speed_code]);
1659 }
1660
1661 /* Payload size is the lesser of what our speed supports and what
1662 * our host supports. */
a237f35f
SR		 1663 scsi_id->max_payload_size =
1664 min(sbp2_speedto_max_payload[scsi_id->speed_code],
1665 (u8) (hi->host->csr.max_rec - 1));
1da177e4
LT		 1666
1667 HPSB_DEBUG("Node " NODE_BUS_FMT ": Max speed [%s] - Max payload [%u]",
1668 NODE_BUS_ARGS(hi->host, scsi_id->ne->nodeid),
1669 hpsb_speedto_str[scsi_id->speed_code],
a237f35f 1670 1 << ((u32) scsi_id->max_payload_size + 2));
1da177e4 1671
a237f35f 1672 return 0;
1da177e4
LT		 1673}
1674
1675/*
1676 * This function is called in order to perform a SBP-2 agent reset.
1677 */
1678static int sbp2_agent_reset(struct scsi_id_instance_data *scsi_id, int wait)
1679{
1680 quadlet_t data;
1681 u64 addr;
1682 int retval;
1683
1684 SBP2_DEBUG("sbp2_agent_reset");
1685
1686 /*
1687 * Ok, let's write to the target's management agent register
1688 */
1689 data = ntohl(SBP2_AGENT_RESET_DATA);
1690 addr = scsi_id->sbp2_command_block_agent_addr + SBP2_AGENT_RESET_OFFSET;
1691
1692 if (wait)
1693 retval = hpsb_node_write(scsi_id->ne, addr, &data, 4);
1694 else
1695 retval = sbp2util_node_write_no_wait(scsi_id->ne, addr, &data, 4);
1696
1697 if (retval < 0) {
1698 SBP2_ERR("hpsb_node_write failed.\n");
1699 return -EIO;
1700 }
1701
1702 /*
1703 * Need to make sure orb pointer is written on next command
1704 */
1705 scsi_id->last_orb = NULL;
1706
a237f35f 1707 return 0;
1da177e4
LT		 1708}
1709
cf8d2c09
SR		 1710static void sbp2_prep_command_orb_sg(struct sbp2_command_orb *orb,
1711 struct sbp2scsi_host_info *hi,
1712 struct sbp2_command_info *command,
1713 unsigned int scsi_use_sg,
1714 struct scatterlist *sgpnt,
1715 u32 orb_direction,
1716 enum dma_data_direction dma_dir)
1717{
1718 command->dma_dir = dma_dir;
1719 orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id);
1720 orb->misc |= ORB_SET_DIRECTION(orb_direction);
1721
1722 /* Special case if only one element (and less than 64KB in size) */
1723 if ((scsi_use_sg == 1) &&
1724 (sgpnt[0].length <= SBP2_MAX_SG_ELEMENT_LENGTH)) {
1725
1726 SBP2_DEBUG("Only one s/g element");
1727 command->dma_size = sgpnt[0].length;
1728 command->dma_type = CMD_DMA_PAGE;
1729 command->cmd_dma = pci_map_page(hi->host->pdev,
1730 sgpnt[0].page,
1731 sgpnt[0].offset,
1732 command->dma_size,
1733 command->dma_dir);
1734 SBP2_DMA_ALLOC("single page scatter element");
1735
1736 orb->data_descriptor_lo = command->cmd_dma;
1737 orb->misc |= ORB_SET_DATA_SIZE(command->dma_size);
1738
1739 } else {
1740 struct sbp2_unrestricted_page_table *sg_element =
1741 &command->scatter_gather_element[0];
1742 u32 sg_count, sg_len;
1743 dma_addr_t sg_addr;
1744 int i, count = pci_map_sg(hi->host->pdev, sgpnt, scsi_use_sg,
1745 dma_dir);
1746
1747 SBP2_DMA_ALLOC("scatter list");
1748
1749 command->dma_size = scsi_use_sg;
1750 command->sge_buffer = sgpnt;
1751
1752 /* use page tables (s/g) */
1753 orb->misc |= ORB_SET_PAGE_TABLE_PRESENT(0x1);
1754 orb->data_descriptor_lo = command->sge_dma;
1755
1756 /*
1757 * Loop through and fill out our sbp-2 page tables
1758 * (and split up anything too large)
1759 */
1760 for (i = 0, sg_count = 0 ; i < count; i++, sgpnt++) {
1761 sg_len = sg_dma_len(sgpnt);
1762 sg_addr = sg_dma_address(sgpnt);
1763 while (sg_len) {
1764 sg_element[sg_count].segment_base_lo = sg_addr;
1765 if (sg_len > SBP2_MAX_SG_ELEMENT_LENGTH) {
1766 sg_element[sg_count].length_segment_base_hi =
1767 PAGE_TABLE_SET_SEGMENT_LENGTH(SBP2_MAX_SG_ELEMENT_LENGTH);
1768 sg_addr += SBP2_MAX_SG_ELEMENT_LENGTH;
1769 sg_len -= SBP2_MAX_SG_ELEMENT_LENGTH;
1770 } else {
1771 sg_element[sg_count].length_segment_base_hi =
1772 PAGE_TABLE_SET_SEGMENT_LENGTH(sg_len);
1773 sg_len = 0;
1774 }
1775 sg_count++;
1776 }
1777 }
1778
1779 /* Number of page table (s/g) elements */
1780 orb->misc |= ORB_SET_DATA_SIZE(sg_count);
1781
1782 sbp2util_packet_dump(sg_element,
1783 (sizeof(struct sbp2_unrestricted_page_table)) * sg_count,
1784 "sbp2 s/g list", command->sge_dma);
1785
1786 /* Byte swap page tables if necessary */
1787 sbp2util_cpu_to_be32_buffer(sg_element,
1788 (sizeof(struct sbp2_unrestricted_page_table)) *
1789 sg_count);
1790 }
1791}
1792
1793static void sbp2_prep_command_orb_no_sg(struct sbp2_command_orb *orb,
1794 struct sbp2scsi_host_info *hi,
1795 struct sbp2_command_info *command,
1796 struct scatterlist *sgpnt,
1797 u32 orb_direction,
1798 unsigned int scsi_request_bufflen,
1799 void *scsi_request_buffer,
1800 enum dma_data_direction dma_dir)
1801{
1802 command->dma_dir = dma_dir;
1803 command->dma_size = scsi_request_bufflen;
1804 command->dma_type = CMD_DMA_SINGLE;
1805 command->cmd_dma = pci_map_single(hi->host->pdev, scsi_request_buffer,
1806 command->dma_size, command->dma_dir);
1807 orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id);
1808 orb->misc |= ORB_SET_DIRECTION(orb_direction);
1809
1810 SBP2_DMA_ALLOC("single bulk");
1811
1812 /*
1813 * Handle case where we get a command w/o s/g enabled (but
1814 * check for transfers larger than 64K)
1815 */
1816 if (scsi_request_bufflen <= SBP2_MAX_SG_ELEMENT_LENGTH) {
1817
1818 orb->data_descriptor_lo = command->cmd_dma;
1819 orb->misc |= ORB_SET_DATA_SIZE(scsi_request_bufflen);
1820
1821 } else {
1822 struct sbp2_unrestricted_page_table *sg_element =
1823 &command->scatter_gather_element[0];
1824 u32 sg_count, sg_len;
1825 dma_addr_t sg_addr;
1826
1827 /*
1828 * Need to turn this into page tables, since the
1829 * buffer is too large.
1830 */
1831 orb->data_descriptor_lo = command->sge_dma;
1832
1833 /* Use page tables (s/g) */
1834 orb->misc |= ORB_SET_PAGE_TABLE_PRESENT(0x1);
1835
1836 /*
1837 * fill out our sbp-2 page tables (and split up
1838 * the large buffer)
1839 */
1840 sg_count = 0;
1841 sg_len = scsi_request_bufflen;
1842 sg_addr = command->cmd_dma;
1843 while (sg_len) {
1844 sg_element[sg_count].segment_base_lo = sg_addr;
1845 if (sg_len > SBP2_MAX_SG_ELEMENT_LENGTH) {
1846 sg_element[sg_count].length_segment_base_hi =
1847 PAGE_TABLE_SET_SEGMENT_LENGTH(SBP2_MAX_SG_ELEMENT_LENGTH);
1848 sg_addr += SBP2_MAX_SG_ELEMENT_LENGTH;
1849 sg_len -= SBP2_MAX_SG_ELEMENT_LENGTH;
1850 } else {
1851 sg_element[sg_count].length_segment_base_hi =
1852 PAGE_TABLE_SET_SEGMENT_LENGTH(sg_len);
1853 sg_len = 0;
1854 }
1855 sg_count++;
1856 }
1857
1858 /* Number of page table (s/g) elements */
1859 orb->misc |= ORB_SET_DATA_SIZE(sg_count);
1860
1861 sbp2util_packet_dump(sg_element,
1862 (sizeof(struct sbp2_unrestricted_page_table)) * sg_count,
1863 "sbp2 s/g list", command->sge_dma);
1864
1865 /* Byte swap page tables if necessary */
1866 sbp2util_cpu_to_be32_buffer(sg_element,
1867 (sizeof(struct sbp2_unrestricted_page_table)) *
1868 sg_count);
1869 }
1870}
1871
1da177e4
LT		 1872/*
1873 * This function is called to create the actual command orb and s/g list
1874 * out of the scsi command itself.
1875 */
cf8d2c09
SR		 1876static void sbp2_create_command_orb(struct scsi_id_instance_data *scsi_id,
1877 struct sbp2_command_info *command,
1878 unchar *scsi_cmd,
1879 unsigned int scsi_use_sg,
1880 unsigned int scsi_request_bufflen,
1881 void *scsi_request_buffer,
1882 enum dma_data_direction dma_dir)
1da177e4
LT		 1883{
1884 struct sbp2scsi_host_info *hi = scsi_id->hi;
a237f35f 1885 struct scatterlist *sgpnt = (struct scatterlist *)scsi_request_buffer;
1da177e4 1886 struct sbp2_command_orb *command_orb = &command->command_orb;
cf8d2c09 1887 u32 orb_direction;
1da177e4
LT		 1888
1889 /*
1890 * Set-up our command ORB..
1891 *
1892 * NOTE: We're doing unrestricted page tables (s/g), as this is
1893 * best performance (at least with the devices I have). This means
1894 * that data_size becomes the number of s/g elements, and
1895 * page_size should be zero (for unrestricted).
1896 */
1897 command_orb->next_ORB_hi = ORB_SET_NULL_PTR(1);
1898 command_orb->next_ORB_lo = 0x0;
1899 command_orb->misc = ORB_SET_MAX_PAYLOAD(scsi_id->max_payload_size);
1900 command_orb->misc |= ORB_SET_SPEED(scsi_id->speed_code);
a237f35f 1901 command_orb->misc |= ORB_SET_NOTIFY(1); /* Notify us when complete */
1da177e4 1902
43863eba 1903 if (dma_dir == DMA_NONE)
a237f35f 1904 orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
43863eba 1905 else if (dma_dir == DMA_TO_DEVICE && scsi_request_bufflen)
a237f35f 1906 orb_direction = ORB_DIRECTION_WRITE_TO_MEDIA;
43863eba 1907 else if (dma_dir == DMA_FROM_DEVICE && scsi_request_bufflen)
a237f35f 1908 orb_direction = ORB_DIRECTION_READ_FROM_MEDIA;
43863eba
SR		 1909 else {
1910 SBP2_WARN("Falling back to DMA_NONE");
1911 orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
1da177e4
LT		 1912 }
1913
cf8d2c09 1914 /* Set-up our pagetable stuff */
1da177e4 1915 if (orb_direction == ORB_DIRECTION_NO_DATA_TRANSFER) {
1da177e4 1916 SBP2_DEBUG("No data transfer");
1da177e4
LT		 1917 command_orb->data_descriptor_hi = 0x0;
1918 command_orb->data_descriptor_lo = 0x0;
1919 command_orb->misc |= ORB_SET_DIRECTION(1);
1da177e4 1920 } else if (scsi_use_sg) {
1da177e4 1921 SBP2_DEBUG("Use scatter/gather");
cf8d2c09
SR		 1922 sbp2_prep_command_orb_sg(command_orb, hi, command, scsi_use_sg,
1923 sgpnt, orb_direction, dma_dir);
1da177e4 1924 } else {
1da177e4 1925 SBP2_DEBUG("No scatter/gather");
cf8d2c09
SR		 1926 sbp2_prep_command_orb_no_sg(command_orb, hi, command, sgpnt,
1927 orb_direction, scsi_request_bufflen,
1928 scsi_request_buffer, dma_dir);
1da177e4
LT		 1929 }
1930
cf8d2c09 1931 /* Byte swap command ORB if necessary */
1da177e4
LT		 1932 sbp2util_cpu_to_be32_buffer(command_orb, sizeof(struct sbp2_command_orb));
1933
cf8d2c09 1934 /* Put our scsi command in the command ORB */
1da177e4
LT		 1935 memset(command_orb->cdb, 0, 12);
1936 memcpy(command_orb->cdb, scsi_cmd, COMMAND_SIZE(*scsi_cmd));
1da177e4
LT		 1937}
1938
1939/*
1940 * This function is called in order to begin a regular SBP-2 command.
1941 */
1942static int sbp2_link_orb_command(struct scsi_id_instance_data *scsi_id,
1943 struct sbp2_command_info *command)
1944{
1945 struct sbp2scsi_host_info *hi = scsi_id->hi;
1946 struct sbp2_command_orb *command_orb = &command->command_orb;
1947 struct node_entry *ne = scsi_id->ne;
1948 u64 addr;
1949
1950 outstanding_orb_incr;
1951 SBP2_ORB_DEBUG("sending command orb %p, total orbs = %x",
a237f35f 1952 command_orb, global_outstanding_command_orbs);
1da177e4
LT		 1953
1954 pci_dma_sync_single_for_device(hi->host->pdev, command->command_orb_dma,
1955 sizeof(struct sbp2_command_orb),
1956 PCI_DMA_BIDIRECTIONAL);
1957 pci_dma_sync_single_for_device(hi->host->pdev, command->sge_dma,
1958 sizeof(command->scatter_gather_element),
1959 PCI_DMA_BIDIRECTIONAL);
1960 /*
1961 * Check to see if there are any previous orbs to use
1962 */
1963 if (scsi_id->last_orb == NULL) {
1964 quadlet_t data[2];
1965
1966 /*
1967 * Ok, let's write to the target's management agent register
1968 */
1969 addr = scsi_id->sbp2_command_block_agent_addr + SBP2_ORB_POINTER_OFFSET;
1970 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1971 data[1] = command->command_orb_dma;
1972 sbp2util_cpu_to_be32_buffer(data, 8);
1973
1974 SBP2_ORB_DEBUG("write command agent, command orb %p", command_orb);
1975
1976 if (sbp2util_node_write_no_wait(ne, addr, data, 8) < 0) {
1977 SBP2_ERR("sbp2util_node_write_no_wait failed.\n");
1978 return -EIO;
1979 }
1980
1981 SBP2_ORB_DEBUG("write command agent complete");
1982
1983 scsi_id->last_orb = command_orb;
1984 scsi_id->last_orb_dma = command->command_orb_dma;
1985
1986 } else {
1987 quadlet_t data;
1988
1989 /*
1990 * We have an orb already sent (maybe or maybe not
1991 * processed) that we can append this orb to. So do so,
1992 * and ring the doorbell. Have to be very careful
1993 * modifying these next orb pointers, as they are accessed
1994 * both by the sbp2 device and us.
1995 */
1996 scsi_id->last_orb->next_ORB_lo =
a237f35f 1997 cpu_to_be32(command->command_orb_dma);
1da177e4
LT		 1998 /* Tells hardware that this pointer is valid */
1999 scsi_id->last_orb->next_ORB_hi = 0x0;
a237f35f
SR		 2000 pci_dma_sync_single_for_device(hi->host->pdev,
2001 scsi_id->last_orb_dma,
1da177e4
LT		 2002 sizeof(struct sbp2_command_orb),
2003 PCI_DMA_BIDIRECTIONAL);
2004
2005 /*
2006 * Ring the doorbell
2007 */
2008 data = cpu_to_be32(command->command_orb_dma);
2009 addr = scsi_id->sbp2_command_block_agent_addr + SBP2_DOORBELL_OFFSET;
2010
2011 SBP2_ORB_DEBUG("ring doorbell, command orb %p", command_orb);
2012
2013 if (sbp2util_node_write_no_wait(ne, addr, &data, 4) < 0) {
2014 SBP2_ERR("sbp2util_node_write_no_wait failed");
a237f35f 2015 return -EIO;
1da177e4
LT		 2016 }
2017
2018 scsi_id->last_orb = command_orb;
2019 scsi_id->last_orb_dma = command->command_orb_dma;
2020
2021 }
a237f35f 2022 return 0;
1da177e4
LT		 2023}
2024
2025/*
2026 * This function is called in order to begin a regular SBP-2 command.
2027 */
2028static int sbp2_send_command(struct scsi_id_instance_data *scsi_id,
2029 struct scsi_cmnd *SCpnt,
2030 void (*done)(struct scsi_cmnd *))
2031{
2032 unchar *cmd = (unchar *) SCpnt->cmnd;
2033 unsigned int request_bufflen = SCpnt->request_bufflen;
2034 struct sbp2_command_info *command;
2035
2036 SBP2_DEBUG("sbp2_send_command");
2037#if (CONFIG_IEEE1394_SBP2_DEBUG >= 2) || defined(CONFIG_IEEE1394_SBP2_PACKET_DUMP)
2038 printk("[scsi command]\n ");
2039 scsi_print_command(SCpnt);
2040#endif
2041 SBP2_DEBUG("SCSI transfer size = %x", request_bufflen);
2042 SBP2_DEBUG("SCSI s/g elements = %x", (unsigned int)SCpnt->use_sg);
2043
2044 /*
2045 * Allocate a command orb and s/g structure
2046 */
2047 command = sbp2util_allocate_command_orb(scsi_id, SCpnt, done);
2048 if (!command) {
a237f35f 2049 return -EIO;
1da177e4
LT		 2050 }
2051
2052 /*
2053 * The scsi stack sends down a request_bufflen which does not match the
2054 * length field in the scsi cdb. This causes some sbp2 devices to
2055 * reject this inquiry command. Fix the request_bufflen.
2056 */
2057 if (*cmd == INQUIRY) {
2058 if (force_inquiry_hack || scsi_id->workarounds & SBP2_BREAKAGE_INQUIRY_HACK)
2059 request_bufflen = cmd[4] = 0x24;
2060 else
2061 request_bufflen = cmd[4];
2062 }
2063
2064 /*
2065 * Now actually fill in the comamnd orb and sbp2 s/g list
2066 */
2067 sbp2_create_command_orb(scsi_id, command, cmd, SCpnt->use_sg,
2068 request_bufflen, SCpnt->request_buffer,
2069 SCpnt->sc_data_direction);
1da177e4
LT		 2070
2071 sbp2util_packet_dump(&command->command_orb, sizeof(struct sbp2_command_orb),
2072 "sbp2 command orb", command->command_orb_dma);
2073
2074 /*
2075 * Initialize status fifo
2076 */
2077 memset(&scsi_id->status_block, 0, sizeof(struct sbp2_status_block));
2078
2079 /*
2080 * Link up the orb, and ring the doorbell if needed
2081 */
2082 sbp2_link_orb_command(scsi_id, command);
2083
a237f35f 2084 return 0;
1da177e4
LT		 2085}
2086
1da177e4
LT		 2087/*
2088 * Translates SBP-2 status into SCSI sense data for check conditions
2089 */
2090static unsigned int sbp2_status_to_sense_data(unchar *sbp2_status, unchar *sense_data)
2091{
2092 SBP2_DEBUG("sbp2_status_to_sense_data");
2093
2094 /*
2095 * Ok, it's pretty ugly... ;-)
2096 */
2097 sense_data[0] = 0x70;
2098 sense_data[1] = 0x0;
2099 sense_data[2] = sbp2_status[9];
2100 sense_data[3] = sbp2_status[12];
2101 sense_data[4] = sbp2_status[13];
2102 sense_data[5] = sbp2_status[14];
2103 sense_data[6] = sbp2_status[15];
2104 sense_data[7] = 10;
2105 sense_data[8] = sbp2_status[16];
2106 sense_data[9] = sbp2_status[17];
2107 sense_data[10] = sbp2_status[18];
2108 sense_data[11] = sbp2_status[19];
2109 sense_data[12] = sbp2_status[10];
2110 sense_data[13] = sbp2_status[11];
2111 sense_data[14] = sbp2_status[20];
2112 sense_data[15] = sbp2_status[21];
2113
a237f35f 2114 return sbp2_status[8] & 0x3f; /* return scsi status */
1da177e4
LT		 2115}
2116
2117/*
2118 * This function is called after a command is completed, in order to do any necessary SBP-2
2119 * response data translations for the SCSI stack
2120 */
a237f35f 2121static void sbp2_check_sbp2_response(struct scsi_id_instance_data *scsi_id,
1da177e4
LT		 2122 struct scsi_cmnd *SCpnt)
2123{
2124 u8 *scsi_buf = SCpnt->request_buffer;
1da177e4
LT		 2125
2126 SBP2_DEBUG("sbp2_check_sbp2_response");
2127
2128 switch (SCpnt->cmnd[0]) {
2129
a237f35f
SR		 2130 case INQUIRY:
2131 /*
2132 * Make sure data length is ok. Minimum length is 36 bytes
2133 */
2134 if (scsi_buf[4] == 0) {
2135 scsi_buf[4] = 36 - 5;
2136 }
1da177e4 2137
a237f35f
SR		 2138 /*
2139 * Fix ansi revision and response data format
2140 */
2141 scsi_buf[2] |= 2;
2142 scsi_buf[3] = (scsi_buf[3] & 0xf0) | 2;
1da177e4 2143
a237f35f 2144 break;
1da177e4 2145
a237f35f
SR		 2146 default:
2147 break;
1da177e4
LT		 2148 }
2149 return;
2150}
2151
2152/*
2153 * This function deals with status writes from the SBP-2 device
2154 */
2155static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int destid,
2156 quadlet_t *data, u64 addr, size_t length, u16 fl)
2157{
2158 struct sbp2scsi_host_info *hi;
2159 struct scsi_id_instance_data *scsi_id = NULL, *scsi_id_tmp;
2160 u32 id;
2161 struct scsi_cmnd *SCpnt = NULL;
2162 u32 scsi_status = SBP2_SCSI_STATUS_GOOD;
2163 struct sbp2_command_info *command;
79456197 2164 unsigned long flags;
1da177e4
LT		 2165
2166 SBP2_DEBUG("sbp2_handle_status_write");
2167
2168 sbp2util_packet_dump(data, length, "sbp2 status write by device", (u32)addr);
2169
2170 if (!host) {
2171 SBP2_ERR("host is NULL - this is bad!");
a237f35f 2172 return RCODE_ADDRESS_ERROR;
1da177e4
LT		 2173 }
2174
2175 hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
2176
2177 if (!hi) {
2178 SBP2_ERR("host info is NULL - this is bad!");
a237f35f 2179 return RCODE_ADDRESS_ERROR;
1da177e4
LT		 2180 }
2181
2182 /*
2183 * Find our scsi_id structure by looking at the status fifo address written to by
2184 * the sbp2 device.
2185 */
2186 id = SBP2_STATUS_FIFO_OFFSET_TO_ENTRY((u32)(addr - SBP2_STATUS_FIFO_ADDRESS));
2187 list_for_each_entry(scsi_id_tmp, &hi->scsi_ids, scsi_list) {
2188 if (scsi_id_tmp->ne->nodeid == nodeid && scsi_id_tmp->ud->id == id) {
2189 scsi_id = scsi_id_tmp;
2190 break;
2191 }
2192 }
2193
2194 if (!scsi_id) {
2195 SBP2_ERR("scsi_id is NULL - device is gone?");
a237f35f 2196 return RCODE_ADDRESS_ERROR;
1da177e4
LT		 2197 }
2198
2199 /*
2200 * Put response into scsi_id status fifo...
2201 */
2202 memcpy(&scsi_id->status_block, data, length);
2203
2204 /*
2205 * Byte swap first two quadlets (8 bytes) of status for processing
2206 */
2207 sbp2util_be32_to_cpu_buffer(&scsi_id->status_block, 8);
2208
2209 /*
2210 * Handle command ORB status here if necessary. First, need to match status with command.
2211 */
2212 command = sbp2util_find_command_for_orb(scsi_id, scsi_id->status_block.ORB_offset_lo);
2213 if (command) {
2214
2215 SBP2_DEBUG("Found status for command ORB");
2216 pci_dma_sync_single_for_cpu(hi->host->pdev, command->command_orb_dma,
2217 sizeof(struct sbp2_command_orb),
2218 PCI_DMA_BIDIRECTIONAL);
2219 pci_dma_sync_single_for_cpu(hi->host->pdev, command->sge_dma,
2220 sizeof(command->scatter_gather_element),
2221 PCI_DMA_BIDIRECTIONAL);
2222
2223 SBP2_ORB_DEBUG("matched command orb %p", &command->command_orb);
2224 outstanding_orb_decr;
2225
2226 /*
2227 * Matched status with command, now grab scsi command pointers and check status
2228 */
2229 SCpnt = command->Current_SCpnt;
2230 sbp2util_mark_command_completed(scsi_id, command);
2231
2232 if (SCpnt) {
2233
2234 /*
2235 * See if the target stored any scsi status information
2236 */
2237 if (STATUS_GET_LENGTH(scsi_id->status_block.ORB_offset_hi_misc) > 1) {
2238 /*
2239 * Translate SBP-2 status to SCSI sense data
2240 */
2241 SBP2_DEBUG("CHECK CONDITION");
2242 scsi_status = sbp2_status_to_sense_data((unchar *)&scsi_id->status_block, SCpnt->sense_buffer);
2243 }
2244
2245 /*
2246 * Check to see if the dead bit is set. If so, we'll have to initiate
2247 * a fetch agent reset.
2248 */
2249 if (STATUS_GET_DEAD_BIT(scsi_id->status_block.ORB_offset_hi_misc)) {
2250
2251 /*
2252 * Initiate a fetch agent reset.
2253 */
2254 SBP2_DEBUG("Dead bit set - initiating fetch agent reset");
2255 sbp2_agent_reset(scsi_id, 0);
2256 }
2257
2258 SBP2_ORB_DEBUG("completing command orb %p", &command->command_orb);
2259 }
2260
2261 /*
2262 * Check here to see if there are no commands in-use. If there are none, we can
2263 * null out last orb so that next time around we write directly to the orb pointer...
2264 * Quick start saves one 1394 bus transaction.
2265 */
79456197 2266 spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
1da177e4
LT		 2267 if (list_empty(&scsi_id->sbp2_command_orb_inuse)) {
2268 scsi_id->last_orb = NULL;
2269 }
79456197 2270 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
1da177e4
LT		 2271
2272 } else {
2273
2274 /*
2275 * It's probably a login/logout/reconnect status.
2276 */
2277 if ((scsi_id->login_orb_dma == scsi_id->status_block.ORB_offset_lo) ||
2278 (scsi_id->query_logins_orb_dma == scsi_id->status_block.ORB_offset_lo) ||
2279 (scsi_id->reconnect_orb_dma == scsi_id->status_block.ORB_offset_lo) ||
2280 (scsi_id->logout_orb_dma == scsi_id->status_block.ORB_offset_lo)) {
2281 atomic_set(&scsi_id->sbp2_login_complete, 1);
2282 }
2283 }
2284
2285 if (SCpnt) {
2286
2287 /* Complete the SCSI command. */
2288 SBP2_DEBUG("Completing SCSI command");
2289 sbp2scsi_complete_command(scsi_id, scsi_status, SCpnt,
2290 command->Current_done);
2291 SBP2_ORB_DEBUG("command orb completed");
2292 }
2293
a237f35f 2294 return RCODE_COMPLETE;
1da177e4
LT		 2295}
2296
1da177e4
LT		 2297/**************************************
2298 * SCSI interface related section
2299 **************************************/
2300
2301/*
2302 * This routine is the main request entry routine for doing I/O. It is
2303 * called from the scsi stack directly.
2304 */
2305static int sbp2scsi_queuecommand(struct scsi_cmnd *SCpnt,
2306 void (*done)(struct scsi_cmnd *))
2307{
2308 struct scsi_id_instance_data *scsi_id =
2309 (struct scsi_id_instance_data *)SCpnt->device->host->hostdata[0];
2310 struct sbp2scsi_host_info *hi;
abd559b1 2311 int result = DID_NO_CONNECT << 16;
1da177e4
LT		 2312
2313 SBP2_DEBUG("sbp2scsi_queuecommand");
2314
abd559b1
JM		 2315 if (!sbp2util_node_is_available(scsi_id))
2316 goto done;
1da177e4
LT		 2317
2318 hi = scsi_id->hi;
2319
2320 if (!hi) {
2321 SBP2_ERR("sbp2scsi_host_info is NULL - this is bad!");
abd559b1 2322 goto done;
1da177e4
LT		 2323 }
2324
2325 /*
2326 * Until we handle multiple luns, just return selection time-out
2327 * to any IO directed at non-zero LUNs
2328 */
abd559b1
JM		 2329 if (SCpnt->device->lun)
2330 goto done;
1da177e4
LT		 2331
2332 /*
2333 * Check for request sense command, and handle it here
2334 * (autorequest sense)
2335 */
2336 if (SCpnt->cmnd[0] == REQUEST_SENSE) {
2337 SBP2_DEBUG("REQUEST_SENSE");
2338 memcpy(SCpnt->request_buffer, SCpnt->sense_buffer, SCpnt->request_bufflen);
2339 memset(SCpnt->sense_buffer, 0, sizeof(SCpnt->sense_buffer));
2340 sbp2scsi_complete_command(scsi_id, SBP2_SCSI_STATUS_GOOD, SCpnt, done);
abd559b1 2341 return 0;
1da177e4
LT		 2342 }
2343
2344 /*
2345 * Check to see if we are in the middle of a bus reset.
2346 */
2347 if (!hpsb_node_entry_valid(scsi_id->ne)) {
2348 SBP2_ERR("Bus reset in progress - rejecting command");
abd559b1
JM		 2349 result = DID_BUS_BUSY << 16;
2350 goto done;
1da177e4
LT		 2351 }
2352
43863eba
SR		 2353 /*
2354 * Bidirectional commands are not yet implemented,
2355 * and unknown transfer direction not handled.
2356 */
2357 if (SCpnt->sc_data_direction == DMA_BIDIRECTIONAL) {
2358 SBP2_ERR("Cannot handle DMA_BIDIRECTIONAL - rejecting command");
2359 result = DID_ERROR << 16;
2360 goto done;
2361 }
2362
1da177e4
LT		 2363 /*
2364 * Try and send our SCSI command
2365 */
2366 if (sbp2_send_command(scsi_id, SCpnt, done)) {
2367 SBP2_ERR("Error sending SCSI command");
2368 sbp2scsi_complete_command(scsi_id, SBP2_SCSI_STATUS_SELECTION_TIMEOUT,
2369 SCpnt, done);
2370 }
abd559b1 2371 return 0;
1da177e4 2372
abd559b1
JM		 2373done:
2374 SCpnt->result = result;
2375 done(SCpnt);
2376 return 0;
1da177e4
LT		 2377}
2378
2379/*
2380 * This function is called in order to complete all outstanding SBP-2
2381 * commands (in case of resets, etc.).
2382 */
2383static void sbp2scsi_complete_all_commands(struct scsi_id_instance_data *scsi_id,
2384 u32 status)
2385{
2386 struct sbp2scsi_host_info *hi = scsi_id->hi;
2387 struct list_head *lh;
2388 struct sbp2_command_info *command;
79456197 2389 unsigned long flags;
1da177e4
LT		 2390
2391 SBP2_DEBUG("sbp2scsi_complete_all_commands");
2392
79456197 2393 spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags);
1da177e4
LT		 2394 while (!list_empty(&scsi_id->sbp2_command_orb_inuse)) {
2395 SBP2_DEBUG("Found pending command to complete");
2396 lh = scsi_id->sbp2_command_orb_inuse.next;
2397 command = list_entry(lh, struct sbp2_command_info, list);
2398 pci_dma_sync_single_for_cpu(hi->host->pdev, command->command_orb_dma,
2399 sizeof(struct sbp2_command_orb),
2400 PCI_DMA_BIDIRECTIONAL);
2401 pci_dma_sync_single_for_cpu(hi->host->pdev, command->sge_dma,
2402 sizeof(command->scatter_gather_element),
2403 PCI_DMA_BIDIRECTIONAL);
2404 sbp2util_mark_command_completed(scsi_id, command);
2405 if (command->Current_SCpnt) {
2406 command->Current_SCpnt->result = status << 16;
2407 command->Current_done(command->Current_SCpnt);
2408 }
2409 }
79456197 2410 spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags);
1da177e4
LT		 2411
2412 return;
2413}
2414
2415/*
2416 * This function is called in order to complete a regular SBP-2 command.
2417 *
2418 * This can be called in interrupt context.
2419 */
2420static void sbp2scsi_complete_command(struct scsi_id_instance_data *scsi_id,
2421 u32 scsi_status, struct scsi_cmnd *SCpnt,
2422 void (*done)(struct scsi_cmnd *))
2423{
1da177e4
LT		 2424 SBP2_DEBUG("sbp2scsi_complete_command");
2425
2426 /*
2427 * Sanity
2428 */
2429 if (!SCpnt) {
2430 SBP2_ERR("SCpnt is NULL");
2431 return;
2432 }
2433
2434 /*
2435 * If a bus reset is in progress and there was an error, don't
2436 * complete the command, just let it get retried at the end of the
2437 * bus reset.
2438 */
a237f35f
SR		 2439 if (!hpsb_node_entry_valid(scsi_id->ne)
2440 && (scsi_status != SBP2_SCSI_STATUS_GOOD)) {
1da177e4
LT		 2441 SBP2_ERR("Bus reset in progress - retry command later");
2442 return;
2443 }
a237f35f 2444
1da177e4
LT		 2445 /*
2446 * Switch on scsi status
2447 */
2448 switch (scsi_status) {
a237f35f
SR		 2449 case SBP2_SCSI_STATUS_GOOD:
2450 SCpnt->result = DID_OK;
2451 break;
1da177e4 2452
a237f35f
SR		 2453 case SBP2_SCSI_STATUS_BUSY:
2454 SBP2_ERR("SBP2_SCSI_STATUS_BUSY");
2455 SCpnt->result = DID_BUS_BUSY << 16;
2456 break;
1da177e4 2457
a237f35f
SR		 2458 case SBP2_SCSI_STATUS_CHECK_CONDITION:
2459 SBP2_DEBUG("SBP2_SCSI_STATUS_CHECK_CONDITION");
2460 SCpnt->result = CHECK_CONDITION << 1;
1da177e4 2461
a237f35f
SR		 2462 /*
2463 * Debug stuff
2464 */
1da177e4 2465#if CONFIG_IEEE1394_SBP2_DEBUG >= 1
a237f35f
SR		 2466 scsi_print_command(SCpnt);
2467 scsi_print_sense("bh", SCpnt);
1da177e4
LT		 2468#endif
2469
a237f35f 2470 break;
1da177e4 2471
a237f35f
SR		 2472 case SBP2_SCSI_STATUS_SELECTION_TIMEOUT:
2473 SBP2_ERR("SBP2_SCSI_STATUS_SELECTION_TIMEOUT");
2474 SCpnt->result = DID_NO_CONNECT << 16;
2475 scsi_print_command(SCpnt);
2476 break;
1da177e4 2477
a237f35f
SR		 2478 case SBP2_SCSI_STATUS_CONDITION_MET:
2479 case SBP2_SCSI_STATUS_RESERVATION_CONFLICT:
2480 case SBP2_SCSI_STATUS_COMMAND_TERMINATED:
2481 SBP2_ERR("Bad SCSI status = %x", scsi_status);
2482 SCpnt->result = DID_ERROR << 16;
2483 scsi_print_command(SCpnt);
2484 break;
1da177e4 2485
a237f35f
SR		 2486 default:
2487 SBP2_ERR("Unsupported SCSI status = %x", scsi_status);
2488 SCpnt->result = DID_ERROR << 16;
1da177e4
LT		 2489 }
2490
2491 /*
2492 * Take care of any sbp2 response data mucking here (RBC stuff, etc.)
2493 */
2494 if (SCpnt->result == DID_OK) {
2495 sbp2_check_sbp2_response(scsi_id, SCpnt);
2496 }
2497
2498 /*
2499 * If a bus reset is in progress and there was an error, complete
2500 * the command as busy so that it will get retried.
2501 */
a237f35f
SR		 2502 if (!hpsb_node_entry_valid(scsi_id->ne)
2503 && (scsi_status != SBP2_SCSI_STATUS_GOOD)) {
1da177e4
LT		 2504 SBP2_ERR("Completing command with busy (bus reset)");
2505 SCpnt->result = DID_BUS_BUSY << 16;
2506 }
2507
2508 /*
2509 * If a unit attention occurs, return busy status so it gets
2510 * retried... it could have happened because of a 1394 bus reset
2511 * or hot-plug...
2512 */
2513#if 0
2514 if ((scsi_status == SBP2_SCSI_STATUS_CHECK_CONDITION) &&
2515 (SCpnt->sense_buffer[2] == UNIT_ATTENTION)) {
2516 SBP2_DEBUG("UNIT ATTENTION - return busy");
2517 SCpnt->result = DID_BUS_BUSY << 16;
2518 }
2519#endif
2520
2521 /*
2522 * Tell scsi stack that we're done with this command
2523 */
a237f35f 2524 done(SCpnt);
1da177e4
LT		 2525}
2526
abd559b1 2527static int sbp2scsi_slave_alloc(struct scsi_device *sdev)
1da177e4 2528{
abd559b1
JM		 2529 ((struct scsi_id_instance_data *)sdev->host->hostdata[0])->sdev = sdev;
2530 return 0;
2531}
2532
abd559b1
JM		 2533static int sbp2scsi_slave_configure(struct scsi_device *sdev)
2534{
2535 blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
365c786f
BC		 2536 sdev->use_10_for_rw = 1;
2537 sdev->use_10_for_ms = 1;
1da177e4
LT		 2538 return 0;
2539}
2540
abd559b1
JM		 2541static void sbp2scsi_slave_destroy(struct scsi_device *sdev)
2542{
2543 ((struct scsi_id_instance_data *)sdev->host->hostdata[0])->sdev = NULL;
2544 return;
2545}
2546
1da177e4
LT		 2547/*
2548 * Called by scsi stack when something has really gone wrong. Usually
2549 * called when a command has timed-out for some reason.
2550 */
2551static int sbp2scsi_abort(struct scsi_cmnd *SCpnt)
2552{
2553 struct scsi_id_instance_data *scsi_id =
2554 (struct scsi_id_instance_data *)SCpnt->device->host->hostdata[0];
2555 struct sbp2scsi_host_info *hi = scsi_id->hi;
2556 struct sbp2_command_info *command;
2557
2558 SBP2_ERR("aborting sbp2 command");
2559 scsi_print_command(SCpnt);
2560
abd559b1 2561 if (sbp2util_node_is_available(scsi_id)) {
1da177e4
LT		 2562
2563 /*
2564 * Right now, just return any matching command structures
2565 * to the free pool.
2566 */
2567 command = sbp2util_find_command_for_SCpnt(scsi_id, SCpnt);
2568 if (command) {
2569 SBP2_DEBUG("Found command to abort");
2570 pci_dma_sync_single_for_cpu(hi->host->pdev,
2571 command->command_orb_dma,
2572 sizeof(struct sbp2_command_orb),
2573 PCI_DMA_BIDIRECTIONAL);
2574 pci_dma_sync_single_for_cpu(hi->host->pdev,
2575 command->sge_dma,
2576 sizeof(command->scatter_gather_element),
2577 PCI_DMA_BIDIRECTIONAL);
2578 sbp2util_mark_command_completed(scsi_id, command);
2579 if (command->Current_SCpnt) {
2580 command->Current_SCpnt->result = DID_ABORT << 16;
2581 command->Current_done(command->Current_SCpnt);
2582 }
2583 }
2584
2585 /*
2586 * Initiate a fetch agent reset.
2587 */
2588 sbp2_agent_reset(scsi_id, 0);
2589 sbp2scsi_complete_all_commands(scsi_id, DID_BUS_BUSY);
2590 }
2591
a237f35f 2592 return SUCCESS;
1da177e4
LT		 2593}
2594
2595/*
2596 * Called by scsi stack when something has really gone wrong.
2597 */
abd559b1 2598static int sbp2scsi_reset(struct scsi_cmnd *SCpnt)
1da177e4
LT		 2599{
2600 struct scsi_id_instance_data *scsi_id =
2601 (struct scsi_id_instance_data *)SCpnt->device->host->hostdata[0];
2602
2603 SBP2_ERR("reset requested");
2604
abd559b1 2605 if (sbp2util_node_is_available(scsi_id)) {
1da177e4
LT		 2606 SBP2_ERR("Generating sbp2 fetch agent reset");
2607 sbp2_agent_reset(scsi_id, 0);
2608 }
2609
abd559b1 2610 return SUCCESS;
94d0e7b8
JG		 2611}
2612
a237f35f
SR		 2613static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev,
2614 struct device_attribute *attr,
2615 char *buf)
1da177e4
LT		 2616{
2617 struct scsi_device *sdev;
2618 struct scsi_id_instance_data *scsi_id;
2619 int lun;
2620
2621 if (!(sdev = to_scsi_device(dev)))
2622 return 0;
2623
2624 if (!(scsi_id = (struct scsi_id_instance_data *)sdev->host->hostdata[0]))
2625 return 0;
2626
e309fc6d 2627 lun = ORB_SET_LUN(scsi_id->sbp2_lun);
1da177e4
LT		 2628
2629 return sprintf(buf, "%016Lx:%d:%d\n", (unsigned long long)scsi_id->ne->guid,
2630 scsi_id->ud->id, lun);
2631}
2632static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
2633
2634static struct device_attribute *sbp2_sysfs_sdev_attrs[] = {
2635 &dev_attr_ieee1394_id,
2636 NULL
2637};
2638
2639MODULE_AUTHOR("Ben Collins <bcollins@debian.org>");
2640MODULE_DESCRIPTION("IEEE-1394 SBP-2 protocol driver");
2641MODULE_SUPPORTED_DEVICE(SBP2_DEVICE_NAME);
2642MODULE_LICENSE("GPL");
2643
2644/* SCSI host template */
2645static struct scsi_host_template scsi_driver_template = {
2646 .module = THIS_MODULE,
2647 .name = "SBP-2 IEEE-1394",
2648 .proc_name = SBP2_DEVICE_NAME,
1da177e4
LT		 2649 .queuecommand = sbp2scsi_queuecommand,
2650 .eh_abort_handler = sbp2scsi_abort,
2651 .eh_device_reset_handler = sbp2scsi_reset,
abd559b1 2652 .slave_alloc = sbp2scsi_slave_alloc,
1da177e4 2653 .slave_configure = sbp2scsi_slave_configure,
abd559b1 2654 .slave_destroy = sbp2scsi_slave_destroy,
1da177e4
LT		 2655 .this_id = -1,
2656 .sg_tablesize = SG_ALL,
2657 .use_clustering = ENABLE_CLUSTERING,
2658 .cmd_per_lun = SBP2_MAX_CMDS,
2659 .can_queue = SBP2_MAX_CMDS,
2660 .emulated = 1,
2661 .sdev_attrs = sbp2_sysfs_sdev_attrs,
2662};
2663
2664static int sbp2_module_init(void)
2665{
2666 int ret;
2667
2668 SBP2_DEBUG("sbp2_module_init");
2669
1da177e4
LT		 2670 /* Module load debug option to force one command at a time (serializing I/O) */
2671 if (serialize_io) {
2bab359a
JM		 2672 SBP2_INFO("Driver forced to serialize I/O (serialize_io=1)");
2673 SBP2_INFO("Try serialize_io=0 for better performance");
1da177e4
LT		 2674 scsi_driver_template.can_queue = 1;
2675 scsi_driver_template.cmd_per_lun = 1;
2676 }
2677
2678 /* Set max sectors (module load option). Default is 255 sectors. */
2679 scsi_driver_template.max_sectors = max_sectors;
2680
1da177e4
LT		 2681 /* Register our high level driver with 1394 stack */
2682 hpsb_register_highlevel(&sbp2_highlevel);
2683
2684 ret = hpsb_register_protocol(&sbp2_driver);
2685 if (ret) {
2686 SBP2_ERR("Failed to register protocol");
2687 hpsb_unregister_highlevel(&sbp2_highlevel);
2688 return ret;
2689 }
2690
2691 return 0;
2692}
2693
2694static void __exit sbp2_module_exit(void)
2695{
2696 SBP2_DEBUG("sbp2_module_exit");
2697
2698 hpsb_unregister_protocol(&sbp2_driver);
2699
2700 hpsb_unregister_highlevel(&sbp2_highlevel);
2701}
2702
2703module_init(sbp2_module_init);
2704module_exit(sbp2_module_exit);
Linux 6.x block layer and io_uring tree(s)