blob: 2108cd92451bc06ef22f6ffc824e3371e7d048c9 [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øgsberg82eff9d2007-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 Richter285838e2007-11-07 01:12:51 +0100631/*
632 * Always get the target's kref when scheduling work on one its units.
633 * Each workqueue job is responsible to call sbp2_target_put() upon return.
634 */
635static void sbp2_queue_work(struct sbp2_logical_unit *lu, unsigned long delay)
636{
637 if (queue_delayed_work(sbp2_wq, &lu->work, delay))
638 kref_get(&lu->tgt->kref);
639}
640
641static void sbp2_target_put(struct sbp2_target *tgt)
642{
643 kref_put(&tgt->kref, sbp2_release_target);
644}
645
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200646static void sbp2_reconnect(struct work_struct *work);
647
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500648static void sbp2_login(struct work_struct *work)
649{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200650 struct sbp2_logical_unit *lu =
651 container_of(work, struct sbp2_logical_unit, work.work);
652 struct Scsi_Host *shost =
653 container_of((void *)lu->tgt, struct Scsi_Host, hostdata[0]);
654 struct scsi_device *sdev;
655 struct scsi_lun eight_bytes_lun;
656 struct fw_unit *unit = lu->tgt->unit;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500657 struct fw_device *device = fw_device(unit->device.parent);
658 struct sbp2_login_response response;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200659 int generation, node_id, local_node_id;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500660
661 generation = device->card->generation;
662 node_id = device->node->node_id;
663 local_node_id = device->card->local_node->node_id;
664
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200665 if (sbp2_send_management_orb(lu, node_id, generation,
666 SBP2_LOGIN_REQUEST, lu->lun, &response) < 0) {
Stefan Richter285838e2007-11-07 01:12:51 +0100667 if (lu->retries++ < 5)
668 sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
669 else
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200670 fw_error("failed to login to %s LUN %04x\n",
671 unit->device.bus_id, lu->lun);
Stefan Richter285838e2007-11-07 01:12:51 +0100672 goto out;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500673 }
674
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200675 lu->generation = generation;
676 lu->tgt->node_id = node_id;
677 lu->tgt->address_high = local_node_id << 16;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500678
679 /* Get command block agent offset and login id. */
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200680 lu->command_block_agent_address =
Kristian Høgsberg5c5539d2007-03-07 12:12:45 -0500681 ((u64) (response.command_block_agent.high & 0xffff) << 32) |
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500682 response.command_block_agent.low;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200683 lu->login_id = LOGIN_RESPONSE_GET_LOGIN_ID(response);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500684
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200685 fw_notify("logged in to %s LUN %04x (%d retries)\n",
686 unit->device.bus_id, lu->lun, lu->retries);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500687
688#if 0
689 /* FIXME: The linux1394 sbp2 does this last step. */
690 sbp2_set_busy_timeout(scsi_id);
691#endif
692
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200693 PREPARE_DELAYED_WORK(&lu->work, sbp2_reconnect);
694 sbp2_agent_reset(lu);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500695
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200696 memset(&eight_bytes_lun, 0, sizeof(eight_bytes_lun));
697 eight_bytes_lun.scsi_lun[0] = (lu->lun >> 8) & 0xff;
698 eight_bytes_lun.scsi_lun[1] = lu->lun & 0xff;
699
700 sdev = __scsi_add_device(shost, 0, 0,
701 scsilun_to_int(&eight_bytes_lun), lu);
702 if (IS_ERR(sdev)) {
703 sbp2_send_management_orb(lu, node_id, generation,
704 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
Kristian Høgsbergc781c062007-05-07 20:33:32 -0400705 /*
706 * Set this back to sbp2_login so we fall back and
707 * retry login on bus reset.
708 */
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200709 PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
710 } else {
711 lu->sdev = sdev;
712 scsi_device_put(sdev);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500713 }
Stefan Richter285838e2007-11-07 01:12:51 +0100714 out:
715 sbp2_target_put(lu->tgt);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500716}
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500717
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200718static int sbp2_add_logical_unit(struct sbp2_target *tgt, int lun_entry)
719{
720 struct sbp2_logical_unit *lu;
721
722 lu = kmalloc(sizeof(*lu), GFP_KERNEL);
723 if (!lu)
724 return -ENOMEM;
725
726 lu->address_handler.length = 0x100;
727 lu->address_handler.address_callback = sbp2_status_write;
728 lu->address_handler.callback_data = lu;
729
730 if (fw_core_add_address_handler(&lu->address_handler,
731 &fw_high_memory_region) < 0) {
732 kfree(lu);
733 return -ENOMEM;
734 }
735
736 lu->tgt = tgt;
737 lu->sdev = NULL;
738 lu->lun = lun_entry & 0xffff;
739 lu->retries = 0;
740 INIT_LIST_HEAD(&lu->orb_list);
741 INIT_DELAYED_WORK(&lu->work, sbp2_login);
742
743 list_add_tail(&lu->link, &tgt->lu_list);
744 return 0;
745}
746
747static int sbp2_scan_logical_unit_dir(struct sbp2_target *tgt, u32 *directory)
748{
749 struct fw_csr_iterator ci;
750 int key, value;
751
752 fw_csr_iterator_init(&ci, directory);
753 while (fw_csr_iterator_next(&ci, &key, &value))
754 if (key == SBP2_CSR_LOGICAL_UNIT_NUMBER &&
755 sbp2_add_logical_unit(tgt, value) < 0)
756 return -ENOMEM;
757 return 0;
758}
759
760static int sbp2_scan_unit_dir(struct sbp2_target *tgt, u32 *directory,
761 u32 *model, u32 *firmware_revision)
762{
763 struct fw_csr_iterator ci;
764 int key, value;
765
766 fw_csr_iterator_init(&ci, directory);
767 while (fw_csr_iterator_next(&ci, &key, &value)) {
768 switch (key) {
769
770 case CSR_DEPENDENT_INFO | CSR_OFFSET:
771 tgt->management_agent_address =
772 CSR_REGISTER_BASE + 4 * value;
773 break;
774
775 case CSR_DIRECTORY_ID:
776 tgt->directory_id = value;
777 break;
778
779 case CSR_MODEL:
780 *model = value;
781 break;
782
783 case SBP2_CSR_FIRMWARE_REVISION:
784 *firmware_revision = value;
785 break;
786
787 case SBP2_CSR_LOGICAL_UNIT_NUMBER:
788 if (sbp2_add_logical_unit(tgt, value) < 0)
789 return -ENOMEM;
790 break;
791
792 case SBP2_CSR_LOGICAL_UNIT_DIRECTORY:
793 if (sbp2_scan_logical_unit_dir(tgt, ci.p + value) < 0)
794 return -ENOMEM;
795 break;
796 }
797 }
798 return 0;
799}
800
801static void sbp2_init_workarounds(struct sbp2_target *tgt, u32 model,
802 u32 firmware_revision)
803{
804 int i;
Stefan Richter2df222b2007-08-13 17:48:25 +0200805 unsigned w = sbp2_param_workarounds;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200806
Stefan Richter2df222b2007-08-13 17:48:25 +0200807 if (w)
808 fw_notify("Please notify linux1394-devel@lists.sourceforge.net "
809 "if you need the workarounds parameter for %s\n",
810 tgt->unit->device.bus_id);
811
812 if (w & SBP2_WORKAROUND_OVERRIDE)
813 goto out;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200814
815 for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
816
817 if (sbp2_workarounds_table[i].firmware_revision !=
818 (firmware_revision & 0xffffff00))
819 continue;
820
821 if (sbp2_workarounds_table[i].model != model &&
822 sbp2_workarounds_table[i].model != ~0)
823 continue;
824
Stefan Richter2df222b2007-08-13 17:48:25 +0200825 w |= sbp2_workarounds_table[i].workarounds;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200826 break;
827 }
Stefan Richter2df222b2007-08-13 17:48:25 +0200828 out:
829 if (w)
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200830 fw_notify("Workarounds for %s: 0x%x "
831 "(firmware_revision 0x%06x, model_id 0x%06x)\n",
832 tgt->unit->device.bus_id,
Stefan Richter2df222b2007-08-13 17:48:25 +0200833 w, firmware_revision, model);
834 tgt->workarounds = w;
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200835}
836
837static struct scsi_host_template scsi_driver_template;
838
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500839static int sbp2_probe(struct device *dev)
840{
841 struct fw_unit *unit = fw_unit(dev);
842 struct fw_device *device = fw_device(unit->device.parent);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200843 struct sbp2_target *tgt;
844 struct sbp2_logical_unit *lu;
845 struct Scsi_Host *shost;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500846 u32 model, firmware_revision;
847
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200848 shost = scsi_host_alloc(&scsi_driver_template, sizeof(*tgt));
849 if (shost == NULL)
850 return -ENOMEM;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500851
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200852 tgt = (struct sbp2_target *)shost->hostdata;
853 unit->device.driver_data = tgt;
854 tgt->unit = unit;
855 kref_init(&tgt->kref);
856 INIT_LIST_HEAD(&tgt->lu_list);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500857
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200858 if (fw_device_enable_phys_dma(device) < 0)
859 goto fail_shost_put;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500860
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200861 if (scsi_add_host(shost, &unit->device) < 0)
862 goto fail_shost_put;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500863
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200864 /* Initialize to values that won't match anything in our table. */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500865 firmware_revision = 0xff000000;
866 model = 0xff000000;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500867
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200868 /* implicit directory ID */
869 tgt->directory_id = ((unit->directory - device->config_rom) * 4
870 + CSR_CONFIG_ROM) & 0xffffff;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500871
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200872 if (sbp2_scan_unit_dir(tgt, unit->directory, &model,
873 &firmware_revision) < 0)
874 goto fail_tgt_put;
875
876 sbp2_init_workarounds(tgt, model, firmware_revision);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500877
Kristian Høgsbergb3d6e152007-03-14 17:34:58 -0400878 get_device(&unit->device);
879
Stefan Richter285838e2007-11-07 01:12:51 +0100880 /* Do the login in a workqueue so we can easily reschedule retries. */
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200881 list_for_each_entry(lu, &tgt->lu_list, link)
Stefan Richter285838e2007-11-07 01:12:51 +0100882 sbp2_queue_work(lu, 0);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500883 return 0;
Kristian Høgsbergad852742007-05-09 19:23:07 -0400884
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200885 fail_tgt_put:
Stefan Richter285838e2007-11-07 01:12:51 +0100886 sbp2_target_put(tgt);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200887 return -ENOMEM;
888
889 fail_shost_put:
890 scsi_host_put(shost);
891 return -ENOMEM;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500892}
893
894static int sbp2_remove(struct device *dev)
895{
896 struct fw_unit *unit = fw_unit(dev);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200897 struct sbp2_target *tgt = unit->device.driver_data;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500898
Stefan Richter285838e2007-11-07 01:12:51 +0100899 sbp2_target_put(tgt);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500900 return 0;
901}
902
903static void sbp2_reconnect(struct work_struct *work)
904{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200905 struct sbp2_logical_unit *lu =
906 container_of(work, struct sbp2_logical_unit, work.work);
907 struct fw_unit *unit = lu->tgt->unit;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500908 struct fw_device *device = fw_device(unit->device.parent);
909 int generation, node_id, local_node_id;
910
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500911 generation = device->card->generation;
912 node_id = device->node->node_id;
913 local_node_id = device->card->local_node->node_id;
914
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200915 if (sbp2_send_management_orb(lu, node_id, generation,
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500916 SBP2_RECONNECT_REQUEST,
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200917 lu->login_id, NULL) < 0) {
918 if (lu->retries++ >= 5) {
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500919 fw_error("failed to reconnect to %s\n",
920 unit->device.bus_id);
921 /* Fall back and try to log in again. */
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200922 lu->retries = 0;
923 PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500924 }
Stefan Richter285838e2007-11-07 01:12:51 +0100925 sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
926 goto out;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500927 }
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500928
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200929 lu->generation = generation;
930 lu->tgt->node_id = node_id;
931 lu->tgt->address_high = local_node_id << 16;
Kristian Høgsberg7f37c422007-02-06 14:49:34 -0500932
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200933 fw_notify("reconnected to %s LUN %04x (%d retries)\n",
934 unit->device.bus_id, lu->lun, lu->retries);
935
936 sbp2_agent_reset(lu);
937 sbp2_cancel_orbs(lu);
Stefan Richter285838e2007-11-07 01:12:51 +0100938 out:
939 sbp2_target_put(lu->tgt);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500940}
941
942static void sbp2_update(struct fw_unit *unit)
943{
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200944 struct sbp2_target *tgt = unit->device.driver_data;
945 struct sbp2_logical_unit *lu;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500946
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200947 fw_device_enable_phys_dma(fw_device(unit->device.parent));
948
949 /*
950 * Fw-core serializes sbp2_update() against sbp2_remove().
951 * Iteration over tgt->lu_list is therefore safe here.
952 */
953 list_for_each_entry(lu, &tgt->lu_list, link) {
954 lu->retries = 0;
Stefan Richter285838e2007-11-07 01:12:51 +0100955 sbp2_queue_work(lu, 0);
Stefan Richter5a3c2be2007-08-25 14:05:28 +0200956 }
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500957}
958
959#define SBP2_UNIT_SPEC_ID_ENTRY 0x0000609e
960#define SBP2_SW_VERSION_ENTRY 0x00010483
961
Stefan Richter21ebcd12007-01-14 15:29:07 +0100962static const struct fw_device_id sbp2_id_table[] = {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500963 {
964 .match_flags = FW_MATCH_SPECIFIER_ID | FW_MATCH_VERSION,
965 .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY,
Stefan Richter5af4e5e2007-01-21 20:45:32 +0100966 .version = SBP2_SW_VERSION_ENTRY,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500967 },
968 { }
969};
970
971static struct fw_driver sbp2_driver = {
972 .driver = {
973 .owner = THIS_MODULE,
974 .name = sbp2_driver_name,
975 .bus = &fw_bus_type,
976 .probe = sbp2_probe,
977 .remove = sbp2_remove,
978 },
979 .update = sbp2_update,
980 .id_table = sbp2_id_table,
981};
982
Kristian Høgsbergfbb54232007-04-10 18:11:18 -0400983static unsigned int
984sbp2_status_to_sense_data(u8 *sbp2_status, u8 *sense_data)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500985{
Kristian Høgsbergfbb54232007-04-10 18:11:18 -0400986 int sam_status;
987
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -0500988 sense_data[0] = 0x70;
989 sense_data[1] = 0x0;
990 sense_data[2] = sbp2_status[1];
991 sense_data[3] = sbp2_status[4];
992 sense_data[4] = sbp2_status[5];
993 sense_data[5] = sbp2_status[6];
994 sense_data[6] = sbp2_status[7];
995 sense_data[7] = 10;
996 sense_data[8] = sbp2_status[8];
997 sense_data[9] = sbp2_status[9];
998 sense_data[10] = sbp2_status[10];
999 sense_data[11] = sbp2_status[11];
1000 sense_data[12] = sbp2_status[2];
1001 sense_data[13] = sbp2_status[3];
1002 sense_data[14] = sbp2_status[12];
1003 sense_data[15] = sbp2_status[13];
1004
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001005 sam_status = sbp2_status[0] & 0x3f;
1006
1007 switch (sam_status) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001008 case SAM_STAT_GOOD:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001009 case SAM_STAT_CHECK_CONDITION:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001010 case SAM_STAT_CONDITION_MET:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001011 case SAM_STAT_BUSY:
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001012 case SAM_STAT_RESERVATION_CONFLICT:
1013 case SAM_STAT_COMMAND_TERMINATED:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001014 return DID_OK << 16 | sam_status;
1015
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001016 default:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001017 return DID_ERROR << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001018 }
1019}
1020
1021static void
1022complete_command_orb(struct sbp2_orb *base_orb, struct sbp2_status *status)
1023{
Jay Fenlason6f061482007-06-27 16:04:33 -04001024 struct sbp2_command_orb *orb =
1025 container_of(base_orb, struct sbp2_command_orb, base);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001026 struct fw_device *device = fw_device(orb->lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001027 int result;
1028
1029 if (status != NULL) {
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001030 if (STATUS_GET_DEAD(*status))
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001031 sbp2_agent_reset(orb->lu);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001032
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001033 switch (STATUS_GET_RESPONSE(*status)) {
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001034 case SBP2_STATUS_REQUEST_COMPLETE:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001035 result = DID_OK << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001036 break;
1037 case SBP2_STATUS_TRANSPORT_FAILURE:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001038 result = DID_BUS_BUSY << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001039 break;
1040 case SBP2_STATUS_ILLEGAL_REQUEST:
1041 case SBP2_STATUS_VENDOR_DEPENDENT:
1042 default:
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001043 result = DID_ERROR << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001044 break;
1045 }
1046
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001047 if (result == DID_OK << 16 && STATUS_GET_LEN(*status) > 1)
1048 result = sbp2_status_to_sense_data(STATUS_GET_DATA(*status),
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001049 orb->cmd->sense_buffer);
1050 } else {
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001051 /*
1052 * If the orb completes with status == NULL, something
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001053 * went wrong, typically a bus reset happened mid-orb
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001054 * or when sending the write (less likely).
1055 */
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001056 result = DID_BUS_BUSY << 16;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001057 }
1058
1059 dma_unmap_single(device->card->device, orb->base.request_bus,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001060 sizeof(orb->request), DMA_TO_DEVICE);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001061
Stefan Richter412edf62007-07-16 21:05:41 +02001062 if (scsi_sg_count(orb->cmd) > 0)
1063 dma_unmap_sg(device->card->device, scsi_sglist(orb->cmd),
1064 scsi_sg_count(orb->cmd),
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001065 orb->cmd->sc_data_direction);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001066
1067 if (orb->page_table_bus != 0)
1068 dma_unmap_single(device->card->device, orb->page_table_bus,
Stefan Richterb4be0162007-07-02 22:07:34 +02001069 sizeof(orb->page_table), DMA_TO_DEVICE);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001070
Kristian Høgsbergfbb54232007-04-10 18:11:18 -04001071 orb->cmd->result = result;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001072 orb->done(orb->cmd);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001073}
1074
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001075static int
1076sbp2_map_scatterlist(struct sbp2_command_orb *orb, struct fw_device *device,
1077 struct sbp2_logical_unit *lu)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001078{
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001079 struct scatterlist *sg;
1080 int sg_len, l, i, j, count;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001081 dma_addr_t sg_addr;
1082
Stefan Richter412edf62007-07-16 21:05:41 +02001083 sg = scsi_sglist(orb->cmd);
1084 count = dma_map_sg(device->card->device, sg, scsi_sg_count(orb->cmd),
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001085 orb->cmd->sc_data_direction);
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001086 if (count == 0)
1087 goto fail;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001088
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001089 /*
1090 * Handle the special case where there is only one element in
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001091 * the scatter list by converting it to an immediate block
1092 * request. This is also a workaround for broken devices such
1093 * as the second generation iPod which doesn't support page
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001094 * tables.
1095 */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001096 if (count == 1 && sg_dma_len(sg) < SBP2_MAX_SG_ELEMENT_LENGTH) {
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001097 orb->request.data_descriptor.high = lu->tgt->address_high;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001098 orb->request.data_descriptor.low = sg_dma_address(sg);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001099 orb->request.misc |= COMMAND_ORB_DATA_SIZE(sg_dma_len(sg));
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001100 return 0;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001101 }
1102
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001103 /*
1104 * Convert the scatterlist to an sbp2 page table. If any
Kristian Høgsberg, Stefan Richter36abb3b2007-05-09 19:23:10 -04001105 * scatterlist entries are too big for sbp2, we split them as we
1106 * go. Even if we ask the block I/O layer to not give us sg
1107 * elements larger than 65535 bytes, some IOMMUs may merge sg elements
1108 * during DMA mapping, and Linux currently doesn't prevent this.
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001109 */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001110 for (i = 0, j = 0; i < count; i++) {
1111 sg_len = sg_dma_len(sg + i);
1112 sg_addr = sg_dma_address(sg + i);
1113 while (sg_len) {
Stefan Richter332ef332007-07-01 13:56:03 +02001114 /* FIXME: This won't get us out of the pinch. */
1115 if (unlikely(j >= ARRAY_SIZE(orb->page_table))) {
1116 fw_error("page table overflow\n");
1117 goto fail_page_table;
1118 }
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001119 l = min(sg_len, SBP2_MAX_SG_ELEMENT_LENGTH);
1120 orb->page_table[j].low = sg_addr;
1121 orb->page_table[j].high = (l << 16);
1122 sg_addr += l;
1123 sg_len -= l;
1124 j++;
1125 }
1126 }
1127
Stefan Richterb4be0162007-07-02 22:07:34 +02001128 fw_memcpy_to_be32(orb->page_table, orb->page_table,
1129 sizeof(orb->page_table[0]) * j);
1130 orb->page_table_bus =
1131 dma_map_single(device->card->device, orb->page_table,
1132 sizeof(orb->page_table), DMA_TO_DEVICE);
1133 if (dma_mapping_error(orb->page_table_bus))
1134 goto fail_page_table;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001135
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001136 /*
1137 * The data_descriptor pointer is the one case where we need
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001138 * to fill in the node ID part of the address. All other
1139 * pointers assume that the data referenced reside on the
1140 * initiator (i.e. us), but data_descriptor can refer to data
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001141 * on other nodes so we need to put our ID in descriptor.high.
1142 */
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001143 orb->request.data_descriptor.high = lu->tgt->address_high;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001144 orb->request.data_descriptor.low = orb->page_table_bus;
1145 orb->request.misc |=
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001146 COMMAND_ORB_PAGE_TABLE_PRESENT |
1147 COMMAND_ORB_DATA_SIZE(j);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001148
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001149 return 0;
1150
1151 fail_page_table:
Stefan Richter412edf62007-07-16 21:05:41 +02001152 dma_unmap_sg(device->card->device, sg, scsi_sg_count(orb->cmd),
Kristian Høgsberg95ffc5e2007-05-09 19:23:08 -04001153 orb->cmd->sc_data_direction);
1154 fail:
1155 return -ENOMEM;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001156}
1157
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001158/* SCSI stack integration */
1159
1160static int sbp2_scsi_queuecommand(struct scsi_cmnd *cmd, scsi_done_fn_t done)
1161{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001162 struct sbp2_logical_unit *lu = cmd->device->hostdata;
1163 struct fw_device *device = fw_device(lu->tgt->unit->device.parent);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001164 struct sbp2_command_orb *orb;
Stefan Richter25659f72007-07-21 22:43:05 +02001165 unsigned max_payload;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001166 int retval = SCSI_MLQUEUE_HOST_BUSY;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001167
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001168 /*
1169 * Bidirectional commands are not yet implemented, and unknown
1170 * transfer direction not handled.
1171 */
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001172 if (cmd->sc_data_direction == DMA_BIDIRECTIONAL) {
Stefan Richter8a8cea22007-06-09 19:26:22 +02001173 fw_error("Can't handle DMA_BIDIRECTIONAL, rejecting command\n");
Kristian Høgsberge1b68c42007-05-09 19:23:09 -04001174 cmd->result = DID_ERROR << 16;
1175 done(cmd);
1176 return 0;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001177 }
1178
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001179 orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001180 if (orb == NULL) {
1181 fw_notify("failed to alloc orb\n");
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001182 return SCSI_MLQUEUE_HOST_BUSY;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001183 }
1184
Kristian Høgsberg12f26aa2007-04-10 18:11:20 -04001185 /* Initialize rcode to something not RCODE_COMPLETE. */
1186 orb->base.rcode = -1;
Kristian Høgsberge57d2012007-08-24 18:59:58 -04001187 kref_init(&orb->base.kref);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001188
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001189 orb->lu = lu;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001190 orb->done = done;
1191 orb->cmd = cmd;
1192
1193 orb->request.next.high = SBP2_ORB_NULL;
1194 orb->request.next.low = 0x0;
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001195 /*
1196 * At speed 100 we can do 512 bytes per packet, at speed 200,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001197 * 1024 bytes per packet etc. The SBP-2 max_payload field
1198 * specifies the max payload size as 2 ^ (max_payload + 2), so
Kristian Høgsbergc781c062007-05-07 20:33:32 -04001199 * if we set this to max_speed + 7, we get the right value.
1200 */
Stefan Richter25659f72007-07-21 22:43:05 +02001201 max_payload = min(device->max_speed + 7,
1202 device->card->max_receive - 1);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001203 orb->request.misc =
Stefan Richter25659f72007-07-21 22:43:05 +02001204 COMMAND_ORB_MAX_PAYLOAD(max_payload) |
Stefan Richterf1397492007-06-10 21:31:36 +02001205 COMMAND_ORB_SPEED(device->max_speed) |
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001206 COMMAND_ORB_NOTIFY;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001207
1208 if (cmd->sc_data_direction == DMA_FROM_DEVICE)
1209 orb->request.misc |=
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001210 COMMAND_ORB_DIRECTION(SBP2_DIRECTION_FROM_MEDIA);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001211 else if (cmd->sc_data_direction == DMA_TO_DEVICE)
1212 orb->request.misc |=
Kristian Høgsberga77754a2007-05-07 20:33:35 -04001213 COMMAND_ORB_DIRECTION(SBP2_DIRECTION_TO_MEDIA);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001214
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001215 if (scsi_sg_count(cmd) && sbp2_map_scatterlist(orb, device, lu) < 0)
1216 goto out;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001217
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001218 fw_memcpy_to_be32(&orb->request, &orb->request, sizeof(orb->request));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001219
1220 memset(orb->request.command_block,
Kristian Høgsberg2d826cc2007-05-09 19:23:14 -04001221 0, sizeof(orb->request.command_block));
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001222 memcpy(orb->request.command_block, cmd->cmnd, COMMAND_SIZE(*cmd->cmnd));
1223
1224 orb->base.callback = complete_command_orb;
Stefan Richter85263922007-07-02 21:04:08 +02001225 orb->base.request_bus =
1226 dma_map_single(device->card->device, &orb->request,
1227 sizeof(orb->request), DMA_TO_DEVICE);
1228 if (dma_mapping_error(orb->base.request_bus))
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001229 goto out;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001230
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001231 sbp2_send_orb(&orb->base, lu, lu->tgt->node_id, lu->generation,
1232 lu->command_block_agent_address + SBP2_ORB_POINTER);
1233 retval = 0;
1234 out:
Kristian Høgsberge57d2012007-08-24 18:59:58 -04001235 kref_put(&orb->base.kref, free_orb);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001236 return retval;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001237}
1238
Stefan Richtercfb01382007-01-23 21:20:08 +01001239static int sbp2_scsi_slave_alloc(struct scsi_device *sdev)
1240{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001241 struct sbp2_logical_unit *lu = sdev->hostdata;
Stefan Richtercfb01382007-01-23 21:20:08 +01001242
1243 sdev->allow_restart = 1;
1244
James Bottomley465ff312008-01-01 10:00:10 -06001245 /*
1246 * Update the dma alignment (minimum alignment requirements for
1247 * start and end of DMA transfers) to be a sector
1248 */
1249 blk_queue_update_dma_alignment(sdev->request_queue, 511);
1250
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001251 if (lu->tgt->workarounds & SBP2_WORKAROUND_INQUIRY_36)
Stefan Richtercfb01382007-01-23 21:20:08 +01001252 sdev->inquiry_len = 36;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001253
Stefan Richtercfb01382007-01-23 21:20:08 +01001254 return 0;
1255}
1256
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001257static int sbp2_scsi_slave_configure(struct scsi_device *sdev)
1258{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001259 struct sbp2_logical_unit *lu = sdev->hostdata;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001260
Stefan Richtercfb01382007-01-23 21:20:08 +01001261 sdev->use_10_for_rw = 1;
1262
1263 if (sdev->type == TYPE_ROM)
1264 sdev->use_10_for_ms = 1;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001265
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001266 if (sdev->type == TYPE_DISK &&
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001267 lu->tgt->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001268 sdev->skip_ms_page_8 = 1;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001269
1270 if (lu->tgt->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001271 sdev->fix_capacity = 1;
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001272
1273 if (lu->tgt->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
Stefan Richtercf47c7a2007-06-17 23:52:08 +02001274 blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001275
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001276 return 0;
1277}
1278
1279/*
1280 * Called by scsi stack when something has really gone wrong. Usually
1281 * called when a command has timed-out for some reason.
1282 */
1283static int sbp2_scsi_abort(struct scsi_cmnd *cmd)
1284{
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001285 struct sbp2_logical_unit *lu = cmd->device->hostdata;
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001286
1287 fw_notify("sbp2_scsi_abort\n");
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001288 sbp2_agent_reset(lu);
1289 sbp2_cancel_orbs(lu);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001290
1291 return SUCCESS;
1292}
1293
Stefan Richter14e21982007-05-27 13:18:27 +02001294/*
1295 * Format of /sys/bus/scsi/devices/.../ieee1394_id:
1296 * u64 EUI-64 : u24 directory_ID : u16 LUN (all printed in hexadecimal)
1297 *
1298 * This is the concatenation of target port identifier and logical unit
1299 * identifier as per SAM-2...SAM-4 annex A.
1300 */
1301static ssize_t
1302sbp2_sysfs_ieee1394_id_show(struct device *dev, struct device_attribute *attr,
1303 char *buf)
1304{
1305 struct scsi_device *sdev = to_scsi_device(dev);
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001306 struct sbp2_logical_unit *lu;
Stefan Richter14e21982007-05-27 13:18:27 +02001307 struct fw_device *device;
Stefan Richter14e21982007-05-27 13:18:27 +02001308
1309 if (!sdev)
1310 return 0;
Stefan Richter14e21982007-05-27 13:18:27 +02001311
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001312 lu = sdev->hostdata;
1313 device = fw_device(lu->tgt->unit->device.parent);
Stefan Richter14e21982007-05-27 13:18:27 +02001314
1315 return sprintf(buf, "%08x%08x:%06x:%04x\n",
1316 device->config_rom[3], device->config_rom[4],
Stefan Richter5a3c2be2007-08-25 14:05:28 +02001317 lu->tgt->directory_id, lu->lun);
Stefan Richter14e21982007-05-27 13:18:27 +02001318}
1319
1320static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
1321
1322static struct device_attribute *sbp2_scsi_sysfs_attrs[] = {
1323 &dev_attr_ieee1394_id,
1324 NULL
1325};
1326
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001327static struct scsi_host_template scsi_driver_template = {
1328 .module = THIS_MODULE,
1329 .name = "SBP-2 IEEE-1394",
Kristian Høgsbergb02b6bc2007-05-09 19:23:12 -04001330 .proc_name = sbp2_driver_name,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001331 .queuecommand = sbp2_scsi_queuecommand,
Stefan Richtercfb01382007-01-23 21:20:08 +01001332 .slave_alloc = sbp2_scsi_slave_alloc,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001333 .slave_configure = sbp2_scsi_slave_configure,
1334 .eh_abort_handler = sbp2_scsi_abort,
1335 .this_id = -1,
1336 .sg_tablesize = SG_ALL,
1337 .use_clustering = ENABLE_CLUSTERING,
Stefan Richter02af8e72007-01-21 20:50:11 +01001338 .cmd_per_lun = 1,
1339 .can_queue = 1,
Stefan Richter14e21982007-05-27 13:18:27 +02001340 .sdev_attrs = sbp2_scsi_sysfs_attrs,
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001341};
1342
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001343MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
1344MODULE_DESCRIPTION("SCSI over IEEE1394");
1345MODULE_LICENSE("GPL");
1346MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
1347
Olaf Hering1e4c7b02007-05-05 23:17:13 +02001348/* Provide a module alias so root-on-sbp2 initrds don't break. */
1349#ifndef CONFIG_IEEE1394_SBP2_MODULE
1350MODULE_ALIAS("sbp2");
1351#endif
1352
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001353static int __init sbp2_init(void)
1354{
Stefan Richterdf8ec242007-08-12 12:51:18 +02001355 sbp2_wq = create_singlethread_workqueue(KBUILD_MODNAME);
1356 if (!sbp2_wq)
1357 return -ENOMEM;
1358
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001359 return driver_register(&sbp2_driver.driver);
1360}
1361
1362static void __exit sbp2_cleanup(void)
1363{
1364 driver_unregister(&sbp2_driver.driver);
Stefan Richterdf8ec242007-08-12 12:51:18 +02001365 destroy_workqueue(sbp2_wq);
Kristian Høgsberg9ba136d2006-12-19 19:58:40 -05001366}
1367
1368module_init(sbp2_init);
1369module_exit(sbp2_cleanup);