blob: 624ff3e082f68116f4efe158c80fcdd0c7f27a74 [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
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -050031#include <linux/kernel.h>
32#include <linux/module.h>
Stefan Richter5cd54c92007-06-17 23:55:41 +020033#include <linux/moduleparam.h>
Stefan Richterfe69ca32006-12-28 12:46:54 +010034#include <linux/mod_devicetable.h>
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -050035#include <linux/device.h>
Andrew Morton0b5b2902006-12-27 14:49:23 -080036#include <linux/scatterlist.h>
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -050037#include <linux/dma-mapping.h>
Stefan Richtercf47c7a2007-06-17 23:52:08 +020038#include <linux/blkdev.h>
Stefan Richtere7cdf232007-07-01 13:54:57 +020039#include <linux/string.h>
Stefan Richter2df222b2007-08-13 17:48:25 +020040#include <linux/stringify.h>
Kristian Høgsberg1d3d52c2007-02-06 14:49:33 -050041#include <linux/timer.h>
Stefan Richterdf8ec242007-08-12 12:51:18 +020042#include <linux/workqueue.h>
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -050043
44#include <scsi/scsi.h>
45#include <scsi/scsi_cmnd.h>
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -050046#include <scsi/scsi_device.h>
47#include <scsi/scsi_host.h>
48
49#include "fw-transaction.h"
50#include "fw-topology.h"
51#include "fw-device.h"
52
Stefan Richter5cd54c92007-06-17 23:55:41 +020053/*
54 * So far only bridges from Oxford Semiconductor are known to support
55 * concurrent logins. Depending on firmware, four or two concurrent logins
56 * are possible on OXFW911 and newer Oxsemi bridges.
57 *
58 * Concurrent logins are useful together with cluster filesystems.
59 */
60static int sbp2_param_exclusive_login = 1;
61module_param_named(exclusive_login, sbp2_param_exclusive_login, bool, 0644);
62MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device "
63 "(default = Y, use N for concurrent initiators)");
64
Stefan Richter2df222b2007-08-13 17:48:25 +020065/*
66 * Flags for firmware oddities
67 *
68 * - 128kB max transfer
69 * Limit transfer size. Necessary for some old bridges.
70 *
71 * - 36 byte inquiry
72 * When scsi_mod probes the device, let the inquiry command look like that
73 * from MS Windows.
74 *
75 * - skip mode page 8
76 * Suppress sending of mode_sense for mode page 8 if the device pretends to
77 * support the SCSI Primary Block commands instead of Reduced Block Commands.
78 *
79 * - fix capacity
80 * Tell sd_mod to correct the last sector number reported by read_capacity.
81 * Avoids access beyond actual disk limits on devices with an off-by-one bug.
82 * Don't use this with devices which don't have this bug.
83 *
84 * - override internal blacklist
85 * Instead of adding to the built-in blacklist, use only the workarounds
86 * specified in the module load parameter.
87 * Useful if a blacklist entry interfered with a non-broken device.
88 */
89#define SBP2_WORKAROUND_128K_MAX_TRANS 0x1
90#define SBP2_WORKAROUND_INQUIRY_36 0x2
91#define SBP2_WORKAROUND_MODE_SENSE_8 0x4
92#define SBP2_WORKAROUND_FIX_CAPACITY 0x8
93#define SBP2_WORKAROUND_OVERRIDE 0x100
94
95static int sbp2_param_workarounds;
96module_param_named(workarounds, sbp2_param_workarounds, int, 0644);
97MODULE_PARM_DESC(workarounds, "Work around device bugs (default = 0"
98 ", 128kB max transfer = " __stringify(SBP2_WORKAROUND_128K_MAX_TRANS)
99 ", 36 byte inquiry = " __stringify(SBP2_WORKAROUND_INQUIRY_36)
100 ", skip mode page 8 = " __stringify(SBP2_WORKAROUND_MODE_SENSE_8)
101 ", fix capacity = " __stringify(SBP2_WORKAROUND_FIX_CAPACITY)
102 ", override internal blacklist = " __stringify(SBP2_WORKAROUND_OVERRIDE)
103 ", or a combination)");
104
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500105/* I don't know why the SCSI stack doesn't define something like this... */
Kristian Høgsberga98e2712007-05-07 20:33:34 -0400106typedef void (*scsi_done_fn_t)(struct scsi_cmnd *);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500107
108static const char sbp2_driver_name[] = "sbp2";
109
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200110/*
111 * We create one struct sbp2_logical_unit per SBP-2 Logical Unit Number Entry
112 * and one struct scsi_device per sbp2_logical_unit.
113 */
114struct sbp2_logical_unit {
115 struct sbp2_target *tgt;
116 struct list_head link;
117 struct scsi_device *sdev;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500118 struct fw_address_handler address_handler;
119 struct list_head orb_list;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200120
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500121 u64 command_block_agent_address;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200122 u16 lun;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500123 int login_id;
124
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400125 /*
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200126 * The generation is updated once we've logged in or reconnected
127 * to the logical unit. Thus, I/O to the device will automatically
128 * fail and get retried if it happens in a window where the device
129 * is not ready, e.g. after a bus reset but before we reconnect.
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400130 */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500131 int generation;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500132 int retries;
133 struct delayed_work work;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500134};
135
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200136/*
137 * We create one struct sbp2_target per IEEE 1212 Unit Directory
138 * and one struct Scsi_Host per sbp2_target.
139 */
140struct sbp2_target {
141 struct kref kref;
142 struct fw_unit *unit;
143
144 u64 management_agent_address;
145 int directory_id;
146 int node_id;
147 int address_high;
148
149 unsigned workarounds;
150 struct list_head lu_list;
151};
152
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500153#define SBP2_MAX_SG_ELEMENT_LENGTH 0xf000
154#define SBP2_MAX_SECTORS 255 /* Max sectors supported */
Kristian Høgsberg1d3d52c2007-02-06 14:49:33 -0500155#define SBP2_ORB_TIMEOUT 2000 /* Timeout in ms */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500156
157#define SBP2_ORB_NULL 0x80000000
158
159#define SBP2_DIRECTION_TO_MEDIA 0x0
160#define SBP2_DIRECTION_FROM_MEDIA 0x1
161
162/* Unit directory keys */
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200163#define SBP2_CSR_FIRMWARE_REVISION 0x3c
164#define SBP2_CSR_LOGICAL_UNIT_NUMBER 0x14
165#define SBP2_CSR_LOGICAL_UNIT_DIRECTORY 0xd4
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500166
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500167/* Management orb opcodes */
168#define SBP2_LOGIN_REQUEST 0x0
169#define SBP2_QUERY_LOGINS_REQUEST 0x1
170#define SBP2_RECONNECT_REQUEST 0x3
171#define SBP2_SET_PASSWORD_REQUEST 0x4
172#define SBP2_LOGOUT_REQUEST 0x7
173#define SBP2_ABORT_TASK_REQUEST 0xb
174#define SBP2_ABORT_TASK_SET 0xc
175#define SBP2_LOGICAL_UNIT_RESET 0xe
176#define SBP2_TARGET_RESET_REQUEST 0xf
177
178/* Offsets for command block agent registers */
179#define SBP2_AGENT_STATE 0x00
180#define SBP2_AGENT_RESET 0x04
181#define SBP2_ORB_POINTER 0x08
182#define SBP2_DOORBELL 0x10
183#define SBP2_UNSOLICITED_STATUS_ENABLE 0x14
184
185/* Status write response codes */
186#define SBP2_STATUS_REQUEST_COMPLETE 0x0
187#define SBP2_STATUS_TRANSPORT_FAILURE 0x1
188#define SBP2_STATUS_ILLEGAL_REQUEST 0x2
189#define SBP2_STATUS_VENDOR_DEPENDENT 0x3
190
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400191#define STATUS_GET_ORB_HIGH(v) ((v).status & 0xffff)
192#define STATUS_GET_SBP_STATUS(v) (((v).status >> 16) & 0xff)
193#define STATUS_GET_LEN(v) (((v).status >> 24) & 0x07)
194#define STATUS_GET_DEAD(v) (((v).status >> 27) & 0x01)
195#define STATUS_GET_RESPONSE(v) (((v).status >> 28) & 0x03)
196#define STATUS_GET_SOURCE(v) (((v).status >> 30) & 0x03)
197#define STATUS_GET_ORB_LOW(v) ((v).orb_low)
198#define STATUS_GET_DATA(v) ((v).data)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500199
200struct sbp2_status {
201 u32 status;
202 u32 orb_low;
203 u8 data[24];
204};
205
206struct sbp2_pointer {
207 u32 high;
208 u32 low;
209};
210
211struct sbp2_orb {
212 struct fw_transaction t;
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400213 struct kref kref;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500214 dma_addr_t request_bus;
215 int rcode;
216 struct sbp2_pointer pointer;
Kristian Høgsberga98e2712007-05-07 20:33:34 -0400217 void (*callback)(struct sbp2_orb * orb, struct sbp2_status * status);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500218 struct list_head link;
219};
220
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400221#define MANAGEMENT_ORB_LUN(v) ((v))
222#define MANAGEMENT_ORB_FUNCTION(v) ((v) << 16)
223#define MANAGEMENT_ORB_RECONNECT(v) ((v) << 20)
Stefan Richter5cd54c92007-06-17 23:55:41 +0200224#define MANAGEMENT_ORB_EXCLUSIVE(v) ((v) ? 1 << 28 : 0)
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400225#define MANAGEMENT_ORB_REQUEST_FORMAT(v) ((v) << 29)
226#define MANAGEMENT_ORB_NOTIFY ((1) << 31)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500227
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400228#define MANAGEMENT_ORB_RESPONSE_LENGTH(v) ((v))
229#define MANAGEMENT_ORB_PASSWORD_LENGTH(v) ((v) << 16)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500230
231struct sbp2_management_orb {
232 struct sbp2_orb base;
233 struct {
234 struct sbp2_pointer password;
235 struct sbp2_pointer response;
236 u32 misc;
237 u32 length;
238 struct sbp2_pointer status_fifo;
239 } request;
240 __be32 response[4];
241 dma_addr_t response_bus;
242 struct completion done;
243 struct sbp2_status status;
244};
245
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400246#define LOGIN_RESPONSE_GET_LOGIN_ID(v) ((v).misc & 0xffff)
247#define LOGIN_RESPONSE_GET_LENGTH(v) (((v).misc >> 16) & 0xffff)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500248
249struct sbp2_login_response {
250 u32 misc;
251 struct sbp2_pointer command_block_agent;
252 u32 reconnect_hold;
253};
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400254#define COMMAND_ORB_DATA_SIZE(v) ((v))
255#define COMMAND_ORB_PAGE_SIZE(v) ((v) << 16)
256#define COMMAND_ORB_PAGE_TABLE_PRESENT ((1) << 19)
257#define COMMAND_ORB_MAX_PAYLOAD(v) ((v) << 20)
258#define COMMAND_ORB_SPEED(v) ((v) << 24)
259#define COMMAND_ORB_DIRECTION(v) ((v) << 27)
260#define COMMAND_ORB_REQUEST_FORMAT(v) ((v) << 29)
261#define COMMAND_ORB_NOTIFY ((1) << 31)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500262
263struct sbp2_command_orb {
264 struct sbp2_orb base;
265 struct {
266 struct sbp2_pointer next;
267 struct sbp2_pointer data_descriptor;
268 u32 misc;
269 u8 command_block[12];
270 } request;
271 struct scsi_cmnd *cmd;
272 scsi_done_fn_t done;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200273 struct sbp2_logical_unit *lu;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500274
Stefan Richter9fb2dd12007-07-01 13:55:31 +0200275 struct sbp2_pointer page_table[SG_ALL] __attribute__((aligned(8)));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500276 dma_addr_t page_table_bus;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500277};
278
279/*
280 * List of devices with known bugs.
281 *
282 * The firmware_revision field, masked with 0xffff00, is the best
283 * indicator for the type of bridge chip of a device. It yields a few
284 * false positives but this did not break correctly behaving devices
285 * so far. We use ~0 as a wildcard, since the 24 bit values we get
286 * from the config rom can never match that.
287 */
288static const struct {
289 u32 firmware_revision;
290 u32 model;
291 unsigned workarounds;
292} sbp2_workarounds_table[] = {
293 /* DViCO Momobay CX-1 with TSB42AA9 bridge */ {
294 .firmware_revision = 0x002800,
295 .model = 0x001010,
296 .workarounds = SBP2_WORKAROUND_INQUIRY_36 |
297 SBP2_WORKAROUND_MODE_SENSE_8,
298 },
299 /* Initio bridges, actually only needed for some older ones */ {
300 .firmware_revision = 0x000200,
301 .model = ~0,
302 .workarounds = SBP2_WORKAROUND_INQUIRY_36,
303 },
304 /* Symbios bridge */ {
305 .firmware_revision = 0xa0b800,
306 .model = ~0,
307 .workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
308 },
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400309
310 /*
311 * There are iPods (2nd gen, 3rd gen) with model_id == 0, but
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500312 * these iPods do not feature the read_capacity bug according
313 * to one report. Read_capacity behaviour as well as model_id
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400314 * could change due to Apple-supplied firmware updates though.
315 */
316
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500317 /* iPod 4th generation. */ {
318 .firmware_revision = 0x0a2700,
319 .model = 0x000021,
320 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
321 },
322 /* iPod mini */ {
323 .firmware_revision = 0x0a2700,
324 .model = 0x000023,
325 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
326 },
327 /* iPod Photo */ {
328 .firmware_revision = 0x0a2700,
329 .model = 0x00007e,
330 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
331 }
332};
333
334static void
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400335free_orb(struct kref *kref)
336{
337 struct sbp2_orb *orb = container_of(kref, struct sbp2_orb, kref);
338
339 kfree(orb);
340}
341
342static void
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500343sbp2_status_write(struct fw_card *card, struct fw_request *request,
344 int tcode, int destination, int source,
345 int generation, int speed,
346 unsigned long long offset,
347 void *payload, size_t length, void *callback_data)
348{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200349 struct sbp2_logical_unit *lu = callback_data;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500350 struct sbp2_orb *orb;
351 struct sbp2_status status;
352 size_t header_size;
353 unsigned long flags;
354
355 if (tcode != TCODE_WRITE_BLOCK_REQUEST ||
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400356 length == 0 || length > sizeof(status)) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500357 fw_send_response(card, request, RCODE_TYPE_ERROR);
358 return;
359 }
360
361 header_size = min(length, 2 * sizeof(u32));
362 fw_memcpy_from_be32(&status, payload, header_size);
363 if (length > header_size)
364 memcpy(status.data, payload + 8, length - header_size);
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400365 if (STATUS_GET_SOURCE(status) == 2 || STATUS_GET_SOURCE(status) == 3) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500366 fw_notify("non-orb related status write, not handled\n");
367 fw_send_response(card, request, RCODE_COMPLETE);
368 return;
369 }
370
371 /* Lookup the orb corresponding to this status write. */
372 spin_lock_irqsave(&card->lock, flags);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200373 list_for_each_entry(orb, &lu->orb_list, link) {
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400374 if (STATUS_GET_ORB_HIGH(status) == 0 &&
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400375 STATUS_GET_ORB_LOW(status) == orb->request_bus) {
376 orb->rcode = RCODE_COMPLETE;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500377 list_del(&orb->link);
378 break;
379 }
380 }
381 spin_unlock_irqrestore(&card->lock, flags);
382
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200383 if (&orb->link != &lu->orb_list)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500384 orb->callback(orb, &status);
385 else
386 fw_error("status write for unknown orb\n");
387
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400388 kref_put(&orb->kref, free_orb);
389
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500390 fw_send_response(card, request, RCODE_COMPLETE);
391}
392
393static void
394complete_transaction(struct fw_card *card, int rcode,
395 void *payload, size_t length, void *data)
396{
397 struct sbp2_orb *orb = data;
398 unsigned long flags;
399
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400400 /*
401 * This is a little tricky. We can get the status write for
402 * the orb before we get this callback. The status write
403 * handler above will assume the orb pointer transaction was
404 * successful and set the rcode to RCODE_COMPLETE for the orb.
405 * So this callback only sets the rcode if it hasn't already
406 * been set and only does the cleanup if the transaction
407 * failed and we didn't already get a status write.
408 */
409 spin_lock_irqsave(&card->lock, flags);
410
411 if (orb->rcode == -1)
412 orb->rcode = rcode;
413 if (orb->rcode != RCODE_COMPLETE) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500414 list_del(&orb->link);
Stefan Richter1b34e972007-08-25 10:40:42 +0200415 spin_unlock_irqrestore(&card->lock, flags);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500416 orb->callback(orb, NULL);
Stefan Richter1b34e972007-08-25 10:40:42 +0200417 } else {
418 spin_unlock_irqrestore(&card->lock, flags);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500419 }
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400420
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400421 kref_put(&orb->kref, free_orb);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500422}
423
424static void
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200425sbp2_send_orb(struct sbp2_orb *orb, struct sbp2_logical_unit *lu,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500426 int node_id, int generation, u64 offset)
427{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200428 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500429 unsigned long flags;
430
431 orb->pointer.high = 0;
432 orb->pointer.low = orb->request_bus;
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400433 fw_memcpy_to_be32(&orb->pointer, &orb->pointer, sizeof(orb->pointer));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500434
435 spin_lock_irqsave(&device->card->lock, flags);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200436 list_add_tail(&orb->link, &lu->orb_list);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500437 spin_unlock_irqrestore(&device->card->lock, flags);
438
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400439 /* Take a ref for the orb list and for the transaction callback. */
440 kref_get(&orb->kref);
441 kref_get(&orb->kref);
442
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500443 fw_send_request(device->card, &orb->t, TCODE_WRITE_BLOCK_REQUEST,
Stefan Richterf1397492007-06-10 21:31:36 +0200444 node_id, generation, device->max_speed, offset,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400445 &orb->pointer, sizeof(orb->pointer),
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500446 complete_transaction, orb);
447}
448
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200449static int sbp2_cancel_orbs(struct sbp2_logical_unit *lu)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500450{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200451 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500452 struct sbp2_orb *orb, *next;
453 struct list_head list;
454 unsigned long flags;
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500455 int retval = -ENOENT;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500456
457 INIT_LIST_HEAD(&list);
458 spin_lock_irqsave(&device->card->lock, flags);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200459 list_splice_init(&lu->orb_list, &list);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500460 spin_unlock_irqrestore(&device->card->lock, flags);
461
462 list_for_each_entry_safe(orb, next, &list, link) {
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500463 retval = 0;
Kristian Høgsberg730c32f2007-02-06 14:49:32 -0500464 if (fw_cancel_transaction(device->card, &orb->t) == 0)
465 continue;
466
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500467 orb->rcode = RCODE_CANCELLED;
468 orb->callback(orb, NULL);
469 }
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500470
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500471 return retval;
Kristian Høgsberg1d3d52c2007-02-06 14:49:33 -0500472}
473
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500474static void
475complete_management_orb(struct sbp2_orb *base_orb, struct sbp2_status *status)
476{
477 struct sbp2_management_orb *orb =
Jay Fenlason6f061482007-06-27 16:04:33 -0400478 container_of(base_orb, struct sbp2_management_orb, base);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500479
480 if (status)
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400481 memcpy(&orb->status, status, sizeof(*status));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500482 complete(&orb->done);
483}
484
485static int
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200486sbp2_send_management_orb(struct sbp2_logical_unit *lu, int node_id,
487 int generation, int function, int lun_or_login_id,
488 void *response)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500489{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200490 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500491 struct sbp2_management_orb *orb;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500492 int retval = -ENOMEM;
493
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400494 orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500495 if (orb == NULL)
496 return -ENOMEM;
497
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400498 kref_init(&orb->base.kref);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500499 orb->response_bus =
500 dma_map_single(device->card->device, &orb->response,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400501 sizeof(orb->response), DMA_FROM_DEVICE);
Kristian Høgsberg82eff9db2007-02-06 14:49:40 -0500502 if (dma_mapping_error(orb->response_bus))
Stefan Richter7aa48482007-07-02 21:04:44 +0200503 goto fail_mapping_response;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500504
505 orb->request.response.high = 0;
506 orb->request.response.low = orb->response_bus;
507
508 orb->request.misc =
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400509 MANAGEMENT_ORB_NOTIFY |
510 MANAGEMENT_ORB_FUNCTION(function) |
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200511 MANAGEMENT_ORB_LUN(lun_or_login_id);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500512 orb->request.length =
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400513 MANAGEMENT_ORB_RESPONSE_LENGTH(sizeof(orb->response));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500514
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200515 orb->request.status_fifo.high = lu->address_handler.offset >> 32;
516 orb->request.status_fifo.low = lu->address_handler.offset;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500517
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500518 if (function == SBP2_LOGIN_REQUEST) {
519 orb->request.misc |=
Stefan Richter5cd54c92007-06-17 23:55:41 +0200520 MANAGEMENT_ORB_EXCLUSIVE(sbp2_param_exclusive_login) |
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400521 MANAGEMENT_ORB_RECONNECT(0);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500522 }
523
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400524 fw_memcpy_to_be32(&orb->request, &orb->request, sizeof(orb->request));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500525
526 init_completion(&orb->done);
527 orb->base.callback = complete_management_orb;
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500528
Stefan Richter7aa48482007-07-02 21:04:44 +0200529 orb->base.request_bus =
530 dma_map_single(device->card->device, &orb->request,
531 sizeof(orb->request), DMA_TO_DEVICE);
532 if (dma_mapping_error(orb->base.request_bus))
533 goto fail_mapping_request;
534
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200535 sbp2_send_orb(&orb->base, lu, node_id, generation,
536 lu->tgt->management_agent_address);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500537
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500538 wait_for_completion_timeout(&orb->done,
539 msecs_to_jiffies(SBP2_ORB_TIMEOUT));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500540
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500541 retval = -EIO;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200542 if (sbp2_cancel_orbs(lu) == 0) {
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500543 fw_error("orb reply timed out, rcode=0x%02x\n",
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500544 orb->base.rcode);
545 goto out;
546 }
547
Kristian Høgsberg2aaad972007-03-07 12:12:47 -0500548 if (orb->base.rcode != RCODE_COMPLETE) {
549 fw_error("management write failed, rcode 0x%02x\n",
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500550 orb->base.rcode);
551 goto out;
552 }
553
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400554 if (STATUS_GET_RESPONSE(orb->status) != 0 ||
555 STATUS_GET_SBP_STATUS(orb->status) != 0) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500556 fw_error("error status: %d:%d\n",
Kristian Høgsberga77754a2007-05-07 20:33:35 -0400557 STATUS_GET_RESPONSE(orb->status),
558 STATUS_GET_SBP_STATUS(orb->status));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500559 goto out;
560 }
561
562 retval = 0;
563 out:
564 dma_unmap_single(device->card->device, orb->base.request_bus,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400565 sizeof(orb->request), DMA_TO_DEVICE);
Stefan Richter7aa48482007-07-02 21:04:44 +0200566 fail_mapping_request:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500567 dma_unmap_single(device->card->device, orb->response_bus,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400568 sizeof(orb->response), DMA_FROM_DEVICE);
Stefan Richter7aa48482007-07-02 21:04:44 +0200569 fail_mapping_response:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500570 if (response)
571 fw_memcpy_from_be32(response,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400572 orb->response, sizeof(orb->response));
Kristian Høgsberge57d2012007-08-24 18:59:58 -0400573 kref_put(&orb->base.kref, free_orb);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500574
575 return retval;
576}
577
578static void
579complete_agent_reset_write(struct fw_card *card, int rcode,
580 void *payload, size_t length, void *data)
581{
582 struct fw_transaction *t = data;
583
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500584 kfree(t);
585}
586
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200587static int sbp2_agent_reset(struct sbp2_logical_unit *lu)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500588{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200589 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500590 struct fw_transaction *t;
591 static u32 zero;
592
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400593 t = kzalloc(sizeof(*t), GFP_ATOMIC);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500594 if (t == NULL)
595 return -ENOMEM;
596
597 fw_send_request(device->card, t, TCODE_WRITE_QUADLET_REQUEST,
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200598 lu->tgt->node_id, lu->generation, device->max_speed,
599 lu->command_block_agent_address + SBP2_AGENT_RESET,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -0400600 &zero, sizeof(zero), complete_agent_reset_write, t);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500601
602 return 0;
603}
604
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200605static void sbp2_release_target(struct kref *kref)
Kristian Høgsbergb3d6e152007-03-14 17:34:58 -0400606{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200607 struct sbp2_target *tgt = container_of(kref, struct sbp2_target, kref);
608 struct sbp2_logical_unit *lu, *next;
609 struct Scsi_Host *shost =
610 container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
Kristian Høgsbergb3d6e152007-03-14 17:34:58 -0400611
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200612 list_for_each_entry_safe(lu, next, &tgt->lu_list, link) {
613 if (lu->sdev)
614 scsi_remove_device(lu->sdev);
615
616 sbp2_send_management_orb(lu, tgt->node_id, lu->generation,
617 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
618 fw_core_remove_address_handler(&lu->address_handler);
619 list_del(&lu->link);
620 kfree(lu);
621 }
622 scsi_remove_host(shost);
623 fw_notify("released %s\n", tgt->unit->device.bus_id);
624
625 put_device(&tgt->unit->device);
626 scsi_host_put(shost);
Kristian Høgsbergb3d6e152007-03-14 17:34:58 -0400627}
628
Stefan Richterdf8ec242007-08-12 12:51:18 +0200629static struct workqueue_struct *sbp2_wq;
630
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200631static void sbp2_reconnect(struct work_struct *work);
632
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500633static void sbp2_login(struct work_struct *work)
634{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200635 struct sbp2_logical_unit *lu =
636 container_of(work, struct sbp2_logical_unit, work.work);
637 struct Scsi_Host *shost =
638 container_of((void *)lu->tgt, struct Scsi_Host, hostdata[0]);
639 struct scsi_device *sdev;
640 struct scsi_lun eight_bytes_lun;
641 struct fw_unit *unit = lu->tgt->unit;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500642 struct fw_device *device = fw_device(unit->device.parent);
643 struct sbp2_login_response response;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200644 int generation, node_id, local_node_id;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500645
646 generation = device->card->generation;
647 node_id = device->node->node_id;
648 local_node_id = device->card->local_node->node_id;
649
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200650 if (sbp2_send_management_orb(lu, node_id, generation,
651 SBP2_LOGIN_REQUEST, lu->lun, &response) < 0) {
652 if (lu->retries++ < 5) {
Stefan Richter7c45d192007-11-07 01:11:56 +0100653 if (queue_delayed_work(sbp2_wq, &lu->work,
654 DIV_ROUND_UP(HZ, 5)))
655 kref_get(&lu->tgt->kref);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500656 } else {
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200657 fw_error("failed to login to %s LUN %04x\n",
658 unit->device.bus_id, lu->lun);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500659 }
Stefan Richter7c45d192007-11-07 01:11:56 +0100660 kref_put(&lu->tgt->kref, sbp2_release_target);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500661 return;
662 }
663
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200664 lu->generation = generation;
665 lu->tgt->node_id = node_id;
666 lu->tgt->address_high = local_node_id << 16;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500667
668 /* Get command block agent offset and login id. */
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200669 lu->command_block_agent_address =
Kristian Høgsberg5c5539d2007-03-07 12:12:45 -0500670 ((u64) (response.command_block_agent.high & 0xffff) << 32) |
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500671 response.command_block_agent.low;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200672 lu->login_id = LOGIN_RESPONSE_GET_LOGIN_ID(response);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500673
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200674 fw_notify("logged in to %s LUN %04x (%d retries)\n",
675 unit->device.bus_id, lu->lun, lu->retries);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500676
677#if 0
678 /* FIXME: The linux1394 sbp2 does this last step. */
679 sbp2_set_busy_timeout(scsi_id);
680#endif
681
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200682 PREPARE_DELAYED_WORK(&lu->work, sbp2_reconnect);
683 sbp2_agent_reset(lu);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500684
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200685 memset(&eight_bytes_lun, 0, sizeof(eight_bytes_lun));
686 eight_bytes_lun.scsi_lun[0] = (lu->lun >> 8) & 0xff;
687 eight_bytes_lun.scsi_lun[1] = lu->lun & 0xff;
688
689 sdev = __scsi_add_device(shost, 0, 0,
690 scsilun_to_int(&eight_bytes_lun), lu);
691 if (IS_ERR(sdev)) {
692 sbp2_send_management_orb(lu, node_id, generation,
693 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400694 /*
695 * Set this back to sbp2_login so we fall back and
696 * retry login on bus reset.
697 */
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200698 PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
699 } else {
700 lu->sdev = sdev;
701 scsi_device_put(sdev);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500702 }
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200703 kref_put(&lu->tgt->kref, sbp2_release_target);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500704}
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500705
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200706static int sbp2_add_logical_unit(struct sbp2_target *tgt, int lun_entry)
707{
708 struct sbp2_logical_unit *lu;
709
710 lu = kmalloc(sizeof(*lu), GFP_KERNEL);
711 if (!lu)
712 return -ENOMEM;
713
714 lu->address_handler.length = 0x100;
715 lu->address_handler.address_callback = sbp2_status_write;
716 lu->address_handler.callback_data = lu;
717
718 if (fw_core_add_address_handler(&lu->address_handler,
719 &fw_high_memory_region) < 0) {
720 kfree(lu);
721 return -ENOMEM;
722 }
723
724 lu->tgt = tgt;
725 lu->sdev = NULL;
726 lu->lun = lun_entry & 0xffff;
727 lu->retries = 0;
728 INIT_LIST_HEAD(&lu->orb_list);
729 INIT_DELAYED_WORK(&lu->work, sbp2_login);
730
731 list_add_tail(&lu->link, &tgt->lu_list);
732 return 0;
733}
734
735static int sbp2_scan_logical_unit_dir(struct sbp2_target *tgt, u32 *directory)
736{
737 struct fw_csr_iterator ci;
738 int key, value;
739
740 fw_csr_iterator_init(&ci, directory);
741 while (fw_csr_iterator_next(&ci, &key, &value))
742 if (key == SBP2_CSR_LOGICAL_UNIT_NUMBER &&
743 sbp2_add_logical_unit(tgt, value) < 0)
744 return -ENOMEM;
745 return 0;
746}
747
748static int sbp2_scan_unit_dir(struct sbp2_target *tgt, u32 *directory,
749 u32 *model, u32 *firmware_revision)
750{
751 struct fw_csr_iterator ci;
752 int key, value;
753
754 fw_csr_iterator_init(&ci, directory);
755 while (fw_csr_iterator_next(&ci, &key, &value)) {
756 switch (key) {
757
758 case CSR_DEPENDENT_INFO | CSR_OFFSET:
759 tgt->management_agent_address =
760 CSR_REGISTER_BASE + 4 * value;
761 break;
762
763 case CSR_DIRECTORY_ID:
764 tgt->directory_id = value;
765 break;
766
767 case CSR_MODEL:
768 *model = value;
769 break;
770
771 case SBP2_CSR_FIRMWARE_REVISION:
772 *firmware_revision = value;
773 break;
774
775 case SBP2_CSR_LOGICAL_UNIT_NUMBER:
776 if (sbp2_add_logical_unit(tgt, value) < 0)
777 return -ENOMEM;
778 break;
779
780 case SBP2_CSR_LOGICAL_UNIT_DIRECTORY:
781 if (sbp2_scan_logical_unit_dir(tgt, ci.p + value) < 0)
782 return -ENOMEM;
783 break;
784 }
785 }
786 return 0;
787}
788
789static void sbp2_init_workarounds(struct sbp2_target *tgt, u32 model,
790 u32 firmware_revision)
791{
792 int i;
Stefan Richter2df222b2007-08-13 17:48:25 +0200793 unsigned w = sbp2_param_workarounds;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200794
Stefan Richter2df222b2007-08-13 17:48:25 +0200795 if (w)
796 fw_notify("Please notify linux1394-devel@lists.sourceforge.net "
797 "if you need the workarounds parameter for %s\n",
798 tgt->unit->device.bus_id);
799
800 if (w & SBP2_WORKAROUND_OVERRIDE)
801 goto out;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200802
803 for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
804
805 if (sbp2_workarounds_table[i].firmware_revision !=
806 (firmware_revision & 0xffffff00))
807 continue;
808
809 if (sbp2_workarounds_table[i].model != model &&
810 sbp2_workarounds_table[i].model != ~0)
811 continue;
812
Stefan Richter2df222b2007-08-13 17:48:25 +0200813 w |= sbp2_workarounds_table[i].workarounds;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200814 break;
815 }
Stefan Richter2df222b2007-08-13 17:48:25 +0200816 out:
817 if (w)
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200818 fw_notify("Workarounds for %s: 0x%x "
819 "(firmware_revision 0x%06x, model_id 0x%06x)\n",
820 tgt->unit->device.bus_id,
Stefan Richter2df222b2007-08-13 17:48:25 +0200821 w, firmware_revision, model);
822 tgt->workarounds = w;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200823}
824
825static struct scsi_host_template scsi_driver_template;
826
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500827static int sbp2_probe(struct device *dev)
828{
829 struct fw_unit *unit = fw_unit(dev);
830 struct fw_device *device = fw_device(unit->device.parent);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200831 struct sbp2_target *tgt;
832 struct sbp2_logical_unit *lu;
833 struct Scsi_Host *shost;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500834 u32 model, firmware_revision;
835
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200836 shost = scsi_host_alloc(&scsi_driver_template, sizeof(*tgt));
837 if (shost == NULL)
838 return -ENOMEM;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500839
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200840 tgt = (struct sbp2_target *)shost->hostdata;
841 unit->device.driver_data = tgt;
842 tgt->unit = unit;
843 kref_init(&tgt->kref);
844 INIT_LIST_HEAD(&tgt->lu_list);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500845
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200846 if (fw_device_enable_phys_dma(device) < 0)
847 goto fail_shost_put;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500848
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200849 if (scsi_add_host(shost, &unit->device) < 0)
850 goto fail_shost_put;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500851
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200852 /* Initialize to values that won't match anything in our table. */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500853 firmware_revision = 0xff000000;
854 model = 0xff000000;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500855
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200856 /* implicit directory ID */
857 tgt->directory_id = ((unit->directory - device->config_rom) * 4
858 + CSR_CONFIG_ROM) & 0xffffff;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500859
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200860 if (sbp2_scan_unit_dir(tgt, unit->directory, &model,
861 &firmware_revision) < 0)
862 goto fail_tgt_put;
863
864 sbp2_init_workarounds(tgt, model, firmware_revision);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500865
Kristian Høgsbergb3d6e152007-03-14 17:34:58 -0400866 get_device(&unit->device);
867
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400868 /*
869 * We schedule work to do the login so we can easily
Kristian Høgsbergb3d6e152007-03-14 17:34:58 -0400870 * reschedule retries. Always get the ref before scheduling
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400871 * work.
872 */
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200873 list_for_each_entry(lu, &tgt->lu_list, link)
Stefan Richterdf8ec242007-08-12 12:51:18 +0200874 if (queue_delayed_work(sbp2_wq, &lu->work, 0))
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200875 kref_get(&tgt->kref);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500876 return 0;
Kristian Høgsbergad852742007-05-09 19:23:07 -0400877
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200878 fail_tgt_put:
879 kref_put(&tgt->kref, sbp2_release_target);
880 return -ENOMEM;
881
882 fail_shost_put:
883 scsi_host_put(shost);
884 return -ENOMEM;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500885}
886
887static int sbp2_remove(struct device *dev)
888{
889 struct fw_unit *unit = fw_unit(dev);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200890 struct sbp2_target *tgt = unit->device.driver_data;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500891
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200892 kref_put(&tgt->kref, sbp2_release_target);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500893 return 0;
894}
895
896static void sbp2_reconnect(struct work_struct *work)
897{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200898 struct sbp2_logical_unit *lu =
899 container_of(work, struct sbp2_logical_unit, work.work);
900 struct fw_unit *unit = lu->tgt->unit;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500901 struct fw_device *device = fw_device(unit->device.parent);
902 int generation, node_id, local_node_id;
903
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500904 generation = device->card->generation;
905 node_id = device->node->node_id;
906 local_node_id = device->card->local_node->node_id;
907
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200908 if (sbp2_send_management_orb(lu, node_id, generation,
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500909 SBP2_RECONNECT_REQUEST,
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200910 lu->login_id, NULL) < 0) {
911 if (lu->retries++ >= 5) {
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500912 fw_error("failed to reconnect to %s\n",
913 unit->device.bus_id);
914 /* Fall back and try to log in again. */
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200915 lu->retries = 0;
916 PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500917 }
Stefan Richter7c45d192007-11-07 01:11:56 +0100918 if (queue_delayed_work(sbp2_wq, &lu->work, DIV_ROUND_UP(HZ, 5)))
919 kref_get(&lu->tgt->kref);
920 kref_put(&lu->tgt->kref, sbp2_release_target);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500921 return;
922 }
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500923
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200924 lu->generation = generation;
925 lu->tgt->node_id = node_id;
926 lu->tgt->address_high = local_node_id << 16;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500927
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200928 fw_notify("reconnected to %s LUN %04x (%d retries)\n",
929 unit->device.bus_id, lu->lun, lu->retries);
930
931 sbp2_agent_reset(lu);
932 sbp2_cancel_orbs(lu);
933
934 kref_put(&lu->tgt->kref, sbp2_release_target);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500935}
936
937static void sbp2_update(struct fw_unit *unit)
938{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200939 struct sbp2_target *tgt = unit->device.driver_data;
940 struct sbp2_logical_unit *lu;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500941
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200942 fw_device_enable_phys_dma(fw_device(unit->device.parent));
943
944 /*
945 * Fw-core serializes sbp2_update() against sbp2_remove().
946 * Iteration over tgt->lu_list is therefore safe here.
947 */
948 list_for_each_entry(lu, &tgt->lu_list, link) {
949 lu->retries = 0;
Stefan Richterdf8ec242007-08-12 12:51:18 +0200950 if (queue_delayed_work(sbp2_wq, &lu->work, 0))
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200951 kref_get(&tgt->kref);
952 }
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500953}
954
955#define SBP2_UNIT_SPEC_ID_ENTRY 0x0000609e
956#define SBP2_SW_VERSION_ENTRY 0x00010483
957
Stefan Richter21ebcd12007-01-14 15:29:07 +0100958static const struct fw_device_id sbp2_id_table[] = {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500959 {
960 .match_flags = FW_MATCH_SPECIFIER_ID | FW_MATCH_VERSION,
961 .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY,
Stefan Richter5af4e5e2007-01-21 20:45:32 +0100962 .version = SBP2_SW_VERSION_ENTRY,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500963 },
964 { }
965};
966
967static struct fw_driver sbp2_driver = {
968 .driver = {
969 .owner = THIS_MODULE,
970 .name = sbp2_driver_name,
971 .bus = &fw_bus_type,
972 .probe = sbp2_probe,
973 .remove = sbp2_remove,
974 },
975 .update = sbp2_update,
976 .id_table = sbp2_id_table,
977};
978
Kristian Høgsbergfbb54232007-04-10 18:11:18 -0400979static unsigned int
980sbp2_status_to_sense_data(u8 *sbp2_status, u8 *sense_data)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500981{
Kristian Høgsbergfbb54232007-04-10 18:11:18 -0400982 int sam_status;
983
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500984 sense_data[0] = 0x70;
985 sense_data[1] = 0x0;
986 sense_data[2] = sbp2_status[1];
987 sense_data[3] = sbp2_status[4];
988 sense_data[4] = sbp2_status[5];
989 sense_data[5] = sbp2_status[6];
990 sense_data[6] = sbp2_status[7];
991 sense_data[7] = 10;
992 sense_data[8] = sbp2_status[8];
993 sense_data[9] = sbp2_status[9];
994 sense_data[10] = sbp2_status[10];
995 sense_data[11] = sbp2_status[11];
996 sense_data[12] = sbp2_status[2];
997 sense_data[13] = sbp2_status[3];
998 sense_data[14] = sbp2_status[12];
999 sense_data[15] = sbp2_status[13];
1000
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001001 sam_status = sbp2_status[0] & 0x3f;
1002
1003 switch (sam_status) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001004 case SAM_STAT_GOOD:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001005 case SAM_STAT_CHECK_CONDITION:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001006 case SAM_STAT_CONDITION_MET:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001007 case SAM_STAT_BUSY:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001008 case SAM_STAT_RESERVATION_CONFLICT:
1009 case SAM_STAT_COMMAND_TERMINATED:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001010 return DID_OK << 16 | sam_status;
1011
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001012 default:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001013 return DID_ERROR << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001014 }
1015}
1016
1017static void
1018complete_command_orb(struct sbp2_orb *base_orb, struct sbp2_status *status)
1019{
Jay Fenlason6f061482007-06-27 16:04:33 -04001020 struct sbp2_command_orb *orb =
1021 container_of(base_orb, struct sbp2_command_orb, base);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001022 struct fw_device *device = fw_device(orb->lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001023 int result;
1024
1025 if (status != NULL) {
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001026 if (STATUS_GET_DEAD(*status))
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001027 sbp2_agent_reset(orb->lu);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001028
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001029 switch (STATUS_GET_RESPONSE(*status)) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001030 case SBP2_STATUS_REQUEST_COMPLETE:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001031 result = DID_OK << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001032 break;
1033 case SBP2_STATUS_TRANSPORT_FAILURE:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001034 result = DID_BUS_BUSY << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001035 break;
1036 case SBP2_STATUS_ILLEGAL_REQUEST:
1037 case SBP2_STATUS_VENDOR_DEPENDENT:
1038 default:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001039 result = DID_ERROR << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001040 break;
1041 }
1042
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001043 if (result == DID_OK << 16 && STATUS_GET_LEN(*status) > 1)
1044 result = sbp2_status_to_sense_data(STATUS_GET_DATA(*status),
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001045 orb->cmd->sense_buffer);
1046 } else {
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001047 /*
1048 * If the orb completes with status == NULL, something
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001049 * went wrong, typically a bus reset happened mid-orb
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001050 * or when sending the write (less likely).
1051 */
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001052 result = DID_BUS_BUSY << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001053 }
1054
1055 dma_unmap_single(device->card->device, orb->base.request_bus,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001056 sizeof(orb->request), DMA_TO_DEVICE);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001057
Stefan Richter412edf62007-07-16 21:05:41 +02001058 if (scsi_sg_count(orb->cmd) > 0)
1059 dma_unmap_sg(device->card->device, scsi_sglist(orb->cmd),
1060 scsi_sg_count(orb->cmd),
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001061 orb->cmd->sc_data_direction);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001062
1063 if (orb->page_table_bus != 0)
1064 dma_unmap_single(device->card->device, orb->page_table_bus,
Stefan Richterb4be0162007-07-02 22:07:34 +02001065 sizeof(orb->page_table), DMA_TO_DEVICE);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001066
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001067 orb->cmd->result = result;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001068 orb->done(orb->cmd);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001069}
1070
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001071static int
1072sbp2_map_scatterlist(struct sbp2_command_orb *orb, struct fw_device *device,
1073 struct sbp2_logical_unit *lu)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001074{
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001075 struct scatterlist *sg;
1076 int sg_len, l, i, j, count;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001077 dma_addr_t sg_addr;
1078
Stefan Richter412edf62007-07-16 21:05:41 +02001079 sg = scsi_sglist(orb->cmd);
1080 count = dma_map_sg(device->card->device, sg, scsi_sg_count(orb->cmd),
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001081 orb->cmd->sc_data_direction);
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001082 if (count == 0)
1083 goto fail;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001084
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001085 /*
1086 * Handle the special case where there is only one element in
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001087 * the scatter list by converting it to an immediate block
1088 * request. This is also a workaround for broken devices such
1089 * as the second generation iPod which doesn't support page
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001090 * tables.
1091 */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001092 if (count == 1 && sg_dma_len(sg) < SBP2_MAX_SG_ELEMENT_LENGTH) {
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001093 orb->request.data_descriptor.high = lu->tgt->address_high;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001094 orb->request.data_descriptor.low = sg_dma_address(sg);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001095 orb->request.misc |= COMMAND_ORB_DATA_SIZE(sg_dma_len(sg));
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001096 return 0;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001097 }
1098
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001099 /*
1100 * Convert the scatterlist to an sbp2 page table. If any
Kristian Høgsberg, Stefan Richter36abb3b2007-05-09 19:23:10 -04001101 * scatterlist entries are too big for sbp2, we split them as we
1102 * go. Even if we ask the block I/O layer to not give us sg
1103 * elements larger than 65535 bytes, some IOMMUs may merge sg elements
1104 * during DMA mapping, and Linux currently doesn't prevent this.
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001105 */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001106 for (i = 0, j = 0; i < count; i++) {
1107 sg_len = sg_dma_len(sg + i);
1108 sg_addr = sg_dma_address(sg + i);
1109 while (sg_len) {
Stefan Richter332ef332007-07-01 13:56:03 +02001110 /* FIXME: This won't get us out of the pinch. */
1111 if (unlikely(j >= ARRAY_SIZE(orb->page_table))) {
1112 fw_error("page table overflow\n");
1113 goto fail_page_table;
1114 }
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001115 l = min(sg_len, SBP2_MAX_SG_ELEMENT_LENGTH);
1116 orb->page_table[j].low = sg_addr;
1117 orb->page_table[j].high = (l << 16);
1118 sg_addr += l;
1119 sg_len -= l;
1120 j++;
1121 }
1122 }
1123
Stefan Richterb4be0162007-07-02 22:07:34 +02001124 fw_memcpy_to_be32(orb->page_table, orb->page_table,
1125 sizeof(orb->page_table[0]) * j);
1126 orb->page_table_bus =
1127 dma_map_single(device->card->device, orb->page_table,
1128 sizeof(orb->page_table), DMA_TO_DEVICE);
1129 if (dma_mapping_error(orb->page_table_bus))
1130 goto fail_page_table;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001131
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001132 /*
1133 * The data_descriptor pointer is the one case where we need
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001134 * to fill in the node ID part of the address. All other
1135 * pointers assume that the data referenced reside on the
1136 * initiator (i.e. us), but data_descriptor can refer to data
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001137 * on other nodes so we need to put our ID in descriptor.high.
1138 */
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001139 orb->request.data_descriptor.high = lu->tgt->address_high;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001140 orb->request.data_descriptor.low = orb->page_table_bus;
1141 orb->request.misc |=
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001142 COMMAND_ORB_PAGE_TABLE_PRESENT |
1143 COMMAND_ORB_DATA_SIZE(j);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001144
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001145 return 0;
1146
1147 fail_page_table:
Stefan Richter412edf62007-07-16 21:05:41 +02001148 dma_unmap_sg(device->card->device, sg, scsi_sg_count(orb->cmd),
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001149 orb->cmd->sc_data_direction);
1150 fail:
1151 return -ENOMEM;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001152}
1153
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001154/* SCSI stack integration */
1155
1156static int sbp2_scsi_queuecommand(struct scsi_cmnd *cmd, scsi_done_fn_t done)
1157{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001158 struct sbp2_logical_unit *lu = cmd->device->hostdata;
1159 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001160 struct sbp2_command_orb *orb;
Stefan Richter25659f72007-07-21 22:43:05 +02001161 unsigned max_payload;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001162 int retval = SCSI_MLQUEUE_HOST_BUSY;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001163
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001164 /*
1165 * Bidirectional commands are not yet implemented, and unknown
1166 * transfer direction not handled.
1167 */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001168 if (cmd->sc_data_direction == DMA_BIDIRECTIONAL) {
Stefan Richter8a8cea22007-06-09 19:26:22 +02001169 fw_error("Can't handle DMA_BIDIRECTIONAL, rejecting command\n");
Kristian Høgsberge1b68c42007-05-09 19:23:09 -04001170 cmd->result = DID_ERROR << 16;
1171 done(cmd);
1172 return 0;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001173 }
1174
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001175 orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001176 if (orb == NULL) {
1177 fw_notify("failed to alloc orb\n");
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001178 return SCSI_MLQUEUE_HOST_BUSY;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001179 }
1180
Kristian Høgsberg12f26aa2007-04-10 18:11:20 -04001181 /* Initialize rcode to something not RCODE_COMPLETE. */
1182 orb->base.rcode = -1;
Kristian Høgsberge57d2012007-08-24 18:59:58 -04001183 kref_init(&orb->base.kref);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001184
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001185 orb->lu = lu;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001186 orb->done = done;
1187 orb->cmd = cmd;
1188
1189 orb->request.next.high = SBP2_ORB_NULL;
1190 orb->request.next.low = 0x0;
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001191 /*
1192 * At speed 100 we can do 512 bytes per packet, at speed 200,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001193 * 1024 bytes per packet etc. The SBP-2 max_payload field
1194 * specifies the max payload size as 2 ^ (max_payload + 2), so
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001195 * if we set this to max_speed + 7, we get the right value.
1196 */
Stefan Richter25659f72007-07-21 22:43:05 +02001197 max_payload = min(device->max_speed + 7,
1198 device->card->max_receive - 1);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001199 orb->request.misc =
Stefan Richter25659f72007-07-21 22:43:05 +02001200 COMMAND_ORB_MAX_PAYLOAD(max_payload) |
Stefan Richterf1397492007-06-10 21:31:36 +02001201 COMMAND_ORB_SPEED(device->max_speed) |
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001202 COMMAND_ORB_NOTIFY;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001203
1204 if (cmd->sc_data_direction == DMA_FROM_DEVICE)
1205 orb->request.misc |=
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001206 COMMAND_ORB_DIRECTION(SBP2_DIRECTION_FROM_MEDIA);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001207 else if (cmd->sc_data_direction == DMA_TO_DEVICE)
1208 orb->request.misc |=
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001209 COMMAND_ORB_DIRECTION(SBP2_DIRECTION_TO_MEDIA);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001210
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001211 if (scsi_sg_count(cmd) && sbp2_map_scatterlist(orb, device, lu) < 0)
1212 goto out;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001213
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001214 fw_memcpy_to_be32(&orb->request, &orb->request, sizeof(orb->request));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001215
1216 memset(orb->request.command_block,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001217 0, sizeof(orb->request.command_block));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001218 memcpy(orb->request.command_block, cmd->cmnd, COMMAND_SIZE(*cmd->cmnd));
1219
1220 orb->base.callback = complete_command_orb;
Stefan Richter85263922007-07-02 21:04:08 +02001221 orb->base.request_bus =
1222 dma_map_single(device->card->device, &orb->request,
1223 sizeof(orb->request), DMA_TO_DEVICE);
1224 if (dma_mapping_error(orb->base.request_bus))
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001225 goto out;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001226
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001227 sbp2_send_orb(&orb->base, lu, lu->tgt->node_id, lu->generation,
1228 lu->command_block_agent_address + SBP2_ORB_POINTER);
1229 retval = 0;
1230 out:
Kristian Høgsberge57d2012007-08-24 18:59:58 -04001231 kref_put(&orb->base.kref, free_orb);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001232 return retval;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001233}
1234
Stefan Richtercfb01382007-01-23 21:20:08 +01001235static int sbp2_scsi_slave_alloc(struct scsi_device *sdev)
1236{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001237 struct sbp2_logical_unit *lu = sdev->hostdata;
Stefan Richtercfb01382007-01-23 21:20:08 +01001238
1239 sdev->allow_restart = 1;
1240
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001241 if (lu->tgt->workarounds & SBP2_WORKAROUND_INQUIRY_36)
Stefan Richtercfb01382007-01-23 21:20:08 +01001242 sdev->inquiry_len = 36;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001243
Stefan Richtercfb01382007-01-23 21:20:08 +01001244 return 0;
1245}
1246
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001247static int sbp2_scsi_slave_configure(struct scsi_device *sdev)
1248{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001249 struct sbp2_logical_unit *lu = sdev->hostdata;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001250
Stefan Richtercfb01382007-01-23 21:20:08 +01001251 sdev->use_10_for_rw = 1;
1252
1253 if (sdev->type == TYPE_ROM)
1254 sdev->use_10_for_ms = 1;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001255
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001256 if (sdev->type == TYPE_DISK &&
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001257 lu->tgt->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001258 sdev->skip_ms_page_8 = 1;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001259
1260 if (lu->tgt->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001261 sdev->fix_capacity = 1;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001262
1263 if (lu->tgt->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
Stefan Richtercf47c7a2007-06-17 23:52:08 +02001264 blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001265
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001266 return 0;
1267}
1268
1269/*
1270 * Called by scsi stack when something has really gone wrong. Usually
1271 * called when a command has timed-out for some reason.
1272 */
1273static int sbp2_scsi_abort(struct scsi_cmnd *cmd)
1274{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001275 struct sbp2_logical_unit *lu = cmd->device->hostdata;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001276
1277 fw_notify("sbp2_scsi_abort\n");
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001278 sbp2_agent_reset(lu);
1279 sbp2_cancel_orbs(lu);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001280
1281 return SUCCESS;
1282}
1283
Stefan Richter14e21982007-05-27 13:18:27 +02001284/*
1285 * Format of /sys/bus/scsi/devices/.../ieee1394_id:
1286 * u64 EUI-64 : u24 directory_ID : u16 LUN (all printed in hexadecimal)
1287 *
1288 * This is the concatenation of target port identifier and logical unit
1289 * identifier as per SAM-2...SAM-4 annex A.
1290 */
1291static ssize_t
1292sbp2_sysfs_ieee1394_id_show(struct device *dev, struct device_attribute *attr,
1293 char *buf)
1294{
1295 struct scsi_device *sdev = to_scsi_device(dev);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001296 struct sbp2_logical_unit *lu;
Stefan Richter14e21982007-05-27 13:18:27 +02001297 struct fw_device *device;
Stefan Richter14e21982007-05-27 13:18:27 +02001298
1299 if (!sdev)
1300 return 0;
Stefan Richter14e21982007-05-27 13:18:27 +02001301
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001302 lu = sdev->hostdata;
1303 device = fw_device(lu->tgt->unit->device.parent);
Stefan Richter14e21982007-05-27 13:18:27 +02001304
1305 return sprintf(buf, "%08x%08x:%06x:%04x\n",
1306 device->config_rom[3], device->config_rom[4],
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001307 lu->tgt->directory_id, lu->lun);
Stefan Richter14e21982007-05-27 13:18:27 +02001308}
1309
1310static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
1311
1312static struct device_attribute *sbp2_scsi_sysfs_attrs[] = {
1313 &dev_attr_ieee1394_id,
1314 NULL
1315};
1316
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001317static struct scsi_host_template scsi_driver_template = {
1318 .module = THIS_MODULE,
1319 .name = "SBP-2 IEEE-1394",
Kristian Høgsbergb02b6bc2007-05-09 19:23:12 -04001320 .proc_name = sbp2_driver_name,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001321 .queuecommand = sbp2_scsi_queuecommand,
Stefan Richtercfb01382007-01-23 21:20:08 +01001322 .slave_alloc = sbp2_scsi_slave_alloc,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001323 .slave_configure = sbp2_scsi_slave_configure,
1324 .eh_abort_handler = sbp2_scsi_abort,
1325 .this_id = -1,
1326 .sg_tablesize = SG_ALL,
1327 .use_clustering = ENABLE_CLUSTERING,
Stefan Richter02af8e72007-01-21 20:50:11 +01001328 .cmd_per_lun = 1,
1329 .can_queue = 1,
Stefan Richter14e21982007-05-27 13:18:27 +02001330 .sdev_attrs = sbp2_scsi_sysfs_attrs,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001331};
1332
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001333MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
1334MODULE_DESCRIPTION("SCSI over IEEE1394");
1335MODULE_LICENSE("GPL");
1336MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
1337
Olaf Hering1e4c7b02007-05-05 23:17:13 +02001338/* Provide a module alias so root-on-sbp2 initrds don't break. */
1339#ifndef CONFIG_IEEE1394_SBP2_MODULE
1340MODULE_ALIAS("sbp2");
1341#endif
1342
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001343static int __init sbp2_init(void)
1344{
Stefan Richterdf8ec242007-08-12 12:51:18 +02001345 sbp2_wq = create_singlethread_workqueue(KBUILD_MODNAME);
1346 if (!sbp2_wq)
1347 return -ENOMEM;
1348
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001349 return driver_register(&sbp2_driver.driver);
1350}
1351
1352static void __exit sbp2_cleanup(void)
1353{
1354 driver_unregister(&sbp2_driver.driver);
Stefan Richterdf8ec242007-08-12 12:51:18 +02001355 destroy_workqueue(sbp2_wq);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001356}
1357
1358module_init(sbp2_init);
1359module_exit(sbp2_cleanup);