2 * SuperTrak EX Series Storage Controller driver for Linux
4 * Copyright (C) 2005, 2006 Promise Technology Inc.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 * Ed Lin <promise_linux@promise.com>
18 #include <linux/init.h>
19 #include <linux/errno.h>
20 #include <linux/kernel.h>
21 #include <linux/delay.h>
22 #include <linux/sched.h>
23 #include <linux/time.h>
24 #include <linux/pci.h>
25 #include <linux/blkdev.h>
26 #include <linux/interrupt.h>
27 #include <linux/types.h>
28 #include <linux/module.h>
29 #include <linux/spinlock.h>
32 #include <asm/byteorder.h>
33 #include <scsi/scsi.h>
34 #include <scsi/scsi_device.h>
35 #include <scsi/scsi_cmnd.h>
36 #include <scsi/scsi_host.h>
37 #include <scsi/scsi_tcq.h>
39 #define DRV_NAME "stex"
40 #define ST_DRIVER_VERSION "3.0.0.1"
41 #define ST_VER_MAJOR 3
42 #define ST_VER_MINOR 0
44 #define ST_BUILD_VER 1
47 /* MU register offset */
48 IMR0
= 0x10, /* MU_INBOUND_MESSAGE_REG0 */
49 IMR1
= 0x14, /* MU_INBOUND_MESSAGE_REG1 */
50 OMR0
= 0x18, /* MU_OUTBOUND_MESSAGE_REG0 */
51 OMR1
= 0x1c, /* MU_OUTBOUND_MESSAGE_REG1 */
52 IDBL
= 0x20, /* MU_INBOUND_DOORBELL */
53 IIS
= 0x24, /* MU_INBOUND_INTERRUPT_STATUS */
54 IIM
= 0x28, /* MU_INBOUND_INTERRUPT_MASK */
55 ODBL
= 0x2c, /* MU_OUTBOUND_DOORBELL */
56 OIS
= 0x30, /* MU_OUTBOUND_INTERRUPT_STATUS */
57 OIM
= 0x3c, /* MU_OUTBOUND_INTERRUPT_MASK */
59 /* MU register value */
60 MU_INBOUND_DOORBELL_HANDSHAKE
= 1,
61 MU_INBOUND_DOORBELL_REQHEADCHANGED
= 2,
62 MU_INBOUND_DOORBELL_STATUSTAILCHANGED
= 4,
63 MU_INBOUND_DOORBELL_HMUSTOPPED
= 8,
64 MU_INBOUND_DOORBELL_RESET
= 16,
66 MU_OUTBOUND_DOORBELL_HANDSHAKE
= 1,
67 MU_OUTBOUND_DOORBELL_REQUESTTAILCHANGED
= 2,
68 MU_OUTBOUND_DOORBELL_STATUSHEADCHANGED
= 4,
69 MU_OUTBOUND_DOORBELL_BUSCHANGE
= 8,
70 MU_OUTBOUND_DOORBELL_HASEVENT
= 16,
73 MU_STATE_STARTING
= 1,
74 MU_STATE_FMU_READY_FOR_HANDSHAKE
= 2,
75 MU_STATE_SEND_HANDSHAKE_FRAME
= 3,
77 MU_STATE_RESETTING
= 5,
80 MU_HANDSHAKE_SIGNATURE
= 0x55aaaa55,
81 MU_HANDSHAKE_SIGNATURE_HALF
= 0x5a5a0000,
82 MU_HARD_RESET_WAIT
= 30000,
85 /* firmware returned values */
86 SRB_STATUS_SUCCESS
= 0x01,
87 SRB_STATUS_ERROR
= 0x04,
88 SRB_STATUS_BUSY
= 0x05,
89 SRB_STATUS_INVALID_REQUEST
= 0x06,
90 SRB_STATUS_SELECTION_TIMEOUT
= 0x0A,
94 TASK_ATTRIBUTE_SIMPLE
= 0x0,
95 TASK_ATTRIBUTE_HEADOFQUEUE
= 0x1,
96 TASK_ATTRIBUTE_ORDERED
= 0x2,
97 TASK_ATTRIBUTE_ACA
= 0x4,
99 /* request count, etc. */
102 /* one message wasted, use MU_MAX_REQUEST+1
103 to handle MU_MAX_REQUEST messages */
104 MU_REQ_COUNT
= (MU_MAX_REQUEST
+ 1),
105 MU_STATUS_COUNT
= (MU_MAX_REQUEST
+ 1),
107 STEX_CDB_LENGTH
= MAX_COMMAND_SIZE
,
108 REQ_VARIABLE_LEN
= 1024,
109 STATUS_VAR_LEN
= 128,
110 ST_CAN_QUEUE
= MU_MAX_REQUEST
,
111 ST_CMD_PER_LUN
= MU_MAX_REQUEST
,
115 SG_CF_EOT
= 0x80, /* end of table */
116 SG_CF_64B
= 0x40, /* 64 bit item */
117 SG_CF_HOST
= 0x20, /* sg in host memory */
119 ST_MAX_ARRAY_SUPPORTED
= 16,
120 ST_MAX_TARGET_NUM
= (ST_MAX_ARRAY_SUPPORTED
+1),
121 ST_MAX_LUN_PER_TARGET
= 16,
128 PASSTHRU_REQ_TYPE
= 0x00000001,
129 PASSTHRU_REQ_NO_WAKEUP
= 0x00000100,
130 ST_INTERNAL_TIMEOUT
= 30,
135 /* vendor specific commands of Promise */
137 SINBAND_MGT_CMD
= 0xd9,
139 CONTROLLER_CMD
= 0xe1,
140 DEBUGGING_CMD
= 0xe2,
143 PASSTHRU_GET_ADAPTER
= 0x05,
144 PASSTHRU_GET_DRVVER
= 0x10,
146 CTLR_CONFIG_CMD
= 0x03,
147 CTLR_SHUTDOWN
= 0x0d,
149 CTLR_POWER_STATE_CHANGE
= 0x0e,
150 CTLR_POWER_SAVING
= 0x01,
152 PASSTHRU_SIGNATURE
= 0x4e415041,
153 MGT_CMD_SIGNATURE
= 0xba,
157 ST_ADDITIONAL_MEM
= 0x200000,
160 /* SCSI inquiry data */
161 typedef struct st_inq
{
163 u8 DeviceTypeQualifier
:3;
164 u8 DeviceTypeModifier
:7;
165 u8 RemovableMedia
:1;
167 u8 ResponseDataFormat
:4;
177 u8 LinkedCommands
:1;
181 u8 RelativeAddressing
:1;
184 u8 ProductRevisionLevel
[4];
185 u8 VendorSpecific
[20];
190 u8 ctrl
; /* SG_CF_xxx */
201 struct st_sgitem table
[ST_MAX_SG
];
204 struct handshake_frame
{
205 __le32 rb_phy
; /* request payload queue physical address */
207 __le16 req_sz
; /* size of each request payload */
208 __le16 req_cnt
; /* count of reqs the buffer can hold */
209 __le16 status_sz
; /* size of each status payload */
210 __le16 status_cnt
; /* count of status the buffer can hold */
211 __le32 hosttime
; /* seconds from Jan 1, 1970 (GMT) */
213 u8 partner_type
; /* who sends this frame */
215 __le32 partner_ver_major
;
216 __le32 partner_ver_minor
;
217 __le32 partner_ver_oem
;
218 __le32 partner_ver_build
;
219 __le32 extra_offset
; /* NEW */
220 __le32 extra_size
; /* NEW */
231 u8 payload_sz
; /* payload size in 4-byte, not used */
232 u8 cdb
[STEX_CDB_LENGTH
];
233 u8 variable
[REQ_VARIABLE_LEN
];
243 u8 payload_sz
; /* payload size in 4-byte */
244 u8 variable
[STATUS_VAR_LEN
];
259 struct ver_info drv_ver
;
260 struct ver_info bios_ver
;
289 #define MU_REQ_BUFFER_SIZE (MU_REQ_COUNT * sizeof(struct req_msg))
290 #define MU_STATUS_BUFFER_SIZE (MU_STATUS_COUNT * sizeof(struct status_msg))
291 #define MU_BUFFER_SIZE (MU_REQ_BUFFER_SIZE + MU_STATUS_BUFFER_SIZE)
292 #define STEX_EXTRA_SIZE max(sizeof(struct st_frame), sizeof(ST_INQ))
293 #define STEX_BUFFER_SIZE (MU_BUFFER_SIZE + STEX_EXTRA_SIZE)
297 struct scsi_cmnd
*cmd
;
300 unsigned int sense_bufflen
;
309 void __iomem
*mmio_base
; /* iomapped PCI memory space */
311 dma_addr_t dma_handle
;
314 struct Scsi_Host
*host
;
315 struct pci_dev
*pdev
;
322 struct status_msg
*status_buffer
;
323 void *copy_buffer
; /* temp buffer for driver-handled commands */
324 struct st_ccb ccb
[MU_MAX_REQUEST
];
325 struct st_ccb
*wait_ccb
;
326 wait_queue_head_t waitq
;
328 unsigned int mu_status
;
331 unsigned int cardtype
;
334 static const char console_inq_page
[] =
336 0x03,0x00,0x03,0x03,0xFA,0x00,0x00,0x30,
337 0x50,0x72,0x6F,0x6D,0x69,0x73,0x65,0x20, /* "Promise " */
338 0x52,0x41,0x49,0x44,0x20,0x43,0x6F,0x6E, /* "RAID Con" */
339 0x73,0x6F,0x6C,0x65,0x20,0x20,0x20,0x20, /* "sole " */
340 0x31,0x2E,0x30,0x30,0x20,0x20,0x20,0x20, /* "1.00 " */
341 0x53,0x58,0x2F,0x52,0x53,0x41,0x46,0x2D, /* "SX/RSAF-" */
342 0x54,0x45,0x31,0x2E,0x30,0x30,0x20,0x20, /* "TE1.00 " */
343 0x0C,0x20,0x20,0x20,0x20,0x20,0x20,0x20
346 MODULE_AUTHOR("Ed Lin");
347 MODULE_DESCRIPTION("Promise Technology SuperTrak EX Controllers");
348 MODULE_LICENSE("GPL");
349 MODULE_VERSION(ST_DRIVER_VERSION
);
351 static void stex_gettime(__le32
*time
)
354 do_gettimeofday(&tv
);
356 *time
= cpu_to_le32(tv
.tv_sec
& 0xffffffff);
357 *(time
+ 1) = cpu_to_le32((tv
.tv_sec
>> 16) >> 16);
360 static struct status_msg
*stex_get_status(struct st_hba
*hba
)
362 struct status_msg
*status
=
363 hba
->status_buffer
+ hba
->status_tail
;
366 hba
->status_tail
%= MU_STATUS_COUNT
;
371 static void stex_set_sense(struct scsi_cmnd
*cmd
, u8 sk
, u8 asc
, u8 ascq
)
373 cmd
->result
= (DRIVER_SENSE
<< 24) | SAM_STAT_CHECK_CONDITION
;
375 cmd
->sense_buffer
[0] = 0x70; /* fixed format, current */
376 cmd
->sense_buffer
[2] = sk
;
377 cmd
->sense_buffer
[7] = 18 - 8; /* additional sense length */
378 cmd
->sense_buffer
[12] = asc
;
379 cmd
->sense_buffer
[13] = ascq
;
382 static void stex_invalid_field(struct scsi_cmnd
*cmd
,
383 void (*done
)(struct scsi_cmnd
*))
385 /* "Invalid field in cbd" */
386 stex_set_sense(cmd
, ILLEGAL_REQUEST
, 0x24, 0x0);
390 static struct req_msg
*stex_alloc_req(struct st_hba
*hba
)
392 struct req_msg
*req
= ((struct req_msg
*)hba
->dma_mem
) +
396 hba
->req_head
%= MU_REQ_COUNT
;
401 static int stex_map_sg(struct st_hba
*hba
,
402 struct req_msg
*req
, struct st_ccb
*ccb
)
404 struct pci_dev
*pdev
= hba
->pdev
;
405 struct scsi_cmnd
*cmd
;
406 dma_addr_t dma_handle
;
407 struct scatterlist
*src
;
408 struct st_sgtable
*dst
;
412 dst
= (struct st_sgtable
*)req
->variable
;
413 dst
->max_sg_count
= cpu_to_le16(ST_MAX_SG
);
414 dst
->sz_in_byte
= cpu_to_le32(cmd
->request_bufflen
);
419 src
= (struct scatterlist
*) cmd
->request_buffer
;
420 n_elem
= pci_map_sg(pdev
, src
,
421 cmd
->use_sg
, cmd
->sc_data_direction
);
425 ccb
->sg_count
= n_elem
;
426 dst
->sg_count
= cpu_to_le16((u16
)n_elem
);
428 for (i
= 0; i
< n_elem
; i
++, src
++) {
429 dst
->table
[i
].count
= cpu_to_le32((u32
)sg_dma_len(src
));
431 cpu_to_le32(sg_dma_address(src
) & 0xffffffff);
432 dst
->table
[i
].addr_hi
=
433 cpu_to_le32((sg_dma_address(src
) >> 16) >> 16);
434 dst
->table
[i
].ctrl
= SG_CF_64B
| SG_CF_HOST
;
436 dst
->table
[--i
].ctrl
|= SG_CF_EOT
;
440 dma_handle
= pci_map_single(pdev
, cmd
->request_buffer
,
441 cmd
->request_bufflen
, cmd
->sc_data_direction
);
442 cmd
->SCp
.dma_handle
= dma_handle
;
445 dst
->sg_count
= cpu_to_le16(1);
446 dst
->table
[0].addr
= cpu_to_le32(dma_handle
& 0xffffffff);
447 dst
->table
[0].addr_hi
= cpu_to_le32((dma_handle
>> 16) >> 16);
448 dst
->table
[0].count
= cpu_to_le32((u32
)cmd
->request_bufflen
);
449 dst
->table
[0].ctrl
= SG_CF_EOT
| SG_CF_64B
| SG_CF_HOST
;
454 static void stex_internal_copy(struct scsi_cmnd
*cmd
,
455 const void *src
, size_t *count
, int sg_count
, int direction
)
459 void *s
, *d
, *base
= NULL
;
460 if (*count
> cmd
->request_bufflen
)
461 *count
= cmd
->request_bufflen
;
467 size_t offset
= *count
- lcount
;
469 base
= scsi_kmap_atomic_sg(cmd
->request_buffer
,
470 sg_count
, &offset
, &len
);
477 d
= cmd
->request_buffer
;
479 if (direction
== ST_TO_CMD
)
486 scsi_kunmap_atomic_sg(base
);
490 static int stex_direct_copy(struct scsi_cmnd
*cmd
,
491 const void *src
, size_t count
)
493 struct st_hba
*hba
= (struct st_hba
*) &cmd
->device
->host
->hostdata
[0];
494 size_t cp_len
= count
;
498 n_elem
= pci_map_sg(hba
->pdev
, cmd
->request_buffer
,
499 cmd
->use_sg
, cmd
->sc_data_direction
);
504 stex_internal_copy(cmd
, src
, &cp_len
, n_elem
, ST_TO_CMD
);
507 pci_unmap_sg(hba
->pdev
, cmd
->request_buffer
,
508 cmd
->use_sg
, cmd
->sc_data_direction
);
509 return cp_len
== count
;
512 static void stex_controller_info(struct st_hba
*hba
, struct st_ccb
*ccb
)
515 size_t count
= sizeof(struct st_frame
);
517 p
= hba
->copy_buffer
;
518 stex_internal_copy(ccb
->cmd
, p
, &count
, ccb
->sg_count
, ST_FROM_CMD
);
519 memset(p
->base
, 0, sizeof(u32
)*6);
520 *(unsigned long *)(p
->base
) = pci_resource_start(hba
->pdev
, 0);
523 p
->drv_ver
.major
= ST_VER_MAJOR
;
524 p
->drv_ver
.minor
= ST_VER_MINOR
;
525 p
->drv_ver
.oem
= ST_OEM
;
526 p
->drv_ver
.build
= ST_BUILD_VER
;
528 p
->bus
= hba
->pdev
->bus
->number
;
529 p
->slot
= hba
->pdev
->devfn
;
531 p
->irq_vec
= hba
->pdev
->irq
;
532 p
->id
= hba
->pdev
->vendor
<< 16 | hba
->pdev
->device
;
534 hba
->pdev
->subsystem_vendor
<< 16 | hba
->pdev
->subsystem_device
;
536 stex_internal_copy(ccb
->cmd
, p
, &count
, ccb
->sg_count
, ST_TO_CMD
);
540 stex_send_cmd(struct st_hba
*hba
, struct req_msg
*req
, u16 tag
)
542 req
->tag
= cpu_to_le16(tag
);
543 req
->task_attr
= TASK_ATTRIBUTE_SIMPLE
;
544 req
->task_manage
= 0; /* not supported yet */
546 hba
->ccb
[tag
].req
= req
;
549 writel(hba
->req_head
, hba
->mmio_base
+ IMR0
);
550 writel(MU_INBOUND_DOORBELL_REQHEADCHANGED
, hba
->mmio_base
+ IDBL
);
551 readl(hba
->mmio_base
+ IDBL
); /* flush */
555 stex_slave_alloc(struct scsi_device
*sdev
)
557 /* Cheat: usually extracted from Inquiry data */
558 sdev
->tagged_supported
= 1;
560 scsi_activate_tcq(sdev
, sdev
->host
->can_queue
);
566 stex_slave_config(struct scsi_device
*sdev
)
568 sdev
->use_10_for_rw
= 1;
569 sdev
->use_10_for_ms
= 1;
570 sdev
->timeout
= 60 * HZ
;
571 sdev
->tagged_supported
= 1;
577 stex_slave_destroy(struct scsi_device
*sdev
)
579 scsi_deactivate_tcq(sdev
, 1);
583 stex_queuecommand(struct scsi_cmnd
*cmd
, void (* done
)(struct scsi_cmnd
*))
586 struct Scsi_Host
*host
;
590 host
= cmd
->device
->host
;
591 id
= cmd
->device
->id
;
592 lun
= cmd
->device
->channel
; /* firmware lun issue work around */
593 hba
= (struct st_hba
*) &host
->hostdata
[0];
595 switch (cmd
->cmnd
[0]) {
598 static char ms10_caching_page
[12] =
599 { 0, 0x12, 0, 0, 0, 0, 0, 0, 0x8, 0xa, 0x4, 0 };
601 page
= cmd
->cmnd
[2] & 0x3f;
602 if (page
== 0x8 || page
== 0x3f) {
603 stex_direct_copy(cmd
, ms10_caching_page
,
604 sizeof(ms10_caching_page
));
605 cmd
->result
= DID_OK
<< 16 | COMMAND_COMPLETE
<< 8;
608 stex_invalid_field(cmd
, done
);
612 if (id
!= ST_MAX_ARRAY_SUPPORTED
)
614 if (lun
== 0 && (cmd
->cmnd
[1] & INQUIRY_EVPD
) == 0) {
615 stex_direct_copy(cmd
, console_inq_page
,
616 sizeof(console_inq_page
));
617 cmd
->result
= DID_OK
<< 16 | COMMAND_COMPLETE
<< 8;
620 stex_invalid_field(cmd
, done
);
623 if (cmd
->cmnd
[1] == PASSTHRU_GET_DRVVER
) {
624 struct st_drvver ver
;
625 ver
.major
= ST_VER_MAJOR
;
626 ver
.minor
= ST_VER_MINOR
;
628 ver
.build
= ST_BUILD_VER
;
629 ver
.signature
[0] = PASSTHRU_SIGNATURE
;
630 ver
.console_id
= ST_MAX_ARRAY_SUPPORTED
;
631 ver
.host_no
= hba
->host
->host_no
;
632 cmd
->result
= stex_direct_copy(cmd
, &ver
, sizeof(ver
)) ?
633 DID_OK
<< 16 | COMMAND_COMPLETE
<< 8 :
634 DID_ERROR
<< 16 | COMMAND_COMPLETE
<< 8;
642 cmd
->scsi_done
= done
;
644 tag
= cmd
->request
->tag
;
646 if (unlikely(tag
>= host
->can_queue
))
647 return SCSI_MLQUEUE_HOST_BUSY
;
649 req
= stex_alloc_req(hba
);
651 if (hba
->cardtype
== st_yosemite
) {
652 req
->lun
= lun
* (ST_MAX_TARGET_NUM
- 1) + id
;
660 memcpy(req
->cdb
, cmd
->cmnd
, STEX_CDB_LENGTH
);
662 hba
->ccb
[tag
].cmd
= cmd
;
663 hba
->ccb
[tag
].sense_bufflen
= SCSI_SENSE_BUFFERSIZE
;
664 hba
->ccb
[tag
].sense_buffer
= cmd
->sense_buffer
;
665 hba
->ccb
[tag
].req_type
= 0;
667 if (cmd
->sc_data_direction
!= DMA_NONE
)
668 stex_map_sg(hba
, req
, &hba
->ccb
[tag
]);
670 stex_send_cmd(hba
, req
, tag
);
674 static void stex_unmap_sg(struct st_hba
*hba
, struct scsi_cmnd
*cmd
)
676 if (cmd
->sc_data_direction
!= DMA_NONE
) {
678 pci_unmap_sg(hba
->pdev
, cmd
->request_buffer
,
679 cmd
->use_sg
, cmd
->sc_data_direction
);
681 pci_unmap_single(hba
->pdev
, cmd
->SCp
.dma_handle
,
682 cmd
->request_bufflen
, cmd
->sc_data_direction
);
686 static void stex_scsi_done(struct st_ccb
*ccb
)
688 struct scsi_cmnd
*cmd
= ccb
->cmd
;
691 if (ccb
->srb_status
== SRB_STATUS_SUCCESS
|| ccb
->srb_status
== 0) {
692 result
= ccb
->scsi_status
;
693 switch (ccb
->scsi_status
) {
695 result
|= DID_OK
<< 16 | COMMAND_COMPLETE
<< 8;
697 case SAM_STAT_CHECK_CONDITION
:
698 result
|= DRIVER_SENSE
<< 24;
701 result
|= DID_BUS_BUSY
<< 16 | COMMAND_COMPLETE
<< 8;
704 result
|= DID_ERROR
<< 16 | COMMAND_COMPLETE
<< 8;
708 else if (ccb
->srb_status
& SRB_SEE_SENSE
)
709 result
= DRIVER_SENSE
<< 24 | SAM_STAT_CHECK_CONDITION
;
710 else switch (ccb
->srb_status
) {
711 case SRB_STATUS_SELECTION_TIMEOUT
:
712 result
= DID_NO_CONNECT
<< 16 | COMMAND_COMPLETE
<< 8;
714 case SRB_STATUS_BUSY
:
715 result
= DID_BUS_BUSY
<< 16 | COMMAND_COMPLETE
<< 8;
717 case SRB_STATUS_INVALID_REQUEST
:
718 case SRB_STATUS_ERROR
:
720 result
= DID_ERROR
<< 16 | COMMAND_COMPLETE
<< 8;
724 cmd
->result
= result
;
728 static void stex_copy_data(struct st_ccb
*ccb
,
729 struct status_msg
*resp
, unsigned int variable
)
731 size_t count
= variable
;
732 if (resp
->scsi_status
!= SAM_STAT_GOOD
) {
733 if (ccb
->sense_buffer
!= NULL
)
734 memcpy(ccb
->sense_buffer
, resp
->variable
,
735 min(variable
, ccb
->sense_bufflen
));
739 if (ccb
->cmd
== NULL
)
741 stex_internal_copy(ccb
->cmd
,
742 resp
->variable
, &count
, ccb
->sg_count
, ST_TO_CMD
);
745 static void stex_ys_commands(struct st_hba
*hba
,
746 struct st_ccb
*ccb
, struct status_msg
*resp
)
750 if (ccb
->cmd
->cmnd
[0] == MGT_CMD
&&
751 resp
->scsi_status
!= SAM_STAT_CHECK_CONDITION
) {
752 ccb
->cmd
->request_bufflen
=
753 le32_to_cpu(*(__le32
*)&resp
->variable
[0]);
757 if (resp
->srb_status
!= 0)
760 /* determine inquiry command status by DeviceTypeQualifier */
761 if (ccb
->cmd
->cmnd
[0] == INQUIRY
&&
762 resp
->scsi_status
== SAM_STAT_GOOD
) {
765 count
= STEX_EXTRA_SIZE
;
766 stex_internal_copy(ccb
->cmd
, hba
->copy_buffer
,
767 &count
, ccb
->sg_count
, ST_FROM_CMD
);
768 inq_data
= (ST_INQ
*)hba
->copy_buffer
;
769 if (inq_data
->DeviceTypeQualifier
!= 0)
770 ccb
->srb_status
= SRB_STATUS_SELECTION_TIMEOUT
;
772 ccb
->srb_status
= SRB_STATUS_SUCCESS
;
773 } else if (ccb
->cmd
->cmnd
[0] == REPORT_LUNS
) {
774 u8
*report_lun_data
= (u8
*)hba
->copy_buffer
;
776 count
= STEX_EXTRA_SIZE
;
777 stex_internal_copy(ccb
->cmd
, report_lun_data
,
778 &count
, ccb
->sg_count
, ST_FROM_CMD
);
779 if (report_lun_data
[2] || report_lun_data
[3]) {
780 report_lun_data
[2] = 0x00;
781 report_lun_data
[3] = 0x08;
782 stex_internal_copy(ccb
->cmd
, report_lun_data
,
783 &count
, ccb
->sg_count
, ST_TO_CMD
);
788 static void stex_mu_intr(struct st_hba
*hba
, u32 doorbell
)
790 void __iomem
*base
= hba
->mmio_base
;
791 struct status_msg
*resp
;
796 if (!(doorbell
& MU_OUTBOUND_DOORBELL_STATUSHEADCHANGED
))
799 /* status payloads */
800 hba
->status_head
= readl(base
+ OMR1
);
801 if (unlikely(hba
->status_head
>= MU_STATUS_COUNT
)) {
802 printk(KERN_WARNING DRV_NAME
"(%s): invalid status head\n",
803 pci_name(hba
->pdev
));
808 * it's not a valid status payload if:
809 * 1. there are no pending requests(e.g. during init stage)
810 * 2. there are some pending requests, but the controller is in
811 * reset status, and its type is not st_yosemite
812 * firmware of st_yosemite in reset status will return pending requests
813 * to driver, so we allow it to pass
815 if (unlikely(hba
->out_req_cnt
<= 0 ||
816 (hba
->mu_status
== MU_STATE_RESETTING
&&
817 hba
->cardtype
!= st_yosemite
))) {
818 hba
->status_tail
= hba
->status_head
;
822 while (hba
->status_tail
!= hba
->status_head
) {
823 resp
= stex_get_status(hba
);
824 tag
= le16_to_cpu(resp
->tag
);
825 if (unlikely(tag
>= hba
->host
->can_queue
)) {
826 printk(KERN_WARNING DRV_NAME
827 "(%s): invalid tag\n", pci_name(hba
->pdev
));
831 ccb
= &hba
->ccb
[tag
];
832 if (hba
->wait_ccb
== ccb
)
833 hba
->wait_ccb
= NULL
;
834 if (unlikely(ccb
->req
== NULL
)) {
835 printk(KERN_WARNING DRV_NAME
836 "(%s): lagging req\n", pci_name(hba
->pdev
));
841 size
= resp
->payload_sz
* sizeof(u32
); /* payload size */
842 if (unlikely(size
< sizeof(*resp
) - STATUS_VAR_LEN
||
843 size
> sizeof(*resp
))) {
844 printk(KERN_WARNING DRV_NAME
"(%s): bad status size\n",
845 pci_name(hba
->pdev
));
847 size
-= sizeof(*resp
) - STATUS_VAR_LEN
; /* copy size */
849 stex_copy_data(ccb
, resp
, size
);
852 ccb
->srb_status
= resp
->srb_status
;
853 ccb
->scsi_status
= resp
->scsi_status
;
855 if (likely(ccb
->cmd
!= NULL
)) {
856 if (hba
->cardtype
== st_yosemite
)
857 stex_ys_commands(hba
, ccb
, resp
);
859 if (unlikely(ccb
->cmd
->cmnd
[0] == PASSTHRU_CMD
&&
860 ccb
->cmd
->cmnd
[1] == PASSTHRU_GET_ADAPTER
))
861 stex_controller_info(hba
, ccb
);
863 stex_unmap_sg(hba
, ccb
->cmd
);
866 } else if (ccb
->req_type
& PASSTHRU_REQ_TYPE
) {
868 if (ccb
->req_type
& PASSTHRU_REQ_NO_WAKEUP
) {
873 if (waitqueue_active(&hba
->waitq
))
874 wake_up(&hba
->waitq
);
879 writel(hba
->status_head
, base
+ IMR1
);
880 readl(base
+ IMR1
); /* flush */
883 static irqreturn_t
stex_intr(int irq
, void *__hba
)
885 struct st_hba
*hba
= __hba
;
886 void __iomem
*base
= hba
->mmio_base
;
891 spin_lock_irqsave(hba
->host
->host_lock
, flags
);
893 data
= readl(base
+ ODBL
);
895 if (data
&& data
!= 0xffffffff) {
896 /* clear the interrupt */
897 writel(data
, base
+ ODBL
);
898 readl(base
+ ODBL
); /* flush */
899 stex_mu_intr(hba
, data
);
903 spin_unlock_irqrestore(hba
->host
->host_lock
, flags
);
905 return IRQ_RETVAL(handled
);
908 static int stex_handshake(struct st_hba
*hba
)
910 void __iomem
*base
= hba
->mmio_base
;
911 struct handshake_frame
*h
;
912 dma_addr_t status_phys
;
914 unsigned long before
;
916 if (readl(base
+ OMR0
) != MU_HANDSHAKE_SIGNATURE
) {
917 writel(MU_INBOUND_DOORBELL_HANDSHAKE
, base
+ IDBL
);
920 while (readl(base
+ OMR0
) != MU_HANDSHAKE_SIGNATURE
) {
921 if (time_after(jiffies
, before
+ MU_MAX_DELAY
* HZ
)) {
922 printk(KERN_ERR DRV_NAME
923 "(%s): no handshake signature\n",
924 pci_name(hba
->pdev
));
934 data
= readl(base
+ OMR1
);
935 if ((data
& 0xffff0000) == MU_HANDSHAKE_SIGNATURE_HALF
) {
937 if (hba
->host
->can_queue
> data
)
938 hba
->host
->can_queue
= data
;
941 h
= (struct handshake_frame
*)(hba
->dma_mem
+ MU_REQ_BUFFER_SIZE
);
942 h
->rb_phy
= cpu_to_le32(hba
->dma_handle
);
943 h
->rb_phy_hi
= cpu_to_le32((hba
->dma_handle
>> 16) >> 16);
944 h
->req_sz
= cpu_to_le16(sizeof(struct req_msg
));
945 h
->req_cnt
= cpu_to_le16(MU_REQ_COUNT
);
946 h
->status_sz
= cpu_to_le16(sizeof(struct status_msg
));
947 h
->status_cnt
= cpu_to_le16(MU_STATUS_COUNT
);
948 stex_gettime(&h
->hosttime
);
949 h
->partner_type
= HMU_PARTNER_TYPE
;
950 if (hba
->dma_size
> STEX_BUFFER_SIZE
) {
951 h
->extra_offset
= cpu_to_le32(STEX_BUFFER_SIZE
);
952 h
->extra_size
= cpu_to_le32(ST_ADDITIONAL_MEM
);
954 h
->extra_offset
= h
->extra_size
= 0;
956 status_phys
= hba
->dma_handle
+ MU_REQ_BUFFER_SIZE
;
957 writel(status_phys
, base
+ IMR0
);
959 writel((status_phys
>> 16) >> 16, base
+ IMR1
);
962 writel((status_phys
>> 16) >> 16, base
+ OMR0
); /* old fw compatible */
964 writel(MU_INBOUND_DOORBELL_HANDSHAKE
, base
+ IDBL
);
965 readl(base
+ IDBL
); /* flush */
969 while (readl(base
+ OMR0
) != MU_HANDSHAKE_SIGNATURE
) {
970 if (time_after(jiffies
, before
+ MU_MAX_DELAY
* HZ
)) {
971 printk(KERN_ERR DRV_NAME
972 "(%s): no signature after handshake frame\n",
973 pci_name(hba
->pdev
));
980 writel(0, base
+ IMR0
);
982 writel(0, base
+ OMR0
);
984 writel(0, base
+ IMR1
);
986 writel(0, base
+ OMR1
);
987 readl(base
+ OMR1
); /* flush */
988 hba
->mu_status
= MU_STATE_STARTED
;
992 static int stex_abort(struct scsi_cmnd
*cmd
)
994 struct Scsi_Host
*host
= cmd
->device
->host
;
995 struct st_hba
*hba
= (struct st_hba
*)host
->hostdata
;
996 u16 tag
= cmd
->request
->tag
;
999 int result
= SUCCESS
;
1000 unsigned long flags
;
1001 base
= hba
->mmio_base
;
1002 spin_lock_irqsave(host
->host_lock
, flags
);
1003 if (tag
< host
->can_queue
&& hba
->ccb
[tag
].cmd
== cmd
)
1004 hba
->wait_ccb
= &hba
->ccb
[tag
];
1006 for (tag
= 0; tag
< host
->can_queue
; tag
++)
1007 if (hba
->ccb
[tag
].cmd
== cmd
) {
1008 hba
->wait_ccb
= &hba
->ccb
[tag
];
1011 if (tag
>= host
->can_queue
)
1015 data
= readl(base
+ ODBL
);
1016 if (data
== 0 || data
== 0xffffffff)
1019 writel(data
, base
+ ODBL
);
1020 readl(base
+ ODBL
); /* flush */
1022 stex_mu_intr(hba
, data
);
1024 if (hba
->wait_ccb
== NULL
) {
1025 printk(KERN_WARNING DRV_NAME
1026 "(%s): lost interrupt\n", pci_name(hba
->pdev
));
1031 stex_unmap_sg(hba
, cmd
);
1032 hba
->wait_ccb
->req
= NULL
; /* nullify the req's future return */
1033 hba
->wait_ccb
= NULL
;
1036 spin_unlock_irqrestore(host
->host_lock
, flags
);
1040 static void stex_hard_reset(struct st_hba
*hba
)
1042 struct pci_bus
*bus
;
1047 for (i
= 0; i
< 16; i
++)
1048 pci_read_config_dword(hba
->pdev
, i
* 4,
1049 &hba
->pdev
->saved_config_space
[i
]);
1051 /* Reset secondary bus. Our controller(MU/ATU) is the only device on
1052 secondary bus. Consult Intel 80331/3 developer's manual for detail */
1053 bus
= hba
->pdev
->bus
;
1054 pci_read_config_byte(bus
->self
, PCI_BRIDGE_CONTROL
, &pci_bctl
);
1055 pci_bctl
|= PCI_BRIDGE_CTL_BUS_RESET
;
1056 pci_write_config_byte(bus
->self
, PCI_BRIDGE_CONTROL
, pci_bctl
);
1058 pci_bctl
&= ~PCI_BRIDGE_CTL_BUS_RESET
;
1059 pci_write_config_byte(bus
->self
, PCI_BRIDGE_CONTROL
, pci_bctl
);
1061 for (i
= 0; i
< MU_HARD_RESET_WAIT
; i
++) {
1062 pci_read_config_word(hba
->pdev
, PCI_COMMAND
, &pci_cmd
);
1063 if (pci_cmd
!= 0xffff && (pci_cmd
& PCI_COMMAND_MASTER
))
1069 for (i
= 0; i
< 16; i
++)
1070 pci_write_config_dword(hba
->pdev
, i
* 4,
1071 hba
->pdev
->saved_config_space
[i
]);
1074 static int stex_reset(struct scsi_cmnd
*cmd
)
1077 unsigned long flags
;
1078 unsigned long before
;
1079 hba
= (struct st_hba
*) &cmd
->device
->host
->hostdata
[0];
1081 hba
->mu_status
= MU_STATE_RESETTING
;
1083 if (hba
->cardtype
== st_shasta
)
1084 stex_hard_reset(hba
);
1086 if (hba
->cardtype
!= st_yosemite
) {
1087 if (stex_handshake(hba
)) {
1088 printk(KERN_WARNING DRV_NAME
1089 "(%s): resetting: handshake failed\n",
1090 pci_name(hba
->pdev
));
1093 spin_lock_irqsave(hba
->host
->host_lock
, flags
);
1096 hba
->status_head
= 0;
1097 hba
->status_tail
= 0;
1098 hba
->out_req_cnt
= 0;
1099 spin_unlock_irqrestore(hba
->host
->host_lock
, flags
);
1104 writel(MU_INBOUND_DOORBELL_RESET
, hba
->mmio_base
+ IDBL
);
1105 readl(hba
->mmio_base
+ IDBL
); /* flush */
1107 while (hba
->out_req_cnt
> 0) {
1108 if (time_after(jiffies
, before
+ ST_INTERNAL_TIMEOUT
* HZ
)) {
1109 printk(KERN_WARNING DRV_NAME
1110 "(%s): reset timeout\n", pci_name(hba
->pdev
));
1116 hba
->mu_status
= MU_STATE_STARTED
;
1120 static int stex_biosparam(struct scsi_device
*sdev
,
1121 struct block_device
*bdev
, sector_t capacity
, int geom
[])
1123 int heads
= 255, sectors
= 63;
1125 if (capacity
< 0x200000) {
1130 sector_div(capacity
, heads
* sectors
);
1139 static struct scsi_host_template driver_template
= {
1140 .module
= THIS_MODULE
,
1142 .proc_name
= DRV_NAME
,
1143 .bios_param
= stex_biosparam
,
1144 .queuecommand
= stex_queuecommand
,
1145 .slave_alloc
= stex_slave_alloc
,
1146 .slave_configure
= stex_slave_config
,
1147 .slave_destroy
= stex_slave_destroy
,
1148 .eh_abort_handler
= stex_abort
,
1149 .eh_host_reset_handler
= stex_reset
,
1150 .can_queue
= ST_CAN_QUEUE
,
1152 .sg_tablesize
= ST_MAX_SG
,
1153 .cmd_per_lun
= ST_CMD_PER_LUN
,
1156 static int stex_set_dma_mask(struct pci_dev
* pdev
)
1159 if (!pci_set_dma_mask(pdev
, DMA_64BIT_MASK
)
1160 && !pci_set_consistent_dma_mask(pdev
, DMA_64BIT_MASK
))
1162 ret
= pci_set_dma_mask(pdev
, DMA_32BIT_MASK
);
1164 ret
= pci_set_consistent_dma_mask(pdev
, DMA_32BIT_MASK
);
1168 static int __devinit
1169 stex_probe(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
1172 struct Scsi_Host
*host
;
1175 err
= pci_enable_device(pdev
);
1179 pci_set_master(pdev
);
1181 host
= scsi_host_alloc(&driver_template
, sizeof(struct st_hba
));
1184 printk(KERN_ERR DRV_NAME
"(%s): scsi_host_alloc failed\n",
1190 hba
= (struct st_hba
*)host
->hostdata
;
1191 memset(hba
, 0, sizeof(struct st_hba
));
1193 err
= pci_request_regions(pdev
, DRV_NAME
);
1195 printk(KERN_ERR DRV_NAME
"(%s): request regions failed\n",
1197 goto out_scsi_host_put
;
1200 hba
->mmio_base
= ioremap(pci_resource_start(pdev
, 0),
1201 pci_resource_len(pdev
, 0));
1202 if ( !hba
->mmio_base
) {
1203 printk(KERN_ERR DRV_NAME
"(%s): memory map failed\n",
1206 goto out_release_regions
;
1209 err
= stex_set_dma_mask(pdev
);
1211 printk(KERN_ERR DRV_NAME
"(%s): set dma mask failed\n",
1216 hba
->cardtype
= (unsigned int) id
->driver_data
;
1217 if (hba
->cardtype
== st_vsc
&& (pdev
->subsystem_device
& 0xf) == 0x1)
1218 hba
->cardtype
= st_vsc1
;
1219 hba
->dma_size
= (hba
->cardtype
== st_vsc1
) ?
1220 (STEX_BUFFER_SIZE
+ ST_ADDITIONAL_MEM
) : (STEX_BUFFER_SIZE
);
1221 hba
->dma_mem
= dma_alloc_coherent(&pdev
->dev
,
1222 hba
->dma_size
, &hba
->dma_handle
, GFP_KERNEL
);
1223 if (!hba
->dma_mem
) {
1225 printk(KERN_ERR DRV_NAME
"(%s): dma mem alloc failed\n",
1230 hba
->status_buffer
=
1231 (struct status_msg
*)(hba
->dma_mem
+ MU_REQ_BUFFER_SIZE
);
1232 hba
->copy_buffer
= hba
->dma_mem
+ MU_BUFFER_SIZE
;
1233 hba
->mu_status
= MU_STATE_STARTING
;
1235 /* firmware uses id/lun pair for a logical drive, but lun would be
1236 always 0 if CONFIG_SCSI_MULTI_LUN not configured, so we use
1237 channel to map lun here */
1238 host
->max_channel
= ST_MAX_LUN_PER_TARGET
- 1;
1239 host
->max_id
= ST_MAX_TARGET_NUM
;
1241 host
->unique_id
= host
->host_no
;
1242 host
->max_cmd_len
= STEX_CDB_LENGTH
;
1246 init_waitqueue_head(&hba
->waitq
);
1248 err
= request_irq(pdev
->irq
, stex_intr
, IRQF_SHARED
, DRV_NAME
, hba
);
1250 printk(KERN_ERR DRV_NAME
"(%s): request irq failed\n",
1255 err
= stex_handshake(hba
);
1259 err
= scsi_init_shared_tag_map(host
, host
->can_queue
);
1261 printk(KERN_ERR DRV_NAME
"(%s): init shared queue failed\n",
1266 pci_set_drvdata(pdev
, hba
);
1268 err
= scsi_add_host(host
, &pdev
->dev
);
1270 printk(KERN_ERR DRV_NAME
"(%s): scsi_add_host failed\n",
1275 scsi_scan_host(host
);
1280 free_irq(pdev
->irq
, hba
);
1282 dma_free_coherent(&pdev
->dev
, hba
->dma_size
,
1283 hba
->dma_mem
, hba
->dma_handle
);
1285 iounmap(hba
->mmio_base
);
1286 out_release_regions
:
1287 pci_release_regions(pdev
);
1289 scsi_host_put(host
);
1291 pci_disable_device(pdev
);
1296 static void stex_hba_stop(struct st_hba
*hba
)
1298 struct req_msg
*req
;
1299 unsigned long flags
;
1300 unsigned long before
;
1303 spin_lock_irqsave(hba
->host
->host_lock
, flags
);
1304 req
= stex_alloc_req(hba
);
1305 memset(req
->cdb
, 0, STEX_CDB_LENGTH
);
1307 if (hba
->cardtype
== st_yosemite
) {
1308 req
->cdb
[0] = MGT_CMD
;
1309 req
->cdb
[1] = MGT_CMD_SIGNATURE
;
1310 req
->cdb
[2] = CTLR_CONFIG_CMD
;
1311 req
->cdb
[3] = CTLR_SHUTDOWN
;
1313 req
->cdb
[0] = CONTROLLER_CMD
;
1314 req
->cdb
[1] = CTLR_POWER_STATE_CHANGE
;
1315 req
->cdb
[2] = CTLR_POWER_SAVING
;
1318 hba
->ccb
[tag
].cmd
= NULL
;
1319 hba
->ccb
[tag
].sg_count
= 0;
1320 hba
->ccb
[tag
].sense_bufflen
= 0;
1321 hba
->ccb
[tag
].sense_buffer
= NULL
;
1322 hba
->ccb
[tag
].req_type
|= PASSTHRU_REQ_TYPE
;
1324 stex_send_cmd(hba
, req
, tag
);
1325 spin_unlock_irqrestore(hba
->host
->host_lock
, flags
);
1328 while (hba
->ccb
[tag
].req_type
& PASSTHRU_REQ_TYPE
) {
1329 if (time_after(jiffies
, before
+ ST_INTERNAL_TIMEOUT
* HZ
))
1335 static void stex_hba_free(struct st_hba
*hba
)
1337 free_irq(hba
->pdev
->irq
, hba
);
1339 iounmap(hba
->mmio_base
);
1341 pci_release_regions(hba
->pdev
);
1343 dma_free_coherent(&hba
->pdev
->dev
, hba
->dma_size
,
1344 hba
->dma_mem
, hba
->dma_handle
);
1347 static void stex_remove(struct pci_dev
*pdev
)
1349 struct st_hba
*hba
= pci_get_drvdata(pdev
);
1351 scsi_remove_host(hba
->host
);
1353 pci_set_drvdata(pdev
, NULL
);
1359 scsi_host_put(hba
->host
);
1361 pci_disable_device(pdev
);
1364 static void stex_shutdown(struct pci_dev
*pdev
)
1366 struct st_hba
*hba
= pci_get_drvdata(pdev
);
1371 static struct pci_device_id stex_pci_tbl
[] = {
1373 { 0x105a, 0x8350, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
1374 st_shasta
}, /* SuperTrak EX8350/8300/16350/16300 */
1375 { 0x105a, 0xc350, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
1376 st_shasta
}, /* SuperTrak EX12350 */
1377 { 0x105a, 0x4302, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
1378 st_shasta
}, /* SuperTrak EX4350 */
1379 { 0x105a, 0xe350, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
1380 st_shasta
}, /* SuperTrak EX24350 */
1383 { 0x105a, 0x7250, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, st_vsc
},
1386 { 0x105a, 0x8650, PCI_ANY_ID
, 0x4600, 0, 0,
1387 st_yosemite
}, /* SuperTrak EX4650 */
1388 { 0x105a, 0x8650, PCI_ANY_ID
, 0x4610, 0, 0,
1389 st_yosemite
}, /* SuperTrak EX4650o */
1390 { 0x105a, 0x8650, PCI_ANY_ID
, 0x8600, 0, 0,
1391 st_yosemite
}, /* SuperTrak EX8650EL */
1392 { 0x105a, 0x8650, PCI_ANY_ID
, 0x8601, 0, 0,
1393 st_yosemite
}, /* SuperTrak EX8650 */
1394 { 0x105a, 0x8650, PCI_ANY_ID
, 0x8602, 0, 0,
1395 st_yosemite
}, /* SuperTrak EX8654 */
1396 { 0x105a, 0x8650, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
1397 st_yosemite
}, /* generic st_yosemite */
1398 { } /* terminate list */
1400 MODULE_DEVICE_TABLE(pci
, stex_pci_tbl
);
1402 static struct pci_driver stex_pci_driver
= {
1404 .id_table
= stex_pci_tbl
,
1405 .probe
= stex_probe
,
1406 .remove
= __devexit_p(stex_remove
),
1407 .shutdown
= stex_shutdown
,
1410 static int __init
stex_init(void)
1412 printk(KERN_INFO DRV_NAME
1413 ": Promise SuperTrak EX Driver version: %s\n",
1416 return pci_register_driver(&stex_pci_driver
);
1419 static void __exit
stex_exit(void)
1421 pci_unregister_driver(&stex_pci_driver
);
1424 module_init(stex_init
);
1425 module_exit(stex_exit
);