Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* fc.c: Generic Fibre Channel and FC4 SCSI driver. |
2 | * | |
3 | * Copyright (C) 1997,1998,1999 Jakub Jelinek (jj@ultra.linux.cz) | |
4 | * Copyright (C) 1997,1998 Jirka Hanika (geo@ff.cuni.cz) | |
5 | * | |
6 | * There are two kinds of Fibre Channel adapters used in Linux. Either | |
7 | * the adapter is "smart" and does all FC bookkeeping by itself and | |
8 | * just presents a standard SCSI interface to the operating system | |
9 | * (that's e.g. the case with Qlogic FC cards), or leaves most of the FC | |
10 | * bookkeeping to the OS (e.g. soc, socal). Drivers for the former adapters | |
11 | * will look like normal SCSI drivers (with the exception of max_id will be | |
12 | * usually 127), the latter on the other side allows SCSI, IP over FC and other | |
13 | * protocols. This driver tree is for the latter adapters. | |
14 | * | |
15 | * This file should support both Point-to-Point and Arbitrated Loop topologies. | |
16 | * | |
17 | * Sources: | |
18 | * Fibre Channel Physical & Signaling Interface (FC-PH), dpANS, 1994 | |
19 | * dpANS Fibre Channel Protocol for SCSI (X3.269-199X), Rev. 012, 1995 | |
20 | * Fibre Channel Arbitrated Loop (FC-AL), Rev. 4.5, 1995 | |
21 | * Fibre Channel Private Loop SCSI Direct Attach (FC-PLDA), Rev. 2.1, 1997 | |
22 | */ | |
23 | ||
24 | #include <linux/module.h> | |
25 | #include <linux/kernel.h> | |
26 | #include <linux/jiffies.h> | |
27 | #include <linux/types.h> | |
28 | #include <linux/fcntl.h> | |
29 | #include <linux/interrupt.h> | |
30 | #include <linux/ptrace.h> | |
31 | #include <linux/ioport.h> | |
32 | #include <linux/in.h> | |
33 | #include <linux/slab.h> | |
34 | #include <linux/string.h> | |
35 | #include <linux/init.h> | |
36 | ||
37 | #include <asm/pgtable.h> | |
38 | #include <asm/irq.h> | |
39 | #include <asm/semaphore.h> | |
40 | #include "fcp_impl.h" | |
41 | #include <scsi/scsi_host.h> | |
42 | ||
43 | /* #define FCDEBUG */ | |
44 | ||
45 | #define fc_printk printk ("%s: ", fc->name); printk | |
46 | ||
47 | #ifdef FCDEBUG | |
48 | #define FCD(x) fc_printk x; | |
49 | #define FCND(x) printk ("FC: "); printk x; | |
50 | #else | |
51 | #define FCD(x) | |
52 | #define FCND(x) | |
53 | #endif | |
54 | ||
55 | #ifdef __sparc__ | |
56 | #define dma_alloc_consistent(d,s,p) sbus_alloc_consistent(d,s,p) | |
57 | #define dma_free_consistent(d,s,v,h) sbus_free_consistent(d,s,v,h) | |
58 | #define dma_map_single(d,v,s,dir) sbus_map_single(d,v,s,dir) | |
59 | #define dma_unmap_single(d,h,s,dir) sbus_unmap_single(d,h,s,dir) | |
60 | #define dma_map_sg(d,s,n,dir) sbus_map_sg(d,s,n,dir) | |
61 | #define dma_unmap_sg(d,s,n,dir) sbus_unmap_sg(d,s,n,dir) | |
62 | #else | |
63 | #define dma_alloc_consistent(d,s,p) pci_alloc_consistent(d,s,p) | |
64 | #define dma_free_consistent(d,s,v,h) pci_free_consistent(d,s,v,h) | |
65 | #define dma_map_single(d,v,s,dir) pci_map_single(d,v,s,dir) | |
66 | #define dma_unmap_single(d,h,s,dir) pci_unmap_single(d,h,s,dir) | |
67 | #define dma_map_sg(d,s,n,dir) pci_map_sg(d,s,n,dir) | |
68 | #define dma_unmap_sg(d,s,n,dir) pci_unmap_sg(d,s,n,dir) | |
69 | #endif | |
70 | ||
71 | #define FCP_CMND(SCpnt) ((fcp_cmnd *)&(SCpnt->SCp)) | |
72 | #define FC_SCMND(SCpnt) ((fc_channel *)(SCpnt->device->host->hostdata[0])) | |
73 | #define SC_FCMND(fcmnd) ((Scsi_Cmnd *)((long)fcmnd - (long)&(((Scsi_Cmnd *)0)->SCp))) | |
74 | ||
75 | static int fcp_scsi_queue_it(fc_channel *, Scsi_Cmnd *, fcp_cmnd *, int); | |
76 | void fcp_queue_empty(fc_channel *); | |
77 | ||
78 | static void fcp_scsi_insert_queue (fc_channel *fc, fcp_cmnd *fcmd) | |
79 | { | |
80 | if (!fc->scsi_que) { | |
81 | fc->scsi_que = fcmd; | |
82 | fcmd->next = fcmd; | |
83 | fcmd->prev = fcmd; | |
84 | } else { | |
85 | fc->scsi_que->prev->next = fcmd; | |
86 | fcmd->prev = fc->scsi_que->prev; | |
87 | fc->scsi_que->prev = fcmd; | |
88 | fcmd->next = fc->scsi_que; | |
89 | } | |
90 | } | |
91 | ||
92 | static void fcp_scsi_remove_queue (fc_channel *fc, fcp_cmnd *fcmd) | |
93 | { | |
94 | if (fcmd == fcmd->next) { | |
95 | fc->scsi_que = NULL; | |
96 | return; | |
97 | } | |
98 | if (fcmd == fc->scsi_que) | |
99 | fc->scsi_que = fcmd->next; | |
100 | fcmd->prev->next = fcmd->next; | |
101 | fcmd->next->prev = fcmd->prev; | |
102 | } | |
103 | ||
104 | fc_channel *fc_channels = NULL; | |
105 | ||
106 | #define LSMAGIC 620829043 | |
107 | typedef struct { | |
108 | /* Must be first */ | |
109 | struct semaphore sem; | |
110 | int magic; | |
111 | int count; | |
112 | logi *logi; | |
113 | fcp_cmnd *fcmds; | |
114 | atomic_t todo; | |
115 | struct timer_list timer; | |
116 | unsigned char grace[0]; | |
117 | } ls; | |
118 | ||
119 | #define LSOMAGIC 654907799 | |
120 | typedef struct { | |
121 | /* Must be first */ | |
122 | struct semaphore sem; | |
123 | int magic; | |
124 | int count; | |
125 | fcp_cmnd *fcmds; | |
126 | atomic_t todo; | |
127 | struct timer_list timer; | |
128 | } lso; | |
129 | ||
130 | #define LSEMAGIC 84482456 | |
131 | typedef struct { | |
132 | /* Must be first */ | |
133 | struct semaphore sem; | |
134 | int magic; | |
135 | int status; | |
136 | struct timer_list timer; | |
137 | } lse; | |
138 | ||
139 | static void fcp_login_timeout(unsigned long data) | |
140 | { | |
141 | ls *l = (ls *)data; | |
142 | FCND(("Login timeout\n")) | |
143 | up(&l->sem); | |
144 | } | |
145 | ||
146 | static void fcp_login_done(fc_channel *fc, int i, int status) | |
147 | { | |
148 | fcp_cmnd *fcmd; | |
149 | logi *plogi; | |
150 | fc_hdr *fch; | |
151 | ls *l = (ls *)fc->ls; | |
152 | ||
153 | FCD(("Login done %d %d\n", i, status)) | |
154 | if (i < l->count) { | |
155 | if (fc->state == FC_STATE_FPORT_OK) { | |
156 | FCD(("Additional FPORT_OK received with status %d\n", status)) | |
157 | return; | |
158 | } | |
159 | switch (status) { | |
160 | case FC_STATUS_OK: /* Oh, we found a fabric */ | |
161 | case FC_STATUS_P_RJT: /* Oh, we haven't found any */ | |
162 | fc->state = FC_STATE_FPORT_OK; | |
163 | fcmd = l->fcmds + i; | |
164 | plogi = l->logi + 3 * i; | |
165 | dma_unmap_single (fc->dev, fcmd->cmd, 3 * sizeof(logi), | |
166 | DMA_BIDIRECTIONAL); | |
167 | plogi->code = LS_PLOGI; | |
168 | memcpy (&plogi->nport_wwn, &fc->wwn_nport, sizeof(fc_wwn)); | |
169 | memcpy (&plogi->node_wwn, &fc->wwn_node, sizeof(fc_wwn)); | |
170 | memcpy (&plogi->common, fc->common_svc, sizeof(common_svc_parm)); | |
171 | memcpy (&plogi->class1, fc->class_svcs, 3*sizeof(svc_parm)); | |
172 | fch = &fcmd->fch; | |
173 | fcmd->token += l->count; | |
174 | FILL_FCHDR_RCTL_DID(fch, R_CTL_ELS_REQ, fc->did); | |
175 | FILL_FCHDR_SID(fch, fc->sid); | |
176 | #ifdef FCDEBUG | |
177 | { | |
178 | int i; | |
179 | unsigned *x = (unsigned *)plogi; | |
180 | printk ("logi: "); | |
181 | for (i = 0; i < 21; i++) | |
182 | printk ("%08x ", x[i]); | |
183 | printk ("\n"); | |
184 | } | |
185 | #endif | |
186 | fcmd->cmd = dma_map_single (fc->dev, plogi, 3 * sizeof(logi), | |
187 | DMA_BIDIRECTIONAL); | |
188 | fcmd->rsp = fcmd->cmd + 2 * sizeof(logi); | |
189 | if (fc->hw_enque (fc, fcmd)) | |
190 | printk ("FC: Cannot enque PLOGI packet on %s\n", fc->name); | |
191 | break; | |
192 | case FC_STATUS_ERR_OFFLINE: | |
193 | fc->state = FC_STATE_MAYBEOFFLINE; | |
194 | FCD (("FC is offline %d\n", l->grace[i])) | |
195 | break; | |
196 | default: | |
197 | printk ("FLOGI failed for %s with status %d\n", fc->name, status); | |
198 | /* Do some sort of error recovery here */ | |
199 | break; | |
200 | } | |
201 | } else { | |
202 | i -= l->count; | |
203 | if (fc->state != FC_STATE_FPORT_OK) { | |
204 | FCD(("Unexpected N-PORT rsp received")) | |
205 | return; | |
206 | } | |
207 | switch (status) { | |
208 | case FC_STATUS_OK: | |
209 | plogi = l->logi + 3 * i; | |
210 | dma_unmap_single (fc->dev, l->fcmds[i].cmd, 3 * sizeof(logi), | |
211 | DMA_BIDIRECTIONAL); | |
212 | if (!fc->wwn_dest.lo && !fc->wwn_dest.hi) { | |
213 | memcpy (&fc->wwn_dest, &plogi[1].node_wwn, sizeof(fc_wwn)); | |
214 | FCD(("Dest WWN %08x%08x\n", *(u32 *)&fc->wwn_dest, fc->wwn_dest.lo)) | |
215 | } else if (fc->wwn_dest.lo != plogi[1].node_wwn.lo || | |
216 | fc->wwn_dest.hi != plogi[1].node_wwn.hi) { | |
217 | printk ("%s: mismatch in wwns. Got %08x%08x, expected %08x%08x\n", | |
218 | fc->name, | |
219 | *(u32 *)&plogi[1].node_wwn, plogi[1].node_wwn.lo, | |
220 | *(u32 *)&fc->wwn_dest, fc->wwn_dest.lo); | |
221 | } | |
222 | fc->state = FC_STATE_ONLINE; | |
223 | printk ("%s: ONLINE\n", fc->name); | |
224 | if (atomic_dec_and_test (&l->todo)) | |
225 | up(&l->sem); | |
226 | break; | |
227 | case FC_STATUS_ERR_OFFLINE: | |
228 | fc->state = FC_STATE_OFFLINE; | |
229 | dma_unmap_single (fc->dev, l->fcmds[i].cmd, 3 * sizeof(logi), | |
230 | DMA_BIDIRECTIONAL); | |
231 | printk ("%s: FC is offline\n", fc->name); | |
232 | if (atomic_dec_and_test (&l->todo)) | |
233 | up(&l->sem); | |
234 | break; | |
235 | default: | |
236 | printk ("PLOGI failed for %s with status %d\n", fc->name, status); | |
237 | /* Do some sort of error recovery here */ | |
238 | break; | |
239 | } | |
240 | } | |
241 | } | |
242 | ||
243 | static void fcp_report_map_done(fc_channel *fc, int i, int status) | |
244 | { | |
245 | fcp_cmnd *fcmd; | |
246 | fc_hdr *fch; | |
247 | unsigned char j; | |
248 | ls *l = (ls *)fc->ls; | |
249 | fc_al_posmap *p; | |
250 | ||
251 | FCD(("Report map done %d %d\n", i, status)) | |
252 | switch (status) { | |
253 | case FC_STATUS_OK: /* Ok, let's have a fun on a loop */ | |
254 | dma_unmap_single (fc->dev, l->fcmds[i].cmd, 3 * sizeof(logi), | |
255 | DMA_BIDIRECTIONAL); | |
256 | p = (fc_al_posmap *)(l->logi + 3 * i); | |
257 | #ifdef FCDEBUG | |
258 | { | |
259 | u32 *u = (u32 *)p; | |
260 | FCD(("%08x\n", u[0])) | |
261 | u ++; | |
262 | FCD(("%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n", u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7])) | |
263 | } | |
264 | #endif | |
265 | if ((p->magic & 0xffff0000) != FC_AL_LILP || !p->len) { | |
266 | printk ("FC: Bad magic from REPORT_AL_MAP on %s - %08x\n", fc->name, p->magic); | |
267 | fc->state = FC_STATE_OFFLINE; | |
268 | } else { | |
269 | fc->posmap = (fcp_posmap *)kmalloc(sizeof(fcp_posmap)+p->len, GFP_KERNEL); | |
270 | if (!fc->posmap) { | |
271 | printk("FC: Not enough memory, offlining channel\n"); | |
272 | fc->state = FC_STATE_OFFLINE; | |
273 | } else { | |
274 | int k; | |
275 | memset(fc->posmap, 0, sizeof(fcp_posmap)+p->len); | |
276 | /* FIXME: This is where SOCAL transfers our AL-PA. | |
277 | Keep it here till we found out what other cards do... */ | |
278 | fc->sid = (p->magic & 0xff); | |
279 | for (i = 0; i < p->len; i++) | |
280 | if (p->alpa[i] == fc->sid) | |
281 | break; | |
282 | k = p->len; | |
283 | if (i == p->len) | |
284 | i = 0; | |
285 | else { | |
286 | p->len--; | |
287 | i++; | |
288 | } | |
289 | fc->posmap->len = p->len; | |
290 | for (j = 0; j < p->len; j++) { | |
291 | if (i == k) i = 0; | |
292 | fc->posmap->list[j] = p->alpa[i++]; | |
293 | } | |
294 | fc->state = FC_STATE_ONLINE; | |
295 | } | |
296 | } | |
297 | printk ("%s: ONLINE\n", fc->name); | |
298 | if (atomic_dec_and_test (&l->todo)) | |
299 | up(&l->sem); | |
300 | break; | |
301 | case FC_STATUS_POINTTOPOINT: /* We're Point-to-Point, no AL... */ | |
302 | FCD(("SID %d DID %d\n", fc->sid, fc->did)) | |
303 | fcmd = l->fcmds + i; | |
304 | dma_unmap_single(fc->dev, fcmd->cmd, 3 * sizeof(logi), | |
305 | DMA_BIDIRECTIONAL); | |
306 | fch = &fcmd->fch; | |
307 | memset(l->logi + 3 * i, 0, 3 * sizeof(logi)); | |
308 | FILL_FCHDR_RCTL_DID(fch, R_CTL_ELS_REQ, FS_FABRIC_F_PORT); | |
309 | FILL_FCHDR_SID(fch, 0); | |
310 | FILL_FCHDR_TYPE_FCTL(fch, TYPE_EXTENDED_LS, F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE); | |
311 | FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0); | |
312 | FILL_FCHDR_OXRX(fch, 0xffff, 0xffff); | |
313 | fch->param = 0; | |
314 | l->logi [3 * i].code = LS_FLOGI; | |
315 | fcmd->cmd = dma_map_single (fc->dev, l->logi + 3 * i, 3 * sizeof(logi), | |
316 | DMA_BIDIRECTIONAL); | |
317 | fcmd->rsp = fcmd->cmd + sizeof(logi); | |
318 | fcmd->cmdlen = sizeof(logi); | |
319 | fcmd->rsplen = sizeof(logi); | |
320 | fcmd->data = (dma_addr_t)NULL; | |
321 | fcmd->class = FC_CLASS_SIMPLE; | |
322 | fcmd->proto = TYPE_EXTENDED_LS; | |
323 | if (fc->hw_enque (fc, fcmd)) | |
324 | printk ("FC: Cannot enque FLOGI packet on %s\n", fc->name); | |
325 | break; | |
326 | case FC_STATUS_ERR_OFFLINE: | |
327 | fc->state = FC_STATE_MAYBEOFFLINE; | |
328 | FCD (("FC is offline %d\n", l->grace[i])) | |
329 | break; | |
330 | default: | |
331 | printk ("FLOGI failed for %s with status %d\n", fc->name, status); | |
332 | /* Do some sort of error recovery here */ | |
333 | break; | |
334 | } | |
335 | } | |
336 | ||
337 | void fcp_register(fc_channel *fc, u8 type, int unregister) | |
338 | { | |
339 | int size, i; | |
340 | int slots = (fc->can_queue * 3) >> 1; | |
341 | ||
342 | FCND(("Going to %sregister\n", unregister ? "un" : "")) | |
343 | ||
344 | if (type == TYPE_SCSI_FCP) { | |
345 | if (!unregister) { | |
346 | fc->scsi_cmd_pool = (fcp_cmd *) | |
347 | dma_alloc_consistent (fc->dev, | |
348 | slots * (sizeof (fcp_cmd) + fc->rsp_size), | |
349 | &fc->dma_scsi_cmd); | |
350 | fc->scsi_rsp_pool = (char *)(fc->scsi_cmd_pool + slots); | |
351 | fc->dma_scsi_rsp = fc->dma_scsi_cmd + slots * sizeof (fcp_cmd); | |
352 | fc->scsi_bitmap_end = (slots + 63) & ~63; | |
353 | size = fc->scsi_bitmap_end / 8; | |
354 | fc->scsi_bitmap = kmalloc (size, GFP_KERNEL); | |
355 | memset (fc->scsi_bitmap, 0, size); | |
356 | set_bit (0, fc->scsi_bitmap); | |
357 | for (i = fc->can_queue; i < fc->scsi_bitmap_end; i++) | |
358 | set_bit (i, fc->scsi_bitmap); | |
359 | fc->scsi_free = fc->can_queue; | |
360 | fc->cmd_slots = (fcp_cmnd **)kmalloc(slots * sizeof(fcp_cmnd*), GFP_KERNEL); | |
361 | memset(fc->cmd_slots, 0, slots * sizeof(fcp_cmnd*)); | |
362 | fc->abort_count = 0; | |
363 | } else { | |
364 | fc->scsi_name[0] = 0; | |
365 | kfree (fc->scsi_bitmap); | |
366 | kfree (fc->cmd_slots); | |
367 | FCND(("Unregistering\n")); | |
368 | if (fc->rst_pkt) { | |
369 | if (fc->rst_pkt->eh_state == SCSI_STATE_UNUSED) | |
370 | kfree(fc->rst_pkt); | |
371 | else { | |
372 | /* Can't happen. Some memory would be lost. */ | |
373 | printk("FC: Reset in progress. Now?!"); | |
374 | } | |
375 | } | |
376 | FCND(("Unregistered\n")); | |
377 | } | |
378 | } else | |
379 | printk ("FC: %segistering unknown type %02x\n", unregister ? "Unr" : "R", type); | |
380 | } | |
381 | ||
382 | static void fcp_scsi_done(Scsi_Cmnd *SCpnt); | |
383 | ||
384 | static inline void fcp_scsi_receive(fc_channel *fc, int token, int status, fc_hdr *fch) | |
385 | { | |
386 | fcp_cmnd *fcmd; | |
387 | fcp_rsp *rsp; | |
388 | int host_status; | |
389 | Scsi_Cmnd *SCpnt; | |
390 | int sense_len; | |
391 | int rsp_status; | |
392 | ||
393 | fcmd = fc->cmd_slots[token]; | |
394 | if (!fcmd) return; | |
395 | rsp = (fcp_rsp *) (fc->scsi_rsp_pool + fc->rsp_size * token); | |
396 | SCpnt = SC_FCMND(fcmd); | |
397 | ||
398 | if (SCpnt->done != fcp_scsi_done) | |
399 | return; | |
400 | ||
401 | rsp_status = rsp->fcp_status; | |
402 | FCD(("rsp_status %08x status %08x\n", rsp_status, status)) | |
403 | switch (status) { | |
404 | case FC_STATUS_OK: | |
405 | host_status=DID_OK; | |
406 | ||
407 | if (rsp_status & FCP_STATUS_RESID) { | |
408 | #ifdef FCDEBUG | |
409 | FCD(("Resid %d\n", rsp->fcp_resid)) | |
410 | { | |
411 | fcp_cmd *cmd = fc->scsi_cmd_pool + token; | |
412 | int i; | |
413 | ||
414 | printk ("Command "); | |
415 | for (i = 0; i < sizeof(fcp_cmd); i+=4) | |
416 | printk ("%08x ", *(u32 *)(((char *)cmd)+i)); | |
417 | printk ("\nResponse "); | |
418 | for (i = 0; i < fc->rsp_size; i+=4) | |
419 | printk ("%08x ", *(u32 *)(((char *)rsp)+i)); | |
420 | printk ("\n"); | |
421 | } | |
422 | #endif | |
423 | } | |
424 | ||
425 | if (rsp_status & FCP_STATUS_SENSE_LEN) { | |
426 | sense_len = rsp->fcp_sense_len; | |
427 | if (sense_len > sizeof(SCpnt->sense_buffer)) sense_len = sizeof(SCpnt->sense_buffer); | |
428 | memcpy(SCpnt->sense_buffer, ((char *)(rsp+1)), sense_len); | |
429 | } | |
430 | ||
431 | if (fcmd->data) { | |
432 | if (SCpnt->use_sg) | |
433 | dma_unmap_sg(fc->dev, (struct scatterlist *)SCpnt->buffer, | |
434 | SCpnt->use_sg, | |
435 | SCpnt->sc_data_direction); | |
436 | else | |
437 | dma_unmap_single(fc->dev, fcmd->data, SCpnt->request_bufflen, | |
438 | SCpnt->sc_data_direction); | |
439 | } | |
440 | break; | |
441 | default: | |
442 | host_status=DID_ERROR; /* FIXME */ | |
443 | FCD(("Wrong FC status %d for token %d\n", status, token)) | |
444 | break; | |
445 | } | |
446 | ||
447 | if (status_byte(rsp_status) == QUEUE_FULL) { | |
448 | printk ("%s: (%d,%d) Received rsp_status 0x%x\n", fc->name, SCpnt->device->channel, SCpnt->device->id, rsp_status); | |
449 | } | |
450 | ||
451 | SCpnt->result = (host_status << 16) | (rsp_status & 0xff); | |
452 | #ifdef FCDEBUG | |
453 | if (host_status || SCpnt->result || rsp_status) printk("FC: host_status %d, packet status %d\n", | |
454 | host_status, SCpnt->result); | |
455 | #endif | |
456 | SCpnt->done = fcmd->done; | |
457 | fcmd->done=NULL; | |
458 | clear_bit(token, fc->scsi_bitmap); | |
459 | fc->scsi_free++; | |
460 | FCD(("Calling scsi_done with %08x\n", SCpnt->result)) | |
461 | SCpnt->scsi_done(SCpnt); | |
462 | } | |
463 | ||
464 | void fcp_receive_solicited(fc_channel *fc, int proto, int token, int status, fc_hdr *fch) | |
465 | { | |
466 | int magic; | |
467 | FCD(("receive_solicited %d %d %d\n", proto, token, status)) | |
468 | switch (proto) { | |
469 | case TYPE_SCSI_FCP: | |
470 | fcp_scsi_receive(fc, token, status, fch); break; | |
471 | case TYPE_EXTENDED_LS: | |
472 | case PROTO_REPORT_AL_MAP: | |
473 | magic = 0; | |
474 | if (fc->ls) | |
475 | magic = ((ls *)(fc->ls))->magic; | |
476 | if (magic == LSMAGIC) { | |
477 | ls *l = (ls *)fc->ls; | |
478 | int i = (token >= l->count) ? token - l->count : token; | |
479 | ||
480 | /* Let's be sure */ | |
481 | if ((unsigned)i < l->count && l->fcmds[i].fc == fc) { | |
482 | if (proto == TYPE_EXTENDED_LS) | |
483 | fcp_login_done(fc, token, status); | |
484 | else | |
485 | fcp_report_map_done(fc, token, status); | |
486 | break; | |
487 | } | |
488 | } | |
489 | FCD(("fc %p fc->ls %p fc->cmd_slots %p\n", fc, fc->ls, fc->cmd_slots)) | |
490 | if (proto == TYPE_EXTENDED_LS && !fc->ls && fc->cmd_slots) { | |
491 | fcp_cmnd *fcmd; | |
492 | ||
493 | fcmd = fc->cmd_slots[token]; | |
494 | if (fcmd && fcmd->ls && ((ls *)(fcmd->ls))->magic == LSEMAGIC) { | |
495 | lse *l = (lse *)fcmd->ls; | |
496 | ||
497 | l->status = status; | |
498 | up (&l->sem); | |
499 | } | |
500 | } | |
501 | break; | |
502 | case PROTO_OFFLINE: | |
503 | if (fc->ls && ((lso *)(fc->ls))->magic == LSOMAGIC) { | |
504 | lso *l = (lso *)fc->ls; | |
505 | ||
506 | if ((unsigned)token < l->count && l->fcmds[token].fc == fc) { | |
507 | /* Wow, OFFLINE response arrived :) */ | |
508 | FCD(("OFFLINE Response arrived\n")) | |
509 | fc->state = FC_STATE_OFFLINE; | |
510 | if (atomic_dec_and_test (&l->todo)) | |
511 | up(&l->sem); | |
512 | } | |
513 | } | |
514 | break; | |
515 | ||
516 | default: | |
517 | break; | |
518 | } | |
519 | } | |
520 | ||
521 | void fcp_state_change(fc_channel *fc, int state) | |
522 | { | |
523 | FCD(("state_change %d %d\n", state, fc->state)) | |
524 | if (state == FC_STATE_ONLINE && fc->state == FC_STATE_MAYBEOFFLINE) | |
525 | fc->state = FC_STATE_UNINITED; | |
526 | else if (state == FC_STATE_ONLINE) | |
527 | printk (KERN_WARNING "%s: state change to ONLINE\n", fc->name); | |
528 | else | |
529 | printk (KERN_ERR "%s: state change to OFFLINE\n", fc->name); | |
530 | } | |
531 | ||
532 | int fcp_initialize(fc_channel *fcchain, int count) | |
533 | { | |
534 | fc_channel *fc; | |
535 | fcp_cmnd *fcmd; | |
536 | int i, retry, ret; | |
537 | ls *l; | |
538 | ||
539 | FCND(("fcp_inititialize %08lx\n", (long)fcp_init)) | |
540 | FCND(("fc_channels %08lx\n", (long)fc_channels)) | |
541 | FCND((" SID %d DID %d\n", fcchain->sid, fcchain->did)) | |
542 | l = kmalloc(sizeof (ls) + count, GFP_KERNEL); | |
543 | if (!l) { | |
544 | printk ("FC: Cannot allocate memory for initialization\n"); | |
545 | return -ENOMEM; | |
546 | } | |
547 | memset (l, 0, sizeof(ls) + count); | |
548 | l->magic = LSMAGIC; | |
549 | l->count = count; | |
550 | FCND(("FCP Init for %d channels\n", count)) | |
551 | init_MUTEX_LOCKED(&l->sem); | |
552 | init_timer(&l->timer); | |
553 | l->timer.function = fcp_login_timeout; | |
554 | l->timer.data = (unsigned long)l; | |
555 | atomic_set (&l->todo, count); | |
556 | l->logi = kmalloc (count * 3 * sizeof(logi), GFP_KERNEL); | |
557 | l->fcmds = kmalloc (count * sizeof(fcp_cmnd), GFP_KERNEL); | |
558 | if (!l->logi || !l->fcmds) { | |
559 | if (l->logi) kfree (l->logi); | |
560 | if (l->fcmds) kfree (l->fcmds); | |
561 | kfree (l); | |
562 | printk ("FC: Cannot allocate DMA memory for initialization\n"); | |
563 | return -ENOMEM; | |
564 | } | |
565 | memset (l->logi, 0, count * 3 * sizeof(logi)); | |
566 | memset (l->fcmds, 0, count * sizeof(fcp_cmnd)); | |
567 | for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++) { | |
568 | fc->state = FC_STATE_UNINITED; | |
569 | fc->rst_pkt = NULL; /* kmalloc when first used */ | |
570 | } | |
571 | /* First try if we are in a AL topology */ | |
572 | FCND(("Initializing REPORT_MAP packets\n")) | |
573 | for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++) { | |
574 | fcmd = l->fcmds + i; | |
575 | fc->login = fcmd; | |
576 | fc->ls = (void *)l; | |
577 | /* Assumes sizeof(fc_al_posmap) < 3 * sizeof(logi), which is true */ | |
578 | fcmd->cmd = dma_map_single (fc->dev, l->logi + 3 * i, 3 * sizeof(logi), | |
579 | DMA_BIDIRECTIONAL); | |
580 | fcmd->proto = PROTO_REPORT_AL_MAP; | |
581 | fcmd->token = i; | |
582 | fcmd->fc = fc; | |
583 | } | |
584 | for (retry = 0; retry < 8; retry++) { | |
585 | int nqueued = 0; | |
586 | FCND(("Sending REPORT_MAP/FLOGI/PLOGI packets\n")) | |
587 | for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++) { | |
588 | if (fc->state == FC_STATE_ONLINE || fc->state == FC_STATE_OFFLINE) | |
589 | continue; | |
590 | disable_irq(fc->irq); | |
591 | if (fc->state == FC_STATE_MAYBEOFFLINE) { | |
592 | if (!l->grace[i]) { | |
593 | l->grace[i]++; | |
594 | FCD(("Grace\n")) | |
595 | } else { | |
596 | fc->state = FC_STATE_OFFLINE; | |
597 | enable_irq(fc->irq); | |
598 | dma_unmap_single (fc->dev, l->fcmds[i].cmd, 3 * sizeof(logi), DMA_BIDIRECTIONAL); | |
599 | if (atomic_dec_and_test (&l->todo)) | |
600 | goto all_done; | |
601 | } | |
602 | } | |
603 | ret = fc->hw_enque (fc, fc->login); | |
604 | enable_irq(fc->irq); | |
605 | if (!ret) { | |
606 | nqueued++; | |
607 | continue; | |
608 | } | |
609 | if (ret == -ENOSYS && fc->login->proto == PROTO_REPORT_AL_MAP) { | |
610 | /* Oh yes, this card handles Point-to-Point only, so let's try that. */ | |
611 | fc_hdr *fch; | |
612 | ||
613 | FCD(("SID %d DID %d\n", fc->sid, fc->did)) | |
614 | fcmd = l->fcmds + i; | |
615 | dma_unmap_single(fc->dev, fcmd->cmd, 3 * sizeof(logi), DMA_BIDIRECTIONAL); | |
616 | fch = &fcmd->fch; | |
617 | FILL_FCHDR_RCTL_DID(fch, R_CTL_ELS_REQ, FS_FABRIC_F_PORT); | |
618 | FILL_FCHDR_SID(fch, 0); | |
619 | FILL_FCHDR_TYPE_FCTL(fch, TYPE_EXTENDED_LS, F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE); | |
620 | FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0); | |
621 | FILL_FCHDR_OXRX(fch, 0xffff, 0xffff); | |
622 | fch->param = 0; | |
623 | l->logi [3 * i].code = LS_FLOGI; | |
624 | fcmd->cmd = dma_map_single (fc->dev, l->logi + 3 * i, 3 * sizeof(logi), DMA_BIDIRECTIONAL); | |
625 | fcmd->rsp = fcmd->cmd + sizeof(logi); | |
626 | fcmd->cmdlen = sizeof(logi); | |
627 | fcmd->rsplen = sizeof(logi); | |
628 | fcmd->data = (dma_addr_t)NULL; | |
629 | fcmd->class = FC_CLASS_SIMPLE; | |
630 | fcmd->proto = TYPE_EXTENDED_LS; | |
631 | } else | |
632 | printk ("FC: Cannot enque FLOGI/REPORT_MAP packet on %s\n", fc->name); | |
633 | } | |
634 | ||
635 | if (nqueued) { | |
636 | l->timer.expires = jiffies + 5 * HZ; | |
637 | add_timer(&l->timer); | |
638 | ||
639 | down(&l->sem); | |
640 | if (!atomic_read(&l->todo)) { | |
641 | FCND(("All channels answered in time\n")) | |
642 | break; /* All fc channels have answered us */ | |
643 | } | |
644 | } | |
645 | } | |
646 | all_done: | |
647 | for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++) { | |
648 | fc->ls = NULL; | |
649 | switch (fc->state) { | |
650 | case FC_STATE_ONLINE: break; | |
651 | case FC_STATE_OFFLINE: break; | |
652 | default: dma_unmap_single (fc->dev, l->fcmds[i].cmd, 3 * sizeof(logi), DMA_BIDIRECTIONAL); | |
653 | break; | |
654 | } | |
655 | } | |
656 | del_timer(&l->timer); | |
657 | kfree (l->logi); | |
658 | kfree (l->fcmds); | |
659 | kfree (l); | |
660 | return 0; | |
661 | } | |
662 | ||
663 | int fcp_forceoffline(fc_channel *fcchain, int count) | |
664 | { | |
665 | fc_channel *fc; | |
666 | fcp_cmnd *fcmd; | |
667 | int i, ret; | |
668 | lso l; | |
669 | ||
670 | memset (&l, 0, sizeof(lso)); | |
671 | l.count = count; | |
672 | l.magic = LSOMAGIC; | |
673 | FCND(("FCP Force Offline for %d channels\n", count)) | |
674 | init_MUTEX_LOCKED(&l.sem); | |
675 | init_timer(&l.timer); | |
676 | l.timer.function = fcp_login_timeout; | |
677 | l.timer.data = (unsigned long)&l; | |
678 | atomic_set (&l.todo, count); | |
679 | l.fcmds = kmalloc (count * sizeof(fcp_cmnd), GFP_KERNEL); | |
680 | if (!l.fcmds) { | |
681 | kfree (l.fcmds); | |
682 | printk ("FC: Cannot allocate memory for forcing offline\n"); | |
683 | return -ENOMEM; | |
684 | } | |
685 | memset (l.fcmds, 0, count * sizeof(fcp_cmnd)); | |
686 | FCND(("Initializing OFFLINE packets\n")) | |
687 | for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++) { | |
688 | fc->state = FC_STATE_UNINITED; | |
689 | fcmd = l.fcmds + i; | |
690 | fc->login = fcmd; | |
691 | fc->ls = (void *)&l; | |
692 | fcmd->did = fc->did; | |
693 | fcmd->class = FC_CLASS_OFFLINE; | |
694 | fcmd->proto = PROTO_OFFLINE; | |
695 | fcmd->token = i; | |
696 | fcmd->fc = fc; | |
697 | disable_irq(fc->irq); | |
698 | ret = fc->hw_enque (fc, fc->login); | |
699 | enable_irq(fc->irq); | |
700 | if (ret) printk ("FC: Cannot enque OFFLINE packet on %s\n", fc->name); | |
701 | } | |
702 | ||
703 | l.timer.expires = jiffies + 5 * HZ; | |
704 | add_timer(&l.timer); | |
705 | down(&l.sem); | |
706 | del_timer(&l.timer); | |
707 | ||
708 | for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++) | |
709 | fc->ls = NULL; | |
710 | kfree (l.fcmds); | |
711 | return 0; | |
712 | } | |
713 | ||
714 | int fcp_init(fc_channel *fcchain) | |
715 | { | |
716 | fc_channel *fc; | |
717 | int count=0; | |
718 | int ret; | |
719 | ||
720 | for (fc = fcchain; fc; fc = fc->next) { | |
721 | fc->fcp_register = fcp_register; | |
722 | count++; | |
723 | } | |
724 | ||
725 | ret = fcp_initialize (fcchain, count); | |
726 | if (ret) | |
727 | return ret; | |
728 | ||
729 | if (!fc_channels) | |
730 | fc_channels = fcchain; | |
731 | else { | |
732 | for (fc = fc_channels; fc->next; fc = fc->next); | |
733 | fc->next = fcchain; | |
734 | } | |
735 | return ret; | |
736 | } | |
737 | ||
738 | void fcp_release(fc_channel *fcchain, int count) /* count must > 0 */ | |
739 | { | |
740 | fc_channel *fc; | |
741 | fc_channel *fcx; | |
742 | ||
743 | for (fc = fcchain; --count && fc->next; fc = fc->next); | |
744 | if (count) { | |
745 | printk("FC: nothing to release\n"); | |
746 | return; | |
747 | } | |
748 | ||
749 | if (fc_channels == fcchain) | |
750 | fc_channels = fc->next; | |
751 | else { | |
752 | for (fcx = fc_channels; fcx->next != fcchain; fcx = fcx->next); | |
753 | fcx->next = fc->next; | |
754 | } | |
755 | fc->next = NULL; | |
756 | ||
757 | /* | |
758 | * We've just grabbed fcchain out of the fc_channel list | |
759 | * and zero-terminated it, while destroying the count. | |
760 | * | |
761 | * Freeing the fc's is the low level driver's responsibility. | |
762 | */ | |
763 | } | |
764 | ||
765 | ||
766 | static void fcp_scsi_done (Scsi_Cmnd *SCpnt) | |
767 | { | |
768 | unsigned long flags; | |
769 | ||
770 | spin_lock_irqsave(SCpnt->device->host->host_lock, flags); | |
771 | if (FCP_CMND(SCpnt)->done) | |
772 | FCP_CMND(SCpnt)->done(SCpnt); | |
773 | spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags); | |
774 | } | |
775 | ||
776 | static int fcp_scsi_queue_it(fc_channel *fc, Scsi_Cmnd *SCpnt, fcp_cmnd *fcmd, int prepare) | |
777 | { | |
778 | long i; | |
779 | fcp_cmd *cmd; | |
780 | u32 fcp_cntl; | |
781 | if (prepare) { | |
782 | i = find_first_zero_bit (fc->scsi_bitmap, fc->scsi_bitmap_end); | |
783 | set_bit (i, fc->scsi_bitmap); | |
784 | fcmd->token = i; | |
785 | cmd = fc->scsi_cmd_pool + i; | |
786 | ||
787 | if (fc->encode_addr (SCpnt, cmd->fcp_addr, fc, fcmd)) { | |
788 | /* Invalid channel/id/lun and couldn't map it into fcp_addr */ | |
789 | clear_bit (i, fc->scsi_bitmap); | |
790 | SCpnt->result = (DID_BAD_TARGET << 16); | |
791 | SCpnt->scsi_done(SCpnt); | |
792 | return 0; | |
793 | } | |
794 | fc->scsi_free--; | |
795 | fc->cmd_slots[fcmd->token] = fcmd; | |
796 | ||
797 | if (SCpnt->device->tagged_supported) { | |
798 | if (jiffies - fc->ages[SCpnt->device->channel * fc->targets + SCpnt->device->id] > (5 * 60 * HZ)) { | |
799 | fc->ages[SCpnt->device->channel * fc->targets + SCpnt->device->id] = jiffies; | |
800 | fcp_cntl = FCP_CNTL_QTYPE_ORDERED; | |
801 | } else | |
802 | fcp_cntl = FCP_CNTL_QTYPE_SIMPLE; | |
803 | } else | |
804 | fcp_cntl = FCP_CNTL_QTYPE_UNTAGGED; | |
805 | if (!SCpnt->request_bufflen && !SCpnt->use_sg) { | |
806 | cmd->fcp_cntl = fcp_cntl; | |
807 | fcmd->data = (dma_addr_t)NULL; | |
808 | } else { | |
809 | switch (SCpnt->cmnd[0]) { | |
810 | case WRITE_6: | |
811 | case WRITE_10: | |
812 | case WRITE_12: | |
813 | cmd->fcp_cntl = (FCP_CNTL_WRITE | fcp_cntl); break; | |
814 | default: | |
815 | cmd->fcp_cntl = (FCP_CNTL_READ | fcp_cntl); break; | |
816 | } | |
817 | if (!SCpnt->use_sg) { | |
818 | cmd->fcp_data_len = SCpnt->request_bufflen; | |
819 | fcmd->data = dma_map_single (fc->dev, (char *)SCpnt->request_buffer, | |
820 | SCpnt->request_bufflen, | |
821 | SCpnt->sc_data_direction); | |
822 | } else { | |
823 | struct scatterlist *sg = (struct scatterlist *)SCpnt->buffer; | |
824 | int nents; | |
825 | ||
826 | FCD(("XXX: Use_sg %d %d\n", SCpnt->use_sg, sg->length)) | |
827 | nents = dma_map_sg (fc->dev, sg, SCpnt->use_sg, | |
828 | SCpnt->sc_data_direction); | |
829 | if (nents > 1) printk ("%s: SG for nents %d (use_sg %d) not handled yet\n", fc->name, nents, SCpnt->use_sg); | |
830 | fcmd->data = sg_dma_address(sg); | |
831 | cmd->fcp_data_len = sg_dma_len(sg); | |
832 | } | |
833 | } | |
834 | memcpy (cmd->fcp_cdb, SCpnt->cmnd, SCpnt->cmd_len); | |
835 | memset (cmd->fcp_cdb+SCpnt->cmd_len, 0, sizeof(cmd->fcp_cdb)-SCpnt->cmd_len); | |
836 | FCD(("XXX: %04x.%04x.%04x.%04x - %08x%08x%08x\n", cmd->fcp_addr[0], cmd->fcp_addr[1], cmd->fcp_addr[2], cmd->fcp_addr[3], *(u32 *)SCpnt->cmnd, *(u32 *)(SCpnt->cmnd+4), *(u32 *)(SCpnt->cmnd+8))) | |
837 | } | |
838 | FCD(("Trying to enque %p\n", fcmd)) | |
839 | if (!fc->scsi_que) { | |
840 | if (!fc->hw_enque (fc, fcmd)) { | |
841 | FCD(("hw_enque succeeded for %p\n", fcmd)) | |
842 | return 0; | |
843 | } | |
844 | } | |
845 | FCD(("Putting into que1 %p\n", fcmd)) | |
846 | fcp_scsi_insert_queue (fc, fcmd); | |
847 | return 0; | |
848 | } | |
849 | ||
850 | int fcp_scsi_queuecommand(Scsi_Cmnd *SCpnt, void (* done)(Scsi_Cmnd *)) | |
851 | { | |
852 | fcp_cmnd *fcmd = FCP_CMND(SCpnt); | |
853 | fc_channel *fc = FC_SCMND(SCpnt); | |
854 | ||
855 | FCD(("Entering SCSI queuecommand %p\n", fcmd)) | |
856 | if (SCpnt->done != fcp_scsi_done) { | |
857 | fcmd->done = SCpnt->done; | |
858 | SCpnt->done = fcp_scsi_done; | |
859 | SCpnt->scsi_done = done; | |
860 | fcmd->proto = TYPE_SCSI_FCP; | |
861 | if (!fc->scsi_free) { | |
862 | FCD(("FC: !scsi_free, putting cmd on ML queue\n")) | |
863 | #if (FCP_SCSI_USE_NEW_EH_CODE == 0) | |
864 | printk("fcp_scsi_queue_command: queue full, losing cmd, bad\n"); | |
865 | #endif | |
866 | return 1; | |
867 | } | |
868 | return fcp_scsi_queue_it(fc, SCpnt, fcmd, 1); | |
869 | } | |
870 | return fcp_scsi_queue_it(fc, SCpnt, fcmd, 0); | |
871 | } | |
872 | ||
873 | void fcp_queue_empty(fc_channel *fc) | |
874 | { | |
875 | fcp_cmnd *fcmd; | |
876 | ||
877 | FCD(("Queue empty\n")) | |
878 | while ((fcmd = fc->scsi_que)) { | |
879 | /* The hw told us we can try again queue some packet */ | |
880 | if (fc->hw_enque (fc, fcmd)) | |
881 | break; | |
882 | fcp_scsi_remove_queue (fc, fcmd); | |
883 | } | |
884 | } | |
885 | ||
886 | int fcp_scsi_abort(Scsi_Cmnd *SCpnt) | |
887 | { | |
888 | /* Internal bookkeeping only. Lose 1 cmd_slots slot. */ | |
889 | fcp_cmnd *fcmd = FCP_CMND(SCpnt); | |
890 | fc_channel *fc = FC_SCMND(SCpnt); | |
891 | ||
892 | /* | |
893 | * We react to abort requests by simply forgetting | |
894 | * about the command and pretending everything's sweet. | |
895 | * This may or may not be silly. We can't, however, | |
896 | * immediately reuse the command's cmd_slots slot, | |
897 | * as its result may arrive later and we cannot | |
898 | * check whether it is the aborted one, can't we? | |
899 | * | |
900 | * Therefore, after the first few aborts are done, | |
901 | * we tell the scsi error handler to do something clever. | |
902 | * It will eventually call host reset, refreshing | |
903 | * cmd_slots for us. | |
904 | * | |
905 | * There is a theoretical chance that we sometimes allow | |
906 | * more than can_queue packets to the jungle this way, | |
907 | * but the worst outcome possible is a series of | |
908 | * more aborts and eventually the dev_reset catharsis. | |
909 | */ | |
910 | ||
911 | if (++fc->abort_count < (fc->can_queue >> 1)) { | |
912 | unsigned long flags; | |
913 | ||
914 | SCpnt->result = DID_ABORT; | |
915 | spin_lock_irqsave(SCpnt->device->host->host_lock, flags); | |
916 | fcmd->done(SCpnt); | |
917 | spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags); | |
918 | printk("FC: soft abort\n"); | |
919 | return SUCCESS; | |
920 | } else { | |
921 | printk("FC: hard abort refused\n"); | |
922 | return FAILED; | |
923 | } | |
924 | } | |
925 | ||
926 | void fcp_scsi_reset_done(Scsi_Cmnd *SCpnt) | |
927 | { | |
928 | fc_channel *fc = FC_SCMND(SCpnt); | |
929 | ||
930 | fc->rst_pkt->eh_state = SCSI_STATE_FINISHED; | |
931 | up(fc->rst_pkt->device->host->eh_action); | |
932 | } | |
933 | ||
934 | #define FCP_RESET_TIMEOUT (2*HZ) | |
935 | ||
936 | int fcp_scsi_dev_reset(Scsi_Cmnd *SCpnt) | |
937 | { | |
938 | fcp_cmd *cmd; | |
939 | fcp_cmnd *fcmd; | |
940 | fc_channel *fc = FC_SCMND(SCpnt); | |
941 | DECLARE_MUTEX_LOCKED(sem); | |
942 | ||
943 | if (!fc->rst_pkt) { | |
944 | fc->rst_pkt = (Scsi_Cmnd *) kmalloc(sizeof(SCpnt), GFP_KERNEL); | |
945 | if (!fc->rst_pkt) return FAILED; | |
946 | ||
947 | fcmd = FCP_CMND(fc->rst_pkt); | |
948 | ||
949 | ||
950 | fcmd->token = 0; | |
951 | cmd = fc->scsi_cmd_pool + 0; | |
952 | FCD(("Preparing rst packet\n")) | |
953 | fc->encode_addr (SCpnt, cmd->fcp_addr, fc, fcmd); | |
954 | fc->rst_pkt->device = SCpnt->device; | |
955 | fc->rst_pkt->cmd_len = 0; | |
956 | ||
957 | fc->cmd_slots[0] = fcmd; | |
958 | ||
959 | cmd->fcp_cntl = FCP_CNTL_QTYPE_ORDERED | FCP_CNTL_RESET; | |
960 | fcmd->data = (dma_addr_t)NULL; | |
961 | fcmd->proto = TYPE_SCSI_FCP; | |
962 | ||
963 | memcpy (cmd->fcp_cdb, SCpnt->cmnd, SCpnt->cmd_len); | |
964 | memset (cmd->fcp_cdb+SCpnt->cmd_len, 0, sizeof(cmd->fcp_cdb)-SCpnt->cmd_len); | |
965 | FCD(("XXX: %04x.%04x.%04x.%04x - %08x%08x%08x\n", cmd->fcp_addr[0], cmd->fcp_addr[1], cmd->fcp_addr[2], cmd->fcp_addr[3], *(u32 *)SCpnt->cmnd, *(u32 *)(SCpnt->cmnd+4), *(u32 *)(SCpnt->cmnd+8))) | |
966 | } else { | |
967 | fcmd = FCP_CMND(fc->rst_pkt); | |
968 | if (fc->rst_pkt->eh_state == SCSI_STATE_QUEUED) | |
969 | return FAILED; /* or SUCCESS. Only these */ | |
970 | } | |
971 | fc->rst_pkt->done = NULL; | |
972 | ||
973 | ||
974 | fc->rst_pkt->eh_state = SCSI_STATE_QUEUED; | |
975 | init_timer(&fc->rst_pkt->eh_timeout); | |
976 | fc->rst_pkt->eh_timeout.data = (unsigned long) fc->rst_pkt; | |
977 | fc->rst_pkt->eh_timeout.expires = jiffies + FCP_RESET_TIMEOUT; | |
978 | fc->rst_pkt->eh_timeout.function = (void (*)(unsigned long))fcp_scsi_reset_done; | |
979 | ||
980 | add_timer(&fc->rst_pkt->eh_timeout); | |
981 | ||
982 | /* | |
983 | * Set up the semaphore so we wait for the command to complete. | |
984 | */ | |
985 | ||
986 | fc->rst_pkt->device->host->eh_action = &sem; | |
987 | fc->rst_pkt->request->rq_status = RQ_SCSI_BUSY; | |
988 | ||
989 | fc->rst_pkt->done = fcp_scsi_reset_done; | |
990 | fcp_scsi_queue_it(fc, fc->rst_pkt, fcmd, 0); | |
991 | ||
992 | down(&sem); | |
993 | ||
994 | fc->rst_pkt->device->host->eh_action = NULL; | |
995 | del_timer(&fc->rst_pkt->eh_timeout); | |
996 | ||
997 | /* | |
998 | * See if timeout. If so, tell the host to forget about it. | |
999 | * In other words, we don't want a callback any more. | |
1000 | */ | |
1001 | if (fc->rst_pkt->eh_state == SCSI_STATE_TIMEOUT ) { | |
1002 | fc->rst_pkt->eh_state = SCSI_STATE_UNUSED; | |
1003 | return FAILED; | |
1004 | } | |
1005 | fc->rst_pkt->eh_state = SCSI_STATE_UNUSED; | |
1006 | return SUCCESS; | |
1007 | } | |
1008 | ||
1009 | int fcp_scsi_bus_reset(Scsi_Cmnd *SCpnt) | |
1010 | { | |
1011 | printk ("FC: bus reset!\n"); | |
1012 | return FAILED; | |
1013 | } | |
1014 | ||
1015 | int fcp_scsi_host_reset(Scsi_Cmnd *SCpnt) | |
1016 | { | |
1017 | fc_channel *fc = FC_SCMND(SCpnt); | |
1018 | fcp_cmnd *fcmd = FCP_CMND(SCpnt); | |
1019 | int i; | |
1020 | ||
1021 | printk ("FC: host reset\n"); | |
1022 | ||
1023 | for (i=0; i < fc->can_queue; i++) { | |
1024 | if (fc->cmd_slots[i] && SCpnt->result != DID_ABORT) { | |
1025 | SCpnt->result = DID_RESET; | |
1026 | fcmd->done(SCpnt); | |
1027 | fc->cmd_slots[i] = NULL; | |
1028 | } | |
1029 | } | |
1030 | fc->reset(fc); | |
1031 | fc->abort_count = 0; | |
1032 | if (fcp_initialize(fc, 1)) return SUCCESS; | |
1033 | else return FAILED; | |
1034 | } | |
1035 | ||
1036 | static int fcp_els_queue_it(fc_channel *fc, fcp_cmnd *fcmd) | |
1037 | { | |
1038 | long i; | |
1039 | ||
1040 | i = find_first_zero_bit (fc->scsi_bitmap, fc->scsi_bitmap_end); | |
1041 | set_bit (i, fc->scsi_bitmap); | |
1042 | fcmd->token = i; | |
1043 | fc->scsi_free--; | |
1044 | fc->cmd_slots[fcmd->token] = fcmd; | |
1045 | return fcp_scsi_queue_it(fc, NULL, fcmd, 0); | |
1046 | } | |
1047 | ||
1048 | static int fc_do_els(fc_channel *fc, unsigned int alpa, void *data, int len) | |
1049 | { | |
1050 | fcp_cmnd _fcmd, *fcmd; | |
1051 | fc_hdr *fch; | |
1052 | lse l; | |
1053 | int i; | |
1054 | ||
1055 | fcmd = &_fcmd; | |
1056 | memset(fcmd, 0, sizeof(fcmd)); | |
1057 | FCD(("PLOGI SID %d DID %d\n", fc->sid, alpa)) | |
1058 | fch = &fcmd->fch; | |
1059 | FILL_FCHDR_RCTL_DID(fch, R_CTL_ELS_REQ, alpa); | |
1060 | FILL_FCHDR_SID(fch, fc->sid); | |
1061 | FILL_FCHDR_TYPE_FCTL(fch, TYPE_EXTENDED_LS, F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE); | |
1062 | FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0); | |
1063 | FILL_FCHDR_OXRX(fch, 0xffff, 0xffff); | |
1064 | fch->param = 0; | |
1065 | fcmd->cmd = dma_map_single (fc->dev, data, 2 * len, DMA_BIDIRECTIONAL); | |
1066 | fcmd->rsp = fcmd->cmd + len; | |
1067 | fcmd->cmdlen = len; | |
1068 | fcmd->rsplen = len; | |
1069 | fcmd->data = (dma_addr_t)NULL; | |
1070 | fcmd->fc = fc; | |
1071 | fcmd->class = FC_CLASS_SIMPLE; | |
1072 | fcmd->proto = TYPE_EXTENDED_LS; | |
1073 | ||
1074 | memset (&l, 0, sizeof(lse)); | |
1075 | l.magic = LSEMAGIC; | |
1076 | init_MUTEX_LOCKED(&l.sem); | |
1077 | l.timer.function = fcp_login_timeout; | |
1078 | l.timer.data = (unsigned long)&l; | |
1079 | l.status = FC_STATUS_TIMED_OUT; | |
1080 | fcmd->ls = (void *)&l; | |
1081 | ||
1082 | disable_irq(fc->irq); | |
1083 | fcp_els_queue_it(fc, fcmd); | |
1084 | enable_irq(fc->irq); | |
1085 | ||
1086 | for (i = 0;;) { | |
1087 | l.timer.expires = jiffies + 5 * HZ; | |
1088 | add_timer(&l.timer); | |
1089 | down(&l.sem); | |
1090 | del_timer(&l.timer); | |
1091 | if (l.status != FC_STATUS_TIMED_OUT) break; | |
1092 | if (++i == 3) break; | |
1093 | disable_irq(fc->irq); | |
1094 | fcp_scsi_queue_it(fc, NULL, fcmd, 0); | |
1095 | enable_irq(fc->irq); | |
1096 | } | |
1097 | ||
1098 | clear_bit(fcmd->token, fc->scsi_bitmap); | |
1099 | fc->scsi_free++; | |
1100 | dma_unmap_single (fc->dev, fcmd->cmd, 2 * len, DMA_BIDIRECTIONAL); | |
1101 | return l.status; | |
1102 | } | |
1103 | ||
1104 | int fc_do_plogi(fc_channel *fc, unsigned char alpa, fc_wwn *node, fc_wwn *nport) | |
1105 | { | |
1106 | logi *l; | |
1107 | int status; | |
1108 | ||
1109 | l = (logi *)kmalloc(2 * sizeof(logi), GFP_KERNEL); | |
1110 | if (!l) return -ENOMEM; | |
1111 | memset(l, 0, 2 * sizeof(logi)); | |
1112 | l->code = LS_PLOGI; | |
1113 | memcpy (&l->nport_wwn, &fc->wwn_nport, sizeof(fc_wwn)); | |
1114 | memcpy (&l->node_wwn, &fc->wwn_node, sizeof(fc_wwn)); | |
1115 | memcpy (&l->common, fc->common_svc, sizeof(common_svc_parm)); | |
1116 | memcpy (&l->class1, fc->class_svcs, 3*sizeof(svc_parm)); | |
1117 | status = fc_do_els(fc, alpa, l, sizeof(logi)); | |
1118 | if (status == FC_STATUS_OK) { | |
1119 | if (l[1].code == LS_ACC) { | |
1120 | #ifdef FCDEBUG | |
1121 | u32 *u = (u32 *)&l[1].nport_wwn; | |
1122 | FCD(("AL-PA %02x: Port WWN %08x%08x Node WWN %08x%08x\n", alpa, | |
1123 | u[0], u[1], u[2], u[3])) | |
1124 | #endif | |
1125 | memcpy(nport, &l[1].nport_wwn, sizeof(fc_wwn)); | |
1126 | memcpy(node, &l[1].node_wwn, sizeof(fc_wwn)); | |
1127 | } else | |
1128 | status = FC_STATUS_BAD_RSP; | |
1129 | } | |
1130 | kfree(l); | |
1131 | return status; | |
1132 | } | |
1133 | ||
1134 | typedef struct { | |
1135 | unsigned int code; | |
1136 | unsigned params[4]; | |
1137 | } prli; | |
1138 | ||
1139 | int fc_do_prli(fc_channel *fc, unsigned char alpa) | |
1140 | { | |
1141 | prli *p; | |
1142 | int status; | |
1143 | ||
1144 | p = (prli *)kmalloc(2 * sizeof(prli), GFP_KERNEL); | |
1145 | if (!p) return -ENOMEM; | |
1146 | memset(p, 0, 2 * sizeof(prli)); | |
1147 | p->code = LS_PRLI; | |
1148 | p->params[0] = 0x08002000; | |
1149 | p->params[3] = 0x00000022; | |
1150 | status = fc_do_els(fc, alpa, p, sizeof(prli)); | |
1151 | if (status == FC_STATUS_OK && p[1].code != LS_PRLI_ACC && p[1].code != LS_ACC) | |
1152 | status = FC_STATUS_BAD_RSP; | |
1153 | kfree(p); | |
1154 | return status; | |
1155 | } | |
1156 | ||
1157 | MODULE_LICENSE("GPL"); | |
1158 |