aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/ieee1394/sbp2.c
diff options
context:
space:
mode:
authorStefan Richter <stefanr@s5r6.in-berlin.de>2010-10-09 18:12:20 -0400
committerStefan Richter <stefanr@s5r6.in-berlin.de>2010-10-11 08:48:03 -0400
commit66fa12c571d35e3cd62574c65f1785a460105397 (patch)
treeb4f8de3d5ca827d2b134ed628628a7bff46967ca /drivers/ieee1394/sbp2.c
parent1ef5b816c0eaf84f91106cfc0893069c49e86113 (diff)
ieee1394: remove the old IEEE 1394 driver stack
The drivers - ohci1394 (controller driver) - ieee1394 (core) - dv1394, raw1394, video1394 (userspace ABI) - eth1394, sbp2 (protocol drivers) are replaced by - firewire-ohci (controller driver) - firewire-core (core and userspace ABI) - firewire-net, firewire-sbp2 (protocol drivers) which are more featureful, better performing, and more secure than the older drivers; all with a smaller and more modern code base. The driver firedtv in drivers/media/dvb/firewire/ contains backends to both ieee1394 and firewire-core. Its ieee1394 backend code can be removed in an independent commit; firedtv as-is builds and works fine without ieee1394. The driver pcilynx (an incomplete controller driver) is deleted without replacement since PCILynx cards are extremely rare. Owners of these cards use them with the stand-alone bus sniffer driver nosy instead. The drivers nosy and init_ohci1394_dma which do not interact with either of the two IEEE 1394 stacks are not affected by the ieee1394 subsystem removal. There are still some issues with the newer firewire subsystem compared to the older one: - The rare and quirky controllers ALi M52xx, Apple UniNorth v1, NVIDIA NForce2 are even less well supported by firewire-ohci than by ohci1394. I am looking into the M52xx issue. - The experimental firewire-net is reportedly less stable than its experimental cousin eth1394. - Audio playback of a certain group of audio devices (ones based on DICE chipset with EAP; supported by prerelease FFADO code) does not work yet. This issue is still under investigation. - There were some ieee1394 based out-of-the-mainline drivers. Of them, only lisight, an audio driver for iSight webcams, seems still useful. Work is underway to reimplement it on top of firewire-core. All these remainig issues are minor; they should not stand in the way of overall better user experience of IEEE 1394 on Linux, together with a reduction in support efforts and maintenance burden. The coexistence of two IEEE 1394 kernel driver stacks in the mainline since 2.6.22 shall end now, as announced earlier this year. Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Diffstat (limited to 'drivers/ieee1394/sbp2.c')
-rw-r--r--drivers/ieee1394/sbp2.c2138
1 files changed, 0 insertions, 2138 deletions
diff --git a/drivers/ieee1394/sbp2.c b/drivers/ieee1394/sbp2.c
deleted file mode 100644
index d6e251a300ce..000000000000
--- a/drivers/ieee1394/sbp2.c
+++ /dev/null
@@ -1,2138 +0,0 @@
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 */
115static int sbp2_max_speed = IEEE1394_SPEED_MAX;
116module_param_named(max_speed, sbp2_max_speed, int, 0644);
117MODULE_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 */
124static int sbp2_serialize_io = 1;
125module_param_named(serialize_io, sbp2_serialize_io, bool, 0444);
126MODULE_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 */
141static int sbp2_max_sectors;
142module_param_named(max_sectors, sbp2_max_sectors, int, 0444);
143MODULE_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 */
159static int sbp2_exclusive_login = 1;
160module_param_named(exclusive_login, sbp2_exclusive_login, bool, 0644);
161MODULE_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 */
198static int sbp2_default_workarounds;
199module_param_named(workarounds, sbp2_default_workarounds, int, 0644);
200MODULE_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 */
227static int sbp2_long_sysfs_ieee1394_id;
228module_param_named(long_ieee1394_id, sbp2_long_sysfs_ieee1394_id, bool, 0644);
229MODULE_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 */
239static void sbp2scsi_complete_all_commands(struct sbp2_lu *, u32);
240static void sbp2scsi_complete_command(struct sbp2_lu *, u32, struct scsi_cmnd *,
241 void (*)(struct scsi_cmnd *));
242static struct sbp2_lu *sbp2_alloc_device(struct unit_directory *);
243static int sbp2_start_device(struct sbp2_lu *);
244static void sbp2_remove_device(struct sbp2_lu *);
245static int sbp2_login_device(struct sbp2_lu *);
246static int sbp2_reconnect_device(struct sbp2_lu *);
247static int sbp2_logout_device(struct sbp2_lu *);
248static void sbp2_host_reset(struct hpsb_host *);
249static int sbp2_handle_status_write(struct hpsb_host *, int, int, quadlet_t *,
250 u64, size_t, u16);
251static int sbp2_agent_reset(struct sbp2_lu *, int);
252static void sbp2_parse_unit_directory(struct sbp2_lu *,
253 struct unit_directory *);
254static int sbp2_set_busy_timeout(struct sbp2_lu *);
255static int sbp2_max_speed_and_size(struct sbp2_lu *);
256
257
258static const u8 sbp2_speedto_max_payload[] = { 0x7, 0x8, 0x9, 0xa, 0xa, 0xa };
259
260static DEFINE_RWLOCK(sbp2_hi_logical_units_lock);
261
262static struct hpsb_highlevel sbp2_highlevel = {
263 .name = SBP2_DEVICE_NAME,
264 .host_reset = sbp2_host_reset,
265};
266
267static const struct hpsb_address_ops sbp2_ops = {
268 .write = sbp2_handle_status_write
269};
270
271#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
272static int sbp2_handle_physdma_write(struct hpsb_host *, int, int, quadlet_t *,
273 u64, size_t, u16);
274static int sbp2_handle_physdma_read(struct hpsb_host *, int, quadlet_t *, u64,
275 size_t, u16);
276
277static 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 */
287static 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};
294MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
295
296static int sbp2_probe(struct device *);
297static int sbp2_remove(struct device *);
298static int sbp2_update(struct unit_directory *);
299
300static 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 */
314static int sbp2scsi_queuecommand(struct scsi_cmnd *,
315 void (*)(struct scsi_cmnd *));
316static int sbp2scsi_abort(struct scsi_cmnd *);
317static int sbp2scsi_reset(struct scsi_cmnd *);
318static int sbp2scsi_slave_alloc(struct scsi_device *);
319static int sbp2scsi_slave_configure(struct scsi_device *);
320static void sbp2scsi_slave_destroy(struct scsi_device *);
321static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *,
322 struct device_attribute *, char *);
323
324static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
325
326static struct device_attribute *sbp2_sysfs_sdev_attrs[] = {
327 &dev_attr_ieee1394_id,
328 NULL
329};
330
331static 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 */
359static 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 */
436static 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 */
447static 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
460static 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 */
466static 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
476static 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 */
486static 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
504static 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
522static 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
533static 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
540static 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
570failed_sge:
571 dma_unmap_single(dmadev, cmd->command_orb_dma,
572 sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
573failed_orb:
574 kfree(cmd);
575failed_alloc:
576 return -ENOMEM;
577}
578
579static 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 */
607static 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 */
630static 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
642static 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 */
669static 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 */
683static 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
692static 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
712static 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
745static 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
791static 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
891failed_alloc:
892 sbp2_remove_device(lu);
893 return NULL;
894}
895
896static 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
917static 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
990alloc_fail:
991 SBP2_ERR("Could not allocate memory for lu");
992 sbp2_remove_device(lu);
993 return -ENOMEM;
994}
995
996static 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);
1056no_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 */
1065static 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 */
1077static 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
1090static 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
1162static 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
1237static 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
1278static 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 */
1337static 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
1347static 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 firmware_revision, model;
1354 unsigned workarounds;
1355 int i;
1356
1357 management_agent_addr = 0;
1358 firmware_revision = SBP2_ROM_VALUE_MISSING;
1359 model = ud->flags & UNIT_DIRECTORY_MODEL_ID ?
1360 ud->model_id : SBP2_ROM_VALUE_MISSING;
1361
1362 csr1212_for_each_dir_entry(ud->ne->csr, kv, ud->ud_kv, dentry) {
1363 switch (kv->key.id) {
1364 case CSR1212_KV_ID_DEPENDENT_INFO:
1365 if (kv->key.type == CSR1212_KV_TYPE_CSR_OFFSET)
1366 management_agent_addr =
1367 CSR1212_REGISTER_SPACE_BASE +
1368 (kv->value.csr_offset << 2);
1369
1370 else if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE)
1371 lu->lun = ORB_SET_LUN(kv->value.immediate);
1372 break;
1373
1374
1375 case SBP2_FIRMWARE_REVISION_KEY:
1376 firmware_revision = kv->value.immediate;
1377 break;
1378
1379 default:
1380 /* FIXME: Check for SBP2_UNIT_CHARACTERISTICS_KEY
1381 * mgt_ORB_timeout and ORB_size, SBP-2 clause 7.4.8. */
1382
1383 /* FIXME: Check for SBP2_DEVICE_TYPE_AND_LUN_KEY.
1384 * Its "ordered" bit has consequences for command ORB
1385 * list handling. See SBP-2 clauses 4.6, 7.4.11, 10.2 */
1386 break;
1387 }
1388 }
1389
1390 workarounds = sbp2_default_workarounds;
1391
1392 if (!(workarounds & SBP2_WORKAROUND_OVERRIDE))
1393 for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
1394 if (sbp2_workarounds_table[i].firmware_revision !=
1395 SBP2_ROM_VALUE_WILDCARD &&
1396 sbp2_workarounds_table[i].firmware_revision !=
1397 (firmware_revision & 0xffff00))
1398 continue;
1399 if (sbp2_workarounds_table[i].model !=
1400 SBP2_ROM_VALUE_WILDCARD &&
1401 sbp2_workarounds_table[i].model != model)
1402 continue;
1403 workarounds |= sbp2_workarounds_table[i].workarounds;
1404 break;
1405 }
1406
1407 if (workarounds)
1408 SBP2_INFO("Workarounds for node " NODE_BUS_FMT ": 0x%x "
1409 "(firmware_revision 0x%06x, vendor_id 0x%06x,"
1410 " model_id 0x%06x)",
1411 NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid),
1412 workarounds, firmware_revision, ud->vendor_id,
1413 model);
1414
1415 /* We would need one SCSI host template for each target to adjust
1416 * max_sectors on the fly, therefore warn only. */
1417 if (workarounds & SBP2_WORKAROUND_128K_MAX_TRANS &&
1418 (sbp2_max_sectors * 512) > (128 * 1024))
1419 SBP2_INFO("Node " NODE_BUS_FMT ": Bridge only supports 128KB "
1420 "max transfer size. WARNING: Current max_sectors "
1421 "setting is larger than 128KB (%d sectors)",
1422 NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid),
1423 sbp2_max_sectors);
1424
1425 /* If this is a logical unit directory entry, process the parent
1426 * to get the values. */
1427 if (ud->flags & UNIT_DIRECTORY_LUN_DIRECTORY) {
1428 struct unit_directory *parent_ud = container_of(
1429 ud->device.parent, struct unit_directory, device);
1430 sbp2_parse_unit_directory(lu, parent_ud);
1431 } else {
1432 lu->management_agent_addr = management_agent_addr;
1433 lu->workarounds = workarounds;
1434 if (ud->flags & UNIT_DIRECTORY_HAS_LUN)
1435 lu->lun = ORB_SET_LUN(ud->lun);
1436 }
1437}
1438
1439#define SBP2_PAYLOAD_TO_BYTES(p) (1 << ((p) + 2))
1440
1441/*
1442 * This function is called in order to determine the max speed and packet
1443 * size we can use in our ORBs. Note, that we (the driver and host) only
1444 * initiate the transaction. The SBP-2 device actually transfers the data
1445 * (by reading from the DMA area we tell it). This means that the SBP-2
1446 * device decides the actual maximum data it can transfer. We just tell it
1447 * the speed that it needs to use, and the max_rec the host supports, and
1448 * it takes care of the rest.
1449 */
1450static int sbp2_max_speed_and_size(struct sbp2_lu *lu)
1451{
1452 struct sbp2_fwhost_info *hi = lu->hi;
1453 u8 payload;
1454
1455 lu->speed_code = hi->host->speed[NODEID_TO_NODE(lu->ne->nodeid)];
1456
1457 if (lu->speed_code > sbp2_max_speed) {
1458 lu->speed_code = sbp2_max_speed;
1459 SBP2_INFO("Reducing speed to %s",
1460 hpsb_speedto_str[sbp2_max_speed]);
1461 }
1462
1463 /* Payload size is the lesser of what our speed supports and what
1464 * our host supports. */
1465 payload = min(sbp2_speedto_max_payload[lu->speed_code],
1466 (u8) (hi->host->csr.max_rec - 1));
1467
1468 /* If physical DMA is off, work around limitation in ohci1394:
1469 * packet size must not exceed PAGE_SIZE */
1470 if (lu->ne->host->low_addr_space < (1ULL << 32))
1471 while (SBP2_PAYLOAD_TO_BYTES(payload) + 24 > PAGE_SIZE &&
1472 payload)
1473 payload--;
1474
1475 SBP2_INFO("Node " NODE_BUS_FMT ": Max speed [%s] - Max payload [%u]",
1476 NODE_BUS_ARGS(hi->host, lu->ne->nodeid),
1477 hpsb_speedto_str[lu->speed_code],
1478 SBP2_PAYLOAD_TO_BYTES(payload));
1479
1480 lu->max_payload_size = payload;
1481 return 0;
1482}
1483
1484static int sbp2_agent_reset(struct sbp2_lu *lu, int wait)
1485{
1486 quadlet_t data;
1487 u64 addr;
1488 int retval;
1489 unsigned long flags;
1490
1491 /* flush lu->protocol_work */
1492 if (wait)
1493 flush_scheduled_work();
1494
1495 data = ntohl(SBP2_AGENT_RESET_DATA);
1496 addr = lu->command_block_agent_addr + SBP2_AGENT_RESET_OFFSET;
1497
1498 if (wait)
1499 retval = hpsb_node_write(lu->ne, addr, &data, 4);
1500 else
1501 retval = sbp2util_node_write_no_wait(lu->ne, addr, &data, 4);
1502
1503 if (retval < 0) {
1504 SBP2_ERR("hpsb_node_write failed.\n");
1505 return -EIO;
1506 }
1507
1508 /* make sure that the ORB_POINTER is written on next command */
1509 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1510 lu->last_orb = NULL;
1511 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1512
1513 return 0;
1514}
1515
1516static int sbp2_prep_command_orb_sg(struct sbp2_command_orb *orb,
1517 struct sbp2_fwhost_info *hi,
1518 struct sbp2_command_info *cmd,
1519 unsigned int sg_count,
1520 struct scatterlist *sg,
1521 u32 orb_direction,
1522 enum dma_data_direction dma_dir)
1523{
1524 struct device *dmadev = hi->host->device.parent;
1525 struct sbp2_unrestricted_page_table *pt;
1526 int i, n;
1527
1528 n = dma_map_sg(dmadev, sg, sg_count, dma_dir);
1529 if (n == 0)
1530 return -ENOMEM;
1531
1532 orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id);
1533 orb->misc |= ORB_SET_DIRECTION(orb_direction);
1534
1535 /* special case if only one element (and less than 64KB in size) */
1536 if (n == 1) {
1537 orb->misc |= ORB_SET_DATA_SIZE(sg_dma_len(sg));
1538 orb->data_descriptor_lo = sg_dma_address(sg);
1539 } else {
1540 pt = &cmd->scatter_gather_element[0];
1541
1542 dma_sync_single_for_cpu(dmadev, cmd->sge_dma,
1543 sizeof(cmd->scatter_gather_element),
1544 DMA_TO_DEVICE);
1545
1546 for_each_sg(sg, sg, n, i) {
1547 pt[i].high = cpu_to_be32(sg_dma_len(sg) << 16);
1548 pt[i].low = cpu_to_be32(sg_dma_address(sg));
1549 }
1550
1551 orb->misc |= ORB_SET_PAGE_TABLE_PRESENT(0x1) |
1552 ORB_SET_DATA_SIZE(n);
1553 orb->data_descriptor_lo = cmd->sge_dma;
1554
1555 dma_sync_single_for_device(dmadev, cmd->sge_dma,
1556 sizeof(cmd->scatter_gather_element),
1557 DMA_TO_DEVICE);
1558 }
1559 return 0;
1560}
1561
1562static int sbp2_create_command_orb(struct sbp2_lu *lu,
1563 struct sbp2_command_info *cmd,
1564 struct scsi_cmnd *SCpnt)
1565{
1566 struct device *dmadev = lu->hi->host->device.parent;
1567 struct sbp2_command_orb *orb = &cmd->command_orb;
1568 unsigned int scsi_request_bufflen = scsi_bufflen(SCpnt);
1569 enum dma_data_direction dma_dir = SCpnt->sc_data_direction;
1570 u32 orb_direction;
1571 int ret;
1572
1573 dma_sync_single_for_cpu(dmadev, cmd->command_orb_dma,
1574 sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
1575 /*
1576 * Set-up our command ORB.
1577 *
1578 * NOTE: We're doing unrestricted page tables (s/g), as this is
1579 * best performance (at least with the devices I have). This means
1580 * that data_size becomes the number of s/g elements, and
1581 * page_size should be zero (for unrestricted).
1582 */
1583 orb->next_ORB_hi = ORB_SET_NULL_PTR(1);
1584 orb->next_ORB_lo = 0x0;
1585 orb->misc = ORB_SET_MAX_PAYLOAD(lu->max_payload_size);
1586 orb->misc |= ORB_SET_SPEED(lu->speed_code);
1587 orb->misc |= ORB_SET_NOTIFY(1);
1588
1589 if (dma_dir == DMA_NONE)
1590 orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
1591 else if (dma_dir == DMA_TO_DEVICE && scsi_request_bufflen)
1592 orb_direction = ORB_DIRECTION_WRITE_TO_MEDIA;
1593 else if (dma_dir == DMA_FROM_DEVICE && scsi_request_bufflen)
1594 orb_direction = ORB_DIRECTION_READ_FROM_MEDIA;
1595 else {
1596 SBP2_INFO("Falling back to DMA_NONE");
1597 orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
1598 }
1599
1600 /* set up our page table stuff */
1601 if (orb_direction == ORB_DIRECTION_NO_DATA_TRANSFER) {
1602 orb->data_descriptor_hi = 0x0;
1603 orb->data_descriptor_lo = 0x0;
1604 orb->misc |= ORB_SET_DIRECTION(1);
1605 ret = 0;
1606 } else {
1607 ret = sbp2_prep_command_orb_sg(orb, lu->hi, cmd,
1608 scsi_sg_count(SCpnt),
1609 scsi_sglist(SCpnt),
1610 orb_direction, dma_dir);
1611 }
1612 sbp2util_cpu_to_be32_buffer(orb, sizeof(*orb));
1613
1614 memset(orb->cdb, 0, sizeof(orb->cdb));
1615 memcpy(orb->cdb, SCpnt->cmnd, SCpnt->cmd_len);
1616
1617 dma_sync_single_for_device(dmadev, cmd->command_orb_dma,
1618 sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
1619 return ret;
1620}
1621
1622static void sbp2_link_orb_command(struct sbp2_lu *lu,
1623 struct sbp2_command_info *cmd)
1624{
1625 struct sbp2_fwhost_info *hi = lu->hi;
1626 struct sbp2_command_orb *last_orb;
1627 dma_addr_t last_orb_dma;
1628 u64 addr = lu->command_block_agent_addr;
1629 quadlet_t data[2];
1630 size_t length;
1631 unsigned long flags;
1632
1633 /* check to see if there are any previous orbs to use */
1634 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1635 last_orb = lu->last_orb;
1636 last_orb_dma = lu->last_orb_dma;
1637 if (!last_orb) {
1638 /*
1639 * last_orb == NULL means: We know that the target's fetch agent
1640 * is not active right now.
1641 */
1642 addr += SBP2_ORB_POINTER_OFFSET;
1643 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
1644 data[1] = cmd->command_orb_dma;
1645 sbp2util_cpu_to_be32_buffer(data, 8);
1646 length = 8;
1647 } else {
1648 /*
1649 * last_orb != NULL means: We know that the target's fetch agent
1650 * is (very probably) not dead or in reset state right now.
1651 * We have an ORB already sent that we can append a new one to.
1652 * The target's fetch agent may or may not have read this
1653 * previous ORB yet.
1654 */
1655 dma_sync_single_for_cpu(hi->host->device.parent, last_orb_dma,
1656 sizeof(struct sbp2_command_orb),
1657 DMA_TO_DEVICE);
1658 last_orb->next_ORB_lo = cpu_to_be32(cmd->command_orb_dma);
1659 wmb();
1660 /* Tells hardware that this pointer is valid */
1661 last_orb->next_ORB_hi = 0;
1662 dma_sync_single_for_device(hi->host->device.parent,
1663 last_orb_dma,
1664 sizeof(struct sbp2_command_orb),
1665 DMA_TO_DEVICE);
1666 addr += SBP2_DOORBELL_OFFSET;
1667 data[0] = 0;
1668 length = 4;
1669 }
1670 lu->last_orb = &cmd->command_orb;
1671 lu->last_orb_dma = cmd->command_orb_dma;
1672 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1673
1674 if (sbp2util_node_write_no_wait(lu->ne, addr, data, length)) {
1675 /*
1676 * sbp2util_node_write_no_wait failed. We certainly ran out
1677 * of transaction labels, perhaps just because there were no
1678 * context switches which gave khpsbpkt a chance to collect
1679 * free tlabels. Try again in non-atomic context. If necessary,
1680 * the workqueue job will sleep to guaranteedly get a tlabel.
1681 * We do not accept new commands until the job is over.
1682 */
1683 scsi_block_requests(lu->shost);
1684 PREPARE_WORK(&lu->protocol_work,
1685 last_orb ? sbp2util_write_doorbell:
1686 sbp2util_write_orb_pointer);
1687 schedule_work(&lu->protocol_work);
1688 }
1689}
1690
1691static int sbp2_send_command(struct sbp2_lu *lu, struct scsi_cmnd *SCpnt,
1692 void (*done)(struct scsi_cmnd *))
1693{
1694 struct sbp2_command_info *cmd;
1695
1696 cmd = sbp2util_allocate_command_orb(lu, SCpnt, done);
1697 if (!cmd)
1698 return -EIO;
1699
1700 if (sbp2_create_command_orb(lu, cmd, SCpnt))
1701 return -ENOMEM;
1702
1703 sbp2_link_orb_command(lu, cmd);
1704 return 0;
1705}
1706
1707/*
1708 * Translates SBP-2 status into SCSI sense data for check conditions
1709 */
1710static unsigned int sbp2_status_to_sense_data(unchar *sbp2_status,
1711 unchar *sense_data)
1712{
1713 /* OK, it's pretty ugly... ;-) */
1714 sense_data[0] = 0x70;
1715 sense_data[1] = 0x0;
1716 sense_data[2] = sbp2_status[9];
1717 sense_data[3] = sbp2_status[12];
1718 sense_data[4] = sbp2_status[13];
1719 sense_data[5] = sbp2_status[14];
1720 sense_data[6] = sbp2_status[15];
1721 sense_data[7] = 10;
1722 sense_data[8] = sbp2_status[16];
1723 sense_data[9] = sbp2_status[17];
1724 sense_data[10] = sbp2_status[18];
1725 sense_data[11] = sbp2_status[19];
1726 sense_data[12] = sbp2_status[10];
1727 sense_data[13] = sbp2_status[11];
1728 sense_data[14] = sbp2_status[20];
1729 sense_data[15] = sbp2_status[21];
1730
1731 return sbp2_status[8] & 0x3f;
1732}
1733
1734static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid,
1735 int destid, quadlet_t *data, u64 addr,
1736 size_t length, u16 fl)
1737{
1738 struct sbp2_fwhost_info *hi;
1739 struct sbp2_lu *lu = NULL, *lu_tmp;
1740 struct scsi_cmnd *SCpnt = NULL;
1741 struct sbp2_status_block *sb;
1742 u32 scsi_status = SBP2_SCSI_STATUS_GOOD;
1743 struct sbp2_command_info *cmd;
1744 unsigned long flags;
1745
1746 if (unlikely(length < 8 || length > sizeof(struct sbp2_status_block))) {
1747 SBP2_ERR("Wrong size of status block");
1748 return RCODE_ADDRESS_ERROR;
1749 }
1750 if (unlikely(!host)) {
1751 SBP2_ERR("host is NULL - this is bad!");
1752 return RCODE_ADDRESS_ERROR;
1753 }
1754 hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
1755 if (unlikely(!hi)) {
1756 SBP2_ERR("host info is NULL - this is bad!");
1757 return RCODE_ADDRESS_ERROR;
1758 }
1759
1760 /* Find the unit which wrote the status. */
1761 read_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
1762 list_for_each_entry(lu_tmp, &hi->logical_units, lu_list) {
1763 if (lu_tmp->ne->nodeid == nodeid &&
1764 lu_tmp->status_fifo_addr == addr) {
1765 lu = lu_tmp;
1766 break;
1767 }
1768 }
1769 read_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
1770
1771 if (unlikely(!lu)) {
1772 SBP2_ERR("lu is NULL - device is gone?");
1773 return RCODE_ADDRESS_ERROR;
1774 }
1775
1776 /* Put response into lu status fifo buffer. The first two bytes
1777 * come in big endian bit order. Often the target writes only a
1778 * truncated status block, minimally the first two quadlets. The rest
1779 * is implied to be zeros. */
1780 sb = &lu->status_block;
1781 memset(sb->command_set_dependent, 0, sizeof(sb->command_set_dependent));
1782 memcpy(sb, data, length);
1783 sbp2util_be32_to_cpu_buffer(sb, 8);
1784
1785 /* Ignore unsolicited status. Handle command ORB status. */
1786 if (unlikely(STATUS_GET_SRC(sb->ORB_offset_hi_misc) == 2))
1787 cmd = NULL;
1788 else
1789 cmd = sbp2util_find_command_for_orb(lu, sb->ORB_offset_lo);
1790 if (cmd) {
1791 /* Grab SCSI command pointers and check status. */
1792 /*
1793 * FIXME: If the src field in the status is 1, the ORB DMA must
1794 * not be reused until status for a subsequent ORB is received.
1795 */
1796 SCpnt = cmd->Current_SCpnt;
1797 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1798 sbp2util_mark_command_completed(lu, cmd);
1799 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1800
1801 if (SCpnt) {
1802 u32 h = sb->ORB_offset_hi_misc;
1803 u32 r = STATUS_GET_RESP(h);
1804
1805 if (r != RESP_STATUS_REQUEST_COMPLETE) {
1806 SBP2_INFO("resp 0x%x, sbp_status 0x%x",
1807 r, STATUS_GET_SBP_STATUS(h));
1808 scsi_status =
1809 r == RESP_STATUS_TRANSPORT_FAILURE ?
1810 SBP2_SCSI_STATUS_BUSY :
1811 SBP2_SCSI_STATUS_COMMAND_TERMINATED;
1812 }
1813
1814 if (STATUS_GET_LEN(h) > 1)
1815 scsi_status = sbp2_status_to_sense_data(
1816 (unchar *)sb, SCpnt->sense_buffer);
1817
1818 if (STATUS_TEST_DEAD(h))
1819 sbp2_agent_reset(lu, 0);
1820 }
1821
1822 /* Check here to see if there are no commands in-use. If there
1823 * are none, we know that the fetch agent left the active state
1824 * _and_ that we did not reactivate it yet. Therefore clear
1825 * last_orb so that next time we write directly to the
1826 * ORB_POINTER register. That way the fetch agent does not need
1827 * to refetch the next_ORB. */
1828 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1829 if (list_empty(&lu->cmd_orb_inuse))
1830 lu->last_orb = NULL;
1831 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1832
1833 } else {
1834 /* It's probably status after a management request. */
1835 if ((sb->ORB_offset_lo == lu->reconnect_orb_dma) ||
1836 (sb->ORB_offset_lo == lu->login_orb_dma) ||
1837 (sb->ORB_offset_lo == lu->query_logins_orb_dma) ||
1838 (sb->ORB_offset_lo == lu->logout_orb_dma)) {
1839 lu->access_complete = 1;
1840 wake_up_interruptible(&sbp2_access_wq);
1841 }
1842 }
1843
1844 if (SCpnt)
1845 sbp2scsi_complete_command(lu, scsi_status, SCpnt,
1846 cmd->Current_done);
1847 return RCODE_COMPLETE;
1848}
1849
1850/**************************************
1851 * SCSI interface related section
1852 **************************************/
1853
1854static int sbp2scsi_queuecommand(struct scsi_cmnd *SCpnt,
1855 void (*done)(struct scsi_cmnd *))
1856{
1857 struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
1858 struct sbp2_fwhost_info *hi;
1859 int result = DID_NO_CONNECT << 16;
1860
1861 if (unlikely(!sbp2util_node_is_available(lu)))
1862 goto done;
1863
1864 hi = lu->hi;
1865
1866 if (unlikely(!hi)) {
1867 SBP2_ERR("sbp2_fwhost_info is NULL - this is bad!");
1868 goto done;
1869 }
1870
1871 /* Multiple units are currently represented to the SCSI core as separate
1872 * targets, not as one target with multiple LUs. Therefore return
1873 * selection time-out to any IO directed at non-zero LUNs. */
1874 if (unlikely(SCpnt->device->lun))
1875 goto done;
1876
1877 if (unlikely(!hpsb_node_entry_valid(lu->ne))) {
1878 SBP2_ERR("Bus reset in progress - rejecting command");
1879 result = DID_BUS_BUSY << 16;
1880 goto done;
1881 }
1882
1883 /* Bidirectional commands are not yet implemented,
1884 * and unknown transfer direction not handled. */
1885 if (unlikely(SCpnt->sc_data_direction == DMA_BIDIRECTIONAL)) {
1886 SBP2_ERR("Cannot handle DMA_BIDIRECTIONAL - rejecting command");
1887 result = DID_ERROR << 16;
1888 goto done;
1889 }
1890
1891 if (sbp2_send_command(lu, SCpnt, done)) {
1892 SBP2_ERR("Error sending SCSI command");
1893 sbp2scsi_complete_command(lu,
1894 SBP2_SCSI_STATUS_SELECTION_TIMEOUT,
1895 SCpnt, done);
1896 }
1897 return 0;
1898
1899done:
1900 SCpnt->result = result;
1901 done(SCpnt);
1902 return 0;
1903}
1904
1905static void sbp2scsi_complete_all_commands(struct sbp2_lu *lu, u32 status)
1906{
1907 struct list_head *lh;
1908 struct sbp2_command_info *cmd;
1909 unsigned long flags;
1910
1911 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1912 while (!list_empty(&lu->cmd_orb_inuse)) {
1913 lh = lu->cmd_orb_inuse.next;
1914 cmd = list_entry(lh, struct sbp2_command_info, list);
1915 sbp2util_mark_command_completed(lu, cmd);
1916 if (cmd->Current_SCpnt) {
1917 cmd->Current_SCpnt->result = status << 16;
1918 cmd->Current_done(cmd->Current_SCpnt);
1919 }
1920 }
1921 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1922
1923 return;
1924}
1925
1926/*
1927 * Complete a regular SCSI command. Can be called in atomic context.
1928 */
1929static void sbp2scsi_complete_command(struct sbp2_lu *lu, u32 scsi_status,
1930 struct scsi_cmnd *SCpnt,
1931 void (*done)(struct scsi_cmnd *))
1932{
1933 if (!SCpnt) {
1934 SBP2_ERR("SCpnt is NULL");
1935 return;
1936 }
1937
1938 switch (scsi_status) {
1939 case SBP2_SCSI_STATUS_GOOD:
1940 SCpnt->result = DID_OK << 16;
1941 break;
1942
1943 case SBP2_SCSI_STATUS_BUSY:
1944 SBP2_ERR("SBP2_SCSI_STATUS_BUSY");
1945 SCpnt->result = DID_BUS_BUSY << 16;
1946 break;
1947
1948 case SBP2_SCSI_STATUS_CHECK_CONDITION:
1949 SCpnt->result = CHECK_CONDITION << 1 | DID_OK << 16;
1950 break;
1951
1952 case SBP2_SCSI_STATUS_SELECTION_TIMEOUT:
1953 SBP2_ERR("SBP2_SCSI_STATUS_SELECTION_TIMEOUT");
1954 SCpnt->result = DID_NO_CONNECT << 16;
1955 scsi_print_command(SCpnt);
1956 break;
1957
1958 case SBP2_SCSI_STATUS_CONDITION_MET:
1959 case SBP2_SCSI_STATUS_RESERVATION_CONFLICT:
1960 case SBP2_SCSI_STATUS_COMMAND_TERMINATED:
1961 SBP2_ERR("Bad SCSI status = %x", scsi_status);
1962 SCpnt->result = DID_ERROR << 16;
1963 scsi_print_command(SCpnt);
1964 break;
1965
1966 default:
1967 SBP2_ERR("Unsupported SCSI status = %x", scsi_status);
1968 SCpnt->result = DID_ERROR << 16;
1969 }
1970
1971 /* If a bus reset is in progress and there was an error, complete
1972 * the command as busy so that it will get retried. */
1973 if (!hpsb_node_entry_valid(lu->ne)
1974 && (scsi_status != SBP2_SCSI_STATUS_GOOD)) {
1975 SBP2_ERR("Completing command with busy (bus reset)");
1976 SCpnt->result = DID_BUS_BUSY << 16;
1977 }
1978
1979 /* Tell the SCSI stack that we're done with this command. */
1980 done(SCpnt);
1981}
1982
1983static int sbp2scsi_slave_alloc(struct scsi_device *sdev)
1984{
1985 struct sbp2_lu *lu = (struct sbp2_lu *)sdev->host->hostdata[0];
1986
1987 if (sdev->lun != 0 || sdev->id != lu->ud->id || sdev->channel != 0)
1988 return -ENODEV;
1989
1990 lu->sdev = sdev;
1991 sdev->allow_restart = 1;
1992
1993 /* SBP-2 requires quadlet alignment of the data buffers. */
1994 blk_queue_update_dma_alignment(sdev->request_queue, 4 - 1);
1995
1996 if (lu->workarounds & SBP2_WORKAROUND_INQUIRY_36)
1997 sdev->inquiry_len = 36;
1998 return 0;
1999}
2000
2001static int sbp2scsi_slave_configure(struct scsi_device *sdev)
2002{
2003 struct sbp2_lu *lu = (struct sbp2_lu *)sdev->host->hostdata[0];
2004
2005 sdev->use_10_for_rw = 1;
2006
2007 if (sbp2_exclusive_login)
2008 sdev->manage_start_stop = 1;
2009 if (sdev->type == TYPE_ROM)
2010 sdev->use_10_for_ms = 1;
2011 if (sdev->type == TYPE_DISK &&
2012 lu->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
2013 sdev->skip_ms_page_8 = 1;
2014 if (lu->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
2015 sdev->fix_capacity = 1;
2016 if (lu->workarounds & SBP2_WORKAROUND_POWER_CONDITION)
2017 sdev->start_stop_pwr_cond = 1;
2018 if (lu->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
2019 blk_queue_max_hw_sectors(sdev->request_queue, 128 * 1024 / 512);
2020
2021 blk_queue_max_segment_size(sdev->request_queue, SBP2_MAX_SEG_SIZE);
2022 return 0;
2023}
2024
2025static void sbp2scsi_slave_destroy(struct scsi_device *sdev)
2026{
2027 ((struct sbp2_lu *)sdev->host->hostdata[0])->sdev = NULL;
2028 return;
2029}
2030
2031/*
2032 * Called by scsi stack when something has really gone wrong.
2033 * Usually called when a command has timed-out for some reason.
2034 */
2035static int sbp2scsi_abort(struct scsi_cmnd *SCpnt)
2036{
2037 struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
2038 struct sbp2_command_info *cmd;
2039 unsigned long flags;
2040
2041 SBP2_INFO("aborting sbp2 command");
2042 scsi_print_command(SCpnt);
2043
2044 if (sbp2util_node_is_available(lu)) {
2045 sbp2_agent_reset(lu, 1);
2046
2047 /* Return a matching command structure to the free pool. */
2048 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
2049 cmd = sbp2util_find_command_for_SCpnt(lu, SCpnt);
2050 if (cmd) {
2051 sbp2util_mark_command_completed(lu, cmd);
2052 if (cmd->Current_SCpnt) {
2053 cmd->Current_SCpnt->result = DID_ABORT << 16;
2054 cmd->Current_done(cmd->Current_SCpnt);
2055 }
2056 }
2057 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
2058
2059 sbp2scsi_complete_all_commands(lu, DID_BUS_BUSY);
2060 }
2061
2062 return SUCCESS;
2063}
2064
2065/*
2066 * Called by scsi stack when something has really gone wrong.
2067 */
2068static int sbp2scsi_reset(struct scsi_cmnd *SCpnt)
2069{
2070 struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
2071
2072 SBP2_INFO("reset requested");
2073
2074 if (sbp2util_node_is_available(lu)) {
2075 SBP2_INFO("generating sbp2 fetch agent reset");
2076 sbp2_agent_reset(lu, 1);
2077 }
2078
2079 return SUCCESS;
2080}
2081
2082static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev,
2083 struct device_attribute *attr,
2084 char *buf)
2085{
2086 struct scsi_device *sdev;
2087 struct sbp2_lu *lu;
2088
2089 if (!(sdev = to_scsi_device(dev)))
2090 return 0;
2091
2092 if (!(lu = (struct sbp2_lu *)sdev->host->hostdata[0]))
2093 return 0;
2094
2095 if (sbp2_long_sysfs_ieee1394_id)
2096 return sprintf(buf, "%016Lx:%06x:%04x\n",
2097 (unsigned long long)lu->ne->guid,
2098 lu->ud->directory_id, ORB_SET_LUN(lu->lun));
2099 else
2100 return sprintf(buf, "%016Lx:%d:%d\n",
2101 (unsigned long long)lu->ne->guid,
2102 lu->ud->id, ORB_SET_LUN(lu->lun));
2103}
2104
2105MODULE_AUTHOR("Ben Collins <bcollins@debian.org>");
2106MODULE_DESCRIPTION("IEEE-1394 SBP-2 protocol driver");
2107MODULE_SUPPORTED_DEVICE(SBP2_DEVICE_NAME);
2108MODULE_LICENSE("GPL");
2109
2110static int sbp2_module_init(void)
2111{
2112 int ret;
2113
2114 if (sbp2_serialize_io) {
2115 sbp2_shost_template.can_queue = 1;
2116 sbp2_shost_template.cmd_per_lun = 1;
2117 }
2118
2119 sbp2_shost_template.max_sectors = sbp2_max_sectors;
2120
2121 hpsb_register_highlevel(&sbp2_highlevel);
2122 ret = hpsb_register_protocol(&sbp2_driver);
2123 if (ret) {
2124 SBP2_ERR("Failed to register protocol");
2125 hpsb_unregister_highlevel(&sbp2_highlevel);
2126 return ret;
2127 }
2128 return 0;
2129}
2130
2131static void __exit sbp2_module_exit(void)
2132{
2133 hpsb_unregister_protocol(&sbp2_driver);
2134 hpsb_unregister_highlevel(&sbp2_highlevel);
2135}
2136
2137module_init(sbp2_module_init);
2138module_exit(sbp2_module_exit);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-04 01:14:18 -0500