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