1 /* pluto.c: SparcSTORAGE Array SCSI host adapter driver.
3 * Copyright (C) 1997,1998,1999 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
7 #include <linux/kernel.h>
8 #include <linux/delay.h>
9 #include <linux/types.h>
10 #include <linux/string.h>
11 #include <linux/slab.h>
12 #include <linux/blkdev.h>
13 #include <linux/proc_fs.h>
14 #include <linux/stat.h>
15 #include <linux/init.h>
17 #include <linux/kmod.h>
23 #include <scsi/scsi_host.h>
24 #include "../fc4/fcp_impl.h"
27 #include <linux/module.h>
29 #define RQ_SCSI_BUSY 0xffff
30 #define RQ_SCSI_DONE 0xfffe
32 /* #define PLUTO_DEBUG */
34 #define pluto_printk printk ("PLUTO %s: ", fc->name); printk
37 #define PLD(x) pluto_printk x;
38 #define PLND(x) printk ("PLUTO: "); printk x;
44 static struct ctrl_inquiry
{
45 struct Scsi_Host host
;
51 static int fcscount __initdata
= 0;
52 static atomic_t fcss __initdata
= ATOMIC_INIT(0);
53 DECLARE_MUTEX_LOCKED(fc_sem
);
55 static int pluto_encode_addr(Scsi_Cmnd
*SCpnt
, u16
*addr
, fc_channel
*fc
, fcp_cmnd
*fcmd
);
57 static void __init
pluto_detect_timeout(unsigned long data
)
63 static void __init
pluto_detect_done(Scsi_Cmnd
*SCpnt
)
68 static void __init
pluto_detect_scsi_done(Scsi_Cmnd
*SCpnt
)
70 SCpnt
->request
->rq_status
= RQ_SCSI_DONE
;
71 PLND(("Detect done %08lx\n", (long)SCpnt
))
72 if (atomic_dec_and_test (&fcss
))
76 int pluto_slave_configure(struct scsi_device
*device
)
80 if (device
->tagged_supported
)
81 depth_to_use
= /* 254 */ 8;
85 scsi_adjust_queue_depth(device
,
86 (device
->tagged_supported
?
93 /* Detect all SSAs attached to the machine.
94 To be fast, do it on all online FC channels at the same time. */
95 int __init
pluto_detect(struct scsi_host_template
*tpnt
)
97 int i
, retry
, nplutos
;
99 struct scsi_device dev
;
100 DEFINE_TIMER(fc_timer
, pluto_detect_timeout
, 0, 0);
102 tpnt
->proc_name
= "pluto";
104 for_each_online_fc_channel(fc
) {
108 PLND(("%d channels online\n", fcscount
))
110 #if defined(MODULE) && defined(CONFIG_FC4_SOC_MODULE) && defined(CONFIG_KMOD)
111 request_module("soc");
113 for_each_online_fc_channel(fc
) {
121 fcs
= (struct ctrl_inquiry
*) kmalloc (sizeof (struct ctrl_inquiry
) * fcscount
, GFP_DMA
);
123 printk ("PLUTO: Not enough memory to probe\n");
127 memset (fcs
, 0, sizeof (struct ctrl_inquiry
) * fcscount
);
128 memset (&dev
, 0, sizeof(dev
));
129 atomic_set (&fcss
, fcscount
);
132 for_each_online_fc_channel(fc
) {
134 struct Scsi_Host
*host
;
137 if (i
== fcscount
) break;
138 if (fc
->posmap
) continue;
140 PLD(("trying to find SSA\n"))
142 /* If this is already registered to some other SCSI host, then it cannot be pluto */
143 if (fc
->scsi_name
[0]) continue;
144 memcpy (fc
->scsi_name
, "SSA", 4);
148 fc
->can_queue
= PLUTO_CAN_QUEUE
;
150 fc
->encode_addr
= pluto_encode_addr
;
152 fc
->fcp_register(fc
, TYPE_SCSI_FCP
, 0);
154 SCpnt
= &(fcs
[i
].cmd
);
155 host
= &(fcs
[i
].host
);
156 pluto
= (struct pluto
*)host
->hostdata
;
160 SCpnt
->cmnd
[0] = INQUIRY
;
161 SCpnt
->cmnd
[4] = 255;
163 /* FC layer requires this, so that SCpnt->device->tagged_supported is initially 0 */
164 SCpnt
->device
= &dev
;
167 SCpnt
->cmd_len
= COMMAND_SIZE(INQUIRY
);
169 SCpnt
->request
->rq_status
= RQ_SCSI_BUSY
;
171 SCpnt
->done
= pluto_detect_done
;
172 SCpnt
->bufflen
= 256;
173 SCpnt
->buffer
= fcs
[i
].inquiry
;
174 SCpnt
->request_bufflen
= 256;
175 SCpnt
->request_buffer
= fcs
[i
].inquiry
;
176 PLD(("set up %d %08lx\n", i
, (long)SCpnt
))
180 for (retry
= 0; retry
< 5; retry
++) {
181 for (i
= 0; i
< fcscount
; i
++) {
182 if (!fcs
[i
].fc
) break;
183 if (fcs
[i
].cmd
.request
->rq_status
!= RQ_SCSI_DONE
) {
184 disable_irq(fcs
[i
].fc
->irq
);
185 PLND(("queuecommand %d %d\n", retry
, i
))
186 fcp_scsi_queuecommand (&(fcs
[i
].cmd
),
187 pluto_detect_scsi_done
);
188 enable_irq(fcs
[i
].fc
->irq
);
192 fc_timer
.expires
= jiffies
+ 10 * HZ
;
193 add_timer(&fc_timer
);
197 if (!atomic_read(&fcss
))
198 break; /* All fc channels have answered us */
200 del_timer_sync(&fc_timer
);
202 PLND(("Finished search\n"))
203 for (i
= 0, nplutos
= 0; i
< fcscount
; i
++) {
206 if (!(fc
= fcs
[i
].fc
)) break;
208 SCpnt
= &(fcs
[i
].cmd
);
210 /* Let FC mid-level free allocated resources */
213 if (!SCpnt
->result
) {
214 struct pluto_inquiry
*inq
;
216 struct Scsi_Host
*host
;
218 inq
= (struct pluto_inquiry
*)fcs
[i
].inquiry
;
220 if ((inq
->dtype
& 0x1f) == TYPE_PROCESSOR
&&
221 !strncmp (inq
->vendor_id
, "SUN", 3) &&
222 !strncmp (inq
->product_id
, "SSA", 3)) {
226 ages
= kmalloc (((inq
->channels
+ 1) * inq
->targets
) * sizeof(long), GFP_KERNEL
);
229 host
= scsi_register (tpnt
, sizeof (struct pluto
));
236 if (!try_module_get(fc
->module
)) {
238 scsi_unregister(host
);
244 pluto
= (struct pluto
*)host
->hostdata
;
246 host
->max_id
= inq
->targets
;
247 host
->max_channel
= inq
->channels
;
250 fc
->channels
= inq
->channels
+ 1;
251 fc
->targets
= inq
->targets
;
253 memset (ages
, 0, ((inq
->channels
+ 1) * inq
->targets
) * sizeof(long));
256 memcpy (pluto
->rev_str
, inq
->revision
, 4);
257 pluto
->rev_str
[4] = 0;
258 p
= strchr (pluto
->rev_str
, ' ');
260 memcpy (pluto
->fw_rev_str
, inq
->fw_revision
, 4);
261 pluto
->fw_rev_str
[4] = 0;
262 p
= strchr (pluto
->fw_rev_str
, ' ');
264 memcpy (pluto
->serial_str
, inq
->serial
, 12);
265 pluto
->serial_str
[12] = 0;
266 p
= strchr (pluto
->serial_str
, ' ');
269 PLD(("Found SSA rev %s fw rev %s serial %s %dx%d\n", pluto
->rev_str
, pluto
->fw_rev_str
, pluto
->serial_str
, host
->max_channel
, host
->max_id
))
271 fc
->fcp_register(fc
, TYPE_SCSI_FCP
, 1);
273 fc
->fcp_register(fc
, TYPE_SCSI_FCP
, 1);
277 printk ("PLUTO: Total of %d SparcSTORAGE Arrays found\n", nplutos
);
281 int pluto_release(struct Scsi_Host
*host
)
283 struct pluto
*pluto
= (struct pluto
*)host
->hostdata
;
284 fc_channel
*fc
= pluto
->fc
;
286 module_put(fc
->module
);
288 fc
->fcp_register(fc
, TYPE_SCSI_FCP
, 1);
289 PLND((" releasing pluto.\n"));
291 PLND(("released pluto!\n"));
295 const char *pluto_info(struct Scsi_Host
*host
)
297 static char buf
[128], *p
;
298 struct pluto
*pluto
= (struct pluto
*) host
->hostdata
;
300 sprintf(buf
, "SUN SparcSTORAGE Array %s fw %s serial %s %dx%d on %s",
301 pluto
->rev_str
, pluto
->fw_rev_str
, pluto
->serial_str
,
302 host
->max_channel
, host
->max_id
, pluto
->fc
->name
);
305 sprintf(p
, " PROM node %x", pluto
->fc
->dev
->prom_node
);
310 /* SSA uses this FC4S addressing:
313 case 0: CONTROLLER - All of addr[1]..addr[3] has to be 0
314 case 1: SINGLE DISK - addr[1] channel, addr[2] id, addr[3] 0
315 case 2: DISK GROUP - ???
318 So that SCSI mid-layer can access to these, we reserve
319 channel 0 id 0 lun 0 for CONTROLLER
320 and channels 1 .. max_channel are normal single disks.
322 static int pluto_encode_addr(Scsi_Cmnd
*SCpnt
, u16
*addr
, fc_channel
*fc
, fcp_cmnd
*fcmd
)
324 PLND(("encode addr %d %d %d\n", SCpnt
->device
->channel
, SCpnt
->device
->id
, SCpnt
->cmnd
[1] & 0xe0))
325 /* We don't support LUNs - neither does SSA :) */
326 if (SCpnt
->cmnd
[1] & 0xe0)
328 if (!SCpnt
->device
->channel
) {
329 if (SCpnt
->device
->id
)
331 memset (addr
, 0, 4 * sizeof(u16
));
334 addr
[1] = SCpnt
->device
->channel
- 1;
335 addr
[2] = SCpnt
->device
->id
;
338 /* We're Point-to-Point, so target it to the default DID */
340 PLND(("trying %04x%04x%04x%04x\n", addr
[0], addr
[1], addr
[2], addr
[3]))
344 static struct scsi_host_template driver_template
= {
345 .name
= "Sparc Storage Array 100/200",
346 .detect
= pluto_detect
,
347 .release
= pluto_release
,
349 .queuecommand
= fcp_scsi_queuecommand
,
350 .slave_configure
= pluto_slave_configure
,
351 .can_queue
= PLUTO_CAN_QUEUE
,
355 .use_clustering
= ENABLE_CLUSTERING
,
356 .eh_abort_handler
= fcp_scsi_abort
,
357 .eh_device_reset_handler
= fcp_scsi_dev_reset
,
358 .eh_host_reset_handler
= fcp_scsi_host_reset
,
361 #include "scsi_module.c"
363 MODULE_LICENSE("GPL");