blob: f199896c41135c7b3117ef96b571dff01f72394c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Stefan Richter2a533b12006-11-02 21:16:08 +010032 * You may access any attached SBP-2 (usually storage devices) as regular
33 * SCSI devices. E.g. mount /dev/sda1, fdisk, mkfs, etc..
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 *
Stefan Richter2a533b12006-11-02 21:16:08 +010035 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 *
Stefan Richter2a533b12006-11-02 21:16:08 +010038 * 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
Stefan Richter2a533b12006-11-02 21:16:08 +010051 * Grep for inline FIXME comments below.
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 */
53
Stefan Richter4e6343a2007-12-16 17:31:26 +010054#include <linux/blkdev.h>
Stefan Richter902abed2006-08-14 18:56:00 +020055#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#include <linux/kernel.h>
62#include <linux/list.h>
Andrew Mortonf84c9222007-04-23 11:50:56 -070063#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#include <linux/module.h>
65#include <linux/moduleparam.h>
Andrew Mortonf84c9222007-04-23 11:50:56 -070066#include <linux/sched.h>
Stefan Richter902abed2006-08-14 18:56:00 +020067#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>
Stefan Richtere8398bb2006-07-23 22:19:00 +020073#include <linux/wait.h>
Stefan Richter20e20082007-05-05 17:18:12 +020074#include <linux/workqueue.h>
Adrian Bunk87ae9af2007-10-30 10:35:04 +010075#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Linus Torvalds1da177e2005-04-16 15:20:36 -070077#include <asm/byteorder.h>
Stefan Richter902abed2006-08-14 18:56:00 +020078#include <asm/errno.h>
79#include <asm/param.h>
Stefan Richter902abed2006-08-14 18:56:00 +020080#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
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070094#include "highlevel.h"
Stefan Richter902abed2006-08-14 18:56:00 +020095#include "hosts.h"
96#include "ieee1394.h"
97#include "ieee1394_core.h"
98#include "ieee1394_hotplug.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070099#include "ieee1394_transactions.h"
Stefan Richter902abed2006-08-14 18:56:00 +0200100#include "ieee1394_types.h"
101#include "nodemgr.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102#include "sbp2.h"
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104/*
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 */
Stefan Richterca0c7452006-11-02 21:16:08 +0100116static int sbp2_max_speed = IEEE1394_SPEED_MAX;
117module_param_named(max_speed, sbp2_max_speed, int, 0644);
Stefan Richter4106cef2009-01-19 19:20:31 +0100118MODULE_PARM_DESC(max_speed, "Limit data transfer speed (5 <= 3200, "
119 "4 <= 1600, 3 <= 800, 2 <= 400, 1 <= 200, 0 = 100 Mb/s)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
121/*
Stefan Richter77bba7a2007-06-17 23:54:52 +0200122 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 */
Stefan Richterca0c7452006-11-02 21:16:08 +0100125static int sbp2_serialize_io = 1;
Stefan Richter77bba7a2007-06-17 23:54:52 +0200126module_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)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
130/*
Stefan Richter4e6343a2007-12-16 17:31:26 +0100131 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 */
Stefan Richter4e6343a2007-12-16 17:31:26 +0100142static int sbp2_max_sectors;
Stefan Richterca0c7452006-11-02 21:16:08 +0100143module_param_named(max_sectors, sbp2_max_sectors, int, 0444);
144MODULE_PARM_DESC(max_sectors, "Change max sectors per I/O supported "
Stefan Richter4e6343a2007-12-16 17:31:26 +0100145 "(default = 0 = use SCSI stack's default)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
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
Ben Collins20f45782006-06-12 18:13:11 -0400153 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 */
Stefan Richterca0c7452006-11-02 21:16:08 +0100160static int sbp2_exclusive_login = 1;
Stefan Richter77bba7a2007-06-17 23:54:52 +0200161module_param_named(exclusive_login, sbp2_exclusive_login, bool, 0644);
Stefan Richterca0c7452006-11-02 21:16:08 +0100162MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device "
Stefan Richter77bba7a2007-06-17 23:54:52 +0200163 "(default = Y, use N for concurrent initiators)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
165/*
Stefan Richter24d3bf82006-05-15 22:04:59 +0200166 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 *
Stefan Richter24d3bf82006-05-15 22:04:59 +0200170 * - 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.
Stefan Richtere9a1c522006-05-15 22:06:37 +0200180 *
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.
Stefan Richter679c0cd2006-05-15 22:08:09 +0200185 *
Stefan Richterd94a9832008-02-03 23:07:44 +0100186 * - delay inquiry
187 * Wait extra SBP2_INQUIRY_DELAY seconds after login before SCSI inquiry.
188 *
Stefan Richter37191222008-05-11 00:35:55 +0200189 * - power condition
190 * Set the power condition field in the START STOP UNIT commands sent by
191 * sd_mod on suspend, resume, and shutdown (if manage_start_stop is on).
192 * Some disks need this to spin down or to resume properly.
193 *
Stefan Richter679c0cd2006-05-15 22:08:09 +0200194 * - override internal blacklist
195 * Instead of adding to the built-in blacklist, use only the workarounds
196 * specified in the module load parameter.
197 * Useful if a blacklist entry interfered with a non-broken device.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 */
Stefan Richter24d3bf82006-05-15 22:04:59 +0200199static int sbp2_default_workarounds;
200module_param_named(workarounds, sbp2_default_workarounds, int, 0644);
201MODULE_PARM_DESC(workarounds, "Work around device bugs (default = 0"
202 ", 128kB max transfer = " __stringify(SBP2_WORKAROUND_128K_MAX_TRANS)
203 ", 36 byte inquiry = " __stringify(SBP2_WORKAROUND_INQUIRY_36)
204 ", skip mode page 8 = " __stringify(SBP2_WORKAROUND_MODE_SENSE_8)
Stefan Richtere9a1c522006-05-15 22:06:37 +0200205 ", fix capacity = " __stringify(SBP2_WORKAROUND_FIX_CAPACITY)
Stefan Richterd94a9832008-02-03 23:07:44 +0100206 ", delay inquiry = " __stringify(SBP2_WORKAROUND_DELAY_INQUIRY)
Stefan Richter37191222008-05-11 00:35:55 +0200207 ", set power condition in start stop unit = "
208 __stringify(SBP2_WORKAROUND_POWER_CONDITION)
Stefan Richter679c0cd2006-05-15 22:08:09 +0200209 ", override internal blacklist = " __stringify(SBP2_WORKAROUND_OVERRIDE)
Stefan Richter24d3bf82006-05-15 22:04:59 +0200210 ", or a combination)");
211
Stefan Richterd7794c82007-05-27 13:17:15 +0200212/*
213 * This influences the format of the sysfs attribute
214 * /sys/bus/scsi/devices/.../ieee1394_id.
215 *
216 * The default format is like in older kernels: %016Lx:%d:%d
217 * It contains the target's EUI-64, a number given to the logical unit by
218 * the ieee1394 driver's nodemgr (starting at 0), and the LUN.
219 *
220 * The long format is: %016Lx:%06x:%04x
221 * It contains the target's EUI-64, the unit directory's directory_ID as per
222 * IEEE 1212 clause 7.7.19, and the LUN. This format comes closest to the
223 * format of SBP(-3) target port and logical unit identifier as per SAM (SCSI
224 * Architecture Model) rev.2 to 4 annex A. Therefore and because it is
225 * independent of the implementation of the ieee1394 nodemgr, the longer format
226 * is recommended for future use.
227 */
228static int sbp2_long_sysfs_ieee1394_id;
229module_param_named(long_ieee1394_id, sbp2_long_sysfs_ieee1394_id, bool, 0644);
230MODULE_PARM_DESC(long_ieee1394_id, "8+3+2 bytes format of ieee1394_id in sysfs "
231 "(default = backwards-compatible = N, SAM-conforming = Y)");
232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
Stefan Richteredf1fb22006-11-02 21:16:08 +0100234#define SBP2_INFO(fmt, args...) HPSB_INFO("sbp2: "fmt, ## args)
235#define SBP2_ERR(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237/*
238 * Globals
239 */
Stefan Richter138c8af2006-11-02 21:16:08 +0100240static void sbp2scsi_complete_all_commands(struct sbp2_lu *, u32);
241static void sbp2scsi_complete_command(struct sbp2_lu *, u32, struct scsi_cmnd *,
Stefan Richterea42ea02006-11-02 21:16:08 +0100242 void (*)(struct scsi_cmnd *));
Stefan Richter138c8af2006-11-02 21:16:08 +0100243static struct sbp2_lu *sbp2_alloc_device(struct unit_directory *);
244static int sbp2_start_device(struct sbp2_lu *);
245static void sbp2_remove_device(struct sbp2_lu *);
246static int sbp2_login_device(struct sbp2_lu *);
247static int sbp2_reconnect_device(struct sbp2_lu *);
248static int sbp2_logout_device(struct sbp2_lu *);
Stefan Richterea42ea02006-11-02 21:16:08 +0100249static void sbp2_host_reset(struct hpsb_host *);
250static int sbp2_handle_status_write(struct hpsb_host *, int, int, quadlet_t *,
251 u64, size_t, u16);
Stefan Richter138c8af2006-11-02 21:16:08 +0100252static int sbp2_agent_reset(struct sbp2_lu *, int);
253static void sbp2_parse_unit_directory(struct sbp2_lu *,
Stefan Richterea42ea02006-11-02 21:16:08 +0100254 struct unit_directory *);
Stefan Richter138c8af2006-11-02 21:16:08 +0100255static int sbp2_set_busy_timeout(struct sbp2_lu *);
256static int sbp2_max_speed_and_size(struct sbp2_lu *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Stefan Richterd3e3e972009-01-24 19:41:46 +0100259static const u8 sbp2_speedto_max_payload[] = { 0x7, 0x8, 0x9, 0xa, 0xa, 0xa };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
Stefan Richter261b5f62007-08-11 11:52:08 +0200261static DEFINE_RWLOCK(sbp2_hi_logical_units_lock);
262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263static struct hpsb_highlevel sbp2_highlevel = {
Stefan Richterea42ea02006-11-02 21:16:08 +0100264 .name = SBP2_DEVICE_NAME,
265 .host_reset = sbp2_host_reset,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266};
267
Tobias Klauser1c4fb572009-02-09 22:05:06 +0100268static const struct hpsb_address_ops sbp2_ops = {
Stefan Richterea42ea02006-11-02 21:16:08 +0100269 .write = sbp2_handle_status_write
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270};
271
272#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
Stefan Richterea42ea02006-11-02 21:16:08 +0100273static int sbp2_handle_physdma_write(struct hpsb_host *, int, int, quadlet_t *,
274 u64, size_t, u16);
275static int sbp2_handle_physdma_read(struct hpsb_host *, int, quadlet_t *, u64,
276 size_t, u16);
277
Tobias Klauser1c4fb572009-02-09 22:05:06 +0100278static const struct hpsb_address_ops sbp2_physdma_ops = {
Stefan Richterea42ea02006-11-02 21:16:08 +0100279 .read = sbp2_handle_physdma_read,
280 .write = sbp2_handle_physdma_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281};
282#endif
283
Stefan Richterea42ea02006-11-02 21:16:08 +0100284
285/*
286 * Interface to driver core and IEEE 1394 core
287 */
Stefan Richterc6409462009-02-15 23:11:38 +0100288static const struct ieee1394_device_id sbp2_id_table[] = {
Stefan Richterea42ea02006-11-02 21:16:08 +0100289 {
290 .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION,
291 .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY & 0xffffff,
292 .version = SBP2_SW_VERSION_ENTRY & 0xffffff},
293 {}
294};
295MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
296
297static int sbp2_probe(struct device *);
298static int sbp2_remove(struct device *);
299static int sbp2_update(struct unit_directory *);
300
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301static struct hpsb_protocol_driver sbp2_driver = {
Ben Collinsed30c262006-11-23 13:59:48 -0500302 .name = SBP2_DEVICE_NAME,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 .id_table = sbp2_id_table,
304 .update = sbp2_update,
305 .driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 .probe = sbp2_probe,
307 .remove = sbp2_remove,
308 },
309};
310
Stefan Richterea42ea02006-11-02 21:16:08 +0100311
312/*
313 * Interface to SCSI core
314 */
315static int sbp2scsi_queuecommand(struct scsi_cmnd *,
316 void (*)(struct scsi_cmnd *));
317static int sbp2scsi_abort(struct scsi_cmnd *);
318static int sbp2scsi_reset(struct scsi_cmnd *);
319static int sbp2scsi_slave_alloc(struct scsi_device *);
320static int sbp2scsi_slave_configure(struct scsi_device *);
321static void sbp2scsi_slave_destroy(struct scsi_device *);
322static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *,
323 struct device_attribute *, char *);
324
325static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
326
327static struct device_attribute *sbp2_sysfs_sdev_attrs[] = {
328 &dev_attr_ieee1394_id,
329 NULL
330};
331
Stefan Richterca0c7452006-11-02 21:16:08 +0100332static struct scsi_host_template sbp2_shost_template = {
Stefan Richterea42ea02006-11-02 21:16:08 +0100333 .module = THIS_MODULE,
334 .name = "SBP-2 IEEE-1394",
335 .proc_name = SBP2_DEVICE_NAME,
336 .queuecommand = sbp2scsi_queuecommand,
337 .eh_abort_handler = sbp2scsi_abort,
338 .eh_device_reset_handler = sbp2scsi_reset,
339 .slave_alloc = sbp2scsi_slave_alloc,
340 .slave_configure = sbp2scsi_slave_configure,
341 .slave_destroy = sbp2scsi_slave_destroy,
342 .this_id = -1,
343 .sg_tablesize = SG_ALL,
344 .use_clustering = ENABLE_CLUSTERING,
345 .cmd_per_lun = SBP2_MAX_CMDS,
346 .can_queue = SBP2_MAX_CMDS,
Stefan Richterea42ea02006-11-02 21:16:08 +0100347 .sdev_attrs = sbp2_sysfs_sdev_attrs,
348};
349
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100350#define SBP2_ROM_VALUE_WILDCARD ~0 /* match all */
351#define SBP2_ROM_VALUE_MISSING 0xff000000 /* not present in the unit dir. */
Stefan Richterea42ea02006-11-02 21:16:08 +0100352
Stefan Richtera80614d2006-02-14 22:04:19 -0500353/*
Stefan Richter24d3bf82006-05-15 22:04:59 +0200354 * List of devices with known bugs.
355 *
356 * The firmware_revision field, masked with 0xffff00, is the best indicator
357 * for the type of bridge chip of a device. It yields a few false positives
358 * but this did not break correctly behaving devices so far.
Stefan Richtera80614d2006-02-14 22:04:19 -0500359 */
Stefan Richter24d3bf82006-05-15 22:04:59 +0200360static const struct {
361 u32 firmware_revision;
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100362 u32 model;
Stefan Richter24d3bf82006-05-15 22:04:59 +0200363 unsigned workarounds;
364} sbp2_workarounds_table[] = {
Ben Collins4b9a3342006-06-12 18:10:18 -0400365 /* DViCO Momobay CX-1 with TSB42AA9 bridge */ {
Stefan Richter24d3bf82006-05-15 22:04:59 +0200366 .firmware_revision = 0x002800,
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100367 .model = 0x001010,
Stefan Richter24d3bf82006-05-15 22:04:59 +0200368 .workarounds = SBP2_WORKAROUND_INQUIRY_36 |
Stefan Richter37191222008-05-11 00:35:55 +0200369 SBP2_WORKAROUND_MODE_SENSE_8 |
370 SBP2_WORKAROUND_POWER_CONDITION,
Stefan Richter24d3bf82006-05-15 22:04:59 +0200371 },
Stefan Richterd94a9832008-02-03 23:07:44 +0100372 /* DViCO Momobay FX-3A with TSB42AA9A bridge */ {
373 .firmware_revision = 0x002800,
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100374 .model = 0x000000,
Stefan Richter625f0852009-09-06 19:34:17 +0200375 .workarounds = SBP2_WORKAROUND_POWER_CONDITION,
Stefan Richterd94a9832008-02-03 23:07:44 +0100376 },
Stefan Richter24d3bf82006-05-15 22:04:59 +0200377 /* Initio bridges, actually only needed for some older ones */ {
378 .firmware_revision = 0x000200,
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100379 .model = SBP2_ROM_VALUE_WILDCARD,
Stefan Richter24d3bf82006-05-15 22:04:59 +0200380 .workarounds = SBP2_WORKAROUND_INQUIRY_36,
381 },
Stefan Richter37191222008-05-11 00:35:55 +0200382 /* PL-3507 bridge with Prolific firmware */ {
383 .firmware_revision = 0x012800,
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100384 .model = SBP2_ROM_VALUE_WILDCARD,
Stefan Richter37191222008-05-11 00:35:55 +0200385 .workarounds = SBP2_WORKAROUND_POWER_CONDITION,
386 },
Stefan Richter24d3bf82006-05-15 22:04:59 +0200387 /* Symbios bridge */ {
388 .firmware_revision = 0xa0b800,
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100389 .model = SBP2_ROM_VALUE_WILDCARD,
Stefan Richter24d3bf82006-05-15 22:04:59 +0200390 .workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
Stefan Richtere9a1c522006-05-15 22:06:37 +0200391 },
Stefan Richter6e45ef42008-03-11 22:32:52 +0100392 /* Datafab MD2-FW2 with Symbios/LSILogic SYM13FW500 bridge */ {
393 .firmware_revision = 0x002600,
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100394 .model = SBP2_ROM_VALUE_WILDCARD,
Stefan Richter6e45ef42008-03-11 22:32:52 +0100395 .workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
396 },
Stefan Richter1448d7c2009-01-29 00:13:20 +0100397 /*
398 * iPod 2nd generation: needs 128k max transfer size workaround
399 * iPod 3rd generation: needs fix capacity workaround
400 */
401 {
402 .firmware_revision = 0x0a2700,
403 .model = 0x000000,
404 .workarounds = SBP2_WORKAROUND_128K_MAX_TRANS |
405 SBP2_WORKAROUND_FIX_CAPACITY,
406 },
Stefan Richtere9a1c522006-05-15 22:06:37 +0200407 /* iPod 4th generation */ {
408 .firmware_revision = 0x0a2700,
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100409 .model = 0x000021,
Stefan Richtere9a1c522006-05-15 22:06:37 +0200410 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
411 },
412 /* iPod mini */ {
413 .firmware_revision = 0x0a2700,
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100414 .model = 0x000022,
Stefan Richter9e0de912008-11-22 12:38:24 +0100415 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
416 },
417 /* iPod mini */ {
418 .firmware_revision = 0x0a2700,
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100419 .model = 0x000023,
Stefan Richtere9a1c522006-05-15 22:06:37 +0200420 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
421 },
422 /* iPod Photo */ {
423 .firmware_revision = 0x0a2700,
Stefan Richterc1fbdd72009-01-24 19:41:46 +0100424 .model = 0x00007e,
Stefan Richtere9a1c522006-05-15 22:06:37 +0200425 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
Stefan Richter24d3bf82006-05-15 22:04:59 +0200426 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427};
428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429/**************************************
430 * General utility functions
431 **************************************/
432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433#ifndef __BIG_ENDIAN
434/*
435 * Converts a buffer from be32 to cpu byte ordering. Length is in bytes.
436 */
Stefan Richter2b01b802006-07-03 12:02:28 -0400437static inline void sbp2util_be32_to_cpu_buffer(void *buffer, int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
439 u32 *temp = buffer;
440
441 for (length = (length >> 2); length--; )
442 temp[length] = be32_to_cpu(temp[length]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443}
444
445/*
446 * Converts a buffer from cpu to be32 byte ordering. Length is in bytes.
447 */
Stefan Richter2b01b802006-07-03 12:02:28 -0400448static inline void sbp2util_cpu_to_be32_buffer(void *buffer, int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
450 u32 *temp = buffer;
451
452 for (length = (length >> 2); length--; )
453 temp[length] = cpu_to_be32(temp[length]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454}
455#else /* BIG_ENDIAN */
456/* Why waste the cpu cycles? */
Stefan Richter611aa192006-08-02 18:44:00 +0200457#define sbp2util_be32_to_cpu_buffer(x,y) do {} while (0)
458#define sbp2util_cpu_to_be32_buffer(x,y) do {} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459#endif
460
Stefan Richterca0c7452006-11-02 21:16:08 +0100461static DECLARE_WAIT_QUEUE_HEAD(sbp2_access_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
Stefan Richtere8398bb2006-07-23 22:19:00 +0200463/*
464 * Waits for completion of an SBP-2 access request.
465 * Returns nonzero if timed out or prematurely interrupted.
466 */
Stefan Richter138c8af2006-11-02 21:16:08 +0100467static int sbp2util_access_timeout(struct sbp2_lu *lu, int timeout)
Stefan Richtere8398bb2006-07-23 22:19:00 +0200468{
Stefan Richterca0c7452006-11-02 21:16:08 +0100469 long leftover;
Stefan Richtere8398bb2006-07-23 22:19:00 +0200470
Stefan Richterca0c7452006-11-02 21:16:08 +0100471 leftover = wait_event_interruptible_timeout(
Stefan Richter138c8af2006-11-02 21:16:08 +0100472 sbp2_access_wq, lu->access_complete, timeout);
473 lu->access_complete = 0;
Stefan Richtere8398bb2006-07-23 22:19:00 +0200474 return leftover <= 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475}
476
Stefan Richter138c8af2006-11-02 21:16:08 +0100477static void sbp2_free_packet(void *packet)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478{
479 hpsb_free_tlabel(packet);
480 hpsb_free_packet(packet);
481}
482
Stefan Richtere8ca5662006-11-02 21:16:08 +0100483/*
484 * This is much like hpsb_node_write(), except it ignores the response
485 * subaction and returns immediately. Can be used from atomic context.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 */
487static int sbp2util_node_write_no_wait(struct node_entry *ne, u64 addr,
Stefan Richter138c8af2006-11-02 21:16:08 +0100488 quadlet_t *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489{
490 struct hpsb_packet *packet;
491
Stefan Richter138c8af2006-11-02 21:16:08 +0100492 packet = hpsb_make_writepacket(ne->host, ne->nodeid, addr, buf, len);
Stefan Richtera237f352005-11-07 06:31:39 -0500493 if (!packet)
494 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
Stefan Richter138c8af2006-11-02 21:16:08 +0100496 hpsb_set_packet_complete_task(packet, sbp2_free_packet, packet);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 hpsb_node_fill_packet(ne, packet);
Stefan Richtera237f352005-11-07 06:31:39 -0500498 if (hpsb_send_packet(packet) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 sbp2_free_packet(packet);
500 return -EIO;
501 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 return 0;
503}
504
Stefan Richter138c8af2006-11-02 21:16:08 +0100505static void sbp2util_notify_fetch_agent(struct sbp2_lu *lu, u64 offset,
506 quadlet_t *data, size_t len)
Stefan Richter09ee67a2006-08-14 18:43:00 +0200507{
Stefan Richter138c8af2006-11-02 21:16:08 +0100508 /* There is a small window after a bus reset within which the node
509 * entry's generation is current but the reconnect wasn't completed. */
510 if (unlikely(atomic_read(&lu->state) == SBP2LU_STATE_IN_RESET))
Stefan Richter09ee67a2006-08-14 18:43:00 +0200511 return;
512
Stefan Richter138c8af2006-11-02 21:16:08 +0100513 if (hpsb_node_write(lu->ne, lu->command_block_agent_addr + offset,
Stefan Richter09ee67a2006-08-14 18:43:00 +0200514 data, len))
515 SBP2_ERR("sbp2util_notify_fetch_agent failed.");
Stefan Richter138c8af2006-11-02 21:16:08 +0100516
517 /* Now accept new SCSI commands, unless a bus reset happended during
518 * hpsb_node_write. */
519 if (likely(atomic_read(&lu->state) != SBP2LU_STATE_IN_RESET))
520 scsi_unblock_requests(lu->shost);
Stefan Richter09ee67a2006-08-14 18:43:00 +0200521}
522
David Howellsc4028952006-11-22 14:57:56 +0000523static void sbp2util_write_orb_pointer(struct work_struct *work)
Stefan Richter09ee67a2006-08-14 18:43:00 +0200524{
Stefan Richterec9b7e12006-12-07 23:23:25 +0100525 struct sbp2_lu *lu = container_of(work, struct sbp2_lu, protocol_work);
Stefan Richter09ee67a2006-08-14 18:43:00 +0200526 quadlet_t data[2];
527
Stefan Richterec9b7e12006-12-07 23:23:25 +0100528 data[0] = ORB_SET_NODE_ID(lu->hi->host->node_id);
529 data[1] = lu->last_orb_dma;
Stefan Richter09ee67a2006-08-14 18:43:00 +0200530 sbp2util_cpu_to_be32_buffer(data, 8);
Stefan Richterec9b7e12006-12-07 23:23:25 +0100531 sbp2util_notify_fetch_agent(lu, SBP2_ORB_POINTER_OFFSET, data, 8);
Stefan Richter09ee67a2006-08-14 18:43:00 +0200532}
533
David Howellsc4028952006-11-22 14:57:56 +0000534static void sbp2util_write_doorbell(struct work_struct *work)
Stefan Richter09ee67a2006-08-14 18:43:00 +0200535{
Stefan Richterec9b7e12006-12-07 23:23:25 +0100536 struct sbp2_lu *lu = container_of(work, struct sbp2_lu, protocol_work);
537
538 sbp2util_notify_fetch_agent(lu, SBP2_DOORBELL_OFFSET, NULL, 4);
Stefan Richter09ee67a2006-08-14 18:43:00 +0200539}
540
Stefan Richter138c8af2006-11-02 21:16:08 +0100541static int sbp2util_create_command_orb_pool(struct sbp2_lu *lu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542{
Stefan Richter138c8af2006-11-02 21:16:08 +0100543 struct sbp2_command_info *cmd;
Stefan Richtercd8c79f2008-08-09 20:16:24 +0200544 struct device *dmadev = lu->hi->host->device.parent;
Stefan Richter3d269cb2007-02-04 20:57:38 +0100545 int i, orbs = sbp2_serialize_io ? 2 : SBP2_MAX_CMDS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 for (i = 0; i < orbs; i++) {
Stefan Richter3d269cb2007-02-04 20:57:38 +0100548 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
549 if (!cmd)
Stefan Richtercd8c79f2008-08-09 20:16:24 +0200550 goto failed_alloc;
551
552 cmd->command_orb_dma =
553 dma_map_single(dmadev, &cmd->command_orb,
554 sizeof(struct sbp2_command_orb),
555 DMA_TO_DEVICE);
556 if (dma_mapping_error(dmadev, cmd->command_orb_dma))
557 goto failed_orb;
558
559 cmd->sge_dma =
560 dma_map_single(dmadev, &cmd->scatter_gather_element,
561 sizeof(cmd->scatter_gather_element),
562 DMA_TO_DEVICE);
563 if (dma_mapping_error(dmadev, cmd->sge_dma))
564 goto failed_sge;
565
Stefan Richter138c8af2006-11-02 21:16:08 +0100566 INIT_LIST_HEAD(&cmd->list);
567 list_add_tail(&cmd->list, &lu->cmd_orb_completed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 return 0;
Stefan Richtercd8c79f2008-08-09 20:16:24 +0200570
571failed_sge:
572 dma_unmap_single(dmadev, cmd->command_orb_dma,
573 sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
574failed_orb:
575 kfree(cmd);
576failed_alloc:
577 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578}
579
Stefan Richtera2ee3f92007-08-11 11:51:16 +0200580static void sbp2util_remove_command_orb_pool(struct sbp2_lu *lu,
581 struct hpsb_host *host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 struct list_head *lh, *next;
Stefan Richter138c8af2006-11-02 21:16:08 +0100584 struct sbp2_command_info *cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 unsigned long flags;
586
Stefan Richter138c8af2006-11-02 21:16:08 +0100587 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
588 if (!list_empty(&lu->cmd_orb_completed))
589 list_for_each_safe(lh, next, &lu->cmd_orb_completed) {
590 cmd = list_entry(lh, struct sbp2_command_info, list);
Stefan Richter97d552e2006-12-29 23:47:04 +0100591 dma_unmap_single(host->device.parent,
592 cmd->command_orb_dma,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 sizeof(struct sbp2_command_orb),
Stefan Richter9b7d9c02006-11-22 21:44:34 +0100594 DMA_TO_DEVICE);
Stefan Richter97d552e2006-12-29 23:47:04 +0100595 dma_unmap_single(host->device.parent, cmd->sge_dma,
Stefan Richter138c8af2006-11-02 21:16:08 +0100596 sizeof(cmd->scatter_gather_element),
Stefan Richter2446a792007-02-04 20:54:57 +0100597 DMA_TO_DEVICE);
Stefan Richter138c8af2006-11-02 21:16:08 +0100598 kfree(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 }
Stefan Richter138c8af2006-11-02 21:16:08 +0100600 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 return;
602}
603
604/*
Stefan Richtere8ca5662006-11-02 21:16:08 +0100605 * Finds the sbp2_command for a given outstanding command ORB.
606 * Only looks at the in-use list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 */
608static struct sbp2_command_info *sbp2util_find_command_for_orb(
Stefan Richter138c8af2006-11-02 21:16:08 +0100609 struct sbp2_lu *lu, dma_addr_t orb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610{
Stefan Richter138c8af2006-11-02 21:16:08 +0100611 struct sbp2_command_info *cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 unsigned long flags;
613
Stefan Richter138c8af2006-11-02 21:16:08 +0100614 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
615 if (!list_empty(&lu->cmd_orb_inuse))
616 list_for_each_entry(cmd, &lu->cmd_orb_inuse, list)
617 if (cmd->command_orb_dma == orb) {
618 spin_unlock_irqrestore(
619 &lu->cmd_orb_lock, flags);
620 return cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 }
Stefan Richter138c8af2006-11-02 21:16:08 +0100622 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
Stefan Richtera237f352005-11-07 06:31:39 -0500623 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624}
625
626/*
Stefan Richtere8ca5662006-11-02 21:16:08 +0100627 * Finds the sbp2_command for a given outstanding SCpnt.
628 * Only looks at the in-use list.
Stefan Richter138c8af2006-11-02 21:16:08 +0100629 * Must be called with lu->cmd_orb_lock held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 */
Stefan Richter24c7cd02006-04-01 21:11:41 +0200631static struct sbp2_command_info *sbp2util_find_command_for_SCpnt(
Stefan Richter138c8af2006-11-02 21:16:08 +0100632 struct sbp2_lu *lu, void *SCpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633{
Stefan Richter138c8af2006-11-02 21:16:08 +0100634 struct sbp2_command_info *cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635
Stefan Richter138c8af2006-11-02 21:16:08 +0100636 if (!list_empty(&lu->cmd_orb_inuse))
637 list_for_each_entry(cmd, &lu->cmd_orb_inuse, list)
638 if (cmd->Current_SCpnt == SCpnt)
639 return cmd;
Stefan Richtera237f352005-11-07 06:31:39 -0500640 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641}
642
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643static struct sbp2_command_info *sbp2util_allocate_command_orb(
Stefan Richter138c8af2006-11-02 21:16:08 +0100644 struct sbp2_lu *lu,
645 struct scsi_cmnd *Current_SCpnt,
646 void (*Current_done)(struct scsi_cmnd *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647{
648 struct list_head *lh;
Stefan Richter138c8af2006-11-02 21:16:08 +0100649 struct sbp2_command_info *cmd = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 unsigned long flags;
651
Stefan Richter138c8af2006-11-02 21:16:08 +0100652 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
653 if (!list_empty(&lu->cmd_orb_completed)) {
654 lh = lu->cmd_orb_completed.next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 list_del(lh);
Stefan Richter138c8af2006-11-02 21:16:08 +0100656 cmd = list_entry(lh, struct sbp2_command_info, list);
657 cmd->Current_done = Current_done;
658 cmd->Current_SCpnt = Current_SCpnt;
659 list_add_tail(&cmd->list, &lu->cmd_orb_inuse);
660 } else
Harvey Harrisonb1ce1fd2008-03-05 18:24:54 -0800661 SBP2_ERR("%s: no orbs available", __func__);
Stefan Richter138c8af2006-11-02 21:16:08 +0100662 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
663 return cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664}
665
Stefan Richter58272c12006-11-04 09:55:33 +0100666/*
667 * Unmaps the DMAs of a command and moves the command to the completed ORB list.
668 * Must be called with lu->cmd_orb_lock held.
669 */
670static void sbp2util_mark_command_completed(struct sbp2_lu *lu,
671 struct sbp2_command_info *cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672{
Stefan Richtered6ffd02008-08-14 09:28:14 +0200673 if (scsi_sg_count(cmd->Current_SCpnt))
674 dma_unmap_sg(lu->ud->ne->host->device.parent,
675 scsi_sglist(cmd->Current_SCpnt),
676 scsi_sg_count(cmd->Current_SCpnt),
677 cmd->Current_SCpnt->sc_data_direction);
Stefan Richtercd641f62006-11-02 21:16:08 +0100678 list_move_tail(&cmd->list, &lu->cmd_orb_completed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679}
680
Jody McIntyreabd559b2005-09-30 11:59:06 -0700681/*
Stefan Richter138c8af2006-11-02 21:16:08 +0100682 * Is lu valid? Is the 1394 node still present?
Jody McIntyreabd559b2005-09-30 11:59:06 -0700683 */
Stefan Richter138c8af2006-11-02 21:16:08 +0100684static inline int sbp2util_node_is_available(struct sbp2_lu *lu)
Jody McIntyreabd559b2005-09-30 11:59:06 -0700685{
Stefan Richter138c8af2006-11-02 21:16:08 +0100686 return lu && lu->ne && !lu->ne->in_limbo;
Jody McIntyreabd559b2005-09-30 11:59:06 -0700687}
688
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689/*********************************************
690 * IEEE-1394 core driver stack related section
691 *********************************************/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
693static int sbp2_probe(struct device *dev)
694{
695 struct unit_directory *ud;
Stefan Richter138c8af2006-11-02 21:16:08 +0100696 struct sbp2_lu *lu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 ud = container_of(dev, struct unit_directory, device);
699
700 /* Don't probe UD's that have the LUN flag. We'll probe the LUN(s)
701 * instead. */
702 if (ud->flags & UNIT_DIRECTORY_HAS_LUN_DIRECTORY)
703 return -ENODEV;
704
Stefan Richter138c8af2006-11-02 21:16:08 +0100705 lu = sbp2_alloc_device(ud);
706 if (!lu)
Stefan Richtera237f352005-11-07 06:31:39 -0500707 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
Stefan Richter138c8af2006-11-02 21:16:08 +0100709 sbp2_parse_unit_directory(lu, ud);
710 return sbp2_start_device(lu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711}
712
713static int sbp2_remove(struct device *dev)
714{
715 struct unit_directory *ud;
Stefan Richter138c8af2006-11-02 21:16:08 +0100716 struct sbp2_lu *lu;
Jody McIntyreabd559b2005-09-30 11:59:06 -0700717 struct scsi_device *sdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 ud = container_of(dev, struct unit_directory, device);
Greg Kroah-Hartmanbab03052009-04-30 14:43:31 -0700720 lu = dev_get_drvdata(&ud->device);
Stefan Richter138c8af2006-11-02 21:16:08 +0100721 if (!lu)
Jody McIntyreabd559b2005-09-30 11:59:06 -0700722 return 0;
723
Stefan Richter138c8af2006-11-02 21:16:08 +0100724 if (lu->shost) {
Stefan Richterbf637ec2006-01-31 00:13:06 -0500725 /* Get rid of enqueued commands if there is no chance to
726 * send them. */
Stefan Richter138c8af2006-11-02 21:16:08 +0100727 if (!sbp2util_node_is_available(lu))
728 sbp2scsi_complete_all_commands(lu, DID_NO_CONNECT);
Stefan Richtere8ca5662006-11-02 21:16:08 +0100729 /* scsi_remove_device() may trigger shutdown functions of SCSI
Stefan Richterbf637ec2006-01-31 00:13:06 -0500730 * highlevel drivers which would deadlock if blocked. */
Stefan Richter138c8af2006-11-02 21:16:08 +0100731 atomic_set(&lu->state, SBP2LU_STATE_IN_SHUTDOWN);
732 scsi_unblock_requests(lu->shost);
Stefan Richterbf637ec2006-01-31 00:13:06 -0500733 }
Stefan Richter138c8af2006-11-02 21:16:08 +0100734 sdev = lu->sdev;
Jody McIntyreabd559b2005-09-30 11:59:06 -0700735 if (sdev) {
Stefan Richter138c8af2006-11-02 21:16:08 +0100736 lu->sdev = NULL;
Jody McIntyreabd559b2005-09-30 11:59:06 -0700737 scsi_remove_device(sdev);
738 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
Stefan Richter138c8af2006-11-02 21:16:08 +0100740 sbp2_logout_device(lu);
741 sbp2_remove_device(lu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
743 return 0;
744}
745
746static int sbp2_update(struct unit_directory *ud)
747{
Greg Kroah-Hartmanbab03052009-04-30 14:43:31 -0700748 struct sbp2_lu *lu = dev_get_drvdata(&ud->device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
Stefan Richtera3384062008-08-16 13:39:26 +0200750 if (sbp2_reconnect_device(lu) != 0) {
751 /*
752 * Reconnect failed. If another bus reset happened,
753 * let nodemgr proceed and call sbp2_update again later
754 * (or sbp2_remove if this node went away).
755 */
756 if (!hpsb_node_entry_valid(lu->ne))
757 return 0;
758 /*
759 * Or the target rejected the reconnect because we weren't
760 * fast enough. Try a regular login, but first log out
761 * just in case of any weirdness.
762 */
Stefan Richter138c8af2006-11-02 21:16:08 +0100763 sbp2_logout_device(lu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
Stefan Richtera3384062008-08-16 13:39:26 +0200765 if (sbp2_login_device(lu) != 0) {
766 if (!hpsb_node_entry_valid(lu->ne))
767 return 0;
768
769 /* Maybe another initiator won the login. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 SBP2_ERR("Failed to reconnect to sbp2 device!");
771 return -EBUSY;
772 }
773 }
774
Stefan Richter138c8af2006-11-02 21:16:08 +0100775 sbp2_set_busy_timeout(lu);
776 sbp2_agent_reset(lu, 1);
777 sbp2_max_speed_and_size(lu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
Stefan Richtere8ca5662006-11-02 21:16:08 +0100779 /* Complete any pending commands with busy (so they get retried)
780 * and remove them from our queue. */
Stefan Richter138c8af2006-11-02 21:16:08 +0100781 sbp2scsi_complete_all_commands(lu, DID_BUS_BUSY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
Stefan Richter4fc383c2006-08-14 18:46:00 +0200783 /* Accept new commands unless there was another bus reset in the
784 * meantime. */
Stefan Richter138c8af2006-11-02 21:16:08 +0100785 if (hpsb_node_entry_valid(lu->ne)) {
786 atomic_set(&lu->state, SBP2LU_STATE_RUNNING);
787 scsi_unblock_requests(lu->shost);
Stefan Richter4fc383c2006-08-14 18:46:00 +0200788 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 return 0;
790}
791
Stefan Richter138c8af2006-11-02 21:16:08 +0100792static struct sbp2_lu *sbp2_alloc_device(struct unit_directory *ud)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793{
Stefan Richterca0c7452006-11-02 21:16:08 +0100794 struct sbp2_fwhost_info *hi;
Stefan Richter138c8af2006-11-02 21:16:08 +0100795 struct Scsi_Host *shost = NULL;
796 struct sbp2_lu *lu = NULL;
Stefan Richter261b5f62007-08-11 11:52:08 +0200797 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Stefan Richter138c8af2006-11-02 21:16:08 +0100799 lu = kzalloc(sizeof(*lu), GFP_KERNEL);
800 if (!lu) {
801 SBP2_ERR("failed to create lu");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 goto failed_alloc;
803 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Stefan Richter138c8af2006-11-02 21:16:08 +0100805 lu->ne = ud->ne;
806 lu->ud = ud;
807 lu->speed_code = IEEE1394_SPEED_100;
808 lu->max_payload_size = sbp2_speedto_max_payload[IEEE1394_SPEED_100];
809 lu->status_fifo_addr = CSR1212_INVALID_ADDR_SPACE;
810 INIT_LIST_HEAD(&lu->cmd_orb_inuse);
811 INIT_LIST_HEAD(&lu->cmd_orb_completed);
812 INIT_LIST_HEAD(&lu->lu_list);
813 spin_lock_init(&lu->cmd_orb_lock);
814 atomic_set(&lu->state, SBP2LU_STATE_RUNNING);
815 INIT_WORK(&lu->protocol_work, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
Greg Kroah-Hartmanbab03052009-04-30 14:43:31 -0700817 dev_set_drvdata(&ud->device, lu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818
819 hi = hpsb_get_hostinfo(&sbp2_highlevel, ud->ne->host);
820 if (!hi) {
Stefan Richter138c8af2006-11-02 21:16:08 +0100821 hi = hpsb_create_hostinfo(&sbp2_highlevel, ud->ne->host,
822 sizeof(*hi));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 if (!hi) {
824 SBP2_ERR("failed to allocate hostinfo");
825 goto failed_alloc;
826 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 hi->host = ud->ne->host;
Stefan Richter138c8af2006-11-02 21:16:08 +0100828 INIT_LIST_HEAD(&hi->logical_units);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
831 /* Handle data movement if physical dma is not
Stefan Richter55664052006-03-28 19:59:42 -0500832 * enabled or not supported on host controller */
833 if (!hpsb_register_addrspace(&sbp2_highlevel, ud->ne->host,
834 &sbp2_physdma_ops,
835 0x0ULL, 0xfffffffcULL)) {
836 SBP2_ERR("failed to register lower 4GB address range");
837 goto failed_alloc;
838 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839#endif
840 }
841
Stefan Richtered6ffd02008-08-14 09:28:14 +0200842 if (dma_get_max_seg_size(hi->host->device.parent) > SBP2_MAX_SEG_SIZE)
843 BUG_ON(dma_set_max_seg_size(hi->host->device.parent,
844 SBP2_MAX_SEG_SIZE));
845
Stefan Richter147830f2006-03-28 19:54:52 -0500846 /* Prevent unloading of the 1394 host */
847 if (!try_module_get(hi->host->driver->owner)) {
848 SBP2_ERR("failed to get a reference on 1394 host driver");
849 goto failed_alloc;
850 }
851
Stefan Richter138c8af2006-11-02 21:16:08 +0100852 lu->hi = hi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
Stefan Richter261b5f62007-08-11 11:52:08 +0200854 write_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
Stefan Richter138c8af2006-11-02 21:16:08 +0100855 list_add_tail(&lu->lu_list, &hi->logical_units);
Stefan Richter261b5f62007-08-11 11:52:08 +0200856 write_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857
Stefan Richter35bdddb2006-01-31 00:13:33 -0500858 /* Register the status FIFO address range. We could use the same FIFO
859 * for targets at different nodes. However we need different FIFOs per
Stefan Richtera54c9d32006-05-15 22:09:46 +0200860 * target in order to support multi-unit devices.
861 * The FIFO is located out of the local host controller's physical range
862 * but, if possible, within the posted write area. Status writes will
863 * then be performed as unified transactions. This slightly reduces
864 * bandwidth usage, and some Prolific based devices seem to require it.
865 */
Stefan Richter138c8af2006-11-02 21:16:08 +0100866 lu->status_fifo_addr = hpsb_allocate_and_register_addrspace(
Stefan Richter35bdddb2006-01-31 00:13:33 -0500867 &sbp2_highlevel, ud->ne->host, &sbp2_ops,
868 sizeof(struct sbp2_status_block), sizeof(quadlet_t),
Ben Collins40ae6c52006-06-12 18:13:49 -0400869 ud->ne->host->low_addr_space, CSR1212_ALL_SPACE_END);
Stefan Richter138c8af2006-11-02 21:16:08 +0100870 if (lu->status_fifo_addr == CSR1212_INVALID_ADDR_SPACE) {
Stefan Richter35bdddb2006-01-31 00:13:33 -0500871 SBP2_ERR("failed to allocate status FIFO address range");
872 goto failed_alloc;
873 }
874
Stefan Richter138c8af2006-11-02 21:16:08 +0100875 shost = scsi_host_alloc(&sbp2_shost_template, sizeof(unsigned long));
876 if (!shost) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 SBP2_ERR("failed to register scsi host");
878 goto failed_alloc;
879 }
880
Stefan Richter138c8af2006-11-02 21:16:08 +0100881 shost->hostdata[0] = (unsigned long)lu;
Stefan Richterebbb16b2009-06-30 20:28:31 +0200882 shost->max_cmd_len = SBP2_MAX_CDB_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883
Stefan Richter138c8af2006-11-02 21:16:08 +0100884 if (!scsi_add_host(shost, &ud->device)) {
885 lu->shost = shost;
886 return lu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 }
888
889 SBP2_ERR("failed to add scsi host");
Stefan Richter138c8af2006-11-02 21:16:08 +0100890 scsi_host_put(shost);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891
892failed_alloc:
Stefan Richter138c8af2006-11-02 21:16:08 +0100893 sbp2_remove_device(lu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 return NULL;
895}
896
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897static void sbp2_host_reset(struct hpsb_host *host)
898{
Stefan Richterca0c7452006-11-02 21:16:08 +0100899 struct sbp2_fwhost_info *hi;
Stefan Richter138c8af2006-11-02 21:16:08 +0100900 struct sbp2_lu *lu;
Stefan Richter261b5f62007-08-11 11:52:08 +0200901 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
903 hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
Stefan Richter2cccbb52006-08-14 18:59:00 +0200904 if (!hi)
905 return;
Stefan Richter261b5f62007-08-11 11:52:08 +0200906
907 read_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
Stefan Richter2642b112008-11-29 14:55:47 +0100908
Stefan Richter138c8af2006-11-02 21:16:08 +0100909 list_for_each_entry(lu, &hi->logical_units, lu_list)
Stefan Richter2642b112008-11-29 14:55:47 +0100910 if (atomic_cmpxchg(&lu->state,
911 SBP2LU_STATE_RUNNING, SBP2LU_STATE_IN_RESET)
912 == SBP2LU_STATE_RUNNING)
Stefan Richter138c8af2006-11-02 21:16:08 +0100913 scsi_block_requests(lu->shost);
Stefan Richter2642b112008-11-29 14:55:47 +0100914
Stefan Richter261b5f62007-08-11 11:52:08 +0200915 read_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916}
917
Stefan Richter138c8af2006-11-02 21:16:08 +0100918static int sbp2_start_device(struct sbp2_lu *lu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919{
Stefan Richter138c8af2006-11-02 21:16:08 +0100920 struct sbp2_fwhost_info *hi = lu->hi;
James Bottomley146f7262005-09-10 12:44:09 -0500921 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
Stefan Richter97d552e2006-12-29 23:47:04 +0100923 lu->login_response = dma_alloc_coherent(hi->host->device.parent,
Stefan Richtera237f352005-11-07 06:31:39 -0500924 sizeof(struct sbp2_login_response),
Stefan Richter9b7d9c02006-11-22 21:44:34 +0100925 &lu->login_response_dma, GFP_KERNEL);
Stefan Richter138c8af2006-11-02 21:16:08 +0100926 if (!lu->login_response)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 goto alloc_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928
Stefan Richter97d552e2006-12-29 23:47:04 +0100929 lu->query_logins_orb = dma_alloc_coherent(hi->host->device.parent,
Stefan Richtera237f352005-11-07 06:31:39 -0500930 sizeof(struct sbp2_query_logins_orb),
Stefan Richter9b7d9c02006-11-22 21:44:34 +0100931 &lu->query_logins_orb_dma, GFP_KERNEL);
Stefan Richter138c8af2006-11-02 21:16:08 +0100932 if (!lu->query_logins_orb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 goto alloc_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
Stefan Richter97d552e2006-12-29 23:47:04 +0100935 lu->query_logins_response = dma_alloc_coherent(hi->host->device.parent,
Stefan Richtera237f352005-11-07 06:31:39 -0500936 sizeof(struct sbp2_query_logins_response),
Stefan Richter9b7d9c02006-11-22 21:44:34 +0100937 &lu->query_logins_response_dma, GFP_KERNEL);
Stefan Richter138c8af2006-11-02 21:16:08 +0100938 if (!lu->query_logins_response)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 goto alloc_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940
Stefan Richter97d552e2006-12-29 23:47:04 +0100941 lu->reconnect_orb = dma_alloc_coherent(hi->host->device.parent,
Stefan Richtera237f352005-11-07 06:31:39 -0500942 sizeof(struct sbp2_reconnect_orb),
Stefan Richter9b7d9c02006-11-22 21:44:34 +0100943 &lu->reconnect_orb_dma, GFP_KERNEL);
Stefan Richter138c8af2006-11-02 21:16:08 +0100944 if (!lu->reconnect_orb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 goto alloc_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
Stefan Richter97d552e2006-12-29 23:47:04 +0100947 lu->logout_orb = dma_alloc_coherent(hi->host->device.parent,
Stefan Richtera237f352005-11-07 06:31:39 -0500948 sizeof(struct sbp2_logout_orb),
Stefan Richter9b7d9c02006-11-22 21:44:34 +0100949 &lu->logout_orb_dma, GFP_KERNEL);
Stefan Richter138c8af2006-11-02 21:16:08 +0100950 if (!lu->logout_orb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 goto alloc_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952
Stefan Richter97d552e2006-12-29 23:47:04 +0100953 lu->login_orb = dma_alloc_coherent(hi->host->device.parent,
Stefan Richtera237f352005-11-07 06:31:39 -0500954 sizeof(struct sbp2_login_orb),
Stefan Richter9b7d9c02006-11-22 21:44:34 +0100955 &lu->login_orb_dma, GFP_KERNEL);
Stefan Richter138c8af2006-11-02 21:16:08 +0100956 if (!lu->login_orb)
Stefan Richtereaceec72005-12-13 11:05:05 -0500957 goto alloc_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
Stefan Richter3d269cb2007-02-04 20:57:38 +0100959 if (sbp2util_create_command_orb_pool(lu))
960 goto alloc_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
Stefan Richtere8ca5662006-11-02 21:16:08 +0100962 /* Wait a second before trying to log in. Previously logged in
963 * initiators need a chance to reconnect. */
Stefan Richter902abed2006-08-14 18:56:00 +0200964 if (msleep_interruptible(1000)) {
Stefan Richter138c8af2006-11-02 21:16:08 +0100965 sbp2_remove_device(lu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 return -EINTR;
967 }
Stefan Richtera237f352005-11-07 06:31:39 -0500968
Stefan Richter138c8af2006-11-02 21:16:08 +0100969 if (sbp2_login_device(lu)) {
970 sbp2_remove_device(lu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 return -EBUSY;
972 }
973
Stefan Richter138c8af2006-11-02 21:16:08 +0100974 sbp2_set_busy_timeout(lu);
975 sbp2_agent_reset(lu, 1);
976 sbp2_max_speed_and_size(lu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977
Stefan Richterd94a9832008-02-03 23:07:44 +0100978 if (lu->workarounds & SBP2_WORKAROUND_DELAY_INQUIRY)
979 ssleep(SBP2_INQUIRY_DELAY);
980
Stefan Richter138c8af2006-11-02 21:16:08 +0100981 error = scsi_add_device(lu->shost, 0, lu->ud->id, 0);
James Bottomley146f7262005-09-10 12:44:09 -0500982 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 SBP2_ERR("scsi_add_device failed");
Stefan Richter138c8af2006-11-02 21:16:08 +0100984 sbp2_logout_device(lu);
985 sbp2_remove_device(lu);
James Bottomley146f7262005-09-10 12:44:09 -0500986 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 }
988
989 return 0;
Stefan Richtereaceec72005-12-13 11:05:05 -0500990
991alloc_fail:
Stefan Richter138c8af2006-11-02 21:16:08 +0100992 SBP2_ERR("Could not allocate memory for lu");
993 sbp2_remove_device(lu);
Stefan Richtereaceec72005-12-13 11:05:05 -0500994 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995}
996
Stefan Richter138c8af2006-11-02 21:16:08 +0100997static void sbp2_remove_device(struct sbp2_lu *lu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998{
Stefan Richterca0c7452006-11-02 21:16:08 +0100999 struct sbp2_fwhost_info *hi;
Stefan Richter261b5f62007-08-11 11:52:08 +02001000 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
Stefan Richter138c8af2006-11-02 21:16:08 +01001002 if (!lu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 return;
Stefan Richter138c8af2006-11-02 21:16:08 +01001004 hi = lu->hi;
Stefan Richtera2ee3f92007-08-11 11:51:16 +02001005 if (!hi)
1006 goto no_hi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007
Stefan Richter138c8af2006-11-02 21:16:08 +01001008 if (lu->shost) {
1009 scsi_remove_host(lu->shost);
1010 scsi_host_put(lu->shost);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 }
Stefan Richter09ee67a2006-08-14 18:43:00 +02001012 flush_scheduled_work();
Stefan Richtera2ee3f92007-08-11 11:51:16 +02001013 sbp2util_remove_command_orb_pool(lu, hi->host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014
Stefan Richter261b5f62007-08-11 11:52:08 +02001015 write_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
Stefan Richter138c8af2006-11-02 21:16:08 +01001016 list_del(&lu->lu_list);
Stefan Richter261b5f62007-08-11 11:52:08 +02001017 write_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018
Stefan Richter138c8af2006-11-02 21:16:08 +01001019 if (lu->login_response)
Stefan Richter97d552e2006-12-29 23:47:04 +01001020 dma_free_coherent(hi->host->device.parent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 sizeof(struct sbp2_login_response),
Stefan Richter138c8af2006-11-02 21:16:08 +01001022 lu->login_response,
1023 lu->login_response_dma);
1024 if (lu->login_orb)
Stefan Richter97d552e2006-12-29 23:47:04 +01001025 dma_free_coherent(hi->host->device.parent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 sizeof(struct sbp2_login_orb),
Stefan Richter138c8af2006-11-02 21:16:08 +01001027 lu->login_orb,
1028 lu->login_orb_dma);
1029 if (lu->reconnect_orb)
Stefan Richter97d552e2006-12-29 23:47:04 +01001030 dma_free_coherent(hi->host->device.parent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 sizeof(struct sbp2_reconnect_orb),
Stefan Richter138c8af2006-11-02 21:16:08 +01001032 lu->reconnect_orb,
1033 lu->reconnect_orb_dma);
1034 if (lu->logout_orb)
Stefan Richter97d552e2006-12-29 23:47:04 +01001035 dma_free_coherent(hi->host->device.parent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 sizeof(struct sbp2_logout_orb),
Stefan Richter138c8af2006-11-02 21:16:08 +01001037 lu->logout_orb,
1038 lu->logout_orb_dma);
1039 if (lu->query_logins_orb)
Stefan Richter97d552e2006-12-29 23:47:04 +01001040 dma_free_coherent(hi->host->device.parent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 sizeof(struct sbp2_query_logins_orb),
Stefan Richter138c8af2006-11-02 21:16:08 +01001042 lu->query_logins_orb,
1043 lu->query_logins_orb_dma);
1044 if (lu->query_logins_response)
Stefan Richter97d552e2006-12-29 23:47:04 +01001045 dma_free_coherent(hi->host->device.parent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 sizeof(struct sbp2_query_logins_response),
Stefan Richter138c8af2006-11-02 21:16:08 +01001047 lu->query_logins_response,
1048 lu->query_logins_response_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049
Stefan Richter138c8af2006-11-02 21:16:08 +01001050 if (lu->status_fifo_addr != CSR1212_INVALID_ADDR_SPACE)
Stefan Richter35bdddb2006-01-31 00:13:33 -05001051 hpsb_unregister_addrspace(&sbp2_highlevel, hi->host,
Stefan Richter138c8af2006-11-02 21:16:08 +01001052 lu->status_fifo_addr);
Stefan Richter35bdddb2006-01-31 00:13:33 -05001053
Greg Kroah-Hartmanbab03052009-04-30 14:43:31 -07001054 dev_set_drvdata(&lu->ud->device, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055
Stefan Richtera2ee3f92007-08-11 11:51:16 +02001056 module_put(hi->host->driver->owner);
1057no_hi:
Stefan Richter138c8af2006-11-02 21:16:08 +01001058 kfree(lu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059}
1060
1061#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA
1062/*
Stefan Richtere8ca5662006-11-02 21:16:08 +01001063 * Deal with write requests on adapters which do not support physical DMA or
1064 * have it switched off.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 */
Stefan Richtera237f352005-11-07 06:31:39 -05001066static int sbp2_handle_physdma_write(struct hpsb_host *host, int nodeid,
1067 int destid, quadlet_t *data, u64 addr,
1068 size_t length, u16 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069{
Stefan Richtera237f352005-11-07 06:31:39 -05001070 memcpy(bus_to_virt((u32) addr), data, length);
Stefan Richtera237f352005-11-07 06:31:39 -05001071 return RCODE_COMPLETE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072}
1073
1074/*
Stefan Richtere8ca5662006-11-02 21:16:08 +01001075 * Deal with read requests on adapters which do not support physical DMA or
1076 * have it switched off.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 */
Stefan Richtera237f352005-11-07 06:31:39 -05001078static int sbp2_handle_physdma_read(struct hpsb_host *host, int nodeid,
1079 quadlet_t *data, u64 addr, size_t length,
1080 u16 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081{
Stefan Richtera237f352005-11-07 06:31:39 -05001082 memcpy(data, bus_to_virt((u32) addr), length);
Stefan Richtera237f352005-11-07 06:31:39 -05001083 return RCODE_COMPLETE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084}
1085#endif
1086
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087/**************************************
1088 * SBP-2 protocol related section
1089 **************************************/
1090
Stefan Richter138c8af2006-11-02 21:16:08 +01001091static int sbp2_query_logins(struct sbp2_lu *lu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092{
Stefan Richter138c8af2006-11-02 21:16:08 +01001093 struct sbp2_fwhost_info *hi = lu->hi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 quadlet_t data[2];
1095 int max_logins;
1096 int active_logins;
1097
Stefan Richter138c8af2006-11-02 21:16:08 +01001098 lu->query_logins_orb->reserved1 = 0x0;
1099 lu->query_logins_orb->reserved2 = 0x0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
Stefan Richter138c8af2006-11-02 21:16:08 +01001101 lu->query_logins_orb->query_response_lo = lu->query_logins_response_dma;
1102 lu->query_logins_orb->query_response_hi =
1103 ORB_SET_NODE_ID(hi->host->node_id);
1104 lu->query_logins_orb->lun_misc =
1105 ORB_SET_FUNCTION(SBP2_QUERY_LOGINS_REQUEST);
1106 lu->query_logins_orb->lun_misc |= ORB_SET_NOTIFY(1);
1107 lu->query_logins_orb->lun_misc |= ORB_SET_LUN(lu->lun);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108
Stefan Richter138c8af2006-11-02 21:16:08 +01001109 lu->query_logins_orb->reserved_resp_length =
1110 ORB_SET_QUERY_LOGINS_RESP_LENGTH(
1111 sizeof(struct sbp2_query_logins_response));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
Stefan Richter138c8af2006-11-02 21:16:08 +01001113 lu->query_logins_orb->status_fifo_hi =
1114 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1115 lu->query_logins_orb->status_fifo_lo =
1116 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
Stefan Richter138c8af2006-11-02 21:16:08 +01001118 sbp2util_cpu_to_be32_buffer(lu->query_logins_orb,
1119 sizeof(struct sbp2_query_logins_orb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
Stefan Richter138c8af2006-11-02 21:16:08 +01001121 memset(lu->query_logins_response, 0,
1122 sizeof(struct sbp2_query_logins_response));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
Stefan Richter138c8af2006-11-02 21:16:08 +01001125 data[1] = lu->query_logins_orb_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 sbp2util_cpu_to_be32_buffer(data, 8);
1127
Stefan Richter138c8af2006-11-02 21:16:08 +01001128 hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
Stefan Richter138c8af2006-11-02 21:16:08 +01001130 if (sbp2util_access_timeout(lu, 2*HZ)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
Stefan Richtera237f352005-11-07 06:31:39 -05001132 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 }
1134
Stefan Richter138c8af2006-11-02 21:16:08 +01001135 if (lu->status_block.ORB_offset_lo != lu->query_logins_orb_dma) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 SBP2_INFO("Error querying logins to SBP-2 device - timed out");
Stefan Richtera237f352005-11-07 06:31:39 -05001137 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 }
1139
Stefan Richter138c8af2006-11-02 21:16:08 +01001140 if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
Stefan Richter60657722006-07-23 22:18:00 +02001141 SBP2_INFO("Error querying logins to SBP-2 device - failed");
Stefan Richtera237f352005-11-07 06:31:39 -05001142 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 }
1144
Stefan Richter138c8af2006-11-02 21:16:08 +01001145 sbp2util_cpu_to_be32_buffer(lu->query_logins_response,
1146 sizeof(struct sbp2_query_logins_response));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147
Stefan Richter138c8af2006-11-02 21:16:08 +01001148 max_logins = RESPONSE_GET_MAX_LOGINS(
1149 lu->query_logins_response->length_max_logins);
Ben Collins20f45782006-06-12 18:13:11 -04001150 SBP2_INFO("Maximum concurrent logins supported: %d", max_logins);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Stefan Richter138c8af2006-11-02 21:16:08 +01001152 active_logins = RESPONSE_GET_ACTIVE_LOGINS(
1153 lu->query_logins_response->length_max_logins);
Ben Collins20f45782006-06-12 18:13:11 -04001154 SBP2_INFO("Number of active logins: %d", active_logins);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
1156 if (active_logins >= max_logins) {
Stefan Richtera237f352005-11-07 06:31:39 -05001157 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 }
1159
1160 return 0;
1161}
1162
Stefan Richter138c8af2006-11-02 21:16:08 +01001163static int sbp2_login_device(struct sbp2_lu *lu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164{
Stefan Richter138c8af2006-11-02 21:16:08 +01001165 struct sbp2_fwhost_info *hi = lu->hi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 quadlet_t data[2];
1167
Stefan Richter138c8af2006-11-02 21:16:08 +01001168 if (!lu->login_orb)
Stefan Richtera237f352005-11-07 06:31:39 -05001169 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170
Stefan Richter138c8af2006-11-02 21:16:08 +01001171 if (!sbp2_exclusive_login && sbp2_query_logins(lu)) {
Stefan Richterca0c7452006-11-02 21:16:08 +01001172 SBP2_INFO("Device does not support any more concurrent logins");
1173 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 }
1175
Stefan Richtere8ca5662006-11-02 21:16:08 +01001176 /* assume no password */
Stefan Richter138c8af2006-11-02 21:16:08 +01001177 lu->login_orb->password_hi = 0;
1178 lu->login_orb->password_lo = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
Stefan Richter138c8af2006-11-02 21:16:08 +01001180 lu->login_orb->login_response_lo = lu->login_response_dma;
1181 lu->login_orb->login_response_hi = ORB_SET_NODE_ID(hi->host->node_id);
1182 lu->login_orb->lun_misc = ORB_SET_FUNCTION(SBP2_LOGIN_REQUEST);
Stefan Richtere8ca5662006-11-02 21:16:08 +01001183
1184 /* one second reconnect time */
Stefan Richter138c8af2006-11-02 21:16:08 +01001185 lu->login_orb->lun_misc |= ORB_SET_RECONNECT(0);
1186 lu->login_orb->lun_misc |= ORB_SET_EXCLUSIVE(sbp2_exclusive_login);
1187 lu->login_orb->lun_misc |= ORB_SET_NOTIFY(1);
1188 lu->login_orb->lun_misc |= ORB_SET_LUN(lu->lun);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
Stefan Richter138c8af2006-11-02 21:16:08 +01001190 lu->login_orb->passwd_resp_lengths =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 ORB_SET_LOGIN_RESP_LENGTH(sizeof(struct sbp2_login_response));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
Stefan Richter138c8af2006-11-02 21:16:08 +01001193 lu->login_orb->status_fifo_hi =
1194 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1195 lu->login_orb->status_fifo_lo =
1196 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
Stefan Richter138c8af2006-11-02 21:16:08 +01001198 sbp2util_cpu_to_be32_buffer(lu->login_orb,
1199 sizeof(struct sbp2_login_orb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200
Stefan Richter138c8af2006-11-02 21:16:08 +01001201 memset(lu->login_response, 0, sizeof(struct sbp2_login_response));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
Stefan Richter138c8af2006-11-02 21:16:08 +01001204 data[1] = lu->login_orb_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 sbp2util_cpu_to_be32_buffer(data, 8);
1206
Stefan Richter138c8af2006-11-02 21:16:08 +01001207 hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208
Stefan Richtere8ca5662006-11-02 21:16:08 +01001209 /* wait up to 20 seconds for login status */
Stefan Richter138c8af2006-11-02 21:16:08 +01001210 if (sbp2util_access_timeout(lu, 20*HZ)) {
Stefan Richtere8398bb2006-07-23 22:19:00 +02001211 SBP2_ERR("Error logging into SBP-2 device - timed out");
Stefan Richtera237f352005-11-07 06:31:39 -05001212 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 }
1214
Stefan Richtere8ca5662006-11-02 21:16:08 +01001215 /* make sure that the returned status matches the login ORB */
Stefan Richter138c8af2006-11-02 21:16:08 +01001216 if (lu->status_block.ORB_offset_lo != lu->login_orb_dma) {
Stefan Richter60657722006-07-23 22:18:00 +02001217 SBP2_ERR("Error logging into SBP-2 device - timed out");
Stefan Richtera237f352005-11-07 06:31:39 -05001218 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 }
1220
Stefan Richter138c8af2006-11-02 21:16:08 +01001221 if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
Stefan Richter60657722006-07-23 22:18:00 +02001222 SBP2_ERR("Error logging into SBP-2 device - failed");
Stefan Richtera237f352005-11-07 06:31:39 -05001223 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 }
1225
Stefan Richter138c8af2006-11-02 21:16:08 +01001226 sbp2util_cpu_to_be32_buffer(lu->login_response,
1227 sizeof(struct sbp2_login_response));
1228 lu->command_block_agent_addr =
1229 ((u64)lu->login_response->command_block_agent_hi) << 32;
1230 lu->command_block_agent_addr |=
1231 ((u64)lu->login_response->command_block_agent_lo);
1232 lu->command_block_agent_addr &= 0x0000ffffffffffffULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233
1234 SBP2_INFO("Logged into SBP-2 device");
Stefan Richtera237f352005-11-07 06:31:39 -05001235 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236}
1237
Stefan Richter138c8af2006-11-02 21:16:08 +01001238static int sbp2_logout_device(struct sbp2_lu *lu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239{
Stefan Richter138c8af2006-11-02 21:16:08 +01001240 struct sbp2_fwhost_info *hi = lu->hi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 quadlet_t data[2];
1242 int error;
1243
Stefan Richter138c8af2006-11-02 21:16:08 +01001244 lu->logout_orb->reserved1 = 0x0;
1245 lu->logout_orb->reserved2 = 0x0;
1246 lu->logout_orb->reserved3 = 0x0;
1247 lu->logout_orb->reserved4 = 0x0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248
Stefan Richter138c8af2006-11-02 21:16:08 +01001249 lu->logout_orb->login_ID_misc = ORB_SET_FUNCTION(SBP2_LOGOUT_REQUEST);
1250 lu->logout_orb->login_ID_misc |=
1251 ORB_SET_LOGIN_ID(lu->login_response->length_login_ID);
1252 lu->logout_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253
Stefan Richter138c8af2006-11-02 21:16:08 +01001254 lu->logout_orb->reserved5 = 0x0;
1255 lu->logout_orb->status_fifo_hi =
1256 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1257 lu->logout_orb->status_fifo_lo =
1258 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
Stefan Richter138c8af2006-11-02 21:16:08 +01001260 sbp2util_cpu_to_be32_buffer(lu->logout_orb,
1261 sizeof(struct sbp2_logout_orb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
Stefan Richter138c8af2006-11-02 21:16:08 +01001264 data[1] = lu->logout_orb_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 sbp2util_cpu_to_be32_buffer(data, 8);
1266
Stefan Richter138c8af2006-11-02 21:16:08 +01001267 error = hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 if (error)
1269 return error;
1270
Stefan Richtere8ca5662006-11-02 21:16:08 +01001271 /* wait up to 1 second for the device to complete logout */
Stefan Richter138c8af2006-11-02 21:16:08 +01001272 if (sbp2util_access_timeout(lu, HZ))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 return -EIO;
1274
1275 SBP2_INFO("Logged out of SBP-2 device");
Stefan Richtera237f352005-11-07 06:31:39 -05001276 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277}
1278
Stefan Richter138c8af2006-11-02 21:16:08 +01001279static int sbp2_reconnect_device(struct sbp2_lu *lu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280{
Stefan Richter138c8af2006-11-02 21:16:08 +01001281 struct sbp2_fwhost_info *hi = lu->hi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 quadlet_t data[2];
1283 int error;
1284
Stefan Richter138c8af2006-11-02 21:16:08 +01001285 lu->reconnect_orb->reserved1 = 0x0;
1286 lu->reconnect_orb->reserved2 = 0x0;
1287 lu->reconnect_orb->reserved3 = 0x0;
1288 lu->reconnect_orb->reserved4 = 0x0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289
Stefan Richter138c8af2006-11-02 21:16:08 +01001290 lu->reconnect_orb->login_ID_misc =
1291 ORB_SET_FUNCTION(SBP2_RECONNECT_REQUEST);
1292 lu->reconnect_orb->login_ID_misc |=
1293 ORB_SET_LOGIN_ID(lu->login_response->length_login_ID);
1294 lu->reconnect_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295
Stefan Richter138c8af2006-11-02 21:16:08 +01001296 lu->reconnect_orb->reserved5 = 0x0;
1297 lu->reconnect_orb->status_fifo_hi =
1298 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1299 lu->reconnect_orb->status_fifo_lo =
1300 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301
Stefan Richter138c8af2006-11-02 21:16:08 +01001302 sbp2util_cpu_to_be32_buffer(lu->reconnect_orb,
1303 sizeof(struct sbp2_reconnect_orb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
Stefan Richter138c8af2006-11-02 21:16:08 +01001306 data[1] = lu->reconnect_orb_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 sbp2util_cpu_to_be32_buffer(data, 8);
1308
Stefan Richter138c8af2006-11-02 21:16:08 +01001309 error = hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 if (error)
1311 return error;
1312
Stefan Richtere8ca5662006-11-02 21:16:08 +01001313 /* wait up to 1 second for reconnect status */
Stefan Richter138c8af2006-11-02 21:16:08 +01001314 if (sbp2util_access_timeout(lu, HZ)) {
Stefan Richtere8398bb2006-07-23 22:19:00 +02001315 SBP2_ERR("Error reconnecting to SBP-2 device - timed out");
Stefan Richtera237f352005-11-07 06:31:39 -05001316 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 }
1318
Stefan Richtere8ca5662006-11-02 21:16:08 +01001319 /* make sure that the returned status matches the reconnect ORB */
Stefan Richter138c8af2006-11-02 21:16:08 +01001320 if (lu->status_block.ORB_offset_lo != lu->reconnect_orb_dma) {
Stefan Richter60657722006-07-23 22:18:00 +02001321 SBP2_ERR("Error reconnecting to SBP-2 device - timed out");
Stefan Richtera237f352005-11-07 06:31:39 -05001322 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 }
1324
Stefan Richter138c8af2006-11-02 21:16:08 +01001325 if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
Stefan Richter60657722006-07-23 22:18:00 +02001326 SBP2_ERR("Error reconnecting to SBP-2 device - failed");
Stefan Richtera237f352005-11-07 06:31:39 -05001327 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 }
1329
Stefan Richter35644092006-11-02 21:16:08 +01001330 SBP2_INFO("Reconnected to SBP-2 device");
Stefan Richtera237f352005-11-07 06:31:39 -05001331 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332}
1333
1334/*
Stefan Richtere8ca5662006-11-02 21:16:08 +01001335 * Set the target node's Single Phase Retry limit. Affects the target's retry
1336 * behaviour if our node is too busy to accept requests.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 */
Stefan Richter138c8af2006-11-02 21:16:08 +01001338static int sbp2_set_busy_timeout(struct sbp2_lu *lu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339{
1340 quadlet_t data;
1341
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 data = cpu_to_be32(SBP2_BUSY_TIMEOUT_VALUE);
Stefan Richter138c8af2006-11-02 21:16:08 +01001343 if (hpsb_node_write(lu->ne, SBP2_BUSY_TIMEOUT_ADDRESS, &data, 4))
Harvey Harrisonb1ce1fd2008-03-05 18:24:54 -08001344 SBP2_ERR("%s error", __func__);
Stefan Richtera237f352005-11-07 06:31:39 -05001345 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346}
1347
Stefan Richter138c8af2006-11-02 21:16:08 +01001348static void sbp2_parse_unit_directory(struct sbp2_lu *lu,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 struct unit_directory *ud)
1350{
1351 struct csr1212_keyval *kv;
1352 struct csr1212_dentry *dentry;
1353 u64 management_agent_addr;
Stefan Richterc1fbdd72009-01-24 19:41:46 +01001354 u32 unit_characteristics, firmware_revision, model;
Stefan Richter24d3bf82006-05-15 22:04:59 +02001355 unsigned workarounds;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 int i;
1357
Stefan Richter9117c6d2006-11-02 21:16:08 +01001358 management_agent_addr = 0;
1359 unit_characteristics = 0;
Stefan Richterc1fbdd72009-01-24 19:41:46 +01001360 firmware_revision = SBP2_ROM_VALUE_MISSING;
1361 model = ud->flags & UNIT_DIRECTORY_MODEL_ID ?
1362 ud->model_id : SBP2_ROM_VALUE_MISSING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 csr1212_for_each_dir_entry(ud->ne->csr, kv, ud->ud_kv, dentry) {
1365 switch (kv->key.id) {
1366 case CSR1212_KV_ID_DEPENDENT_INFO:
Stefan Richteredf1fb22006-11-02 21:16:08 +01001367 if (kv->key.type == CSR1212_KV_TYPE_CSR_OFFSET)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 management_agent_addr =
Stefan Richtera237f352005-11-07 06:31:39 -05001369 CSR1212_REGISTER_SPACE_BASE +
1370 (kv->value.csr_offset << 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371
Stefan Richteredf1fb22006-11-02 21:16:08 +01001372 else if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE)
Stefan Richter138c8af2006-11-02 21:16:08 +01001373 lu->lun = ORB_SET_LUN(kv->value.immediate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 break;
1375
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 case SBP2_UNIT_CHARACTERISTICS_KEY:
Stefan Richtere8ca5662006-11-02 21:16:08 +01001377 /* FIXME: This is ignored so far.
1378 * See SBP-2 clause 7.4.8. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 unit_characteristics = kv->value.immediate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 break;
1381
1382 case SBP2_FIRMWARE_REVISION_KEY:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 firmware_revision = kv->value.immediate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 break;
1385
1386 default:
Stefan Richtere8ca5662006-11-02 21:16:08 +01001387 /* FIXME: Check for SBP2_DEVICE_TYPE_AND_LUN_KEY.
1388 * Its "ordered" bit has consequences for command ORB
1389 * list handling. See SBP-2 clauses 4.6, 7.4.11, 10.2 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 break;
1391 }
1392 }
1393
Stefan Richter24d3bf82006-05-15 22:04:59 +02001394 workarounds = sbp2_default_workarounds;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395
Stefan Richter679c0cd2006-05-15 22:08:09 +02001396 if (!(workarounds & SBP2_WORKAROUND_OVERRIDE))
1397 for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
Stefan Richter4618fd32006-12-30 15:37:09 +01001398 if (sbp2_workarounds_table[i].firmware_revision !=
1399 SBP2_ROM_VALUE_WILDCARD &&
Stefan Richter679c0cd2006-05-15 22:08:09 +02001400 sbp2_workarounds_table[i].firmware_revision !=
1401 (firmware_revision & 0xffff00))
1402 continue;
Stefan Richterc1fbdd72009-01-24 19:41:46 +01001403 if (sbp2_workarounds_table[i].model !=
Stefan Richter4618fd32006-12-30 15:37:09 +01001404 SBP2_ROM_VALUE_WILDCARD &&
Stefan Richterc1fbdd72009-01-24 19:41:46 +01001405 sbp2_workarounds_table[i].model != model)
Stefan Richter679c0cd2006-05-15 22:08:09 +02001406 continue;
1407 workarounds |= sbp2_workarounds_table[i].workarounds;
1408 break;
1409 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410
Stefan Richter24d3bf82006-05-15 22:04:59 +02001411 if (workarounds)
Stefan Richtere9a1c522006-05-15 22:06:37 +02001412 SBP2_INFO("Workarounds for node " NODE_BUS_FMT ": 0x%x "
1413 "(firmware_revision 0x%06x, vendor_id 0x%06x,"
1414 " model_id 0x%06x)",
Stefan Richter24d3bf82006-05-15 22:04:59 +02001415 NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid),
Stefan Richtere90874f2009-01-24 19:41:46 +01001416 workarounds, firmware_revision, ud->vendor_id,
Stefan Richterc1fbdd72009-01-24 19:41:46 +01001417 model);
Stefan Richter24d3bf82006-05-15 22:04:59 +02001418
1419 /* We would need one SCSI host template for each target to adjust
1420 * max_sectors on the fly, therefore warn only. */
1421 if (workarounds & SBP2_WORKAROUND_128K_MAX_TRANS &&
Stefan Richterca0c7452006-11-02 21:16:08 +01001422 (sbp2_max_sectors * 512) > (128 * 1024))
Stefan Richter35644092006-11-02 21:16:08 +01001423 SBP2_INFO("Node " NODE_BUS_FMT ": Bridge only supports 128KB "
Stefan Richter24d3bf82006-05-15 22:04:59 +02001424 "max transfer size. WARNING: Current max_sectors "
1425 "setting is larger than 128KB (%d sectors)",
1426 NODE_BUS_ARGS(ud->ne->host, ud->ne->nodeid),
Stefan Richterca0c7452006-11-02 21:16:08 +01001427 sbp2_max_sectors);
Stefan Richter24d3bf82006-05-15 22:04:59 +02001428
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 /* If this is a logical unit directory entry, process the parent
1430 * to get the values. */
1431 if (ud->flags & UNIT_DIRECTORY_LUN_DIRECTORY) {
Stefan Richter138c8af2006-11-02 21:16:08 +01001432 struct unit_directory *parent_ud = container_of(
1433 ud->device.parent, struct unit_directory, device);
1434 sbp2_parse_unit_directory(lu, parent_ud);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 } else {
Stefan Richter138c8af2006-11-02 21:16:08 +01001436 lu->management_agent_addr = management_agent_addr;
1437 lu->workarounds = workarounds;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 if (ud->flags & UNIT_DIRECTORY_HAS_LUN)
Stefan Richter138c8af2006-11-02 21:16:08 +01001439 lu->lun = ORB_SET_LUN(ud->lun);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 }
1441}
1442
Ben Collinsfd23ade2006-06-12 18:14:14 -04001443#define SBP2_PAYLOAD_TO_BYTES(p) (1 << ((p) + 2))
1444
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445/*
1446 * This function is called in order to determine the max speed and packet
1447 * size we can use in our ORBs. Note, that we (the driver and host) only
1448 * initiate the transaction. The SBP-2 device actually transfers the data
1449 * (by reading from the DMA area we tell it). This means that the SBP-2
1450 * device decides the actual maximum data it can transfer. We just tell it
1451 * the speed that it needs to use, and the max_rec the host supports, and
1452 * it takes care of the rest.
1453 */
Stefan Richter138c8af2006-11-02 21:16:08 +01001454static int sbp2_max_speed_and_size(struct sbp2_lu *lu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455{
Stefan Richter138c8af2006-11-02 21:16:08 +01001456 struct sbp2_fwhost_info *hi = lu->hi;
Ben Collinsfd23ade2006-06-12 18:14:14 -04001457 u8 payload;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458
Stefan Richter138c8af2006-11-02 21:16:08 +01001459 lu->speed_code = hi->host->speed[NODEID_TO_NODE(lu->ne->nodeid)];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460
Stefan Richter138c8af2006-11-02 21:16:08 +01001461 if (lu->speed_code > sbp2_max_speed) {
1462 lu->speed_code = sbp2_max_speed;
Stefan Richterca0c7452006-11-02 21:16:08 +01001463 SBP2_INFO("Reducing speed to %s",
1464 hpsb_speedto_str[sbp2_max_speed]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 }
1466
1467 /* Payload size is the lesser of what our speed supports and what
1468 * our host supports. */
Stefan Richter138c8af2006-11-02 21:16:08 +01001469 payload = min(sbp2_speedto_max_payload[lu->speed_code],
Ben Collinsfd23ade2006-06-12 18:14:14 -04001470 (u8) (hi->host->csr.max_rec - 1));
1471
1472 /* If physical DMA is off, work around limitation in ohci1394:
1473 * packet size must not exceed PAGE_SIZE */
Stefan Richter138c8af2006-11-02 21:16:08 +01001474 if (lu->ne->host->low_addr_space < (1ULL << 32))
Ben Collinsfd23ade2006-06-12 18:14:14 -04001475 while (SBP2_PAYLOAD_TO_BYTES(payload) + 24 > PAGE_SIZE &&
1476 payload)
1477 payload--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478
Stefan Richter35644092006-11-02 21:16:08 +01001479 SBP2_INFO("Node " NODE_BUS_FMT ": Max speed [%s] - Max payload [%u]",
Stefan Richter138c8af2006-11-02 21:16:08 +01001480 NODE_BUS_ARGS(hi->host, lu->ne->nodeid),
1481 hpsb_speedto_str[lu->speed_code],
Stefan Richter35644092006-11-02 21:16:08 +01001482 SBP2_PAYLOAD_TO_BYTES(payload));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483
Stefan Richter138c8af2006-11-02 21:16:08 +01001484 lu->max_payload_size = payload;
Stefan Richtera237f352005-11-07 06:31:39 -05001485 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486}
1487
Stefan Richter138c8af2006-11-02 21:16:08 +01001488static int sbp2_agent_reset(struct sbp2_lu *lu, int wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489{
1490 quadlet_t data;
1491 u64 addr;
1492 int retval;
Stefan Richtercc078182006-07-23 22:12:00 +02001493 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
Stefan Richterec9b7e12006-12-07 23:23:25 +01001495 /* flush lu->protocol_work */
Stefan Richter09ee67a2006-08-14 18:43:00 +02001496 if (wait)
1497 flush_scheduled_work();
1498
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 data = ntohl(SBP2_AGENT_RESET_DATA);
Stefan Richter138c8af2006-11-02 21:16:08 +01001500 addr = lu->command_block_agent_addr + SBP2_AGENT_RESET_OFFSET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501
1502 if (wait)
Stefan Richter138c8af2006-11-02 21:16:08 +01001503 retval = hpsb_node_write(lu->ne, addr, &data, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 else
Stefan Richter138c8af2006-11-02 21:16:08 +01001505 retval = sbp2util_node_write_no_wait(lu->ne, addr, &data, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506
1507 if (retval < 0) {
1508 SBP2_ERR("hpsb_node_write failed.\n");
1509 return -EIO;
1510 }
1511
Stefan Richtere8ca5662006-11-02 21:16:08 +01001512 /* make sure that the ORB_POINTER is written on next command */
Stefan Richter138c8af2006-11-02 21:16:08 +01001513 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1514 lu->last_orb = NULL;
1515 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
Stefan Richtera237f352005-11-07 06:31:39 -05001517 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518}
1519
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001520static int sbp2_prep_command_orb_sg(struct sbp2_command_orb *orb,
1521 struct sbp2_fwhost_info *hi,
1522 struct sbp2_command_info *cmd,
Stefan Richtered6ffd02008-08-14 09:28:14 +02001523 unsigned int sg_count,
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001524 struct scatterlist *sg,
1525 u32 orb_direction,
1526 enum dma_data_direction dma_dir)
Stefan Richtercf8d2c02005-12-13 11:05:03 -05001527{
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001528 struct device *dmadev = hi->host->device.parent;
Stefan Richtered6ffd02008-08-14 09:28:14 +02001529 struct sbp2_unrestricted_page_table *pt;
1530 int i, n;
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001531
Stefan Richtered6ffd02008-08-14 09:28:14 +02001532 n = dma_map_sg(dmadev, sg, sg_count, dma_dir);
1533 if (n == 0)
1534 return -ENOMEM;
1535
Stefan Richtercf8d2c02005-12-13 11:05:03 -05001536 orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id);
1537 orb->misc |= ORB_SET_DIRECTION(orb_direction);
1538
Stefan Richtere8ca5662006-11-02 21:16:08 +01001539 /* special case if only one element (and less than 64KB in size) */
Stefan Richtered6ffd02008-08-14 09:28:14 +02001540 if (n == 1) {
1541 orb->misc |= ORB_SET_DATA_SIZE(sg_dma_len(sg));
1542 orb->data_descriptor_lo = sg_dma_address(sg);
Stefan Richtercf8d2c02005-12-13 11:05:03 -05001543 } else {
Stefan Richtered6ffd02008-08-14 09:28:14 +02001544 pt = &cmd->scatter_gather_element[0];
Stefan Richtercf8d2c02005-12-13 11:05:03 -05001545
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001546 dma_sync_single_for_cpu(dmadev, cmd->sge_dma,
Stefan Richter0a77b172008-08-09 20:13:00 +02001547 sizeof(cmd->scatter_gather_element),
1548 DMA_TO_DEVICE);
1549
Stefan Richtered6ffd02008-08-14 09:28:14 +02001550 for_each_sg(sg, sg, n, i) {
1551 pt[i].high = cpu_to_be32(sg_dma_len(sg) << 16);
1552 pt[i].low = cpu_to_be32(sg_dma_address(sg));
Stefan Richtercf8d2c02005-12-13 11:05:03 -05001553 }
1554
Stefan Richtered6ffd02008-08-14 09:28:14 +02001555 orb->misc |= ORB_SET_PAGE_TABLE_PRESENT(0x1) |
1556 ORB_SET_DATA_SIZE(n);
1557 orb->data_descriptor_lo = cmd->sge_dma;
Stefan Richter0a77b172008-08-09 20:13:00 +02001558
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001559 dma_sync_single_for_device(dmadev, cmd->sge_dma,
Stefan Richter0a77b172008-08-09 20:13:00 +02001560 sizeof(cmd->scatter_gather_element),
1561 DMA_TO_DEVICE);
Stefan Richtercf8d2c02005-12-13 11:05:03 -05001562 }
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001563 return 0;
Stefan Richtercf8d2c02005-12-13 11:05:03 -05001564}
1565
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001566static int sbp2_create_command_orb(struct sbp2_lu *lu,
1567 struct sbp2_command_info *cmd,
1568 struct scsi_cmnd *SCpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569{
Stefan Richter0a77b172008-08-09 20:13:00 +02001570 struct device *dmadev = lu->hi->host->device.parent;
Stefan Richter138c8af2006-11-02 21:16:08 +01001571 struct sbp2_command_orb *orb = &cmd->command_orb;
Stefan Richter93c596f2008-05-04 16:54:14 +02001572 unsigned int scsi_request_bufflen = scsi_bufflen(SCpnt);
1573 enum dma_data_direction dma_dir = SCpnt->sc_data_direction;
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001574 u32 orb_direction;
1575 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576
Stefan Richter0a77b172008-08-09 20:13:00 +02001577 dma_sync_single_for_cpu(dmadev, cmd->command_orb_dma,
1578 sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 /*
Stefan Richtere8ca5662006-11-02 21:16:08 +01001580 * Set-up our command ORB.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 *
1582 * NOTE: We're doing unrestricted page tables (s/g), as this is
1583 * best performance (at least with the devices I have). This means
1584 * that data_size becomes the number of s/g elements, and
1585 * page_size should be zero (for unrestricted).
1586 */
Stefan Richter138c8af2006-11-02 21:16:08 +01001587 orb->next_ORB_hi = ORB_SET_NULL_PTR(1);
1588 orb->next_ORB_lo = 0x0;
1589 orb->misc = ORB_SET_MAX_PAYLOAD(lu->max_payload_size);
1590 orb->misc |= ORB_SET_SPEED(lu->speed_code);
1591 orb->misc |= ORB_SET_NOTIFY(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592
Stefan Richter43863eb2005-12-12 23:03:24 -05001593 if (dma_dir == DMA_NONE)
Stefan Richtera237f352005-11-07 06:31:39 -05001594 orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
Stefan Richter43863eb2005-12-12 23:03:24 -05001595 else if (dma_dir == DMA_TO_DEVICE && scsi_request_bufflen)
Stefan Richtera237f352005-11-07 06:31:39 -05001596 orb_direction = ORB_DIRECTION_WRITE_TO_MEDIA;
Stefan Richter43863eb2005-12-12 23:03:24 -05001597 else if (dma_dir == DMA_FROM_DEVICE && scsi_request_bufflen)
Stefan Richtera237f352005-11-07 06:31:39 -05001598 orb_direction = ORB_DIRECTION_READ_FROM_MEDIA;
Stefan Richter43863eb2005-12-12 23:03:24 -05001599 else {
Stefan Richter35644092006-11-02 21:16:08 +01001600 SBP2_INFO("Falling back to DMA_NONE");
Stefan Richter43863eb2005-12-12 23:03:24 -05001601 orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 }
1603
Stefan Richtere8ca5662006-11-02 21:16:08 +01001604 /* set up our page table stuff */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 if (orb_direction == ORB_DIRECTION_NO_DATA_TRANSFER) {
Stefan Richter138c8af2006-11-02 21:16:08 +01001606 orb->data_descriptor_hi = 0x0;
1607 orb->data_descriptor_lo = 0x0;
1608 orb->misc |= ORB_SET_DIRECTION(1);
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001609 ret = 0;
1610 } else {
1611 ret = sbp2_prep_command_orb_sg(orb, lu->hi, cmd,
1612 scsi_sg_count(SCpnt),
1613 scsi_sglist(SCpnt),
1614 orb_direction, dma_dir);
1615 }
Stefan Richter138c8af2006-11-02 21:16:08 +01001616 sbp2util_cpu_to_be32_buffer(orb, sizeof(*orb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617
Stefan Richter93c596f2008-05-04 16:54:14 +02001618 memset(orb->cdb, 0, sizeof(orb->cdb));
1619 memcpy(orb->cdb, SCpnt->cmnd, SCpnt->cmd_len);
Stefan Richter0a77b172008-08-09 20:13:00 +02001620
1621 dma_sync_single_for_device(dmadev, cmd->command_orb_dma,
1622 sizeof(struct sbp2_command_orb), DMA_TO_DEVICE);
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001623 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624}
1625
Stefan Richter138c8af2006-11-02 21:16:08 +01001626static void sbp2_link_orb_command(struct sbp2_lu *lu,
1627 struct sbp2_command_info *cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628{
Stefan Richter138c8af2006-11-02 21:16:08 +01001629 struct sbp2_fwhost_info *hi = lu->hi;
Stefan Richtercc078182006-07-23 22:12:00 +02001630 struct sbp2_command_orb *last_orb;
1631 dma_addr_t last_orb_dma;
Stefan Richter138c8af2006-11-02 21:16:08 +01001632 u64 addr = lu->command_block_agent_addr;
Stefan Richtercc078182006-07-23 22:12:00 +02001633 quadlet_t data[2];
1634 size_t length;
1635 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636
Stefan Richtere8ca5662006-11-02 21:16:08 +01001637 /* check to see if there are any previous orbs to use */
Stefan Richter138c8af2006-11-02 21:16:08 +01001638 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1639 last_orb = lu->last_orb;
1640 last_orb_dma = lu->last_orb_dma;
Stefan Richtercc078182006-07-23 22:12:00 +02001641 if (!last_orb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 /*
Stefan Richtercc078182006-07-23 22:12:00 +02001643 * last_orb == NULL means: We know that the target's fetch agent
1644 * is not active right now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 */
Stefan Richtercc078182006-07-23 22:12:00 +02001646 addr += SBP2_ORB_POINTER_OFFSET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 data[0] = ORB_SET_NODE_ID(hi->host->node_id);
Stefan Richter138c8af2006-11-02 21:16:08 +01001648 data[1] = cmd->command_orb_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 sbp2util_cpu_to_be32_buffer(data, 8);
Stefan Richtercc078182006-07-23 22:12:00 +02001650 length = 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 /*
Stefan Richtercc078182006-07-23 22:12:00 +02001653 * last_orb != NULL means: We know that the target's fetch agent
1654 * is (very probably) not dead or in reset state right now.
1655 * We have an ORB already sent that we can append a new one to.
1656 * The target's fetch agent may or may not have read this
1657 * previous ORB yet.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 */
Stefan Richter97d552e2006-12-29 23:47:04 +01001659 dma_sync_single_for_cpu(hi->host->device.parent, last_orb_dma,
Stefan Richter9b7d9c02006-11-22 21:44:34 +01001660 sizeof(struct sbp2_command_orb),
1661 DMA_TO_DEVICE);
Stefan Richter138c8af2006-11-02 21:16:08 +01001662 last_orb->next_ORB_lo = cpu_to_be32(cmd->command_orb_dma);
Stefan Richtercc078182006-07-23 22:12:00 +02001663 wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 /* Tells hardware that this pointer is valid */
Stefan Richtercc078182006-07-23 22:12:00 +02001665 last_orb->next_ORB_hi = 0;
Stefan Richter97d552e2006-12-29 23:47:04 +01001666 dma_sync_single_for_device(hi->host->device.parent,
1667 last_orb_dma,
Stefan Richter9b7d9c02006-11-22 21:44:34 +01001668 sizeof(struct sbp2_command_orb),
1669 DMA_TO_DEVICE);
Stefan Richtercc078182006-07-23 22:12:00 +02001670 addr += SBP2_DOORBELL_OFFSET;
1671 data[0] = 0;
1672 length = 4;
1673 }
Stefan Richter138c8af2006-11-02 21:16:08 +01001674 lu->last_orb = &cmd->command_orb;
1675 lu->last_orb_dma = cmd->command_orb_dma;
1676 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
Stefan Richter138c8af2006-11-02 21:16:08 +01001678 if (sbp2util_node_write_no_wait(lu->ne, addr, data, length)) {
Stefan Richter09ee67a2006-08-14 18:43:00 +02001679 /*
1680 * sbp2util_node_write_no_wait failed. We certainly ran out
1681 * of transaction labels, perhaps just because there were no
1682 * context switches which gave khpsbpkt a chance to collect
1683 * free tlabels. Try again in non-atomic context. If necessary,
1684 * the workqueue job will sleep to guaranteedly get a tlabel.
1685 * We do not accept new commands until the job is over.
1686 */
Stefan Richter138c8af2006-11-02 21:16:08 +01001687 scsi_block_requests(lu->shost);
1688 PREPARE_WORK(&lu->protocol_work,
Stefan Richter09ee67a2006-08-14 18:43:00 +02001689 last_orb ? sbp2util_write_doorbell:
Stefan Richterec9b7e12006-12-07 23:23:25 +01001690 sbp2util_write_orb_pointer);
Stefan Richter138c8af2006-11-02 21:16:08 +01001691 schedule_work(&lu->protocol_work);
Stefan Richter09ee67a2006-08-14 18:43:00 +02001692 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693}
1694
Stefan Richter138c8af2006-11-02 21:16:08 +01001695static int sbp2_send_command(struct sbp2_lu *lu, struct scsi_cmnd *SCpnt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 void (*done)(struct scsi_cmnd *))
1697{
Stefan Richter138c8af2006-11-02 21:16:08 +01001698 struct sbp2_command_info *cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699
Stefan Richter138c8af2006-11-02 21:16:08 +01001700 cmd = sbp2util_allocate_command_orb(lu, SCpnt, done);
1701 if (!cmd)
Stefan Richtera237f352005-11-07 06:31:39 -05001702 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001704 if (sbp2_create_command_orb(lu, cmd, SCpnt))
1705 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706
Stefan Richtercd8c79f2008-08-09 20:16:24 +02001707 sbp2_link_orb_command(lu, cmd);
Stefan Richtera237f352005-11-07 06:31:39 -05001708 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709}
1710
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 * Translates SBP-2 status into SCSI sense data for check conditions
1713 */
Stefan Richter138c8af2006-11-02 21:16:08 +01001714static unsigned int sbp2_status_to_sense_data(unchar *sbp2_status,
1715 unchar *sense_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716{
Stefan Richtere8ca5662006-11-02 21:16:08 +01001717 /* OK, it's pretty ugly... ;-) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 sense_data[0] = 0x70;
1719 sense_data[1] = 0x0;
1720 sense_data[2] = sbp2_status[9];
1721 sense_data[3] = sbp2_status[12];
1722 sense_data[4] = sbp2_status[13];
1723 sense_data[5] = sbp2_status[14];
1724 sense_data[6] = sbp2_status[15];
1725 sense_data[7] = 10;
1726 sense_data[8] = sbp2_status[16];
1727 sense_data[9] = sbp2_status[17];
1728 sense_data[10] = sbp2_status[18];
1729 sense_data[11] = sbp2_status[19];
1730 sense_data[12] = sbp2_status[10];
1731 sense_data[13] = sbp2_status[11];
1732 sense_data[14] = sbp2_status[20];
1733 sense_data[15] = sbp2_status[21];
1734
Stefan Richtere8ca5662006-11-02 21:16:08 +01001735 return sbp2_status[8] & 0x3f;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736}
1737
Stefan Richter3e98eab42006-07-23 22:16:00 +02001738static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid,
1739 int destid, quadlet_t *data, u64 addr,
1740 size_t length, u16 fl)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741{
Stefan Richterca0c7452006-11-02 21:16:08 +01001742 struct sbp2_fwhost_info *hi;
Stefan Richter138c8af2006-11-02 21:16:08 +01001743 struct sbp2_lu *lu = NULL, *lu_tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 struct scsi_cmnd *SCpnt = NULL;
Stefan Richter3e98eab42006-07-23 22:16:00 +02001745 struct sbp2_status_block *sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 u32 scsi_status = SBP2_SCSI_STATUS_GOOD;
Stefan Richter138c8af2006-11-02 21:16:08 +01001747 struct sbp2_command_info *cmd;
Jody McIntyre79456192005-11-07 06:29:39 -05001748 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749
Stefan Richter60657722006-07-23 22:18:00 +02001750 if (unlikely(length < 8 || length > sizeof(struct sbp2_status_block))) {
1751 SBP2_ERR("Wrong size of status block");
1752 return RCODE_ADDRESS_ERROR;
1753 }
1754 if (unlikely(!host)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 SBP2_ERR("host is NULL - this is bad!");
Stefan Richtera237f352005-11-07 06:31:39 -05001756 return RCODE_ADDRESS_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 hi = hpsb_get_hostinfo(&sbp2_highlevel, host);
Stefan Richter60657722006-07-23 22:18:00 +02001759 if (unlikely(!hi)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 SBP2_ERR("host info is NULL - this is bad!");
Stefan Richtera237f352005-11-07 06:31:39 -05001761 return RCODE_ADDRESS_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 }
Stefan Richtere8ca5662006-11-02 21:16:08 +01001763
1764 /* Find the unit which wrote the status. */
Stefan Richter261b5f62007-08-11 11:52:08 +02001765 read_lock_irqsave(&sbp2_hi_logical_units_lock, flags);
Stefan Richter138c8af2006-11-02 21:16:08 +01001766 list_for_each_entry(lu_tmp, &hi->logical_units, lu_list) {
1767 if (lu_tmp->ne->nodeid == nodeid &&
1768 lu_tmp->status_fifo_addr == addr) {
1769 lu = lu_tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 break;
1771 }
1772 }
Stefan Richter261b5f62007-08-11 11:52:08 +02001773 read_unlock_irqrestore(&sbp2_hi_logical_units_lock, flags);
1774
Stefan Richter138c8af2006-11-02 21:16:08 +01001775 if (unlikely(!lu)) {
1776 SBP2_ERR("lu is NULL - device is gone?");
Stefan Richtera237f352005-11-07 06:31:39 -05001777 return RCODE_ADDRESS_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 }
1779
Stefan Richter138c8af2006-11-02 21:16:08 +01001780 /* Put response into lu status fifo buffer. The first two bytes
Stefan Richter3e98eab42006-07-23 22:16:00 +02001781 * come in big endian bit order. Often the target writes only a
1782 * truncated status block, minimally the first two quadlets. The rest
Stefan Richtere8ca5662006-11-02 21:16:08 +01001783 * is implied to be zeros. */
Stefan Richter138c8af2006-11-02 21:16:08 +01001784 sb = &lu->status_block;
Stefan Richter3e98eab42006-07-23 22:16:00 +02001785 memset(sb->command_set_dependent, 0, sizeof(sb->command_set_dependent));
1786 memcpy(sb, data, length);
1787 sbp2util_be32_to_cpu_buffer(sb, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788
Stefan Richtere8ca5662006-11-02 21:16:08 +01001789 /* Ignore unsolicited status. Handle command ORB status. */
Stefan Richter60657722006-07-23 22:18:00 +02001790 if (unlikely(STATUS_GET_SRC(sb->ORB_offset_hi_misc) == 2))
Stefan Richter138c8af2006-11-02 21:16:08 +01001791 cmd = NULL;
Stefan Richter60657722006-07-23 22:18:00 +02001792 else
Stefan Richter138c8af2006-11-02 21:16:08 +01001793 cmd = sbp2util_find_command_for_orb(lu, sb->ORB_offset_lo);
1794 if (cmd) {
Stefan Richtere8ca5662006-11-02 21:16:08 +01001795 /* Grab SCSI command pointers and check status. */
Stefan Richter60657722006-07-23 22:18:00 +02001796 /*
1797 * FIXME: If the src field in the status is 1, the ORB DMA must
1798 * not be reused until status for a subsequent ORB is received.
1799 */
Stefan Richter138c8af2006-11-02 21:16:08 +01001800 SCpnt = cmd->Current_SCpnt;
1801 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1802 sbp2util_mark_command_completed(lu, cmd);
1803 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804
1805 if (SCpnt) {
Stefan Richterabbca102006-08-14 18:51:00 +02001806 u32 h = sb->ORB_offset_hi_misc;
1807 u32 r = STATUS_GET_RESP(h);
1808
1809 if (r != RESP_STATUS_REQUEST_COMPLETE) {
Stefan Richter35644092006-11-02 21:16:08 +01001810 SBP2_INFO("resp 0x%x, sbp_status 0x%x",
Stefan Richterabbca102006-08-14 18:51:00 +02001811 r, STATUS_GET_SBP_STATUS(h));
Stefan Richter60657722006-07-23 22:18:00 +02001812 scsi_status =
Stefan Richterabbca102006-08-14 18:51:00 +02001813 r == RESP_STATUS_TRANSPORT_FAILURE ?
1814 SBP2_SCSI_STATUS_BUSY :
Stefan Richter60657722006-07-23 22:18:00 +02001815 SBP2_SCSI_STATUS_COMMAND_TERMINATED;
Stefan Richterabbca102006-08-14 18:51:00 +02001816 }
Stefan Richtere8ca5662006-11-02 21:16:08 +01001817
Stefan Richteredf1fb22006-11-02 21:16:08 +01001818 if (STATUS_GET_LEN(h) > 1)
Stefan Richter3e98eab42006-07-23 22:16:00 +02001819 scsi_status = sbp2_status_to_sense_data(
1820 (unchar *)sb, SCpnt->sense_buffer);
Stefan Richtere8ca5662006-11-02 21:16:08 +01001821
Stefan Richteredf1fb22006-11-02 21:16:08 +01001822 if (STATUS_TEST_DEAD(h))
Stefan Richter138c8af2006-11-02 21:16:08 +01001823 sbp2_agent_reset(lu, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 }
1825
Stefan Richtere8ca5662006-11-02 21:16:08 +01001826 /* Check here to see if there are no commands in-use. If there
Stefan Richtercc078182006-07-23 22:12:00 +02001827 * are none, we know that the fetch agent left the active state
1828 * _and_ that we did not reactivate it yet. Therefore clear
1829 * last_orb so that next time we write directly to the
1830 * ORB_POINTER register. That way the fetch agent does not need
Stefan Richtere8ca5662006-11-02 21:16:08 +01001831 * to refetch the next_ORB. */
Stefan Richter138c8af2006-11-02 21:16:08 +01001832 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1833 if (list_empty(&lu->cmd_orb_inuse))
1834 lu->last_orb = NULL;
1835 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836
1837 } else {
Stefan Richtere8ca5662006-11-02 21:16:08 +01001838 /* It's probably status after a management request. */
Stefan Richter138c8af2006-11-02 21:16:08 +01001839 if ((sb->ORB_offset_lo == lu->reconnect_orb_dma) ||
1840 (sb->ORB_offset_lo == lu->login_orb_dma) ||
1841 (sb->ORB_offset_lo == lu->query_logins_orb_dma) ||
1842 (sb->ORB_offset_lo == lu->logout_orb_dma)) {
1843 lu->access_complete = 1;
Stefan Richterca0c7452006-11-02 21:16:08 +01001844 wake_up_interruptible(&sbp2_access_wq);
Stefan Richtere8398bb2006-07-23 22:19:00 +02001845 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 }
1847
Stefan Richteredf1fb22006-11-02 21:16:08 +01001848 if (SCpnt)
Stefan Richter138c8af2006-11-02 21:16:08 +01001849 sbp2scsi_complete_command(lu, scsi_status, SCpnt,
1850 cmd->Current_done);
Stefan Richtera237f352005-11-07 06:31:39 -05001851 return RCODE_COMPLETE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852}
1853
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854/**************************************
1855 * SCSI interface related section
1856 **************************************/
1857
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858static int sbp2scsi_queuecommand(struct scsi_cmnd *SCpnt,
1859 void (*done)(struct scsi_cmnd *))
1860{
Stefan Richter138c8af2006-11-02 21:16:08 +01001861 struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
Stefan Richterca0c7452006-11-02 21:16:08 +01001862 struct sbp2_fwhost_info *hi;
Jody McIntyreabd559b2005-09-30 11:59:06 -07001863 int result = DID_NO_CONNECT << 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
Stefan Richter138c8af2006-11-02 21:16:08 +01001865 if (unlikely(!sbp2util_node_is_available(lu)))
Jody McIntyreabd559b2005-09-30 11:59:06 -07001866 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867
Stefan Richter138c8af2006-11-02 21:16:08 +01001868 hi = lu->hi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869
Stefan Richter5796aa72006-11-02 21:16:08 +01001870 if (unlikely(!hi)) {
Stefan Richterca0c7452006-11-02 21:16:08 +01001871 SBP2_ERR("sbp2_fwhost_info is NULL - this is bad!");
Jody McIntyreabd559b2005-09-30 11:59:06 -07001872 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 }
1874
Stefan Richtere8ca5662006-11-02 21:16:08 +01001875 /* Multiple units are currently represented to the SCSI core as separate
1876 * targets, not as one target with multiple LUs. Therefore return
1877 * selection time-out to any IO directed at non-zero LUNs. */
Stefan Richter5796aa72006-11-02 21:16:08 +01001878 if (unlikely(SCpnt->device->lun))
Jody McIntyreabd559b2005-09-30 11:59:06 -07001879 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880
Stefan Richter138c8af2006-11-02 21:16:08 +01001881 if (unlikely(!hpsb_node_entry_valid(lu->ne))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 SBP2_ERR("Bus reset in progress - rejecting command");
Jody McIntyreabd559b2005-09-30 11:59:06 -07001883 result = DID_BUS_BUSY << 16;
1884 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 }
1886
Stefan Richtere8ca5662006-11-02 21:16:08 +01001887 /* Bidirectional commands are not yet implemented,
1888 * and unknown transfer direction not handled. */
Stefan Richter5796aa72006-11-02 21:16:08 +01001889 if (unlikely(SCpnt->sc_data_direction == DMA_BIDIRECTIONAL)) {
Stefan Richter43863eb2005-12-12 23:03:24 -05001890 SBP2_ERR("Cannot handle DMA_BIDIRECTIONAL - rejecting command");
1891 result = DID_ERROR << 16;
1892 goto done;
1893 }
1894
Stefan Richter138c8af2006-11-02 21:16:08 +01001895 if (sbp2_send_command(lu, SCpnt, done)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 SBP2_ERR("Error sending SCSI command");
Stefan Richter138c8af2006-11-02 21:16:08 +01001897 sbp2scsi_complete_command(lu,
1898 SBP2_SCSI_STATUS_SELECTION_TIMEOUT,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 SCpnt, done);
1900 }
Jody McIntyreabd559b2005-09-30 11:59:06 -07001901 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902
Jody McIntyreabd559b2005-09-30 11:59:06 -07001903done:
1904 SCpnt->result = result;
1905 done(SCpnt);
1906 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907}
1908
Stefan Richter138c8af2006-11-02 21:16:08 +01001909static void sbp2scsi_complete_all_commands(struct sbp2_lu *lu, u32 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 struct list_head *lh;
Stefan Richter138c8af2006-11-02 21:16:08 +01001912 struct sbp2_command_info *cmd;
Jody McIntyre79456192005-11-07 06:29:39 -05001913 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914
Stefan Richter138c8af2006-11-02 21:16:08 +01001915 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1916 while (!list_empty(&lu->cmd_orb_inuse)) {
1917 lh = lu->cmd_orb_inuse.next;
1918 cmd = list_entry(lh, struct sbp2_command_info, list);
Stefan Richter138c8af2006-11-02 21:16:08 +01001919 sbp2util_mark_command_completed(lu, cmd);
1920 if (cmd->Current_SCpnt) {
1921 cmd->Current_SCpnt->result = status << 16;
1922 cmd->Current_done(cmd->Current_SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 }
1924 }
Stefan Richter138c8af2006-11-02 21:16:08 +01001925 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926
1927 return;
1928}
1929
1930/*
Stefan Richtere8ca5662006-11-02 21:16:08 +01001931 * Complete a regular SCSI command. Can be called in atomic context.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 */
Stefan Richter138c8af2006-11-02 21:16:08 +01001933static void sbp2scsi_complete_command(struct sbp2_lu *lu, u32 scsi_status,
1934 struct scsi_cmnd *SCpnt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 void (*done)(struct scsi_cmnd *))
1936{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 if (!SCpnt) {
1938 SBP2_ERR("SCpnt is NULL");
1939 return;
1940 }
1941
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 switch (scsi_status) {
Stefan Richtera237f352005-11-07 06:31:39 -05001943 case SBP2_SCSI_STATUS_GOOD:
Stefan Richter8f0525f2006-03-28 20:03:45 -05001944 SCpnt->result = DID_OK << 16;
Stefan Richtera237f352005-11-07 06:31:39 -05001945 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946
Stefan Richtera237f352005-11-07 06:31:39 -05001947 case SBP2_SCSI_STATUS_BUSY:
1948 SBP2_ERR("SBP2_SCSI_STATUS_BUSY");
1949 SCpnt->result = DID_BUS_BUSY << 16;
1950 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951
Stefan Richtera237f352005-11-07 06:31:39 -05001952 case SBP2_SCSI_STATUS_CHECK_CONDITION:
Stefan Richter8f0525f2006-03-28 20:03:45 -05001953 SCpnt->result = CHECK_CONDITION << 1 | DID_OK << 16;
Stefan Richtera237f352005-11-07 06:31:39 -05001954 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955
Stefan Richtera237f352005-11-07 06:31:39 -05001956 case SBP2_SCSI_STATUS_SELECTION_TIMEOUT:
1957 SBP2_ERR("SBP2_SCSI_STATUS_SELECTION_TIMEOUT");
1958 SCpnt->result = DID_NO_CONNECT << 16;
1959 scsi_print_command(SCpnt);
1960 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
Stefan Richtera237f352005-11-07 06:31:39 -05001962 case SBP2_SCSI_STATUS_CONDITION_MET:
1963 case SBP2_SCSI_STATUS_RESERVATION_CONFLICT:
1964 case SBP2_SCSI_STATUS_COMMAND_TERMINATED:
1965 SBP2_ERR("Bad SCSI status = %x", scsi_status);
1966 SCpnt->result = DID_ERROR << 16;
1967 scsi_print_command(SCpnt);
1968 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969
Stefan Richtera237f352005-11-07 06:31:39 -05001970 default:
1971 SBP2_ERR("Unsupported SCSI status = %x", scsi_status);
1972 SCpnt->result = DID_ERROR << 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 }
1974
Stefan Richtere8ca5662006-11-02 21:16:08 +01001975 /* If a bus reset is in progress and there was an error, complete
1976 * the command as busy so that it will get retried. */
Stefan Richter138c8af2006-11-02 21:16:08 +01001977 if (!hpsb_node_entry_valid(lu->ne)
Stefan Richtera237f352005-11-07 06:31:39 -05001978 && (scsi_status != SBP2_SCSI_STATUS_GOOD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 SBP2_ERR("Completing command with busy (bus reset)");
1980 SCpnt->result = DID_BUS_BUSY << 16;
1981 }
1982
Stefan Richtere8ca5662006-11-02 21:16:08 +01001983 /* Tell the SCSI stack that we're done with this command. */
Stefan Richtera237f352005-11-07 06:31:39 -05001984 done(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985}
1986
Jody McIntyreabd559b2005-09-30 11:59:06 -07001987static int sbp2scsi_slave_alloc(struct scsi_device *sdev)
1988{
Stefan Richter138c8af2006-11-02 21:16:08 +01001989 struct sbp2_lu *lu = (struct sbp2_lu *)sdev->host->hostdata[0];
Stefan Richtera80614d2006-02-14 22:04:19 -05001990
Stefan Richteref774c12008-02-17 14:57:10 +01001991 if (sdev->lun != 0 || sdev->id != lu->ud->id || sdev->channel != 0)
1992 return -ENODEV;
1993
Stefan Richter138c8af2006-11-02 21:16:08 +01001994 lu->sdev = sdev;
Stefan Richterc394f1e2006-08-07 20:48:00 +02001995 sdev->allow_restart = 1;
Stefan Richtera80614d2006-02-14 22:04:19 -05001996
Stefan Richtera4b47d62008-01-27 22:32:22 +01001997 /* SBP-2 requires quadlet alignment of the data buffers. */
1998 blk_queue_update_dma_alignment(sdev->request_queue, 4 - 1);
James Bottomley465ff312008-01-01 10:00:10 -06001999
Stefan Richter138c8af2006-11-02 21:16:08 +01002000 if (lu->workarounds & SBP2_WORKAROUND_INQUIRY_36)
Stefan Richtera80614d2006-02-14 22:04:19 -05002001 sdev->inquiry_len = 36;
Jody McIntyreabd559b2005-09-30 11:59:06 -07002002 return 0;
2003}
2004
Jody McIntyreabd559b2005-09-30 11:59:06 -07002005static int sbp2scsi_slave_configure(struct scsi_device *sdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006{
Stefan Richter138c8af2006-11-02 21:16:08 +01002007 struct sbp2_lu *lu = (struct sbp2_lu *)sdev->host->hostdata[0];
Stefan Richter24d3bf82006-05-15 22:04:59 +02002008
Ben Collins365c7862005-11-07 06:31:24 -05002009 sdev->use_10_for_rw = 1;
Stefan Richter24d3bf82006-05-15 22:04:59 +02002010
Stefan Richter82f06e82008-05-11 00:37:14 +02002011 if (sbp2_exclusive_login)
2012 sdev->manage_start_stop = 1;
Stefan Richter1a74bc62007-01-10 20:17:15 +01002013 if (sdev->type == TYPE_ROM)
2014 sdev->use_10_for_ms = 1;
Stefan Richter24d3bf82006-05-15 22:04:59 +02002015 if (sdev->type == TYPE_DISK &&
Stefan Richter138c8af2006-11-02 21:16:08 +01002016 lu->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
Stefan Richter24d3bf82006-05-15 22:04:59 +02002017 sdev->skip_ms_page_8 = 1;
Stefan Richter138c8af2006-11-02 21:16:08 +01002018 if (lu->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
Stefan Richtere9a1c522006-05-15 22:06:37 +02002019 sdev->fix_capacity = 1;
Stefan Richter37191222008-05-11 00:35:55 +02002020 if (lu->workarounds & SBP2_WORKAROUND_POWER_CONDITION)
2021 sdev->start_stop_pwr_cond = 1;
Stefan Richter4e6343a2007-12-16 17:31:26 +01002022 if (lu->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
2023 blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
Stefan Richtered6ffd02008-08-14 09:28:14 +02002024
2025 blk_queue_max_segment_size(sdev->request_queue, SBP2_MAX_SEG_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 return 0;
2027}
2028
Jody McIntyreabd559b2005-09-30 11:59:06 -07002029static void sbp2scsi_slave_destroy(struct scsi_device *sdev)
2030{
Stefan Richter138c8af2006-11-02 21:16:08 +01002031 ((struct sbp2_lu *)sdev->host->hostdata[0])->sdev = NULL;
Jody McIntyreabd559b2005-09-30 11:59:06 -07002032 return;
2033}
2034
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035/*
Stefan Richtere8ca5662006-11-02 21:16:08 +01002036 * Called by scsi stack when something has really gone wrong.
2037 * Usually called when a command has timed-out for some reason.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 */
2039static int sbp2scsi_abort(struct scsi_cmnd *SCpnt)
2040{
Stefan Richter138c8af2006-11-02 21:16:08 +01002041 struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
Stefan Richter138c8af2006-11-02 21:16:08 +01002042 struct sbp2_command_info *cmd;
Stefan Richter24c7cd02006-04-01 21:11:41 +02002043 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044
Stefan Richter35644092006-11-02 21:16:08 +01002045 SBP2_INFO("aborting sbp2 command");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046 scsi_print_command(SCpnt);
2047
Stefan Richter138c8af2006-11-02 21:16:08 +01002048 if (sbp2util_node_is_available(lu)) {
2049 sbp2_agent_reset(lu, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050
Stefan Richter23077f12006-09-11 20:17:14 +02002051 /* Return a matching command structure to the free pool. */
Stefan Richter138c8af2006-11-02 21:16:08 +01002052 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
2053 cmd = sbp2util_find_command_for_SCpnt(lu, SCpnt);
2054 if (cmd) {
Stefan Richter138c8af2006-11-02 21:16:08 +01002055 sbp2util_mark_command_completed(lu, cmd);
2056 if (cmd->Current_SCpnt) {
2057 cmd->Current_SCpnt->result = DID_ABORT << 16;
2058 cmd->Current_done(cmd->Current_SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 }
2060 }
Stefan Richter138c8af2006-11-02 21:16:08 +01002061 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062
Stefan Richter138c8af2006-11-02 21:16:08 +01002063 sbp2scsi_complete_all_commands(lu, DID_BUS_BUSY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 }
2065
Stefan Richtera237f352005-11-07 06:31:39 -05002066 return SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067}
2068
2069/*
2070 * Called by scsi stack when something has really gone wrong.
2071 */
Jody McIntyreabd559b2005-09-30 11:59:06 -07002072static int sbp2scsi_reset(struct scsi_cmnd *SCpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073{
Stefan Richter138c8af2006-11-02 21:16:08 +01002074 struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075
Stefan Richter35644092006-11-02 21:16:08 +01002076 SBP2_INFO("reset requested");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077
Stefan Richter138c8af2006-11-02 21:16:08 +01002078 if (sbp2util_node_is_available(lu)) {
Stefan Richter35644092006-11-02 21:16:08 +01002079 SBP2_INFO("generating sbp2 fetch agent reset");
Stefan Richter138c8af2006-11-02 21:16:08 +01002080 sbp2_agent_reset(lu, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 }
2082
Jody McIntyreabd559b2005-09-30 11:59:06 -07002083 return SUCCESS;
Jeff Garzik 94d0e7b82005-05-28 07:55:48 -04002084}
2085
Stefan Richtera237f352005-11-07 06:31:39 -05002086static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev,
2087 struct device_attribute *attr,
2088 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089{
2090 struct scsi_device *sdev;
Stefan Richter138c8af2006-11-02 21:16:08 +01002091 struct sbp2_lu *lu;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092
2093 if (!(sdev = to_scsi_device(dev)))
2094 return 0;
2095
Stefan Richter138c8af2006-11-02 21:16:08 +01002096 if (!(lu = (struct sbp2_lu *)sdev->host->hostdata[0]))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 return 0;
2098
Stefan Richterd7794c82007-05-27 13:17:15 +02002099 if (sbp2_long_sysfs_ieee1394_id)
2100 return sprintf(buf, "%016Lx:%06x:%04x\n",
2101 (unsigned long long)lu->ne->guid,
2102 lu->ud->directory_id, ORB_SET_LUN(lu->lun));
2103 else
2104 return sprintf(buf, "%016Lx:%d:%d\n",
2105 (unsigned long long)lu->ne->guid,
2106 lu->ud->id, ORB_SET_LUN(lu->lun));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108
2109MODULE_AUTHOR("Ben Collins <bcollins@debian.org>");
2110MODULE_DESCRIPTION("IEEE-1394 SBP-2 protocol driver");
2111MODULE_SUPPORTED_DEVICE(SBP2_DEVICE_NAME);
2112MODULE_LICENSE("GPL");
2113
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114static int sbp2_module_init(void)
2115{
2116 int ret;
2117
Stefan Richterca0c7452006-11-02 21:16:08 +01002118 if (sbp2_serialize_io) {
2119 sbp2_shost_template.can_queue = 1;
2120 sbp2_shost_template.cmd_per_lun = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 }
2122
Stefan Richterca0c7452006-11-02 21:16:08 +01002123 sbp2_shost_template.max_sectors = sbp2_max_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 hpsb_register_highlevel(&sbp2_highlevel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 ret = hpsb_register_protocol(&sbp2_driver);
2127 if (ret) {
2128 SBP2_ERR("Failed to register protocol");
2129 hpsb_unregister_highlevel(&sbp2_highlevel);
2130 return ret;
2131 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 return 0;
2133}
2134
2135static void __exit sbp2_module_exit(void)
2136{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 hpsb_unregister_protocol(&sbp2_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 hpsb_unregister_highlevel(&sbp2_highlevel);
2139}
2140
2141module_init(sbp2_module_init);
2142module_exit(sbp2_module_exit);