2 mvsas.c - Marvell 88SE6440 SAS/SATA support
4 Copyright 2007 Red Hat, 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 as
8 published by the Free Software Foundation; either version 2,
9 or (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty
13 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 See the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public
17 License along with this program; see the file COPYING. If not,
18 write to the Free Software Foundation, 675 Mass Ave, Cambridge,
21 ---------------------------------------------------------------
24 * hardware supports controlling the endian-ness of data
25 structures. this permits elimination of all the le32_to_cpu()
26 and cpu_to_le32() conversions.
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/pci.h>
33 #include <linux/interrupt.h>
34 #include <linux/spinlock.h>
35 #include <linux/delay.h>
36 #include <linux/dma-mapping.h>
37 #include <scsi/libsas.h>
40 #define DRV_NAME "mvsas"
41 #define DRV_VERSION "0.1"
43 #define mr32(reg) readl(regs + MVS_##reg)
44 #define mw32(reg,val) writel((val), regs + MVS_##reg)
45 #define mw32_f(reg,val) do { \
46 writel((val), regs + MVS_##reg); \
47 readl(regs + MVS_##reg); \
50 /* driver compile-time configuration */
51 enum driver_configuration {
52 MVS_TX_RING_SZ = 1024, /* TX ring size (12-bit) */
53 MVS_RX_RING_SZ = 1024, /* RX ring size (12-bit) */
54 /* software requires power-of-2
57 MVS_SLOTS = 512, /* command slots */
58 MVS_SLOT_BUF_SZ = 8192, /* cmd tbl + IU + status + PRD */
59 MVS_SSP_CMD_SZ = 64, /* SSP command table buffer size */
60 MVS_ATA_CMD_SZ = 128, /* SATA command table buffer size */
61 MVS_OAF_SZ = 64, /* Open address frame buffer size */
63 MVS_RX_FIS_COUNT = 17, /* Optional rx'd FISs (max 17) */
66 /* unchangeable hardware details */
67 enum hardware_details {
68 MVS_MAX_PHYS = 8, /* max. possible phys */
69 MVS_MAX_PORTS = 8, /* max. possible ports */
70 MVS_RX_FISL_SZ = 0x400 + (MVS_RX_FIS_COUNT * 0x100),
73 /* peripheral registers (BAR2) */
74 enum peripheral_registers {
75 SPI_CTL = 0x10, /* EEPROM control */
76 SPI_CMD = 0x14, /* EEPROM command */
77 SPI_DATA = 0x18, /* EEPROM data */
80 enum peripheral_register_bits {
81 TWSI_RDY = (1U << 7), /* EEPROM interface ready */
82 TWSI_RD = (1U << 4), /* EEPROM read access */
84 SPI_ADDR_MASK = 0x3ffff, /* bits 17:0 */
87 /* enhanced mode registers (BAR4) */
89 MVS_GBL_CTL = 0x04, /* global control */
90 MVS_GBL_INT_STAT = 0x08, /* global irq status */
91 MVS_GBL_PI = 0x0C, /* ports implemented bitmask */
92 MVS_GBL_PORT_TYPE = 0x00, /* port type */
94 MVS_CTL = 0x100, /* SAS/SATA port configuration */
95 MVS_PCS = 0x104, /* SAS/SATA port control/status */
96 MVS_CMD_LIST_LO = 0x108, /* cmd list addr */
97 MVS_CMD_LIST_HI = 0x10C,
98 MVS_RX_FIS_LO = 0x110, /* RX FIS list addr */
99 MVS_RX_FIS_HI = 0x114,
101 MVS_TX_CFG = 0x120, /* TX configuration */
102 MVS_TX_LO = 0x124, /* TX (delivery) ring addr */
105 MVS_RX_PROD_IDX = 0x12C, /* RX producer pointer */
106 MVS_RX_CONS_IDX = 0x130, /* RX consumer pointer (RO) */
107 MVS_RX_CFG = 0x134, /* RX configuration */
108 MVS_RX_LO = 0x138, /* RX (completion) ring addr */
111 MVS_INT_COAL = 0x148, /* Int coalescing config */
112 MVS_INT_COAL_TMOUT = 0x14C, /* Int coalescing timeout */
113 MVS_INT_STAT = 0x150, /* Central int status */
114 MVS_INT_MASK = 0x154, /* Central int enable */
115 MVS_INT_STAT_SRS = 0x158, /* SATA register set status */
117 /* ports 1-3 follow after this */
118 MVS_P0_INT_STAT = 0x160, /* port0 interrupt status */
119 MVS_P0_INT_MASK = 0x164, /* port0 interrupt mask */
121 /* ports 1-3 follow after this */
122 MVS_P0_SER_CTLSTAT = 0x180, /* port0 serial control/status */
124 MVS_CMD_ADDR = 0x1B8, /* Command register port (addr) */
125 MVS_CMD_DATA = 0x1BC, /* Command register port (data) */
127 /* ports 1-3 follow after this */
128 MVS_P0_CFG_ADDR = 0x1C0, /* port0 phy register address */
129 MVS_P0_CFG_DATA = 0x1C4, /* port0 phy register data */
132 enum hw_register_bits {
134 INT_EN = (1U << 1), /* Global int enable */
135 HBA_RST = (1U << 0), /* HBA reset */
137 /* MVS_GBL_INT_STAT */
138 INT_XOR = (1U << 4), /* XOR engine event */
139 INT_SAS_SATA = (1U << 0), /* SAS/SATA event */
141 /* MVS_GBL_PORT_TYPE */ /* shl for ports 1-3 */
142 SATA_TARGET = (1U << 16), /* port0 SATA target enable */
143 AUTO_DET = (1U << 8), /* port0 SAS/SATA autodetect */
144 SAS_MODE = (1U << 0), /* port0 SAS(1), SATA(0) mode */
145 /* SAS_MODE value may be
146 * dictated (in hw) by values
147 * of SATA_TARGET & AUTO_DET
151 TX_EN = (1U << 16), /* Enable TX */
152 TX_RING_SZ_MASK = 0xfff, /* TX ring size, bits 11:0 */
155 RX_EN = (1U << 16), /* Enable RX */
156 RX_RING_SZ_MASK = 0xfff, /* RX ring size, bits 11:0 */
159 COAL_EN = (1U << 16), /* Enable int coalescing */
161 /* MVS_INT_STAT, MVS_INT_MASK */
162 CINT_I2C = (1U << 31), /* I2C event */
163 CINT_SW0 = (1U << 30), /* software event 0 */
164 CINT_SW1 = (1U << 29), /* software event 1 */
165 CINT_PRD_BC = (1U << 28), /* PRD BC err for read cmd */
166 CINT_DMA_PCIE = (1U << 27), /* DMA to PCIE timeout */
167 CINT_MEM = (1U << 26), /* int mem parity err */
168 CINT_I2C_SLAVE = (1U << 25), /* slave I2C event */
169 CINT_SRS = (1U << 3), /* SRS event */
170 CINT_CI_STOP = (1U << 10), /* cmd issue stopped */
171 CINT_DONE = (1U << 0), /* cmd completion */
173 /* shl for ports 1-3 */
174 CINT_PORT_STOPPED = (1U << 16), /* port0 stopped */
175 CINT_PORT = (1U << 8), /* port0 event */
177 /* TX (delivery) ring bits */
179 TXQ_CMD_SSP = 1, /* SSP protocol */
180 TXQ_CMD_SMP = 2, /* SMP protocol */
181 TXQ_CMD_STP = 3, /* STP/SATA protocol */
182 TXQ_CMD_SSP_FREE_LIST = 4, /* add to SSP targ free list */
183 TXQ_CMD_SLOT_RESET = 7, /* reset command slot */
184 TXQ_MODE_I = (1U << 28), /* mode: 0=target,1=initiator */
185 TXQ_PRIO_HI = (1U << 27), /* priority: 0=normal, 1=high */
186 TXQ_SRS_SHIFT = 20, /* SATA register set */
188 TXQ_PHY_SHIFT = 12, /* PHY bitmap */
190 TXQ_SLOT_MASK = 0xfff, /* slot number */
192 /* RX (completion) ring bits */
193 RXQ_GOOD = (1U << 23), /* Response good */
194 RXQ_SLOT_RESET = (1U << 21), /* Slot reset complete */
195 RXQ_CMD_RX = (1U << 20), /* target cmd received */
196 RXQ_ATTN = (1U << 19), /* attention */
197 RXQ_RSP = (1U << 18), /* response frame xfer'd */
198 RXQ_ERR = (1U << 17), /* err info rec xfer'd */
199 RXQ_DONE = (1U << 16), /* cmd complete */
200 RXQ_SLOT_MASK = 0xfff, /* slot number */
202 /* mvs_cmd_hdr bits */
203 MCH_PRD_LEN_SHIFT = 16, /* 16-bit PRD table len */
204 MCH_SSP_FR_TYPE_SHIFT = 13, /* SSP frame type */
206 /* SSP initiator only */
207 MCH_SSP_FR_CMD = 0x0, /* COMMAND frame */
209 /* SSP initiator or target */
210 MCH_SSP_FR_TASK = 0x1, /* TASK frame */
212 /* SSP target only */
213 MCH_SSP_FR_XFER_RDY = 0x4, /* XFER_RDY frame */
214 MCH_SSP_FR_RESP = 0x5, /* RESPONSE frame */
215 MCH_SSP_FR_READ = 0x6, /* Read DATA frame(s) */
216 MCH_SSP_FR_READ_RESP = 0x7, /* ditto, plus RESPONSE */
218 MCH_PASSTHRU = (1U << 12), /* pass-through (SSP) */
219 MCH_FBURST = (1U << 11), /* first burst (SSP) */
220 MCH_CHK_LEN = (1U << 10), /* chk xfer len (SSP) */
221 MCH_RETRY = (1U << 9), /* tport layer retry (SSP) */
222 MCH_PROTECTION = (1U << 8), /* protection info rec (SSP) */
223 MCH_RESET = (1U << 7), /* Reset (STP/SATA) */
224 MCH_FPDMA = (1U << 6), /* First party DMA (STP/SATA) */
225 MCH_ATAPI = (1U << 5), /* ATAPI (STP/SATA) */
226 MCH_BIST = (1U << 4), /* BIST activate (STP/SATA) */
227 MCH_PMP_MASK = 0xf, /* PMP from cmd FIS (STP/SATA)*/
229 CCTL_RST = (1U << 5), /* port logic reset */
231 /* 0(LSB first), 1(MSB first) */
232 CCTL_ENDIAN_DATA = (1U << 3), /* PRD data */
233 CCTL_ENDIAN_RSP = (1U << 2), /* response frame */
234 CCTL_ENDIAN_OPEN = (1U << 1), /* open address frame */
235 CCTL_ENDIAN_CMD = (1U << 0), /* command table */
237 /* MVS_Px_SER_CTLSTAT (per-phy control) */
238 PHY_SSP_RST = (1U << 3), /* reset SSP link layer */
239 PHY_BCAST_CHG = (1U << 2), /* broadcast(change) notif */
240 PHY_RST_HARD = (1U << 1), /* hard reset + phy reset */
241 PHY_RST = (1U << 0), /* phy reset */
243 /* MVS_Px_INT_STAT, MVS_Px_INT_MASK (per-phy events) */
244 PHYEV_UNASSOC_FIS = (1U << 19), /* unassociated FIS rx'd */
245 PHYEV_AN = (1U << 18), /* SATA async notification */
246 PHYEV_BIST_ACT = (1U << 17), /* BIST activate FIS */
247 PHYEV_SIG_FIS = (1U << 16), /* signature FIS */
248 PHYEV_POOF = (1U << 12), /* phy ready from 1 -> 0 */
249 PHYEV_IU_BIG = (1U << 11), /* IU too long err */
250 PHYEV_IU_SMALL = (1U << 10), /* IU too short err */
251 PHYEV_UNK_TAG = (1U << 9), /* unknown tag */
252 PHYEV_BROAD_CH = (1U << 8), /* broadcast(CHANGE) */
253 PHYEV_COMWAKE = (1U << 7), /* COMWAKE rx'd */
254 PHYEV_PORT_SEL = (1U << 6), /* port selector present */
255 PHYEV_HARD_RST = (1U << 5), /* hard reset rx'd */
256 PHYEV_ID_TMOUT = (1U << 4), /* identify timeout */
257 PHYEV_ID_FAIL = (1U << 3), /* identify failed */
258 PHYEV_ID_DONE = (1U << 2), /* identify done */
259 PHYEV_HARD_RST_DONE = (1U << 1), /* hard reset done */
260 PHYEV_RDY_CH = (1U << 0), /* phy ready changed state */
263 PCS_SATA_RETRY = (1U << 8), /* retry ctl FIS on R_ERR */
264 PCS_RSP_RX_EN = (1U << 7), /* raw response rx */
265 PCS_SELF_CLEAR = (1U << 5), /* self-clearing int mode */
266 PCS_FIS_RX_EN = (1U << 4), /* FIS rx enable */
267 PCS_CMD_STOP_ERR = (1U << 3), /* cmd stop-on-err enable */
268 PCS_CMD_RST = (1U << 2), /* reset cmd issue */
269 PCS_CMD_EN = (1U << 0), /* enable cmd issue */
272 enum mvs_info_flags {
273 MVF_MSI = (1U << 0), /* MSI is enabled */
274 MVF_PHY_PWR_FIX = (1U << 1), /* bug workaround */
277 enum sas_cmd_port_registers {
278 CMD_CMRST_OOB_DET = 0x100, /* COMRESET OOB detect register */
279 CMD_CMWK_OOB_DET = 0x104, /* COMWAKE OOB detect register */
280 CMD_CMSAS_OOB_DET = 0x108, /* COMSAS OOB detect register */
281 CMD_BRST_OOB_DET = 0x10c, /* burst OOB detect register */
282 CMD_OOB_SPACE = 0x110, /* OOB space control register */
283 CMD_OOB_BURST = 0x114, /* OOB burst control register */
284 CMD_PHY_TIMER = 0x118, /* PHY timer control register */
285 CMD_PHY_CONFIG0 = 0x11c, /* PHY config register 0 */
286 CMD_PHY_CONFIG1 = 0x120, /* PHY config register 1 */
287 CMD_SAS_CTL0 = 0x124, /* SAS control register 0 */
288 CMD_SAS_CTL1 = 0x128, /* SAS control register 1 */
289 CMD_SAS_CTL2 = 0x12c, /* SAS control register 2 */
290 CMD_SAS_CTL3 = 0x130, /* SAS control register 3 */
291 CMD_ID_TEST = 0x134, /* ID test register */
292 CMD_PL_TIMER = 0x138, /* PL timer register */
293 CMD_WD_TIMER = 0x13c, /* WD timer register */
294 CMD_PORT_SEL_COUNT = 0x140, /* port selector count register */
295 CMD_APP_MEM_CTL = 0x144, /* Application Memory Control */
296 CMD_XOR_MEM_CTL = 0x148, /* XOR Block Memory Control */
297 CMD_DMA_MEM_CTL = 0x14c, /* DMA Block Memory Control */
298 CMD_PORT_MEM_CTL0 = 0x150, /* Port Memory Control 0 */
299 CMD_PORT_MEM_CTL1 = 0x154, /* Port Memory Control 1 */
300 CMD_SATA_PORT_MEM_CTL0 = 0x158, /* SATA Port Memory Control 0 */
301 CMD_SATA_PORT_MEM_CTL1 = 0x15c, /* SATA Port Memory Control 1 */
302 CMD_XOR_MEM_BIST_CTL = 0x160, /* XOR Memory BIST Control */
303 CMD_XOR_MEM_BIST_STAT = 0x164, /* XOR Memroy BIST Status */
304 CMD_DMA_MEM_BIST_CTL = 0x168, /* DMA Memory BIST Control */
305 CMD_DMA_MEM_BIST_STAT = 0x16c, /* DMA Memory BIST Status */
306 CMD_PORT_MEM_BIST_CTL = 0x170, /* Port Memory BIST Control */
307 CMD_PORT_MEM_BIST_STAT0 = 0x174, /* Port Memory BIST Status 0 */
308 CMD_PORT_MEM_BIST_STAT1 = 0x178, /* Port Memory BIST Status 1 */
309 CMD_STP_MEM_BIST_CTL = 0x17c, /* STP Memory BIST Control */
310 CMD_STP_MEM_BIST_STAT0 = 0x180, /* STP Memory BIST Status 0 */
311 CMD_STP_MEM_BIST_STAT1 = 0x184, /* STP Memory BIST Status 1 */
312 CMD_RESET_COUNT = 0x188, /* Reset Count */
313 CMD_MONTR_DATA_SEL = 0x18C, /* Monitor Data/Select */
314 CMD_PLL_PHY_CONFIG = 0x190, /* PLL/PHY Configuration */
315 CMD_PHY_CTL = 0x194, /* PHY Control and Status */
316 CMD_PHY_TEST_COUNT0 = 0x198, /* Phy Test Count 0 */
317 CMD_PHY_TEST_COUNT1 = 0x19C, /* Phy Test Count 1 */
318 CMD_PHY_TEST_COUNT2 = 0x1A0, /* Phy Test Count 2 */
319 CMD_APP_ERR_CONFIG = 0x1A4, /* Application Error Configuration */
320 CMD_PND_FIFO_CTL0 = 0x1A8, /* Pending FIFO Control 0 */
321 CMD_HOST_CTL = 0x1AC, /* Host Control Status */
322 CMD_HOST_WR_DATA = 0x1B0, /* Host Write Data */
323 CMD_HOST_RD_DATA = 0x1B4, /* Host Read Data */
324 CMD_PHY_MODE_21 = 0x1B8, /* Phy Mode 21 */
325 CMD_SL_MODE0 = 0x1BC, /* SL Mode 0 */
326 CMD_SL_MODE1 = 0x1C0, /* SL Mode 1 */
327 CMD_PND_FIFO_CTL1 = 0x1C4, /* Pending FIFO Control 1 */
330 /* SAS/SATA configuration port registers, aka phy registers */
331 enum sas_sata_config_port_regs {
332 PHYR_IDENTIFY = 0x0, /* info for IDENTIFY frame */
333 PHYR_ADDR_LO = 0x4, /* my SAS address (low) */
334 PHYR_ADDR_HI = 0x8, /* my SAS address (high) */
335 PHYR_ATT_DEV_INFO = 0xC, /* attached device info */
336 PHYR_ATT_ADDR_LO = 0x10, /* attached dev SAS addr (low) */
337 PHYR_ATT_ADDR_HI = 0x14, /* attached dev SAS addr (high) */
338 PHYR_SATA_CTL = 0x18, /* SATA control */
339 PHYR_PHY_STAT = 0x1C, /* PHY status */
340 PHYR_WIDE_PORT = 0x38, /* wide port participating */
341 PHYR_CURRENT0 = 0x80, /* current connection info 0 */
342 PHYR_CURRENT1 = 0x84, /* current connection info 1 */
343 PHYR_CURRENT2 = 0x88, /* current connection info 2 */
346 enum pci_cfg_registers {
351 enum pci_cfg_register_bits {
352 PCTL_PWR_ON = (0xFU << 24),
353 PCTL_OFF = (0xFU << 12),
356 enum nvram_layout_offsets {
357 NVR_SIG = 0x00, /* 0xAA, 0x55 */
358 NVR_SAS_ADDR = 0x02, /* 8-byte SAS address */
367 struct mvs_chip_info {
370 unsigned int slot_width;
373 struct mvs_err_info {
379 __le64 addr; /* 64-bit buffer address */
381 __le32 len; /* 16-bit length */
385 __le32 flags; /* PRD tbl len; SAS, SATA ctl */
386 __le32 lens; /* cmd, max resp frame len */
387 __le32 tags; /* targ port xfer tag; tag */
388 __le32 data_len; /* data xfer len */
389 __le64 cmd_tbl; /* command table address */
390 __le64 open_frame; /* open addr frame address */
391 __le64 status_buf; /* status buffer address */
392 __le64 prd_tbl; /* PRD tbl address */
396 struct mvs_slot_info {
397 struct sas_task *task;
400 /* DMA buffer for storing cmd tbl, open addr frame, status buffer,
410 struct asd_sas_port sas_port;
414 struct mvs_port *port;
415 struct asd_sas_phy sas_phy;
417 u8 frame_rcvd[24 + 1024];
423 spinlock_t lock; /* host-wide lock */
424 struct pci_dev *pdev; /* our device */
425 void __iomem *regs; /* enhanced mode registers */
426 void __iomem *peri_regs; /* peripheral registers */
428 u8 sas_addr[SAS_ADDR_SIZE];
429 struct sas_ha_struct sas; /* SCSI/SAS glue */
430 struct Scsi_Host *shost;
432 __le32 *tx; /* TX (delivery) DMA ring */
434 u32 tx_prod; /* cached next-producer idx */
436 __le32 *rx; /* RX (completion) DMA ring */
438 u32 rx_cons; /* RX consumer idx */
440 __le32 *rx_fis; /* RX'd FIS area */
441 dma_addr_t rx_fis_dma;
443 struct mvs_cmd_hdr *slot; /* DMA command header slots */
446 const struct mvs_chip_info *chip;
448 /* further per-slot information */
449 struct mvs_slot_info slot_info[MVS_SLOTS];
450 unsigned long tags[(MVS_SLOTS / sizeof(unsigned long)) + 1];
452 struct mvs_phy phy[MVS_MAX_PHYS];
453 struct mvs_port port[MVS_MAX_PHYS];
456 static struct scsi_transport_template *mvs_stt;
458 static const struct mvs_chip_info mvs_chips[] = {
459 [chip_6320] = { 2, 16, 9 },
460 [chip_6440] = { 4, 16, 9 },
461 [chip_6480] = { 8, 32, 10 },
464 static struct scsi_host_template mvs_sht = {
465 .module = THIS_MODULE,
467 .queuecommand = sas_queuecommand,
468 .target_alloc = sas_target_alloc,
469 .slave_configure = sas_slave_configure,
470 .slave_destroy = sas_slave_destroy,
471 .change_queue_depth = sas_change_queue_depth,
472 .change_queue_type = sas_change_queue_type,
473 .bios_param = sas_bios_param,
477 .sg_tablesize = SG_ALL,
478 .max_sectors = SCSI_DEFAULT_MAX_SECTORS,
479 .use_clustering = ENABLE_CLUSTERING,
480 .eh_device_reset_handler= sas_eh_device_reset_handler,
481 .eh_bus_reset_handler = sas_eh_bus_reset_handler,
482 .slave_alloc = sas_slave_alloc,
483 .target_destroy = sas_target_destroy,
487 static void mvs_int_rx(struct mvs_info *mvi, bool self_clear);
489 /* move to PCI layer or libata core? */
490 static int pci_go_64(struct pci_dev *pdev)
494 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
495 rc = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
497 rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
499 dev_printk(KERN_ERR, &pdev->dev,
500 "64-bit DMA enable failed\n");
505 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
507 dev_printk(KERN_ERR, &pdev->dev,
508 "32-bit DMA enable failed\n");
511 rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
513 dev_printk(KERN_ERR, &pdev->dev,
514 "32-bit consistent DMA enable failed\n");
522 static void mvs_tag_clear(struct mvs_info *mvi, unsigned int tag)
524 mvi->tags[tag / sizeof(unsigned long)] &=
525 ~(1UL << (tag % sizeof(unsigned long)));
528 static void mvs_tag_set(struct mvs_info *mvi, unsigned int tag)
530 mvi->tags[tag / sizeof(unsigned long)] |=
531 (1UL << (tag % sizeof(unsigned long)));
534 static bool mvs_tag_test(struct mvs_info *mvi, unsigned int tag)
536 return mvi->tags[tag / sizeof(unsigned long)] &
537 (1UL << (tag % sizeof(unsigned long)));
540 static int mvs_tag_alloc(struct mvs_info *mvi, unsigned int *tag_out)
544 for (i = 0; i < MVS_SLOTS; i++)
545 if (!mvs_tag_test(mvi, i)) {
554 static int mvs_eep_read(void __iomem *regs, unsigned int addr, u32 *data)
558 if (addr & ~SPI_ADDR_MASK)
561 writel(addr, regs + SPI_CMD);
562 writel(TWSI_RD, regs + SPI_CTL);
564 while (timeout-- > 0) {
565 if (readl(regs + SPI_CTL) & TWSI_RDY) {
566 *data = readl(regs + SPI_DATA);
576 static int mvs_eep_read_buf(void __iomem *regs, unsigned int addr,
577 void *buf, unsigned int buflen)
579 unsigned int addr_end, tmp_addr, i, j;
582 u8 *tmp8, *buf8 = buf;
584 addr_end = addr + buflen;
585 tmp_addr = ALIGN(addr, 4);
591 rc = mvs_eep_read(regs, tmp_addr, &tmp);
596 for (i = j; i < 4; i++)
602 for (j = ALIGN(addr_end, 4); tmp_addr < j; tmp_addr += 4) {
603 rc = mvs_eep_read(regs, tmp_addr, &tmp);
607 memcpy(buf8, &tmp, 4);
611 if (tmp_addr < addr_end) {
612 rc = mvs_eep_read(regs, tmp_addr, &tmp);
617 j = addr_end - tmp_addr;
618 for (i = 0; i < j; i++)
627 static int mvs_nvram_read(struct mvs_info *mvi, unsigned int addr,
628 void *buf, unsigned int buflen)
630 void __iomem *regs = mvi->regs;
636 rc = mvs_eep_read_buf(regs, addr, &hdr, 2);
638 msg = "nvram hdr read failed";
641 rc = mvs_eep_read_buf(regs, addr + 2, buf, buflen);
643 msg = "nvram read failed";
647 if (hdr[0] != 0x5A) { /* entry id */
648 msg = "invalid nvram entry id";
654 sum = ((unsigned int)hdr[0]) + ((unsigned int)hdr[1]);
655 for (i = 0; i < buflen; i++)
656 sum += ((unsigned int)tmp[i]);
659 msg = "nvram checksum failure";
667 dev_printk(KERN_ERR, &mvi->pdev->dev, "%s", msg);
671 static void mvs_int_port(struct mvs_info *mvi, int port_no, u32 events)
676 static void mvs_int_sata(struct mvs_info *mvi)
681 static void mvs_slot_free(struct mvs_info *mvi, struct sas_task *task,
682 struct mvs_slot_info *slot, unsigned int slot_idx)
685 pci_unmap_sg(mvi->pdev, task->scatter,
686 slot->n_elem, task->data_dir);
688 switch (task->task_proto) {
689 case SAS_PROTOCOL_SMP:
690 pci_unmap_sg(mvi->pdev, &task->smp_task.smp_resp, 1,
692 pci_unmap_sg(mvi->pdev, &task->smp_task.smp_req, 1,
696 case SAS_PROTOCOL_SATA:
697 case SAS_PROTOCOL_STP:
698 case SAS_PROTOCOL_SSP:
704 mvs_tag_clear(mvi, slot_idx);
707 static void mvs_slot_err(struct mvs_info *mvi, struct sas_task *task,
708 unsigned int slot_idx)
713 static void mvs_slot_complete(struct mvs_info *mvi, u32 rx_desc)
715 unsigned int slot_idx = rx_desc & RXQ_SLOT_MASK;
716 struct mvs_slot_info *slot = &mvi->slot_info[slot_idx];
717 struct sas_task *task = slot->task;
718 struct task_status_struct *tstat = &task->task_status;
721 spin_lock(&task->task_state_lock);
722 aborted = task->task_state_flags & SAS_TASK_STATE_ABORTED;
724 task->task_state_flags &=
725 ~(SAS_TASK_STATE_PENDING | SAS_TASK_AT_INITIATOR);
726 task->task_state_flags |= SAS_TASK_STATE_DONE;
728 spin_unlock(&task->task_state_lock);
733 memset(tstat, 0, sizeof(*tstat));
734 tstat->resp = SAS_TASK_COMPLETE;
736 /* error info record present */
737 if (rx_desc & RXQ_ERR) {
738 tstat->stat = SAM_CHECK_COND;
739 mvs_slot_err(mvi, task, slot_idx);
743 switch (task->task_proto) {
744 case SAS_PROTOCOL_SSP:
745 /* hw says status == 0, datapres == 0 */
746 if (rx_desc & RXQ_GOOD)
747 tstat->stat = SAM_GOOD;
749 /* response frame present */
750 else if (rx_desc & RXQ_RSP) {
751 struct ssp_response_iu *iu =
752 slot->response + sizeof(struct mvs_err_info);
753 sas_ssp_task_response(&mvi->pdev->dev, task, iu);
756 /* should never happen? */
758 tstat->stat = SAM_CHECK_COND;
761 case SAS_PROTOCOL_SMP:
762 tstat->stat = SAM_GOOD;
765 case SAS_PROTOCOL_SATA:
766 case SAS_PROTOCOL_STP:
767 if ((rx_desc & (RXQ_DONE | RXQ_ERR | RXQ_ATTN)) == RXQ_DONE)
768 tstat->stat = SAM_GOOD;
770 tstat->stat = SAM_CHECK_COND;
771 /* FIXME: read taskfile data from SATA register set
772 * associated with SATA target
777 tstat->stat = SAM_CHECK_COND;
782 mvs_slot_free(mvi, task, slot, slot_idx);
783 task->task_done(task);
786 static void mvs_int_full(struct mvs_info *mvi)
788 void __iomem *regs = mvi->regs;
792 stat = mr32(INT_STAT);
794 for (i = 0; i < MVS_MAX_PORTS; i++) {
795 tmp = (stat >> i) & (CINT_PORT | CINT_PORT_STOPPED);
797 mvs_int_port(mvi, i, tmp);
803 if (stat & (CINT_CI_STOP | CINT_DONE))
804 mvs_int_rx(mvi, false);
806 mw32(INT_STAT, stat);
809 static void mvs_int_rx(struct mvs_info *mvi, bool self_clear)
811 u32 rx_prod_idx, rx_desc;
814 /* the first dword in the RX ring is special: it contains
815 * a mirror of the hardware's RX producer index, so that
816 * we don't have to stall the CPU reading that register.
817 * The actual RX ring is offset by one dword, due to this.
819 rx_prod_idx = le32_to_cpu(mvi->rx[0]) & 0xfff;
820 if (rx_prod_idx == 0xfff) { /* h/w hasn't touched RX ring yet */
821 mvi->rx_cons = 0xfff;
824 if (mvi->rx_cons == 0xfff)
825 mvi->rx_cons = MVS_RX_RING_SZ - 1;
827 while (mvi->rx_cons != rx_prod_idx) {
828 /* increment our internal RX consumer pointer */
829 mvi->rx_cons = (mvi->rx_cons + 1) & (MVS_RX_RING_SZ - 1);
831 /* Read RX descriptor at offset+1, due to above */
832 rx_desc = le32_to_cpu(mvi->rx[mvi->rx_cons + 1]);
834 if (rx_desc & RXQ_DONE)
835 /* we had a completion, error or no */
836 mvs_slot_complete(mvi, rx_desc);
838 if (rx_desc & RXQ_ATTN)
842 if (attn && self_clear)
847 static irqreturn_t mvs_interrupt(int irq, void *opaque)
849 struct mvs_info *mvi = opaque;
850 void __iomem *regs = mvi->regs;
853 stat = mr32(GBL_INT_STAT);
854 if (stat == 0 || stat == 0xffffffff)
857 spin_lock(&mvi->lock);
861 spin_unlock(&mvi->lock);
866 static irqreturn_t mvs_msi_interrupt(int irq, void *opaque)
868 struct mvs_info *mvi = opaque;
870 spin_lock(&mvi->lock);
872 mvs_int_rx(mvi, true);
874 spin_unlock(&mvi->lock);
879 struct mvs_task_exec_info {
880 struct sas_task *task;
881 struct mvs_cmd_hdr *hdr;
886 static int mvs_task_prep_smp(struct mvs_info *mvi, struct mvs_task_exec_info *tei)
889 struct mvs_cmd_hdr *hdr = tei->hdr;
890 struct scatterlist *sg_req, *sg_resp;
891 unsigned int req_len, resp_len, tag = tei->tag;
894 * DMA-map SMP request, response buffers
897 sg_req = &tei->task->smp_task.smp_req;
898 elem = pci_map_sg(mvi->pdev, sg_req, 1, PCI_DMA_TODEVICE);
901 req_len = sg_dma_len(sg_req);
903 sg_resp = &tei->task->smp_task.smp_resp;
904 elem = pci_map_sg(mvi->pdev, sg_resp, 1, PCI_DMA_FROMDEVICE);
909 resp_len = sg_dma_len(sg_resp);
911 /* must be in dwords */
912 if ((req_len & 0x3) || (resp_len & 0x3)) {
918 * Fill in TX ring and command slot header
921 mvi->tx[tag] = cpu_to_le32(
922 (TXQ_CMD_SMP << TXQ_CMD_SHIFT) | TXQ_MODE_I | tag);
925 hdr->lens = cpu_to_le32(((resp_len / 4) << 16) | (req_len / 4));
926 hdr->tags = cpu_to_le32(tag);
928 hdr->cmd_tbl = cpu_to_le64(sg_dma_address(sg_req));
930 hdr->status_buf = cpu_to_le64(sg_dma_address(sg_resp));
936 pci_unmap_sg(mvi->pdev, &tei->task->smp_task.smp_resp, 1,
939 pci_unmap_sg(mvi->pdev, &tei->task->smp_task.smp_req, 1,
944 static int mvs_task_prep_ata(struct mvs_info *mvi,
945 struct mvs_task_exec_info *tei)
947 struct sas_task *task = tei->task;
948 struct domain_device *dev = task->dev;
949 struct mvs_cmd_hdr *hdr = tei->hdr;
950 struct asd_sas_port *sas_port = dev->port;
951 unsigned int tag = tei->tag;
952 struct mvs_slot_info *slot = &mvi->slot_info[tag];
953 u32 flags = (tei->n_elem << MCH_PRD_LEN_SHIFT);
954 struct scatterlist *sg;
955 struct mvs_prd *buf_prd;
957 u8 *buf_cmd, *buf_oaf;
958 dma_addr_t buf_tmp_dma;
959 unsigned int i, req_len, resp_len;
961 /* FIXME: fill in SATA register set */
962 mvi->tx[tag] = cpu_to_le32(TXQ_MODE_I | tag |
963 (TXQ_CMD_STP << TXQ_CMD_SHIFT) |
964 (sas_port->phy_mask << TXQ_PHY_SHIFT));
966 if (task->ata_task.use_ncq)
968 if (dev->sata_dev.command_set == ATAPI_COMMAND_SET)
970 /* FIXME: fill in port multiplier number */
972 hdr->flags = cpu_to_le32(flags);
973 hdr->tags = cpu_to_le32(tag);
974 hdr->data_len = cpu_to_le32(task->total_xfer_len);
977 * arrange MVS_SLOT_BUF_SZ-sized DMA buffer according to our needs
979 memset(slot->buf, 0, MVS_SLOT_BUF_SZ);
981 /* region 1: command table area (MVS_ATA_CMD_SZ bytes) ***************/
984 buf_tmp_dma = slot->buf_dma;
986 hdr->cmd_tbl = cpu_to_le64(buf_tmp_dma);
988 buf_tmp += MVS_ATA_CMD_SZ;
989 buf_tmp_dma += MVS_ATA_CMD_SZ;
991 /* region 2: open address frame area (MVS_OAF_SZ bytes) **********/
992 /* used for STP. unused for SATA? */
994 hdr->open_frame = cpu_to_le64(buf_tmp_dma);
996 buf_tmp += MVS_OAF_SZ;
997 buf_tmp_dma += MVS_OAF_SZ;
999 /* region 3: PRD table ***********************************************/
1001 hdr->prd_tbl = cpu_to_le64(buf_tmp_dma);
1003 i = sizeof(struct mvs_prd) * tei->n_elem;
1007 /* region 4: status buffer (larger the PRD, smaller this buf) ********/
1008 /* FIXME: probably unused, for SATA. kept here just in case
1009 * we get a STP/SATA error information record
1011 slot->response = buf_tmp;
1012 hdr->status_buf = cpu_to_le64(buf_tmp_dma);
1014 req_len = sizeof(struct ssp_frame_hdr) + 28;
1015 resp_len = MVS_SLOT_BUF_SZ - MVS_ATA_CMD_SZ -
1016 sizeof(struct mvs_err_info) - i;
1018 /* request, response lengths */
1019 hdr->lens = cpu_to_le32(((resp_len / 4) << 16) | (req_len / 4));
1021 /* fill in command FIS and ATAPI CDB */
1022 memcpy(buf_cmd, &task->ata_task.fis,
1023 sizeof(struct host_to_dev_fis));
1024 memcpy(buf_cmd + 0x40, task->ata_task.atapi_packet, 16);
1026 /* fill in PRD (scatter/gather) table, if any */
1028 for (i = 0; i < tei->n_elem; i++) {
1029 buf_prd->addr = cpu_to_le64(sg_dma_address(sg));
1030 buf_prd->len = cpu_to_le32(sg_dma_len(sg));
1039 static int mvs_task_prep_ssp(struct mvs_info *mvi,
1040 struct mvs_task_exec_info *tei)
1042 struct sas_task *task = tei->task;
1043 struct asd_sas_port *sas_port = task->dev->port;
1044 struct mvs_cmd_hdr *hdr = tei->hdr;
1045 struct mvs_slot_info *slot;
1046 struct scatterlist *sg;
1047 unsigned int resp_len, req_len, i, tag = tei->tag;
1048 struct mvs_prd *buf_prd;
1049 struct ssp_frame_hdr *ssp_hdr;
1051 u8 *buf_cmd, *buf_oaf, fburst = 0;
1052 dma_addr_t buf_tmp_dma;
1055 slot = &mvi->slot_info[tag];
1057 mvi->tx[tag] = cpu_to_le32(TXQ_MODE_I | tag |
1058 (TXQ_CMD_SSP << TXQ_CMD_SHIFT) |
1059 (sas_port->phy_mask << TXQ_PHY_SHIFT));
1062 if (task->ssp_task.enable_first_burst) {
1063 flags |= MCH_FBURST;
1066 hdr->flags = cpu_to_le32(flags |
1067 (tei->n_elem << MCH_PRD_LEN_SHIFT) |
1068 (MCH_SSP_FR_CMD << MCH_SSP_FR_TYPE_SHIFT));
1070 hdr->tags = cpu_to_le32(tag);
1071 hdr->data_len = cpu_to_le32(task->total_xfer_len);
1074 * arrange MVS_SLOT_BUF_SZ-sized DMA buffer according to our needs
1076 memset(slot->buf, 0, MVS_SLOT_BUF_SZ);
1078 /* region 1: command table area (MVS_SSP_CMD_SZ bytes) ***************/
1080 buf_tmp = slot->buf;
1081 buf_tmp_dma = slot->buf_dma;
1083 hdr->cmd_tbl = cpu_to_le64(buf_tmp_dma);
1085 buf_tmp += MVS_SSP_CMD_SZ;
1086 buf_tmp_dma += MVS_SSP_CMD_SZ;
1088 /* region 2: open address frame area (MVS_OAF_SZ bytes) **********/
1090 hdr->open_frame = cpu_to_le64(buf_tmp_dma);
1092 buf_tmp += MVS_OAF_SZ;
1093 buf_tmp_dma += MVS_OAF_SZ;
1095 /* region 3: PRD table ***********************************************/
1097 hdr->prd_tbl = cpu_to_le64(buf_tmp_dma);
1099 i = sizeof(struct mvs_prd) * tei->n_elem;
1103 /* region 4: status buffer (larger the PRD, smaller this buf) ********/
1104 slot->response = buf_tmp;
1105 hdr->status_buf = cpu_to_le64(buf_tmp_dma);
1107 req_len = sizeof(struct ssp_frame_hdr) + 28;
1108 resp_len = MVS_SLOT_BUF_SZ - MVS_SSP_CMD_SZ - MVS_OAF_SZ -
1109 sizeof(struct mvs_err_info) - i;
1111 /* request, response lengths */
1112 hdr->lens = cpu_to_le32(((resp_len / 4) << 16) | (req_len / 4));
1114 /* generate open address frame hdr (first 12 bytes) */
1115 buf_oaf[0] = (1 << 7) | (1 << 4) | 0x1; /* initiator, SSP, ftype 1h */
1116 buf_oaf[1] = task->dev->linkrate & 0xf;
1117 buf_oaf[2] = tag >> 8;
1119 memcpy(buf_oaf + 4, task->dev->sas_addr, SAS_ADDR_SIZE);
1121 /* fill in SSP frame header */
1122 ssp_hdr = (struct ssp_frame_hdr *) buf_cmd;
1123 ssp_hdr->frame_type = SSP_COMMAND;
1124 memcpy(ssp_hdr->hashed_dest_addr, task->dev->hashed_sas_addr,
1125 HASHED_SAS_ADDR_SIZE);
1126 memcpy(ssp_hdr->hashed_src_addr,
1127 task->dev->port->ha->hashed_sas_addr, HASHED_SAS_ADDR_SIZE);
1128 ssp_hdr->tag = cpu_to_be16(tag);
1130 /* fill in command frame IU */
1131 buf_cmd += sizeof(*ssp_hdr);
1132 memcpy(buf_cmd, &task->ssp_task.LUN, 8);
1133 buf_cmd[9] = fburst |
1134 task->ssp_task.task_attr |
1135 (task->ssp_task.task_prio << 3);
1136 memcpy(buf_cmd + 12, &task->ssp_task.cdb, 16);
1138 /* fill in PRD (scatter/gather) table, if any */
1140 for (i = 0; i < tei->n_elem; i++) {
1141 buf_prd->addr = cpu_to_le64(sg_dma_address(sg));
1142 buf_prd->len = cpu_to_le32(sg_dma_len(sg));
1151 static int mvs_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags)
1153 struct mvs_info *mvi = task->dev->port->ha->lldd_ha;
1154 unsigned int tag = 0xdeadbeef, rc, n_elem = 0;
1155 void __iomem *regs = mvi->regs;
1156 unsigned long flags;
1157 struct mvs_task_exec_info tei;
1159 /* FIXME: STP/SATA support not complete yet */
1160 if (task->task_proto == SAS_PROTOCOL_SATA || task->task_proto == SAS_PROTOCOL_STP)
1161 return -SAS_DEV_NO_RESPONSE;
1163 if (task->num_scatter) {
1164 n_elem = pci_map_sg(mvi->pdev, task->scatter,
1165 task->num_scatter, task->data_dir);
1170 spin_lock_irqsave(&mvi->lock, flags);
1172 rc = mvs_tag_alloc(mvi, &tag);
1176 mvi->slot_info[tag].task = task;
1177 mvi->slot_info[tag].n_elem = n_elem;
1179 tei.hdr = &mvi->slot[tag];
1181 tei.n_elem = n_elem;
1183 switch (task->task_proto) {
1184 case SAS_PROTOCOL_SMP:
1185 rc = mvs_task_prep_smp(mvi, &tei);
1187 case SAS_PROTOCOL_SSP:
1188 rc = mvs_task_prep_ssp(mvi, &tei);
1190 case SAS_PROTOCOL_SATA:
1191 case SAS_PROTOCOL_STP:
1192 rc = mvs_task_prep_ata(mvi, &tei);
1202 /* TODO: select normal or high priority */
1204 mw32(RX_PROD_IDX, mvi->tx_prod);
1206 mvi->tx_prod = (mvi->tx_prod + 1) & (MVS_TX_RING_SZ - 1);
1208 spin_lock(&task->task_state_lock);
1209 task->task_state_flags |= SAS_TASK_AT_INITIATOR;
1210 spin_unlock(&task->task_state_lock);
1212 spin_unlock_irqrestore(&mvi->lock, flags);
1216 mvs_tag_clear(mvi, tag);
1219 pci_unmap_sg(mvi->pdev, task->scatter, n_elem, task->data_dir);
1220 spin_unlock_irqrestore(&mvi->lock, flags);
1224 static void mvs_free(struct mvs_info *mvi)
1231 for (i = 0; i < MVS_SLOTS; i++) {
1232 struct mvs_slot_info *slot = &mvi->slot_info[i];
1235 dma_free_coherent(&mvi->pdev->dev, MVS_SLOT_BUF_SZ,
1236 slot->buf, slot->buf_dma);
1240 dma_free_coherent(&mvi->pdev->dev,
1241 sizeof(*mvi->tx) * MVS_TX_RING_SZ,
1242 mvi->tx, mvi->tx_dma);
1244 dma_free_coherent(&mvi->pdev->dev, MVS_RX_FISL_SZ,
1245 mvi->rx_fis, mvi->rx_fis_dma);
1247 dma_free_coherent(&mvi->pdev->dev,
1248 sizeof(*mvi->rx) * MVS_RX_RING_SZ,
1249 mvi->rx, mvi->rx_dma);
1251 dma_free_coherent(&mvi->pdev->dev,
1252 sizeof(*mvi->slot) * MVS_RX_RING_SZ,
1253 mvi->slot, mvi->slot_dma);
1255 iounmap(mvi->peri_regs);
1259 scsi_host_put(mvi->shost);
1260 kfree(mvi->sas.sas_port);
1261 kfree(mvi->sas.sas_phy);
1265 /* FIXME: locking? */
1266 static int mvs_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
1269 struct mvs_info *mvi = sas_phy->ha->lldd_ha;
1271 int rc = 0, phy_id = sas_phy->id;
1274 reg = mvi->regs + MVS_P0_SER_CTLSTAT + (phy_id * 4);
1277 case PHY_FUNC_SET_LINK_RATE: {
1278 struct sas_phy_linkrates *rates = funcdata;
1279 u32 lrmin = 0, lrmax = 0;
1281 lrmin = (rates->minimum_linkrate << 8);
1282 lrmax = (rates->maximum_linkrate << 12);
1290 tmp &= ~(0xf << 12);
1297 case PHY_FUNC_HARD_RESET:
1299 if (tmp & PHY_RST_HARD)
1301 writel(tmp | PHY_RST_HARD, reg);
1304 case PHY_FUNC_LINK_RESET:
1305 writel(readl(reg) | PHY_RST, reg);
1308 case PHY_FUNC_DISABLE:
1309 case PHY_FUNC_RELEASE_SPINUP_HOLD:
1317 static void __devinit mvs_phy_init(struct mvs_info *mvi, int phy_id)
1319 struct mvs_phy *phy = &mvi->phy[phy_id];
1320 struct asd_sas_phy *sas_phy = &phy->sas_phy;
1322 sas_phy->enabled = (phy_id < mvi->chip->n_phy) ? 1 : 0;
1323 sas_phy->class = SAS;
1324 sas_phy->iproto = SAS_PROTOCOL_ALL;
1325 sas_phy->tproto = 0;
1326 sas_phy->type = PHY_TYPE_PHYSICAL;
1327 sas_phy->role = PHY_ROLE_INITIATOR;
1328 sas_phy->oob_mode = OOB_NOT_CONNECTED;
1329 sas_phy->linkrate = SAS_LINK_RATE_UNKNOWN;
1331 sas_phy->id = phy_id;
1332 sas_phy->sas_addr = &mvi->sas_addr[0];
1333 sas_phy->frame_rcvd = &phy->frame_rcvd[0];
1334 sas_phy->ha = &mvi->sas;
1335 sas_phy->lldd_phy = phy;
1338 static struct mvs_info * __devinit mvs_alloc(struct pci_dev *pdev,
1339 const struct pci_device_id *ent)
1341 struct mvs_info *mvi;
1342 unsigned long res_start, res_len;
1343 struct asd_sas_phy **arr_phy;
1344 struct asd_sas_port **arr_port;
1345 const struct mvs_chip_info *chip = &mvs_chips[ent->driver_data];
1349 * alloc and init our per-HBA mvs_info struct
1352 mvi = kzalloc(sizeof(*mvi), GFP_KERNEL);
1356 spin_lock_init(&mvi->lock);
1360 if (pdev->device == 0x6440 && pdev->revision == 0)
1361 mvi->flags |= MVF_PHY_PWR_FIX;
1364 * alloc and init SCSI, SAS glue
1367 mvi->shost = scsi_host_alloc(&mvs_sht, sizeof(void *));
1371 arr_phy = kcalloc(MVS_MAX_PHYS, sizeof(void *), GFP_KERNEL);
1372 arr_port = kcalloc(MVS_MAX_PHYS, sizeof(void *), GFP_KERNEL);
1373 if (!arr_phy || !arr_port)
1376 for (i = 0; i < MVS_MAX_PHYS; i++) {
1377 mvs_phy_init(mvi, i);
1378 arr_phy[i] = &mvi->phy[i].sas_phy;
1379 arr_port[i] = &mvi->port[i].sas_port;
1382 SHOST_TO_SAS_HA(mvi->shost) = &mvi->sas;
1383 mvi->shost->transportt = mvs_stt;
1384 mvi->shost->max_id = ~0;
1385 mvi->shost->max_lun = ~0;
1386 mvi->shost->max_cmd_len = ~0;
1388 mvi->sas.sas_ha_name = DRV_NAME;
1389 mvi->sas.dev = &pdev->dev;
1390 mvi->sas.lldd_module = THIS_MODULE;
1391 mvi->sas.sas_addr = &mvi->sas_addr[0];
1392 mvi->sas.sas_phy = arr_phy;
1393 mvi->sas.sas_port = arr_port;
1394 mvi->sas.num_phys = chip->n_phy;
1395 mvi->sas.lldd_max_execute_num = MVS_TX_RING_SZ - 1;/* FIXME: correct? */
1396 mvi->sas.lldd_queue_size = MVS_TX_RING_SZ - 1; /* FIXME: correct? */
1397 mvi->sas.lldd_ha = mvi;
1398 mvi->sas.core.shost = mvi->shost;
1400 mvs_tag_set(mvi, MVS_TX_RING_SZ - 1);
1403 * ioremap main and peripheral registers
1406 res_start = pci_resource_start(pdev, 2);
1407 res_len = pci_resource_len(pdev, 2);
1408 if (!res_start || !res_len)
1411 mvi->peri_regs = ioremap_nocache(res_start, res_len);
1415 res_start = pci_resource_start(pdev, 4);
1416 res_len = pci_resource_len(pdev, 4);
1417 if (!res_start || !res_len)
1420 mvi->regs = ioremap_nocache(res_start, res_len);
1425 * alloc and init our DMA areas
1428 mvi->tx = dma_alloc_coherent(&pdev->dev,
1429 sizeof(*mvi->tx) * MVS_TX_RING_SZ,
1430 &mvi->tx_dma, GFP_KERNEL);
1433 memset(mvi->tx, 0, sizeof(*mvi->tx) * MVS_TX_RING_SZ);
1435 mvi->rx_fis = dma_alloc_coherent(&pdev->dev, MVS_RX_FISL_SZ,
1436 &mvi->rx_fis_dma, GFP_KERNEL);
1439 memset(mvi->rx_fis, 0, MVS_RX_FISL_SZ);
1441 mvi->rx = dma_alloc_coherent(&pdev->dev,
1442 sizeof(*mvi->rx) * MVS_RX_RING_SZ,
1443 &mvi->rx_dma, GFP_KERNEL);
1446 memset(mvi->rx, 0, sizeof(*mvi->rx) * MVS_RX_RING_SZ);
1448 mvi->rx[0] = cpu_to_le32(0xfff);
1449 mvi->rx_cons = 0xfff;
1451 mvi->slot = dma_alloc_coherent(&pdev->dev,
1452 sizeof(*mvi->slot) * MVS_SLOTS,
1453 &mvi->slot_dma, GFP_KERNEL);
1456 memset(mvi->slot, 0, sizeof(*mvi->slot) * MVS_SLOTS);
1458 for (i = 0; i < MVS_SLOTS; i++) {
1459 struct mvs_slot_info *slot = &mvi->slot_info[i];
1461 slot->buf = dma_alloc_coherent(&pdev->dev, MVS_SLOT_BUF_SZ,
1462 &slot->buf_dma, GFP_KERNEL);
1465 memset(slot->buf, 0, MVS_SLOT_BUF_SZ);
1468 /* finally, read NVRAM to get our SAS address */
1469 if (mvs_nvram_read(mvi, NVR_SAS_ADDR, &mvi->sas_addr, 8))
1479 static u32 mvs_cr32(void __iomem *regs, u32 addr)
1481 mw32(CMD_ADDR, addr);
1482 return mr32(CMD_DATA);
1485 static void mvs_cw32(void __iomem *regs, u32 addr, u32 val)
1487 mw32(CMD_ADDR, addr);
1488 mw32(CMD_DATA, val);
1492 static u32 mvs_phy_read(struct mvs_info *mvi, unsigned int phy_id, u32 addr)
1494 void __iomem *regs = mvi->regs;
1495 void __iomem *phy_regs = regs + MVS_P0_CFG_ADDR + (phy_id * 8);
1497 writel(addr, phy_regs);
1498 return readl(phy_regs + 4);
1502 static void mvs_phy_write(struct mvs_info *mvi, unsigned int phy_id,
1505 void __iomem *regs = mvi->regs;
1506 void __iomem *phy_regs = regs + MVS_P0_CFG_ADDR + (phy_id * 8);
1508 writel(addr, phy_regs);
1509 writel(val, phy_regs + 4);
1510 readl(phy_regs); /* flush */
1513 static void __devinit mvs_phy_hacks(struct mvs_info *mvi)
1515 void __iomem *regs = mvi->regs;
1518 /* workaround for SATA R-ERR, to ignore phy glitch */
1519 tmp = mvs_cr32(regs, CMD_PHY_TIMER);
1522 mvs_cw32(regs, CMD_PHY_TIMER, tmp);
1524 /* enable retry 127 times */
1525 mvs_cw32(regs, CMD_SAS_CTL1, 0x7f7f);
1527 /* extend open frame timeout to max */
1528 tmp = mvs_cr32(regs, CMD_SAS_CTL0);
1531 mvs_cw32(regs, CMD_SAS_CTL0, tmp);
1533 /* workaround for WDTIMEOUT , set to 550 ms */
1534 mvs_cw32(regs, CMD_WD_TIMER, 0xffffff);
1536 /* not to halt for different port op during wideport link change */
1537 mvs_cw32(regs, CMD_APP_ERR_CONFIG, 0xffefbf7d);
1539 /* workaround for Seagate disk not-found OOB sequence, recv
1540 * COMINIT before sending out COMWAKE */
1541 tmp = mvs_cr32(regs, CMD_PHY_MODE_21);
1544 mvs_cw32(regs, CMD_PHY_MODE_21, tmp);
1546 tmp = mvs_cr32(regs, CMD_PHY_TIMER);
1548 tmp |= (2U << 29); /* 8 ms retry */
1549 mvs_cw32(regs, CMD_PHY_TIMER, tmp);
1552 static int __devinit mvs_hw_init(struct mvs_info *mvi)
1554 void __iomem *regs = mvi->regs;
1558 /* make sure interrupts are masked immediately (paranoia) */
1560 tmp = mr32(GBL_CTL);
1562 if (!(tmp & HBA_RST)) {
1563 if (mvi->flags & MVF_PHY_PWR_FIX) {
1564 pci_read_config_dword(mvi->pdev, PCR_PHY_CTL, &tmp);
1565 tmp &= ~PCTL_PWR_ON;
1567 pci_write_config_dword(mvi->pdev, PCR_PHY_CTL, tmp);
1569 pci_read_config_dword(mvi->pdev, PCR_PHY_CTL2, &tmp);
1570 tmp &= ~PCTL_PWR_ON;
1572 pci_write_config_dword(mvi->pdev, PCR_PHY_CTL2, tmp);
1575 /* global reset, incl. COMRESET/H_RESET_N (self-clearing) */
1576 mw32_f(GBL_CTL, HBA_RST);
1580 /* wait for reset to finish; timeout is just a guess */
1585 if (!(mr32(GBL_CTL) & HBA_RST))
1588 if (mr32(GBL_CTL) & HBA_RST) {
1589 dev_printk(KERN_ERR, &mvi->pdev->dev, "HBA reset failed\n");
1593 /* make sure RST is set; HBA_RST /should/ have done that for us */
1595 if (cctl & CCTL_RST)
1598 mw32_f(CTL, cctl | CCTL_RST);
1600 pci_read_config_dword(mvi->pdev, PCR_PHY_CTL, &tmp);
1603 pci_write_config_dword(mvi->pdev, PCR_PHY_CTL, tmp);
1605 pci_read_config_dword(mvi->pdev, PCR_PHY_CTL2, &tmp);
1608 pci_write_config_dword(mvi->pdev, PCR_PHY_CTL2, tmp);
1614 mw32(CMD_LIST_LO, mvi->slot_dma);
1615 mw32(CMD_LIST_HI, (mvi->slot_dma >> 16) >> 16);
1617 mw32(RX_FIS_LO, mvi->rx_fis_dma);
1618 mw32(RX_FIS_HI, (mvi->rx_fis_dma >> 16) >> 16);
1620 mw32(TX_CFG, MVS_TX_RING_SZ);
1621 mw32(TX_LO, mvi->tx_dma);
1622 mw32(TX_HI, (mvi->tx_dma >> 16) >> 16);
1624 mw32(RX_CFG, MVS_RX_RING_SZ);
1625 mw32(RX_LO, mvi->rx_dma);
1626 mw32(RX_HI, (mvi->rx_dma >> 16) >> 16);
1628 /* init and reset phys */
1629 for (i = 0; i < mvi->chip->n_phy; i++) {
1630 /* FIXME: is this the correct dword order? */
1631 u32 lo = *((u32 *) &mvi->sas_addr[0]);
1632 u32 hi = *((u32 *) &mvi->sas_addr[4]);
1634 /* set phy local SAS address */
1635 mvs_phy_write(mvi, i, PHYR_ADDR_LO, lo);
1636 mvs_phy_write(mvi, i, PHYR_ADDR_HI, hi);
1639 tmp = readl(regs + MVS_P0_SER_CTLSTAT + (i * 4));
1641 writel(tmp, regs + MVS_P0_SER_CTLSTAT + (i * 4));
1646 for (i = 0; i < mvi->chip->n_phy; i++) {
1647 /* set phy int mask */
1648 writel(PHYEV_BROAD_CH | PHYEV_RDY_CH,
1649 regs + MVS_P0_INT_MASK + (i * 8));
1651 /* clear phy int status */
1652 tmp = readl(regs + MVS_P0_INT_STAT + (i * 8));
1653 writel(tmp, regs + MVS_P0_INT_STAT + (i * 8));
1656 /* FIXME: update wide port bitmaps */
1658 /* ladies and gentlemen, start your engines */
1659 mw32(TX_CFG, MVS_TX_RING_SZ | TX_EN);
1660 mw32(RX_CFG, MVS_RX_RING_SZ | RX_EN);
1661 mw32(PCS, PCS_SATA_RETRY | PCS_FIS_RX_EN | PCS_CMD_EN |
1662 ((mvi->flags & MVF_MSI) ? PCS_SELF_CLEAR : 0));
1664 /* re-enable interrupts globally */
1665 mw32(GBL_CTL, INT_EN);
1670 static void __devinit mvs_print_info(struct mvs_info *mvi)
1672 struct pci_dev *pdev = mvi->pdev;
1673 static int printed_version;
1675 if (!printed_version++)
1676 dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
1678 dev_printk(KERN_INFO, &pdev->dev, "%u phys, addr %llx\n",
1679 mvi->chip->n_phy, SAS_ADDR(mvi->sas_addr));
1682 static int __devinit mvs_pci_init(struct pci_dev *pdev,
1683 const struct pci_device_id *ent)
1686 struct mvs_info *mvi;
1687 irq_handler_t irq_handler = mvs_interrupt;
1689 rc = pci_enable_device(pdev);
1693 pci_set_master(pdev);
1695 rc = pci_request_regions(pdev, DRV_NAME);
1697 goto err_out_disable;
1699 rc = pci_go_64(pdev);
1701 goto err_out_regions;
1703 mvi = mvs_alloc(pdev, ent);
1706 goto err_out_regions;
1709 rc = mvs_hw_init(mvi);
1713 if (!pci_enable_msi(pdev)) {
1714 mvi->flags |= MVF_MSI;
1715 irq_handler = mvs_msi_interrupt;
1718 rc = request_irq(pdev->irq, irq_handler, IRQF_SHARED, DRV_NAME, mvi);
1722 rc = scsi_add_host(mvi->shost, &pdev->dev);
1726 rc = sas_register_ha(&mvi->sas);
1730 pci_set_drvdata(pdev, mvi);
1732 mvs_print_info(mvi);
1734 scsi_scan_host(mvi->shost);
1738 scsi_remove_host(mvi->shost);
1740 free_irq(pdev->irq, mvi);
1742 if (mvi->flags |= MVF_MSI)
1743 pci_disable_msi(pdev);
1747 pci_release_regions(pdev);
1749 pci_disable_device(pdev);
1753 static void __devexit mvs_pci_remove(struct pci_dev *pdev)
1755 struct mvs_info *mvi = pci_get_drvdata(pdev);
1757 pci_set_drvdata(pdev, NULL);
1759 sas_unregister_ha(&mvi->sas);
1760 sas_remove_host(mvi->shost);
1761 scsi_remove_host(mvi->shost);
1763 free_irq(pdev->irq, mvi);
1764 if (mvi->flags & MVF_MSI)
1765 pci_disable_msi(pdev);
1767 pci_release_regions(pdev);
1768 pci_disable_device(pdev);
1771 static struct sas_domain_function_template mvs_transport_ops = {
1772 .lldd_execute_task = mvs_task_exec,
1773 .lldd_control_phy = mvs_phy_control,
1776 static struct pci_device_id __devinitdata mvs_pci_table[] = {
1777 { PCI_VDEVICE(MARVELL, 0x6320), chip_6320 },
1778 { PCI_VDEVICE(MARVELL, 0x6340), chip_6440 },
1779 { PCI_VDEVICE(MARVELL, 0x6440), chip_6440 },
1780 { PCI_VDEVICE(MARVELL, 0x6480), chip_6480 },
1782 { } /* terminate list */
1785 static struct pci_driver mvs_pci_driver = {
1787 .id_table = mvs_pci_table,
1788 .probe = mvs_pci_init,
1789 .remove = __devexit_p(mvs_pci_remove),
1792 static int __init mvs_init(void)
1796 mvs_stt = sas_domain_attach_transport(&mvs_transport_ops);
1800 rc = pci_register_driver(&mvs_pci_driver);
1807 sas_release_transport(mvs_stt);
1811 static void __exit mvs_exit(void)
1813 pci_unregister_driver(&mvs_pci_driver);
1814 sas_release_transport(mvs_stt);
1817 module_init(mvs_init);
1818 module_exit(mvs_exit);
1820 MODULE_AUTHOR("Jeff Garzik <jgarzik@pobox.com>");
1821 MODULE_DESCRIPTION("Marvell 88SE6440 SAS/SATA controller driver");
1822 MODULE_VERSION(DRV_VERSION);
1823 MODULE_LICENSE("GPL");
1824 MODULE_DEVICE_TABLE(pci, mvs_pci_table);