include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6.git] / drivers / ieee1394 / sbp2.c
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 (usually storage devices) as regular
33  * SCSI devices. E.g. mount /dev/sda1, fdisk, mkfs, etc..
34  *
35  * See http://www.t10.org/drafts.htm#sbp2 for the final draft of the SBP-2
36  * specification and for where to purchase the official standard.
37  *
38  * TODO:
39  *   - look into possible improvements of the SCSI error handlers
40  *   - handle Unit_Characteristics.mgt_ORB_timeout and .ORB_size
41  *   - handle Logical_Unit_Number.ordered
42  *   - handle src == 1 in status blocks
43  *   - reimplement the DMA mapping in absence of physical DMA so that
44  *     bus_to_virt is no longer required
45  *   - debug the handling of absent physical DMA
46  *   - replace CONFIG_IEEE1394_SBP2_PHYS_DMA by automatic detection
47  *     (this is easy but depends on the previous two TODO items)
48  *   - make the parameter serialize_io configurable per device
49  *   - move all requests to fetch agent registers into non-atomic context,
50  *     replace all usages of sbp2util_node_write_no_wait by true transactions
51  * Grep for inline FIXME comments below.
52  */
53
54 #include <linux/blkdev.h>
55 #include <linux/compiler.h>
56 #include <linux/delay.h>
57 #include <linux/device.h>
58 #include <linux/dma-mapping.h>
59 #include <linux/init.h>
60 #include <linux/kernel.h>
61 #include <linux/list.h>
62 #include <linux/mm.h>
63 #include <linux/module.h>
64 #include <linux/moduleparam.h>
65 #include <linux/sched.h>
66 #include <linux/slab.h>
67 #include <linux/spinlock.h>
68 #include <linux/stat.h>
69 #include <linux/string.h>
70 #include <linux/stringify.h>
71 #include <linux/types.h>
72 #include <linux/wait.h>
73 #include <linux/workqueue.h>
74 #include <linux/scatterlist.h>
75
76 #include <asm/byteorder.h>
77 #include <asm/errno.h>
78 #include <asm/param.h>
79 #include <asm/system.h>
80 #include <asm/types.h>
81
82 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
83 #include <asm/io.h> /* for bus_to_virt */
84 #endif
85
86 #include <scsi/scsi.h>
87 #include <scsi/scsi_cmnd.h>
88 #include <scsi/scsi_dbg.h>
89 #include <scsi/scsi_device.h>
90 #include <scsi/scsi_host.h>
91
92 #include "csr1212.h"
93 #include "highlevel.h"
94 #include "hosts.h"
95 #include "ieee1394.h"
96 #include "ieee1394_core.h"
97 #include "ieee1394_hotplug.h"
98 #include "ieee1394_transactions.h"
99 #include "ieee1394_types.h"
100 #include "nodemgr.h"
101 #include "sbp2.h"
102
103 /*
104  * Module load parameter definitions
105  */
106
107 /*
108  * Change max_speed on module load if you have a bad IEEE-1394
109  * controller that has trouble running 2KB packets at 400mb.
110  *
111  * NOTE: On certain OHCI parts I have seen short packets on async transmit
112  * (probably due to PCI latency/throughput issues with the part). You can
113  * bump down the speed if you are running into problems.
114  */
115 static int sbp2_max_speed = IEEE1394_SPEED_MAX;
116 module_param_named(max_speed, sbp2_max_speed, int, 0644);
117 MODULE_PARM_DESC(max_speed, "Limit data transfer speed (5 <= 3200, "
118                  "4 <= 1600, 3 <= 800, 2 <= 400, 1 <= 200, 0 = 100 Mb/s)");
119
120 /*
121  * Set serialize_io to 0 or N to use dynamically appended lists of command ORBs.
122  * This is and always has been buggy in multiple subtle ways. See above TODOs.
123  */
124 static int sbp2_serialize_io = 1;
125 module_param_named(serialize_io, sbp2_serialize_io, bool, 0444);
126 MODULE_PARM_DESC(serialize_io, "Serialize requests coming from SCSI drivers "
127                  "(default = Y, faster but buggy = N)");
128
129 /*
130  * Adjust max_sectors if you'd like to influence how many sectors each SCSI
131  * command can transfer at most. Please note that some older SBP-2 bridge
132  * chips are broken for transfers greater or equal to 128KB, therefore
133  * max_sectors used to be a safe 255 sectors for many years. We now have a
134  * default of 0 here which means that we let the SCSI stack choose a limit.
135  *
136  * The SBP2_WORKAROUND_128K_MAX_TRANS flag, if set either in the workarounds
137  * module parameter or in the sbp2_workarounds_table[], will override the
138  * value of max_sectors. We should use sbp2_workarounds_table[] to cover any
139  * bridge chip which becomes known to need the 255 sectors limit.
140  */
141 static int sbp2_max_sectors;
142 module_param_named(max_sectors, sbp2_max_sectors, int, 0444);
143 MODULE_PARM_DESC(max_sectors, "Change max sectors per I/O supported "
144                  "(default = 0 = use SCSI stack's default)");
145
146 /*
147  * Exclusive login to sbp2 device? In most cases, the sbp2 driver should
148  * do an exclusive login, as it's generally unsafe to have two hosts
149  * talking to a single sbp2 device at the same time (filesystem coherency,
150  * etc.). If you're running an sbp2 device that supports multiple logins,
151  * and you're either running read-only filesystems or some sort of special
152  * filesystem supporting multiple hosts, e.g. OpenGFS, Oracle Cluster
153  * File System, or Lustre, then set exclusive_login to zero.
154  *
155  * So far only bridges from Oxford Semiconductor are known to support
156  * concurrent logins. Depending on firmware, four or two concurrent logins
157  * are possible on OXFW911 and newer Oxsemi bridges.
158  */
159 static int sbp2_exclusive_login = 1;
160 module_param_named(exclusive_login, sbp2_exclusive_login, bool, 0644);
161 MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device "
162                  "(default = Y, use N for concurrent initiators)");
163
164 /*
165  * If any of the following workarounds is required for your device to work,
166  * please submit the kernel messages logged by sbp2 to the linux1394-devel
167  * mailing list.
168  *
169  * - 128kB max transfer
170  *   Limit transfer size. Necessary for some old bridges.
171  *
172  * - 36 byte inquiry
173  *   When scsi_mod probes the device, let the inquiry command look like that
174  *   from MS Windows.
175  *
176  * - skip mode page 8
177  *   Suppress sending of mode_sense for mode page 8 if the device pretends to
178  *   support the SCSI Primary Block commands instead of Reduced Block Commands.
179  *
180  * - fix capacity
181  *   Tell sd_mod to correct the last sector number reported by read_capacity.
182  *   Avoids access beyond actual disk limits on devices with an off-by-one bug.
183  *   Don't use this with devices which don't have this bug.
184  *
185  * - delay inquiry
186  *   Wait extra SBP2_INQUIRY_DELAY seconds after login before SCSI inquiry.
187  *
188  * - power condition
189  *   Set the power condition field in the START STOP UNIT commands sent by
190  *   sd_mod on suspend, resume, and shutdown (if manage_start_stop is on).
191  *   Some disks need this to spin down or to resume properly.
192  *
193  * - override internal blacklist
194  *   Instead of adding to the built-in blacklist, use only the workarounds
195  *   specified in the module load parameter.
196  *   Useful if a blacklist entry interfered with a non-broken device.
197  */
198 static int sbp2_default_workarounds;
199 module_param_named(workarounds, sbp2_default_workarounds, int, 0644);
200 MODULE_PARM_DESC(workarounds, "Work around device bugs (default = 0"
201         ", 128kB max transfer = " __stringify(SBP2_WORKAROUND_128K_MAX_TRANS)
202         ", 36 byte inquiry = "    __stringify(SBP2_WORKAROUND_INQUIRY_36)
203         ", skip mode page 8 = "   __stringify(SBP2_WORKAROUND_MODE_SENSE_8)
204         ", fix capacity = "       __stringify(SBP2_WORKAROUND_FIX_CAPACITY)
205         ", delay inquiry = "      __stringify(SBP2_WORKAROUND_DELAY_INQUIRY)
206         ", set power condition in start stop unit = "
207                                   __stringify(SBP2_WORKAROUND_POWER_CONDITION)
208         ", override internal blacklist = " __stringify(SBP2_WORKAROUND_OVERRIDE)
209         ", or a combination)");
210
211 /*
212  * This influences the format of the sysfs attribute
213  * /sys/bus/scsi/devices/.../ieee1394_id.
214  *
215  * The default format is like in older kernels:  %016Lx:%d:%d
216  * It contains the target's EUI-64, a number given to the logical unit by
217  * the ieee1394 driver's nodemgr (starting at 0), and the LUN.
218  *
219  * The long format is:  %016Lx:%06x:%04x
220  * It contains the target's EUI-64, the unit directory's directory_ID as per
221  * IEEE 1212 clause 7.7.19, and the LUN.  This format comes closest to the
222  * format of SBP(-3) target port and logical unit identifier as per SAM (SCSI
223  * Architecture Model) rev.2 to 4 annex A.  Therefore and because it is
224  * independent of the implementation of the ieee1394 nodemgr, the longer format
225  * is recommended for future use.
226  */
227 static int sbp2_long_sysfs_ieee1394_id;
228 module_param_named(long_ieee1394_id, sbp2_long_sysfs_ieee1394_id, bool, 0644);
229 MODULE_PARM_DESC(long_ieee1394_id, "8+3+2 bytes format of ieee1394_id in sysfs "
230                  "(default = backwards-compatible = N, SAM-conforming = Y)");
231
232
233 #define SBP2_INFO(fmt, args...) HPSB_INFO("sbp2: "fmt, ## args)
234 #define SBP2_ERR(fmt, args...)  HPSB_ERR("sbp2: "fmt, ## args)
235
236 /*
237  * Globals
238  */
239 static void sbp2scsi_complete_all_commands(struct sbp2_lu *, u32);
240 static void sbp2scsi_complete_command(struct sbp2_lu *, u32, struct scsi_cmnd *,
241                                       void (*)(struct scsi_cmnd *));
242 static struct sbp2_lu *sbp2_alloc_device(struct unit_directory *);
243 static int sbp2_start_device(struct sbp2_lu *);
244 static void sbp2_remove_device(struct sbp2_lu *);
245 static int sbp2_login_device(struct sbp2_lu *);
246 static int sbp2_reconnect_device(struct sbp2_lu *);
247 static int sbp2_logout_device(struct sbp2_lu *);
248 static void sbp2_host_reset(struct hpsb_host *);
249 static int sbp2_handle_status_write(struct hpsb_host *, int, int, quadlet_t *,
250                                     u64, size_t, u16);
251 static int sbp2_agent_reset(struct sbp2_lu *, int);
252 static void sbp2_parse_unit_directory(struct sbp2_lu *,
253                                       struct unit_directory *);
254 static int sbp2_set_busy_timeout(struct sbp2_lu *);
255 static int sbp2_max_speed_and_size(struct sbp2_lu *);
256
257
258 static const u8 sbp2_speedto_max_payload[] = { 0x7, 0x8, 0x9, 0xa, 0xa, 0xa };
259
260 static DEFINE_RWLOCK(sbp2_hi_logical_units_lock);
261
262 static struct hpsb_highlevel sbp2_highlevel = {
263         .name           = SBP2_DEVICE_NAME,
264         .host_reset     = sbp2_host_reset,
265 };
266
267 static const struct hpsb_address_ops sbp2_ops = {
268         .write          = sbp2_handle_status_write
269 };
270
271 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
272 static int sbp2_handle_physdma_write(struct hpsb_host *, int, int, quadlet_t *,
273                                      u64, size_t, u16);
274 static int sbp2_handle_physdma_read(struct hpsb_host *, int, quadlet_t *, u64,
275                                     size_t, u16);
276
277 static const struct hpsb_address_ops sbp2_physdma_ops = {
278         .read           = sbp2_handle_physdma_read,
279         .write          = sbp2_handle_physdma_write,
280 };
281 #endif
282
283
284 /*
285  * Interface to driver core and IEEE 1394 core
286  */
287 static const struct ieee1394_device_id sbp2_id_table[] = {
288         {
289          .match_flags   = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
290          .specifier_id  = SBP2_UNIT_SPEC_ID_ENTRY & 0xffffff,
291          .version       = SBP2_SW_VERSION_ENTRY & 0xffffff},
292         {}
293 };
294 MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
295
296 static int sbp2_probe(struct device *);
297 static int sbp2_remove(struct device *);
298 static int sbp2_update(struct unit_directory *);
299
300 static struct hpsb_protocol_driver sbp2_driver = {
301         .name           = SBP2_DEVICE_NAME,
302         .id_table       = sbp2_id_table,
303         .update         = sbp2_update,
304         .driver         = {
305                 .probe          = sbp2_probe,
306                 .remove         = sbp2_remove,
307         },
308 };
309
310
311 /*
312  * Interface to SCSI core
313  */
314 static int sbp2scsi_queuecommand(struct scsi_cmnd *,
315                                  void (*)(struct scsi_cmnd *));
316 static int sbp2scsi_abort(struct scsi_cmnd *);
317 static int sbp2scsi_reset(struct scsi_cmnd *);
318 static int sbp2scsi_slave_alloc(struct scsi_device *);
319 static int sbp2scsi_slave_configure(struct scsi_device *);
320 static void sbp2scsi_slave_destroy(struct scsi_device *);
321 static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *,
322                                            struct device_attribute *, char *);
323
324 static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
325
326 static struct device_attribute *sbp2_sysfs_sdev_attrs[] = {
327         &dev_attr_ieee1394_id,
328         NULL
329 };
330
331 static struct scsi_host_template sbp2_shost_template = {
332         .module                  = THIS_MODULE,
333         .name                    = "SBP-2 IEEE-1394",
334         .proc_name               = SBP2_DEVICE_NAME,
335         .queuecommand            = sbp2scsi_queuecommand,
336         .eh_abort_handler        = sbp2scsi_abort,
337         .eh_device_reset_handler = sbp2scsi_reset,
338         .slave_alloc             = sbp2scsi_slave_alloc,
339         .slave_configure         = sbp2scsi_slave_configure,
340         .slave_destroy           = sbp2scsi_slave_destroy,
341         .this_id                 = -1,
342         .sg_tablesize            = SG_ALL,
343         .use_clustering          = ENABLE_CLUSTERING,
344         .cmd_per_lun             = SBP2_MAX_CMDS,
345         .can_queue               = SBP2_MAX_CMDS,
346         .sdev_attrs              = sbp2_sysfs_sdev_attrs,
347 };
348
349 #define SBP2_ROM_VALUE_WILDCARD ~0         /* match all */
350 #define SBP2_ROM_VALUE_MISSING  0xff000000 /* not present in the unit dir. */
351
352 /*
353  * List of devices with known bugs.
354  *
355  * The firmware_revision field, masked with 0xffff00, is the best indicator
356  * for the type of bridge chip of a device.  It yields a few false positives
357  * but this did not break correctly behaving devices so far.
358  */
359 static const struct {
360         u32 firmware_revision;
361         u32 model;
362         unsigned workarounds;
363 } sbp2_workarounds_table[] = {
364         /* DViCO Momobay CX-1 with TSB42AA9 bridge */ {
365                 .firmware_revision      = 0x002800,
366                 .model                  = 0x001010,
367                 .workarounds            = SBP2_WORKAROUND_INQUIRY_36 |
368                                           SBP2_WORKAROUND_MODE_SENSE_8 |
369                                           SBP2_WORKAROUND_POWER_CONDITION,
370         },
371         /* DViCO Momobay FX-3A with TSB42AA9A bridge */ {
372                 .firmware_revision      = 0x002800,
373                 .model                  = 0x000000,
374                 .workarounds            = SBP2_WORKAROUND_POWER_CONDITION,
375         },
376         /* Initio bridges, actually only needed for some older ones */ {
377                 .firmware_revision      = 0x000200,
378                 .model                  = SBP2_ROM_VALUE_WILDCARD,
379                 .workarounds            = SBP2_WORKAROUND_INQUIRY_36,
380         },
381         /* PL-3507 bridge with Prolific firmware */ {
382                 .firmware_revision      = 0x012800,
383                 .model                  = SBP2_ROM_VALUE_WILDCARD,
384                 .workarounds            = SBP2_WORKAROUND_POWER_CONDITION,
385         },
386         /* Symbios bridge */ {
387                 .firmware_revision      = 0xa0b800,
388                 .model                  = SBP2_ROM_VALUE_WILDCARD,
389                 .workarounds            = SBP2_WORKAROUND_128K_MAX_TRANS,
390         },
391         /* Datafab MD2-FW2 with Symbios/LSILogic SYM13FW500 bridge */ {
392                 .firmware_revision      = 0x002600,
393                 .model                  = SBP2_ROM_VALUE_WILDCARD,
394                 .workarounds            = SBP2_WORKAROUND_128K_MAX_TRANS,
395         },
396         /*
397          * iPod 2nd generation: needs 128k max transfer size workaround
398          * iPod 3rd generation: needs fix capacity workaround
399          */
400         {
401                 .firmware_revision      = 0x0a2700,
402                 .model                  = 0x000000,
403                 .workarounds            = SBP2_WORKAROUND_128K_MAX_TRANS |
404                                           SBP2_WORKAROUND_FIX_CAPACITY,
405         },
406         /* iPod 4th generation */ {
407                 .firmware_revision      = 0x0a2700,
408                 .model                  = 0x000021,
409                 .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
410         },
411         /* iPod mini */ {
412                 .firmware_revision      = 0x0a2700,
413                 .model                  = 0x000022,
414                 .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
415         },
416         /* iPod mini */ {
417                 .firmware_revision      = 0x0a2700,
418                 .model                  = 0x000023,
419                 .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
420         },
421         /* iPod Photo */ {
422                 .firmware_revision      = 0x0a2700,
423                 .model                  = 0x00007e,
424                 .workarounds            = SBP2_WORKAROUND_FIX_CAPACITY,
425         }
426 };
427
428 /**************************************
429  * General utility functions
430  **************************************/
431
432 #ifndef __BIG_ENDIAN
433 /*
434  * Converts a buffer from be32 to cpu byte ordering. Length is in bytes.
435  */
436 static inline void sbp2util_be32_to_cpu_buffer(void *buffer, int length)
437 {
438         u32 *temp = buffer;
439
440         for (length = (length >> 2); length--; )
441                 temp[length] = be32_to_cpu(temp[length]);
442 }
443
444 /*
445  * Converts a buffer from cpu to be32 byte ordering. Length is in bytes.
446  */
447 static inline void sbp2util_cpu_to_be32_buffer(void *buffer, int length)
448 {
449         u32 *temp = buffer;
450
451         for (length = (length >> 2); length--; )
452                 temp[length] = cpu_to_be32(temp[length]);
453 }
454 #else /* BIG_ENDIAN */
455 /* Why waste the cpu cycles? */
456 #define sbp2util_be32_to_cpu_buffer(x,y) do {} while (0)
457 #define sbp2util_cpu_to_be32_buffer(x,y) do {} while (0)
458 #endif
459
460 static DECLARE_WAIT_QUEUE_HEAD(sbp2_access_wq);
461
462 /*
463  * Waits for completion of an SBP-2 access request.
464  * Returns nonzero if timed out or prematurely interrupted.
465  */
466 static int sbp2util_access_timeout(struct sbp2_lu *lu, int timeout)
467 {
468         long leftover;
469
470         leftover = wait_event_interruptible_timeout(
471                         sbp2_access_wq, lu->access_complete, timeout);
472         lu->access_complete = 0;
473         return leftover <= 0;
474 }
475
476 static void sbp2_free_packet(void *packet)
477 {
478         hpsb_free_tlabel(packet);
479         hpsb_free_packet(packet);
480 }
481
482 /*
483  * This is much like hpsb_node_write(), except it ignores the response
484  * subaction and returns immediately. Can be used from atomic context.
485  */
486 static int sbp2util_node_write_no_wait(struct node_entry *ne, u64 addr,
487                                        quadlet_t *buf, size_t len)
488 {
489         struct hpsb_packet *packet;
490
491         packet = hpsb_make_writepacket(ne->host, ne->nodeid, addr, buf, len);
492         if (!packet)
493                 return -ENOMEM;
494
495         hpsb_set_packet_complete_task(packet, sbp2_free_packet, packet);
496         hpsb_node_fill_packet(ne, packet);
497         if (hpsb_send_packet(packet) < 0) {
498                 sbp2_free_packet(packet);
499                 return -EIO;
500         }
501         return 0;
502 }
503
504 static void sbp2util_notify_fetch_agent(struct sbp2_lu *lu, u64 offset,
505                                         quadlet_t *data, size_t len)
506 {
507         /* There is a small window after a bus reset within which the node
508          * entry's generation is current but the reconnect wasn't completed. */
509         if (unlikely(atomic_read(&lu->state) == SBP2LU_STATE_IN_RESET))
510                 return;
511
512         if (hpsb_node_write(lu->ne, lu->command_block_agent_addr + offset,
513                             data, len))
514                 SBP2_ERR("sbp2util_notify_fetch_agent failed.");
515
516         /* Now accept new SCSI commands, unless a bus reset happended during
517          * hpsb_node_write. */
518         if (likely(atomic_read(&lu->state) != SBP2LU_STATE_IN_RESET))
519                 scsi_unblock_requests(lu->shost);
520 }
521
522 static void sbp2util_write_orb_pointer(struct work_struct *work)
523 {
524         struct sbp2_lu *lu = container_of(work, struct sbp2_lu, protocol_work);
525         quadlet_t data[2];
526
527         data[0] = ORB_SET_NODE_ID(lu->hi->host->node_id);
528         data[1] = lu->last_orb_dma;
529         sbp2util_cpu_to_be32_buffer(data, 8);
530         sbp2util_notify_fetch_agent(lu, SBP2_ORB_POINTER_OFFSET, data, 8);
531 }
532
533 static void sbp2util_write_doorbell(struct work_struct *work)
534 {
535         struct sbp2_lu *lu = container_of(work, struct sbp2_lu, protocol_work);
536
537         sbp2util_notify_fetch_agent(lu, SBP2_DOORBELL_OFFSET, NULL, 4);
538 }
539
540 static int sbp2util_create_command_orb_pool(struct sbp2_lu *lu)
541 {
542         struct sbp2_command_info *cmd;
543         struct device *dmadev = lu->hi->host->device.parent;
544         int i, orbs = sbp2_serialize_io ? 2 : SBP2_MAX_CMDS;
545
546         for (i = 0; i < orbs; i++) {
547                 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
548                 if (!cmd)
549                         goto failed_alloc;
550
551                 cmd->command_orb_dma =
552                     dma_map_single(dmadev, &cmd->command_orb,
553                                    sizeof(struct sbp2_command_orb),
554                                    DMA_TO_DEVICE);
555                 if (dma_mapping_error(dmadev, cmd->command_orb_dma))
556                         goto failed_orb;
557
558                 cmd->sge_dma =
559                     dma_map_single(dmadev, &cmd->scatter_gather_element,
560                                    sizeof(cmd->scatter_gather_element),
561                                    DMA_TO_DEVICE);
562                 if (dma_mapping_error(dmadev, cmd->sge_dma))
563                         goto failed_sge;
564
565                 INIT_LIST_HEAD(&cmd->list);
566                 list_add_tail(&cmd->list, &lu->cmd_orb_completed);
567         }
568         return 0;
569
570 failed_sge:
571         dma_unmap_single(dmadev, cmd->command_orb_dma,
572                          sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
573 failed_orb:
574         kfree(cmd);
575 failed_alloc:
576         return -ENOMEM;
577 }
578
579 static void sbp2util_remove_command_orb_pool(struct sbp2_lu *lu,
580                                              struct hpsb_host *host)
581 {
582         struct list_head *lh, *next;
583         struct sbp2_command_info *cmd;
584         unsigned long flags;
585
586         spin_lock_irqsave(&lu->cmd_orb_lock, flags);
587         if (!list_empty(&lu->cmd_orb_completed))
588                 list_for_each_safe(lh, next, &lu->cmd_orb_completed) {
589                         cmd = list_entry(lh, struct sbp2_command_info, list);
590                         dma_unmap_single(host->device.parent,
591                                          cmd->command_orb_dma,
592                                          sizeof(struct sbp2_command_orb),
593                                          DMA_TO_DEVICE);
594                         dma_unmap_single(host->device.parent, cmd->sge_dma,
595                                          sizeof(cmd->scatter_gather_element),
596                                          DMA_TO_DEVICE);
597                         kfree(cmd);
598                 }
599         spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
600         return;
601 }
602
603 /*
604  * Finds the sbp2_command for a given outstanding command ORB.
605  * Only looks at the in-use list.
606  */
607 static struct sbp2_command_info *sbp2util_find_command_for_orb(
608                                 struct sbp2_lu *lu, dma_addr_t orb)
609 {
610         struct sbp2_command_info *cmd;
611         unsigned long flags;
612
613         spin_lock_irqsave(&lu->cmd_orb_lock, flags);
614         if (!list_empty(&lu->cmd_orb_inuse))
615                 list_for_each_entry(cmd, &lu->cmd_orb_inuse, list)
616                         if (cmd->command_orb_dma == orb) {
617                                 spin_unlock_irqrestore(
618                                                 &lu->cmd_orb_lock, flags);
619                                 return cmd;
620                         }
621         spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
622         return NULL;
623 }
624
625 /*
626  * Finds the sbp2_command for a given outstanding SCpnt.
627  * Only looks at the in-use list.
628  * Must be called with lu->cmd_orb_lock held.
629  */
630 static struct sbp2_command_info *sbp2util_find_command_for_SCpnt(
631                                 struct sbp2_lu *lu, void *SCpnt)
632 {
633         struct sbp2_command_info *cmd;
634
635         if (!list_empty(&lu->cmd_orb_inuse))
636                 list_for_each_entry(cmd, &lu->cmd_orb_inuse, list)
637                         if (cmd->Current_SCpnt == SCpnt)
638                                 return cmd;
639         return NULL;
640 }
641
642 static struct sbp2_command_info *sbp2util_allocate_command_orb(
643                                 struct sbp2_lu *lu,
644                                 struct scsi_cmnd *Current_SCpnt,
645                                 void (*Current_done)(struct scsi_cmnd *))
646 {
647         struct list_head *lh;
648         struct sbp2_command_info *cmd = NULL;
649         unsigned long flags;
650
651         spin_lock_irqsave(&lu->cmd_orb_lock, flags);
652         if (!list_empty(&lu->cmd_orb_completed)) {
653                 lh = lu->cmd_orb_completed.next;
654                 list_del(lh);
655                 cmd = list_entry(lh, struct sbp2_command_info, list);
656                 cmd->Current_done = Current_done;
657                 cmd->Current_SCpnt = Current_SCpnt;
658                 list_add_tail(&cmd->list, &lu->cmd_orb_inuse);
659         } else
660                 SBP2_ERR("%s: no orbs available", __func__);
661         spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
662         return cmd;
663 }
664
665 /*
666  * Unmaps the DMAs of a command and moves the command to the completed ORB list.
667  * Must be called with lu->cmd_orb_lock held.
668  */
669 static void sbp2util_mark_command_completed(struct sbp2_lu *lu,
670                                             struct sbp2_command_info *cmd)
671 {
672         if (scsi_sg_count(cmd->Current_SCpnt))
673                 dma_unmap_sg(lu->ud->ne->host->device.parent,
674                              scsi_sglist(cmd->Current_SCpnt),
675                              scsi_sg_count(cmd->Current_SCpnt),
676                              cmd->Current_SCpnt->sc_data_direction);
677         list_move_tail(&cmd->list, &lu->cmd_orb_completed);
678 }
679
680 /*
681  * Is lu valid? Is the 1394 node still present?
682  */
683 static inline int sbp2util_node_is_available(struct sbp2_lu *lu)
684 {
685         return lu && lu->ne && !lu->ne->in_limbo;
686 }
687
688 /*********************************************
689  * IEEE-1394 core driver stack related section
690  *********************************************/
691
692 static int sbp2_probe(struct device *dev)
693 {
694         struct unit_directory *ud;
695         struct sbp2_lu *lu;
696
697         ud = container_of(dev, struct unit_directory, device);
698
699         /* Don't probe UD's that have the LUN flag. We'll probe the LUN(s)
700          * instead. */
701         if (ud->flags & UNIT_DIRECTORY_HAS_LUN_DIRECTORY)
702                 return -ENODEV;
703
704         lu = sbp2_alloc_device(ud);
705         if (!lu)
706                 return -ENOMEM;
707
708         sbp2_parse_unit_directory(lu, ud);
709         return sbp2_start_device(lu);
710 }
711
712 static int sbp2_remove(struct device *dev)
713 {
714         struct unit_directory *ud;
715         struct sbp2_lu *lu;
716         struct scsi_device *sdev;
717
718         ud = container_of(dev, struct unit_directory, device);
719         lu = dev_get_drvdata(&ud->device);
720         if (!lu)
721                 return 0;
722
723         if (lu->shost) {
724                 /* Get rid of enqueued commands if there is no chance to
725                  * send them. */
726                 if (!sbp2util_node_is_available(lu))
727                         sbp2scsi_complete_all_commands(lu, DID_NO_CONNECT);
728                 /* scsi_remove_device() may trigger shutdown functions of SCSI
729                  * highlevel drivers which would deadlock if blocked. */
730                 atomic_set(&lu->state, SBP2LU_STATE_IN_SHUTDOWN);
731                 scsi_unblock_requests(lu->shost);
732         }
733         sdev = lu->sdev;
734         if (sdev) {
735                 lu->sdev = NULL;
736                 scsi_remove_device(sdev);
737         }
738
739         sbp2_logout_device(lu);
740         sbp2_remove_device(lu);
741
742         return 0;
743 }
744
745 static int sbp2_update(struct unit_directory *ud)
746 {
747         struct sbp2_lu *lu = dev_get_drvdata(&ud->device);
748
749         if (sbp2_reconnect_device(lu) != 0) {
750                 /*
751                  * Reconnect failed.  If another bus reset happened,
752                  * let nodemgr proceed and call sbp2_update again later
753                  * (or sbp2_remove if this node went away).
754                  */
755                 if (!hpsb_node_entry_valid(lu->ne))
756                         return 0;
757                 /*
758                  * Or the target rejected the reconnect because we weren't
759                  * fast enough.  Try a regular login, but first log out
760                  * just in case of any weirdness.
761                  */
762                 sbp2_logout_device(lu);
763
764                 if (sbp2_login_device(lu) != 0) {
765                         if (!hpsb_node_entry_valid(lu->ne))
766                                 return 0;
767
768                         /* Maybe another initiator won the login. */
769                         SBP2_ERR("Failed to reconnect to sbp2 device!");
770                         return -EBUSY;
771                 }
772         }
773
774         sbp2_set_busy_timeout(lu);
775         sbp2_agent_reset(lu, 1);
776         sbp2_max_speed_and_size(lu);
777
778         /* Complete any pending commands with busy (so they get retried)
779          * and remove them from our queue. */
780         sbp2scsi_complete_all_commands(lu, DID_BUS_BUSY);
781
782         /* Accept new commands unless there was another bus reset in the
783          * meantime. */
784         if (hpsb_node_entry_valid(lu->ne)) {
785                 atomic_set(&lu->state, SBP2LU_STATE_RUNNING);
786                 scsi_unblock_requests(lu->shost);
787         }
788         return 0;
789 }
790
791 static struct sbp2_lu *sbp2_alloc_device(struct unit_directory *ud)
792 {
793         struct sbp2_fwhost_info *hi;
794         struct Scsi_Host *shost = NULL;
795         struct sbp2_lu *lu = NULL;
796         unsigned long flags;
797
798         lu = kzalloc(sizeof(*lu), GFP_KERNEL);
799         if (!lu) {
800                 SBP2_ERR("failed to create lu");
801                 goto failed_alloc;
802         }
803
804         lu->ne = ud->ne;
805         lu->ud = ud;
806         lu->speed_code = IEEE1394_SPEED_100;
807         lu->max_payload_size = sbp2_speedto_max_payload[IEEE1394_SPEED_100];
808         lu->status_fifo_addr = CSR1212_INVALID_ADDR_SPACE;
809         INIT_LIST_HEAD(&lu->cmd_orb_inuse);
810         INIT_LIST_HEAD(&lu->cmd_orb_completed);
811         INIT_LIST_HEAD(&lu->lu_list);
812         spin_lock_init(&lu->cmd_orb_lock);
813         atomic_set(&lu->state, SBP2LU_STATE_RUNNING);
814         INIT_WORK(&lu->protocol_work, NULL);
815
816         dev_set_drvdata(&ud->device, lu);
817
818         hi = hpsb_get_hostinfo(&sbp2_highlevel, ud->ne->host);
819         if (!hi) {
820                 hi = hpsb_create_hostinfo(&sbp2_highlevel, ud->ne->host,
821                                           sizeof(*hi));
822                 if (!hi) {
823                         SBP2_ERR("failed to allocate hostinfo");
824                         goto failed_alloc;
825                 }
826                 hi->host = ud->ne->host;
827                 INIT_LIST_HEAD(&hi->logical_units);
828
829 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
830                 /* Handle data movement if physical dma is not
831                  * enabled or not supported on host controller */
832                 if (!hpsb_register_addrspace(&sbp2_highlevel, ud->ne->host,
833                                              &sbp2_physdma_ops,
834                                              0x0ULL, 0xfffffffcULL)) {
835                         SBP2_ERR("failed to register lower 4GB address range");
836                         goto failed_alloc;
837                 }
838 #endif
839         }
840
841         if (dma_get_max_seg_size(hi->host->device.parent) > SBP2_MAX_SEG_SIZE)
842                 BUG_ON(dma_set_max_seg_size(hi->host->device.parent,
843                                             SBP2_MAX_SEG_SIZE));
844
845         /* Prevent unloading of the 1394 host */
846         if (!try_module_get(hi->host->driver->owner)) {
847                 SBP2_ERR("failed to get a reference on 1394 host driver");
848                 goto failed_alloc;
849         }
850
851         lu->hi = hi;
852
853         write_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
854         list_add_tail(&lu->lu_list, &hi->logical_units);
855         write_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
856
857         /* Register the status FIFO address range. We could use the same FIFO
858          * for targets at different nodes. However we need different FIFOs per
859          * target in order to support multi-unit devices.
860          * The FIFO is located out of the local host controller's physical range
861          * but, if possible, within the posted write area. Status writes will
862          * then be performed as unified transactions. This slightly reduces
863          * bandwidth usage, and some Prolific based devices seem to require it.
864          */
865         lu->status_fifo_addr = hpsb_allocate_and_register_addrspace(
866                         &sbp2_highlevel, ud->ne->host, &sbp2_ops,
867                         sizeof(struct sbp2_status_block), sizeof(quadlet_t),
868                         ud->ne->host->low_addr_space, CSR1212_ALL_SPACE_END);
869         if (lu->status_fifo_addr == CSR1212_INVALID_ADDR_SPACE) {
870                 SBP2_ERR("failed to allocate status FIFO address range");
871                 goto failed_alloc;
872         }
873
874         shost = scsi_host_alloc(&sbp2_shost_template, sizeof(unsigned long));
875         if (!shost) {
876                 SBP2_ERR("failed to register scsi host");
877                 goto failed_alloc;
878         }
879
880         shost->hostdata[0] = (unsigned long)lu;
881         shost->max_cmd_len = SBP2_MAX_CDB_SIZE;
882
883         if (!scsi_add_host(shost, &ud->device)) {
884                 lu->shost = shost;
885                 return lu;
886         }
887
888         SBP2_ERR("failed to add scsi host");
889         scsi_host_put(shost);
890
891 failed_alloc:
892         sbp2_remove_device(lu);
893         return NULL;
894 }
895
896 static void sbp2_host_reset(struct hpsb_host *host)
897 {
898         struct sbp2_fwhost_info *hi;
899         struct sbp2_lu *lu;
900         unsigned long flags;
901
902         hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
903         if (!hi)
904                 return;
905
906         read_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
907
908         list_for_each_entry(lu, &hi->logical_units, lu_list)
909                 if (atomic_cmpxchg(&lu->state,
910                                    SBP2LU_STATE_RUNNING, SBP2LU_STATE_IN_RESET)
911                     == SBP2LU_STATE_RUNNING)
912                         scsi_block_requests(lu->shost);
913
914         read_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
915 }
916
917 static int sbp2_start_device(struct sbp2_lu *lu)
918 {
919         struct sbp2_fwhost_info *hi = lu->hi;
920         int error;
921
922         lu->login_response = dma_alloc_coherent(hi->host->device.parent,
923                                      sizeof(struct sbp2_login_response),
924                                      &lu->login_response_dma, GFP_KERNEL);
925         if (!lu->login_response)
926                 goto alloc_fail;
927
928         lu->query_logins_orb = dma_alloc_coherent(hi->host->device.parent,
929                                      sizeof(struct sbp2_query_logins_orb),
930                                      &lu->query_logins_orb_dma, GFP_KERNEL);
931         if (!lu->query_logins_orb)
932                 goto alloc_fail;
933
934         lu->query_logins_response = dma_alloc_coherent(hi->host->device.parent,
935                                      sizeof(struct sbp2_query_logins_response),
936                                      &lu->query_logins_response_dma, GFP_KERNEL);
937         if (!lu->query_logins_response)
938                 goto alloc_fail;
939
940         lu->reconnect_orb = dma_alloc_coherent(hi->host->device.parent,
941                                      sizeof(struct sbp2_reconnect_orb),
942                                      &lu->reconnect_orb_dma, GFP_KERNEL);
943         if (!lu->reconnect_orb)
944                 goto alloc_fail;
945
946         lu->logout_orb = dma_alloc_coherent(hi->host->device.parent,
947                                      sizeof(struct sbp2_logout_orb),
948                                      &lu->logout_orb_dma, GFP_KERNEL);
949         if (!lu->logout_orb)
950                 goto alloc_fail;
951
952         lu->login_orb = dma_alloc_coherent(hi->host->device.parent,
953                                      sizeof(struct sbp2_login_orb),
954                                      &lu->login_orb_dma, GFP_KERNEL);
955         if (!lu->login_orb)
956                 goto alloc_fail;
957
958         if (sbp2util_create_command_orb_pool(lu))
959                 goto alloc_fail;
960
961         /* Wait a second before trying to log in. Previously logged in
962          * initiators need a chance to reconnect. */
963         if (msleep_interruptible(1000)) {
964                 sbp2_remove_device(lu);
965                 return -EINTR;
966         }
967
968         if (sbp2_login_device(lu)) {
969                 sbp2_remove_device(lu);
970                 return -EBUSY;
971         }
972
973         sbp2_set_busy_timeout(lu);
974         sbp2_agent_reset(lu, 1);
975         sbp2_max_speed_and_size(lu);
976
977         if (lu->workarounds & SBP2_WORKAROUND_DELAY_INQUIRY)
978                 ssleep(SBP2_INQUIRY_DELAY);
979
980         error = scsi_add_device(lu->shost, 0, lu->ud->id, 0);
981         if (error) {
982                 SBP2_ERR("scsi_add_device failed");
983                 sbp2_logout_device(lu);
984                 sbp2_remove_device(lu);
985                 return error;
986         }
987
988         return 0;
989
990 alloc_fail:
991         SBP2_ERR("Could not allocate memory for lu");
992         sbp2_remove_device(lu);
993         return -ENOMEM;
994 }
995
996 static void sbp2_remove_device(struct sbp2_lu *lu)
997 {
998         struct sbp2_fwhost_info *hi;
999         unsigned long flags;
1000
1001         if (!lu)
1002                 return;
1003         hi = lu->hi;
1004         if (!hi)
1005                 goto no_hi;
1006
1007         if (lu->shost) {
1008                 scsi_remove_host(lu->shost);
1009                 scsi_host_put(lu->shost);
1010         }
1011         flush_scheduled_work();
1012         sbp2util_remove_command_orb_pool(lu, hi->host);
1013
1014         write_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
1015         list_del(&lu->lu_list);
1016         write_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
1017
1018         if (lu->login_response)
1019                 dma_free_coherent(hi->host->device.parent,
1020                                     sizeof(struct sbp2_login_response),
1021                                     lu->login_response,
1022                                     lu->login_response_dma);
1023         if (lu->login_orb)
1024                 dma_free_coherent(hi->host->device.parent,
1025                                     sizeof(struct sbp2_login_orb),
1026                                     lu->login_orb,
1027                                     lu->login_orb_dma);
1028         if (lu->reconnect_orb)
1029                 dma_free_coherent(hi->host->device.parent,
1030                                     sizeof(struct sbp2_reconnect_orb),
1031                                     lu->reconnect_orb,
1032                                     lu->reconnect_orb_dma);
1033         if (lu->logout_orb)
1034                 dma_free_coherent(hi->host->device.parent,
1035                                     sizeof(struct sbp2_logout_orb),
1036                                     lu->logout_orb,
1037                                     lu->logout_orb_dma);
1038         if (lu->query_logins_orb)
1039                 dma_free_coherent(hi->host->device.parent,
1040                                     sizeof(struct sbp2_query_logins_orb),
1041                                     lu->query_logins_orb,
1042                                     lu->query_logins_orb_dma);
1043         if (lu->query_logins_response)
1044                 dma_free_coherent(hi->host->device.parent,
1045                                     sizeof(struct sbp2_query_logins_response),
1046                                     lu->query_logins_response,
1047                                     lu->query_logins_response_dma);
1048
1049         if (lu->status_fifo_addr != CSR1212_INVALID_ADDR_SPACE)
1050                 hpsb_unregister_addrspace(&sbp2_highlevel, hi->host,
1051                                           lu->status_fifo_addr);
1052
1053         dev_set_drvdata(&lu->ud->device, NULL);
1054
1055         module_put(hi->host->driver->owner);
1056 no_hi:
1057         kfree(lu);
1058 }
1059
1060 #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
1061 /*
1062  * Deal with write requests on adapters which do not support physical DMA or
1063  * have it switched off.
1064  */
1065 static int sbp2_handle_physdma_write(struct hpsb_host *host, int nodeid,
1066                                      int destid, quadlet_t *data, u64 addr,
1067                                      size_t length, u16 flags)
1068 {
1069         memcpy(bus_to_virt((u32) addr), data, length);
1070         return RCODE_COMPLETE;
1071 }
1072
1073 /*
1074  * Deal with read requests on adapters which do not support physical DMA or
1075  * have it switched off.
1076  */
1077 static int sbp2_handle_physdma_read(struct hpsb_host *host, int nodeid,
1078                                     quadlet_t *data, u64 addr, size_t length,
1079                                     u16 flags)
1080 {
1081         memcpy(data, bus_to_virt((u32) addr), length);
1082         return RCODE_COMPLETE;
1083 }
1084 #endif
1085
1086 /**************************************
1087  * SBP-2 protocol related section
1088  **************************************/
1089
1090 static int sbp2_query_logins(struct sbp2_lu *lu)
1091 {
1092         struct sbp2_fwhost_info *hi = lu->hi;
1093         quadlet_t data[2];
1094         int max_logins;
1095         int active_logins;
1096
1097         lu->query_logins_orb->reserved1 = 0x0;
1098         lu->query_logins_orb->reserved2 = 0x0;
1099
1100         lu->query_logins_orb->query_response_lo = lu->query_logins_response_dma;
1101         lu->query_logins_orb->query_response_hi =
1102                         ORB_SET_NODE_ID(hi->host->node_id);
1103         lu->query_logins_orb->lun_misc =
1104                         ORB_SET_FUNCTION(SBP2_QUERY_LOGINS_REQUEST);
1105         lu->query_logins_orb->lun_misc |= ORB_SET_NOTIFY(1);
1106         lu->query_logins_orb->lun_misc |= ORB_SET_LUN(lu->lun);
1107
1108         lu->query_logins_orb->reserved_resp_length =
1109                 ORB_SET_QUERY_LOGINS_RESP_LENGTH(
1110                         sizeof(struct sbp2_query_logins_response));
1111
1112         lu->query_logins_orb->status_fifo_hi =
1113                 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1114         lu->query_logins_orb->status_fifo_lo =
1115                 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
1116
1117         sbp2util_cpu_to_be32_buffer(lu->query_logins_orb,
1118                                     sizeof(struct sbp2_query_logins_orb));
1119
1120         memset(lu->query_logins_response, 0,
1121                sizeof(struct sbp2_query_logins_response));
1122
1123         data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1124         data[1] = lu->query_logins_orb_dma;
1125         sbp2util_cpu_to_be32_buffer(data, 8);
1126
1127         hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
1128
1129         if (sbp2util_access_timeout(lu, 2*HZ)) {
1130                 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
1131                 return -EIO;
1132         }
1133
1134         if (lu->status_block.ORB_offset_lo != lu->query_logins_orb_dma) {
1135                 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
1136                 return -EIO;
1137         }
1138
1139         if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
1140                 SBP2_INFO("Error querying logins to SBP-2 device - failed");
1141                 return -EIO;
1142         }
1143
1144         sbp2util_cpu_to_be32_buffer(lu->query_logins_response,
1145                                     sizeof(struct sbp2_query_logins_response));
1146
1147         max_logins = RESPONSE_GET_MAX_LOGINS(
1148                         lu->query_logins_response->length_max_logins);
1149         SBP2_INFO("Maximum concurrent logins supported: %d", max_logins);
1150
1151         active_logins = RESPONSE_GET_ACTIVE_LOGINS(
1152                         lu->query_logins_response->length_max_logins);
1153         SBP2_INFO("Number of active logins: %d", active_logins);
1154
1155         if (active_logins >= max_logins) {
1156                 return -EIO;
1157         }
1158
1159         return 0;
1160 }
1161
1162 static int sbp2_login_device(struct sbp2_lu *lu)
1163 {
1164         struct sbp2_fwhost_info *hi = lu->hi;
1165         quadlet_t data[2];
1166
1167         if (!lu->login_orb)
1168                 return -EIO;
1169
1170         if (!sbp2_exclusive_login && sbp2_query_logins(lu)) {
1171                 SBP2_INFO("Device does not support any more concurrent logins");
1172                 return -EIO;
1173         }
1174
1175         /* assume no password */
1176         lu->login_orb->password_hi = 0;
1177         lu->login_orb->password_lo = 0;
1178
1179         lu->login_orb->login_response_lo = lu->login_response_dma;
1180         lu->login_orb->login_response_hi = ORB_SET_NODE_ID(hi->host->node_id);
1181         lu->login_orb->lun_misc = ORB_SET_FUNCTION(SBP2_LOGIN_REQUEST);
1182
1183         /* one second reconnect time */
1184         lu->login_orb->lun_misc |= ORB_SET_RECONNECT(0);
1185         lu->login_orb->lun_misc |= ORB_SET_EXCLUSIVE(sbp2_exclusive_login);
1186         lu->login_orb->lun_misc |= ORB_SET_NOTIFY(1);
1187         lu->login_orb->lun_misc |= ORB_SET_LUN(lu->lun);
1188
1189         lu->login_orb->passwd_resp_lengths =
1190                 ORB_SET_LOGIN_RESP_LENGTH(sizeof(struct sbp2_login_response));
1191
1192         lu->login_orb->status_fifo_hi =
1193                 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1194         lu->login_orb->status_fifo_lo =
1195                 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
1196
1197         sbp2util_cpu_to_be32_buffer(lu->login_orb,
1198                                     sizeof(struct sbp2_login_orb));
1199
1200         memset(lu->login_response, 0, sizeof(struct sbp2_login_response));
1201
1202         data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1203         data[1] = lu->login_orb_dma;
1204         sbp2util_cpu_to_be32_buffer(data, 8);
1205
1206         hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
1207
1208         /* wait up to 20 seconds for login status */
1209         if (sbp2util_access_timeout(lu, 20*HZ)) {
1210                 SBP2_ERR("Error logging into SBP-2 device - timed out");
1211                 return -EIO;
1212         }
1213
1214         /* make sure that the returned status matches the login ORB */
1215         if (lu->status_block.ORB_offset_lo != lu->login_orb_dma) {
1216                 SBP2_ERR("Error logging into SBP-2 device - timed out");
1217                 return -EIO;
1218         }
1219
1220         if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
1221                 SBP2_ERR("Error logging into SBP-2 device - failed");
1222                 return -EIO;
1223         }
1224
1225         sbp2util_cpu_to_be32_buffer(lu->login_response,
1226                                     sizeof(struct sbp2_login_response));
1227         lu->command_block_agent_addr =
1228                         ((u64)lu->login_response->command_block_agent_hi) << 32;
1229         lu->command_block_agent_addr |=
1230                         ((u64)lu->login_response->command_block_agent_lo);
1231         lu->command_block_agent_addr &= 0x0000ffffffffffffULL;
1232
1233         SBP2_INFO("Logged into SBP-2 device");
1234         return 0;
1235 }
1236
1237 static int sbp2_logout_device(struct sbp2_lu *lu)
1238 {
1239         struct sbp2_fwhost_info *hi = lu->hi;
1240         quadlet_t data[2];
1241         int error;
1242
1243         lu->logout_orb->reserved1 = 0x0;
1244         lu->logout_orb->reserved2 = 0x0;
1245         lu->logout_orb->reserved3 = 0x0;
1246         lu->logout_orb->reserved4 = 0x0;
1247
1248         lu->logout_orb->login_ID_misc = ORB_SET_FUNCTION(SBP2_LOGOUT_REQUEST);
1249         lu->logout_orb->login_ID_misc |=
1250                         ORB_SET_LOGIN_ID(lu->login_response->length_login_ID);
1251         lu->logout_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
1252
1253         lu->logout_orb->reserved5 = 0x0;
1254         lu->logout_orb->status_fifo_hi =
1255                 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1256         lu->logout_orb->status_fifo_lo =
1257                 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
1258
1259         sbp2util_cpu_to_be32_buffer(lu->logout_orb,
1260                                     sizeof(struct sbp2_logout_orb));
1261
1262         data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1263         data[1] = lu->logout_orb_dma;
1264         sbp2util_cpu_to_be32_buffer(data, 8);
1265
1266         error = hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
1267         if (error)
1268                 return error;
1269
1270         /* wait up to 1 second for the device to complete logout */
1271         if (sbp2util_access_timeout(lu, HZ))
1272                 return -EIO;
1273
1274         SBP2_INFO("Logged out of SBP-2 device");
1275         return 0;
1276 }
1277
1278 static int sbp2_reconnect_device(struct sbp2_lu *lu)
1279 {
1280         struct sbp2_fwhost_info *hi = lu->hi;
1281         quadlet_t data[2];
1282         int error;
1283
1284         lu->reconnect_orb->reserved1 = 0x0;
1285         lu->reconnect_orb->reserved2 = 0x0;
1286         lu->reconnect_orb->reserved3 = 0x0;
1287         lu->reconnect_orb->reserved4 = 0x0;
1288
1289         lu->reconnect_orb->login_ID_misc =
1290                         ORB_SET_FUNCTION(SBP2_RECONNECT_REQUEST);
1291         lu->reconnect_orb->login_ID_misc |=
1292                         ORB_SET_LOGIN_ID(lu->login_response->length_login_ID);
1293         lu->reconnect_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
1294
1295         lu->reconnect_orb->reserved5 = 0x0;
1296         lu->reconnect_orb->status_fifo_hi =
1297                 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1298         lu->reconnect_orb->status_fifo_lo =
1299                 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
1300
1301         sbp2util_cpu_to_be32_buffer(lu->reconnect_orb,
1302                                     sizeof(struct sbp2_reconnect_orb));
1303
1304         data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1305         data[1] = lu->reconnect_orb_dma;
1306         sbp2util_cpu_to_be32_buffer(data, 8);
1307
1308         error = hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
1309         if (error)
1310                 return error;
1311
1312         /* wait up to 1 second for reconnect status */
1313         if (sbp2util_access_timeout(lu, HZ)) {
1314                 SBP2_ERR("Error reconnecting to SBP-2 device - timed out");
1315                 return -EIO;
1316         }
1317
1318         /* make sure that the returned status matches the reconnect ORB */
1319         if (lu->status_block.ORB_offset_lo != lu->reconnect_orb_dma) {
1320                 SBP2_ERR("Error reconnecting to SBP-2 device - timed out");
1321                 return -EIO;
1322         }
1323
1324         if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
1325                 SBP2_ERR("Error reconnecting to SBP-2 device - failed");
1326                 return -EIO;
1327         }
1328
1329         SBP2_INFO("Reconnected to SBP-2 device");
1330         return 0;
1331 }
1332
1333 /*
1334  * Set the target node's Single Phase Retry limit. Affects the target's retry
1335  * behaviour if our node is too busy to accept requests.
1336  */
1337 static int sbp2_set_busy_timeout(struct sbp2_lu *lu)
1338 {
1339         quadlet_t data;
1340
1341         data = cpu_to_be32(SBP2_BUSY_TIMEOUT_VALUE);
1342         if (hpsb_node_write(lu->ne, SBP2_BUSY_TIMEOUT_ADDRESS, &data, 4))
1343                 SBP2_ERR("%s error", __func__);
1344         return 0;
1345 }
1346
1347 static void sbp2_parse_unit_directory(struct sbp2_lu *lu,
1348                                       struct unit_directory *ud)
1349 {
1350         struct csr1212_keyval *kv;
1351         struct csr1212_dentry *dentry;
1352         u64 management_agent_addr;
1353         u32 unit_characteristics, firmware_revision, model;
1354         unsigned workarounds;
1355         int i;
1356
1357         management_agent_addr = 0;
1358         unit_characteristics = 0;
1359         firmware_revision = SBP2_ROM_VALUE_MISSING;
1360         model = ud->flags & UNIT_DIRECTORY_MODEL_ID ?
1361                                 ud->model_id : SBP2_ROM_VALUE_MISSING;
1362
1363         csr1212_for_each_dir_entry(ud->ne->csr, kv, ud->ud_kv, dentry) {
1364                 switch (kv->key.id) {
1365                 case CSR1212_KV_ID_DEPENDENT_INFO:
1366                         if (kv->key.type == CSR1212_KV_TYPE_CSR_OFFSET)
1367                                 management_agent_addr =
1368                                     CSR1212_REGISTER_SPACE_BASE +
1369                                     (kv->value.csr_offset << 2);
1370
1371                         else if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE)
1372                                 lu->lun = ORB_SET_LUN(kv->value.immediate);
1373                         break;
1374
1375                 case SBP2_UNIT_CHARACTERISTICS_KEY:
1376                         /* FIXME: This is ignored so far.
1377                          * See SBP-2 clause 7.4.8. */
1378                         unit_characteristics = kv->value.immediate;
1379                         break;
1380
1381                 case SBP2_FIRMWARE_REVISION_KEY:
1382                         firmware_revision = kv->value.immediate;
1383                         break;
1384
1385                 default:
1386                         /* FIXME: Check for SBP2_DEVICE_TYPE_AND_LUN_KEY.
1387                          * Its "ordered" bit has consequences for command ORB
1388                          * list handling. See SBP-2 clauses 4.6, 7.4.11, 10.2 */
1389                         break;
1390                 }
1391         }
1392
1393         workarounds = sbp2_default_workarounds;
1394
1395         if (!(workarounds & SBP2_WORKAROUND_OVERRIDE))
1396                 for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
1397                         if (sbp2_workarounds_table[i].firmware_revision !=
1398                             SBP2_ROM_VALUE_WILDCARD &&
1399                             sbp2_workarounds_table[i].firmware_revision !=
1400                             (firmware_revision & 0xffff00))
1401                                 continue;
1402                         if (sbp2_workarounds_table[i].model !=
1403                             SBP2_ROM_VALUE_WILDCARD &&
1404                             sbp2_workarounds_table[i].model != model)
1405                                 continue;
1406                         workarounds |= sbp2_workarounds_table[i].workarounds;
1407                         break;
1408                 }
1409
1410         if (workarounds)
1411                 SBP2_INFO("Workarounds for node " NODE_BUS_FMT ": 0x%x "
1412                           "(firmware_revision 0x%06x, vendor_id 0x%06x,"
1413                           " model_id 0x%06x)",
1414                           NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid),
1415                           workarounds, firmware_revision, ud->vendor_id,
1416                           model);
1417
1418         /* We would need one SCSI host template for each target to adjust
1419          * max_sectors on the fly, therefore warn only. */
1420         if (workarounds & SBP2_WORKAROUND_128K_MAX_TRANS &&
1421             (sbp2_max_sectors * 512) > (128 * 1024))
1422                 SBP2_INFO("Node " NODE_BUS_FMT ": Bridge only supports 128KB "
1423                           "max transfer size. WARNING: Current max_sectors "
1424                           "setting is larger than 128KB (%d sectors)",
1425                           NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid),
1426                           sbp2_max_sectors);
1427
1428         /* If this is a logical unit directory entry, process the parent
1429          * to get the values. */
1430         if (ud->flags & UNIT_DIRECTORY_LUN_DIRECTORY) {
1431                 struct unit_directory *parent_ud = container_of(
1432                         ud->device.parent, struct unit_directory, device);
1433                 sbp2_parse_unit_directory(lu, parent_ud);
1434         } else {
1435                 lu->management_agent_addr = management_agent_addr;
1436                 lu->workarounds = workarounds;
1437                 if (ud->flags & UNIT_DIRECTORY_HAS_LUN)
1438                         lu->lun = ORB_SET_LUN(ud->lun);
1439         }
1440 }
1441
1442 #define SBP2_PAYLOAD_TO_BYTES(p) (1 << ((p) + 2))
1443
1444 /*
1445  * This function is called in order to determine the max speed and packet
1446  * size we can use in our ORBs. Note, that we (the driver and host) only
1447  * initiate the transaction. The SBP-2 device actually transfers the data
1448  * (by reading from the DMA area we tell it). This means that the SBP-2
1449  * device decides the actual maximum data it can transfer. We just tell it
1450  * the speed that it needs to use, and the max_rec the host supports, and
1451  * it takes care of the rest.
1452  */
1453 static int sbp2_max_speed_and_size(struct sbp2_lu *lu)
1454 {
1455         struct sbp2_fwhost_info *hi = lu->hi;
1456         u8 payload;
1457
1458         lu->speed_code = hi->host->speed[NODEID_TO_NODE(lu->ne->nodeid)];
1459
1460         if (lu->speed_code > sbp2_max_speed) {
1461                 lu->speed_code = sbp2_max_speed;
1462                 SBP2_INFO("Reducing speed to %s",
1463                           hpsb_speedto_str[sbp2_max_speed]);
1464         }
1465
1466         /* Payload size is the lesser of what our speed supports and what
1467          * our host supports.  */
1468         payload = min(sbp2_speedto_max_payload[lu->speed_code],
1469                       (u8) (hi->host->csr.max_rec - 1));
1470
1471         /* If physical DMA is off, work around limitation in ohci1394:
1472          * packet size must not exceed PAGE_SIZE */
1473         if (lu->ne->host->low_addr_space < (1ULL << 32))
1474                 while (SBP2_PAYLOAD_TO_BYTES(payload) + 24 > PAGE_SIZE &&
1475                        payload)
1476                         payload--;
1477
1478         SBP2_INFO("Node " NODE_BUS_FMT ": Max speed [%s] - Max payload [%u]",
1479                   NODE_BUS_ARGS(hi->host, lu->ne->nodeid),
1480                   hpsb_speedto_str[lu->speed_code],
1481                   SBP2_PAYLOAD_TO_BYTES(payload));
1482
1483         lu->max_payload_size = payload;
1484         return 0;
1485 }
1486
1487 static int sbp2_agent_reset(struct sbp2_lu *lu, int wait)
1488 {
1489         quadlet_t data;
1490         u64 addr;
1491         int retval;
1492         unsigned long flags;
1493
1494         /* flush lu->protocol_work */
1495         if (wait)
1496                 flush_scheduled_work();
1497
1498         data = ntohl(SBP2_AGENT_RESET_DATA);
1499         addr = lu->command_block_agent_addr + SBP2_AGENT_RESET_OFFSET;
1500
1501         if (wait)
1502                 retval = hpsb_node_write(lu->ne, addr, &data, 4);
1503         else
1504                 retval = sbp2util_node_write_no_wait(lu->ne, addr, &data, 4);
1505
1506         if (retval < 0) {
1507                 SBP2_ERR("hpsb_node_write failed.\n");
1508                 return -EIO;
1509         }
1510
1511         /* make sure that the ORB_POINTER is written on next command */
1512         spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1513         lu->last_orb = NULL;
1514         spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1515
1516         return 0;
1517 }
1518
1519 static int sbp2_prep_command_orb_sg(struct sbp2_command_orb *orb,
1520                                     struct sbp2_fwhost_info *hi,
1521                                     struct sbp2_command_info *cmd,
1522                                     unsigned int sg_count,
1523                                     struct scatterlist *sg,
1524                                     u32 orb_direction,
1525                                     enum dma_data_direction dma_dir)
1526 {
1527         struct device *dmadev = hi->host->device.parent;
1528         struct sbp2_unrestricted_page_table *pt;
1529         int i, n;
1530
1531         n = dma_map_sg(dmadev, sg, sg_count, dma_dir);
1532         if (n == 0)
1533                 return -ENOMEM;
1534
1535         orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id);
1536         orb->misc |= ORB_SET_DIRECTION(orb_direction);
1537
1538         /* special case if only one element (and less than 64KB in size) */
1539         if (n == 1) {
1540                 orb->misc |= ORB_SET_DATA_SIZE(sg_dma_len(sg));
1541                 orb->data_descriptor_lo = sg_dma_address(sg);
1542         } else {
1543                 pt = &cmd->scatter_gather_element[0];
1544
1545                 dma_sync_single_for_cpu(dmadev, cmd->sge_dma,
1546                                         sizeof(cmd->scatter_gather_element),
1547                                         DMA_TO_DEVICE);
1548
1549                 for_each_sg(sg, sg, n, i) {
1550                         pt[i].high = cpu_to_be32(sg_dma_len(sg) << 16);
1551                         pt[i].low = cpu_to_be32(sg_dma_address(sg));
1552                 }
1553
1554                 orb->misc |= ORB_SET_PAGE_TABLE_PRESENT(0x1) |
1555                              ORB_SET_DATA_SIZE(n);
1556                 orb->data_descriptor_lo = cmd->sge_dma;
1557
1558                 dma_sync_single_for_device(dmadev, cmd->sge_dma,
1559                                            sizeof(cmd->scatter_gather_element),
1560                                            DMA_TO_DEVICE);
1561         }
1562         return 0;
1563 }
1564
1565 static int sbp2_create_command_orb(struct sbp2_lu *lu,
1566                                    struct sbp2_command_info *cmd,
1567                                    struct scsi_cmnd *SCpnt)
1568 {
1569         struct device *dmadev = lu->hi->host->device.parent;
1570         struct sbp2_command_orb *orb = &cmd->command_orb;
1571         unsigned int scsi_request_bufflen = scsi_bufflen(SCpnt);
1572         enum dma_data_direction dma_dir = SCpnt->sc_data_direction;
1573         u32 orb_direction;
1574         int ret;
1575
1576         dma_sync_single_for_cpu(dmadev, cmd->command_orb_dma,
1577                                 sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
1578         /*
1579          * Set-up our command ORB.
1580          *
1581          * NOTE: We're doing unrestricted page tables (s/g), as this is
1582          * best performance (at least with the devices I have). This means
1583          * that data_size becomes the number of s/g elements, and
1584          * page_size should be zero (for unrestricted).
1585          */
1586         orb->next_ORB_hi = ORB_SET_NULL_PTR(1);
1587         orb->next_ORB_lo = 0x0;
1588         orb->misc = ORB_SET_MAX_PAYLOAD(lu->max_payload_size);
1589         orb->misc |= ORB_SET_SPEED(lu->speed_code);
1590         orb->misc |= ORB_SET_NOTIFY(1);
1591
1592         if (dma_dir == DMA_NONE)
1593                 orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
1594         else if (dma_dir == DMA_TO_DEVICE && scsi_request_bufflen)
1595                 orb_direction = ORB_DIRECTION_WRITE_TO_MEDIA;
1596         else if (dma_dir == DMA_FROM_DEVICE && scsi_request_bufflen)
1597                 orb_direction = ORB_DIRECTION_READ_FROM_MEDIA;
1598         else {
1599                 SBP2_INFO("Falling back to DMA_NONE");
1600                 orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
1601         }
1602
1603         /* set up our page table stuff */
1604         if (orb_direction == ORB_DIRECTION_NO_DATA_TRANSFER) {
1605                 orb->data_descriptor_hi = 0x0;
1606                 orb->data_descriptor_lo = 0x0;
1607                 orb->misc |= ORB_SET_DIRECTION(1);
1608                 ret = 0;
1609         } else {
1610                 ret = sbp2_prep_command_orb_sg(orb, lu->hi, cmd,
1611                                                scsi_sg_count(SCpnt),
1612                                                scsi_sglist(SCpnt),
1613                                                orb_direction, dma_dir);
1614         }
1615         sbp2util_cpu_to_be32_buffer(orb, sizeof(*orb));
1616
1617         memset(orb->cdb, 0, sizeof(orb->cdb));
1618         memcpy(orb->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1619
1620         dma_sync_single_for_device(dmadev, cmd->command_orb_dma,
1621                         sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
1622         return ret;
1623 }
1624
1625 static void sbp2_link_orb_command(struct sbp2_lu *lu,
1626                                   struct sbp2_command_info *cmd)
1627 {
1628         struct sbp2_fwhost_info *hi = lu->hi;
1629         struct sbp2_command_orb *last_orb;
1630         dma_addr_t last_orb_dma;
1631         u64 addr = lu->command_block_agent_addr;
1632         quadlet_t data[2];
1633         size_t length;
1634         unsigned long flags;
1635
1636         /* check to see if there are any previous orbs to use */
1637         spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1638         last_orb = lu->last_orb;
1639         last_orb_dma = lu->last_orb_dma;
1640         if (!last_orb) {
1641                 /*
1642                  * last_orb == NULL means: We know that the target's fetch agent
1643                  * is not active right now.
1644                  */
1645                 addr += SBP2_ORB_POINTER_OFFSET;
1646                 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1647                 data[1] = cmd->command_orb_dma;
1648                 sbp2util_cpu_to_be32_buffer(data, 8);
1649                 length = 8;
1650         } else {
1651                 /*
1652                  * last_orb != NULL means: We know that the target's fetch agent
1653                  * is (very probably) not dead or in reset state right now.
1654                  * We have an ORB already sent that we can append a new one to.
1655                  * The target's fetch agent may or may not have read this
1656                  * previous ORB yet.
1657                  */
1658                 dma_sync_single_for_cpu(hi->host->device.parent, last_orb_dma,
1659                                         sizeof(struct sbp2_command_orb),
1660                                         DMA_TO_DEVICE);
1661                 last_orb->next_ORB_lo = cpu_to_be32(cmd->command_orb_dma);
1662                 wmb();
1663                 /* Tells hardware that this pointer is valid */
1664                 last_orb->next_ORB_hi = 0;
1665                 dma_sync_single_for_device(hi->host->device.parent,
1666                                            last_orb_dma,
1667                                            sizeof(struct sbp2_command_orb),
1668                                            DMA_TO_DEVICE);
1669                 addr += SBP2_DOORBELL_OFFSET;
1670                 data[0] = 0;
1671                 length = 4;
1672         }
1673         lu->last_orb = &cmd->command_orb;
1674         lu->last_orb_dma = cmd->command_orb_dma;
1675         spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1676
1677         if (sbp2util_node_write_no_wait(lu->ne, addr, data, length)) {
1678                 /*
1679                  * sbp2util_node_write_no_wait failed. We certainly ran out
1680                  * of transaction labels, perhaps just because there were no
1681                  * context switches which gave khpsbpkt a chance to collect
1682                  * free tlabels. Try again in non-atomic context. If necessary,
1683                  * the workqueue job will sleep to guaranteedly get a tlabel.
1684                  * We do not accept new commands until the job is over.
1685                  */
1686                 scsi_block_requests(lu->shost);
1687                 PREPARE_WORK(&lu->protocol_work,
1688                              last_orb ? sbp2util_write_doorbell:
1689                                         sbp2util_write_orb_pointer);
1690                 schedule_work(&lu->protocol_work);
1691         }
1692 }
1693
1694 static int sbp2_send_command(struct sbp2_lu *lu, struct scsi_cmnd *SCpnt,
1695                              void (*done)(struct scsi_cmnd *))
1696 {
1697         struct sbp2_command_info *cmd;
1698
1699         cmd = sbp2util_allocate_command_orb(lu, SCpnt, done);
1700         if (!cmd)
1701                 return -EIO;
1702
1703         if (sbp2_create_command_orb(lu, cmd, SCpnt))
1704                 return -ENOMEM;
1705
1706         sbp2_link_orb_command(lu, cmd);
1707         return 0;
1708 }
1709
1710 /*
1711  * Translates SBP-2 status into SCSI sense data for check conditions
1712  */
1713 static unsigned int sbp2_status_to_sense_data(unchar *sbp2_status,
1714                                               unchar *sense_data)
1715 {
1716         /* OK, it's pretty ugly... ;-) */
1717         sense_data[0] = 0x70;
1718         sense_data[1] = 0x0;
1719         sense_data[2] = sbp2_status[9];
1720         sense_data[3] = sbp2_status[12];
1721         sense_data[4] = sbp2_status[13];
1722         sense_data[5] = sbp2_status[14];
1723         sense_data[6] = sbp2_status[15];
1724         sense_data[7] = 10;
1725         sense_data[8] = sbp2_status[16];
1726         sense_data[9] = sbp2_status[17];
1727         sense_data[10] = sbp2_status[18];
1728         sense_data[11] = sbp2_status[19];
1729         sense_data[12] = sbp2_status[10];
1730         sense_data[13] = sbp2_status[11];
1731         sense_data[14] = sbp2_status[20];
1732         sense_data[15] = sbp2_status[21];
1733
1734         return sbp2_status[8] & 0x3f;
1735 }
1736
1737 static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid,
1738                                     int destid, quadlet_t *data, u64 addr,
1739                                     size_t length, u16 fl)
1740 {
1741         struct sbp2_fwhost_info *hi;
1742         struct sbp2_lu *lu = NULL, *lu_tmp;
1743         struct scsi_cmnd *SCpnt = NULL;
1744         struct sbp2_status_block *sb;
1745         u32 scsi_status = SBP2_SCSI_STATUS_GOOD;
1746         struct sbp2_command_info *cmd;
1747         unsigned long flags;
1748
1749         if (unlikely(length < 8 || length > sizeof(struct sbp2_status_block))) {
1750                 SBP2_ERR("Wrong size of status block");
1751                 return RCODE_ADDRESS_ERROR;
1752         }
1753         if (unlikely(!host)) {
1754                 SBP2_ERR("host is NULL - this is bad!");
1755                 return RCODE_ADDRESS_ERROR;
1756         }
1757         hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
1758         if (unlikely(!hi)) {
1759                 SBP2_ERR("host info is NULL - this is bad!");
1760                 return RCODE_ADDRESS_ERROR;
1761         }
1762
1763         /* Find the unit which wrote the status. */
1764         read_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
1765         list_for_each_entry(lu_tmp, &hi->logical_units, lu_list) {
1766                 if (lu_tmp->ne->nodeid == nodeid &&
1767                     lu_tmp->status_fifo_addr == addr) {
1768                         lu = lu_tmp;
1769                         break;
1770                 }
1771         }
1772         read_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
1773
1774         if (unlikely(!lu)) {
1775                 SBP2_ERR("lu is NULL - device is gone?");
1776                 return RCODE_ADDRESS_ERROR;
1777         }
1778
1779         /* Put response into lu status fifo buffer. The first two bytes
1780          * come in big endian bit order. Often the target writes only a
1781          * truncated status block, minimally the first two quadlets. The rest
1782          * is implied to be zeros. */
1783         sb = &lu->status_block;
1784         memset(sb->command_set_dependent, 0, sizeof(sb->command_set_dependent));
1785         memcpy(sb, data, length);
1786         sbp2util_be32_to_cpu_buffer(sb, 8);
1787
1788         /* Ignore unsolicited status. Handle command ORB status. */
1789         if (unlikely(STATUS_GET_SRC(sb->ORB_offset_hi_misc) == 2))
1790                 cmd = NULL;
1791         else
1792                 cmd = sbp2util_find_command_for_orb(lu, sb->ORB_offset_lo);
1793         if (cmd) {
1794                 /* Grab SCSI command pointers and check status. */
1795                 /*
1796                  * FIXME: If the src field in the status is 1, the ORB DMA must
1797                  * not be reused until status for a subsequent ORB is received.
1798                  */
1799                 SCpnt = cmd->Current_SCpnt;
1800                 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1801                 sbp2util_mark_command_completed(lu, cmd);
1802                 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1803
1804                 if (SCpnt) {
1805                         u32 h = sb->ORB_offset_hi_misc;
1806                         u32 r = STATUS_GET_RESP(h);
1807
1808                         if (r != RESP_STATUS_REQUEST_COMPLETE) {
1809                                 SBP2_INFO("resp 0x%x, sbp_status 0x%x",
1810                                           r, STATUS_GET_SBP_STATUS(h));
1811                                 scsi_status =
1812                                         r == RESP_STATUS_TRANSPORT_FAILURE ?
1813                                         SBP2_SCSI_STATUS_BUSY :
1814                                         SBP2_SCSI_STATUS_COMMAND_TERMINATED;
1815                         }
1816
1817                         if (STATUS_GET_LEN(h) > 1)
1818                                 scsi_status = sbp2_status_to_sense_data(
1819                                         (unchar *)sb, SCpnt->sense_buffer);
1820
1821                         if (STATUS_TEST_DEAD(h))
1822                                 sbp2_agent_reset(lu, 0);
1823                 }
1824
1825                 /* Check here to see if there are no commands in-use. If there
1826                  * are none, we know that the fetch agent left the active state
1827                  * _and_ that we did not reactivate it yet. Therefore clear
1828                  * last_orb so that next time we write directly to the
1829                  * ORB_POINTER register. That way the fetch agent does not need
1830                  * to refetch the next_ORB. */
1831                 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1832                 if (list_empty(&lu->cmd_orb_inuse))
1833                         lu->last_orb = NULL;
1834                 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1835
1836         } else {
1837                 /* It's probably status after a management request. */
1838                 if ((sb->ORB_offset_lo == lu->reconnect_orb_dma) ||
1839                     (sb->ORB_offset_lo == lu->login_orb_dma) ||
1840                     (sb->ORB_offset_lo == lu->query_logins_orb_dma) ||
1841                     (sb->ORB_offset_lo == lu->logout_orb_dma)) {
1842                         lu->access_complete = 1;
1843                         wake_up_interruptible(&sbp2_access_wq);
1844                 }
1845         }
1846
1847         if (SCpnt)
1848                 sbp2scsi_complete_command(lu, scsi_status, SCpnt,
1849                                           cmd->Current_done);
1850         return RCODE_COMPLETE;
1851 }
1852
1853 /**************************************
1854  * SCSI interface related section
1855  **************************************/
1856
1857 static int sbp2scsi_queuecommand(struct scsi_cmnd *SCpnt,
1858                                  void (*done)(struct scsi_cmnd *))
1859 {
1860         struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
1861         struct sbp2_fwhost_info *hi;
1862         int result = DID_NO_CONNECT << 16;
1863
1864         if (unlikely(!sbp2util_node_is_available(lu)))
1865                 goto done;
1866
1867         hi = lu->hi;
1868
1869         if (unlikely(!hi)) {
1870                 SBP2_ERR("sbp2_fwhost_info is NULL - this is bad!");
1871                 goto done;
1872         }
1873
1874         /* Multiple units are currently represented to the SCSI core as separate
1875          * targets, not as one target with multiple LUs. Therefore return
1876          * selection time-out to any IO directed at non-zero LUNs. */
1877         if (unlikely(SCpnt->device->lun))
1878                 goto done;
1879
1880         if (unlikely(!hpsb_node_entry_valid(lu->ne))) {
1881                 SBP2_ERR("Bus reset in progress - rejecting command");
1882                 result = DID_BUS_BUSY << 16;
1883                 goto done;
1884         }
1885
1886         /* Bidirectional commands are not yet implemented,
1887          * and unknown transfer direction not handled. */
1888         if (unlikely(SCpnt->sc_data_direction == DMA_BIDIRECTIONAL)) {
1889                 SBP2_ERR("Cannot handle DMA_BIDIRECTIONAL - rejecting command");
1890                 result = DID_ERROR << 16;
1891                 goto done;
1892         }
1893
1894         if (sbp2_send_command(lu, SCpnt, done)) {
1895                 SBP2_ERR("Error sending SCSI command");
1896                 sbp2scsi_complete_command(lu,
1897                                           SBP2_SCSI_STATUS_SELECTION_TIMEOUT,
1898                                           SCpnt, done);
1899         }
1900         return 0;
1901
1902 done:
1903         SCpnt->result = result;
1904         done(SCpnt);
1905         return 0;
1906 }
1907
1908 static void sbp2scsi_complete_all_commands(struct sbp2_lu *lu, u32 status)
1909 {
1910         struct list_head *lh;
1911         struct sbp2_command_info *cmd;
1912         unsigned long flags;
1913
1914         spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1915         while (!list_empty(&lu->cmd_orb_inuse)) {
1916                 lh = lu->cmd_orb_inuse.next;
1917                 cmd = list_entry(lh, struct sbp2_command_info, list);
1918                 sbp2util_mark_command_completed(lu, cmd);
1919                 if (cmd->Current_SCpnt) {
1920                         cmd->Current_SCpnt->result = status << 16;
1921                         cmd->Current_done(cmd->Current_SCpnt);
1922                 }
1923         }
1924         spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1925
1926         return;
1927 }
1928
1929 /*
1930  * Complete a regular SCSI command. Can be called in atomic context.
1931  */
1932 static void sbp2scsi_complete_command(struct sbp2_lu *lu, u32 scsi_status,
1933                                       struct scsi_cmnd *SCpnt,
1934                                       void (*done)(struct scsi_cmnd *))
1935 {
1936         if (!SCpnt) {
1937                 SBP2_ERR("SCpnt is NULL");
1938                 return;
1939         }
1940
1941         switch (scsi_status) {
1942         case SBP2_SCSI_STATUS_GOOD:
1943                 SCpnt->result = DID_OK << 16;
1944                 break;
1945
1946         case SBP2_SCSI_STATUS_BUSY:
1947                 SBP2_ERR("SBP2_SCSI_STATUS_BUSY");
1948                 SCpnt->result = DID_BUS_BUSY << 16;
1949                 break;
1950
1951         case SBP2_SCSI_STATUS_CHECK_CONDITION:
1952                 SCpnt->result = CHECK_CONDITION << 1 | DID_OK << 16;
1953                 break;
1954
1955         case SBP2_SCSI_STATUS_SELECTION_TIMEOUT:
1956                 SBP2_ERR("SBP2_SCSI_STATUS_SELECTION_TIMEOUT");
1957                 SCpnt->result = DID_NO_CONNECT << 16;
1958                 scsi_print_command(SCpnt);
1959                 break;
1960
1961         case SBP2_SCSI_STATUS_CONDITION_MET:
1962         case SBP2_SCSI_STATUS_RESERVATION_CONFLICT:
1963         case SBP2_SCSI_STATUS_COMMAND_TERMINATED:
1964                 SBP2_ERR("Bad SCSI status = %x", scsi_status);
1965                 SCpnt->result = DID_ERROR << 16;
1966                 scsi_print_command(SCpnt);
1967                 break;
1968
1969         default:
1970                 SBP2_ERR("Unsupported SCSI status = %x", scsi_status);
1971                 SCpnt->result = DID_ERROR << 16;
1972         }
1973
1974         /* If a bus reset is in progress and there was an error, complete
1975          * the command as busy so that it will get retried. */
1976         if (!hpsb_node_entry_valid(lu->ne)
1977             && (scsi_status != SBP2_SCSI_STATUS_GOOD)) {
1978                 SBP2_ERR("Completing command with busy (bus reset)");
1979                 SCpnt->result = DID_BUS_BUSY << 16;
1980         }
1981
1982         /* Tell the SCSI stack that we're done with this command. */
1983         done(SCpnt);
1984 }
1985
1986 static int sbp2scsi_slave_alloc(struct scsi_device *sdev)
1987 {
1988         struct sbp2_lu *lu = (struct sbp2_lu *)sdev->host->hostdata[0];
1989
1990         if (sdev->lun != 0 || sdev->id != lu->ud->id || sdev->channel != 0)
1991                 return -ENODEV;
1992
1993         lu->sdev = sdev;
1994         sdev->allow_restart = 1;
1995
1996         /* SBP-2 requires quadlet alignment of the data buffers. */
1997         blk_queue_update_dma_alignment(sdev->request_queue, 4 - 1);
1998
1999         if (lu->workarounds & SBP2_WORKAROUND_INQUIRY_36)
2000                 sdev->inquiry_len = 36;
2001         return 0;
2002 }
2003
2004 static int sbp2scsi_slave_configure(struct scsi_device *sdev)
2005 {
2006         struct sbp2_lu *lu = (struct sbp2_lu *)sdev->host->hostdata[0];
2007
2008         sdev->use_10_for_rw = 1;
2009
2010         if (sbp2_exclusive_login)
2011                 sdev->manage_start_stop = 1;
2012         if (sdev->type == TYPE_ROM)
2013                 sdev->use_10_for_ms = 1;
2014         if (sdev->type == TYPE_DISK &&
2015             lu->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
2016                 sdev->skip_ms_page_8 = 1;
2017         if (lu->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
2018                 sdev->fix_capacity = 1;
2019         if (lu->workarounds & SBP2_WORKAROUND_POWER_CONDITION)
2020                 sdev->start_stop_pwr_cond = 1;
2021         if (lu->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
2022                 blk_queue_max_hw_sectors(sdev->request_queue, 128 * 1024 / 512);
2023
2024         blk_queue_max_segment_size(sdev->request_queue, SBP2_MAX_SEG_SIZE);
2025         return 0;
2026 }
2027
2028 static void sbp2scsi_slave_destroy(struct scsi_device *sdev)
2029 {
2030         ((struct sbp2_lu *)sdev->host->hostdata[0])->sdev = NULL;
2031         return;
2032 }
2033
2034 /*
2035  * Called by scsi stack when something has really gone wrong.
2036  * Usually called when a command has timed-out for some reason.
2037  */
2038 static int sbp2scsi_abort(struct scsi_cmnd *SCpnt)
2039 {
2040         struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
2041         struct sbp2_command_info *cmd;
2042         unsigned long flags;
2043
2044         SBP2_INFO("aborting sbp2 command");
2045         scsi_print_command(SCpnt);
2046
2047         if (sbp2util_node_is_available(lu)) {
2048                 sbp2_agent_reset(lu, 1);
2049
2050                 /* Return a matching command structure to the free pool. */
2051                 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
2052                 cmd = sbp2util_find_command_for_SCpnt(lu, SCpnt);
2053                 if (cmd) {
2054                         sbp2util_mark_command_completed(lu, cmd);
2055                         if (cmd->Current_SCpnt) {
2056                                 cmd->Current_SCpnt->result = DID_ABORT << 16;
2057                                 cmd->Current_done(cmd->Current_SCpnt);
2058                         }
2059                 }
2060                 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
2061
2062                 sbp2scsi_complete_all_commands(lu, DID_BUS_BUSY);
2063         }
2064
2065         return SUCCESS;
2066 }
2067
2068 /*
2069  * Called by scsi stack when something has really gone wrong.
2070  */
2071 static int sbp2scsi_reset(struct scsi_cmnd *SCpnt)
2072 {
2073         struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
2074
2075         SBP2_INFO("reset requested");
2076
2077         if (sbp2util_node_is_available(lu)) {
2078                 SBP2_INFO("generating sbp2 fetch agent reset");
2079                 sbp2_agent_reset(lu, 1);
2080         }
2081
2082         return SUCCESS;
2083 }
2084
2085 static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev,
2086                                            struct device_attribute *attr,
2087                                            char *buf)
2088 {
2089         struct scsi_device *sdev;
2090         struct sbp2_lu *lu;
2091
2092         if (!(sdev = to_scsi_device(dev)))
2093                 return 0;
2094
2095         if (!(lu = (struct sbp2_lu *)sdev->host->hostdata[0]))
2096                 return 0;
2097
2098         if (sbp2_long_sysfs_ieee1394_id)
2099                 return sprintf(buf, "%016Lx:%06x:%04x\n",
2100                                 (unsigned long long)lu->ne->guid,
2101                                 lu->ud->directory_id, ORB_SET_LUN(lu->lun));
2102         else
2103                 return sprintf(buf, "%016Lx:%d:%d\n",
2104                                 (unsigned long long)lu->ne->guid,
2105                                 lu->ud->id, ORB_SET_LUN(lu->lun));
2106 }
2107
2108 MODULE_AUTHOR("Ben Collins <bcollins@debian.org>");
2109 MODULE_DESCRIPTION("IEEE-1394 SBP-2 protocol driver");
2110 MODULE_SUPPORTED_DEVICE(SBP2_DEVICE_NAME);
2111 MODULE_LICENSE("GPL");
2112
2113 static int sbp2_module_init(void)
2114 {
2115         int ret;
2116
2117         if (sbp2_serialize_io) {
2118                 sbp2_shost_template.can_queue = 1;
2119                 sbp2_shost_template.cmd_per_lun = 1;
2120         }
2121
2122         sbp2_shost_template.max_sectors = sbp2_max_sectors;
2123
2124         hpsb_register_highlevel(&sbp2_highlevel);
2125         ret = hpsb_register_protocol(&sbp2_driver);
2126         if (ret) {
2127                 SBP2_ERR("Failed to register protocol");
2128                 hpsb_unregister_highlevel(&sbp2_highlevel);
2129                 return ret;
2130         }
2131         return 0;
2132 }
2133
2134 static void __exit sbp2_module_exit(void)
2135 {
2136         hpsb_unregister_protocol(&sbp2_driver);
2137         hpsb_unregister_highlevel(&sbp2_highlevel);
2138 }
2139
2140 module_init(sbp2_module_init);
2141 module_exit(sbp2_module_exit);