1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31#include <linux/blkdev.h>
32#include <linux/bug.h>
33#include <linux/completion.h>
34#include <linux/delay.h>
35#include <linux/device.h>
36#include <linux/dma-mapping.h>
37#include <linux/firewire.h>
38#include <linux/firewire-constants.h>
39#include <linux/init.h>
40#include <linux/jiffies.h>
41#include <linux/kernel.h>
42#include <linux/kref.h>
43#include <linux/list.h>
44#include <linux/mod_devicetable.h>
45#include <linux/module.h>
46#include <linux/moduleparam.h>
47#include <linux/scatterlist.h>
48#include <linux/slab.h>
49#include <linux/spinlock.h>
50#include <linux/string.h>
51#include <linux/stringify.h>
52#include <linux/workqueue.h>
53
54#include <asm/byteorder.h>
55#include <asm/system.h>
56
57#include <scsi/scsi.h>
58#include <scsi/scsi_cmnd.h>
59#include <scsi/scsi_device.h>
60#include <scsi/scsi_host.h>
61
62
63
64
65
66
67
68
69static int sbp2_param_exclusive_login = 1;
70module_param_named(exclusive_login, sbp2_param_exclusive_login, bool, 0644);
71MODULE_PARM_DESC(exclusive_login, "Exclusive login to sbp2 device "
72 "(default = Y, use N for concurrent initiators)");
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106#define SBP2_WORKAROUND_128K_MAX_TRANS 0x1
107#define SBP2_WORKAROUND_INQUIRY_36 0x2
108#define SBP2_WORKAROUND_MODE_SENSE_8 0x4
109#define SBP2_WORKAROUND_FIX_CAPACITY 0x8
110#define SBP2_WORKAROUND_DELAY_INQUIRY 0x10
111#define SBP2_INQUIRY_DELAY 12
112#define SBP2_WORKAROUND_POWER_CONDITION 0x20
113#define SBP2_WORKAROUND_OVERRIDE 0x100
114
115static int sbp2_param_workarounds;
116module_param_named(workarounds, sbp2_param_workarounds, int, 0644);
117MODULE_PARM_DESC(workarounds, "Work around device bugs (default = 0"
118 ", 128kB max transfer = " __stringify(SBP2_WORKAROUND_128K_MAX_TRANS)
119 ", 36 byte inquiry = " __stringify(SBP2_WORKAROUND_INQUIRY_36)
120 ", skip mode page 8 = " __stringify(SBP2_WORKAROUND_MODE_SENSE_8)
121 ", fix capacity = " __stringify(SBP2_WORKAROUND_FIX_CAPACITY)
122 ", delay inquiry = " __stringify(SBP2_WORKAROUND_DELAY_INQUIRY)
123 ", set power condition in start stop unit = "
124 __stringify(SBP2_WORKAROUND_POWER_CONDITION)
125 ", override internal blacklist = " __stringify(SBP2_WORKAROUND_OVERRIDE)
126 ", or a combination)");
127
128
129typedef void (*scsi_done_fn_t)(struct scsi_cmnd *);
130
131static const char sbp2_driver_name[] = "sbp2";
132
133
134
135
136
137struct sbp2_logical_unit {
138 struct sbp2_target *tgt;
139 struct list_head link;
140 struct fw_address_handler address_handler;
141 struct list_head orb_list;
142
143 u64 command_block_agent_address;
144 u16 lun;
145 int login_id;
146
147
148
149
150
151
152
153 int generation;
154 int retries;
155 struct delayed_work work;
156 bool has_sdev;
157 bool blocked;
158};
159
160
161
162
163
164struct sbp2_target {
165 struct kref kref;
166 struct fw_unit *unit;
167 const char *bus_id;
168 struct list_head lu_list;
169
170 u64 management_agent_address;
171 u64 guid;
172 int directory_id;
173 int node_id;
174 int address_high;
175 unsigned int workarounds;
176 unsigned int mgt_orb_timeout;
177 unsigned int max_payload;
178
179 int dont_block;
180 int blocked;
181};
182
183static struct fw_device *target_device(struct sbp2_target *tgt)
184{
185 return fw_parent_device(tgt->unit);
186}
187
188
189#define INVALID_LOGIN_ID 0x10000
190
191#define SBP2_ORB_TIMEOUT 2000U
192#define SBP2_ORB_NULL 0x80000000
193#define SBP2_RETRY_LIMIT 0xf
194#define SBP2_CYCLE_LIMIT (0xc8 << 12)
195
196
197
198
199
200#define SBP2_MAX_CDB_SIZE 16
201
202
203
204
205
206
207#define SBP2_MAX_SEG_SIZE 0xfffc
208
209
210#define SBP2_CSR_UNIT_CHARACTERISTICS 0x3a
211#define SBP2_CSR_FIRMWARE_REVISION 0x3c
212#define SBP2_CSR_LOGICAL_UNIT_NUMBER 0x14
213#define SBP2_CSR_LOGICAL_UNIT_DIRECTORY 0xd4
214
215
216#define SBP2_LOGIN_REQUEST 0x0
217#define SBP2_QUERY_LOGINS_REQUEST 0x1
218#define SBP2_RECONNECT_REQUEST 0x3
219#define SBP2_SET_PASSWORD_REQUEST 0x4
220#define SBP2_LOGOUT_REQUEST 0x7
221#define SBP2_ABORT_TASK_REQUEST 0xb
222#define SBP2_ABORT_TASK_SET 0xc
223#define SBP2_LOGICAL_UNIT_RESET 0xe
224#define SBP2_TARGET_RESET_REQUEST 0xf
225
226
227#define SBP2_AGENT_STATE 0x00
228#define SBP2_AGENT_RESET 0x04
229#define SBP2_ORB_POINTER 0x08
230#define SBP2_DOORBELL 0x10
231#define SBP2_UNSOLICITED_STATUS_ENABLE 0x14
232
233
234#define SBP2_STATUS_REQUEST_COMPLETE 0x0
235#define SBP2_STATUS_TRANSPORT_FAILURE 0x1
236#define SBP2_STATUS_ILLEGAL_REQUEST 0x2
237#define SBP2_STATUS_VENDOR_DEPENDENT 0x3
238
239#define STATUS_GET_ORB_HIGH(v) ((v).status & 0xffff)
240#define STATUS_GET_SBP_STATUS(v) (((v).status >> 16) & 0xff)
241#define STATUS_GET_LEN(v) (((v).status >> 24) & 0x07)
242#define STATUS_GET_DEAD(v) (((v).status >> 27) & 0x01)
243#define STATUS_GET_RESPONSE(v) (((v).status >> 28) & 0x03)
244#define STATUS_GET_SOURCE(v) (((v).status >> 30) & 0x03)
245#define STATUS_GET_ORB_LOW(v) ((v).orb_low)
246#define STATUS_GET_DATA(v) ((v).data)
247
248struct sbp2_status {
249 u32 status;
250 u32 orb_low;
251 u8 data[24];
252};
253
254struct sbp2_pointer {
255 __be32 high;
256 __be32 low;
257};
258
259struct sbp2_orb {
260 struct fw_transaction t;
261 struct kref kref;
262 dma_addr_t request_bus;
263 int rcode;
264 struct sbp2_pointer pointer;
265 void (*callback)(struct sbp2_orb * orb, struct sbp2_status * status);
266 struct list_head link;
267};
268
269#define MANAGEMENT_ORB_LUN(v) ((v))
270#define MANAGEMENT_ORB_FUNCTION(v) ((v) << 16)
271#define MANAGEMENT_ORB_RECONNECT(v) ((v) << 20)
272#define MANAGEMENT_ORB_EXCLUSIVE(v) ((v) ? 1 << 28 : 0)
273#define MANAGEMENT_ORB_REQUEST_FORMAT(v) ((v) << 29)
274#define MANAGEMENT_ORB_NOTIFY ((1) << 31)
275
276#define MANAGEMENT_ORB_RESPONSE_LENGTH(v) ((v))
277#define MANAGEMENT_ORB_PASSWORD_LENGTH(v) ((v) << 16)
278
279struct sbp2_management_orb {
280 struct sbp2_orb base;
281 struct {
282 struct sbp2_pointer password;
283 struct sbp2_pointer response;
284 __be32 misc;
285 __be32 length;
286 struct sbp2_pointer status_fifo;
287 } request;
288 __be32 response[4];
289 dma_addr_t response_bus;
290 struct completion done;
291 struct sbp2_status status;
292};
293
294struct sbp2_login_response {
295 __be32 misc;
296 struct sbp2_pointer command_block_agent;
297 __be32 reconnect_hold;
298};
299#define COMMAND_ORB_DATA_SIZE(v) ((v))
300#define COMMAND_ORB_PAGE_SIZE(v) ((v) << 16)
301#define COMMAND_ORB_PAGE_TABLE_PRESENT ((1) << 19)
302#define COMMAND_ORB_MAX_PAYLOAD(v) ((v) << 20)
303#define COMMAND_ORB_SPEED(v) ((v) << 24)
304#define COMMAND_ORB_DIRECTION ((1) << 27)
305#define COMMAND_ORB_REQUEST_FORMAT(v) ((v) << 29)
306#define COMMAND_ORB_NOTIFY ((1) << 31)
307
308struct sbp2_command_orb {
309 struct sbp2_orb base;
310 struct {
311 struct sbp2_pointer next;
312 struct sbp2_pointer data_descriptor;
313 __be32 misc;
314 u8 command_block[SBP2_MAX_CDB_SIZE];
315 } request;
316 struct scsi_cmnd *cmd;
317 scsi_done_fn_t done;
318 struct sbp2_logical_unit *lu;
319
320 struct sbp2_pointer page_table[SG_ALL] __attribute__((aligned(8)));
321 dma_addr_t page_table_bus;
322};
323
324#define SBP2_ROM_VALUE_WILDCARD ~0
325#define SBP2_ROM_VALUE_MISSING 0xff000000
326
327
328
329
330
331
332
333
334
335static const struct {
336 u32 firmware_revision;
337 u32 model;
338 unsigned int workarounds;
339} sbp2_workarounds_table[] = {
340 {
341 .firmware_revision = 0x002800,
342 .model = 0x001010,
343 .workarounds = SBP2_WORKAROUND_INQUIRY_36 |
344 SBP2_WORKAROUND_MODE_SENSE_8 |
345 SBP2_WORKAROUND_POWER_CONDITION,
346 },
347 {
348 .firmware_revision = 0x002800,
349 .model = 0x000000,
350 .workarounds = SBP2_WORKAROUND_POWER_CONDITION,
351 },
352 {
353 .firmware_revision = 0x000200,
354 .model = SBP2_ROM_VALUE_WILDCARD,
355 .workarounds = SBP2_WORKAROUND_INQUIRY_36,
356 },
357 {
358 .firmware_revision = 0x012800,
359 .model = SBP2_ROM_VALUE_WILDCARD,
360 .workarounds = SBP2_WORKAROUND_POWER_CONDITION,
361 },
362 {
363 .firmware_revision = 0xa0b800,
364 .model = SBP2_ROM_VALUE_WILDCARD,
365 .workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
366 },
367 {
368 .firmware_revision = 0x002600,
369 .model = SBP2_ROM_VALUE_WILDCARD,
370 .workarounds = SBP2_WORKAROUND_128K_MAX_TRANS,
371 },
372
373
374
375
376 {
377 .firmware_revision = 0x0a2700,
378 .model = 0x000000,
379 .workarounds = SBP2_WORKAROUND_128K_MAX_TRANS |
380 SBP2_WORKAROUND_FIX_CAPACITY,
381 },
382 {
383 .firmware_revision = 0x0a2700,
384 .model = 0x000021,
385 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
386 },
387 {
388 .firmware_revision = 0x0a2700,
389 .model = 0x000022,
390 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
391 },
392 {
393 .firmware_revision = 0x0a2700,
394 .model = 0x000023,
395 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
396 },
397 {
398 .firmware_revision = 0x0a2700,
399 .model = 0x00007e,
400 .workarounds = SBP2_WORKAROUND_FIX_CAPACITY,
401 }
402};
403
404static void free_orb(struct kref *kref)
405{
406 struct sbp2_orb *orb = container_of(kref, struct sbp2_orb, kref);
407
408 kfree(orb);
409}
410
411static void sbp2_status_write(struct fw_card *card, struct fw_request *request,
412 int tcode, int destination, int source,
413 int generation, unsigned long long offset,
414 void *payload, size_t length, void *callback_data)
415{
416 struct sbp2_logical_unit *lu = callback_data;
417 struct sbp2_orb *orb;
418 struct sbp2_status status;
419 unsigned long flags;
420
421 if (tcode != TCODE_WRITE_BLOCK_REQUEST ||
422 length < 8 || length > sizeof(status)) {
423 fw_send_response(card, request, RCODE_TYPE_ERROR);
424 return;
425 }
426
427 status.status = be32_to_cpup(payload);
428 status.orb_low = be32_to_cpup(payload + 4);
429 memset(status.data, 0, sizeof(status.data));
430 if (length > 8)
431 memcpy(status.data, payload + 8, length - 8);
432
433 if (STATUS_GET_SOURCE(status) == 2 || STATUS_GET_SOURCE(status) == 3) {
434 fw_notify("non-orb related status write, not handled\n");
435 fw_send_response(card, request, RCODE_COMPLETE);
436 return;
437 }
438
439
440 spin_lock_irqsave(&card->lock, flags);
441 list_for_each_entry(orb, &lu->orb_list, link) {
442 if (STATUS_GET_ORB_HIGH(status) == 0 &&
443 STATUS_GET_ORB_LOW(status) == orb->request_bus) {
444 orb->rcode = RCODE_COMPLETE;
445 list_del(&orb->link);
446 break;
447 }
448 }
449 spin_unlock_irqrestore(&card->lock, flags);
450
451 if (&orb->link != &lu->orb_list) {
452 orb->callback(orb, &status);
453 kref_put(&orb->kref, free_orb);
454 } else {
455 fw_error("status write for unknown orb\n");
456 }
457
458 fw_send_response(card, request, RCODE_COMPLETE);
459}
460
461static void complete_transaction(struct fw_card *card, int rcode,
462 void *payload, size_t length, void *data)
463{
464 struct sbp2_orb *orb = data;
465 unsigned long flags;
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481 spin_lock_irqsave(&card->lock, flags);
482
483 if (orb->rcode == -1)
484 orb->rcode = rcode;
485
486 if (orb->rcode != RCODE_COMPLETE && orb->rcode != RCODE_CANCELLED) {
487 list_del(&orb->link);
488 spin_unlock_irqrestore(&card->lock, flags);
489
490 orb->callback(orb, NULL);
491 kref_put(&orb->kref, free_orb);
492 } else {
493 spin_unlock_irqrestore(&card->lock, flags);
494 }
495
496 kref_put(&orb->kref, free_orb);
497}
498
499static void sbp2_send_orb(struct sbp2_orb *orb, struct sbp2_logical_unit *lu,
500 int node_id, int generation, u64 offset)
501{
502 struct fw_device *device = target_device(lu->tgt);
503 unsigned long flags;
504
505 orb->pointer.high = 0;
506 orb->pointer.low = cpu_to_be32(orb->request_bus);
507
508 spin_lock_irqsave(&device->card->lock, flags);
509 list_add_tail(&orb->link, &lu->orb_list);
510 spin_unlock_irqrestore(&device->card->lock, flags);
511
512 kref_get(&orb->kref);
513 kref_get(&orb->kref);
514
515 fw_send_request(device->card, &orb->t, TCODE_WRITE_BLOCK_REQUEST,
516 node_id, generation, device->max_speed, offset,
517 &orb->pointer, 8, complete_transaction, orb);
518}
519
520static int sbp2_cancel_orbs(struct sbp2_logical_unit *lu)
521{
522 struct fw_device *device = target_device(lu->tgt);
523 struct sbp2_orb *orb, *next;
524 struct list_head list;
525 unsigned long flags;
526 int retval = -ENOENT;
527
528 INIT_LIST_HEAD(&list);
529 spin_lock_irqsave(&device->card->lock, flags);
530 list_splice_init(&lu->orb_list, &list);
531 spin_unlock_irqrestore(&device->card->lock, flags);
532
533 list_for_each_entry_safe(orb, next, &list, link) {
534 retval = 0;
535 fw_cancel_transaction(device->card, &orb->t);
536
537 orb->rcode = RCODE_CANCELLED;
538 orb->callback(orb, NULL);
539 kref_put(&orb->kref, free_orb);
540 }
541
542 return retval;
543}
544
545static void complete_management_orb(struct sbp2_orb *base_orb,
546 struct sbp2_status *status)
547{
548 struct sbp2_management_orb *orb =
549 container_of(base_orb, struct sbp2_management_orb, base);
550
551 if (status)
552 memcpy(&orb->status, status, sizeof(*status));
553 complete(&orb->done);
554}
555
556static int sbp2_send_management_orb(struct sbp2_logical_unit *lu, int node_id,
557 int generation, int function,
558 int lun_or_login_id, void *response)
559{
560 struct fw_device *device = target_device(lu->tgt);
561 struct sbp2_management_orb *orb;
562 unsigned int timeout;
563 int retval = -ENOMEM;
564
565 if (function == SBP2_LOGOUT_REQUEST && fw_device_is_shutdown(device))
566 return 0;
567
568 orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
569 if (orb == NULL)
570 return -ENOMEM;
571
572 kref_init(&orb->base.kref);
573 orb->response_bus =
574 dma_map_single(device->card->device, &orb->response,
575 sizeof(orb->response), DMA_FROM_DEVICE);
576 if (dma_mapping_error(device->card->device, orb->response_bus))
577 goto fail_mapping_response;
578
579 orb->request.response.high = 0;
580 orb->request.response.low = cpu_to_be32(orb->response_bus);
581
582 orb->request.misc = cpu_to_be32(
583 MANAGEMENT_ORB_NOTIFY |
584 MANAGEMENT_ORB_FUNCTION(function) |
585 MANAGEMENT_ORB_LUN(lun_or_login_id));
586 orb->request.length = cpu_to_be32(
587 MANAGEMENT_ORB_RESPONSE_LENGTH(sizeof(orb->response)));
588
589 orb->request.status_fifo.high =
590 cpu_to_be32(lu->address_handler.offset >> 32);
591 orb->request.status_fifo.low =
592 cpu_to_be32(lu->address_handler.offset);
593
594 if (function == SBP2_LOGIN_REQUEST) {
595
596 orb->request.misc |= cpu_to_be32(
597 MANAGEMENT_ORB_RECONNECT(2) |
598 MANAGEMENT_ORB_EXCLUSIVE(sbp2_param_exclusive_login));
599 timeout = lu->tgt->mgt_orb_timeout;
600 } else {
601 timeout = SBP2_ORB_TIMEOUT;
602 }
603
604 init_completion(&orb->done);
605 orb->base.callback = complete_management_orb;
606
607 orb->base.request_bus =
608 dma_map_single(device->card->device, &orb->request,
609 sizeof(orb->request), DMA_TO_DEVICE);
610 if (dma_mapping_error(device->card->device, orb->base.request_bus))
611 goto fail_mapping_request;
612
613 sbp2_send_orb(&orb->base, lu, node_id, generation,
614 lu->tgt->management_agent_address);
615
616 wait_for_completion_timeout(&orb->done, msecs_to_jiffies(timeout));
617
618 retval = -EIO;
619 if (sbp2_cancel_orbs(lu) == 0) {
620 fw_error("%s: orb reply timed out, rcode=0x%02x\n",
621 lu->tgt->bus_id, orb->base.rcode);
622 goto out;
623 }
624
625 if (orb->base.rcode != RCODE_COMPLETE) {
626 fw_error("%s: management write failed, rcode 0x%02x\n",
627 lu->tgt->bus_id, orb->base.rcode);
628 goto out;
629 }
630
631 if (STATUS_GET_RESPONSE(orb->status) != 0 ||
632 STATUS_GET_SBP_STATUS(orb->status) != 0) {
633 fw_error("%s: error status: %d:%d\n", lu->tgt->bus_id,
634 STATUS_GET_RESPONSE(orb->status),
635 STATUS_GET_SBP_STATUS(orb->status));
636 goto out;
637 }
638
639 retval = 0;
640 out:
641 dma_unmap_single(device->card->device, orb->base.request_bus,
642 sizeof(orb->request), DMA_TO_DEVICE);
643 fail_mapping_request:
644 dma_unmap_single(device->card->device, orb->response_bus,
645 sizeof(orb->response), DMA_FROM_DEVICE);
646 fail_mapping_response:
647 if (response)
648 memcpy(response, orb->response, sizeof(orb->response));
649 kref_put(&orb->base.kref, free_orb);
650
651 return retval;
652}
653
654static void sbp2_agent_reset(struct sbp2_logical_unit *lu)
655{
656 struct fw_device *device = target_device(lu->tgt);
657 __be32 d = 0;
658
659 fw_run_transaction(device->card, TCODE_WRITE_QUADLET_REQUEST,
660 lu->tgt->node_id, lu->generation, device->max_speed,
661 lu->command_block_agent_address + SBP2_AGENT_RESET,
662 &d, 4);
663}
664
665static void complete_agent_reset_write_no_wait(struct fw_card *card,
666 int rcode, void *payload, size_t length, void *data)
667{
668 kfree(data);
669}
670
671static void sbp2_agent_reset_no_wait(struct sbp2_logical_unit *lu)
672{
673 struct fw_device *device = target_device(lu->tgt);
674 struct fw_transaction *t;
675 static __be32 d;
676
677 t = kmalloc(sizeof(*t), GFP_ATOMIC);
678 if (t == NULL)
679 return;
680
681 fw_send_request(device->card, t, TCODE_WRITE_QUADLET_REQUEST,
682 lu->tgt->node_id, lu->generation, device->max_speed,
683 lu->command_block_agent_address + SBP2_AGENT_RESET,
684 &d, 4, complete_agent_reset_write_no_wait, t);
685}
686
687static inline void sbp2_allow_block(struct sbp2_logical_unit *lu)
688{
689
690
691
692
693
694
695
696 --lu->tgt->dont_block;
697}
698
699
700
701
702
703
704
705
706
707
708
709static void sbp2_conditionally_block(struct sbp2_logical_unit *lu)
710{
711 struct sbp2_target *tgt = lu->tgt;
712 struct fw_card *card = target_device(tgt)->card;
713 struct Scsi_Host *shost =
714 container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
715 unsigned long flags;
716
717 spin_lock_irqsave(&card->lock, flags);
718 if (!tgt->dont_block && !lu->blocked &&
719 lu->generation != card->generation) {
720 lu->blocked = true;
721 if (++tgt->blocked == 1)
722 scsi_block_requests(shost);
723 }
724 spin_unlock_irqrestore(&card->lock, flags);
725}
726
727
728
729
730
731
732
733static void sbp2_conditionally_unblock(struct sbp2_logical_unit *lu)
734{
735 struct sbp2_target *tgt = lu->tgt;
736 struct fw_card *card = target_device(tgt)->card;
737 struct Scsi_Host *shost =
738 container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
739 unsigned long flags;
740 bool unblock = false;
741
742 spin_lock_irqsave(&card->lock, flags);
743 if (lu->blocked && lu->generation == card->generation) {
744 lu->blocked = false;
745 unblock = --tgt->blocked == 0;
746 }
747 spin_unlock_irqrestore(&card->lock, flags);
748
749 if (unblock)
750 scsi_unblock_requests(shost);
751}
752
753
754
755
756
757
758
759static void sbp2_unblock(struct sbp2_target *tgt)
760{
761 struct fw_card *card = target_device(tgt)->card;
762 struct Scsi_Host *shost =
763 container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
764 unsigned long flags;
765
766 spin_lock_irqsave(&card->lock, flags);
767 ++tgt->dont_block;
768 spin_unlock_irqrestore(&card->lock, flags);
769
770 scsi_unblock_requests(shost);
771}
772
773static int sbp2_lun2int(u16 lun)
774{
775 struct scsi_lun eight_bytes_lun;
776
777 memset(&eight_bytes_lun, 0, sizeof(eight_bytes_lun));
778 eight_bytes_lun.scsi_lun[0] = (lun >> 8) & 0xff;
779 eight_bytes_lun.scsi_lun[1] = lun & 0xff;
780
781 return scsilun_to_int(&eight_bytes_lun);
782}
783
784static void sbp2_release_target(struct kref *kref)
785{
786 struct sbp2_target *tgt = container_of(kref, struct sbp2_target, kref);
787 struct sbp2_logical_unit *lu, *next;
788 struct Scsi_Host *shost =
789 container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
790 struct scsi_device *sdev;
791 struct fw_device *device = target_device(tgt);
792
793
794 sbp2_unblock(tgt);
795
796 list_for_each_entry_safe(lu, next, &tgt->lu_list, link) {
797 sdev = scsi_device_lookup(shost, 0, 0, sbp2_lun2int(lu->lun));
798 if (sdev) {
799 scsi_remove_device(sdev);
800 scsi_device_put(sdev);
801 }
802 if (lu->login_id != INVALID_LOGIN_ID) {
803 int generation, node_id;
804
805
806
807
808
809 generation = device->generation;
810 smp_rmb();
811 node_id = device->node_id;
812 sbp2_send_management_orb(lu, node_id, generation,
813 SBP2_LOGOUT_REQUEST,
814 lu->login_id, NULL);
815 }
816 fw_core_remove_address_handler(&lu->address_handler);
817 list_del(&lu->link);
818 kfree(lu);
819 }
820 scsi_remove_host(shost);
821 fw_notify("released %s, target %d:0:0\n", tgt->bus_id, shost->host_no);
822
823 fw_unit_put(tgt->unit);
824 scsi_host_put(shost);
825 fw_device_put(device);
826}
827
828static void sbp2_target_get(struct sbp2_target *tgt)
829{
830 kref_get(&tgt->kref);
831}
832
833static void sbp2_target_put(struct sbp2_target *tgt)
834{
835 kref_put(&tgt->kref, sbp2_release_target);
836}
837
838static struct workqueue_struct *sbp2_wq;
839
840
841
842
843
844static void sbp2_queue_work(struct sbp2_logical_unit *lu, unsigned long delay)
845{
846 sbp2_target_get(lu->tgt);
847 if (!queue_delayed_work(sbp2_wq, &lu->work, delay))
848 sbp2_target_put(lu->tgt);
849}
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867static void sbp2_set_busy_timeout(struct sbp2_logical_unit *lu)
868{
869 struct fw_device *device = target_device(lu->tgt);
870 __be32 d = cpu_to_be32(SBP2_CYCLE_LIMIT | SBP2_RETRY_LIMIT);
871
872 fw_run_transaction(device->card, TCODE_WRITE_QUADLET_REQUEST,
873 lu->tgt->node_id, lu->generation, device->max_speed,
874 CSR_REGISTER_BASE + CSR_BUSY_TIMEOUT, &d, 4);
875}
876
877static void sbp2_reconnect(struct work_struct *work);
878
879static void sbp2_login(struct work_struct *work)
880{
881 struct sbp2_logical_unit *lu =
882 container_of(work, struct sbp2_logical_unit, work.work);
883 struct sbp2_target *tgt = lu->tgt;
884 struct fw_device *device = target_device(tgt);
885 struct Scsi_Host *shost;
886 struct scsi_device *sdev;
887 struct sbp2_login_response response;
888 int generation, node_id, local_node_id;
889
890 if (fw_device_is_shutdown(device))
891 goto out;
892
893 generation = device->generation;
894 smp_rmb();
895 node_id = device->node_id;
896 local_node_id = device->card->node_id;
897
898
899 if (lu->has_sdev)
900 sbp2_send_management_orb(lu, device->node_id, generation,
901 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
902
903 if (sbp2_send_management_orb(lu, node_id, generation,
904 SBP2_LOGIN_REQUEST, lu->lun, &response) < 0) {
905 if (lu->retries++ < 5) {
906 sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
907 } else {
908 fw_error("%s: failed to login to LUN %04x\n",
909 tgt->bus_id, lu->lun);
910
911 sbp2_unblock(lu->tgt);
912 }
913 goto out;
914 }
915
916 tgt->node_id = node_id;
917 tgt->address_high = local_node_id << 16;
918 smp_wmb();
919 lu->generation = generation;
920
921 lu->command_block_agent_address =
922 ((u64)(be32_to_cpu(response.command_block_agent.high) & 0xffff)
923 << 32) | be32_to_cpu(response.command_block_agent.low);
924 lu->login_id = be32_to_cpu(response.misc) & 0xffff;
925
926 fw_notify("%s: logged in to LUN %04x (%d retries)\n",
927 tgt->bus_id, lu->lun, lu->retries);
928
929
930 sbp2_set_busy_timeout(lu);
931
932 PREPARE_DELAYED_WORK(&lu->work, sbp2_reconnect);
933 sbp2_agent_reset(lu);
934
935
936 if (lu->has_sdev) {
937 sbp2_cancel_orbs(lu);
938 sbp2_conditionally_unblock(lu);
939 goto out;
940 }
941
942 if (lu->tgt->workarounds & SBP2_WORKAROUND_DELAY_INQUIRY)
943 ssleep(SBP2_INQUIRY_DELAY);
944
945 shost = container_of((void *)tgt, struct Scsi_Host, hostdata[0]);
946 sdev = __scsi_add_device(shost, 0, 0, sbp2_lun2int(lu->lun), lu);
947
948
949
950
951
952
953
954
955
956 if (IS_ERR(sdev))
957 goto out_logout_login;
958
959
960 smp_rmb();
961 if (generation != device->card->generation) {
962 scsi_remove_device(sdev);
963 scsi_device_put(sdev);
964 goto out_logout_login;
965 }
966
967
968 lu->has_sdev = true;
969 scsi_device_put(sdev);
970 sbp2_allow_block(lu);
971 goto out;
972
973 out_logout_login:
974 smp_rmb();
975 generation = device->generation;
976 smp_rmb();
977
978 sbp2_send_management_orb(lu, device->node_id, generation,
979 SBP2_LOGOUT_REQUEST, lu->login_id, NULL);
980
981
982
983
984 PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
985 out:
986 sbp2_target_put(tgt);
987}
988
989static int sbp2_add_logical_unit(struct sbp2_target *tgt, int lun_entry)
990{
991 struct sbp2_logical_unit *lu;
992
993 lu = kmalloc(sizeof(*lu), GFP_KERNEL);
994 if (!lu)
995 return -ENOMEM;
996
997 lu->address_handler.length = 0x100;
998 lu->address_handler.address_callback = sbp2_status_write;
999 lu->address_handler.callback_data = lu;
1000
1001 if (fw_core_add_address_handler(&lu->address_handler,
1002 &fw_high_memory_region) < 0) {
1003 kfree(lu);
1004 return -ENOMEM;
1005 }
1006
1007 lu->tgt = tgt;
1008 lu->lun = lun_entry & 0xffff;
1009 lu->login_id = INVALID_LOGIN_ID;
1010 lu->retries = 0;
1011 lu->has_sdev = false;
1012 lu->blocked = false;
1013 ++tgt->dont_block;
1014 INIT_LIST_HEAD(&lu->orb_list);
1015 INIT_DELAYED_WORK(&lu->work, sbp2_login);
1016
1017 list_add_tail(&lu->link, &tgt->lu_list);
1018 return 0;
1019}
1020
1021static int sbp2_scan_logical_unit_dir(struct sbp2_target *tgt,
1022 const u32 *directory)
1023{
1024 struct fw_csr_iterator ci;
1025 int key, value;
1026
1027 fw_csr_iterator_init(&ci, directory);
1028 while (fw_csr_iterator_next(&ci, &key, &value))
1029 if (key == SBP2_CSR_LOGICAL_UNIT_NUMBER &&
1030 sbp2_add_logical_unit(tgt, value) < 0)
1031 return -ENOMEM;
1032 return 0;
1033}
1034
1035static int sbp2_scan_unit_dir(struct sbp2_target *tgt, const u32 *directory,
1036 u32 *model, u32 *firmware_revision)
1037{
1038 struct fw_csr_iterator ci;
1039 int key, value;
1040
1041 fw_csr_iterator_init(&ci, directory);
1042 while (fw_csr_iterator_next(&ci, &key, &value)) {
1043 switch (key) {
1044
1045 case CSR_DEPENDENT_INFO | CSR_OFFSET:
1046 tgt->management_agent_address =
1047 CSR_REGISTER_BASE + 4 * value;
1048 break;
1049
1050 case CSR_DIRECTORY_ID:
1051 tgt->directory_id = value;
1052 break;
1053
1054 case CSR_MODEL:
1055 *model = value;
1056 break;
1057
1058 case SBP2_CSR_FIRMWARE_REVISION:
1059 *firmware_revision = value;
1060 break;
1061
1062 case SBP2_CSR_UNIT_CHARACTERISTICS:
1063
1064 tgt->mgt_orb_timeout = (value >> 8 & 0xff) * 500;
1065 break;
1066
1067 case SBP2_CSR_LOGICAL_UNIT_NUMBER:
1068 if (sbp2_add_logical_unit(tgt, value) < 0)
1069 return -ENOMEM;
1070 break;
1071
1072 case SBP2_CSR_LOGICAL_UNIT_DIRECTORY:
1073
1074 if (sbp2_scan_logical_unit_dir(tgt, ci.p - 1 + value) < 0)
1075 return -ENOMEM;
1076 break;
1077 }
1078 }
1079 return 0;
1080}
1081
1082
1083
1084
1085
1086
1087static void sbp2_clamp_management_orb_timeout(struct sbp2_target *tgt)
1088{
1089 unsigned int timeout = tgt->mgt_orb_timeout;
1090
1091 if (timeout > 40000)
1092 fw_notify("%s: %ds mgt_ORB_timeout limited to 40s\n",
1093 tgt->bus_id, timeout / 1000);
1094
1095 tgt->mgt_orb_timeout = clamp_val(timeout, 5000, 40000);
1096}
1097
1098static void sbp2_init_workarounds(struct sbp2_target *tgt, u32 model,
1099 u32 firmware_revision)
1100{
1101 int i;
1102 unsigned int w = sbp2_param_workarounds;
1103
1104 if (w)
1105 fw_notify("Please notify linux1394-devel@lists.sourceforge.net "
1106 "if you need the workarounds parameter for %s\n",
1107 tgt->bus_id);
1108
1109 if (w & SBP2_WORKAROUND_OVERRIDE)
1110 goto out;
1111
1112 for (i = 0; i < ARRAY_SIZE(sbp2_workarounds_table); i++) {
1113
1114 if (sbp2_workarounds_table[i].firmware_revision !=
1115 (firmware_revision & 0xffffff00))
1116 continue;
1117
1118 if (sbp2_workarounds_table[i].model != model &&
1119 sbp2_workarounds_table[i].model != SBP2_ROM_VALUE_WILDCARD)
1120 continue;
1121
1122 w |= sbp2_workarounds_table[i].workarounds;
1123 break;
1124 }
1125 out:
1126 if (w)
1127 fw_notify("Workarounds for %s: 0x%x "
1128 "(firmware_revision 0x%06x, model_id 0x%06x)\n",
1129 tgt->bus_id, w, firmware_revision, model);
1130 tgt->workarounds = w;
1131}
1132
1133static struct scsi_host_template scsi_driver_template;
1134
1135static int sbp2_probe(struct device *dev)
1136{
1137 struct fw_unit *unit = fw_unit(dev);
1138 struct fw_device *device = fw_parent_device(unit);
1139 struct sbp2_target *tgt;
1140 struct sbp2_logical_unit *lu;
1141 struct Scsi_Host *shost;
1142 u32 model, firmware_revision;
1143
1144 if (dma_get_max_seg_size(device->card->device) > SBP2_MAX_SEG_SIZE)
1145 BUG_ON(dma_set_max_seg_size(device->card->device,
1146 SBP2_MAX_SEG_SIZE));
1147
1148 shost = scsi_host_alloc(&scsi_driver_template, sizeof(*tgt));
1149 if (shost == NULL)
1150 return -ENOMEM;
1151
1152 tgt = (struct sbp2_target *)shost->hostdata;
1153 dev_set_drvdata(&unit->device, tgt);
1154 tgt->unit = unit;
1155 kref_init(&tgt->kref);
1156 INIT_LIST_HEAD(&tgt->lu_list);
1157 tgt->bus_id = dev_name(&unit->device);
1158 tgt->guid = (u64)device->config_rom[3] << 32 | device->config_rom[4];
1159
1160 if (fw_device_enable_phys_dma(device) < 0)
1161 goto fail_shost_put;
1162
1163 shost->max_cmd_len = SBP2_MAX_CDB_SIZE;
1164
1165 if (scsi_add_host(shost, &unit->device) < 0)
1166 goto fail_shost_put;
1167
1168 fw_device_get(device);
1169 fw_unit_get(unit);
1170
1171
1172 tgt->directory_id = ((unit->directory - device->config_rom) * 4
1173 + CSR_CONFIG_ROM) & 0xffffff;
1174
1175 firmware_revision = SBP2_ROM_VALUE_MISSING;
1176 model = SBP2_ROM_VALUE_MISSING;
1177
1178 if (sbp2_scan_unit_dir(tgt, unit->directory, &model,
1179 &firmware_revision) < 0)
1180 goto fail_tgt_put;
1181
1182 sbp2_clamp_management_orb_timeout(tgt);
1183 sbp2_init_workarounds(tgt, model, firmware_revision);
1184
1185
1186
1187
1188
1189
1190
1191 tgt->max_payload = min(device->max_speed + 7, 10U);
1192 tgt->max_payload = min(tgt->max_payload, device->card->max_receive - 1);
1193
1194
1195 list_for_each_entry(lu, &tgt->lu_list, link)
1196 sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
1197 return 0;
1198
1199 fail_tgt_put:
1200 sbp2_target_put(tgt);
1201 return -ENOMEM;
1202
1203 fail_shost_put:
1204 scsi_host_put(shost);
1205 return -ENOMEM;
1206}
1207
1208static int sbp2_remove(struct device *dev)
1209{
1210 struct fw_unit *unit = fw_unit(dev);
1211 struct sbp2_target *tgt = dev_get_drvdata(&unit->device);
1212
1213 sbp2_target_put(tgt);
1214 return 0;
1215}
1216
1217static void sbp2_reconnect(struct work_struct *work)
1218{
1219 struct sbp2_logical_unit *lu =
1220 container_of(work, struct sbp2_logical_unit, work.work);
1221 struct sbp2_target *tgt = lu->tgt;
1222 struct fw_device *device = target_device(tgt);
1223 int generation, node_id, local_node_id;
1224
1225 if (fw_device_is_shutdown(device))
1226 goto out;
1227
1228 generation = device->generation;
1229 smp_rmb();
1230 node_id = device->node_id;
1231 local_node_id = device->card->node_id;
1232
1233 if (sbp2_send_management_orb(lu, node_id, generation,
1234 SBP2_RECONNECT_REQUEST,
1235 lu->login_id, NULL) < 0) {
1236
1237
1238
1239
1240
1241
1242
1243 smp_rmb();
1244 if (generation == device->card->generation ||
1245 lu->retries++ >= 5) {
1246 fw_error("%s: failed to reconnect\n", tgt->bus_id);
1247 lu->retries = 0;
1248 PREPARE_DELAYED_WORK(&lu->work, sbp2_login);
1249 }
1250 sbp2_queue_work(lu, DIV_ROUND_UP(HZ, 5));
1251 goto out;
1252 }
1253
1254 tgt->node_id = node_id;
1255 tgt->address_high = local_node_id << 16;
1256 smp_wmb();
1257 lu->generation = generation;
1258
1259 fw_notify("%s: reconnected to LUN %04x (%d retries)\n",
1260 tgt->bus_id, lu->lun, lu->retries);
1261
1262 sbp2_agent_reset(lu);
1263 sbp2_cancel_orbs(lu);
1264 sbp2_conditionally_unblock(lu);
1265 out:
1266 sbp2_target_put(tgt);
1267}
1268
1269static void sbp2_update(struct fw_unit *unit)
1270{
1271 struct sbp2_target *tgt = dev_get_drvdata(&unit->device);
1272 struct sbp2_logical_unit *lu;
1273
1274 fw_device_enable_phys_dma(fw_parent_device(unit));
1275
1276
1277
1278
1279
1280 list_for_each_entry(lu, &tgt->lu_list, link) {
1281 sbp2_conditionally_block(lu);
1282 lu->retries = 0;
1283 sbp2_queue_work(lu, 0);
1284 }
1285}
1286
1287#define SBP2_UNIT_SPEC_ID_ENTRY 0x0000609e
1288#define SBP2_SW_VERSION_ENTRY 0x00010483
1289
1290static const struct ieee1394_device_id sbp2_id_table[] = {
1291 {
1292 .match_flags = IEEE1394_MATCH_SPECIFIER_ID |
1293 IEEE1394_MATCH_VERSION,
1294 .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY,
1295 .version = SBP2_SW_VERSION_ENTRY,
1296 },
1297 { }
1298};
1299
1300static struct fw_driver sbp2_driver = {
1301 .driver = {
1302 .owner = THIS_MODULE,
1303 .name = sbp2_driver_name,
1304 .bus = &fw_bus_type,
1305 .probe = sbp2_probe,
1306 .remove = sbp2_remove,
1307 },
1308 .update = sbp2_update,
1309 .id_table = sbp2_id_table,
1310};
1311
1312static void sbp2_unmap_scatterlist(struct device *card_device,
1313 struct sbp2_command_orb *orb)
1314{
1315 if (scsi_sg_count(orb->cmd))
1316 dma_unmap_sg(card_device, scsi_sglist(orb->cmd),
1317 scsi_sg_count(orb->cmd),
1318 orb->cmd->sc_data_direction);
1319
1320 if (orb->request.misc & cpu_to_be32(COMMAND_ORB_PAGE_TABLE_PRESENT))
1321 dma_unmap_single(card_device, orb->page_table_bus,
1322 sizeof(orb->page_table), DMA_TO_DEVICE);
1323}
1324
1325static unsigned int sbp2_status_to_sense_data(u8 *sbp2_status, u8 *sense_data)
1326{
1327 int sam_status;
1328
1329 sense_data[0] = 0x70;
1330 sense_data[1] = 0x0;
1331 sense_data[2] = sbp2_status[1];
1332 sense_data[3] = sbp2_status[4];
1333 sense_data[4] = sbp2_status[5];
1334 sense_data[5] = sbp2_status[6];
1335 sense_data[6] = sbp2_status[7];
1336 sense_data[7] = 10;
1337 sense_data[8] = sbp2_status[8];
1338 sense_data[9] = sbp2_status[9];
1339 sense_data[10] = sbp2_status[10];
1340 sense_data[11] = sbp2_status[11];
1341 sense_data[12] = sbp2_status[2];
1342 sense_data[13] = sbp2_status[3];
1343 sense_data[14] = sbp2_status[12];
1344 sense_data[15] = sbp2_status[13];
1345
1346 sam_status = sbp2_status[0] & 0x3f;
1347
1348 switch (sam_status) {
1349 case SAM_STAT_GOOD:
1350 case SAM_STAT_CHECK_CONDITION:
1351 case SAM_STAT_CONDITION_MET:
1352 case SAM_STAT_BUSY:
1353 case SAM_STAT_RESERVATION_CONFLICT:
1354 case SAM_STAT_COMMAND_TERMINATED:
1355 return DID_OK << 16 | sam_status;
1356
1357 default:
1358 return DID_ERROR << 16;
1359 }
1360}
1361
1362static void complete_command_orb(struct sbp2_orb *base_orb,
1363 struct sbp2_status *status)
1364{
1365 struct sbp2_command_orb *orb =
1366 container_of(base_orb, struct sbp2_command_orb, base);
1367 struct fw_device *device = target_device(orb->lu->tgt);
1368 int result;
1369
1370 if (status != NULL) {
1371 if (STATUS_GET_DEAD(*status))
1372 sbp2_agent_reset_no_wait(orb->lu);
1373
1374 switch (STATUS_GET_RESPONSE(*status)) {
1375 case SBP2_STATUS_REQUEST_COMPLETE:
1376 result = DID_OK << 16;
1377 break;
1378 case SBP2_STATUS_TRANSPORT_FAILURE:
1379 result = DID_BUS_BUSY << 16;
1380 break;
1381 case SBP2_STATUS_ILLEGAL_REQUEST:
1382 case SBP2_STATUS_VENDOR_DEPENDENT:
1383 default:
1384 result = DID_ERROR << 16;
1385 break;
1386 }
1387
1388 if (result == DID_OK << 16 && STATUS_GET_LEN(*status) > 1)
1389 result = sbp2_status_to_sense_data(STATUS_GET_DATA(*status),
1390 orb->cmd->sense_buffer);
1391 } else {
1392
1393
1394
1395
1396
1397 result = DID_BUS_BUSY << 16;
1398 sbp2_conditionally_block(orb->lu);
1399 }
1400
1401 dma_unmap_single(device->card->device, orb->base.request_bus,
1402 sizeof(orb->request), DMA_TO_DEVICE);
1403 sbp2_unmap_scatterlist(device->card->device, orb);
1404
1405 orb->cmd->result = result;
1406 orb->done(orb->cmd);
1407}
1408
1409static int sbp2_map_scatterlist(struct sbp2_command_orb *orb,
1410 struct fw_device *device, struct sbp2_logical_unit *lu)
1411{
1412 struct scatterlist *sg = scsi_sglist(orb->cmd);
1413 int i, n;
1414
1415 n = dma_map_sg(device->card->device, sg, scsi_sg_count(orb->cmd),
1416 orb->cmd->sc_data_direction);
1417 if (n == 0)
1418 goto fail;
1419
1420
1421
1422
1423
1424
1425
1426
1427 if (n == 1) {
1428 orb->request.data_descriptor.high =
1429 cpu_to_be32(lu->tgt->address_high);
1430 orb->request.data_descriptor.low =
1431 cpu_to_be32(sg_dma_address(sg));
1432 orb->request.misc |=
1433 cpu_to_be32(COMMAND_ORB_DATA_SIZE(sg_dma_len(sg)));
1434 return 0;
1435 }
1436
1437 for_each_sg(sg, sg, n, i) {
1438 orb->page_table[i].high = cpu_to_be32(sg_dma_len(sg) << 16);
1439 orb->page_table[i].low = cpu_to_be32(sg_dma_address(sg));
1440 }
1441
1442 orb->page_table_bus =
1443 dma_map_single(device->card->device, orb->page_table,
1444 sizeof(orb->page_table), DMA_TO_DEVICE);
1445 if (dma_mapping_error(device->card->device, orb->page_table_bus))
1446 goto fail_page_table;
1447
1448
1449
1450
1451
1452
1453
1454
1455 orb->request.data_descriptor.high = cpu_to_be32(lu->tgt->address_high);
1456 orb->request.data_descriptor.low = cpu_to_be32(orb->page_table_bus);
1457 orb->request.misc |= cpu_to_be32(COMMAND_ORB_PAGE_TABLE_PRESENT |
1458 COMMAND_ORB_DATA_SIZE(n));
1459
1460 return 0;
1461
1462 fail_page_table:
1463 dma_unmap_sg(device->card->device, scsi_sglist(orb->cmd),
1464 scsi_sg_count(orb->cmd), orb->cmd->sc_data_direction);
1465 fail:
1466 return -ENOMEM;
1467}
1468
1469
1470
1471static int sbp2_scsi_queuecommand_lck(struct scsi_cmnd *cmd, scsi_done_fn_t done)
1472{
1473 struct sbp2_logical_unit *lu = cmd->device->hostdata;
1474 struct fw_device *device = target_device(lu->tgt);
1475 struct sbp2_command_orb *orb;
1476 int generation, retval = SCSI_MLQUEUE_HOST_BUSY;
1477
1478
1479
1480
1481
1482 if (cmd->sc_data_direction == DMA_BIDIRECTIONAL) {
1483 fw_error("Can't handle DMA_BIDIRECTIONAL, rejecting command\n");
1484 cmd->result = DID_ERROR << 16;
1485 done(cmd);
1486 return 0;
1487 }
1488
1489 orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
1490 if (orb == NULL) {
1491 fw_notify("failed to alloc orb\n");
1492 return SCSI_MLQUEUE_HOST_BUSY;
1493 }
1494
1495
1496 orb->base.rcode = -1;
1497 kref_init(&orb->base.kref);
1498
1499 orb->lu = lu;
1500 orb->done = done;
1501 orb->cmd = cmd;
1502
1503 orb->request.next.high = cpu_to_be32(SBP2_ORB_NULL);
1504 orb->request.misc = cpu_to_be32(
1505 COMMAND_ORB_MAX_PAYLOAD(lu->tgt->max_payload) |
1506 COMMAND_ORB_SPEED(device->max_speed) |
1507 COMMAND_ORB_NOTIFY);
1508
1509 if (cmd->sc_data_direction == DMA_FROM_DEVICE)
1510 orb->request.misc |= cpu_to_be32(COMMAND_ORB_DIRECTION);
1511
1512 generation = device->generation;
1513 smp_rmb();
1514
1515 if (scsi_sg_count(cmd) && sbp2_map_scatterlist(orb, device, lu) < 0)
1516 goto out;
1517
1518 memcpy(orb->request.command_block, cmd->cmnd, cmd->cmd_len);
1519
1520 orb->base.callback = complete_command_orb;
1521 orb->base.request_bus =
1522 dma_map_single(device->card->device, &orb->request,
1523 sizeof(orb->request), DMA_TO_DEVICE);
1524 if (dma_mapping_error(device->card->device, orb->base.request_bus)) {
1525 sbp2_unmap_scatterlist(device->card->device, orb);
1526 goto out;
1527 }
1528
1529 sbp2_send_orb(&orb->base, lu, lu->tgt->node_id, generation,
1530 lu->command_block_agent_address + SBP2_ORB_POINTER);
1531 retval = 0;
1532 out:
1533 kref_put(&orb->base.kref, free_orb);
1534 return retval;
1535}
1536
1537static DEF_SCSI_QCMD(sbp2_scsi_queuecommand)
1538
1539static int sbp2_scsi_slave_alloc(struct scsi_device *sdev)
1540{
1541 struct sbp2_logical_unit *lu = sdev->hostdata;
1542
1543
1544 if (!lu)
1545 return -ENOSYS;
1546
1547 sdev->allow_restart = 1;
1548
1549
1550 blk_queue_update_dma_alignment(sdev->request_queue, 4 - 1);
1551
1552 if (lu->tgt->workarounds & SBP2_WORKAROUND_INQUIRY_36)
1553 sdev->inquiry_len = 36;
1554
1555 return 0;
1556}
1557
1558static int sbp2_scsi_slave_configure(struct scsi_device *sdev)
1559{
1560 struct sbp2_logical_unit *lu = sdev->hostdata;
1561
1562 sdev->use_10_for_rw = 1;
1563
1564 if (sbp2_param_exclusive_login)
1565 sdev->manage_start_stop = 1;
1566
1567 if (sdev->type == TYPE_ROM)
1568 sdev->use_10_for_ms = 1;
1569
1570 if (sdev->type == TYPE_DISK &&
1571 lu->tgt->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
1572 sdev->skip_ms_page_8 = 1;
1573
1574 if (lu->tgt->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
1575 sdev->fix_capacity = 1;
1576
1577 if (lu->tgt->workarounds & SBP2_WORKAROUND_POWER_CONDITION)
1578 sdev->start_stop_pwr_cond = 1;
1579
1580 if (lu->tgt->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
1581 blk_queue_max_hw_sectors(sdev->request_queue, 128 * 1024 / 512);
1582
1583 blk_queue_max_segment_size(sdev->request_queue, SBP2_MAX_SEG_SIZE);
1584
1585 return 0;
1586}
1587
1588
1589
1590
1591
1592static int sbp2_scsi_abort(struct scsi_cmnd *cmd)
1593{
1594 struct sbp2_logical_unit *lu = cmd->device->hostdata;
1595
1596 fw_notify("%s: sbp2_scsi_abort\n", lu->tgt->bus_id);
1597 sbp2_agent_reset(lu);
1598 sbp2_cancel_orbs(lu);
1599
1600 return SUCCESS;
1601}
1602
1603
1604
1605
1606
1607
1608
1609
1610static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev,
1611 struct device_attribute *attr, char *buf)
1612{
1613 struct scsi_device *sdev = to_scsi_device(dev);
1614 struct sbp2_logical_unit *lu;
1615
1616 if (!sdev)
1617 return 0;
1618
1619 lu = sdev->hostdata;
1620
1621 return sprintf(buf, "%016llx:%06x:%04x\n",
1622 (unsigned long long)lu->tgt->guid,
1623 lu->tgt->directory_id, lu->lun);
1624}
1625
1626static DEVICE_ATTR(ieee1394_id, S_IRUGO, sbp2_sysfs_ieee1394_id_show, NULL);
1627
1628static struct device_attribute *sbp2_scsi_sysfs_attrs[] = {
1629 &dev_attr_ieee1394_id,
1630 NULL
1631};
1632
1633static struct scsi_host_template scsi_driver_template = {
1634 .module = THIS_MODULE,
1635 .name = "SBP-2 IEEE-1394",
1636 .proc_name = sbp2_driver_name,
1637 .queuecommand = sbp2_scsi_queuecommand,
1638 .slave_alloc = sbp2_scsi_slave_alloc,
1639 .slave_configure = sbp2_scsi_slave_configure,
1640 .eh_abort_handler = sbp2_scsi_abort,
1641 .this_id = -1,
1642 .sg_tablesize = SG_ALL,
1643 .use_clustering = ENABLE_CLUSTERING,
1644 .cmd_per_lun = 1,
1645 .can_queue = 1,
1646 .sdev_attrs = sbp2_scsi_sysfs_attrs,
1647};
1648
1649MODULE_AUTHOR("Kristian Hoegsberg <krh@bitplanet.net>");
1650MODULE_DESCRIPTION("SCSI over IEEE1394");
1651MODULE_LICENSE("GPL");
1652MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table);
1653
1654
1655#ifndef CONFIG_IEEE1394_SBP2_MODULE
1656MODULE_ALIAS("sbp2");
1657#endif
1658
1659static int __init sbp2_init(void)
1660{
1661 sbp2_wq = create_singlethread_workqueue(KBUILD_MODNAME);
1662 if (!sbp2_wq)
1663 return -ENOMEM;
1664
1665 return driver_register(&sbp2_driver.driver);
1666}
1667
1668static void __exit sbp2_cleanup(void)
1669{
1670 driver_unregister(&sbp2_driver.driver);
1671 destroy_workqueue(sbp2_wq);
1672}
1673
1674module_init(sbp2_init);
1675module_exit(sbp2_cleanup);
1676