Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/drivers/fc4/fc.c
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 33129 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 33129 byte(s)
Tag kernel26-2.6.12-alx-r9
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 |