1 /*
2 ******************************************************************************************
3 ** O.S : FreeBSD
4 ** FILE NAME : arcmsr.c
5 ** BY : Erich Chen
6 ** Description: SCSI RAID Device Driver for
7 ** ARECA (ARC11XX/ARC12XX) SATA RAID HOST Adapter
8 ** ARCMSR RAID Host adapter[RAID controller:INTEL 331(PCI-X) 341(PCI-EXPRESS) chip set]
9 ******************************************************************************************
10 ************************************************************************
11 **
12 ** Copyright (c) 2004-2006 ARECA Co. Ltd.
13 ** Erich Chen, Taipei Taiwan All rights reserved.
14 **
15 ** Redistribution and use in source and binary forms,with or without
16 ** modification,are permitted provided that the following conditions
17 ** are met:
18 ** 1. Redistributions of source code must retain the above copyright
19 ** notice,this list of conditions and the following disclaimer.
20 ** 2. Redistributions in binary form must reproduce the above copyright
21 ** notice,this list of conditions and the following disclaimer in the
22 ** documentation and/or other materials provided with the distribution.
23 ** 3. The name of the author may not be used to endorse or promote products
24 ** derived from this software without specific prior written permission.
25 **
26 ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
27 ** IMPLIED WARRANTIES,INCLUDING,BUT NOT LIMITED TO,THE IMPLIED WARRANTIES
28 ** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
29 ** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,INDIRECT,
30 ** INCIDENTAL,SPECIAL,EXEMPLARY,OR CONSEQUENTIAL DAMAGES(INCLUDING,BUT
31 ** NOT LIMITED TO,PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 ** DATA,OR PROFITS; OR BUSINESS INTERRUPTION)HOWEVER CAUSED AND ON ANY
33 ** THEORY OF LIABILITY,WHETHER IN CONTRACT,STRICT LIABILITY,OR TORT
34 **(INCLUDING NEGLIGENCE OR OTHERWISE)ARISING IN ANY WAY OUT OF THE USE OF
35 ** THIS SOFTWARE,EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 **************************************************************************
37 ** History
38 **
39 ** REV# DATE NAME DESCRIPTION
40 ** 1.00.00.00 3/31/2004 Erich Chen First release
41 ** 1.20.00.02 11/29/2004 Erich Chen bug fix with arcmsr_bus_reset when PHY error
42 ** 1.20.00.03 4/19/2005 Erich Chen add SATA 24 Ports adapter type support
43 ** clean unused function
44 ** 1.20.00.12 9/12/2005 Erich Chen bug fix with abort command handling,firmware version check
45 ** and firmware update notify for hardware bug fix
46 ** handling if none zero high part physical address
47 ** of srb resource
48 ******************************************************************************************
49 ** $FreeBSD$
50 */
51 #define ARCMSR_DEBUG 0
52 /*
53 **********************************
54 */
55 #include <sys/param.h>
56 #include <sys/systm.h>
57 #include <sys/malloc.h>
58 #include <sys/kernel.h>
59 #include <sys/bus.h>
60 #include <sys/queue.h>
61 #include <sys/stat.h>
62 #include <sys/devicestat.h>
63 #include <sys/kthread.h>
64 #include <sys/module.h>
65 #include <sys/proc.h>
66 #include <sys/lock.h>
67 #include <sys/sysctl.h>
68 #include <sys/poll.h>
69 #include <sys/ioccom.h>
70 #include <vm/vm.h>
71 #include <vm/vm_param.h>
72 #include <vm/pmap.h>
73
74 #include <isa/rtc.h>
75
76 #include <machine/bus.h>
77 #include <machine/clock.h>
78 #include <machine/resource.h>
79 #include <machine/atomic.h>
80 #include <sys/conf.h>
81 #include <sys/rman.h>
82
83 #include <cam/cam.h>
84 #include <cam/cam_ccb.h>
85 #include <cam/cam_sim.h>
86 #include <cam/cam_xpt_sim.h>
87 #include <cam/cam_debug.h>
88 #include <cam/scsi/scsi_all.h>
89 #include <cam/scsi/scsi_message.h>
90 /*
91 **************************************************************************
92 ** Define the OS version specific locks
93 **************************************************************************
94 */
95 #if __FreeBSD_version >= 500005
96 #include <sys/selinfo.h>
97 #include <sys/mutex.h>
98 #include <dev/pci/pcivar.h>
99 #include <dev/pci/pcireg.h>
100 #define ARCMSR_LOCK_INIT(l, s) mtx_init(l, s,NULL, MTX_DEF|MTX_RECURSE)
101 #define ARCMSR_LOCK_ACQUIRE(l) mtx_lock(l)
102 #define ARCMSR_LOCK_RELEASE(l) mtx_unlock(l)
103 typedef struct mtx arcmsr_lock_t;
104 #else
105 #include <sys/select.h>
106 #include <pci/pcivar.h>
107 #include <pci/pcireg.h>
108 #define ARCMSR_LOCK_INIT(l, s) simple_lock_init(l)
109 #define ARCMSR_LOCK_ACQUIRE(l) simple_lock(l)
110 #define ARCMSR_LOCK_RELEASE(l) simple_unlock(l)
111 typedef struct simplelock arcmsr_lock_t;
112 #endif
113 #include <dev/arcmsr/arcmsr.h>
114 /*
115 **************************************************************************
116 ** __FreeBSD_version 502010
117 **************************************************************************
118 */
119 static struct _SRB * arcmsr_get_freesrb(struct _ACB * pACB);
120 static u_int8_t arcmsr_seek_cmd2abort(union ccb * pabortccb);
121 static u_int8_t arcmsr_wait_msgint_ready(struct _ACB * pACB);
122 static u_int32_t arcmsr_probe(device_t dev);
123 static u_int32_t arcmsr_attach(device_t dev);
124 static u_int32_t arcmsr_detach(device_t dev);
125 static u_int32_t arcmsr_iop_ioctlcmd(struct _ACB * pACB,u_int32_t ioctl_cmd,caddr_t arg);
126 static void arcmsr_iop_parking(struct _ACB *pACB);
127 static void arcmsr_shutdown(device_t dev);
128 static void arcmsr_interrupt(void *arg);
129 static void arcmsr_polling_srbdone(struct _ACB *pACB,struct _SRB *poll_srb);
130 static void arcmsr_free_resource(struct _ACB * pACB);
131 static void arcmsr_bus_reset(struct _ACB * pACB);
132 static void arcmsr_stop_adapter_bgrb(struct _ACB * pACB);
133 static void arcmsr_start_adapter_bgrb(struct _ACB * pACB);
134 static void arcmsr_iop_init(struct _ACB * pACB);
135 static void arcmsr_flush_adapter_cache(struct _ACB * pACB);
136 static void arcmsr_queue_wait2go_srb(struct _ACB * pACB,struct _SRB * pSRB);
137 static void arcmsr_post_wait2go_srb(struct _ACB * pACB);
138 static void arcmsr_post_Qbuffer(struct _ACB * pACB);
139 static void arcmsr_abort_allcmd(struct _ACB * pACB);
140 static void arcmsr_srb_complete(struct _SRB * pSRB);
141 static void arcmsr_iop_reset(struct _ACB * pACB);
142 static void arcmsr_report_sense_info(struct _SRB * pSRB);
143 static void arcmsr_build_srb(struct _SRB * pSRB, bus_dma_segment_t * dm_segs, u_int32_t nseg);
144 static int arcmsr_resume(device_t dev);
145 static int arcmsr_suspend(device_t dev);
146 /*
147 *****************************************************************************************
148 ** Character device switch table
149 **struct cdevsw {
150 ** d_open_t *d_open;
151 ** d_close_t *d_close;
152 ** d_read_t *d_read;
153 ** d_write_t *d_write;
154 ** d_ioctl_t *d_ioctl;
155 ** d_poll_t *d_poll;
156 ** d_mmap_t *d_mmap;
157 ** d_strategy_t *d_strategy;
158 ** const char *d_name; "" base device name, e.g. 'vn'
159 ** int d_maj;
160 ** d_dump_t *d_dump;
161 ** d_psize_t *d_psize;
162 ** u_int d_flags;
163 ** int d_bmaj;
164 ** d_kqfilter_t *d_kqfilter; "" additions below are not binary compatible with 4.2 and below
165 **};
166 ******************************************************************************************
167 */
168 /*
169 **************************************************************************
170 ** Insert a delay in micro-seconds and milli-seconds.
171 ** static void MDELAY(u_int32_t ms) { while (ms--) UDELAY(1000); }
172 **************************************************************************
173 */
174 static void UDELAY(u_int32_t us) { DELAY(us); }
175 /*
176 **************************************************************************
177 **
178 **************************************************************************
179 */
180 static bus_dmamap_callback_t arcmsr_map_freesrb;
181 static bus_dmamap_callback_t arcmsr_executesrb;
182 /*
183 **************************************************************************
184 **
185 **************************************************************************
186 */
187 static d_open_t arcmsr_open;
188 static d_close_t arcmsr_close;
189 static d_ioctl_t arcmsr_ioctl;
190
191 static device_method_t arcmsr_methods[]={
192 DEVMETHOD(device_probe, arcmsr_probe),
193 DEVMETHOD(device_attach, arcmsr_attach),
194 DEVMETHOD(device_detach, arcmsr_detach),
195 DEVMETHOD(device_shutdown, arcmsr_shutdown),
196 DEVMETHOD(device_suspend, arcmsr_suspend),
197 DEVMETHOD(device_resume, arcmsr_resume),
198
199 DEVMETHOD(bus_print_child, bus_generic_print_child),
200 DEVMETHOD(bus_driver_added, bus_generic_driver_added),
201 { 0,0 }
202 };
203
204 static driver_t arcmsr_driver={
205 "arcmsr",arcmsr_methods,sizeof(struct _ACB)
206 };
207
208 static devclass_t arcmsr_devclass;
209 DRIVER_MODULE(arcmsr,pci,arcmsr_driver,arcmsr_devclass,0,0);
210 #ifndef BUS_DMA_COHERENT
211 #define BUS_DMA_COHERENT 0x04 /* hint: map memory in a coherent way */
212 #endif
213 #if __FreeBSD_version >= 501000
214 #ifndef D_NEEDGIANT
215 #define D_NEEDGIANT 0x00400000 /* driver want Giant */
216 #endif
217 #ifndef D_VERSION
218 #define D_VERSION 0x20011966
219 #endif
220 static struct cdevsw arcmsr_cdevsw={
221 #if __FreeBSD_version > 502010
222 .d_version = D_VERSION,
223 #endif
224 .d_flags = D_NEEDGIANT,
225 .d_open = arcmsr_open, /* open */
226 .d_close = arcmsr_close, /* close */
227 .d_ioctl = arcmsr_ioctl, /* ioctl */
228 .d_name = "arcmsr", /* name */
229 };
230 #else
231 #define ARCMSR_CDEV_MAJOR 180
232
233 static struct cdevsw arcmsr_cdevsw = {
234 arcmsr_open, /* open */
235 arcmsr_close, /* close */
236 noread, /* read */
237 nowrite, /* write */
238 arcmsr_ioctl, /* ioctl */
239 nopoll, /* poll */
240 nommap, /* mmap */
241 nostrategy, /* strategy */
242 "arcmsr", /* name */
243 ARCMSR_CDEV_MAJOR, /* major */
244 nodump, /* dump */
245 nopsize, /* psize */
246 0 /* flags */
247 };
248 #endif
249
250 #if __FreeBSD_version < 500005
251 static int arcmsr_open(dev_t dev, int flags, int fmt, struct proc *proc)
252 #else
253 #if __FreeBSD_version < 503000
254 static int arcmsr_open(dev_t dev, int flags, int fmt, struct thread *proc)
255 #else
256 static int arcmsr_open(struct cdev *dev, int flags, int fmt, d_thread_t *proc)
257 #endif
258 #endif
259 {
260 #if __FreeBSD_version < 503000
261 struct _ACB * pACB=dev->si_drv1;
262 #else
263 int unit = minor(dev);
264 struct _ACB * pACB = devclass_get_softc(arcmsr_devclass, unit);
265 #endif
266
267 if(pACB==NULL)
268 {
269 return ENXIO;
270 }
271 return 0;
272 }
273 /*
274 **************************************************************************
275 **************************************************************************
276 */
277 #if __FreeBSD_version < 500005
278 static int arcmsr_close(dev_t dev, int flags, int fmt, struct proc *proc)
279 #else
280 #if __FreeBSD_version < 503000
281 static int arcmsr_close(dev_t dev, int flags, int fmt, struct thread *proc)
282 #else
283 static int arcmsr_close(struct cdev *dev, int flags, int fmt, d_thread_t *proc)
284 #endif
285 #endif
286 {
287 #if __FreeBSD_version < 503000
288 struct _ACB * pACB=dev->si_drv1;
289 #else
290 int unit = minor(dev);
291 struct _ACB * pACB = devclass_get_softc(arcmsr_devclass, unit);
292 #endif
293
294 if(pACB==NULL)
295 {
296 return ENXIO;
297 }
298 return 0;
299 }
300 /*
301 **************************************************************************
302 **ENOENT
303 **ENOIOCTL
304 **ENOMEM
305 **EINVAL
306 **************************************************************************
307 */
308 #if __FreeBSD_version < 500005
309 static int arcmsr_ioctl(dev_t dev, u_long ioctl_cmd, caddr_t arg, int flags, struct proc *proc)
310 #else
311 #if __FreeBSD_version < 503000
312 static int arcmsr_ioctl(dev_t dev, u_long ioctl_cmd, caddr_t arg, int flags, struct thread *proc)
313 #else
314 static int arcmsr_ioctl(struct cdev *dev, u_long ioctl_cmd, caddr_t arg,int flags, d_thread_t *proc)
315 #endif
316 #endif
317 {
318 #if __FreeBSD_version < 503000
319 struct _ACB * pACB=dev->si_drv1;
320 #else
321 int unit = minor(dev);
322 struct _ACB * pACB = devclass_get_softc(arcmsr_devclass, unit);
323 #endif
324
325 if(pACB==NULL)
326 {
327 return ENXIO;
328 }
329 return(arcmsr_iop_ioctlcmd(pACB,ioctl_cmd,arg));
330 }
331 /*
332 *******************************************************************************
333 ** Bring the controller to a quiescent state, ready for system suspend.
334 *******************************************************************************
335 */
336 static int arcmsr_suspend(device_t dev)
337 {
338 struct _ACB *pACB = device_get_softc(dev);
339 u_int32_t intmask_org;
340 int s;
341
342 s = splbio();
343 /* disable all outbound interrupt */
344 intmask_org=readl(&pACB->pmu->outbound_intmask);
345 writel(&pACB->pmu->outbound_intmask,(intmask_org|ARCMSR_MU_OUTBOUND_ALL_INTMASKENABLE));
346 /* flush controller */
347 printf("arcmsr%d: flushing cache...\n",pACB->pci_unit);
348 arcmsr_iop_parking(pACB);
349 splx(s);
350 return(0);
351 }
352 /*
353 *******************************************************************************
354 ** Bring the controller back to a state ready for operation.
355 *******************************************************************************
356 */
357 static int arcmsr_resume(device_t dev)
358 {
359 struct _ACB *pACB = device_get_softc(dev);
360
361 arcmsr_iop_init(pACB);
362 return(0);
363 }
364 /*
365 *********************************************************************************
366 ** Asynchronous notification handler.
367 *********************************************************************************
368 */
369 static void arcmsr_async(void *cb_arg, u_int32_t code, struct cam_path *path, void *arg)
370 {
371 struct _ACB * pACB;
372 u_int8_t target_id,target_lun;
373 struct cam_sim * sim;
374 u_int32_t s;
375
376 s=splcam();
377 sim=(struct cam_sim *) cb_arg;
378 pACB =(struct _ACB *) cam_sim_softc(sim);
379 switch (code)
380 {
381 case AC_LOST_DEVICE:
382 target_id=xpt_path_target_id(path);
383 target_lun=xpt_path_lun_id(path);
384 if((target_id > ARCMSR_MAX_TARGETID) || (target_lun > ARCMSR_MAX_TARGETLUN))
385 {
386 break;
387 }
388 printf("%s:scsi id%d lun%d device lost \n",device_get_name(pACB->pci_dev),target_id,target_lun);
389 break;
390 default:
391 break;
392 }
393 splx(s);
394 }
395 /*
396 ************************************************************************
397 **
398 **
399 ************************************************************************
400 */
401 static void arcmsr_flush_adapter_cache(struct _ACB * pACB)
402 {
403 writel(&pACB->pmu->inbound_msgaddr0,ARCMSR_INBOUND_MESG0_FLUSH_CACHE);
404 return;
405 }
406 /*
407 **********************************************************************
408 **
409 **
410 **
411 **********************************************************************
412 */
413 static u_int8_t arcmsr_wait_msgint_ready(struct _ACB * pACB)
414 {
415 u_int32_t Index;
416 u_int8_t Retries=0x00;
417 do
418 {
419 for(Index=0; Index < 100; Index++)
420 {
421 if(readl(&pACB->pmu->outbound_intstatus) & ARCMSR_MU_OUTBOUND_MESSAGE0_INT)
422 {
423 writel(&pACB->pmu->outbound_intstatus, ARCMSR_MU_OUTBOUND_MESSAGE0_INT);/*clear interrupt*/
424 return 0x00;
425 }
426 /* one us delay */
427 UDELAY(10000);
428 }/*max 1 seconds*/
429 }while(Retries++ < 20);/*max 20 sec*/
430 return 0xff;
431 }
432 /*
433 **********************************************************************
434 **
435 ** Q back this SRB into ACB ArraySRB
436 **
437 **********************************************************************
438 */
439 static void arcmsr_srb_complete(struct _SRB * pSRB)
440 {
441 u_int32_t s;
442 struct _ACB * pACB=pSRB->pACB;
443 union ccb * pccb=pSRB->pccb;
444
445 if((pccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE)
446 {
447 bus_dmasync_op_t op;
448
449 if((pccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN)
450 {
451 op = BUS_DMASYNC_POSTREAD;
452 }
453 else
454 {
455 op = BUS_DMASYNC_POSTWRITE;
456 }
457 bus_dmamap_sync(pACB->buffer_dmat, pSRB->dmamap, op);
458 bus_dmamap_unload(pACB->buffer_dmat, pSRB->dmamap);
459 }
460 s=splcam();
461 atomic_subtract_int(&pACB->srboutstandingcount,1);
462 pSRB->startdone=ARCMSR_SRB_DONE;
463 pSRB->srb_flags=0;
464 pACB->psrbringQ[pACB->srb_doneindex]=pSRB;
465 pACB->srb_doneindex++;
466 pACB->srb_doneindex %= ARCMSR_MAX_FREESRB_NUM;
467 splx(s);
468 xpt_done(pccb);
469 return;
470 }
471 /*
472 **********************************************************************
473 ** if scsi error do auto request sense
474 **********************************************************************
475 */
476 static void arcmsr_report_sense_info(struct _SRB * pSRB)
477 {
478 union ccb * pccb=pSRB->pccb;
479 PSENSE_DATA psenseBuffer=(PSENSE_DATA)&pccb->csio.sense_data;
480
481 pccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR;
482 pccb->csio.scsi_status = SCSI_STATUS_CHECK_COND;
483 if(psenseBuffer)
484 {
485 memset(psenseBuffer, 0, sizeof(pccb->csio.sense_data));
486 memcpy(psenseBuffer,pSRB->arcmsr_cdb.SenseData,get_min(sizeof(struct _SENSE_DATA),sizeof(pccb->csio.sense_data)));
487 psenseBuffer->ErrorCode=0x70;
488 psenseBuffer->Valid=1;
489 pccb->ccb_h.status |= CAM_AUTOSNS_VALID;
490 }
491 return;
492 }
493 /*
494 *********************************************************************
495 ** to insert pSRB into tail of pACB wait exec srbQ
496 *********************************************************************
497 */
498 static void arcmsr_queue_wait2go_srb(struct _ACB * pACB,struct _SRB * pSRB)
499 {
500 u_int32_t s;
501 u_int32_t i=0;
502
503 s=splcam();
504 while(1)
505 {
506 if(pACB->psrbwait2go[i]==NULL)
507 {
508 pACB->psrbwait2go[i]=pSRB;
509 atomic_add_int(&pACB->srbwait2gocount,1);
510 splx(s);
511 return;
512 }
513 i++;
514 i%=ARCMSR_MAX_OUTSTANDING_CMD;
515 }
516 return;
517 }
518 /*
519 *********************************************************************
520 **
521 *********************************************************************
522 */
523 static void arcmsr_abort_allcmd(struct _ACB * pACB)
524 {
525 writel(&pACB->pmu->inbound_msgaddr0,ARCMSR_INBOUND_MESG0_ABORT_CMD);
526 return;
527 }
528
529 /*
530 ****************************************************************************
531 ** Routine Description: Reset 80331 iop.
532 ** Arguments:
533 ** Return Value: Nothing.
534 ****************************************************************************
535 */
536 static void arcmsr_iop_reset(struct _ACB * pACB)
537 {
538 struct _SRB * pSRB;
539 u_int32_t intmask_org,mask;
540 u_int32_t i=0;
541
542 if(pACB->srboutstandingcount!=0)
543 {
544 printf("arcmsr%d: iop reset srboutstandingcount=%d \n",pACB->pci_unit,pACB->srboutstandingcount);
545 /* disable all outbound interrupt */
546 intmask_org=readl(&pACB->pmu->outbound_intmask);
547 writel(&pACB->pmu->outbound_intmask,intmask_org|ARCMSR_MU_OUTBOUND_ALL_INTMASKENABLE);
548 /* talk to iop 331 outstanding command aborted*/
549 arcmsr_abort_allcmd(pACB);
550 if(arcmsr_wait_msgint_ready(pACB))
551 {
552 printf("arcmsr%d: iop reset wait 'abort all outstanding command' timeout \n",pACB->pci_unit);
553 }
554 /*clear all outbound posted Q*/
555 for(i=0;i<ARCMSR_MAX_OUTSTANDING_CMD;i++)
556 {
557 readl(&pACB->pmu->outbound_queueport);
558 }
559 for(i=0;i<ARCMSR_MAX_FREESRB_NUM;i++)
560 {
561 pSRB=pACB->psrb_pool[i];
562 if(pSRB->startdone==ARCMSR_SRB_START)
563 {
564 pSRB->startdone=ARCMSR_SRB_ABORTED;
565 pSRB->pccb->ccb_h.status=CAM_REQ_ABORTED;
566 arcmsr_srb_complete(pSRB);
567 }
568 }
569 /* enable all outbound interrupt */
570 mask=~(ARCMSR_MU_OUTBOUND_POSTQUEUE_INTMASKENABLE|ARCMSR_MU_OUTBOUND_DOORBELL_INTMASKENABLE|ARCMSR_MU_OUTBOUND_MESSAGE0_INTMASKENABLE);
571 writel(&pACB->pmu->outbound_intmask,intmask_org & mask);
572 /* post abort all outstanding command message to RAID controller */
573 }
574 i=0;
575 while(pACB->srbwait2gocount > 0)
576 {
577 pSRB=pACB->psrbwait2go[i];
578 if(pSRB!=NULL)
579 {
580 printf("arcmsr%d:iop reset abort command srbwait2gocount=%d \n",pACB->pci_unit,pACB->srbwait2gocount);
581 pACB->psrbwait2go[i]=NULL;
582 pSRB->startdone=ARCMSR_SRB_ABORTED;
583 pSRB->pccb->ccb_h.status=CAM_REQ_ABORTED;
584 arcmsr_srb_complete(pSRB);
585 atomic_subtract_int(&pACB->srbwait2gocount,1);
586 }
587 i++;
588 i%=ARCMSR_MAX_OUTSTANDING_CMD;
589 }
590 atomic_set_int(&pACB->srboutstandingcount,0);
591 return;
592 }
593 /*
594 **********************************************************************
595 **
596 ** PAGE_SIZE=4096 or 8192,PAGE_SHIFT=12
597 **********************************************************************
598 */
599 static void arcmsr_build_srb(struct _SRB * pSRB, bus_dma_segment_t *dm_segs, u_int32_t nseg)
600 {
601 struct _ARCMSR_CDB * pARCMSR_CDB=&pSRB->arcmsr_cdb;
602 u_int8_t * psge=(u_int8_t *)&pARCMSR_CDB->u;
603 u_int32_t address_lo,address_hi;
604 union ccb * pccb=pSRB->pccb;
605 struct ccb_scsiio * pcsio=&pccb->csio;
606 u_int32_t arccdbsize=0x30;
607
608 memset(pARCMSR_CDB,0,sizeof(struct _ARCMSR_CDB));
609 pARCMSR_CDB->Bus=0;
610 pARCMSR_CDB->TargetID=pccb->ccb_h.target_id;
611 pARCMSR_CDB->LUN=pccb->ccb_h.target_lun;
612 pARCMSR_CDB->Function=1;
613 pARCMSR_CDB->CdbLength=(u_int8_t)pcsio->cdb_len;
614 pARCMSR_CDB->Context=(unsigned long)pARCMSR_CDB;
615 bcopy(pcsio->cdb_io.cdb_bytes, pARCMSR_CDB->Cdb, pcsio->cdb_len);
616 if(nseg != 0)
617 {
618 struct _ACB * pACB=pSRB->pACB;
619 bus_dmasync_op_t op;
620 u_int32_t length,i,cdb_sgcount=0;
621
622 /* map stor port SG list to our iop SG List.*/
623 for(i=0;i<nseg;i++)
624 {
625 /* Get the physical address of the current data pointer */
626 length=(u_int32_t) dm_segs[i].ds_len;
627 address_lo=dma_addr_lo32(dm_segs[i].ds_addr);
628 address_hi=dma_addr_hi32(dm_segs[i].ds_addr);
629 if(address_hi==0)
630 {
631 struct _SG32ENTRY * pdma_sg=(struct _SG32ENTRY *)psge;
632 pdma_sg->address=address_lo;
633 pdma_sg->length=length;
634 psge += sizeof(struct _SG32ENTRY);
635 arccdbsize += sizeof(struct _SG32ENTRY);
636 }
637 else
638 {
639 u_int32_t sg64s_size=0,tmplength=length;
640
641 #if ARCMSR_DEBUG
642 printf("arcmsr%d: !!!!!!!!!!! address_hi=%x \n",pACB->pci_unit,address_hi);
643 #endif
644 while(1)
645 {
646 u_int64_t span4G,length0;
647 struct _SG64ENTRY * pdma_sg=(struct _SG64ENTRY *)psge;
648
649 span4G=(u_int64_t)address_lo + tmplength;
650 pdma_sg->addresshigh=address_hi;
651 pdma_sg->address=address_lo;
652 if(span4G > 0x100000000)
653 {
654 /*see if cross 4G boundary*/
655 length0=0x100000000-address_lo;
656 pdma_sg->length=(u_int32_t)length0|IS_SG64_ADDR;
657 address_hi=address_hi+1;
658 address_lo=0;
659 tmplength=tmplength-(u_int32_t)length0;
660 sg64s_size += sizeof(struct _SG64ENTRY);
661 psge += sizeof(struct _SG64ENTRY);
662 cdb_sgcount++;
663 }
664 else
665 {
666 pdma_sg->length=tmplength|IS_SG64_ADDR;
667 sg64s_size += sizeof(struct _SG64ENTRY);
668 psge += sizeof(struct _SG64ENTRY);
669 break;
670 }
671 }
672 arccdbsize += sg64s_size;
673 }
674 cdb_sgcount++;
675 }
676 pARCMSR_CDB->sgcount=(u_int8_t)cdb_sgcount;
677 pARCMSR_CDB->DataLength=pcsio->dxfer_len;
678 if( arccdbsize > 256)
679 {
680 pARCMSR_CDB->Flags|=ARCMSR_CDB_FLAG_SGL_BSIZE;
681 }
682 if((pccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN)
683 {
684 op=BUS_DMASYNC_PREREAD;
685 }
686 else
687 {
688 op=BUS_DMASYNC_PREWRITE;
689 pARCMSR_CDB->Flags|=ARCMSR_CDB_FLAG_WRITE;
690 pSRB->srb_flags|=SRB_FLAG_WRITE;
691 }
692 bus_dmamap_sync(pACB->buffer_dmat, pSRB->dmamap, op);
693 }
694 return;
695 }
696 /*
697 **************************************************************************
698 **
699 ** arcmsr_post_srb - Send a protocol specific ARC send postcard to a AIOC .
700 ** handle: Handle of registered ARC protocol driver
701 ** adapter_id: AIOC unique identifier(integer)
702 ** pPOSTCARD_SEND: Pointer to ARC send postcard
703 **
704 ** This routine posts a ARC send postcard to the request post FIFO of a
705 ** specific ARC adapter.
706 **
707 **************************************************************************
708 */
709 static void arcmsr_post_srb(struct _ACB * pACB,struct _SRB * pSRB)
710 {
711 u_int32_t cdb_shifted_phyaddr=(u_int32_t) pSRB->cdb_shifted_phyaddr;
712 struct _ARCMSR_CDB * pARCMSR_CDB=(struct _ARCMSR_CDB *)&pSRB->arcmsr_cdb;
713
714 atomic_add_int(&pACB->srboutstandingcount,1);
715 pSRB->startdone=ARCMSR_SRB_START;
716 if(pARCMSR_CDB->Flags & ARCMSR_CDB_FLAG_SGL_BSIZE)
717 {
718 writel(&pACB->pmu->inbound_queueport,cdb_shifted_phyaddr|ARCMSR_SRBPOST_FLAG_SGL_BSIZE);
719 }
720 else
721 {
722 writel(&pACB->pmu->inbound_queueport,cdb_shifted_phyaddr);
723 }
724 return;
725 }
726 /*
727 **************************************************************************
728 **
729 **
730 **************************************************************************
731 */
732 static void arcmsr_post_wait2go_srb(struct _ACB * pACB)
733 {
734 u_int32_t s;
735 struct _SRB * pSRB;
736 u_int32_t i=0;
737
738 s=splcam();
739 while((pACB->srbwait2gocount > 0) && (pACB->srboutstandingcount < ARCMSR_MAX_OUTSTANDING_CMD))
740 {
741 pSRB=pACB->psrbwait2go[i];
742 if(pSRB!=NULL)
743 {
744 pACB->psrbwait2go[i]=NULL;
745 arcmsr_post_srb(pACB,pSRB);
746 atomic_subtract_int(&pACB->srbwait2gocount,1);
747 }
748 i++;
749 i%=ARCMSR_MAX_OUTSTANDING_CMD;
750 }
751 splx(s);
752 return;
753 }
754 /*
755 **********************************************************************
756 ** Function: arcmsr_post_Qbuffer
757 ** Output:
758 **********************************************************************
759 */
760 static void arcmsr_post_Qbuffer(struct _ACB * pACB)
761 {
762 u_int32_t s;
763 u_int8_t * pQbuffer;
764 struct _QBUFFER * pwbuffer=(struct _QBUFFER *)&pACB->pmu->ioctl_wbuffer;
765 u_int8_t * iop_data=(u_int8_t *)pwbuffer->data;
766 u_int32_t allxfer_len=0;
767
768 s=splcam();
769 while((pACB->wqbuf_firstindex!=pACB->wqbuf_lastindex) && (allxfer_len<124))
770 {
771 pQbuffer=&pACB->wqbuffer[pACB->wqbuf_firstindex];
772 memcpy(iop_data,pQbuffer,1);
773 pACB->wqbuf_firstindex++;
774 pACB->wqbuf_firstindex %= ARCMSR_MAX_QBUFFER; /*if last index number set it to 0 */
775 iop_data++;
776 allxfer_len++;
777 }
778 pwbuffer->data_len=allxfer_len;
779 /*
780 ** push inbound doorbell and wait reply at hwinterrupt routine for next Qbuffer post
781 */
782 writel(&pACB->pmu->inbound_doorbell,ARCMSR_INBOUND_DRIVER_DATA_WRITE_OK);
783 splx(s);
784 return;
785 }
786 /*
787 ************************************************************************
788 ************************************************************************
789 */
790 static void arcmsr_stop_adapter_bgrb(struct _ACB * pACB)
791 {
792 pACB->acb_flags |= ACB_F_MSG_STOP_BGRB;
793 pACB->acb_flags &= ~ACB_F_MSG_START_BGRB;
794 writel(&pACB->pmu->inbound_msgaddr0,ARCMSR_INBOUND_MESG0_STOP_BGRB);
795 return;
796 }
797 /*
798 ************************************************************************
799 ************************************************************************
800 */
801 static void arcmsr_poll(struct cam_sim * psim)
802 {
803 arcmsr_interrupt(cam_sim_softc(psim));
804 return;
805 }
806 /*
807 **********************************************************************
808 ** Function: arcmsr_interrupt
809 ** Output: void
810 ** CAM Status field values
811 **typedef enum {
812 ** CAM_REQ_INPROG, CCB request is in progress
813 ** CAM_REQ_CMP, CCB request completed without error
814 ** CAM_REQ_ABORTED, CCB request aborted by the host
815 ** CAM_UA_ABORT, Unable to abort CCB request
816 ** CAM_REQ_CMP_ERR, CCB request completed with an error
817 ** CAM_BUSY, CAM subsytem is busy
818 ** CAM_REQ_INVALID, CCB request was invalid
819 ** CAM_PATH_INVALID, Supplied Path ID is invalid
820 ** CAM_DEV_NOT_THERE, SCSI Device Not Installed/there
821 ** CAM_UA_TERMIO, Unable to terminate I/O CCB request
822 ** CAM_SEL_TIMEOUT, Target Selection Timeout
823 ** CAM_CMD_TIMEOUT, Command timeout
824 ** CAM_SCSI_STATUS_ERROR, SCSI error, look at error code in CCB
825 ** CAM_MSG_REJECT_REC, Message Reject Received
826 ** CAM_SCSI_BUS_RESET, SCSI Bus Reset Sent/Received
827 ** CAM_UNCOR_PARITY, Uncorrectable parity error occurred
828 ** CAM_AUTOSENSE_FAIL=0x10, Autosense: request sense cmd fail
829 ** CAM_NO_HBA, No HBA Detected error
830 ** CAM_DATA_RUN_ERR, Data Overrun error
831 ** CAM_UNEXP_BUSFREE, Unexpected Bus Free
832 ** CAM_SEQUENCE_FAIL, Target Bus Phase Sequence Failure
833 ** CAM_CCB_LEN_ERR, CCB length supplied is inadequate
834 ** CAM_PROVIDE_FAIL, Unable to provide requested capability
835 ** CAM_BDR_SENT, A SCSI BDR msg was sent to target
836 ** CAM_REQ_TERMIO, CCB request terminated by the host
837 ** CAM_UNREC_HBA_ERROR, Unrecoverable Host Bus Adapter Error
838 ** CAM_REQ_TOO_BIG, The request was too large for this host
839 ** CAM_REQUEUE_REQ,
840 ** * This request should be requeued to preserve
841 ** * transaction ordering. This typically occurs
842 ** * when the SIM recognizes an error that should
843 ** * freeze the queue and must place additional
844 ** * requests for the target at the sim level
845 ** * back into the XPT queue.
846 **
847 ** CAM_IDE=0x33, Initiator Detected Error
848 ** CAM_RESRC_UNAVAIL, Resource Unavailable
849 ** CAM_UNACKED_EVENT, Unacknowledged Event by Host
850 ** CAM_MESSAGE_RECV, Message Received in Host Target Mode
851 ** CAM_INVALID_CDB, Invalid CDB received in Host Target Mode
852 ** CAM_LUN_INVALID, Lun supplied is invalid
853 ** CAM_TID_INVALID, Target ID supplied is invalid
854 ** CAM_FUNC_NOTAVAIL, The requested function is not available
855 ** CAM_NO_NEXUS, Nexus is not established
856 ** CAM_IID_INVALID, The initiator ID is invalid
857 ** CAM_CDB_RECVD, The SCSI CDB has been received
858 ** CAM_LUN_ALRDY_ENA, The LUN is already eanbeld for target mode
859 ** CAM_SCSI_BUSY, SCSI Bus Busy
860 **
861 ** CAM_DEV_QFRZN=0x40, The DEV queue is frozen w/this err
862 **
863 ** Autosense data valid for target
864 ** CAM_AUTOSNS_VALID=0x80,
865 ** CAM_RELEASE_SIMQ=0x100, SIM ready to take more commands
866 ** CAM_SIM_QUEUED =0x200, SIM has this command in it's queue
867 **
868 ** CAM_STATUS_MASK=0x3F, Mask bits for just the status #
869 **
870 ** Target Specific Adjunct Status
871 ** CAM_SENT_SENSE=0x40000000 sent sense with status
872 **} cam_status;
873 **********************************************************************
874 */
875 static void arcmsr_interrupt(void *arg)
876 {
877 struct _ACB * pACB=(struct _ACB *)arg;
878 struct _SRB * pSRB;
879 u_int32_t flag_srb,outbound_intstatus,outbound_doorbell;
880
881 /*
882 *********************************************
883 ** check outbound intstatus À˹µL¶l®t«öªù¹a
884 *********************************************
885 */
886 outbound_intstatus=readl(&pACB->pmu->outbound_intstatus) & pACB->outbound_int_enable;
887 writel(&pACB->pmu->outbound_intstatus, outbound_intstatus);/*clear interrupt*/
888 if(outbound_intstatus & ARCMSR_MU_OUTBOUND_DOORBELL_INT)
889 {
890 /*
891 *********************************************
892 ** DOORBELL ¥m¾´! ¬O§_¦³¶l¥ónñ¦¬
893 *********************************************
894 */
895 outbound_doorbell=readl(&pACB->pmu->outbound_doorbell);
896 writel(&pACB->pmu->outbound_doorbell,outbound_doorbell);/*clear interrupt */
897 if(outbound_doorbell & ARCMSR_OUTBOUND_IOP331_DATA_WRITE_OK)
898 {
899 struct _QBUFFER * prbuffer=(struct _QBUFFER *)&pACB->pmu->ioctl_rbuffer;
900 u_int8_t * iop_data=(u_int8_t *)prbuffer->data;
901 u_int8_t * pQbuffer;
902 u_int32_t my_empty_len,iop_len,rqbuf_firstindex,rqbuf_lastindex;
903
904 /*check this iop data if overflow my rqbuffer*/
905 rqbuf_lastindex=pACB->rqbuf_lastindex;
906 rqbuf_firstindex=pACB->rqbuf_firstindex;
907 iop_len=prbuffer->data_len;
908 my_empty_len=(rqbuf_firstindex-rqbuf_lastindex-1)&(ARCMSR_MAX_QBUFFER-1);
909 if(my_empty_len>=iop_len)
910 {
911 while(iop_len > 0)
912 {
913 pQbuffer=&pACB->rqbuffer[pACB->rqbuf_lastindex];
914 memcpy(pQbuffer,iop_data,1);
915 pACB->rqbuf_lastindex++;
916 pACB->rqbuf_lastindex %= ARCMSR_MAX_QBUFFER;/*if last index number set it to 0 */
917 iop_data++;
918 iop_len--;
919 }
920 writel(&pACB->pmu->inbound_doorbell, ARCMSR_INBOUND_DRIVER_DATA_READ_OK);/*signature, let IOP331 know data has been readed */
921 }
922 else
923 {
924 pACB->acb_flags|=ACB_F_IOPDATA_OVERFLOW;
925 }
926 }
927 if(outbound_doorbell & ARCMSR_OUTBOUND_IOP331_DATA_READ_OK)
928 {
929 /*
930 *********************************************
931 ** ¬Ý¬Ý¬O§_ÁÙ¦³¶l¥ón¶¶¹D±H¥X
932 *********************************************
933 */
934 if(pACB->wqbuf_firstindex!=pACB->wqbuf_lastindex)
935 {
936 u_int8_t * pQbuffer;
937 struct _QBUFFER * pwbuffer=(struct _QBUFFER *)&pACB->pmu->ioctl_wbuffer;
938 u_int8_t * iop_data=(u_int8_t *)pwbuffer->data;
939 u_int32_t allxfer_len=0;
940
941 while((pACB->wqbuf_firstindex!=pACB->wqbuf_lastindex) && (allxfer_len<124))
942 {
943 pQbuffer=&pACB->wqbuffer[pACB->wqbuf_firstindex];
944 memcpy(iop_data,pQbuffer,1);
945 pACB->wqbuf_firstindex++;
946 pACB->wqbuf_firstindex %= ARCMSR_MAX_QBUFFER; /*if last index number set it to 0 */
947 iop_data++;
948 allxfer_len++;
949 }
950 pwbuffer->data_len=allxfer_len;
951 /*
952 ** push inbound doorbell tell iop driver data write ok and wait reply on next hwinterrupt for next Qbuffer post
953 */
954 writel(&pACB->pmu->inbound_doorbell,ARCMSR_INBOUND_DRIVER_DATA_WRITE_OK);
955 }
956 else
957 {
958 pACB->acb_flags |= ACB_F_IOCTL_WQBUFFER_CLEARED;
959 }
960 }
961 }
962 if(outbound_intstatus & ARCMSR_MU_OUTBOUND_POSTQUEUE_INT)
963 {
964 int target,lun;
965 /*
966 *****************************************************************************
967 ** areca cdb command done
968 *****************************************************************************
969 */
970 while(1)
971 {
972 if((flag_srb=readl(&pACB->pmu->outbound_queueport)) == 0xFFFFFFFF)
973 {
974 break;/*chip FIFO no srb for completion already*/
975 }
976 /* check if command done with no error*/
977 pSRB=(struct _SRB *)(pACB->vir2phy_offset+(flag_srb << 5));/*frame must be 32 bytes aligned*/
978 if((pSRB->pACB!=pACB) || (pSRB->startdone!=ARCMSR_SRB_START))
979 {
980 if(pSRB->startdone==ARCMSR_SRB_ABORTED)
981 {
982 printf("arcmsr%d: scsi id=%d lun=%d srb='%p' isr command abort successfully \n",pACB->pci_unit,pSRB->pccb->ccb_h.target_id,pSRB->pccb->ccb_h.target_lun,pSRB);
983 pSRB->pccb->ccb_h.status=CAM_REQ_ABORTED;
984 arcmsr_srb_complete(pSRB);
985 continue;
986 }
987 printf("arcmsr%d: isr get an illegal srb command done acb='%p' srb='%p' srbacb='%p' startdone=0x%x srboutstandingcount=%d \n",pACB->pci_unit,pACB,pSRB,pSRB->pACB,pSRB->startdone,pACB->srboutstandingcount);
988 continue;
989 }
990 target=pSRB->pccb->ccb_h.target_id;
991 lun=pSRB->pccb->ccb_h.target_lun;
992 if((flag_srb & ARCMSR_SRBREPLY_FLAG_ERROR)==0)
993 {
994 if(pACB->devstate[target][lun]==ARECA_RAID_GONE)
995 {
996 pACB->devstate[target][lun]=ARECA_RAID_GOOD;
997 }
998 pSRB->pccb->ccb_h.status=CAM_REQ_CMP;
999 arcmsr_srb_complete(pSRB);
1000 }
1001 else
1002 {
1003 switch(pSRB->arcmsr_cdb.DeviceStatus)
1004 {
1005 case ARCMSR_DEV_SELECT_TIMEOUT:
1006 {
1007 pACB->devstate[target][lun]=ARECA_RAID_GONE;
1008 pSRB->pccb->ccb_h.status=CAM_SEL_TIMEOUT;
1009 arcmsr_srb_complete(pSRB);
1010 }
1011 break;
1012 case ARCMSR_DEV_ABORTED:
1013 case ARCMSR_DEV_INIT_FAIL:
1014 {
1015 pACB->devstate[target][lun]=ARECA_RAID_GONE;
1016 pSRB->pccb->ccb_h.status=CAM_DEV_NOT_THERE;
1017 arcmsr_srb_complete(pSRB);
1018 }
1019 break;
1020 case SCSISTAT_CHECK_CONDITION:
1021 {
1022 pACB->devstate[target][lun]=ARECA_RAID_GOOD;
1023 arcmsr_report_sense_info(pSRB);
1024 arcmsr_srb_complete(pSRB);
1025 }
1026 break;
1027 default:
1028 /* error occur Q all error srb to errorsrbpending Q*/
1029 printf("arcmsr%d: scsi id=%d lun=%d isr get command error done, but got unknow DeviceStatus=0x%x \n",pACB->pci_unit,target,lun,pSRB->arcmsr_cdb.DeviceStatus);
1030 pACB->devstate[target][lun]=ARECA_RAID_GONE;
1031 pSRB->pccb->ccb_h.status=CAM_UNCOR_PARITY;/*unknow error or crc error just for retry*/
1032 arcmsr_srb_complete(pSRB);
1033 break;
1034 }
1035 }
1036 } /*drain reply FIFO*/
1037 }
1038 if(pACB->srbwait2gocount != 0)
1039 {
1040 arcmsr_post_wait2go_srb(pACB);/*try to post all pending srb*/
1041 }
1042 return;
1043 }
1044 /*
1045 *******************************************************************************
1046 *******************************************************************************
1047 */
1048 static void arcmsr_iop_parking(struct _ACB *pACB)
1049 {
1050 if(pACB!=NULL)
1051 {
1052 /* stop adapter background rebuild */
1053 if(pACB->acb_flags & ACB_F_MSG_START_BGRB)
1054 {
1055 pACB->acb_flags &= ~ACB_F_MSG_START_BGRB;
1056 arcmsr_stop_adapter_bgrb(pACB);
1057 if(arcmsr_wait_msgint_ready(pACB))
1058 {
1059 printf("arcmsr%d:iop parking wait 'stop adapter rebulid' timeout \n",pACB->pci_unit);
1060 }
1061 arcmsr_flush_adapter_cache(pACB);
1062 if(arcmsr_wait_msgint_ready(pACB))
1063 {
1064 printf("arcmsr%d:iop parking wait 'flush adapter cache' timeout \n",pACB->pci_unit);
1065 }
1066 }
1067 }
1068 }
1069 /*
1070 ***********************************************************************
1071 **
1072 **int copyin __P((const void *udaddr, void *kaddr, size_t len));
1073 **int copyout __P((const void *kaddr, void *udaddr, size_t len));
1074 **
1075 **ENOENT "" No such file or directory ""
1076 **ENOIOCTL "" ioctl not handled by this layer ""
1077 **ENOMEM "" Cannot allocate memory ""
1078 **EINVAL "" Invalid argument ""
1079 ************************************************************************
1080 */
1081 u_int32_t arcmsr_iop_ioctlcmd(struct _ACB * pACB,u_int32_t ioctl_cmd,caddr_t arg)
1082 {
1083 struct _CMD_IO_CONTROL * pccbioctl=(struct _CMD_IO_CONTROL *) arg;
1084
1085 if(memcmp(pccbioctl->Signature,"ARCMSR",6)!=0)
1086 {
1087 return EINVAL;
1088 }
1089 switch(ioctl_cmd)
1090 {
1091 case ARCMSR_IOCTL_READ_RQBUFFER:
1092 {
1093 u_int32_t s;
1094 struct _CMD_IOCTL_FIELD * pccbioctlfld=(struct _CMD_IOCTL_FIELD *)arg;
1095 u_int8_t * pQbuffer;
1096 u_int8_t * ptmpQbuffer=pccbioctlfld->ioctldatabuffer;
1097 u_int32_t allxfer_len=0;
1098
1099 s=splcam();
1100 while((pACB->rqbuf_firstindex!=pACB->rqbuf_lastindex) && (allxfer_len<1031))
1101 {
1102 /*copy READ QBUFFER to srb*/
1103 pQbuffer=&pACB->rqbuffer[pACB->rqbuf_firstindex];
1104 memcpy(ptmpQbuffer,pQbuffer,1);
1105 pACB->rqbuf_firstindex++;
1106 pACB->rqbuf_firstindex %= ARCMSR_MAX_QBUFFER; /*if last index number set it to 0 */
1107 ptmpQbuffer++;
1108 allxfer_len++;
1109 }
1110 if(pACB->acb_flags & ACB_F_IOPDATA_OVERFLOW)
1111 {
1112 struct _QBUFFER * prbuffer=(struct _QBUFFER *)&pACB->pmu->ioctl_rbuffer;
1113 u_int8_t * pQbuffer;
1114 u_int8_t * iop_data=(u_int8_t *)prbuffer->data;
1115 u_int32_t iop_len;
1116
1117 pACB->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
1118 iop_len=(u_int32_t)prbuffer->data_len;
1119 /*this iop data does no chance to make me overflow again here, so just do it*/
1120 while(iop_len>0)
1121 {
1122 pQbuffer=&pACB->rqbuffer[pACB->rqbuf_lastindex];
1123 memcpy(pQbuffer,iop_data,1);
1124 pACB->rqbuf_lastindex++;
1125 pACB->rqbuf_lastindex %= ARCMSR_MAX_QBUFFER;/*if last index number set it to 0 */
1126 iop_data++;
1127 iop_len--;
1128 }
1129 writel(&pACB->pmu->inbound_doorbell, ARCMSR_INBOUND_DRIVER_DATA_READ_OK);/*signature, let IOP331 know data has been readed */
1130 }
1131 pccbioctl->Length=allxfer_len;
1132 pccbioctl->ReturnCode=ARCMSR_IOCTL_RETURNCODE_OK;
1133 splx(s);
1134 return ARC_IOCTL_SUCCESS;
1135 }
1136 break;
1137 case ARCMSR_IOCTL_WRITE_WQBUFFER:
1138 {
1139 u_int32_t s;
1140 struct _CMD_IOCTL_FIELD * pccbioctlfld=(struct _CMD_IOCTL_FIELD *)arg;
1141 u_int32_t my_empty_len,user_len,wqbuf_firstindex,wqbuf_lastindex;
1142 u_int8_t * pQbuffer;
1143 u_int8_t * ptmpuserbuffer=pccbioctlfld->ioctldatabuffer;
1144
1145 s=splcam();
1146 user_len=pccbioctl->Length;
1147
1148 /*check if data xfer length of this request will overflow my array qbuffer */
1149 wqbuf_lastindex=pACB->wqbuf_lastindex;
1150 wqbuf_firstindex=pACB->wqbuf_firstindex;
1151 my_empty_len=(wqbuf_firstindex-wqbuf_lastindex-1)&(ARCMSR_MAX_QBUFFER-1);
1152 if(my_empty_len>=user_len)
1153 {
1154 while(user_len>0)
1155 {
1156 /*copy srb data to wqbuffer*/
1157 pQbuffer=&pACB->wqbuffer[pACB->wqbuf_lastindex];
1158 memcpy(pQbuffer,ptmpuserbuffer,1);
1159 pACB->wqbuf_lastindex++;
1160 pACB->wqbuf_lastindex %= ARCMSR_MAX_QBUFFER;/*if last index number set it to 0 */
1161 ptmpuserbuffer++;
1162 user_len--;
1163 }
1164 /*post fist Qbuffer*/
1165 if(pACB->acb_flags & ACB_F_IOCTL_WQBUFFER_CLEARED)
1166 {
1167 pACB->acb_flags &=~ACB_F_IOCTL_WQBUFFER_CLEARED;
1168 arcmsr_post_Qbuffer(pACB);
1169 }
1170 pccbioctl->ReturnCode=ARCMSR_IOCTL_RETURNCODE_OK;
1171 }
1172 else
1173 {
1174 pccbioctl->ReturnCode=ARCMSR_IOCTL_RETURNCODE_ERROR;
1175 }
1176 splx(s);
1177 return ARC_IOCTL_SUCCESS;
1178 }
1179 break;
1180 case ARCMSR_IOCTL_CLEAR_RQBUFFER:
1181 {
1182 u_int32_t s;
1183 u_int8_t * pQbuffer=pACB->rqbuffer;
1184 s=splcam();
1185 if(pACB->acb_flags & ACB_F_IOPDATA_OVERFLOW)
1186 {
1187 pACB->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
1188 writel(&pACB->pmu->inbound_doorbell, ARCMSR_INBOUND_DRIVER_DATA_READ_OK);/*signature, let IOP331 know data has been readed */
1189 }
1190 pACB->acb_flags |= ACB_F_IOCTL_RQBUFFER_CLEARED;
1191 pACB->rqbuf_firstindex=0;
1192 pACB->rqbuf_lastindex=0;
1193 memset(pQbuffer, 0, ARCMSR_MAX_QBUFFER);
1194 pccbioctl->ReturnCode=ARCMSR_IOCTL_RETURNCODE_OK;
1195 splx(s);
1196 return ARC_IOCTL_SUCCESS;
1197 }
1198 break;
1199 case ARCMSR_IOCTL_CLEAR_WQBUFFER:
1200 {
1201 u_int32_t s;
1202 u_int8_t * pQbuffer=pACB->wqbuffer;
1203
1204 s=splcam();
1205 if(pACB->acb_flags & ACB_F_IOPDATA_OVERFLOW)
1206 {
1207 pACB->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
1208 writel(&pACB->pmu->inbound_doorbell, ARCMSR_INBOUND_DRIVER_DATA_READ_OK);/*signature, let IOP331 know data has been readed */
1209 }
1210 pACB->acb_flags |= ACB_F_IOCTL_WQBUFFER_CLEARED;
1211 pACB->wqbuf_firstindex=0;
1212 pACB->wqbuf_lastindex=0;
1213 memset(pQbuffer, 0, ARCMSR_MAX_QBUFFER);
1214 pccbioctl->ReturnCode=ARCMSR_IOCTL_RETURNCODE_OK;
1215 splx(s);
1216 return ARC_IOCTL_SUCCESS;
1217 }
1218 break;
1219 case ARCMSR_IOCTL_CLEAR_ALLQBUFFER:
1220 {
1221 u_int32_t s;
1222 u_int8_t * pQbuffer;
1223
1224 s=splcam();
1225 if(pACB->acb_flags & ACB_F_IOPDATA_OVERFLOW)
1226 {
1227 pACB->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
1228 writel(&pACB->pmu->inbound_doorbell, ARCMSR_INBOUND_DRIVER_DATA_READ_OK);/*signature, let IOP331 know data has been readed */
1229 }
1230 pACB->acb_flags |= (ACB_F_IOCTL_WQBUFFER_CLEARED|ACB_F_IOCTL_RQBUFFER_CLEARED);
1231 pACB->rqbuf_firstindex=0;
1232 pACB->rqbuf_lastindex=0;
1233 pACB->wqbuf_firstindex=0;
1234 pACB->wqbuf_lastindex=0;
1235 pQbuffer=pACB->rqbuffer;
1236 memset(pQbuffer, 0, sizeof(struct _QBUFFER));
1237 pQbuffer=pACB->wqbuffer;
1238 memset(pQbuffer, 0, sizeof(struct _QBUFFER));
1239 pccbioctl->ReturnCode=ARCMSR_IOCTL_RETURNCODE_OK;
1240 splx(s);
1241 return ARC_IOCTL_SUCCESS;
1242 }
1243 break;
1244 case ARCMSR_IOCTL_REQUEST_RETURNCODE_3F:
1245 {
1246 pccbioctl->ReturnCode=ARCMSR_IOCTL_RETURNCODE_3F;
1247 return ARC_IOCTL_SUCCESS;
1248 }
1249 break;
1250 case ARCMSR_IOCTL_SAY_HELLO:
1251 {
1252 struct _CMD_IOCTL_FIELD * pccbioctlfld=(struct _CMD_IOCTL_FIELD *)arg;
1253 u_int8_t * hello_string="Hello! I am ARCMSR";
1254 u_int8_t * puserbuffer=(u_int8_t *)pccbioctlfld->ioctldatabuffer;
1255
1256 if(memcpy(puserbuffer,hello_string,(int16_t)strlen(hello_string)))
1257 {
1258 pccbioctl->ReturnCode=ARCMSR_IOCTL_RETURNCODE_ERROR;
1259 return ENOIOCTL;
1260 }
1261 pccbioctl->ReturnCode=ARCMSR_IOCTL_RETURNCODE_OK;
1262 return ARC_IOCTL_SUCCESS;
1263 }
1264 break;
1265 case ARCMSR_IOCTL_SAY_GOODBYE:
1266 {
1267 arcmsr_iop_parking(pACB);
1268 return ARC_IOCTL_SUCCESS;
1269 }
1270 break;
1271 case ARCMSR_IOCTL_FLUSH_ADAPTER_CACHE:
1272 {
1273 arcmsr_flush_adapter_cache(pACB);
1274 if(arcmsr_wait_msgint_ready(pACB))
1275 {
1276 printf("arcmsr%d: ioctl flush cache wait 'flush adapter cache' timeout \n",pACB->pci_unit);
1277 }
1278 return ARC_IOCTL_SUCCESS;
1279 }
1280 break;
1281 }
1282 return EINVAL;
1283 }
1284 /*
1285 **************************************************************************
1286 **
1287 **************************************************************************
1288 */
1289 struct _SRB * arcmsr_get_freesrb(struct _ACB * pACB)
1290 {
1291 struct _SRB * pSRB=NULL;
1292 u_int32_t s;
1293 u_int32_t srb_startindex,srb_doneindex;
1294
1295 s=splcam();
1296 srb_doneindex=pACB->srb_doneindex;
1297 srb_startindex=pACB->srb_startindex;
1298 pSRB=pACB->psrbringQ[srb_startindex];
1299 srb_startindex++;
1300 srb_startindex %= ARCMSR_MAX_FREESRB_NUM;
1301 if(srb_doneindex!=srb_startindex)
1302 {
1303 pACB->srb_startindex=srb_startindex;
1304 }
1305 else
1306 {
1307 pSRB=NULL;
1308 }
1309 splx(s);
1310 return(pSRB);
1311 }
1312 /*
1313 *********************************************************************
1314 **
1315 **
1316 **
1317 *********************************************************************
1318 */
1319 static void arcmsr_executesrb(void *arg,bus_dma_segment_t *dm_segs,int nseg,int error)
1320 {
1321 struct _SRB * pSRB=(struct _SRB *)arg;
1322 struct _ACB * pACB=(struct _ACB *)pSRB->pACB;
1323 union ccb * pccb;
1324 int target,lun;
1325
1326 pccb=pSRB->pccb;
1327 target=pccb->ccb_h.target_id;
1328 lun=pccb->ccb_h.target_lun;
1329 if(error != 0)
1330 {
1331 if(error != EFBIG)
1332 {
1333 printf("arcmsr%d: unexpected error %x returned from 'bus_dmamap_load' \n",pACB->pci_unit,error);
1334 }
1335 if(pccb->ccb_h.status == CAM_REQ_INPROG)
1336 {
1337 xpt_freeze_devq(pccb->ccb_h.path,/*count*/1);
1338 pccb->ccb_h.status=CAM_REQ_TOO_BIG|CAM_DEV_QFRZN;
1339 }
1340 arcmsr_srb_complete(pSRB);
1341 return;
1342 }
1343 if(pACB->acb_flags & ACB_F_BUS_RESET)
1344 {
1345 printf("arcmsr%d: bus reset and return busy \n",pACB->pci_unit);
1346 pccb->ccb_h.status|=CAM_SCSI_BUS_RESET;
1347 arcmsr_srb_complete(pSRB);
1348 return;
1349 }
1350 if(pACB->devstate[target][lun]==ARECA_RAID_GONE)
1351 {
1352 u_int8_t block_cmd;
1353
1354 block_cmd=pccb->csio.cdb_io.cdb_bytes[0] & 0x0f;
1355 if(block_cmd==0x08 || block_cmd==0x0a)
1356 {
1357 printf("arcmsr%d:block 'read/write' command with gone raid volume Cmd=%2x,TargetId=%d,Lun=%d \n",pACB->pci_unit,block_cmd,target,lun);
1358 pccb->ccb_h.status=CAM_DEV_NOT_THERE;
1359 arcmsr_srb_complete(pSRB);
1360 return;
1361 }
1362 }
1363 arcmsr_build_srb(pSRB,dm_segs,nseg);
1364 if(pccb->ccb_h.status != CAM_REQ_INPROG)
1365 {
1366 if(nseg != 0)
1367 {
1368 bus_dmamap_unload(pACB->buffer_dmat,pSRB->dmamap);
1369 }
1370 arcmsr_srb_complete(pSRB);
1371 return;
1372 }
1373 pccb->ccb_h.status |= CAM_SIM_QUEUED;
1374 if(pACB->srboutstandingcount < ARCMSR_MAX_OUTSTANDING_CMD)
1375 {
1376 /*
1377 ******************************************************************
1378 ** and we can make sure there were no pending srb in this duration
1379 ******************************************************************
1380 */
1381 arcmsr_post_srb(pACB,pSRB);
1382 }
1383 else
1384 {
1385 /*
1386 ******************************************************************
1387 ** Q of srbwaitexec will be post out when any outstanding command complete
1388 ******************************************************************
1389 */
1390 arcmsr_queue_wait2go_srb(pACB,pSRB);
1391 }
1392 return;
1393 }
1394 /*
1395 *****************************************************************************************
1396 **
1397 *****************************************************************************************
1398 */
1399 static u_int8_t arcmsr_seek_cmd2abort(union ccb * pabortccb)
1400 {
1401 struct _SRB * pSRB;
1402 struct _ACB * pACB=(struct _ACB *) pabortccb->ccb_h.arcmsr_ccbacb_ptr;
1403 u_int32_t s,intmask_org,mask;
1404 u_int32_t i=0;
1405
1406 s=splcam();
1407 pACB->num_aborts++;
1408 /*
1409 ***************************************************************************
1410 ** It is the upper layer do abort command this lock just prior to calling us.
1411 ** First determine if we currently own this command.
1412 ** Start by searching the device queue. If not found
1413 ** at all,and the system wanted us to just abort the
1414 ** command return success.
1415 ***************************************************************************
1416 */
1417 if(pACB->srboutstandingcount!=0)
1418 {
1419 for(i=0;i<ARCMSR_MAX_FREESRB_NUM;i++)
1420 {
1421 pSRB=pACB->psrb_pool[i];
1422 if(pSRB->startdone==ARCMSR_SRB_START)
1423 {
1424 if(pSRB->pccb==pabortccb)
1425 {
1426 pSRB->startdone=ARCMSR_SRB_ABORTED;
1427 printf("arcmsr%d:scsi id=%d lun=%d abort srb '%p' outstanding command \n",pACB->pci_unit,pabortccb->ccb_h.target_id,pabortccb->ccb_h.target_lun,pSRB);
1428 goto abort_outstanding_cmd;
1429 }
1430 }
1431 }
1432 }
1433 /*
1434 ********************************************************
1435 ** seek this command at our command list
1436 ** if command found then remove,abort it and free this SRB
1437 ********************************************************
1438 */
1439 if(pACB->srbwait2gocount!=0)
1440 {
1441 for(i=0;i<ARCMSR_MAX_OUTSTANDING_CMD;i++)
1442 {
1443 pSRB=pACB->psrbwait2go[i];
1444 if(pSRB!=NULL)
1445 {
1446 if(pSRB->pccb==pabortccb)
1447 {
1448 printf("arcmsr%d:scsi id=%d lun=%d abort ccb '%p' pending command \n",pACB->pci_unit,pabortccb->ccb_h.target_id,pabortccb->ccb_h.target_lun,pSRB);
1449 pACB->psrbwait2go[i]=NULL;
1450 pSRB->startdone=ARCMSR_SRB_ABORTED;
1451 pSRB->pccb->ccb_h.status=CAM_REQ_ABORTED;
1452 arcmsr_srb_complete(pSRB);
1453 atomic_subtract_int(&pACB->srbwait2gocount,1);
1454 splx(s);
1455 return(TRUE);
1456 }
1457 }
1458 }
1459 }
1460 splx(s);
1461 return(FALSE);
1462 abort_outstanding_cmd:
1463 /* disable all outbound interrupt */
1464 intmask_org=readl(&pACB->pmu->outbound_intmask);
1465 writel(&pACB->pmu->outbound_intmask,intmask_org|ARCMSR_MU_OUTBOUND_ALL_INTMASKENABLE);
1466 /* do not talk to iop 331 abort command */
1467 arcmsr_polling_srbdone(pACB,pSRB);
1468 /* enable all outbound interrupt */
1469 mask=~(ARCMSR_MU_OUTBOUND_POSTQUEUE_INTMASKENABLE|ARCMSR_MU_OUTBOUND_DOORBELL_INTMASKENABLE|ARCMSR_MU_OUTBOUND_MESSAGE0_INTMASKENABLE);
1470 writel(&pACB->pmu->outbound_intmask,intmask_org & mask);
1471 atomic_set_int(&pACB->srboutstandingcount,0);
1472 splx(s);
1473 return (TRUE);
1474 }
1475 /*
1476 ****************************************************************************
1477 **
1478 ****************************************************************************
1479 */
1480 static void arcmsr_bus_reset(struct _ACB * pACB)
1481 {
1482 int retry=0;
1483
1484 pACB->num_resets++;
1485 pACB->acb_flags |=ACB_F_BUS_RESET;
1486 while(pACB->srboutstandingcount!=0 && retry < 400)
1487 {
1488 arcmsr_interrupt((void *)pACB);
1489 UDELAY(25000);
1490 retry++;
1491 }
1492 arcmsr_iop_reset(pACB);
1493 pACB->acb_flags &= ~ACB_F_BUS_RESET;
1494 return;
1495 }
1496 /*
1497 *********************************************************************
1498 **
1499 ** CAM Status field values
1500 **typedef enum {
1501 ** CAM_REQ_INPROG, CCB request is in progress
1502 ** CAM_REQ_CMP, CCB request completed without error
1503 ** CAM_REQ_ABORTED, CCB request aborted by the host
1504 ** CAM_UA_ABORT, Unable to abort CCB request
1505 ** CAM_REQ_CMP_ERR, CCB request completed with an error
1506 ** CAM_BUSY, CAM subsytem is busy
1507 ** CAM_REQ_INVALID, CCB request was invalid
1508 ** CAM_PATH_INVALID, Supplied Path ID is invalid
1509 ** CAM_DEV_NOT_THERE, SCSI Device Not Installed/there
1510 ** CAM_UA_TERMIO, Unable to terminate I/O CCB request
1511 ** CAM_SEL_TIMEOUT, Target Selection Timeout
1512 ** CAM_CMD_TIMEOUT, Command timeout
1513 ** CAM_SCSI_STATUS_ERROR, SCSI error, look at error code in CCB
1514 ** CAM_MSG_REJECT_REC, Message Reject Received
1515 ** CAM_SCSI_BUS_RESET, SCSI Bus Reset Sent/Received
1516 ** CAM_UNCOR_PARITY, Uncorrectable parity error occurred
1517 ** CAM_AUTOSENSE_FAIL=0x10, Autosense: request sense cmd fail
1518 ** CAM_NO_HBA, No HBA Detected error
1519 ** CAM_DATA_RUN_ERR, Data Overrun error
1520 ** CAM_UNEXP_BUSFREE, Unexpected Bus Free
1521 ** CAM_SEQUENCE_FAIL, Target Bus Phase Sequence Failure
1522 ** CAM_CCB_LEN_ERR, CCB length supplied is inadequate
1523 ** CAM_PROVIDE_FAIL, Unable to provide requested capability
1524 ** CAM_BDR_SENT, A SCSI BDR msg was sent to target
1525 ** CAM_REQ_TERMIO, CCB request terminated by the host
1526 ** CAM_UNREC_HBA_ERROR, Unrecoverable Host Bus Adapter Error
1527 ** CAM_REQ_TOO_BIG, The request was too large for this host
1528 ** CAM_REQUEUE_REQ,
1529 ** * This request should be requeued to preserve
1530 ** * transaction ordering. This typically occurs
1531 ** * when the SIM recognizes an error that should
1532 ** * freeze the queue and must place additional
1533 ** * requests for the target at the sim level
1534 ** * back into the XPT queue.
1535 **
1536 ** CAM_IDE=0x33, Initiator Detected Error
1537 ** CAM_RESRC_UNAVAIL, Resource Unavailable
1538 ** CAM_UNACKED_EVENT, Unacknowledged Event by Host
1539 ** CAM_MESSAGE_RECV, Message Received in Host Target Mode
1540 ** CAM_INVALID_CDB, Invalid CDB received in Host Target Mode
1541 ** CAM_LUN_INVALID, Lun supplied is invalid
1542 ** CAM_TID_INVALID, Target ID supplied is invalid
1543 ** CAM_FUNC_NOTAVAIL, The requested function is not available
1544 ** CAM_NO_NEXUS, Nexus is not established
1545 ** CAM_IID_INVALID, The initiator ID is invalid
1546 ** CAM_CDB_RECVD, The SCSI CDB has been received
1547 ** CAM_LUN_ALRDY_ENA, The LUN is already eanbeld for target mode
1548 ** CAM_SCSI_BUSY, SCSI Bus Busy
1549 **
1550 ** CAM_DEV_QFRZN=0x40, The DEV queue is frozen w/this err
1551 **
1552 ** Autosense data valid for target
1553 ** CAM_AUTOSNS_VALID=0x80,
1554 ** CAM_RELEASE_SIMQ=0x100, SIM ready to take more commands
1555 ** CAM_SIM_QUEUED =0x200, SIM has this command in it's queue
1556 **
1557 ** CAM_STATUS_MASK=0x3F, Mask bits for just the status #
1558 **
1559 ** Target Specific Adjunct Status
1560 ** CAM_SENT_SENSE=0x40000000 sent sense with status
1561 **} cam_status;
1562 **
1563 **union ccb {
1564 ** struct ccb_hdr ccb_h; For convenience
1565 ** struct ccb_scsiio csio;
1566 ** struct ccb_getdev cgd;
1567 ** struct ccb_getdevlist cgdl;
1568 ** struct ccb_pathinq cpi;
1569 ** struct ccb_relsim crs;
1570 ** struct ccb_setasync csa;
1571 ** struct ccb_setdev csd;
1572 ** struct ccb_pathstats cpis;
1573 ** struct ccb_getdevstats cgds;
1574 ** struct ccb_dev_match cdm;
1575 ** struct ccb_trans_settings cts;
1576 ** struct ccb_calc_geometry ccg;
1577 ** struct ccb_abort cab;
1578 ** struct ccb_resetbus crb;
1579 ** struct ccb_resetdev crd;
1580 ** struct ccb_termio tio;
1581 ** struct ccb_accept_tio atio;
1582 ** struct ccb_scsiio ctio;
1583 ** struct ccb_en_lun cel;
1584 ** struct ccb_immed_notify cin;
1585 ** struct ccb_notify_ack cna;
1586 ** struct ccb_eng_inq cei;
1587 ** struct ccb_eng_exec cee;
1588 ** struct ccb_rescan crcn;
1589 ** struct ccb_debug cdbg;
1590 ** }
1591 **
1592 **struct ccb_hdr {
1593 ** cam_pinfo pinfo; "" Info for priority scheduling
1594 ** camq_entry xpt_links; "" For chaining in the XPT layer
1595 ** camq_entry sim_links; "" For chaining in the SIM layer
1596 ** camq_entry periph_links; "" For chaining in the type driver
1597 ** u_int32_t retry_count;
1598 ** void (*cbfcnp)(struct cam_periph *, union ccb *);"" Callback on completion function
1599 ** xpt_opcode func_code; "" XPT function code
1600 ** u_int32_t status; "" Status returned by CAM subsystem
1601 ** struct cam_path *path; "" Compiled path for this ccb
1602 ** path_id_t path_id; "" Path ID for the request
1603 ** target_id_t target_id; "" Target device ID
1604 ** lun_id_t target_lun; "" Target LUN number
1605 ** u_int32_t flags;
1606 ** ccb_ppriv_area periph_priv;
1607 ** ccb_spriv_area sim_priv;
1608 ** u_int32_t timeout; "" Timeout value
1609 ** struct callout_handle timeout_ch; "" Callout handle used for timeouts
1610 **};
1611 **
1612 **typedef union {
1613 ** u_int8_t *cdb_ptr; "" Pointer to the CDB bytes to send
1614 ** u_int8_t cdb_bytes[IOCDBLEN]; "" Area for the CDB send
1615 **} cdb_t;
1616 **
1617 ** SCSI I/O Request CCB used for the XPT_SCSI_IO and XPT_CONT_TARGET_IO
1618 ** function codes.
1619 **
1620 **struct ccb_scsiio {
1621 ** struct ccb_hdr ccb_h;
1622 ** union ccb *next_ccb; "" Ptr for next CCB for action
1623 ** u_int8_t *req_map; "" Ptr to mapping info
1624 ** u_int8_t *data_ptr; "" Ptr to the data buf/SG list
1625 ** u_int32_t dxfer_len; "" Data transfer length
1626 ** struct scsi_sense_data sense_data; "" Autosense storage
1627 ** u_int8_t sense_len; "" Number of bytes to autosense
1628 ** u_int8_t cdb_len; "" Number of bytes for the CDB
1629 ** u_int16_t sglist_cnt; "" Number of SG list entries
1630 ** u_int8_t scsi_status; "" Returned SCSI status
1631 ** u_int8_t sense_resid; "" Autosense resid length: 2's comp
1632 ** u_int32_t resid; "" Transfer residual length: 2's comp
1633 ** cdb_t cdb_io; "" Union for CDB bytes/pointer
1634 ** u_int8_t *msg_ptr; "" Pointer to the message buffer
1635 ** u_int16_t msg_len; "" Number of bytes for the Message
1636 ** u_int8_t tag_action; "" What to do for tag queueing
1637 **#define CAM_TAG_ACTION_NONE 0x00 "" The tag action should be either the define below (to send a non-tagged transaction) or one of the defined scsi tag messages from scsi_message.h.
1638 ** u_int tag_id; "" tag id from initator (target mode)
1639 ** u_int init_id; "" initiator id of who selected
1640 **}
1641 *********************************************************************
1642 */
1643 static void arcmsr_action(struct cam_sim * psim,union ccb * pccb)
1644 {
1645 struct _ACB * pACB;
1646
1647 pACB=(struct _ACB *) cam_sim_softc(psim);
1648 if(pACB==NULL)
1649 {
1650 pccb->ccb_h.status=CAM_REQ_INVALID;
1651 xpt_done(pccb);
1652 return;
1653 }
1654 switch (pccb->ccb_h.func_code)
1655 {
1656 case XPT_SCSI_IO:
1657 {
1658 struct _SRB * pSRB;
1659
1660 if((pSRB=arcmsr_get_freesrb(pACB)) == NULL)
1661 {
1662 pccb->ccb_h.status=CAM_RESRC_UNAVAIL;
1663 xpt_done(pccb);
1664 return;
1665 }
1666 pccb->ccb_h.arcmsr_ccbsrb_ptr=pSRB;
1667 pccb->ccb_h.arcmsr_ccbacb_ptr=pACB;
1668 pSRB->pccb=pccb;
1669 if((pccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE)
1670 {
1671 if((pccb->ccb_h.flags & CAM_SCATTER_VALID) == 0)
1672 {
1673 if((pccb->ccb_h.flags & CAM_DATA_PHYS) == 0)
1674 {
1675 u_int32_t error,s;
1676
1677 s=splsoftvm();
1678 error = bus_dmamap_load(pACB->buffer_dmat,pSRB->dmamap,pccb->csio.data_ptr,pccb->csio.dxfer_len,arcmsr_executesrb,pSRB,/*flags*/0);
1679 if(error == EINPROGRESS)
1680 {
1681 xpt_freeze_simq(pACB->psim,1);
1682 pccb->ccb_h.status |= CAM_RELEASE_SIMQ;
1683 }
1684 splx(s);
1685 }
1686 else
1687 {
1688 struct bus_dma_segment seg;
1689
1690 seg.ds_addr=(bus_addr_t)pccb->csio.data_ptr;
1691 seg.ds_len=pccb->csio.dxfer_len;
1692 arcmsr_executesrb(pSRB,&seg,1,0);
1693 }
1694 }
1695 else
1696 {
1697 struct bus_dma_segment *segs;
1698
1699 if((pccb->ccb_h.flags & CAM_SG_LIST_PHYS) == 0 || (pccb->ccb_h.flags & CAM_DATA_PHYS) != 0)
1700 {
1701 pccb->ccb_h.status=CAM_PROVIDE_FAIL;
1702 xpt_done(pccb);
1703 free(pSRB,M_DEVBUF);
1704 return;
1705 }
1706 segs=(struct bus_dma_segment *)pccb->csio.data_ptr;
1707 arcmsr_executesrb(pSRB,segs,pccb->csio.sglist_cnt,0);
1708 }
1709 }
1710 else
1711 {
1712 arcmsr_executesrb(pSRB,NULL,0,0);
1713 }
1714 break;
1715 }
1716 case XPT_TARGET_IO:
1717 {
1718 /*
1719 ** target mode not yet support vendor specific commands.
1720 */
1721 pccb->ccb_h.status=CAM_REQ_CMP;
1722 xpt_done(pccb);
1723 break;
1724 }
1725 case XPT_PATH_INQ:
1726 {
1727 struct ccb_pathinq *cpi=&pccb->cpi;
1728
1729 cpi->version_num=1;
1730 cpi->hba_inquiry=PI_SDTR_ABLE | PI_TAG_ABLE;
1731 cpi->target_sprt=0;
1732 cpi->hba_misc=0;
1733 cpi->hba_eng_cnt=0;
1734 cpi->max_target=ARCMSR_MAX_TARGETID;
1735 cpi->max_lun=ARCMSR_MAX_TARGETLUN; /* 7 or 0 */
1736 cpi->initiator_id=ARCMSR_SCSI_INITIATOR_ID;
1737 cpi->bus_id=cam_sim_bus(psim);
1738 strncpy(cpi->sim_vid,"FreeBSD",SIM_IDLEN);
1739 strncpy(cpi->hba_vid,"ARCMSR",HBA_IDLEN);
1740 strncpy(cpi->dev_name,cam_sim_name(psim),DEV_IDLEN);
1741 cpi->unit_number=cam_sim_unit(psim);
1742 cpi->ccb_h.status=CAM_REQ_CMP;
1743 xpt_done(pccb);
1744 break;
1745 }
1746 case XPT_ABORT:
1747 {
1748 union ccb *pabort_ccb;
1749
1750 pabort_ccb=pccb->cab.abort_ccb;
1751 switch (pabort_ccb->ccb_h.func_code)
1752 {
1753 case XPT_ACCEPT_TARGET_IO:
1754 case XPT_IMMED_NOTIFY:
1755 case XPT_CONT_TARGET_IO:
1756 if(arcmsr_seek_cmd2abort(pabort_ccb)==TRUE)
1757 {
1758 pabort_ccb->ccb_h.status=CAM_REQ_ABORTED;
1759 xpt_done(pabort_ccb);
1760 pccb->ccb_h.status=CAM_REQ_CMP;
1761 }
1762 else
1763 {
1764 xpt_print_path(pabort_ccb->ccb_h.path);
1765 printf("Not found\n");
1766 pccb->ccb_h.status=CAM_PATH_INVALID;
1767 }
1768 break;
1769 case XPT_SCSI_IO:
1770 pccb->ccb_h.status=CAM_UA_ABORT;
1771 break;
1772 default:
1773 pccb->ccb_h.status=CAM_REQ_INVALID;
1774 break;
1775 }
1776 xpt_done(pccb);
1777 break;
1778 }
1779 case XPT_RESET_BUS:
1780 case XPT_RESET_DEV:
1781 {
1782 u_int32_t i;
1783
1784 arcmsr_bus_reset(pACB);
1785 for (i=0; i < 500; i++)
1786 {
1787 DELAY(1000);
1788 }
1789 pccb->ccb_h.status=CAM_REQ_CMP;
1790 xpt_done(pccb);
1791 break;
1792 }
1793 case XPT_TERM_IO:
1794 {
1795 pccb->ccb_h.status=CAM_REQ_INVALID;
1796 xpt_done(pccb);
1797 break;
1798 }
1799 case XPT_GET_TRAN_SETTINGS:
1800 {
1801 struct ccb_trans_settings *cts;
1802 u_int32_t s;
1803
1804 cts=&pccb->cts;
1805 s=splcam();
1806 cts->flags=(CCB_TRANS_DISC_ENB | CCB_TRANS_TAG_ENB);
1807 cts->sync_period=3;
1808 cts->sync_offset=32;
1809 cts->bus_width=MSG_EXT_WDTR_BUS_16_BIT;
1810 cts->valid=CCB_TRANS_SYNC_RATE_VALID | CCB_TRANS_SYNC_OFFSET_VALID | CCB_TRANS_BUS_WIDTH_VALID | CCB_TRANS_DISC_VALID | CCB_TRANS_TQ_VALID;
1811 splx(s);
1812 pccb->ccb_h.status=CAM_REQ_CMP;
1813 xpt_done(pccb);
1814 break;
1815 }
1816 case XPT_SET_TRAN_SETTINGS:
1817 {
1818 pccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
1819 xpt_done(pccb);
1820 break;
1821 }
1822 case XPT_CALC_GEOMETRY:
1823 {
1824 struct ccb_calc_geometry *ccg;
1825 u_int32_t size_mb;
1826 u_int32_t secs_per_cylinder;
1827
1828 ccg=&pccb->ccg;
1829 size_mb=ccg->volume_size/((1024L * 1024L)/ccg->block_size);
1830 if(size_mb > 1024 )
1831 {
1832 ccg->heads=255;
1833 ccg->secs_per_track=63;
1834 }
1835 else
1836 {
1837 ccg->heads=64;
1838 ccg->secs_per_track=32;
1839 }
1840 secs_per_cylinder=ccg->heads * ccg->secs_per_track;
1841 ccg->cylinders=ccg->volume_size / secs_per_cylinder;
1842 pccb->ccb_h.status=CAM_REQ_CMP;
1843 xpt_done(pccb);
1844 break;
1845 }
1846 default:
1847 printf("arcmsr%d: invalid XPT function CAM_REQ_INVALID\n",pACB->pci_unit);
1848 pccb->ccb_h.status=CAM_REQ_INVALID;
1849 xpt_done(pccb);
1850 break;
1851 }
1852 return;
1853 }
1854 /*
1855 **********************************************************************
1856 ** start background rebulid
1857 **********************************************************************
1858 */
1859 static void arcmsr_start_adapter_bgrb(struct _ACB * pACB)
1860 {
1861 pACB->acb_flags |= ACB_F_MSG_START_BGRB;
1862 pACB->acb_flags &= ~ACB_F_MSG_STOP_BGRB;
1863 writel(&pACB->pmu->inbound_msgaddr0,ARCMSR_INBOUND_MESG0_START_BGRB);
1864 return;
1865 }
1866 /*
1867 **********************************************************************
1868 **********************************************************************
1869 */
1870 static void arcmsr_polling_srbdone(struct _ACB *pACB,struct _SRB *poll_srb)
1871 {
1872 struct _SRB *pSRB;
1873 uint32_t flag_srb,outbound_intstatus,poll_srb_done=0,poll_count=0;
1874 int id,lun;
1875
1876 polling_srb_retry:
1877 poll_count++;
1878 outbound_intstatus=readl(&pACB->pmu->outbound_intstatus) & pACB->outbound_int_enable;
1879 writel(&pACB->pmu->outbound_intstatus,outbound_intstatus);/*clear interrupt*/
1880 while(1)
1881 {
1882 if((flag_srb=readl(&pACB->pmu->outbound_queueport))==0xFFFFFFFF)
1883 {
1884 if(poll_srb_done)
1885 {
1886 break;/*chip FIFO no ccb for completion already*/
1887 }
1888 else
1889 {
1890 UDELAY(25000);
1891 if(poll_count > 100)
1892 {
1893 break;
1894 }
1895 goto polling_srb_retry;
1896 }
1897 }
1898 /* check ifcommand done with no error*/
1899 pSRB=(struct _SRB *)(pACB->vir2phy_offset+(flag_srb << 5));/*frame must be 32 bytes aligned*/
1900 if((pSRB->pACB!=pACB) || (pSRB->startdone!=ARCMSR_SRB_START))
1901 {
1902 if((pSRB->startdone==ARCMSR_SRB_ABORTED) && (pSRB==poll_srb))
1903 {
1904 printf("arcmsr%d: scsi id=%d lun=%d srb='%p' poll command abort successfully \n",pACB->pci_unit,pSRB->pccb->ccb_h.target_id,pSRB->pccb->ccb_h.target_lun,pSRB);
1905 pSRB->pccb->ccb_h.status=CAM_REQ_ABORTED;
1906 arcmsr_srb_complete(pSRB);
1907 poll_srb_done=1;
1908 continue;
1909 }
1910 printf("arcmsr%d: polling get an illegal srb command done srb='%p' srboutstandingcount=%d \n",pACB->pci_unit,pSRB,pACB->srboutstandingcount);
1911 continue;
1912 }
1913 id=pSRB->pccb->ccb_h.target_id;
1914 lun=pSRB->pccb->ccb_h.target_lun;
1915 if((flag_srb & ARCMSR_SRBREPLY_FLAG_ERROR)==0)
1916 {
1917 if(pACB->devstate[id][lun]==ARECA_RAID_GONE)
1918 {
1919 pACB->devstate[id][lun]=ARECA_RAID_GOOD;
1920 }
1921 pSRB->pccb->ccb_h.status=CAM_REQ_CMP;
1922 arcmsr_srb_complete(pSRB);
1923 }
1924 else
1925 {
1926 switch(pSRB->arcmsr_cdb.DeviceStatus)
1927 {
1928 case ARCMSR_DEV_SELECT_TIMEOUT:
1929 {
1930 pACB->devstate[id][lun]=ARECA_RAID_GONE;
1931 pSRB->pccb->ccb_h.status=CAM_SEL_TIMEOUT;
1932 arcmsr_srb_complete(pSRB);
1933 }
1934 break;
1935 case ARCMSR_DEV_ABORTED:
1936 case ARCMSR_DEV_INIT_FAIL:
1937 {
1938 pACB->devstate[id][lun]=ARECA_RAID_GONE;
1939 pSRB->pccb->ccb_h.status=CAM_DEV_NOT_THERE;
1940 arcmsr_srb_complete(pSRB);
1941 }
1942 break;
1943 case SCSISTAT_CHECK_CONDITION:
1944 {
1945 pACB->devstate[id][lun]=ARECA_RAID_GOOD;
1946 arcmsr_report_sense_info(pSRB);
1947 arcmsr_srb_complete(pSRB);
1948 }
1949 break;
1950 default:
1951 /* error occur Q all error ccb to errorccbpending Q*/
1952 printf("arcmsr%d: scsi id=%d lun=%d polling and getting command error done, but got unknow DeviceStatus=0x%x \n",pACB->pci_unit,id,lun,pSRB->arcmsr_cdb.DeviceStatus);
1953 pACB->devstate[id][lun]=ARECA_RAID_GONE;
1954 pSRB->pccb->ccb_h.status=CAM_UNCOR_PARITY;/*unknow error or crc error just for retry*/
1955 arcmsr_srb_complete(pSRB);
1956 break;
1957 }
1958 }
1959 } /*drain reply FIFO*/
1960 return;
1961 }
1962 /*
1963 **********************************************************************
1964 ** get firmware miscellaneous data
1965 **********************************************************************
1966 */
1967 static void arcmsr_get_firmware_spec(struct _ACB *pACB)
1968 {
1969 char *acb_firm_model=pACB->firm_model;
1970 char *acb_firm_version=pACB->firm_version;
1971 char *iop_firm_model=(char *) (&pACB->pmu->message_rwbuffer[15]); /*firm_model,15,60-67*/
1972 char *iop_firm_version=(char *) (&pACB->pmu->message_rwbuffer[17]); /*firm_version,17,68-83*/
1973 int count;
1974
1975 writel(&pACB->pmu->inbound_msgaddr0,ARCMSR_INBOUND_MESG0_GET_CONFIG);
1976 if(arcmsr_wait_msgint_ready(pACB))
1977 {
1978 printf("arcmsr%d: wait 'get adapter firmware miscellaneous data' timeout \n",pACB->pci_unit);
1979 }
1980 count=8;
1981 while(count)
1982 {
1983 *acb_firm_model=readb(iop_firm_model);
1984 acb_firm_model++;
1985 iop_firm_model++;
1986 count--;
1987 }
1988 count=16;
1989 while(count)
1990 {
1991 *acb_firm_version=readb(iop_firm_version);
1992 acb_firm_version++;
1993 iop_firm_version++;
1994 count--;
1995 }
1996 printf("ARECA RAID ADAPTER%d: FIRMWARE VERSION %s \n",pACB->pci_unit,pACB->firm_version);
1997 if(strncmp(pACB->firm_version,"V1.37",5) < 0)
1998 {
1999 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
2000 printf("!!!!!! PLEASE UPDATE RAID FIRMWARE VERSION EQUAL OR MORE THAN 'V1.37' !!!!!!\n");
2001 printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
2002 }
2003 pACB->firm_request_len=readl(&pACB->pmu->message_rwbuffer[1]); /*firm_request_len,1,04-07*/
2004 pACB->firm_numbers_queue=readl(&pACB->pmu->message_rwbuffer[2]); /*firm_numbers_queue,2,08-11*/
2005 pACB->firm_sdram_size=readl(&pACB->pmu->message_rwbuffer[3]); /*firm_sdram_size,3,12-15*/
2006 pACB->firm_ide_channels=readl(&pACB->pmu->message_rwbuffer[4]); /*firm_ide_channels,4,16-19*/
2007 return;
2008 }
2009 /*
2010 **********************************************************************
2011 ** start background rebulid
2012 **********************************************************************
2013 */
2014 static void arcmsr_iop_init(struct _ACB * pACB)
2015 {
2016 u_int32_t intmask_org,mask,outbound_doorbell,firmware_state=0;
2017
2018 do
2019 {
2020 firmware_state=readl(&pACB->pmu->outbound_msgaddr1);
2021 }while((firmware_state & ARCMSR_OUTBOUND_MESG1_FIRMWARE_OK)==0);
2022 intmask_org=readl(&pACB->pmu->outbound_intmask);
2023 arcmsr_get_firmware_spec(pACB);
2024 /*start background rebuild*/
2025 arcmsr_start_adapter_bgrb(pACB);
2026 if(arcmsr_wait_msgint_ready(pACB))
2027 {
2028 printf("arcmsr%d: iop init wait 'start adapter background rebulid' timeout \n",pACB->pci_unit);
2029 }
2030 /* clear Qbuffer if door bell ringed */
2031 outbound_doorbell=readl(&pACB->pmu->outbound_doorbell);
2032 if(outbound_doorbell & ARCMSR_OUTBOUND_IOP331_DATA_WRITE_OK)
2033 {
2034 writel(&pACB->pmu->outbound_doorbell,outbound_doorbell);/*clear interrupt */
2035 writel(&pACB->pmu->inbound_doorbell,ARCMSR_INBOUND_DRIVER_DATA_READ_OK);
2036 }
2037 /* enable outbound Post Queue,outbound message0,outbell doorbell Interrupt */
2038 mask=~(ARCMSR_MU_OUTBOUND_POSTQUEUE_INTMASKENABLE|ARCMSR_MU_OUTBOUND_DOORBELL_INTMASKENABLE|ARCMSR_MU_OUTBOUND_MESSAGE0_INTMASKENABLE);
2039 writel(&pACB->pmu->outbound_intmask,intmask_org & mask);
2040 pACB->outbound_int_enable = ~(intmask_org & mask) & 0x000000ff;
2041 pACB->acb_flags |=ACB_F_IOP_INITED;
2042 return;
2043 }
2044 /*
2045 **********************************************************************
2046 **
2047 ** map freesrb
2048 **
2049 **********************************************************************
2050 */
2051 static void arcmsr_map_freesrb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
2052 {
2053 struct _ACB * pACB=arg;
2054 struct _SRB * psrb_tmp;
2055 u_int8_t * dma_memptr;
2056 u_int32_t i,cdb_phyaddr,srb_phyaddr_hi32;
2057 unsigned long srb_phyaddr=(unsigned long)segs->ds_addr;
2058
2059 dma_memptr=pACB->uncacheptr;
2060 cdb_phyaddr=(u_int32_t)segs->ds_addr; /* We suppose bus_addr_t high part always 0 here*/
2061 if(((unsigned long)dma_memptr & 0x1F)!=0)
2062 {
2063 dma_memptr=dma_memptr+(0x20-((unsigned long)dma_memptr & 0x1F));
2064 cdb_phyaddr=cdb_phyaddr+(0x20-((unsigned long)cdb_phyaddr & 0x1F));
2065 }
2066 psrb_tmp=(struct _SRB *)dma_memptr;
2067 for(i=0;i<ARCMSR_MAX_FREESRB_NUM;i++)
2068 {
2069 if(((unsigned long)psrb_tmp & 0x1F)==0) /*srb address must 32 (0x20) boundary*/
2070 {
2071 if(bus_dmamap_create(pACB->buffer_dmat, /*flags*/0, &psrb_tmp->dmamap)!=0)
2072 {
2073 pACB->acb_flags |= ACB_F_MAPFREESRB_FAILD;
2074 printf("arcmsr%d: srb dmamap bus_dmamap_create error\n",pACB->pci_unit);
2075 return;
2076 }
2077 psrb_tmp->cdb_shifted_phyaddr=cdb_phyaddr >> 5;
2078 psrb_tmp->pACB=pACB;
2079 pACB->psrbringQ[i]=pACB->psrb_pool[i]=psrb_tmp;
2080 cdb_phyaddr=cdb_phyaddr+sizeof(struct _SRB);
2081 }
2082 else
2083 {
2084 pACB->acb_flags |= ACB_F_MAPFREESRB_FAILD;
2085 printf("arcmsr%d: dma_memptr=%p i=%d this srb cross 32 bytes boundary ignored psrb_tmp=%p \n",pACB->pci_unit,dma_memptr,i,psrb_tmp);
2086 return;
2087 }
2088 psrb_tmp++;
2089 }
2090 /*
2091 ********************************************************************
2092 ** here we need to tell iop 331 our freesrb.HighPart
2093 ** if freesrb.HighPart is not zero
2094 ********************************************************************
2095 */
2096 srb_phyaddr_hi32=(uint32_t) ((srb_phyaddr>>16)>>16);
2097 if(srb_phyaddr_hi32!=0)
2098 {
2099 writel(&pACB->pmu->message_rwbuffer[0],ARCMSR_SIGNATURE_SET_CONFIG);
2100 writel(&pACB->pmu->message_rwbuffer[1],srb_phyaddr_hi32);
2101 writel(&pACB->pmu->inbound_msgaddr0,ARCMSR_INBOUND_MESG0_SET_CONFIG);
2102 if(arcmsr_wait_msgint_ready(pACB))
2103 {
2104 printf("arcmsr%d: 'set srb high part physical address' timeout \n",pACB->pci_unit);
2105 }
2106 }
2107 pACB->vir2phy_offset=(unsigned long)psrb_tmp-(unsigned long)cdb_phyaddr;
2108 return;
2109 }
2110 /*
2111 ************************************************************************
2112 **
2113 **
2114 ************************************************************************
2115 */
2116 static void arcmsr_free_resource(struct _ACB * pACB)
2117 {
2118 /* remove the control device */
2119 if(pACB->ioctl_dev != NULL)
2120 {
2121 destroy_dev(pACB->ioctl_dev);
2122 }
2123 bus_dmamap_unload(pACB->srb_dmat, pACB->srb_dmamap);
2124 bus_dmamap_destroy(pACB->srb_dmat, pACB->srb_dmamap);
2125 bus_dma_tag_destroy(pACB->srb_dmat);
2126 bus_dma_tag_destroy(pACB->buffer_dmat);
2127 bus_dma_tag_destroy(pACB->parent_dmat);
2128 return;
2129 }
2130 /*
2131 ************************************************************************
2132 ** PCI config header registers for all devices
2133 **
2134 ** #define PCIR_COMMAND 0x04
2135 ** #define PCIM_CMD_PORTEN 0x0001
2136 ** #define PCIM_CMD_MEMEN 0x0002
2137 ** #define PCIM_CMD_BUSMASTEREN 0x0004
2138 ** #define PCIM_CMD_MWRICEN 0x0010
2139 ** #define PCIM_CMD_PERRESPEN 0x0040
2140 **
2141 ** Function : arcmsr_initialize
2142 ** Purpose : initialize the internal structures for a given SCSI host
2143 ** Inputs : host - pointer to this host adapter's structure
2144 ** Preconditions : when this function is called,the chip_type
2145 ** field of the pACB structure MUST have been set.
2146 **
2147 ** 10h Base Address register #0
2148 ** 14h Base Address register #1
2149 ** 18h Base Address register #2
2150 ** 1Ch Base Address register #3
2151 ** 20h Base Address register #4
2152 ** 24h Base Address register #5
2153 ************************************************************************
2154 */
2155 static u_int32_t arcmsr_initialize(device_t dev)
2156 {
2157 struct _ACB * pACB=device_get_softc(dev);
2158 u_int32_t intmask_org,rid=PCIR_BAR(0);
2159 vm_offset_t mem_base;
2160 u_int16_t pci_command;
2161 int i,j;
2162
2163 #if __FreeBSD_version >= 502010
2164 if(bus_dma_tag_create( /*parent*/NULL,
2165 /*alignemnt*/1,
2166 /*boundary*/0,
2167 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
2168 /*highaddr*/BUS_SPACE_MAXADDR,
2169 /*filter*/NULL,
2170 /*filterarg*/NULL,
2171 /*maxsize*/BUS_SPACE_MAXSIZE_32BIT,
2172 /*nsegments*/BUS_SPACE_UNRESTRICTED,
2173 /*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
2174 /*flags*/0,
2175 /*lockfunc*/NULL,
2176 /*lockarg*/NULL,
2177 &pACB->parent_dmat) != 0)
2178 #else
2179 if(bus_dma_tag_create( /*parent*/NULL,
2180 /*alignemnt*/1,
2181 /*boundary*/0,
2182 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
2183 /*highaddr*/BUS_SPACE_MAXADDR,
2184 /*filter*/NULL,
2185 /*filterarg*/NULL,
2186 /*maxsize*/BUS_SPACE_MAXSIZE_32BIT,
2187 /*nsegments*/BUS_SPACE_UNRESTRICTED,
2188 /*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
2189 /*flags*/0,
2190 &pACB->parent_dmat) != 0)
2191 #endif
2192 {
2193 printf("arcmsr%d: parent_dmat bus_dma_tag_create failure!\n",pACB->pci_unit);
2194 return ENOMEM;
2195 }
2196 /* Create a single tag describing a region large enough to hold all of the s/g lists we will need. */
2197 #if __FreeBSD_version >= 502010
2198 if(bus_dma_tag_create( /*parent_dmat*/pACB->parent_dmat,
2199 /*alignment*/1,
2200 /*boundary*/0,
2201 /*lowaddr*/BUS_SPACE_MAXADDR,
2202 /*highaddr*/BUS_SPACE_MAXADDR,
2203 /*filter*/NULL,
2204 /*filterarg*/NULL,
2205 /*maxsize*/MAXBSIZE,
2206 /*nsegments*/ARCMSR_MAX_SG_ENTRIES,
2207 /*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
2208 /*flags*/BUS_DMA_ALLOCNOW,
2209 /*lockfunc*/busdma_lock_mutex,
2210 /*lockarg*/&Giant,
2211 &pACB->buffer_dmat) != 0)
2212 #else
2213 if(bus_dma_tag_create( /*parent_dmat*/pACB->parent_dmat,
2214 /*alignment*/1,
2215 /*boundary*/0,
2216 /*lowaddr*/BUS_SPACE_MAXADDR,
2217 /*highaddr*/BUS_SPACE_MAXADDR,
2218 /*filter*/NULL,
2219 /*filterarg*/NULL,
2220 /*maxsize*/MAXBSIZE,
2221 /*nsegments*/ARCMSR_MAX_SG_ENTRIES,
2222 /*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
2223 /*flags*/BUS_DMA_ALLOCNOW,
2224 &pACB->buffer_dmat) != 0)
2225 #endif
2226 {
2227 bus_dma_tag_destroy(pACB->parent_dmat);
2228 printf("arcmsr%d: buffer_dmat bus_dma_tag_create failure!\n",pACB->pci_unit);
2229 return ENOMEM;
2230 }
2231 /* DMA tag for our srb structures.... Allocate the freesrb memory */
2232 #if __FreeBSD_version >= 502010
2233 if(bus_dma_tag_create( /*parent_dmat*/pACB->parent_dmat,
2234 /*alignment*/1,
2235 /*boundary*/0,
2236 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
2237 /*highaddr*/BUS_SPACE_MAXADDR,
2238 /*filter*/NULL,
2239 /*filterarg*/NULL,
2240 /*maxsize*/((sizeof(struct _SRB) * ARCMSR_MAX_FREESRB_NUM)+0x20),
2241 /*nsegments*/1,
2242 /*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
2243 /*flags*/BUS_DMA_ALLOCNOW,
2244 /*lockfunc*/NULL,
2245 /*lockarg*/NULL,
2246 &pACB->srb_dmat) != 0)
2247 #else
2248 if(bus_dma_tag_create( /*parent_dmat*/pACB->parent_dmat,
2249 /*alignment*/1,
2250 /*boundary*/0,
2251 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
2252 /*highaddr*/BUS_SPACE_MAXADDR,
2253 /*filter*/NULL,
2254 /*filterarg*/NULL,
2255 /*maxsize*/((sizeof(struct _SRB) * ARCMSR_MAX_FREESRB_NUM)+0x20),
2256 /*nsegments*/1,
2257 /*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
2258 /*flags*/BUS_DMA_ALLOCNOW,
2259 &pACB->srb_dmat) != 0)
2260 #endif
2261 {
2262 bus_dma_tag_destroy(pACB->buffer_dmat);
2263 bus_dma_tag_destroy(pACB->parent_dmat);
2264 printf("arcmsr%d: srb_dmat bus_dma_tag_create failure!\n",pACB->pci_unit);
2265 return ENXIO;
2266 }
2267 /* Allocation for our srbs */
2268 if(bus_dmamem_alloc(pACB->srb_dmat, (void **)&pACB->uncacheptr, BUS_DMA_WAITOK | BUS_DMA_COHERENT, &pACB->srb_dmamap) != 0)
2269 {
2270 bus_dma_tag_destroy(pACB->srb_dmat);
2271 bus_dma_tag_destroy(pACB->buffer_dmat);
2272 bus_dma_tag_destroy(pACB->parent_dmat);
2273 printf("arcmsr%d: srb_dmat bus_dmamem_alloc failure!\n",pACB->pci_unit);
2274 return ENXIO;
2275 }
2276 /* And permanently map them */
2277 if(bus_dmamap_load(pACB->srb_dmat, pACB->srb_dmamap,pACB->uncacheptr,(sizeof(struct _SRB) * ARCMSR_MAX_FREESRB_NUM)+0x20,arcmsr_map_freesrb, pACB, /*flags*/0))
2278 {
2279 bus_dma_tag_destroy(pACB->srb_dmat);
2280 bus_dma_tag_destroy(pACB->buffer_dmat);
2281 bus_dma_tag_destroy(pACB->parent_dmat);
2282 printf("arcmsr%d: srb_dmat bus_dmamap_load failure!\n",pACB->pci_unit);
2283 return ENXIO;
2284 }
2285 pci_command=pci_read_config(dev,PCIR_COMMAND,2);
2286 pci_command |= PCIM_CMD_BUSMASTEREN;
2287 pci_command |= PCIM_CMD_PERRESPEN;
2288 pci_command |= PCIM_CMD_MWRICEN;
2289 /* Enable Busmaster/Mem */
2290 pci_command |= PCIM_CMD_MEMEN;
2291 pci_write_config(dev,PCIR_COMMAND,pci_command,2);
2292 pACB->sys_res_arcmsr=bus_alloc_resource(dev,SYS_RES_MEMORY,&rid,0,~0,0x1000,RF_ACTIVE);
2293 if(pACB->sys_res_arcmsr == NULL)
2294 {
2295 arcmsr_free_resource(pACB);
2296 printf("arcmsr%d: bus_alloc_resource failure!\n",pACB->pci_unit);
2297 return ENOMEM;
2298 }
2299 if(rman_get_start(pACB->sys_res_arcmsr) <= 0)
2300 {
2301 arcmsr_free_resource(pACB);
2302 printf("arcmsr%d: rman_get_start failure!\n",pACB->pci_unit);
2303 return ENXIO;
2304 }
2305 mem_base=(vm_offset_t) rman_get_virtual(pACB->sys_res_arcmsr);
2306 if(mem_base==0)
2307 {
2308 arcmsr_free_resource(pACB);
2309 printf("arcmsr%d: rman_get_virtual failure!\n",pACB->pci_unit);
2310 return ENXIO;
2311 }
2312 if(pACB->acb_flags & ACB_F_MAPFREESRB_FAILD)
2313 {
2314 arcmsr_free_resource(pACB);
2315 printf("arcmsr%d: map free srb failure!\n",pACB->pci_unit);
2316 return ENXIO;
2317 }
2318 pACB->btag=rman_get_bustag(pACB->sys_res_arcmsr);
2319 pACB->bhandle=rman_get_bushandle(pACB->sys_res_arcmsr);
2320 pACB->pmu=(struct _MU *)mem_base;
2321 pACB->acb_flags |= (ACB_F_IOCTL_WQBUFFER_CLEARED|ACB_F_IOCTL_RQBUFFER_CLEARED);
2322 pACB->acb_flags &= ~ACB_F_SCSISTOPADAPTER;
2323 /*
2324 ********************************************************************
2325 ** init raid volume state
2326 ********************************************************************
2327 */
2328 for(i=0;i<ARCMSR_MAX_TARGETID;i++)
2329 {
2330 for(j=0;j<ARCMSR_MAX_TARGETLUN;j++)
2331 {
2332 pACB->devstate[i][j]=ARECA_RAID_GOOD;
2333 }
2334 }
2335 /* disable iop all outbound interrupt */
2336 intmask_org=readl(&pACB->pmu->outbound_intmask);
2337 writel(&pACB->pmu->outbound_intmask,intmask_org|ARCMSR_MU_OUTBOUND_ALL_INTMASKENABLE);
2338 arcmsr_iop_init(pACB);
2339 return(0);
2340 }
2341 /*
2342 ************************************************************************
2343 **
2344 ** attach and init a host adapter
2345 **
2346 ************************************************************************
2347 */
2348 static u_int32_t arcmsr_attach(device_t dev)
2349 {
2350 struct _ACB * pACB=(struct _ACB *)device_get_softc(dev);
2351 u_int32_t unit=device_get_unit(dev);
2352 struct ccb_setasync csa;
2353 struct cam_devq *devq; /* Device Queue to use for this SIM */
2354 struct resource *irqres;
2355 int rid;
2356
2357 if(pACB == NULL)
2358 {
2359 printf("arcmsr%d: cannot allocate softc\n",unit);
2360 return (ENOMEM);
2361 }
2362 bzero(pACB, sizeof(struct _ACB));
2363 if(arcmsr_initialize(dev))
2364 {
2365 printf("arcmsr%d: initialize failure!\n",unit);
2366 return ENXIO;
2367 }
2368 /* After setting up the adapter,map our interrupt */
2369 rid=0;
2370 irqres=bus_alloc_resource(dev,SYS_RES_IRQ,&rid,0,~0,1,RF_SHAREABLE | RF_ACTIVE);
2371 if(irqres == NULL || bus_setup_intr(dev,irqres,INTR_TYPE_CAM,arcmsr_interrupt,pACB,&pACB->ih))
2372 {
2373 arcmsr_free_resource(pACB);
2374 printf("arcmsr%d: unable to register interrupt handler!\n",unit);
2375 return ENXIO;
2376 }
2377 pACB->irqres=irqres;
2378 pACB->pci_dev=dev;
2379 pACB->pci_unit=unit;
2380 /*
2381 * Now let the CAM generic SCSI layer find the SCSI devices on
2382 * the bus * start queue to reset to the idle loop. *
2383 * Create device queue of SIM(s) * (MAX_START_JOB - 1) :
2384 * max_sim_transactions
2385 */
2386 devq=cam_simq_alloc(ARCMSR_MAX_START_JOB);
2387 if(devq == NULL)
2388 {
2389 arcmsr_free_resource(pACB);
2390 bus_release_resource(dev, SYS_RES_IRQ, 0, pACB->irqres);
2391 printf("arcmsr%d: cam_simq_alloc failure!\n",unit);
2392 return ENXIO;
2393 }
2394 pACB->psim=cam_sim_alloc(arcmsr_action,arcmsr_poll,"arcmsr",pACB,unit,1,ARCMSR_MAX_OUTSTANDING_CMD,devq);
2395 if(pACB->psim == NULL)
2396 {
2397 arcmsr_free_resource(pACB);
2398 bus_release_resource(dev, SYS_RES_IRQ, 0, pACB->irqres);
2399 cam_simq_free(devq);
2400 printf("arcmsr%d: cam_sim_alloc failure!\n",unit);
2401 return ENXIO;
2402 }
2403 if(xpt_bus_register(pACB->psim,0) != CAM_SUCCESS)
2404 {
2405 arcmsr_free_resource(pACB);
2406 bus_release_resource(dev, SYS_RES_IRQ, 0, pACB->irqres);
2407 cam_sim_free(pACB->psim,/*free_devq*/TRUE);
2408 printf("arcmsr%d: xpt_bus_register failure!\n",unit);
2409 return ENXIO;
2410 }
2411 if(xpt_create_path(&pACB->ppath,/* periph */ NULL,cam_sim_path(pACB->psim),CAM_TARGET_WILDCARD,CAM_LUN_WILDCARD) != CAM_REQ_CMP)
2412 {
2413 arcmsr_free_resource(pACB);
2414 bus_release_resource(dev, SYS_RES_IRQ, 0, pACB->irqres);
2415 xpt_bus_deregister(cam_sim_path(pACB->psim));
2416 cam_sim_free(pACB->psim,/* free_simq */ TRUE);
2417 printf("arcmsr%d: xpt_create_path failure!\n",unit);
2418 return ENXIO;
2419 }
2420 /*
2421 ****************************************************
2422 */
2423 xpt_setup_ccb(&csa.ccb_h,pACB->ppath,/*priority*/5);
2424 csa.ccb_h.func_code=XPT_SASYNC_CB;
2425 csa.event_enable=AC_FOUND_DEVICE|AC_LOST_DEVICE;
2426 csa.callback=arcmsr_async;
2427 csa.callback_arg=pACB->psim;
2428 xpt_action((union ccb *)&csa);
2429 /* Create the control device. */
2430 pACB->ioctl_dev=make_dev(&arcmsr_cdevsw, unit, UID_ROOT, GID_WHEEL /* GID_OPERATOR */, S_IRUSR | S_IWUSR, "arcmsr%d", unit);
2431 #if __FreeBSD_version < 503000
2432 pACB->ioctl_dev->si_drv1=pACB;
2433 #endif
2434 #if __FreeBSD_version > 500005
2435 (void)make_dev_alias(pACB->ioctl_dev, "arc%d", unit);
2436 #endif
2437 return 0;
2438 }
2439 /*
2440 ************************************************************************
2441 **
2442 **
2443 **
2444 ************************************************************************
2445 */
2446 static u_int32_t arcmsr_probe(device_t dev)
2447 {
2448 u_int32_t id;
2449
2450 switch(id=pci_get_devid(dev))
2451 {
2452 case PCIDevVenIDARC1110:
2453 device_set_desc(dev,"ARECA ARC1110 PCI-X 4 PORTS SATA RAID CONTROLLER \n" ARCMSR_DRIVER_VERSION );
2454 return 0;
2455 case PCIDevVenIDARC1120:
2456 device_set_desc(dev,"ARECA ARC1120 PCI-X 8 PORTS SATA RAID CONTROLLER (RAID6-ENGINE Inside) \n" ARCMSR_DRIVER_VERSION);
2457 return 0;
2458 case PCIDevVenIDARC1130:
2459 device_set_desc(dev,"ARECA ARC1130 PCI-X 12 PORTS SATA RAID CONTROLLER (RAID6-ENGINE Inside) \n" ARCMSR_DRIVER_VERSION);
2460 return 0;
2461 case PCIDevVenIDARC1160:
2462 device_set_desc(dev,"ARECA ARC1160 PCI-X 16 PORTS SATA RAID CONTROLLER (RAID6-ENGINE Inside) \n" ARCMSR_DRIVER_VERSION);
2463 return 0;
2464 case PCIDevVenIDARC1170:
2465 device_set_desc(dev,"ARECA ARC1170 PCI-X 24 PORTS SATA RAID CONTROLLER (RAID6-ENGINE Inside) \n" ARCMSR_DRIVER_VERSION);
2466 return 0;
2467 case PCIDevVenIDARC1210:
2468 device_set_desc(dev,"ARECA ARC1210 PCI-EXPRESS 4 PORTS SATA RAID CONTROLLER \n" ARCMSR_DRIVER_VERSION);
2469 return 0;
2470 case PCIDevVenIDARC1220:
2471 device_set_desc(dev,"ARECA ARC1220 PCI-EXPRESS 8 PORTS SATA RAID CONTROLLER (RAID6-ENGINE Inside) \n" ARCMSR_DRIVER_VERSION);
2472 return 0;
2473 case PCIDevVenIDARC1230:
2474 device_set_desc(dev,"ARECA ARC1230 PCI-EXPRESS 12 PORTS SATA RAID CONTROLLER (RAID6-ENGINE Inside) \n" ARCMSR_DRIVER_VERSION);
2475 return 0;
2476 case PCIDevVenIDARC1260:
2477 device_set_desc(dev,"ARECA ARC1260 PCI-EXPRESS 16 PORTS SATA RAID CONTROLLER (RAID6-ENGINE Inside) \n" ARCMSR_DRIVER_VERSION);
2478 case PCIDevVenIDARC1270:
2479 device_set_desc(dev,"ARECA ARC1270 PCI-EXPRESS 24 PORTS SATA RAID CONTROLLER (RAID6-ENGINE Inside) \n" ARCMSR_DRIVER_VERSION);
2480 return 0;
2481 }
2482 return ENXIO;
2483 }
2484 /*
2485 ************************************************************************
2486 **
2487 **
2488 **
2489 ************************************************************************
2490 */
2491 static void arcmsr_shutdown(device_t dev)
2492 {
2493 u_int32_t i,poll_count=0;
2494 u_int32_t s,intmask_org;
2495 struct _SRB * pSRB;
2496 struct _ACB * pACB=(struct _ACB *)device_get_softc(dev);
2497
2498 s=splcam();
2499 /* disable all outbound interrupt */
2500 intmask_org=readl(&pACB->pmu->outbound_intmask);
2501 writel(&pACB->pmu->outbound_intmask,(intmask_org|ARCMSR_MU_OUTBOUND_ALL_INTMASKENABLE));
2502 /* stop adapter background rebuild */
2503 arcmsr_stop_adapter_bgrb(pACB);
2504 if(arcmsr_wait_msgint_ready(pACB))
2505 {
2506 printf("arcmsr%d: shutdown wait 'stop adapter rebulid' timeout \n",pACB->pci_unit);
2507 }
2508 arcmsr_flush_adapter_cache(pACB);
2509 if(arcmsr_wait_msgint_ready(pACB))
2510 {
2511 printf("arcmsr%d: shutdown wait 'flush adapter cache' timeout \n",pACB->pci_unit);
2512 }
2513 /* abort all outstanding command */
2514 pACB->acb_flags |= ACB_F_SCSISTOPADAPTER;
2515 pACB->acb_flags &= ~ACB_F_IOP_INITED;
2516 if(pACB->srboutstandingcount!=0)
2517 {
2518 while((pACB->srboutstandingcount!=0) && (poll_count < 256))
2519 {
2520 arcmsr_interrupt((void *)pACB);
2521 UDELAY(25000);
2522 poll_count++;
2523 }
2524 if(pACB->srboutstandingcount!=0)
2525 {
2526 printf("arcmsr%d: shutdown srboutstandingcount!=0 \n",pACB->pci_unit);
2527 arcmsr_abort_allcmd(pACB);
2528 if(arcmsr_wait_msgint_ready(pACB))
2529 {
2530 printf("arcmsr%d: shutdown wait 'abort all outstanding command' timeout \n",pACB->pci_unit);
2531 }
2532 for(i=0;i<ARCMSR_MAX_FREESRB_NUM;i++)
2533 {
2534 pSRB=pACB->psrb_pool[i];
2535 if(pSRB->startdone==ARCMSR_SRB_START)
2536 {
2537 pSRB->startdone=ARCMSR_SRB_ABORTED;
2538 pSRB->pccb->ccb_h.status=CAM_REQ_ABORTED;
2539 arcmsr_srb_complete(pSRB);
2540 }
2541 }
2542 }
2543 }
2544 if(pACB->srbwait2gocount!=0)
2545 { /*remove first wait2go srb and abort it*/
2546 for(i=0;i<ARCMSR_MAX_OUTSTANDING_CMD;i++)
2547 {
2548 pSRB=pACB->psrbwait2go[i];
2549 if(pSRB!=NULL)
2550 {
2551 pACB->psrbwait2go[i]=NULL;
2552 pSRB->startdone=ARCMSR_SRB_ABORTED;
2553 pSRB->pccb->ccb_h.status=CAM_REQ_ABORTED;
2554 arcmsr_srb_complete(pSRB);
2555 atomic_subtract_int(&pACB->srbwait2gocount,1);
2556 }
2557 }
2558 }
2559 atomic_set_int(&pACB->srboutstandingcount,0);
2560 splx(s);
2561 return;
2562 }
2563 /*
2564 ************************************************************************
2565 **
2566 **
2567 **
2568 ************************************************************************
2569 */
2570 static u_int32_t arcmsr_detach(device_t dev)
2571 {
2572 struct _ACB * pACB=(struct _ACB *)device_get_softc(dev);
2573
2574 arcmsr_shutdown(dev);
2575 arcmsr_free_resource(pACB);
2576 bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(0), pACB->sys_res_arcmsr);
2577 bus_teardown_intr(dev, pACB->irqres, pACB->ih);
2578 bus_release_resource(dev, SYS_RES_IRQ, 0, pACB->irqres);
2579 xpt_async(AC_LOST_DEVICE, pACB->ppath, NULL);
2580 xpt_free_path(pACB->ppath);
2581 xpt_bus_deregister(cam_sim_path(pACB->psim));
2582 cam_sim_free(pACB->psim, TRUE);
2583 return (0);
2584 }
2585
2586
2587
Cache object: 8778936d2bb6b62b304f812af58a5feb
|