blob: 62b4e47d0cc00bb19e58de01c3722c522bd2e55a [file] [log] [blame]
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001/*
2 * SBP2 driver (SCSI over IEEE1394)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05003 *
Kristian Høgsberg27a15e52007-02-06 14:49:39 -05004 * Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net>
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05005 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 */
20
Kristian Høgsbergc781c062007-05-07 20:33:32 -040021/*
22 * The basic structure of this driver is based on the old storage driver,
Kristian Høgsberg27a15e52007-02-06 14:49:39 -050023 * drivers/ieee1394/sbp2.c, originally written by
24 * James Goodwin <jamesg@filanet.com>
25 * with later contributions and ongoing maintenance from
26 * Ben Collins <bcollins@debian.org>,
27 * Stefan Richter <stefanr@s5r6.in-berlin.de>
28 * and many others.
29 */
30
Stefan Richter7bb6bf72008-02-03 23:12:17 +010031#include <linux/blkdev.h>
Stefan Richter9220f192008-02-03 23:04:38 +010032#include <linux/delay.h>
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -050033#include <linux/device.h>
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -050034#include <linux/dma-mapping.h>
Stefan Richter7bb6bf72008-02-03 23:12:17 +010035#include <linux/kernel.h>
36#include <linux/mod_devicetable.h>
37#include <linux/module.h>
38#include <linux/moduleparam.h>
39#include <linux/scatterlist.h>
Stefan Richtere7cdf232007-07-01 13:54:57 +020040#include <linux/string.h>
Stefan Richter2df222b2007-08-13 17:48:25 +020041#include <linux/stringify.h>
Kristian Høgsberg1d3d52c2007-02-06 14:49:33 -050042#include <linux/timer.h>
Stefan Richterdf8ec242007-08-12 12:51:18 +020043#include <linux/workqueue.h>
Stefan Richterb5d2a5e2008-01-25 18:57:41 +010044#include <asm/system.h>
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -050045
46#include <scsi/scsi.h>
47#include <scsi/scsi_cmnd.h>
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -050048#include <scsi/scsi_device.h>
49#include <scsi/scsi_host.h>
50
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -050051#include "fw-device.h"
Stefan Richter7bb6bf72008-02-03 23:12:17 +010052#include "fw-topology.h"
53#include "fw-transaction.h"
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -050054
Stefan Richter5cd54c92007-06-17 23:55:41 +020055/*
56 * So far only bridges from Oxford Semiconductor are known to support
57 * concurrent logins. Depending on firmware, four or two concurrent logins
58 * are possible on OXFW911 and newer Oxsemi bridges.
59 *
60 * Concurrent logins are useful together with cluster filesystems.
61 */
62static int sbp2_param_exclusive_login = 1;
63module_param_named(exclusive_login, sbp2_param_exclusive_login, bool, 0644);
64MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device "
65 "(default = Y, use N for concurrent initiators)");
66
Stefan Richter2df222b2007-08-13 17:48:25 +020067/*
68 * Flags for firmware oddities
69 *
70 * - 128kB max transfer
71 * Limit transfer size. Necessary for some old bridges.
72 *
73 * - 36 byte inquiry
74 * When scsi_mod probes the device, let the inquiry command look like that
75 * from MS Windows.
76 *
77 * - skip mode page 8
78 * Suppress sending of mode_sense for mode page 8 if the device pretends to
79 * support the SCSI Primary Block commands instead of Reduced Block Commands.
80 *
81 * - fix capacity
82 * Tell sd_mod to correct the last sector number reported by read_capacity.
83 * Avoids access beyond actual disk limits on devices with an off-by-one bug.
84 * Don't use this with devices which don't have this bug.
85 *
Stefan Richter9220f192008-02-03 23:04:38 +010086 * - delay inquiry
87 * Wait extra SBP2_INQUIRY_DELAY seconds after login before SCSI inquiry.
88 *
Stefan Richter2df222b2007-08-13 17:48:25 +020089 * - override internal blacklist
90 * Instead of adding to the built-in blacklist, use only the workarounds
91 * specified in the module load parameter.
92 * Useful if a blacklist entry interfered with a non-broken device.
93 */
94#define SBP2_WORKAROUND_128K_MAX_TRANS 0x1
95#define SBP2_WORKAROUND_INQUIRY_36 0x2
96#define SBP2_WORKAROUND_MODE_SENSE_8 0x4
97#define SBP2_WORKAROUND_FIX_CAPACITY 0x8
Stefan Richter9220f192008-02-03 23:04:38 +010098#define SBP2_WORKAROUND_DELAY_INQUIRY 0x10
99#define SBP2_INQUIRY_DELAY 12
Stefan Richter2df222b2007-08-13 17:48:25 +0200100#define SBP2_WORKAROUND_OVERRIDE 0x100
101
102static int sbp2_param_workarounds;
103module_param_named(workarounds, sbp2_param_workarounds, int, 0644);
104MODULE_PARM_DESC(workarounds, "Work around device bugs (default = 0"
105 ", 128kB max transfer = " __stringify(SBP2_WORKAROUND_128K_MAX_TRANS)
106 ", 36 byte inquiry = " __stringify(SBP2_WORKAROUND_INQUIRY_36)
107 ", skip mode page 8 = " __stringify(SBP2_WORKAROUND_MODE_SENSE_8)
108 ", fix capacity = " __stringify(SBP2_WORKAROUND_FIX_CAPACITY)
Stefan Richter9220f192008-02-03 23:04:38 +0100109 ", delay inquiry = " __stringify(SBP2_WORKAROUND_DELAY_INQUIRY)
Stefan Richter2df222b2007-08-13 17:48:25 +0200110 ", override internal blacklist = " __stringify(SBP2_WORKAROUND_OVERRIDE)
111 ", or a combination)");
112
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500113/* I don't know why the SCSI stack doesn't define something like this... */
Kristian Høgsberga98e2712007-05-07 20:33:34 -0400114typedef void (*scsi_done_fn_t)(struct scsi_cmnd *);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500115
116static const char sbp2_driver_name[] = "sbp2";
117
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200118/*
119 * We create one struct sbp2_logical_unit per SBP-2 Logical Unit Number Entry
120 * and one struct scsi_device per sbp2_logical_unit.
121 */
122struct sbp2_logical_unit {
123 struct sbp2_target *tgt;
124 struct list_head link;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500125 struct fw_address_handler address_handler;
126 struct list_head orb_list;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200127
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500128 u64 command_block_agent_address;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200129 u16 lun;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500130 int login_id;
131
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400132 /*
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200133 * The generation is updated once we've logged in or reconnected
134 * to the logical unit. Thus, I/O to the device will automatically
135 * fail and get retried if it happens in a window where the device
136 * is not ready, e.g. after a bus reset but before we reconnect.
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400137 */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500138 int generation;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500139 int retries;
140 struct delayed_work work;
Stefan Richterf8436152008-02-26 23:30:02 +0100141 bool has_sdev;
Stefan Richter2e2705b2008-02-16 16:37:28 +0100142 bool blocked;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500143};
144
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200145/*
146 * We create one struct sbp2_target per IEEE 1212 Unit Directory
147 * and one struct Scsi_Host per sbp2_target.
148 */
149struct sbp2_target {
150 struct kref kref;
151 struct fw_unit *unit;
Stefan Richter48f18c72008-02-03 23:09:50 +0100152 const char *bus_id;
Stefan Richter05cca732008-01-26 17:42:45 +0100153 struct list_head lu_list;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200154
155 u64 management_agent_address;
156 int directory_id;
157 int node_id;
158 int address_high;
Stefan Richter05cca732008-01-26 17:42:45 +0100159 unsigned int workarounds;
Jarod Wilson384170d2008-01-25 23:31:12 -0500160 unsigned int mgt_orb_timeout;
Stefan Richter2e2705b2008-02-16 16:37:28 +0100161
162 int dont_block; /* counter for each logical unit */
163 int blocked; /* ditto */
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200164};
165
Jarod Wilsona4c379c2008-01-19 13:15:05 +0100166/*
167 * Per section 7.4.8 of the SBP-2 spec, a mgt_ORB_timeout value can be
Jarod Wilson384170d2008-01-25 23:31:12 -0500168 * provided in the config rom. Most devices do provide a value, which
169 * we'll use for login management orbs, but with some sane limits.
Jarod Wilsona4c379c2008-01-19 13:15:05 +0100170 */
Jarod Wilson384170d2008-01-25 23:31:12 -0500171#define SBP2_MIN_LOGIN_ORB_TIMEOUT 5000U /* Timeout in ms */
172#define SBP2_MAX_LOGIN_ORB_TIMEOUT 40000U /* Timeout in ms */
Stefan Richter05cca732008-01-26 17:42:45 +0100173#define SBP2_ORB_TIMEOUT 2000U /* Timeout in ms */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500174#define SBP2_ORB_NULL 0x80000000
Jarod Wilsona4c379c2008-01-19 13:15:05 +0100175#define SBP2_MAX_SG_ELEMENT_LENGTH 0xf000
Jarod Wilson51f9dbe2008-03-07 01:43:01 -0500176#define SBP2_RETRY_LIMIT 0xf /* 15 retries */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500177
178#define SBP2_DIRECTION_TO_MEDIA 0x0
179#define SBP2_DIRECTION_FROM_MEDIA 0x1
180
181/* Unit directory keys */
Jarod Wilson384170d2008-01-25 23:31:12 -0500182#define SBP2_CSR_UNIT_CHARACTERISTICS 0x3a
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200183#define SBP2_CSR_FIRMWARE_REVISION 0x3c
184#define SBP2_CSR_LOGICAL_UNIT_NUMBER 0x14
185#define SBP2_CSR_LOGICAL_UNIT_DIRECTORY 0xd4
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500186
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500187/* Management orb opcodes */
188#define SBP2_LOGIN_REQUEST 0x0
189#define SBP2_QUERY_LOGINS_REQUEST 0x1
190#define SBP2_RECONNECT_REQUEST 0x3
191#define SBP2_SET_PASSWORD_REQUEST 0x4
192#define SBP2_LOGOUT_REQUEST 0x7
193#define SBP2_ABORT_TASK_REQUEST 0xb
194#define SBP2_ABORT_TASK_SET 0xc
195#define SBP2_LOGICAL_UNIT_RESET 0xe
196#define SBP2_TARGET_RESET_REQUEST 0xf
197
198/* Offsets for command block agent registers */
199#define SBP2_AGENT_STATE 0x00
200#define SBP2_AGENT_RESET 0x04
201#define SBP2_ORB_POINTER 0x08
202#define SBP2_DOORBELL 0x10
203#define SBP2_UNSOLICITED_STATUS_ENABLE 0x14
204
205/* Status write response codes */
206#define SBP2_STATUS_REQUEST_COMPLETE 0x0
207#define SBP2_STATUS_TRANSPORT_FAILURE 0x1
208#define SBP2_STATUS_ILLEGAL_REQUEST 0x2
209#define SBP2_STATUS_VENDOR_DEPENDENT 0x3
210
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400211#define STATUS_GET_ORB_HIGH(v) ((v).status & 0xffff)
212#define STATUS_GET_SBP_STATUS(v) (((v).status >> 16) & 0xff)
213#define STATUS_GET_LEN(v) (((v).status >> 24) & 0x07)
214#define STATUS_GET_DEAD(v) (((v).status >> 27) & 0x01)
215#define STATUS_GET_RESPONSE(v) (((v).status >> 28) & 0x03)
216#define STATUS_GET_SOURCE(v) (((v).status >> 30) & 0x03)
217#define STATUS_GET_ORB_LOW(v) ((v).orb_low)
218#define STATUS_GET_DATA(v) ((v).data)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500219
220struct sbp2_status {
221 u32 status;
222 u32 orb_low;
223 u8 data[24];
224};
225
226struct sbp2_pointer {
227 u32 high;
228 u32 low;
229};
230
231struct sbp2_orb {
232 struct fw_transaction t;
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400233 struct kref kref;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500234 dma_addr_t request_bus;
235 int rcode;
236 struct sbp2_pointer pointer;
Kristian Høgsberga98e2712007-05-07 20:33:34 -0400237 void (*callback)(struct sbp2_orb * orb, struct sbp2_status * status);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500238 struct list_head link;
239};
240
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400241#define MANAGEMENT_ORB_LUN(v) ((v))
242#define MANAGEMENT_ORB_FUNCTION(v) ((v) << 16)
243#define MANAGEMENT_ORB_RECONNECT(v) ((v) << 20)
Stefan Richter5cd54c92007-06-17 23:55:41 +0200244#define MANAGEMENT_ORB_EXCLUSIVE(v) ((v) ? 1 << 28 : 0)
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400245#define MANAGEMENT_ORB_REQUEST_FORMAT(v) ((v) << 29)
246#define MANAGEMENT_ORB_NOTIFY ((1) << 31)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500247
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400248#define MANAGEMENT_ORB_RESPONSE_LENGTH(v) ((v))
249#define MANAGEMENT_ORB_PASSWORD_LENGTH(v) ((v) << 16)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500250
251struct sbp2_management_orb {
252 struct sbp2_orb base;
253 struct {
254 struct sbp2_pointer password;
255 struct sbp2_pointer response;
256 u32 misc;
257 u32 length;
258 struct sbp2_pointer status_fifo;
259 } request;
260 __be32 response[4];
261 dma_addr_t response_bus;
262 struct completion done;
263 struct sbp2_status status;
264};
265
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400266#define LOGIN_RESPONSE_GET_LOGIN_ID(v) ((v).misc & 0xffff)
267#define LOGIN_RESPONSE_GET_LENGTH(v) (((v).misc >> 16) & 0xffff)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500268
269struct sbp2_login_response {
270 u32 misc;
271 struct sbp2_pointer command_block_agent;
272 u32 reconnect_hold;
273};
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400274#define COMMAND_ORB_DATA_SIZE(v) ((v))
275#define COMMAND_ORB_PAGE_SIZE(v) ((v) << 16)
276#define COMMAND_ORB_PAGE_TABLE_PRESENT ((1) << 19)
277#define COMMAND_ORB_MAX_PAYLOAD(v) ((v) << 20)
278#define COMMAND_ORB_SPEED(v) ((v) << 24)
279#define COMMAND_ORB_DIRECTION(v) ((v) << 27)
280#define COMMAND_ORB_REQUEST_FORMAT(v) ((v) << 29)
281#define COMMAND_ORB_NOTIFY ((1) << 31)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500282
283struct sbp2_command_orb {
284 struct sbp2_orb base;
285 struct {
286 struct sbp2_pointer next;
287 struct sbp2_pointer data_descriptor;
288 u32 misc;
289 u8 command_block[12];
290 } request;
291 struct scsi_cmnd *cmd;
292 scsi_done_fn_t done;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200293 struct sbp2_logical_unit *lu;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500294
Stefan Richter9fb2dd12007-07-01 13:55:31 +0200295 struct sbp2_pointer page_table[SG_ALL] __attribute__((aligned(8)));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500296 dma_addr_t page_table_bus;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500297};
298
299/*
300 * List of devices with known bugs.
301 *
302 * The firmware_revision field, masked with 0xffff00, is the best
303 * indicator for the type of bridge chip of a device. It yields a few
304 * false positives but this did not break correctly behaving devices
305 * so far. We use ~0 as a wildcard, since the 24 bit values we get
306 * from the config rom can never match that.
307 */
308static const struct {
309 u32 firmware_revision;
310 u32 model;
Stefan Richter05cca732008-01-26 17:42:45 +0100311 unsigned int workarounds;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500312} sbp2_workarounds_table[] = {
313 /* DViCO Momobay CX-1 with TSB42AA9 bridge */ {
314 .firmware_revision = 0x002800,
315 .model = 0x001010,
316 .workarounds = SBP2_WORKAROUND_INQUIRY_36 |
317 SBP2_WORKAROUND_MODE_SENSE_8,
318 },
Stefan Richter9220f192008-02-03 23:04:38 +0100319 /* DViCO Momobay FX-3A with TSB42AA9A bridge */ {
320 .firmware_revision = 0x002800,
321 .model = 0x000000,
322 .workarounds = SBP2_WORKAROUND_DELAY_INQUIRY,
323 },
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500324 /* Initio bridges, actually only needed for some older ones */ {
325 .firmware_revision = 0x000200,
326 .model = ~0,
327 .workarounds = SBP2_WORKAROUND_INQUIRY_36,
328 },
329 /* Symbios bridge */ {
330 .firmware_revision = 0xa0b800,
331 .model = ~0,
332 .workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
333 },
Stefan Richter2aa9ff72008-03-11 22:32:03 +0100334 /* Datafab MD2-FW2 with Symbios/LSILogic SYM13FW500 bridge */ {
335 .firmware_revision = 0x002600,
336 .model = ~0,
337 .workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
338 },
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400339
340 /*
341 * There are iPods (2nd gen, 3rd gen) with model_id == 0, but
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500342 * these iPods do not feature the read_capacity bug according
343 * to one report. Read_capacity behaviour as well as model_id
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400344 * could change due to Apple-supplied firmware updates though.
345 */
346
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500347 /* iPod 4th generation. */ {
348 .firmware_revision = 0x0a2700,
349 .model = 0x000021,
350 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
351 },
352 /* iPod mini */ {
353 .firmware_revision = 0x0a2700,
354 .model = 0x000023,
355 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
356 },
357 /* iPod Photo */ {
358 .firmware_revision = 0x0a2700,
359 .model = 0x00007e,
360 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
361 }
362};
363
364static void
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400365free_orb(struct kref *kref)
366{
367 struct sbp2_orb *orb = container_of(kref, struct sbp2_orb, kref);
368
369 kfree(orb);
370}
371
372static void
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500373sbp2_status_write(struct fw_card *card, struct fw_request *request,
374 int tcode, int destination, int source,
375 int generation, int speed,
376 unsigned long long offset,
377 void *payload, size_t length, void *callback_data)
378{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200379 struct sbp2_logical_unit *lu = callback_data;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500380 struct sbp2_orb *orb;
381 struct sbp2_status status;
382 size_t header_size;
383 unsigned long flags;
384
385 if (tcode != TCODE_WRITE_BLOCK_REQUEST ||
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400386 length == 0 || length > sizeof(status)) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500387 fw_send_response(card, request, RCODE_TYPE_ERROR);
388 return;
389 }
390
391 header_size = min(length, 2 * sizeof(u32));
392 fw_memcpy_from_be32(&status, payload, header_size);
393 if (length > header_size)
394 memcpy(status.data, payload + 8, length - header_size);
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400395 if (STATUS_GET_SOURCE(status) == 2 || STATUS_GET_SOURCE(status) == 3) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500396 fw_notify("non-orb related status write, not handled\n");
397 fw_send_response(card, request, RCODE_COMPLETE);
398 return;
399 }
400
401 /* Lookup the orb corresponding to this status write. */
402 spin_lock_irqsave(&card->lock, flags);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200403 list_for_each_entry(orb, &lu->orb_list, link) {
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400404 if (STATUS_GET_ORB_HIGH(status) == 0 &&
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400405 STATUS_GET_ORB_LOW(status) == orb->request_bus) {
406 orb->rcode = RCODE_COMPLETE;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500407 list_del(&orb->link);
408 break;
409 }
410 }
411 spin_unlock_irqrestore(&card->lock, flags);
412
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200413 if (&orb->link != &lu->orb_list)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500414 orb->callback(orb, &status);
415 else
416 fw_error("status write for unknown orb\n");
417
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400418 kref_put(&orb->kref, free_orb);
419
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500420 fw_send_response(card, request, RCODE_COMPLETE);
421}
422
423static void
424complete_transaction(struct fw_card *card, int rcode,
425 void *payload, size_t length, void *data)
426{
427 struct sbp2_orb *orb = data;
428 unsigned long flags;
429
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400430 /*
431 * This is a little tricky. We can get the status write for
432 * the orb before we get this callback. The status write
433 * handler above will assume the orb pointer transaction was
434 * successful and set the rcode to RCODE_COMPLETE for the orb.
435 * So this callback only sets the rcode if it hasn't already
436 * been set and only does the cleanup if the transaction
437 * failed and we didn't already get a status write.
438 */
439 spin_lock_irqsave(&card->lock, flags);
440
441 if (orb->rcode == -1)
442 orb->rcode = rcode;
443 if (orb->rcode != RCODE_COMPLETE) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500444 list_del(&orb->link);
Stefan Richter1b34e972007-08-25 10:40:42 +0200445 spin_unlock_irqrestore(&card->lock, flags);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500446 orb->callback(orb, NULL);
Stefan Richter1b34e972007-08-25 10:40:42 +0200447 } else {
448 spin_unlock_irqrestore(&card->lock, flags);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500449 }
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400450
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400451 kref_put(&orb->kref, free_orb);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500452}
453
454static void
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200455sbp2_send_orb(struct sbp2_orb *orb, struct sbp2_logical_unit *lu,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500456 int node_id, int generation, u64 offset)
457{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200458 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500459 unsigned long flags;
460
461 orb->pointer.high = 0;
462 orb->pointer.low = orb->request_bus;
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400463 fw_memcpy_to_be32(&orb->pointer, &orb->pointer, sizeof(orb->pointer));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500464
465 spin_lock_irqsave(&device->card->lock, flags);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200466 list_add_tail(&orb->link, &lu->orb_list);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500467 spin_unlock_irqrestore(&device->card->lock, flags);
468
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400469 /* Take a ref for the orb list and for the transaction callback. */
470 kref_get(&orb->kref);
471 kref_get(&orb->kref);
472
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500473 fw_send_request(device->card, &orb->t, TCODE_WRITE_BLOCK_REQUEST,
Stefan Richterf1397492007-06-10 21:31:36 +0200474 node_id, generation, device->max_speed, offset,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400475 &orb->pointer, sizeof(orb->pointer),
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500476 complete_transaction, orb);
477}
478
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200479static int sbp2_cancel_orbs(struct sbp2_logical_unit *lu)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500480{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200481 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500482 struct sbp2_orb *orb, *next;
483 struct list_head list;
484 unsigned long flags;
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500485 int retval = -ENOENT;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500486
487 INIT_LIST_HEAD(&list);
488 spin_lock_irqsave(&device->card->lock, flags);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200489 list_splice_init(&lu->orb_list, &list);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500490 spin_unlock_irqrestore(&device->card->lock, flags);
491
492 list_for_each_entry_safe(orb, next, &list, link) {
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500493 retval = 0;
Kristian Høgsberg730c32f2007-02-06 14:49:32 -0500494 if (fw_cancel_transaction(device->card, &orb->t) == 0)
495 continue;
496
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500497 orb->rcode = RCODE_CANCELLED;
498 orb->callback(orb, NULL);
499 }
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500500
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500501 return retval;
Kristian Høgsberg1d3d52c2007-02-06 14:49:33 -0500502}
503
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500504static void
505complete_management_orb(struct sbp2_orb *base_orb, struct sbp2_status *status)
506{
507 struct sbp2_management_orb *orb =
Jay Fenlason6f061482007-06-27 16:04:33 -0400508 container_of(base_orb, struct sbp2_management_orb, base);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500509
510 if (status)
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400511 memcpy(&orb->status, status, sizeof(*status));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500512 complete(&orb->done);
513}
514
515static int
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200516sbp2_send_management_orb(struct sbp2_logical_unit *lu, int node_id,
517 int generation, int function, int lun_or_login_id,
518 void *response)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500519{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200520 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500521 struct sbp2_management_orb *orb;
Jarod Wilsona4c379c2008-01-19 13:15:05 +0100522 unsigned int timeout;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500523 int retval = -ENOMEM;
524
Stefan Richterbe6f48b2008-01-27 19:14:44 +0100525 if (function == SBP2_LOGOUT_REQUEST && fw_device_is_shutdown(device))
526 return 0;
527
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400528 orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500529 if (orb == NULL)
530 return -ENOMEM;
531
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400532 kref_init(&orb->base.kref);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500533 orb->response_bus =
534 dma_map_single(device->card->device, &orb->response,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400535 sizeof(orb->response), DMA_FROM_DEVICE);
Kristian Høgsberg82eff9d2007-02-06 14:49:40 -0500536 if (dma_mapping_error(orb->response_bus))
Stefan Richter7aa48482007-07-02 21:04:44 +0200537 goto fail_mapping_response;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500538
539 orb->request.response.high = 0;
540 orb->request.response.low = orb->response_bus;
541
542 orb->request.misc =
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400543 MANAGEMENT_ORB_NOTIFY |
544 MANAGEMENT_ORB_FUNCTION(function) |
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200545 MANAGEMENT_ORB_LUN(lun_or_login_id);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500546 orb->request.length =
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400547 MANAGEMENT_ORB_RESPONSE_LENGTH(sizeof(orb->response));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500548
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200549 orb->request.status_fifo.high = lu->address_handler.offset >> 32;
550 orb->request.status_fifo.low = lu->address_handler.offset;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500551
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500552 if (function == SBP2_LOGIN_REQUEST) {
Stefan Richter14dc9922008-01-20 01:25:31 +0100553 /* Ask for 2^2 == 4 seconds reconnect grace period */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500554 orb->request.misc |=
Stefan Richter14dc9922008-01-20 01:25:31 +0100555 MANAGEMENT_ORB_RECONNECT(2) |
556 MANAGEMENT_ORB_EXCLUSIVE(sbp2_param_exclusive_login);
Jarod Wilson384170d2008-01-25 23:31:12 -0500557 timeout = lu->tgt->mgt_orb_timeout;
Jarod Wilsona4c379c2008-01-19 13:15:05 +0100558 } else {
559 timeout = SBP2_ORB_TIMEOUT;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500560 }
561
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400562 fw_memcpy_to_be32(&orb->request, &orb->request, sizeof(orb->request));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500563
564 init_completion(&orb->done);
565 orb->base.callback = complete_management_orb;
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500566
Stefan Richter7aa48482007-07-02 21:04:44 +0200567 orb->base.request_bus =
568 dma_map_single(device->card->device, &orb->request,
569 sizeof(orb->request), DMA_TO_DEVICE);
570 if (dma_mapping_error(orb->base.request_bus))
571 goto fail_mapping_request;
572
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200573 sbp2_send_orb(&orb->base, lu, node_id, generation,
574 lu->tgt->management_agent_address);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500575
Jarod Wilsona4c379c2008-01-19 13:15:05 +0100576 wait_for_completion_timeout(&orb->done, msecs_to_jiffies(timeout));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500577
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500578 retval = -EIO;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200579 if (sbp2_cancel_orbs(lu) == 0) {
Stefan Richter48f18c72008-02-03 23:09:50 +0100580 fw_error("%s: orb reply timed out, rcode=0x%02x\n",
581 lu->tgt->bus_id, orb->base.rcode);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500582 goto out;
583 }
584
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500585 if (orb->base.rcode != RCODE_COMPLETE) {
Stefan Richter48f18c72008-02-03 23:09:50 +0100586 fw_error("%s: management write failed, rcode 0x%02x\n",
587 lu->tgt->bus_id, orb->base.rcode);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500588 goto out;
589 }
590
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400591 if (STATUS_GET_RESPONSE(orb->status) != 0 ||
592 STATUS_GET_SBP_STATUS(orb->status) != 0) {
Stefan Richter48f18c72008-02-03 23:09:50 +0100593 fw_error("%s: error status: %d:%d\n", lu->tgt->bus_id,
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400594 STATUS_GET_RESPONSE(orb->status),
595 STATUS_GET_SBP_STATUS(orb->status));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500596 goto out;
597 }
598
599 retval = 0;
600 out:
601 dma_unmap_single(device->card->device, orb->base.request_bus,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400602 sizeof(orb->request), DMA_TO_DEVICE);
Stefan Richter7aa48482007-07-02 21:04:44 +0200603 fail_mapping_request:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500604 dma_unmap_single(device->card->device, orb->response_bus,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400605 sizeof(orb->response), DMA_FROM_DEVICE);
Stefan Richter7aa48482007-07-02 21:04:44 +0200606 fail_mapping_response:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500607 if (response)
608 fw_memcpy_from_be32(response,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400609 orb->response, sizeof(orb->response));
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400610 kref_put(&orb->base.kref, free_orb);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500611
612 return retval;
613}
614
615static void
616complete_agent_reset_write(struct fw_card *card, int rcode,
Stefan Richtere0e60212008-02-03 23:08:58 +0100617 void *payload, size_t length, void *done)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500618{
Stefan Richtere0e60212008-02-03 23:08:58 +0100619 complete(done);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500620}
621
Stefan Richtere0e60212008-02-03 23:08:58 +0100622static void sbp2_agent_reset(struct sbp2_logical_unit *lu)
623{
624 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
625 DECLARE_COMPLETION_ONSTACK(done);
626 struct fw_transaction t;
627 static u32 z;
628
629 fw_send_request(device->card, &t, TCODE_WRITE_QUADLET_REQUEST,
630 lu->tgt->node_id, lu->generation, device->max_speed,
631 lu->command_block_agent_address + SBP2_AGENT_RESET,
632 &z, sizeof(z), complete_agent_reset_write, &done);
633 wait_for_completion(&done);
634}
635
636static void
637complete_agent_reset_write_no_wait(struct fw_card *card, int rcode,
638 void *payload, size_t length, void *data)
639{
640 kfree(data);
641}
642
643static void sbp2_agent_reset_no_wait(struct sbp2_logical_unit *lu)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500644{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200645 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500646 struct fw_transaction *t;
Stefan Richtere0e60212008-02-03 23:08:58 +0100647 static u32 z;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500648
Stefan Richtere0e60212008-02-03 23:08:58 +0100649 t = kmalloc(sizeof(*t), GFP_ATOMIC);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500650 if (t == NULL)
Stefan Richtere0e60212008-02-03 23:08:58 +0100651 return;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500652
653 fw_send_request(device->card, t, TCODE_WRITE_QUADLET_REQUEST,
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200654 lu->tgt->node_id, lu->generation, device->max_speed,
655 lu->command_block_agent_address + SBP2_AGENT_RESET,
Stefan Richtere0e60212008-02-03 23:08:58 +0100656 &z, sizeof(z), complete_agent_reset_write_no_wait, t);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500657}
658
Stefan Richter2e2705b2008-02-16 16:37:28 +0100659static void sbp2_set_generation(struct sbp2_logical_unit *lu, int generation)
660{
661 struct fw_card *card = fw_device(lu->tgt->unit->device.parent)->card;
662 unsigned long flags;
663
664 /* serialize with comparisons of lu->generation and card->generation */
665 spin_lock_irqsave(&card->lock, flags);
666 lu->generation = generation;
667 spin_unlock_irqrestore(&card->lock, flags);
668}
669
670static inline void sbp2_allow_block(struct sbp2_logical_unit *lu)
671{
672 /*
673 * We may access dont_block without taking card->lock here:
674 * All callers of sbp2_allow_block() and all callers of sbp2_unblock()
675 * are currently serialized against each other.
676 * And a wrong result in sbp2_conditionally_block()'s access of
677 * dont_block is rather harmless, it simply misses its first chance.
678 */
679 --lu->tgt->dont_block;
680}
681
682/*
683 * Blocks lu->tgt if all of the following conditions are met:
684 * - Login, INQUIRY, and high-level SCSI setup of all of the target's
685 * logical units have been finished (indicated by dont_block == 0).
686 * - lu->generation is stale.
687 *
688 * Note, scsi_block_requests() must be called while holding card->lock,
689 * otherwise it might foil sbp2_[conditionally_]unblock()'s attempt to
690 * unblock the target.
691 */
692static void sbp2_conditionally_block(struct sbp2_logical_unit *lu)
693{
694 struct sbp2_target *tgt = lu->tgt;
695 struct fw_card *card = fw_device(tgt->unit->device.parent)->card;
696 struct Scsi_Host *shost =
697 container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
698 unsigned long flags;
699
700 spin_lock_irqsave(&card->lock, flags);
701 if (!tgt->dont_block && !lu->blocked &&
702 lu->generation != card->generation) {
703 lu->blocked = true;
704 if (++tgt->blocked == 1) {
705 scsi_block_requests(shost);
706 fw_notify("blocked %s\n", lu->tgt->bus_id);
707 }
708 }
709 spin_unlock_irqrestore(&card->lock, flags);
710}
711
712/*
713 * Unblocks lu->tgt as soon as all its logical units can be unblocked.
714 * Note, it is harmless to run scsi_unblock_requests() outside the
715 * card->lock protected section. On the other hand, running it inside
716 * the section might clash with shost->host_lock.
717 */
718static void sbp2_conditionally_unblock(struct sbp2_logical_unit *lu)
719{
720 struct sbp2_target *tgt = lu->tgt;
721 struct fw_card *card = fw_device(tgt->unit->device.parent)->card;
722 struct Scsi_Host *shost =
723 container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
724 unsigned long flags;
725 bool unblock = false;
726
727 spin_lock_irqsave(&card->lock, flags);
728 if (lu->blocked && lu->generation == card->generation) {
729 lu->blocked = false;
730 unblock = --tgt->blocked == 0;
731 }
732 spin_unlock_irqrestore(&card->lock, flags);
733
734 if (unblock) {
735 scsi_unblock_requests(shost);
736 fw_notify("unblocked %s\n", lu->tgt->bus_id);
737 }
738}
739
740/*
741 * Prevents future blocking of tgt and unblocks it.
742 * Note, it is harmless to run scsi_unblock_requests() outside the
743 * card->lock protected section. On the other hand, running it inside
744 * the section might clash with shost->host_lock.
745 */
746static void sbp2_unblock(struct sbp2_target *tgt)
747{
748 struct fw_card *card = fw_device(tgt->unit->device.parent)->card;
749 struct Scsi_Host *shost =
750 container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
751 unsigned long flags;
752
753 spin_lock_irqsave(&card->lock, flags);
754 ++tgt->dont_block;
755 spin_unlock_irqrestore(&card->lock, flags);
756
757 scsi_unblock_requests(shost);
758}
759
Stefan Richterf8436152008-02-26 23:30:02 +0100760static int sbp2_lun2int(u16 lun)
761{
762 struct scsi_lun eight_bytes_lun;
763
764 memset(&eight_bytes_lun, 0, sizeof(eight_bytes_lun));
765 eight_bytes_lun.scsi_lun[0] = (lun >> 8) & 0xff;
766 eight_bytes_lun.scsi_lun[1] = lun & 0xff;
767
768 return scsilun_to_int(&eight_bytes_lun);
769}
770
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200771static void sbp2_release_target(struct kref *kref)
Kristian Høgsbergb3d6e152007-03-14 17:34:58 -0400772{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200773 struct sbp2_target *tgt = container_of(kref, struct sbp2_target, kref);
774 struct sbp2_logical_unit *lu, *next;
775 struct Scsi_Host *shost =
776 container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
Stefan Richterf8436152008-02-26 23:30:02 +0100777 struct scsi_device *sdev;
Stefan Richter855c6032008-02-27 22:14:27 +0100778 struct fw_device *device = fw_device(tgt->unit->device.parent);
Kristian Høgsbergb3d6e152007-03-14 17:34:58 -0400779
Stefan Richter2e2705b2008-02-16 16:37:28 +0100780 /* prevent deadlocks */
781 sbp2_unblock(tgt);
782
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200783 list_for_each_entry_safe(lu, next, &tgt->lu_list, link) {
Stefan Richterf8436152008-02-26 23:30:02 +0100784 sdev = scsi_device_lookup(shost, 0, 0, sbp2_lun2int(lu->lun));
785 if (sdev) {
786 scsi_remove_device(sdev);
787 scsi_device_put(sdev);
Stefan Richter33f1c6c2008-02-19 09:05:49 +0100788 }
Stefan Richterbe6f48b2008-01-27 19:14:44 +0100789 sbp2_send_management_orb(lu, tgt->node_id, lu->generation,
790 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
Stefan Richter4dccd022008-01-20 01:24:26 +0100791
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200792 fw_core_remove_address_handler(&lu->address_handler);
793 list_del(&lu->link);
794 kfree(lu);
795 }
796 scsi_remove_host(shost);
Stefan Richter48f18c72008-02-03 23:09:50 +0100797 fw_notify("released %s\n", tgt->bus_id);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200798
799 put_device(&tgt->unit->device);
800 scsi_host_put(shost);
Stefan Richter855c6032008-02-27 22:14:27 +0100801 fw_device_put(device);
Kristian Høgsbergb3d6e152007-03-14 17:34:58 -0400802}
803
Stefan Richterdf8ec242007-08-12 12:51:18 +0200804static struct workqueue_struct *sbp2_wq;
805
Stefan Richter285838e2007-11-07 01:12:51 +0100806/*
807 * Always get the target's kref when scheduling work on one its units.
808 * Each workqueue job is responsible to call sbp2_target_put() upon return.
809 */
810static void sbp2_queue_work(struct sbp2_logical_unit *lu, unsigned long delay)
811{
812 if (queue_delayed_work(sbp2_wq, &lu->work, delay))
813 kref_get(&lu->tgt->kref);
814}
815
816static void sbp2_target_put(struct sbp2_target *tgt)
817{
818 kref_put(&tgt->kref, sbp2_release_target);
819}
820
Jarod Wilson51f9dbe2008-03-07 01:43:01 -0500821static void
822complete_set_busy_timeout(struct fw_card *card, int rcode,
823 void *payload, size_t length, void *done)
824{
825 complete(done);
826}
827
828static void sbp2_set_busy_timeout(struct sbp2_logical_unit *lu)
829{
830 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
831 DECLARE_COMPLETION_ONSTACK(done);
832 struct fw_transaction t;
833 static __be32 busy_timeout;
834
835 /* FIXME: we should try to set dual-phase cycle_limit too */
836 busy_timeout = cpu_to_be32(SBP2_RETRY_LIMIT);
837
838 fw_send_request(device->card, &t, TCODE_WRITE_QUADLET_REQUEST,
839 lu->tgt->node_id, lu->generation, device->max_speed,
840 CSR_REGISTER_BASE + CSR_BUSY_TIMEOUT, &busy_timeout,
841 sizeof(busy_timeout), complete_set_busy_timeout, &done);
842 wait_for_completion(&done);
843}
844
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200845static void sbp2_reconnect(struct work_struct *work);
846
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500847static void sbp2_login(struct work_struct *work)
848{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200849 struct sbp2_logical_unit *lu =
850 container_of(work, struct sbp2_logical_unit, work.work);
Stefan Richter48f18c72008-02-03 23:09:50 +0100851 struct sbp2_target *tgt = lu->tgt;
852 struct fw_device *device = fw_device(tgt->unit->device.parent);
853 struct Scsi_Host *shost;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200854 struct scsi_device *sdev;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500855 struct sbp2_login_response response;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200856 int generation, node_id, local_node_id;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500857
Stefan Richterbe6f48b2008-01-27 19:14:44 +0100858 if (fw_device_is_shutdown(device))
859 goto out;
860
Stefan Richter5a8a1bc2008-01-24 01:53:19 +0100861 generation = device->generation;
Stefan Richterb5d2a5e2008-01-25 18:57:41 +0100862 smp_rmb(); /* node_id must not be older than generation */
Stefan Richter5a8a1bc2008-01-24 01:53:19 +0100863 node_id = device->node_id;
864 local_node_id = device->card->node_id;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500865
Stefan Richterce896d92008-02-03 23:11:39 +0100866 /* If this is a re-login attempt, log out, or we might be rejected. */
Stefan Richterf8436152008-02-26 23:30:02 +0100867 if (lu->has_sdev)
Stefan Richterce896d92008-02-03 23:11:39 +0100868 sbp2_send_management_orb(lu, device->node_id, generation,
869 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
870
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200871 if (sbp2_send_management_orb(lu, node_id, generation,
872 SBP2_LOGIN_REQUEST, lu->lun, &response) < 0) {
Stefan Richter2e2705b2008-02-16 16:37:28 +0100873 if (lu->retries++ < 5) {
Stefan Richter285838e2007-11-07 01:12:51 +0100874 sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
Stefan Richter2e2705b2008-02-16 16:37:28 +0100875 } else {
Stefan Richter48f18c72008-02-03 23:09:50 +0100876 fw_error("%s: failed to login to LUN %04x\n",
877 tgt->bus_id, lu->lun);
Stefan Richter2e2705b2008-02-16 16:37:28 +0100878 /* Let any waiting I/O fail from now on. */
879 sbp2_unblock(lu->tgt);
880 }
Stefan Richter285838e2007-11-07 01:12:51 +0100881 goto out;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500882 }
883
Stefan Richter48f18c72008-02-03 23:09:50 +0100884 tgt->node_id = node_id;
885 tgt->address_high = local_node_id << 16;
Stefan Richter2e2705b2008-02-16 16:37:28 +0100886 sbp2_set_generation(lu, generation);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500887
888 /* Get command block agent offset and login id. */
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200889 lu->command_block_agent_address =
Kristian Høgsberg5c5539d2007-03-07 12:12:45 -0500890 ((u64) (response.command_block_agent.high & 0xffff) << 32) |
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500891 response.command_block_agent.low;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200892 lu->login_id = LOGIN_RESPONSE_GET_LOGIN_ID(response);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500893
Stefan Richter48f18c72008-02-03 23:09:50 +0100894 fw_notify("%s: logged in to LUN %04x (%d retries)\n",
895 tgt->bus_id, lu->lun, lu->retries);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500896
Jarod Wilson51f9dbe2008-03-07 01:43:01 -0500897 /* set appropriate retry limit(s) in BUSY_TIMEOUT register */
898 sbp2_set_busy_timeout(lu);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500899
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200900 PREPARE_DELAYED_WORK(&lu->work, sbp2_reconnect);
901 sbp2_agent_reset(lu);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500902
Stefan Richter0fa6dfd2008-02-03 23:10:47 +0100903 /* This was a re-login. */
Stefan Richterf8436152008-02-26 23:30:02 +0100904 if (lu->has_sdev) {
Stefan Richter0fa6dfd2008-02-03 23:10:47 +0100905 sbp2_cancel_orbs(lu);
Stefan Richter2e2705b2008-02-16 16:37:28 +0100906 sbp2_conditionally_unblock(lu);
Stefan Richter0fa6dfd2008-02-03 23:10:47 +0100907 goto out;
908 }
909
Stefan Richter9220f192008-02-03 23:04:38 +0100910 if (lu->tgt->workarounds & SBP2_WORKAROUND_DELAY_INQUIRY)
911 ssleep(SBP2_INQUIRY_DELAY);
912
Stefan Richter48f18c72008-02-03 23:09:50 +0100913 shost = container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
Stefan Richterf8436152008-02-26 23:30:02 +0100914 sdev = __scsi_add_device(shost, 0, 0, sbp2_lun2int(lu->lun), lu);
Stefan Richtere80de372008-02-15 21:29:02 +0100915 /*
916 * FIXME: We are unable to perform reconnects while in sbp2_login().
917 * Therefore __scsi_add_device() will get into trouble if a bus reset
918 * happens in parallel. It will either fail or leave us with an
919 * unusable sdev. As a workaround we check for this and retry the
920 * whole login and SCSI probing.
921 */
Stefan Richter1b9c12b2008-01-26 17:43:23 +0100922
Stefan Richtere80de372008-02-15 21:29:02 +0100923 /* Reported error during __scsi_add_device() */
924 if (IS_ERR(sdev))
925 goto out_logout_login;
926
Stefan Richtere80de372008-02-15 21:29:02 +0100927 /* Unreported error during __scsi_add_device() */
928 smp_rmb(); /* get current card generation */
929 if (generation != device->card->generation) {
930 scsi_remove_device(sdev);
Stefan Richter33f1c6c2008-02-19 09:05:49 +0100931 scsi_device_put(sdev);
Stefan Richtere80de372008-02-15 21:29:02 +0100932 goto out_logout_login;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500933 }
Stefan Richtere80de372008-02-15 21:29:02 +0100934
935 /* No error during __scsi_add_device() */
Stefan Richterf8436152008-02-26 23:30:02 +0100936 lu->has_sdev = true;
937 scsi_device_put(sdev);
Stefan Richter2e2705b2008-02-16 16:37:28 +0100938 sbp2_allow_block(lu);
Stefan Richtere80de372008-02-15 21:29:02 +0100939 goto out;
940
941 out_logout_login:
942 smp_rmb(); /* generation may have changed */
943 generation = device->generation;
944 smp_rmb(); /* node_id must not be older than generation */
945
946 sbp2_send_management_orb(lu, device->node_id, generation,
947 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
948 /*
949 * If a bus reset happened, sbp2_update will have requeued
950 * lu->work already. Reset the work from reconnect to login.
951 */
952 PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
Stefan Richter285838e2007-11-07 01:12:51 +0100953 out:
Stefan Richter48f18c72008-02-03 23:09:50 +0100954 sbp2_target_put(tgt);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500955}
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500956
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200957static int sbp2_add_logical_unit(struct sbp2_target *tgt, int lun_entry)
958{
959 struct sbp2_logical_unit *lu;
960
961 lu = kmalloc(sizeof(*lu), GFP_KERNEL);
962 if (!lu)
963 return -ENOMEM;
964
965 lu->address_handler.length = 0x100;
966 lu->address_handler.address_callback = sbp2_status_write;
967 lu->address_handler.callback_data = lu;
968
969 if (fw_core_add_address_handler(&lu->address_handler,
970 &fw_high_memory_region) < 0) {
971 kfree(lu);
972 return -ENOMEM;
973 }
974
Stefan Richterf8436152008-02-26 23:30:02 +0100975 lu->tgt = tgt;
976 lu->lun = lun_entry & 0xffff;
977 lu->retries = 0;
978 lu->has_sdev = false;
979 lu->blocked = false;
Stefan Richter2e2705b2008-02-16 16:37:28 +0100980 ++tgt->dont_block;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200981 INIT_LIST_HEAD(&lu->orb_list);
982 INIT_DELAYED_WORK(&lu->work, sbp2_login);
983
984 list_add_tail(&lu->link, &tgt->lu_list);
985 return 0;
986}
987
988static int sbp2_scan_logical_unit_dir(struct sbp2_target *tgt, u32 *directory)
989{
990 struct fw_csr_iterator ci;
991 int key, value;
992
993 fw_csr_iterator_init(&ci, directory);
994 while (fw_csr_iterator_next(&ci, &key, &value))
995 if (key == SBP2_CSR_LOGICAL_UNIT_NUMBER &&
996 sbp2_add_logical_unit(tgt, value) < 0)
997 return -ENOMEM;
998 return 0;
999}
1000
1001static int sbp2_scan_unit_dir(struct sbp2_target *tgt, u32 *directory,
1002 u32 *model, u32 *firmware_revision)
1003{
1004 struct fw_csr_iterator ci;
1005 int key, value;
Jarod Wilson384170d2008-01-25 23:31:12 -05001006 unsigned int timeout;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001007
1008 fw_csr_iterator_init(&ci, directory);
1009 while (fw_csr_iterator_next(&ci, &key, &value)) {
1010 switch (key) {
1011
1012 case CSR_DEPENDENT_INFO | CSR_OFFSET:
1013 tgt->management_agent_address =
1014 CSR_REGISTER_BASE + 4 * value;
1015 break;
1016
1017 case CSR_DIRECTORY_ID:
1018 tgt->directory_id = value;
1019 break;
1020
1021 case CSR_MODEL:
1022 *model = value;
1023 break;
1024
1025 case SBP2_CSR_FIRMWARE_REVISION:
1026 *firmware_revision = value;
1027 break;
1028
Jarod Wilson384170d2008-01-25 23:31:12 -05001029 case SBP2_CSR_UNIT_CHARACTERISTICS:
1030 /* the timeout value is stored in 500ms units */
1031 timeout = ((unsigned int) value >> 8 & 0xff) * 500;
1032 timeout = max(timeout, SBP2_MIN_LOGIN_ORB_TIMEOUT);
1033 tgt->mgt_orb_timeout =
1034 min(timeout, SBP2_MAX_LOGIN_ORB_TIMEOUT);
1035
1036 if (timeout > tgt->mgt_orb_timeout)
1037 fw_notify("%s: config rom contains %ds "
1038 "management ORB timeout, limiting "
Stefan Richter48f18c72008-02-03 23:09:50 +01001039 "to %ds\n", tgt->bus_id,
Jarod Wilson384170d2008-01-25 23:31:12 -05001040 timeout / 1000,
1041 tgt->mgt_orb_timeout / 1000);
1042 break;
1043
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001044 case SBP2_CSR_LOGICAL_UNIT_NUMBER:
1045 if (sbp2_add_logical_unit(tgt, value) < 0)
1046 return -ENOMEM;
1047 break;
1048
1049 case SBP2_CSR_LOGICAL_UNIT_DIRECTORY:
1050 if (sbp2_scan_logical_unit_dir(tgt, ci.p + value) < 0)
1051 return -ENOMEM;
1052 break;
1053 }
1054 }
1055 return 0;
1056}
1057
1058static void sbp2_init_workarounds(struct sbp2_target *tgt, u32 model,
1059 u32 firmware_revision)
1060{
1061 int i;
Stefan Richter05cca732008-01-26 17:42:45 +01001062 unsigned int w = sbp2_param_workarounds;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001063
Stefan Richter2df222b2007-08-13 17:48:25 +02001064 if (w)
1065 fw_notify("Please notify linux1394-devel@lists.sourceforge.net "
1066 "if you need the workarounds parameter for %s\n",
Stefan Richter48f18c72008-02-03 23:09:50 +01001067 tgt->bus_id);
Stefan Richter2df222b2007-08-13 17:48:25 +02001068
1069 if (w & SBP2_WORKAROUND_OVERRIDE)
1070 goto out;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001071
1072 for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
1073
1074 if (sbp2_workarounds_table[i].firmware_revision !=
1075 (firmware_revision & 0xffffff00))
1076 continue;
1077
1078 if (sbp2_workarounds_table[i].model != model &&
1079 sbp2_workarounds_table[i].model != ~0)
1080 continue;
1081
Stefan Richter2df222b2007-08-13 17:48:25 +02001082 w |= sbp2_workarounds_table[i].workarounds;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001083 break;
1084 }
Stefan Richter2df222b2007-08-13 17:48:25 +02001085 out:
1086 if (w)
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001087 fw_notify("Workarounds for %s: 0x%x "
1088 "(firmware_revision 0x%06x, model_id 0x%06x)\n",
Stefan Richter48f18c72008-02-03 23:09:50 +01001089 tgt->bus_id, w, firmware_revision, model);
Stefan Richter2df222b2007-08-13 17:48:25 +02001090 tgt->workarounds = w;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001091}
1092
1093static struct scsi_host_template scsi_driver_template;
1094
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001095static int sbp2_probe(struct device *dev)
1096{
1097 struct fw_unit *unit = fw_unit(dev);
1098 struct fw_device *device = fw_device(unit->device.parent);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001099 struct sbp2_target *tgt;
1100 struct sbp2_logical_unit *lu;
1101 struct Scsi_Host *shost;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001102 u32 model, firmware_revision;
1103
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001104 shost = scsi_host_alloc(&scsi_driver_template, sizeof(*tgt));
1105 if (shost == NULL)
1106 return -ENOMEM;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001107
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001108 tgt = (struct sbp2_target *)shost->hostdata;
1109 unit->device.driver_data = tgt;
1110 tgt->unit = unit;
1111 kref_init(&tgt->kref);
1112 INIT_LIST_HEAD(&tgt->lu_list);
Stefan Richter48f18c72008-02-03 23:09:50 +01001113 tgt->bus_id = unit->device.bus_id;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001114
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001115 if (fw_device_enable_phys_dma(device) < 0)
1116 goto fail_shost_put;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001117
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001118 if (scsi_add_host(shost, &unit->device) < 0)
1119 goto fail_shost_put;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001120
Stefan Richter855c6032008-02-27 22:14:27 +01001121 fw_device_get(device);
1122
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001123 /* Initialize to values that won't match anything in our table. */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001124 firmware_revision = 0xff000000;
1125 model = 0xff000000;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001126
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001127 /* implicit directory ID */
1128 tgt->directory_id = ((unit->directory - device->config_rom) * 4
1129 + CSR_CONFIG_ROM) & 0xffffff;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001130
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001131 if (sbp2_scan_unit_dir(tgt, unit->directory, &model,
1132 &firmware_revision) < 0)
1133 goto fail_tgt_put;
1134
1135 sbp2_init_workarounds(tgt, model, firmware_revision);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001136
Kristian Høgsbergb3d6e152007-03-14 17:34:58 -04001137 get_device(&unit->device);
1138
Stefan Richter285838e2007-11-07 01:12:51 +01001139 /* Do the login in a workqueue so we can easily reschedule retries. */
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001140 list_for_each_entry(lu, &tgt->lu_list, link)
Stefan Richter285838e2007-11-07 01:12:51 +01001141 sbp2_queue_work(lu, 0);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001142 return 0;
Kristian Høgsbergad852742007-05-09 19:23:07 -04001143
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001144 fail_tgt_put:
Stefan Richter285838e2007-11-07 01:12:51 +01001145 sbp2_target_put(tgt);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001146 return -ENOMEM;
1147
1148 fail_shost_put:
1149 scsi_host_put(shost);
1150 return -ENOMEM;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001151}
1152
1153static int sbp2_remove(struct device *dev)
1154{
1155 struct fw_unit *unit = fw_unit(dev);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001156 struct sbp2_target *tgt = unit->device.driver_data;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001157
Stefan Richter285838e2007-11-07 01:12:51 +01001158 sbp2_target_put(tgt);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001159 return 0;
1160}
1161
1162static void sbp2_reconnect(struct work_struct *work)
1163{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001164 struct sbp2_logical_unit *lu =
1165 container_of(work, struct sbp2_logical_unit, work.work);
Stefan Richter48f18c72008-02-03 23:09:50 +01001166 struct sbp2_target *tgt = lu->tgt;
1167 struct fw_device *device = fw_device(tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001168 int generation, node_id, local_node_id;
1169
Stefan Richterbe6f48b2008-01-27 19:14:44 +01001170 if (fw_device_is_shutdown(device))
1171 goto out;
1172
Stefan Richter5a8a1bc2008-01-24 01:53:19 +01001173 generation = device->generation;
Stefan Richterb5d2a5e2008-01-25 18:57:41 +01001174 smp_rmb(); /* node_id must not be older than generation */
Stefan Richter5a8a1bc2008-01-24 01:53:19 +01001175 node_id = device->node_id;
1176 local_node_id = device->card->node_id;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001177
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001178 if (sbp2_send_management_orb(lu, node_id, generation,
Kristian Høgsberg7f37c422007-02-06 14:49:34 -05001179 SBP2_RECONNECT_REQUEST,
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001180 lu->login_id, NULL) < 0) {
Stefan Richterce896d92008-02-03 23:11:39 +01001181 /*
1182 * If reconnect was impossible even though we are in the
1183 * current generation, fall back and try to log in again.
1184 *
1185 * We could check for "Function rejected" status, but
1186 * looking at the bus generation as simpler and more general.
1187 */
1188 smp_rmb(); /* get current card generation */
1189 if (generation == device->card->generation ||
1190 lu->retries++ >= 5) {
Stefan Richter48f18c72008-02-03 23:09:50 +01001191 fw_error("%s: failed to reconnect\n", tgt->bus_id);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001192 lu->retries = 0;
1193 PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -05001194 }
Stefan Richter285838e2007-11-07 01:12:51 +01001195 sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
1196 goto out;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -05001197 }
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001198
Stefan Richter48f18c72008-02-03 23:09:50 +01001199 tgt->node_id = node_id;
1200 tgt->address_high = local_node_id << 16;
Stefan Richter2e2705b2008-02-16 16:37:28 +01001201 sbp2_set_generation(lu, generation);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -05001202
Stefan Richter48f18c72008-02-03 23:09:50 +01001203 fw_notify("%s: reconnected to LUN %04x (%d retries)\n",
1204 tgt->bus_id, lu->lun, lu->retries);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001205
1206 sbp2_agent_reset(lu);
1207 sbp2_cancel_orbs(lu);
Stefan Richter2e2705b2008-02-16 16:37:28 +01001208 sbp2_conditionally_unblock(lu);
Stefan Richter285838e2007-11-07 01:12:51 +01001209 out:
Stefan Richter48f18c72008-02-03 23:09:50 +01001210 sbp2_target_put(tgt);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001211}
1212
1213static void sbp2_update(struct fw_unit *unit)
1214{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001215 struct sbp2_target *tgt = unit->device.driver_data;
1216 struct sbp2_logical_unit *lu;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001217
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001218 fw_device_enable_phys_dma(fw_device(unit->device.parent));
1219
1220 /*
1221 * Fw-core serializes sbp2_update() against sbp2_remove().
1222 * Iteration over tgt->lu_list is therefore safe here.
1223 */
1224 list_for_each_entry(lu, &tgt->lu_list, link) {
Stefan Richter2e2705b2008-02-16 16:37:28 +01001225 sbp2_conditionally_block(lu);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001226 lu->retries = 0;
Stefan Richter285838e2007-11-07 01:12:51 +01001227 sbp2_queue_work(lu, 0);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001228 }
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001229}
1230
1231#define SBP2_UNIT_SPEC_ID_ENTRY 0x0000609e
1232#define SBP2_SW_VERSION_ENTRY 0x00010483
1233
Stefan Richter21ebcd12007-01-14 15:29:07 +01001234static const struct fw_device_id sbp2_id_table[] = {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001235 {
1236 .match_flags = FW_MATCH_SPECIFIER_ID | FW_MATCH_VERSION,
1237 .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY,
Stefan Richter5af4e5e2007-01-21 20:45:32 +01001238 .version = SBP2_SW_VERSION_ENTRY,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001239 },
1240 { }
1241};
1242
1243static struct fw_driver sbp2_driver = {
1244 .driver = {
1245 .owner = THIS_MODULE,
1246 .name = sbp2_driver_name,
1247 .bus = &fw_bus_type,
1248 .probe = sbp2_probe,
1249 .remove = sbp2_remove,
1250 },
1251 .update = sbp2_update,
1252 .id_table = sbp2_id_table,
1253};
1254
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001255static unsigned int
1256sbp2_status_to_sense_data(u8 *sbp2_status, u8 *sense_data)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001257{
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001258 int sam_status;
1259
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001260 sense_data[0] = 0x70;
1261 sense_data[1] = 0x0;
1262 sense_data[2] = sbp2_status[1];
1263 sense_data[3] = sbp2_status[4];
1264 sense_data[4] = sbp2_status[5];
1265 sense_data[5] = sbp2_status[6];
1266 sense_data[6] = sbp2_status[7];
1267 sense_data[7] = 10;
1268 sense_data[8] = sbp2_status[8];
1269 sense_data[9] = sbp2_status[9];
1270 sense_data[10] = sbp2_status[10];
1271 sense_data[11] = sbp2_status[11];
1272 sense_data[12] = sbp2_status[2];
1273 sense_data[13] = sbp2_status[3];
1274 sense_data[14] = sbp2_status[12];
1275 sense_data[15] = sbp2_status[13];
1276
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001277 sam_status = sbp2_status[0] & 0x3f;
1278
1279 switch (sam_status) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001280 case SAM_STAT_GOOD:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001281 case SAM_STAT_CHECK_CONDITION:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001282 case SAM_STAT_CONDITION_MET:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001283 case SAM_STAT_BUSY:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001284 case SAM_STAT_RESERVATION_CONFLICT:
1285 case SAM_STAT_COMMAND_TERMINATED:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001286 return DID_OK << 16 | sam_status;
1287
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001288 default:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001289 return DID_ERROR << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001290 }
1291}
1292
1293static void
1294complete_command_orb(struct sbp2_orb *base_orb, struct sbp2_status *status)
1295{
Jay Fenlason6f061482007-06-27 16:04:33 -04001296 struct sbp2_command_orb *orb =
1297 container_of(base_orb, struct sbp2_command_orb, base);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001298 struct fw_device *device = fw_device(orb->lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001299 int result;
1300
1301 if (status != NULL) {
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001302 if (STATUS_GET_DEAD(*status))
Stefan Richtere0e60212008-02-03 23:08:58 +01001303 sbp2_agent_reset_no_wait(orb->lu);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001304
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001305 switch (STATUS_GET_RESPONSE(*status)) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001306 case SBP2_STATUS_REQUEST_COMPLETE:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001307 result = DID_OK << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001308 break;
1309 case SBP2_STATUS_TRANSPORT_FAILURE:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001310 result = DID_BUS_BUSY << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001311 break;
1312 case SBP2_STATUS_ILLEGAL_REQUEST:
1313 case SBP2_STATUS_VENDOR_DEPENDENT:
1314 default:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001315 result = DID_ERROR << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001316 break;
1317 }
1318
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001319 if (result == DID_OK << 16 && STATUS_GET_LEN(*status) > 1)
1320 result = sbp2_status_to_sense_data(STATUS_GET_DATA(*status),
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001321 orb->cmd->sense_buffer);
1322 } else {
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001323 /*
1324 * If the orb completes with status == NULL, something
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001325 * went wrong, typically a bus reset happened mid-orb
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001326 * or when sending the write (less likely).
1327 */
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001328 result = DID_BUS_BUSY << 16;
Stefan Richter2e2705b2008-02-16 16:37:28 +01001329 sbp2_conditionally_block(orb->lu);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001330 }
1331
1332 dma_unmap_single(device->card->device, orb->base.request_bus,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001333 sizeof(orb->request), DMA_TO_DEVICE);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001334
Stefan Richter412edf62007-07-16 21:05:41 +02001335 if (scsi_sg_count(orb->cmd) > 0)
1336 dma_unmap_sg(device->card->device, scsi_sglist(orb->cmd),
1337 scsi_sg_count(orb->cmd),
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001338 orb->cmd->sc_data_direction);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001339
1340 if (orb->page_table_bus != 0)
1341 dma_unmap_single(device->card->device, orb->page_table_bus,
Stefan Richterb4be0162007-07-02 22:07:34 +02001342 sizeof(orb->page_table), DMA_TO_DEVICE);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001343
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001344 orb->cmd->result = result;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001345 orb->done(orb->cmd);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001346}
1347
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001348static int
1349sbp2_map_scatterlist(struct sbp2_command_orb *orb, struct fw_device *device,
1350 struct sbp2_logical_unit *lu)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001351{
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001352 struct scatterlist *sg;
1353 int sg_len, l, i, j, count;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001354 dma_addr_t sg_addr;
1355
Stefan Richter412edf62007-07-16 21:05:41 +02001356 sg = scsi_sglist(orb->cmd);
1357 count = dma_map_sg(device->card->device, sg, scsi_sg_count(orb->cmd),
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001358 orb->cmd->sc_data_direction);
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001359 if (count == 0)
1360 goto fail;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001361
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001362 /*
1363 * Handle the special case where there is only one element in
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001364 * the scatter list by converting it to an immediate block
1365 * request. This is also a workaround for broken devices such
1366 * as the second generation iPod which doesn't support page
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001367 * tables.
1368 */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001369 if (count == 1 && sg_dma_len(sg) < SBP2_MAX_SG_ELEMENT_LENGTH) {
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001370 orb->request.data_descriptor.high = lu->tgt->address_high;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001371 orb->request.data_descriptor.low = sg_dma_address(sg);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001372 orb->request.misc |= COMMAND_ORB_DATA_SIZE(sg_dma_len(sg));
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001373 return 0;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001374 }
1375
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001376 /*
1377 * Convert the scatterlist to an sbp2 page table. If any
Kristian Høgsberg, Stefan Richter36abb3b2007-05-09 19:23:10 -04001378 * scatterlist entries are too big for sbp2, we split them as we
1379 * go. Even if we ask the block I/O layer to not give us sg
1380 * elements larger than 65535 bytes, some IOMMUs may merge sg elements
1381 * during DMA mapping, and Linux currently doesn't prevent this.
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001382 */
Stefan Richterb7811da2008-01-15 21:10:50 +01001383 for (i = 0, j = 0; i < count; i++, sg = sg_next(sg)) {
1384 sg_len = sg_dma_len(sg);
1385 sg_addr = sg_dma_address(sg);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001386 while (sg_len) {
Stefan Richter332ef332007-07-01 13:56:03 +02001387 /* FIXME: This won't get us out of the pinch. */
1388 if (unlikely(j >= ARRAY_SIZE(orb->page_table))) {
1389 fw_error("page table overflow\n");
1390 goto fail_page_table;
1391 }
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001392 l = min(sg_len, SBP2_MAX_SG_ELEMENT_LENGTH);
1393 orb->page_table[j].low = sg_addr;
1394 orb->page_table[j].high = (l << 16);
1395 sg_addr += l;
1396 sg_len -= l;
1397 j++;
1398 }
1399 }
1400
Stefan Richterb4be0162007-07-02 22:07:34 +02001401 fw_memcpy_to_be32(orb->page_table, orb->page_table,
1402 sizeof(orb->page_table[0]) * j);
1403 orb->page_table_bus =
1404 dma_map_single(device->card->device, orb->page_table,
1405 sizeof(orb->page_table), DMA_TO_DEVICE);
1406 if (dma_mapping_error(orb->page_table_bus))
1407 goto fail_page_table;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001408
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001409 /*
1410 * The data_descriptor pointer is the one case where we need
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001411 * to fill in the node ID part of the address. All other
1412 * pointers assume that the data referenced reside on the
1413 * initiator (i.e. us), but data_descriptor can refer to data
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001414 * on other nodes so we need to put our ID in descriptor.high.
1415 */
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001416 orb->request.data_descriptor.high = lu->tgt->address_high;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001417 orb->request.data_descriptor.low = orb->page_table_bus;
1418 orb->request.misc |=
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001419 COMMAND_ORB_PAGE_TABLE_PRESENT |
1420 COMMAND_ORB_DATA_SIZE(j);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001421
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001422 return 0;
1423
1424 fail_page_table:
Stefan Richter412edf62007-07-16 21:05:41 +02001425 dma_unmap_sg(device->card->device, sg, scsi_sg_count(orb->cmd),
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001426 orb->cmd->sc_data_direction);
1427 fail:
1428 return -ENOMEM;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001429}
1430
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001431/* SCSI stack integration */
1432
1433static int sbp2_scsi_queuecommand(struct scsi_cmnd *cmd, scsi_done_fn_t done)
1434{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001435 struct sbp2_logical_unit *lu = cmd->device->hostdata;
1436 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001437 struct sbp2_command_orb *orb;
Stefan Richter05cca732008-01-26 17:42:45 +01001438 unsigned int max_payload;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001439 int retval = SCSI_MLQUEUE_HOST_BUSY;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001440
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001441 /*
1442 * Bidirectional commands are not yet implemented, and unknown
1443 * transfer direction not handled.
1444 */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001445 if (cmd->sc_data_direction == DMA_BIDIRECTIONAL) {
Stefan Richter8a8cea22007-06-09 19:26:22 +02001446 fw_error("Can't handle DMA_BIDIRECTIONAL, rejecting command\n");
Kristian Høgsberge1b68c42007-05-09 19:23:09 -04001447 cmd->result = DID_ERROR << 16;
1448 done(cmd);
1449 return 0;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001450 }
1451
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001452 orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001453 if (orb == NULL) {
1454 fw_notify("failed to alloc orb\n");
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001455 return SCSI_MLQUEUE_HOST_BUSY;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001456 }
1457
Kristian Høgsberg12f26aa2007-04-10 18:11:20 -04001458 /* Initialize rcode to something not RCODE_COMPLETE. */
1459 orb->base.rcode = -1;
Kristian Høgsberge57d2012007-08-24 18:59:58 -04001460 kref_init(&orb->base.kref);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001461
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001462 orb->lu = lu;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001463 orb->done = done;
1464 orb->cmd = cmd;
1465
1466 orb->request.next.high = SBP2_ORB_NULL;
1467 orb->request.next.low = 0x0;
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001468 /*
1469 * At speed 100 we can do 512 bytes per packet, at speed 200,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001470 * 1024 bytes per packet etc. The SBP-2 max_payload field
1471 * specifies the max payload size as 2 ^ (max_payload + 2), so
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001472 * if we set this to max_speed + 7, we get the right value.
1473 */
Stefan Richter25659f72007-07-21 22:43:05 +02001474 max_payload = min(device->max_speed + 7,
1475 device->card->max_receive - 1);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001476 orb->request.misc =
Stefan Richter25659f72007-07-21 22:43:05 +02001477 COMMAND_ORB_MAX_PAYLOAD(max_payload) |
Stefan Richterf1397492007-06-10 21:31:36 +02001478 COMMAND_ORB_SPEED(device->max_speed) |
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001479 COMMAND_ORB_NOTIFY;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001480
1481 if (cmd->sc_data_direction == DMA_FROM_DEVICE)
1482 orb->request.misc |=
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001483 COMMAND_ORB_DIRECTION(SBP2_DIRECTION_FROM_MEDIA);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001484 else if (cmd->sc_data_direction == DMA_TO_DEVICE)
1485 orb->request.misc |=
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001486 COMMAND_ORB_DIRECTION(SBP2_DIRECTION_TO_MEDIA);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001487
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001488 if (scsi_sg_count(cmd) && sbp2_map_scatterlist(orb, device, lu) < 0)
1489 goto out;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001490
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001491 fw_memcpy_to_be32(&orb->request, &orb->request, sizeof(orb->request));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001492
1493 memset(orb->request.command_block,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001494 0, sizeof(orb->request.command_block));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001495 memcpy(orb->request.command_block, cmd->cmnd, COMMAND_SIZE(*cmd->cmnd));
1496
1497 orb->base.callback = complete_command_orb;
Stefan Richter85263922007-07-02 21:04:08 +02001498 orb->base.request_bus =
1499 dma_map_single(device->card->device, &orb->request,
1500 sizeof(orb->request), DMA_TO_DEVICE);
1501 if (dma_mapping_error(orb->base.request_bus))
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001502 goto out;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001503
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001504 sbp2_send_orb(&orb->base, lu, lu->tgt->node_id, lu->generation,
1505 lu->command_block_agent_address + SBP2_ORB_POINTER);
1506 retval = 0;
1507 out:
Kristian Høgsberge57d2012007-08-24 18:59:58 -04001508 kref_put(&orb->base.kref, free_orb);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001509 return retval;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001510}
1511
Stefan Richtercfb01382007-01-23 21:20:08 +01001512static int sbp2_scsi_slave_alloc(struct scsi_device *sdev)
1513{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001514 struct sbp2_logical_unit *lu = sdev->hostdata;
Stefan Richtercfb01382007-01-23 21:20:08 +01001515
Stefan Richter5513c5f2008-02-17 14:56:19 +01001516 /* (Re-)Adding logical units via the SCSI stack is not supported. */
1517 if (!lu)
1518 return -ENOSYS;
1519
Stefan Richtercfb01382007-01-23 21:20:08 +01001520 sdev->allow_restart = 1;
1521
James Bottomley465ff312008-01-01 10:00:10 -06001522 /*
1523 * Update the dma alignment (minimum alignment requirements for
1524 * start and end of DMA transfers) to be a sector
1525 */
1526 blk_queue_update_dma_alignment(sdev->request_queue, 511);
1527
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001528 if (lu->tgt->workarounds & SBP2_WORKAROUND_INQUIRY_36)
Stefan Richtercfb01382007-01-23 21:20:08 +01001529 sdev->inquiry_len = 36;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001530
Stefan Richtercfb01382007-01-23 21:20:08 +01001531 return 0;
1532}
1533
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001534static int sbp2_scsi_slave_configure(struct scsi_device *sdev)
1535{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001536 struct sbp2_logical_unit *lu = sdev->hostdata;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001537
Stefan Richtercfb01382007-01-23 21:20:08 +01001538 sdev->use_10_for_rw = 1;
1539
1540 if (sdev->type == TYPE_ROM)
1541 sdev->use_10_for_ms = 1;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001542
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001543 if (sdev->type == TYPE_DISK &&
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001544 lu->tgt->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001545 sdev->skip_ms_page_8 = 1;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001546
1547 if (lu->tgt->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001548 sdev->fix_capacity = 1;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001549
1550 if (lu->tgt->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
Stefan Richtercf47c7a2007-06-17 23:52:08 +02001551 blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001552
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001553 return 0;
1554}
1555
1556/*
1557 * Called by scsi stack when something has really gone wrong. Usually
1558 * called when a command has timed-out for some reason.
1559 */
1560static int sbp2_scsi_abort(struct scsi_cmnd *cmd)
1561{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001562 struct sbp2_logical_unit *lu = cmd->device->hostdata;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001563
Stefan Richter48f18c72008-02-03 23:09:50 +01001564 fw_notify("%s: sbp2_scsi_abort\n", lu->tgt->bus_id);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001565 sbp2_agent_reset(lu);
1566 sbp2_cancel_orbs(lu);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001567
1568 return SUCCESS;
1569}
1570
Stefan Richter14e21982007-05-27 13:18:27 +02001571/*
1572 * Format of /sys/bus/scsi/devices/.../ieee1394_id:
1573 * u64 EUI-64 : u24 directory_ID : u16 LUN (all printed in hexadecimal)
1574 *
1575 * This is the concatenation of target port identifier and logical unit
1576 * identifier as per SAM-2...SAM-4 annex A.
1577 */
1578static ssize_t
1579sbp2_sysfs_ieee1394_id_show(struct device *dev, struct device_attribute *attr,
1580 char *buf)
1581{
1582 struct scsi_device *sdev = to_scsi_device(dev);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001583 struct sbp2_logical_unit *lu;
Stefan Richter14e21982007-05-27 13:18:27 +02001584 struct fw_device *device;
Stefan Richter14e21982007-05-27 13:18:27 +02001585
1586 if (!sdev)
1587 return 0;
Stefan Richter14e21982007-05-27 13:18:27 +02001588
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001589 lu = sdev->hostdata;
1590 device = fw_device(lu->tgt->unit->device.parent);
Stefan Richter14e21982007-05-27 13:18:27 +02001591
1592 return sprintf(buf, "%08x%08x:%06x:%04x\n",
1593 device->config_rom[3], device->config_rom[4],
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001594 lu->tgt->directory_id, lu->lun);
Stefan Richter14e21982007-05-27 13:18:27 +02001595}
1596
1597static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
1598
1599static struct device_attribute *sbp2_scsi_sysfs_attrs[] = {
1600 &dev_attr_ieee1394_id,
1601 NULL
1602};
1603
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001604static struct scsi_host_template scsi_driver_template = {
1605 .module = THIS_MODULE,
1606 .name = "SBP-2 IEEE-1394",
Kristian Høgsbergb02b6bc2007-05-09 19:23:12 -04001607 .proc_name = sbp2_driver_name,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001608 .queuecommand = sbp2_scsi_queuecommand,
Stefan Richtercfb01382007-01-23 21:20:08 +01001609 .slave_alloc = sbp2_scsi_slave_alloc,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001610 .slave_configure = sbp2_scsi_slave_configure,
1611 .eh_abort_handler = sbp2_scsi_abort,
1612 .this_id = -1,
1613 .sg_tablesize = SG_ALL,
1614 .use_clustering = ENABLE_CLUSTERING,
Stefan Richter02af8e72007-01-21 20:50:11 +01001615 .cmd_per_lun = 1,
1616 .can_queue = 1,
Stefan Richter14e21982007-05-27 13:18:27 +02001617 .sdev_attrs = sbp2_scsi_sysfs_attrs,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001618};
1619
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001620MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
1621MODULE_DESCRIPTION("SCSI over IEEE1394");
1622MODULE_LICENSE("GPL");
1623MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
1624
Olaf Hering1e4c7b02007-05-05 23:17:13 +02001625/* Provide a module alias so root-on-sbp2 initrds don't break. */
1626#ifndef CONFIG_IEEE1394_SBP2_MODULE
1627MODULE_ALIAS("sbp2");
1628#endif
1629
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001630static int __init sbp2_init(void)
1631{
Stefan Richterdf8ec242007-08-12 12:51:18 +02001632 sbp2_wq = create_singlethread_workqueue(KBUILD_MODNAME);
1633 if (!sbp2_wq)
1634 return -ENOMEM;
1635
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001636 return driver_register(&sbp2_driver.driver);
1637}
1638
1639static void __exit sbp2_cleanup(void)
1640{
1641 driver_unregister(&sbp2_driver.driver);
Stefan Richterdf8ec242007-08-12 12:51:18 +02001642 destroy_workqueue(sbp2_wq);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001643}
1644
1645module_init(sbp2_init);
1646module_exit(sbp2_cleanup);