xref: /openbmc/linux/drivers/scsi/mvsas/mv_sas.c (revision 6774def6)
1 /*
2  * Marvell 88SE64xx/88SE94xx main function
3  *
4  * Copyright 2007 Red Hat, Inc.
5  * Copyright 2008 Marvell. <kewei@marvell.com>
6  * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
7  *
8  * This file is licensed under GPLv2.
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as
12  * published by the Free Software Foundation; version 2 of the
13  * License.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
23  * USA
24 */
25 
26 #include "mv_sas.h"
27 
28 static int mvs_find_tag(struct mvs_info *mvi, struct sas_task *task, u32 *tag)
29 {
30 	if (task->lldd_task) {
31 		struct mvs_slot_info *slot;
32 		slot = task->lldd_task;
33 		*tag = slot->slot_tag;
34 		return 1;
35 	}
36 	return 0;
37 }
38 
39 void mvs_tag_clear(struct mvs_info *mvi, u32 tag)
40 {
41 	void *bitmap = mvi->tags;
42 	clear_bit(tag, bitmap);
43 }
44 
45 void mvs_tag_free(struct mvs_info *mvi, u32 tag)
46 {
47 	mvs_tag_clear(mvi, tag);
48 }
49 
50 void mvs_tag_set(struct mvs_info *mvi, unsigned int tag)
51 {
52 	void *bitmap = mvi->tags;
53 	set_bit(tag, bitmap);
54 }
55 
56 inline int mvs_tag_alloc(struct mvs_info *mvi, u32 *tag_out)
57 {
58 	unsigned int index, tag;
59 	void *bitmap = mvi->tags;
60 
61 	index = find_first_zero_bit(bitmap, mvi->tags_num);
62 	tag = index;
63 	if (tag >= mvi->tags_num)
64 		return -SAS_QUEUE_FULL;
65 	mvs_tag_set(mvi, tag);
66 	*tag_out = tag;
67 	return 0;
68 }
69 
70 void mvs_tag_init(struct mvs_info *mvi)
71 {
72 	int i;
73 	for (i = 0; i < mvi->tags_num; ++i)
74 		mvs_tag_clear(mvi, i);
75 }
76 
77 struct mvs_info *mvs_find_dev_mvi(struct domain_device *dev)
78 {
79 	unsigned long i = 0, j = 0, hi = 0;
80 	struct sas_ha_struct *sha = dev->port->ha;
81 	struct mvs_info *mvi = NULL;
82 	struct asd_sas_phy *phy;
83 
84 	while (sha->sas_port[i]) {
85 		if (sha->sas_port[i] == dev->port) {
86 			phy =  container_of(sha->sas_port[i]->phy_list.next,
87 				struct asd_sas_phy, port_phy_el);
88 			j = 0;
89 			while (sha->sas_phy[j]) {
90 				if (sha->sas_phy[j] == phy)
91 					break;
92 				j++;
93 			}
94 			break;
95 		}
96 		i++;
97 	}
98 	hi = j/((struct mvs_prv_info *)sha->lldd_ha)->n_phy;
99 	mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[hi];
100 
101 	return mvi;
102 
103 }
104 
105 int mvs_find_dev_phyno(struct domain_device *dev, int *phyno)
106 {
107 	unsigned long i = 0, j = 0, n = 0, num = 0;
108 	struct mvs_device *mvi_dev = (struct mvs_device *)dev->lldd_dev;
109 	struct mvs_info *mvi = mvi_dev->mvi_info;
110 	struct sas_ha_struct *sha = dev->port->ha;
111 
112 	while (sha->sas_port[i]) {
113 		if (sha->sas_port[i] == dev->port) {
114 			struct asd_sas_phy *phy;
115 			list_for_each_entry(phy,
116 				&sha->sas_port[i]->phy_list, port_phy_el) {
117 				j = 0;
118 				while (sha->sas_phy[j]) {
119 					if (sha->sas_phy[j] == phy)
120 						break;
121 					j++;
122 				}
123 				phyno[n] = (j >= mvi->chip->n_phy) ?
124 					(j - mvi->chip->n_phy) : j;
125 				num++;
126 				n++;
127 			}
128 			break;
129 		}
130 		i++;
131 	}
132 	return num;
133 }
134 
135 struct mvs_device *mvs_find_dev_by_reg_set(struct mvs_info *mvi,
136 						u8 reg_set)
137 {
138 	u32 dev_no;
139 	for (dev_no = 0; dev_no < MVS_MAX_DEVICES; dev_no++) {
140 		if (mvi->devices[dev_no].taskfileset == MVS_ID_NOT_MAPPED)
141 			continue;
142 
143 		if (mvi->devices[dev_no].taskfileset == reg_set)
144 			return &mvi->devices[dev_no];
145 	}
146 	return NULL;
147 }
148 
149 static inline void mvs_free_reg_set(struct mvs_info *mvi,
150 				struct mvs_device *dev)
151 {
152 	if (!dev) {
153 		mv_printk("device has been free.\n");
154 		return;
155 	}
156 	if (dev->taskfileset == MVS_ID_NOT_MAPPED)
157 		return;
158 	MVS_CHIP_DISP->free_reg_set(mvi, &dev->taskfileset);
159 }
160 
161 static inline u8 mvs_assign_reg_set(struct mvs_info *mvi,
162 				struct mvs_device *dev)
163 {
164 	if (dev->taskfileset != MVS_ID_NOT_MAPPED)
165 		return 0;
166 	return MVS_CHIP_DISP->assign_reg_set(mvi, &dev->taskfileset);
167 }
168 
169 void mvs_phys_reset(struct mvs_info *mvi, u32 phy_mask, int hard)
170 {
171 	u32 no;
172 	for_each_phy(phy_mask, phy_mask, no) {
173 		if (!(phy_mask & 1))
174 			continue;
175 		MVS_CHIP_DISP->phy_reset(mvi, no, hard);
176 	}
177 }
178 
179 int mvs_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
180 			void *funcdata)
181 {
182 	int rc = 0, phy_id = sas_phy->id;
183 	u32 tmp, i = 0, hi;
184 	struct sas_ha_struct *sha = sas_phy->ha;
185 	struct mvs_info *mvi = NULL;
186 
187 	while (sha->sas_phy[i]) {
188 		if (sha->sas_phy[i] == sas_phy)
189 			break;
190 		i++;
191 	}
192 	hi = i/((struct mvs_prv_info *)sha->lldd_ha)->n_phy;
193 	mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[hi];
194 
195 	switch (func) {
196 	case PHY_FUNC_SET_LINK_RATE:
197 		MVS_CHIP_DISP->phy_set_link_rate(mvi, phy_id, funcdata);
198 		break;
199 
200 	case PHY_FUNC_HARD_RESET:
201 		tmp = MVS_CHIP_DISP->read_phy_ctl(mvi, phy_id);
202 		if (tmp & PHY_RST_HARD)
203 			break;
204 		MVS_CHIP_DISP->phy_reset(mvi, phy_id, MVS_HARD_RESET);
205 		break;
206 
207 	case PHY_FUNC_LINK_RESET:
208 		MVS_CHIP_DISP->phy_enable(mvi, phy_id);
209 		MVS_CHIP_DISP->phy_reset(mvi, phy_id, MVS_SOFT_RESET);
210 		break;
211 
212 	case PHY_FUNC_DISABLE:
213 		MVS_CHIP_DISP->phy_disable(mvi, phy_id);
214 		break;
215 	case PHY_FUNC_RELEASE_SPINUP_HOLD:
216 	default:
217 		rc = -ENOSYS;
218 	}
219 	msleep(200);
220 	return rc;
221 }
222 
223 void mvs_set_sas_addr(struct mvs_info *mvi, int port_id, u32 off_lo,
224 		      u32 off_hi, u64 sas_addr)
225 {
226 	u32 lo = (u32)sas_addr;
227 	u32 hi = (u32)(sas_addr>>32);
228 
229 	MVS_CHIP_DISP->write_port_cfg_addr(mvi, port_id, off_lo);
230 	MVS_CHIP_DISP->write_port_cfg_data(mvi, port_id, lo);
231 	MVS_CHIP_DISP->write_port_cfg_addr(mvi, port_id, off_hi);
232 	MVS_CHIP_DISP->write_port_cfg_data(mvi, port_id, hi);
233 }
234 
235 static void mvs_bytes_dmaed(struct mvs_info *mvi, int i)
236 {
237 	struct mvs_phy *phy = &mvi->phy[i];
238 	struct asd_sas_phy *sas_phy = &phy->sas_phy;
239 	struct sas_ha_struct *sas_ha;
240 	if (!phy->phy_attached)
241 		return;
242 
243 	if (!(phy->att_dev_info & PORT_DEV_TRGT_MASK)
244 		&& phy->phy_type & PORT_TYPE_SAS) {
245 		return;
246 	}
247 
248 	sas_ha = mvi->sas;
249 	sas_ha->notify_phy_event(sas_phy, PHYE_OOB_DONE);
250 
251 	if (sas_phy->phy) {
252 		struct sas_phy *sphy = sas_phy->phy;
253 
254 		sphy->negotiated_linkrate = sas_phy->linkrate;
255 		sphy->minimum_linkrate = phy->minimum_linkrate;
256 		sphy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
257 		sphy->maximum_linkrate = phy->maximum_linkrate;
258 		sphy->maximum_linkrate_hw = MVS_CHIP_DISP->phy_max_link_rate();
259 	}
260 
261 	if (phy->phy_type & PORT_TYPE_SAS) {
262 		struct sas_identify_frame *id;
263 
264 		id = (struct sas_identify_frame *)phy->frame_rcvd;
265 		id->dev_type = phy->identify.device_type;
266 		id->initiator_bits = SAS_PROTOCOL_ALL;
267 		id->target_bits = phy->identify.target_port_protocols;
268 
269 		/* direct attached SAS device */
270 		if (phy->att_dev_info & PORT_SSP_TRGT_MASK) {
271 			MVS_CHIP_DISP->write_port_cfg_addr(mvi, i, PHYR_PHY_STAT);
272 			MVS_CHIP_DISP->write_port_cfg_data(mvi, i, 0x00);
273 		}
274 	} else if (phy->phy_type & PORT_TYPE_SATA) {
275 		/*Nothing*/
276 	}
277 	mv_dprintk("phy %d byte dmaded.\n", i + mvi->id * mvi->chip->n_phy);
278 
279 	sas_phy->frame_rcvd_size = phy->frame_rcvd_size;
280 
281 	mvi->sas->notify_port_event(sas_phy,
282 				   PORTE_BYTES_DMAED);
283 }
284 
285 void mvs_scan_start(struct Scsi_Host *shost)
286 {
287 	int i, j;
288 	unsigned short core_nr;
289 	struct mvs_info *mvi;
290 	struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
291 	struct mvs_prv_info *mvs_prv = sha->lldd_ha;
292 
293 	core_nr = ((struct mvs_prv_info *)sha->lldd_ha)->n_host;
294 
295 	for (j = 0; j < core_nr; j++) {
296 		mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[j];
297 		for (i = 0; i < mvi->chip->n_phy; ++i)
298 			mvs_bytes_dmaed(mvi, i);
299 	}
300 	mvs_prv->scan_finished = 1;
301 }
302 
303 int mvs_scan_finished(struct Scsi_Host *shost, unsigned long time)
304 {
305 	struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
306 	struct mvs_prv_info *mvs_prv = sha->lldd_ha;
307 
308 	if (mvs_prv->scan_finished == 0)
309 		return 0;
310 
311 	sas_drain_work(sha);
312 	return 1;
313 }
314 
315 static int mvs_task_prep_smp(struct mvs_info *mvi,
316 			     struct mvs_task_exec_info *tei)
317 {
318 	int elem, rc, i;
319 	struct sas_ha_struct *sha = mvi->sas;
320 	struct sas_task *task = tei->task;
321 	struct mvs_cmd_hdr *hdr = tei->hdr;
322 	struct domain_device *dev = task->dev;
323 	struct asd_sas_port *sas_port = dev->port;
324 	struct sas_phy *sphy = dev->phy;
325 	struct asd_sas_phy *sas_phy = sha->sas_phy[sphy->number];
326 	struct scatterlist *sg_req, *sg_resp;
327 	u32 req_len, resp_len, tag = tei->tag;
328 	void *buf_tmp;
329 	u8 *buf_oaf;
330 	dma_addr_t buf_tmp_dma;
331 	void *buf_prd;
332 	struct mvs_slot_info *slot = &mvi->slot_info[tag];
333 	u32 flags = (tei->n_elem << MCH_PRD_LEN_SHIFT);
334 
335 	/*
336 	 * DMA-map SMP request, response buffers
337 	 */
338 	sg_req = &task->smp_task.smp_req;
339 	elem = dma_map_sg(mvi->dev, sg_req, 1, PCI_DMA_TODEVICE);
340 	if (!elem)
341 		return -ENOMEM;
342 	req_len = sg_dma_len(sg_req);
343 
344 	sg_resp = &task->smp_task.smp_resp;
345 	elem = dma_map_sg(mvi->dev, sg_resp, 1, PCI_DMA_FROMDEVICE);
346 	if (!elem) {
347 		rc = -ENOMEM;
348 		goto err_out;
349 	}
350 	resp_len = SB_RFB_MAX;
351 
352 	/* must be in dwords */
353 	if ((req_len & 0x3) || (resp_len & 0x3)) {
354 		rc = -EINVAL;
355 		goto err_out_2;
356 	}
357 
358 	/*
359 	 * arrange MVS_SLOT_BUF_SZ-sized DMA buffer according to our needs
360 	 */
361 
362 	/* region 1: command table area (MVS_SSP_CMD_SZ bytes) ***** */
363 	buf_tmp = slot->buf;
364 	buf_tmp_dma = slot->buf_dma;
365 
366 	hdr->cmd_tbl = cpu_to_le64(sg_dma_address(sg_req));
367 
368 	/* region 2: open address frame area (MVS_OAF_SZ bytes) ********* */
369 	buf_oaf = buf_tmp;
370 	hdr->open_frame = cpu_to_le64(buf_tmp_dma);
371 
372 	buf_tmp += MVS_OAF_SZ;
373 	buf_tmp_dma += MVS_OAF_SZ;
374 
375 	/* region 3: PRD table *********************************** */
376 	buf_prd = buf_tmp;
377 	if (tei->n_elem)
378 		hdr->prd_tbl = cpu_to_le64(buf_tmp_dma);
379 	else
380 		hdr->prd_tbl = 0;
381 
382 	i = MVS_CHIP_DISP->prd_size() * tei->n_elem;
383 	buf_tmp += i;
384 	buf_tmp_dma += i;
385 
386 	/* region 4: status buffer (larger the PRD, smaller this buf) ****** */
387 	slot->response = buf_tmp;
388 	hdr->status_buf = cpu_to_le64(buf_tmp_dma);
389 	if (mvi->flags & MVF_FLAG_SOC)
390 		hdr->reserved[0] = 0;
391 
392 	/*
393 	 * Fill in TX ring and command slot header
394 	 */
395 	slot->tx = mvi->tx_prod;
396 	mvi->tx[mvi->tx_prod] = cpu_to_le32((TXQ_CMD_SMP << TXQ_CMD_SHIFT) |
397 					TXQ_MODE_I | tag |
398 					(MVS_PHY_ID << TXQ_PHY_SHIFT));
399 
400 	hdr->flags |= flags;
401 	hdr->lens = cpu_to_le32(((resp_len / 4) << 16) | ((req_len - 4) / 4));
402 	hdr->tags = cpu_to_le32(tag);
403 	hdr->data_len = 0;
404 
405 	/* generate open address frame hdr (first 12 bytes) */
406 	/* initiator, SMP, ftype 1h */
407 	buf_oaf[0] = (1 << 7) | (PROTOCOL_SMP << 4) | 0x01;
408 	buf_oaf[1] = min(sas_port->linkrate, dev->linkrate) & 0xf;
409 	*(u16 *)(buf_oaf + 2) = 0xFFFF;		/* SAS SPEC */
410 	memcpy(buf_oaf + 4, dev->sas_addr, SAS_ADDR_SIZE);
411 
412 	/* fill in PRD (scatter/gather) table, if any */
413 	MVS_CHIP_DISP->make_prd(task->scatter, tei->n_elem, buf_prd);
414 
415 	return 0;
416 
417 err_out_2:
418 	dma_unmap_sg(mvi->dev, &tei->task->smp_task.smp_resp, 1,
419 		     PCI_DMA_FROMDEVICE);
420 err_out:
421 	dma_unmap_sg(mvi->dev, &tei->task->smp_task.smp_req, 1,
422 		     PCI_DMA_TODEVICE);
423 	return rc;
424 }
425 
426 static u32 mvs_get_ncq_tag(struct sas_task *task, u32 *tag)
427 {
428 	struct ata_queued_cmd *qc = task->uldd_task;
429 
430 	if (qc) {
431 		if (qc->tf.command == ATA_CMD_FPDMA_WRITE ||
432 			qc->tf.command == ATA_CMD_FPDMA_READ) {
433 			*tag = qc->tag;
434 			return 1;
435 		}
436 	}
437 
438 	return 0;
439 }
440 
441 static int mvs_task_prep_ata(struct mvs_info *mvi,
442 			     struct mvs_task_exec_info *tei)
443 {
444 	struct sas_ha_struct *sha = mvi->sas;
445 	struct sas_task *task = tei->task;
446 	struct domain_device *dev = task->dev;
447 	struct mvs_device *mvi_dev = dev->lldd_dev;
448 	struct mvs_cmd_hdr *hdr = tei->hdr;
449 	struct asd_sas_port *sas_port = dev->port;
450 	struct sas_phy *sphy = dev->phy;
451 	struct asd_sas_phy *sas_phy = sha->sas_phy[sphy->number];
452 	struct mvs_slot_info *slot;
453 	void *buf_prd;
454 	u32 tag = tei->tag, hdr_tag;
455 	u32 flags, del_q;
456 	void *buf_tmp;
457 	u8 *buf_cmd, *buf_oaf;
458 	dma_addr_t buf_tmp_dma;
459 	u32 i, req_len, resp_len;
460 	const u32 max_resp_len = SB_RFB_MAX;
461 
462 	if (mvs_assign_reg_set(mvi, mvi_dev) == MVS_ID_NOT_MAPPED) {
463 		mv_dprintk("Have not enough regiset for dev %d.\n",
464 			mvi_dev->device_id);
465 		return -EBUSY;
466 	}
467 	slot = &mvi->slot_info[tag];
468 	slot->tx = mvi->tx_prod;
469 	del_q = TXQ_MODE_I | tag |
470 		(TXQ_CMD_STP << TXQ_CMD_SHIFT) |
471 		(MVS_PHY_ID << TXQ_PHY_SHIFT) |
472 		(mvi_dev->taskfileset << TXQ_SRS_SHIFT);
473 	mvi->tx[mvi->tx_prod] = cpu_to_le32(del_q);
474 
475 	if (task->data_dir == DMA_FROM_DEVICE)
476 		flags = (MVS_CHIP_DISP->prd_count() << MCH_PRD_LEN_SHIFT);
477 	else
478 		flags = (tei->n_elem << MCH_PRD_LEN_SHIFT);
479 
480 	if (task->ata_task.use_ncq)
481 		flags |= MCH_FPDMA;
482 	if (dev->sata_dev.command_set == ATAPI_COMMAND_SET) {
483 		if (task->ata_task.fis.command != ATA_CMD_ID_ATAPI)
484 			flags |= MCH_ATAPI;
485 	}
486 
487 	hdr->flags = cpu_to_le32(flags);
488 
489 	if (task->ata_task.use_ncq && mvs_get_ncq_tag(task, &hdr_tag))
490 		task->ata_task.fis.sector_count |= (u8) (hdr_tag << 3);
491 	else
492 		hdr_tag = tag;
493 
494 	hdr->tags = cpu_to_le32(hdr_tag);
495 
496 	hdr->data_len = cpu_to_le32(task->total_xfer_len);
497 
498 	/*
499 	 * arrange MVS_SLOT_BUF_SZ-sized DMA buffer according to our needs
500 	 */
501 
502 	/* region 1: command table area (MVS_ATA_CMD_SZ bytes) ************** */
503 	buf_cmd = buf_tmp = slot->buf;
504 	buf_tmp_dma = slot->buf_dma;
505 
506 	hdr->cmd_tbl = cpu_to_le64(buf_tmp_dma);
507 
508 	buf_tmp += MVS_ATA_CMD_SZ;
509 	buf_tmp_dma += MVS_ATA_CMD_SZ;
510 
511 	/* region 2: open address frame area (MVS_OAF_SZ bytes) ********* */
512 	/* used for STP.  unused for SATA? */
513 	buf_oaf = buf_tmp;
514 	hdr->open_frame = cpu_to_le64(buf_tmp_dma);
515 
516 	buf_tmp += MVS_OAF_SZ;
517 	buf_tmp_dma += MVS_OAF_SZ;
518 
519 	/* region 3: PRD table ********************************************* */
520 	buf_prd = buf_tmp;
521 
522 	if (tei->n_elem)
523 		hdr->prd_tbl = cpu_to_le64(buf_tmp_dma);
524 	else
525 		hdr->prd_tbl = 0;
526 	i = MVS_CHIP_DISP->prd_size() * MVS_CHIP_DISP->prd_count();
527 
528 	buf_tmp += i;
529 	buf_tmp_dma += i;
530 
531 	/* region 4: status buffer (larger the PRD, smaller this buf) ****** */
532 	slot->response = buf_tmp;
533 	hdr->status_buf = cpu_to_le64(buf_tmp_dma);
534 	if (mvi->flags & MVF_FLAG_SOC)
535 		hdr->reserved[0] = 0;
536 
537 	req_len = sizeof(struct host_to_dev_fis);
538 	resp_len = MVS_SLOT_BUF_SZ - MVS_ATA_CMD_SZ -
539 	    sizeof(struct mvs_err_info) - i;
540 
541 	/* request, response lengths */
542 	resp_len = min(resp_len, max_resp_len);
543 	hdr->lens = cpu_to_le32(((resp_len / 4) << 16) | (req_len / 4));
544 
545 	if (likely(!task->ata_task.device_control_reg_update))
546 		task->ata_task.fis.flags |= 0x80; /* C=1: update ATA cmd reg */
547 	/* fill in command FIS and ATAPI CDB */
548 	memcpy(buf_cmd, &task->ata_task.fis, sizeof(struct host_to_dev_fis));
549 	if (dev->sata_dev.command_set == ATAPI_COMMAND_SET)
550 		memcpy(buf_cmd + STP_ATAPI_CMD,
551 			task->ata_task.atapi_packet, 16);
552 
553 	/* generate open address frame hdr (first 12 bytes) */
554 	/* initiator, STP, ftype 1h */
555 	buf_oaf[0] = (1 << 7) | (PROTOCOL_STP << 4) | 0x1;
556 	buf_oaf[1] = min(sas_port->linkrate, dev->linkrate) & 0xf;
557 	*(u16 *)(buf_oaf + 2) = cpu_to_be16(mvi_dev->device_id + 1);
558 	memcpy(buf_oaf + 4, dev->sas_addr, SAS_ADDR_SIZE);
559 
560 	/* fill in PRD (scatter/gather) table, if any */
561 	MVS_CHIP_DISP->make_prd(task->scatter, tei->n_elem, buf_prd);
562 
563 	if (task->data_dir == DMA_FROM_DEVICE)
564 		MVS_CHIP_DISP->dma_fix(mvi, sas_port->phy_mask,
565 				TRASH_BUCKET_SIZE, tei->n_elem, buf_prd);
566 
567 	return 0;
568 }
569 
570 static int mvs_task_prep_ssp(struct mvs_info *mvi,
571 			     struct mvs_task_exec_info *tei, int is_tmf,
572 			     struct mvs_tmf_task *tmf)
573 {
574 	struct sas_task *task = tei->task;
575 	struct mvs_cmd_hdr *hdr = tei->hdr;
576 	struct mvs_port *port = tei->port;
577 	struct domain_device *dev = task->dev;
578 	struct mvs_device *mvi_dev = dev->lldd_dev;
579 	struct asd_sas_port *sas_port = dev->port;
580 	struct mvs_slot_info *slot;
581 	void *buf_prd;
582 	struct ssp_frame_hdr *ssp_hdr;
583 	void *buf_tmp;
584 	u8 *buf_cmd, *buf_oaf, fburst = 0;
585 	dma_addr_t buf_tmp_dma;
586 	u32 flags;
587 	u32 resp_len, req_len, i, tag = tei->tag;
588 	const u32 max_resp_len = SB_RFB_MAX;
589 	u32 phy_mask;
590 
591 	slot = &mvi->slot_info[tag];
592 
593 	phy_mask = ((port->wide_port_phymap) ? port->wide_port_phymap :
594 		sas_port->phy_mask) & TXQ_PHY_MASK;
595 
596 	slot->tx = mvi->tx_prod;
597 	mvi->tx[mvi->tx_prod] = cpu_to_le32(TXQ_MODE_I | tag |
598 				(TXQ_CMD_SSP << TXQ_CMD_SHIFT) |
599 				(phy_mask << TXQ_PHY_SHIFT));
600 
601 	flags = MCH_RETRY;
602 	if (task->ssp_task.enable_first_burst) {
603 		flags |= MCH_FBURST;
604 		fburst = (1 << 7);
605 	}
606 	if (is_tmf)
607 		flags |= (MCH_SSP_FR_TASK << MCH_SSP_FR_TYPE_SHIFT);
608 	else
609 		flags |= (MCH_SSP_FR_CMD << MCH_SSP_FR_TYPE_SHIFT);
610 
611 	hdr->flags = cpu_to_le32(flags | (tei->n_elem << MCH_PRD_LEN_SHIFT));
612 	hdr->tags = cpu_to_le32(tag);
613 	hdr->data_len = cpu_to_le32(task->total_xfer_len);
614 
615 	/*
616 	 * arrange MVS_SLOT_BUF_SZ-sized DMA buffer according to our needs
617 	 */
618 
619 	/* region 1: command table area (MVS_SSP_CMD_SZ bytes) ************** */
620 	buf_cmd = buf_tmp = slot->buf;
621 	buf_tmp_dma = slot->buf_dma;
622 
623 	hdr->cmd_tbl = cpu_to_le64(buf_tmp_dma);
624 
625 	buf_tmp += MVS_SSP_CMD_SZ;
626 	buf_tmp_dma += MVS_SSP_CMD_SZ;
627 
628 	/* region 2: open address frame area (MVS_OAF_SZ bytes) ********* */
629 	buf_oaf = buf_tmp;
630 	hdr->open_frame = cpu_to_le64(buf_tmp_dma);
631 
632 	buf_tmp += MVS_OAF_SZ;
633 	buf_tmp_dma += MVS_OAF_SZ;
634 
635 	/* region 3: PRD table ********************************************* */
636 	buf_prd = buf_tmp;
637 	if (tei->n_elem)
638 		hdr->prd_tbl = cpu_to_le64(buf_tmp_dma);
639 	else
640 		hdr->prd_tbl = 0;
641 
642 	i = MVS_CHIP_DISP->prd_size() * tei->n_elem;
643 	buf_tmp += i;
644 	buf_tmp_dma += i;
645 
646 	/* region 4: status buffer (larger the PRD, smaller this buf) ****** */
647 	slot->response = buf_tmp;
648 	hdr->status_buf = cpu_to_le64(buf_tmp_dma);
649 	if (mvi->flags & MVF_FLAG_SOC)
650 		hdr->reserved[0] = 0;
651 
652 	resp_len = MVS_SLOT_BUF_SZ - MVS_SSP_CMD_SZ - MVS_OAF_SZ -
653 	    sizeof(struct mvs_err_info) - i;
654 	resp_len = min(resp_len, max_resp_len);
655 
656 	req_len = sizeof(struct ssp_frame_hdr) + 28;
657 
658 	/* request, response lengths */
659 	hdr->lens = cpu_to_le32(((resp_len / 4) << 16) | (req_len / 4));
660 
661 	/* generate open address frame hdr (first 12 bytes) */
662 	/* initiator, SSP, ftype 1h */
663 	buf_oaf[0] = (1 << 7) | (PROTOCOL_SSP << 4) | 0x1;
664 	buf_oaf[1] = min(sas_port->linkrate, dev->linkrate) & 0xf;
665 	*(u16 *)(buf_oaf + 2) = cpu_to_be16(mvi_dev->device_id + 1);
666 	memcpy(buf_oaf + 4, dev->sas_addr, SAS_ADDR_SIZE);
667 
668 	/* fill in SSP frame header (Command Table.SSP frame header) */
669 	ssp_hdr = (struct ssp_frame_hdr *)buf_cmd;
670 
671 	if (is_tmf)
672 		ssp_hdr->frame_type = SSP_TASK;
673 	else
674 		ssp_hdr->frame_type = SSP_COMMAND;
675 
676 	memcpy(ssp_hdr->hashed_dest_addr, dev->hashed_sas_addr,
677 	       HASHED_SAS_ADDR_SIZE);
678 	memcpy(ssp_hdr->hashed_src_addr,
679 	       dev->hashed_sas_addr, HASHED_SAS_ADDR_SIZE);
680 	ssp_hdr->tag = cpu_to_be16(tag);
681 
682 	/* fill in IU for TASK and Command Frame */
683 	buf_cmd += sizeof(*ssp_hdr);
684 	memcpy(buf_cmd, &task->ssp_task.LUN, 8);
685 
686 	if (ssp_hdr->frame_type != SSP_TASK) {
687 		buf_cmd[9] = fburst | task->ssp_task.task_attr |
688 				(task->ssp_task.task_prio << 3);
689 		memcpy(buf_cmd + 12, task->ssp_task.cmd->cmnd,
690 		       task->ssp_task.cmd->cmd_len);
691 	} else{
692 		buf_cmd[10] = tmf->tmf;
693 		switch (tmf->tmf) {
694 		case TMF_ABORT_TASK:
695 		case TMF_QUERY_TASK:
696 			buf_cmd[12] =
697 				(tmf->tag_of_task_to_be_managed >> 8) & 0xff;
698 			buf_cmd[13] =
699 				tmf->tag_of_task_to_be_managed & 0xff;
700 			break;
701 		default:
702 			break;
703 		}
704 	}
705 	/* fill in PRD (scatter/gather) table, if any */
706 	MVS_CHIP_DISP->make_prd(task->scatter, tei->n_elem, buf_prd);
707 	return 0;
708 }
709 
710 #define	DEV_IS_GONE(mvi_dev)	((!mvi_dev || (mvi_dev->dev_type == SAS_PHY_UNUSED)))
711 static int mvs_task_prep(struct sas_task *task, struct mvs_info *mvi, int is_tmf,
712 				struct mvs_tmf_task *tmf, int *pass)
713 {
714 	struct domain_device *dev = task->dev;
715 	struct mvs_device *mvi_dev = dev->lldd_dev;
716 	struct mvs_task_exec_info tei;
717 	struct mvs_slot_info *slot;
718 	u32 tag = 0xdeadbeef, n_elem = 0;
719 	int rc = 0;
720 
721 	if (!dev->port) {
722 		struct task_status_struct *tsm = &task->task_status;
723 
724 		tsm->resp = SAS_TASK_UNDELIVERED;
725 		tsm->stat = SAS_PHY_DOWN;
726 		/*
727 		 * libsas will use dev->port, should
728 		 * not call task_done for sata
729 		 */
730 		if (dev->dev_type != SAS_SATA_DEV)
731 			task->task_done(task);
732 		return rc;
733 	}
734 
735 	if (DEV_IS_GONE(mvi_dev)) {
736 		if (mvi_dev)
737 			mv_dprintk("device %d not ready.\n",
738 				mvi_dev->device_id);
739 		else
740 			mv_dprintk("device %016llx not ready.\n",
741 				SAS_ADDR(dev->sas_addr));
742 
743 			rc = SAS_PHY_DOWN;
744 			return rc;
745 	}
746 	tei.port = dev->port->lldd_port;
747 	if (tei.port && !tei.port->port_attached && !tmf) {
748 		if (sas_protocol_ata(task->task_proto)) {
749 			struct task_status_struct *ts = &task->task_status;
750 			mv_dprintk("SATA/STP port %d does not attach"
751 					"device.\n", dev->port->id);
752 			ts->resp = SAS_TASK_COMPLETE;
753 			ts->stat = SAS_PHY_DOWN;
754 
755 			task->task_done(task);
756 
757 		} else {
758 			struct task_status_struct *ts = &task->task_status;
759 			mv_dprintk("SAS port %d does not attach"
760 				"device.\n", dev->port->id);
761 			ts->resp = SAS_TASK_UNDELIVERED;
762 			ts->stat = SAS_PHY_DOWN;
763 			task->task_done(task);
764 		}
765 		return rc;
766 	}
767 
768 	if (!sas_protocol_ata(task->task_proto)) {
769 		if (task->num_scatter) {
770 			n_elem = dma_map_sg(mvi->dev,
771 					    task->scatter,
772 					    task->num_scatter,
773 					    task->data_dir);
774 			if (!n_elem) {
775 				rc = -ENOMEM;
776 				goto prep_out;
777 			}
778 		}
779 	} else {
780 		n_elem = task->num_scatter;
781 	}
782 
783 	rc = mvs_tag_alloc(mvi, &tag);
784 	if (rc)
785 		goto err_out;
786 
787 	slot = &mvi->slot_info[tag];
788 
789 	task->lldd_task = NULL;
790 	slot->n_elem = n_elem;
791 	slot->slot_tag = tag;
792 
793 	slot->buf = pci_pool_alloc(mvi->dma_pool, GFP_ATOMIC, &slot->buf_dma);
794 	if (!slot->buf)
795 		goto err_out_tag;
796 	memset(slot->buf, 0, MVS_SLOT_BUF_SZ);
797 
798 	tei.task = task;
799 	tei.hdr = &mvi->slot[tag];
800 	tei.tag = tag;
801 	tei.n_elem = n_elem;
802 	switch (task->task_proto) {
803 	case SAS_PROTOCOL_SMP:
804 		rc = mvs_task_prep_smp(mvi, &tei);
805 		break;
806 	case SAS_PROTOCOL_SSP:
807 		rc = mvs_task_prep_ssp(mvi, &tei, is_tmf, tmf);
808 		break;
809 	case SAS_PROTOCOL_SATA:
810 	case SAS_PROTOCOL_STP:
811 	case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
812 		rc = mvs_task_prep_ata(mvi, &tei);
813 		break;
814 	default:
815 		dev_printk(KERN_ERR, mvi->dev,
816 			"unknown sas_task proto: 0x%x\n",
817 			task->task_proto);
818 		rc = -EINVAL;
819 		break;
820 	}
821 
822 	if (rc) {
823 		mv_dprintk("rc is %x\n", rc);
824 		goto err_out_slot_buf;
825 	}
826 	slot->task = task;
827 	slot->port = tei.port;
828 	task->lldd_task = slot;
829 	list_add_tail(&slot->entry, &tei.port->list);
830 	spin_lock(&task->task_state_lock);
831 	task->task_state_flags |= SAS_TASK_AT_INITIATOR;
832 	spin_unlock(&task->task_state_lock);
833 
834 	mvi_dev->running_req++;
835 	++(*pass);
836 	mvi->tx_prod = (mvi->tx_prod + 1) & (MVS_CHIP_SLOT_SZ - 1);
837 
838 	return rc;
839 
840 err_out_slot_buf:
841 	pci_pool_free(mvi->dma_pool, slot->buf, slot->buf_dma);
842 err_out_tag:
843 	mvs_tag_free(mvi, tag);
844 err_out:
845 
846 	dev_printk(KERN_ERR, mvi->dev, "mvsas prep failed[%d]!\n", rc);
847 	if (!sas_protocol_ata(task->task_proto))
848 		if (n_elem)
849 			dma_unmap_sg(mvi->dev, task->scatter, n_elem,
850 				     task->data_dir);
851 prep_out:
852 	return rc;
853 }
854 
855 static struct mvs_task_list *mvs_task_alloc_list(int *num, gfp_t gfp_flags)
856 {
857 	struct mvs_task_list *first = NULL;
858 
859 	for (; *num > 0; --*num) {
860 		struct mvs_task_list *mvs_list = kmem_cache_zalloc(mvs_task_list_cache, gfp_flags);
861 
862 		if (!mvs_list)
863 			break;
864 
865 		INIT_LIST_HEAD(&mvs_list->list);
866 		if (!first)
867 			first = mvs_list;
868 		else
869 			list_add_tail(&mvs_list->list, &first->list);
870 
871 	}
872 
873 	return first;
874 }
875 
876 static inline void mvs_task_free_list(struct mvs_task_list *mvs_list)
877 {
878 	LIST_HEAD(list);
879 	struct list_head *pos, *a;
880 	struct mvs_task_list *mlist = NULL;
881 
882 	__list_add(&list, mvs_list->list.prev, &mvs_list->list);
883 
884 	list_for_each_safe(pos, a, &list) {
885 		list_del_init(pos);
886 		mlist = list_entry(pos, struct mvs_task_list, list);
887 		kmem_cache_free(mvs_task_list_cache, mlist);
888 	}
889 }
890 
891 static int mvs_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags,
892 				struct completion *completion, int is_tmf,
893 				struct mvs_tmf_task *tmf)
894 {
895 	struct mvs_info *mvi = NULL;
896 	u32 rc = 0;
897 	u32 pass = 0;
898 	unsigned long flags = 0;
899 
900 	mvi = ((struct mvs_device *)task->dev->lldd_dev)->mvi_info;
901 
902 	spin_lock_irqsave(&mvi->lock, flags);
903 	rc = mvs_task_prep(task, mvi, is_tmf, tmf, &pass);
904 	if (rc)
905 		dev_printk(KERN_ERR, mvi->dev, "mvsas exec failed[%d]!\n", rc);
906 
907 	if (likely(pass))
908 			MVS_CHIP_DISP->start_delivery(mvi, (mvi->tx_prod - 1) &
909 				(MVS_CHIP_SLOT_SZ - 1));
910 	spin_unlock_irqrestore(&mvi->lock, flags);
911 
912 	return rc;
913 }
914 
915 static int mvs_collector_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags,
916 				struct completion *completion, int is_tmf,
917 				struct mvs_tmf_task *tmf)
918 {
919 	struct domain_device *dev = task->dev;
920 	struct mvs_prv_info *mpi = dev->port->ha->lldd_ha;
921 	struct mvs_info *mvi = NULL;
922 	struct sas_task *t = task;
923 	struct mvs_task_list *mvs_list = NULL, *a;
924 	LIST_HEAD(q);
925 	int pass[2] = {0};
926 	u32 rc = 0;
927 	u32 n = num;
928 	unsigned long flags = 0;
929 
930 	mvs_list = mvs_task_alloc_list(&n, gfp_flags);
931 	if (n) {
932 		printk(KERN_ERR "%s: mvs alloc list failed.\n", __func__);
933 		rc = -ENOMEM;
934 		goto free_list;
935 	}
936 
937 	__list_add(&q, mvs_list->list.prev, &mvs_list->list);
938 
939 	list_for_each_entry(a, &q, list) {
940 		a->task = t;
941 		t = list_entry(t->list.next, struct sas_task, list);
942 	}
943 
944 	list_for_each_entry(a, &q , list) {
945 
946 		t = a->task;
947 		mvi = ((struct mvs_device *)t->dev->lldd_dev)->mvi_info;
948 
949 		spin_lock_irqsave(&mvi->lock, flags);
950 		rc = mvs_task_prep(t, mvi, is_tmf, tmf, &pass[mvi->id]);
951 		if (rc)
952 			dev_printk(KERN_ERR, mvi->dev, "mvsas exec failed[%d]!\n", rc);
953 		spin_unlock_irqrestore(&mvi->lock, flags);
954 	}
955 
956 	if (likely(pass[0]))
957 			MVS_CHIP_DISP->start_delivery(mpi->mvi[0],
958 				(mpi->mvi[0]->tx_prod - 1) & (MVS_CHIP_SLOT_SZ - 1));
959 
960 	if (likely(pass[1]))
961 			MVS_CHIP_DISP->start_delivery(mpi->mvi[1],
962 				(mpi->mvi[1]->tx_prod - 1) & (MVS_CHIP_SLOT_SZ - 1));
963 
964 	list_del_init(&q);
965 
966 free_list:
967 	if (mvs_list)
968 		mvs_task_free_list(mvs_list);
969 
970 	return rc;
971 }
972 
973 int mvs_queue_command(struct sas_task *task, const int num,
974 			gfp_t gfp_flags)
975 {
976 	struct mvs_device *mvi_dev = task->dev->lldd_dev;
977 	struct sas_ha_struct *sas = mvi_dev->mvi_info->sas;
978 
979 	if (sas->lldd_max_execute_num < 2)
980 		return mvs_task_exec(task, num, gfp_flags, NULL, 0, NULL);
981 	else
982 		return mvs_collector_task_exec(task, num, gfp_flags, NULL, 0, NULL);
983 }
984 
985 static void mvs_slot_free(struct mvs_info *mvi, u32 rx_desc)
986 {
987 	u32 slot_idx = rx_desc & RXQ_SLOT_MASK;
988 	mvs_tag_clear(mvi, slot_idx);
989 }
990 
991 static void mvs_slot_task_free(struct mvs_info *mvi, struct sas_task *task,
992 			  struct mvs_slot_info *slot, u32 slot_idx)
993 {
994 	if (!slot->task)
995 		return;
996 	if (!sas_protocol_ata(task->task_proto))
997 		if (slot->n_elem)
998 			dma_unmap_sg(mvi->dev, task->scatter,
999 				     slot->n_elem, task->data_dir);
1000 
1001 	switch (task->task_proto) {
1002 	case SAS_PROTOCOL_SMP:
1003 		dma_unmap_sg(mvi->dev, &task->smp_task.smp_resp, 1,
1004 			     PCI_DMA_FROMDEVICE);
1005 		dma_unmap_sg(mvi->dev, &task->smp_task.smp_req, 1,
1006 			     PCI_DMA_TODEVICE);
1007 		break;
1008 
1009 	case SAS_PROTOCOL_SATA:
1010 	case SAS_PROTOCOL_STP:
1011 	case SAS_PROTOCOL_SSP:
1012 	default:
1013 		/* do nothing */
1014 		break;
1015 	}
1016 
1017 	if (slot->buf) {
1018 		pci_pool_free(mvi->dma_pool, slot->buf, slot->buf_dma);
1019 		slot->buf = NULL;
1020 	}
1021 	list_del_init(&slot->entry);
1022 	task->lldd_task = NULL;
1023 	slot->task = NULL;
1024 	slot->port = NULL;
1025 	slot->slot_tag = 0xFFFFFFFF;
1026 	mvs_slot_free(mvi, slot_idx);
1027 }
1028 
1029 static void mvs_update_wideport(struct mvs_info *mvi, int phy_no)
1030 {
1031 	struct mvs_phy *phy = &mvi->phy[phy_no];
1032 	struct mvs_port *port = phy->port;
1033 	int j, no;
1034 
1035 	for_each_phy(port->wide_port_phymap, j, no) {
1036 		if (j & 1) {
1037 			MVS_CHIP_DISP->write_port_cfg_addr(mvi, no,
1038 						PHYR_WIDE_PORT);
1039 			MVS_CHIP_DISP->write_port_cfg_data(mvi, no,
1040 						port->wide_port_phymap);
1041 		} else {
1042 			MVS_CHIP_DISP->write_port_cfg_addr(mvi, no,
1043 						PHYR_WIDE_PORT);
1044 			MVS_CHIP_DISP->write_port_cfg_data(mvi, no,
1045 						0);
1046 		}
1047 	}
1048 }
1049 
1050 static u32 mvs_is_phy_ready(struct mvs_info *mvi, int i)
1051 {
1052 	u32 tmp;
1053 	struct mvs_phy *phy = &mvi->phy[i];
1054 	struct mvs_port *port = phy->port;
1055 
1056 	tmp = MVS_CHIP_DISP->read_phy_ctl(mvi, i);
1057 	if ((tmp & PHY_READY_MASK) && !(phy->irq_status & PHYEV_POOF)) {
1058 		if (!port)
1059 			phy->phy_attached = 1;
1060 		return tmp;
1061 	}
1062 
1063 	if (port) {
1064 		if (phy->phy_type & PORT_TYPE_SAS) {
1065 			port->wide_port_phymap &= ~(1U << i);
1066 			if (!port->wide_port_phymap)
1067 				port->port_attached = 0;
1068 			mvs_update_wideport(mvi, i);
1069 		} else if (phy->phy_type & PORT_TYPE_SATA)
1070 			port->port_attached = 0;
1071 		phy->port = NULL;
1072 		phy->phy_attached = 0;
1073 		phy->phy_type &= ~(PORT_TYPE_SAS | PORT_TYPE_SATA);
1074 	}
1075 	return 0;
1076 }
1077 
1078 static void *mvs_get_d2h_reg(struct mvs_info *mvi, int i, void *buf)
1079 {
1080 	u32 *s = (u32 *) buf;
1081 
1082 	if (!s)
1083 		return NULL;
1084 
1085 	MVS_CHIP_DISP->write_port_cfg_addr(mvi, i, PHYR_SATA_SIG3);
1086 	s[3] = cpu_to_le32(MVS_CHIP_DISP->read_port_cfg_data(mvi, i));
1087 
1088 	MVS_CHIP_DISP->write_port_cfg_addr(mvi, i, PHYR_SATA_SIG2);
1089 	s[2] = cpu_to_le32(MVS_CHIP_DISP->read_port_cfg_data(mvi, i));
1090 
1091 	MVS_CHIP_DISP->write_port_cfg_addr(mvi, i, PHYR_SATA_SIG1);
1092 	s[1] = cpu_to_le32(MVS_CHIP_DISP->read_port_cfg_data(mvi, i));
1093 
1094 	MVS_CHIP_DISP->write_port_cfg_addr(mvi, i, PHYR_SATA_SIG0);
1095 	s[0] = cpu_to_le32(MVS_CHIP_DISP->read_port_cfg_data(mvi, i));
1096 
1097 	if (((s[1] & 0x00FFFFFF) == 0x00EB1401) && (*(u8 *)&s[3] == 0x01))
1098 		s[1] = 0x00EB1401 | (*((u8 *)&s[1] + 3) & 0x10);
1099 
1100 	return s;
1101 }
1102 
1103 static u32 mvs_is_sig_fis_received(u32 irq_status)
1104 {
1105 	return irq_status & PHYEV_SIG_FIS;
1106 }
1107 
1108 static void mvs_sig_remove_timer(struct mvs_phy *phy)
1109 {
1110 	if (phy->timer.function)
1111 		del_timer(&phy->timer);
1112 	phy->timer.function = NULL;
1113 }
1114 
1115 void mvs_update_phyinfo(struct mvs_info *mvi, int i, int get_st)
1116 {
1117 	struct mvs_phy *phy = &mvi->phy[i];
1118 	struct sas_identify_frame *id;
1119 
1120 	id = (struct sas_identify_frame *)phy->frame_rcvd;
1121 
1122 	if (get_st) {
1123 		phy->irq_status = MVS_CHIP_DISP->read_port_irq_stat(mvi, i);
1124 		phy->phy_status = mvs_is_phy_ready(mvi, i);
1125 	}
1126 
1127 	if (phy->phy_status) {
1128 		int oob_done = 0;
1129 		struct asd_sas_phy *sas_phy = &mvi->phy[i].sas_phy;
1130 
1131 		oob_done = MVS_CHIP_DISP->oob_done(mvi, i);
1132 
1133 		MVS_CHIP_DISP->fix_phy_info(mvi, i, id);
1134 		if (phy->phy_type & PORT_TYPE_SATA) {
1135 			phy->identify.target_port_protocols = SAS_PROTOCOL_STP;
1136 			if (mvs_is_sig_fis_received(phy->irq_status)) {
1137 				mvs_sig_remove_timer(phy);
1138 				phy->phy_attached = 1;
1139 				phy->att_dev_sas_addr =
1140 					i + mvi->id * mvi->chip->n_phy;
1141 				if (oob_done)
1142 					sas_phy->oob_mode = SATA_OOB_MODE;
1143 				phy->frame_rcvd_size =
1144 				    sizeof(struct dev_to_host_fis);
1145 				mvs_get_d2h_reg(mvi, i, id);
1146 			} else {
1147 				u32 tmp;
1148 				dev_printk(KERN_DEBUG, mvi->dev,
1149 					"Phy%d : No sig fis\n", i);
1150 				tmp = MVS_CHIP_DISP->read_port_irq_mask(mvi, i);
1151 				MVS_CHIP_DISP->write_port_irq_mask(mvi, i,
1152 						tmp | PHYEV_SIG_FIS);
1153 				phy->phy_attached = 0;
1154 				phy->phy_type &= ~PORT_TYPE_SATA;
1155 				goto out_done;
1156 			}
1157 		}	else if (phy->phy_type & PORT_TYPE_SAS
1158 			|| phy->att_dev_info & PORT_SSP_INIT_MASK) {
1159 			phy->phy_attached = 1;
1160 			phy->identify.device_type =
1161 				phy->att_dev_info & PORT_DEV_TYPE_MASK;
1162 
1163 			if (phy->identify.device_type == SAS_END_DEVICE)
1164 				phy->identify.target_port_protocols =
1165 							SAS_PROTOCOL_SSP;
1166 			else if (phy->identify.device_type != SAS_PHY_UNUSED)
1167 				phy->identify.target_port_protocols =
1168 							SAS_PROTOCOL_SMP;
1169 			if (oob_done)
1170 				sas_phy->oob_mode = SAS_OOB_MODE;
1171 			phy->frame_rcvd_size =
1172 			    sizeof(struct sas_identify_frame);
1173 		}
1174 		memcpy(sas_phy->attached_sas_addr,
1175 			&phy->att_dev_sas_addr, SAS_ADDR_SIZE);
1176 
1177 		if (MVS_CHIP_DISP->phy_work_around)
1178 			MVS_CHIP_DISP->phy_work_around(mvi, i);
1179 	}
1180 	mv_dprintk("phy %d attach dev info is %x\n",
1181 		i + mvi->id * mvi->chip->n_phy, phy->att_dev_info);
1182 	mv_dprintk("phy %d attach sas addr is %llx\n",
1183 		i + mvi->id * mvi->chip->n_phy, phy->att_dev_sas_addr);
1184 out_done:
1185 	if (get_st)
1186 		MVS_CHIP_DISP->write_port_irq_stat(mvi, i, phy->irq_status);
1187 }
1188 
1189 static void mvs_port_notify_formed(struct asd_sas_phy *sas_phy, int lock)
1190 {
1191 	struct sas_ha_struct *sas_ha = sas_phy->ha;
1192 	struct mvs_info *mvi = NULL; int i = 0, hi;
1193 	struct mvs_phy *phy = sas_phy->lldd_phy;
1194 	struct asd_sas_port *sas_port = sas_phy->port;
1195 	struct mvs_port *port;
1196 	unsigned long flags = 0;
1197 	if (!sas_port)
1198 		return;
1199 
1200 	while (sas_ha->sas_phy[i]) {
1201 		if (sas_ha->sas_phy[i] == sas_phy)
1202 			break;
1203 		i++;
1204 	}
1205 	hi = i/((struct mvs_prv_info *)sas_ha->lldd_ha)->n_phy;
1206 	mvi = ((struct mvs_prv_info *)sas_ha->lldd_ha)->mvi[hi];
1207 	if (i >= mvi->chip->n_phy)
1208 		port = &mvi->port[i - mvi->chip->n_phy];
1209 	else
1210 		port = &mvi->port[i];
1211 	if (lock)
1212 		spin_lock_irqsave(&mvi->lock, flags);
1213 	port->port_attached = 1;
1214 	phy->port = port;
1215 	sas_port->lldd_port = port;
1216 	if (phy->phy_type & PORT_TYPE_SAS) {
1217 		port->wide_port_phymap = sas_port->phy_mask;
1218 		mv_printk("set wide port phy map %x\n", sas_port->phy_mask);
1219 		mvs_update_wideport(mvi, sas_phy->id);
1220 
1221 		/* direct attached SAS device */
1222 		if (phy->att_dev_info & PORT_SSP_TRGT_MASK) {
1223 			MVS_CHIP_DISP->write_port_cfg_addr(mvi, i, PHYR_PHY_STAT);
1224 			MVS_CHIP_DISP->write_port_cfg_data(mvi, i, 0x04);
1225 		}
1226 	}
1227 	if (lock)
1228 		spin_unlock_irqrestore(&mvi->lock, flags);
1229 }
1230 
1231 static void mvs_port_notify_deformed(struct asd_sas_phy *sas_phy, int lock)
1232 {
1233 	struct domain_device *dev;
1234 	struct mvs_phy *phy = sas_phy->lldd_phy;
1235 	struct mvs_info *mvi = phy->mvi;
1236 	struct asd_sas_port *port = sas_phy->port;
1237 	int phy_no = 0;
1238 
1239 	while (phy != &mvi->phy[phy_no]) {
1240 		phy_no++;
1241 		if (phy_no >= MVS_MAX_PHYS)
1242 			return;
1243 	}
1244 	list_for_each_entry(dev, &port->dev_list, dev_list_node)
1245 		mvs_do_release_task(phy->mvi, phy_no, dev);
1246 
1247 }
1248 
1249 
1250 void mvs_port_formed(struct asd_sas_phy *sas_phy)
1251 {
1252 	mvs_port_notify_formed(sas_phy, 1);
1253 }
1254 
1255 void mvs_port_deformed(struct asd_sas_phy *sas_phy)
1256 {
1257 	mvs_port_notify_deformed(sas_phy, 1);
1258 }
1259 
1260 struct mvs_device *mvs_alloc_dev(struct mvs_info *mvi)
1261 {
1262 	u32 dev;
1263 	for (dev = 0; dev < MVS_MAX_DEVICES; dev++) {
1264 		if (mvi->devices[dev].dev_type == SAS_PHY_UNUSED) {
1265 			mvi->devices[dev].device_id = dev;
1266 			return &mvi->devices[dev];
1267 		}
1268 	}
1269 
1270 	if (dev == MVS_MAX_DEVICES)
1271 		mv_printk("max support %d devices, ignore ..\n",
1272 			MVS_MAX_DEVICES);
1273 
1274 	return NULL;
1275 }
1276 
1277 void mvs_free_dev(struct mvs_device *mvi_dev)
1278 {
1279 	u32 id = mvi_dev->device_id;
1280 	memset(mvi_dev, 0, sizeof(*mvi_dev));
1281 	mvi_dev->device_id = id;
1282 	mvi_dev->dev_type = SAS_PHY_UNUSED;
1283 	mvi_dev->dev_status = MVS_DEV_NORMAL;
1284 	mvi_dev->taskfileset = MVS_ID_NOT_MAPPED;
1285 }
1286 
1287 int mvs_dev_found_notify(struct domain_device *dev, int lock)
1288 {
1289 	unsigned long flags = 0;
1290 	int res = 0;
1291 	struct mvs_info *mvi = NULL;
1292 	struct domain_device *parent_dev = dev->parent;
1293 	struct mvs_device *mvi_device;
1294 
1295 	mvi = mvs_find_dev_mvi(dev);
1296 
1297 	if (lock)
1298 		spin_lock_irqsave(&mvi->lock, flags);
1299 
1300 	mvi_device = mvs_alloc_dev(mvi);
1301 	if (!mvi_device) {
1302 		res = -1;
1303 		goto found_out;
1304 	}
1305 	dev->lldd_dev = mvi_device;
1306 	mvi_device->dev_status = MVS_DEV_NORMAL;
1307 	mvi_device->dev_type = dev->dev_type;
1308 	mvi_device->mvi_info = mvi;
1309 	mvi_device->sas_device = dev;
1310 	if (parent_dev && DEV_IS_EXPANDER(parent_dev->dev_type)) {
1311 		int phy_id;
1312 		u8 phy_num = parent_dev->ex_dev.num_phys;
1313 		struct ex_phy *phy;
1314 		for (phy_id = 0; phy_id < phy_num; phy_id++) {
1315 			phy = &parent_dev->ex_dev.ex_phy[phy_id];
1316 			if (SAS_ADDR(phy->attached_sas_addr) ==
1317 				SAS_ADDR(dev->sas_addr)) {
1318 				mvi_device->attached_phy = phy_id;
1319 				break;
1320 			}
1321 		}
1322 
1323 		if (phy_id == phy_num) {
1324 			mv_printk("Error: no attached dev:%016llx"
1325 				"at ex:%016llx.\n",
1326 				SAS_ADDR(dev->sas_addr),
1327 				SAS_ADDR(parent_dev->sas_addr));
1328 			res = -1;
1329 		}
1330 	}
1331 
1332 found_out:
1333 	if (lock)
1334 		spin_unlock_irqrestore(&mvi->lock, flags);
1335 	return res;
1336 }
1337 
1338 int mvs_dev_found(struct domain_device *dev)
1339 {
1340 	return mvs_dev_found_notify(dev, 1);
1341 }
1342 
1343 void mvs_dev_gone_notify(struct domain_device *dev)
1344 {
1345 	unsigned long flags = 0;
1346 	struct mvs_device *mvi_dev = dev->lldd_dev;
1347 	struct mvs_info *mvi;
1348 
1349 	if (!mvi_dev) {
1350 		mv_dprintk("found dev has gone.\n");
1351 		return;
1352 	}
1353 
1354 	mvi = mvi_dev->mvi_info;
1355 
1356 	spin_lock_irqsave(&mvi->lock, flags);
1357 
1358 	mv_dprintk("found dev[%d:%x] is gone.\n",
1359 		mvi_dev->device_id, mvi_dev->dev_type);
1360 	mvs_release_task(mvi, dev);
1361 	mvs_free_reg_set(mvi, mvi_dev);
1362 	mvs_free_dev(mvi_dev);
1363 
1364 	dev->lldd_dev = NULL;
1365 	mvi_dev->sas_device = NULL;
1366 
1367 	spin_unlock_irqrestore(&mvi->lock, flags);
1368 }
1369 
1370 
1371 void mvs_dev_gone(struct domain_device *dev)
1372 {
1373 	mvs_dev_gone_notify(dev);
1374 }
1375 
1376 static void mvs_task_done(struct sas_task *task)
1377 {
1378 	if (!del_timer(&task->slow_task->timer))
1379 		return;
1380 	complete(&task->slow_task->completion);
1381 }
1382 
1383 static void mvs_tmf_timedout(unsigned long data)
1384 {
1385 	struct sas_task *task = (struct sas_task *)data;
1386 
1387 	task->task_state_flags |= SAS_TASK_STATE_ABORTED;
1388 	complete(&task->slow_task->completion);
1389 }
1390 
1391 #define MVS_TASK_TIMEOUT 20
1392 static int mvs_exec_internal_tmf_task(struct domain_device *dev,
1393 			void *parameter, u32 para_len, struct mvs_tmf_task *tmf)
1394 {
1395 	int res, retry;
1396 	struct sas_task *task = NULL;
1397 
1398 	for (retry = 0; retry < 3; retry++) {
1399 		task = sas_alloc_slow_task(GFP_KERNEL);
1400 		if (!task)
1401 			return -ENOMEM;
1402 
1403 		task->dev = dev;
1404 		task->task_proto = dev->tproto;
1405 
1406 		memcpy(&task->ssp_task, parameter, para_len);
1407 		task->task_done = mvs_task_done;
1408 
1409 		task->slow_task->timer.data = (unsigned long) task;
1410 		task->slow_task->timer.function = mvs_tmf_timedout;
1411 		task->slow_task->timer.expires = jiffies + MVS_TASK_TIMEOUT*HZ;
1412 		add_timer(&task->slow_task->timer);
1413 
1414 		res = mvs_task_exec(task, 1, GFP_KERNEL, NULL, 1, tmf);
1415 
1416 		if (res) {
1417 			del_timer(&task->slow_task->timer);
1418 			mv_printk("executing internal task failed:%d\n", res);
1419 			goto ex_err;
1420 		}
1421 
1422 		wait_for_completion(&task->slow_task->completion);
1423 		res = TMF_RESP_FUNC_FAILED;
1424 		/* Even TMF timed out, return direct. */
1425 		if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
1426 			if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
1427 				mv_printk("TMF task[%x] timeout.\n", tmf->tmf);
1428 				goto ex_err;
1429 			}
1430 		}
1431 
1432 		if (task->task_status.resp == SAS_TASK_COMPLETE &&
1433 		    task->task_status.stat == SAM_STAT_GOOD) {
1434 			res = TMF_RESP_FUNC_COMPLETE;
1435 			break;
1436 		}
1437 
1438 		if (task->task_status.resp == SAS_TASK_COMPLETE &&
1439 		      task->task_status.stat == SAS_DATA_UNDERRUN) {
1440 			/* no error, but return the number of bytes of
1441 			 * underrun */
1442 			res = task->task_status.residual;
1443 			break;
1444 		}
1445 
1446 		if (task->task_status.resp == SAS_TASK_COMPLETE &&
1447 		      task->task_status.stat == SAS_DATA_OVERRUN) {
1448 			mv_dprintk("blocked task error.\n");
1449 			res = -EMSGSIZE;
1450 			break;
1451 		} else {
1452 			mv_dprintk(" task to dev %016llx response: 0x%x "
1453 				    "status 0x%x\n",
1454 				    SAS_ADDR(dev->sas_addr),
1455 				    task->task_status.resp,
1456 				    task->task_status.stat);
1457 			sas_free_task(task);
1458 			task = NULL;
1459 
1460 		}
1461 	}
1462 ex_err:
1463 	BUG_ON(retry == 3 && task != NULL);
1464 	sas_free_task(task);
1465 	return res;
1466 }
1467 
1468 static int mvs_debug_issue_ssp_tmf(struct domain_device *dev,
1469 				u8 *lun, struct mvs_tmf_task *tmf)
1470 {
1471 	struct sas_ssp_task ssp_task;
1472 	if (!(dev->tproto & SAS_PROTOCOL_SSP))
1473 		return TMF_RESP_FUNC_ESUPP;
1474 
1475 	memcpy(ssp_task.LUN, lun, 8);
1476 
1477 	return mvs_exec_internal_tmf_task(dev, &ssp_task,
1478 				sizeof(ssp_task), tmf);
1479 }
1480 
1481 
1482 /*  Standard mandates link reset for ATA  (type 0)
1483     and hard reset for SSP (type 1) , only for RECOVERY */
1484 static int mvs_debug_I_T_nexus_reset(struct domain_device *dev)
1485 {
1486 	int rc;
1487 	struct sas_phy *phy = sas_get_local_phy(dev);
1488 	int reset_type = (dev->dev_type == SAS_SATA_DEV ||
1489 			(dev->tproto & SAS_PROTOCOL_STP)) ? 0 : 1;
1490 	rc = sas_phy_reset(phy, reset_type);
1491 	sas_put_local_phy(phy);
1492 	msleep(2000);
1493 	return rc;
1494 }
1495 
1496 /* mandatory SAM-3 */
1497 int mvs_lu_reset(struct domain_device *dev, u8 *lun)
1498 {
1499 	unsigned long flags;
1500 	int rc = TMF_RESP_FUNC_FAILED;
1501 	struct mvs_tmf_task tmf_task;
1502 	struct mvs_device * mvi_dev = dev->lldd_dev;
1503 	struct mvs_info *mvi = mvi_dev->mvi_info;
1504 
1505 	tmf_task.tmf = TMF_LU_RESET;
1506 	mvi_dev->dev_status = MVS_DEV_EH;
1507 	rc = mvs_debug_issue_ssp_tmf(dev, lun, &tmf_task);
1508 	if (rc == TMF_RESP_FUNC_COMPLETE) {
1509 		spin_lock_irqsave(&mvi->lock, flags);
1510 		mvs_release_task(mvi, dev);
1511 		spin_unlock_irqrestore(&mvi->lock, flags);
1512 	}
1513 	/* If failed, fall-through I_T_Nexus reset */
1514 	mv_printk("%s for device[%x]:rc= %d\n", __func__,
1515 			mvi_dev->device_id, rc);
1516 	return rc;
1517 }
1518 
1519 int mvs_I_T_nexus_reset(struct domain_device *dev)
1520 {
1521 	unsigned long flags;
1522 	int rc = TMF_RESP_FUNC_FAILED;
1523     struct mvs_device * mvi_dev = (struct mvs_device *)dev->lldd_dev;
1524 	struct mvs_info *mvi = mvi_dev->mvi_info;
1525 
1526 	if (mvi_dev->dev_status != MVS_DEV_EH)
1527 		return TMF_RESP_FUNC_COMPLETE;
1528 	else
1529 		mvi_dev->dev_status = MVS_DEV_NORMAL;
1530 	rc = mvs_debug_I_T_nexus_reset(dev);
1531 	mv_printk("%s for device[%x]:rc= %d\n",
1532 		__func__, mvi_dev->device_id, rc);
1533 
1534 	spin_lock_irqsave(&mvi->lock, flags);
1535 	mvs_release_task(mvi, dev);
1536 	spin_unlock_irqrestore(&mvi->lock, flags);
1537 
1538 	return rc;
1539 }
1540 /* optional SAM-3 */
1541 int mvs_query_task(struct sas_task *task)
1542 {
1543 	u32 tag;
1544 	struct scsi_lun lun;
1545 	struct mvs_tmf_task tmf_task;
1546 	int rc = TMF_RESP_FUNC_FAILED;
1547 
1548 	if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SSP) {
1549 		struct scsi_cmnd * cmnd = (struct scsi_cmnd *)task->uldd_task;
1550 		struct domain_device *dev = task->dev;
1551 		struct mvs_device *mvi_dev = (struct mvs_device *)dev->lldd_dev;
1552 		struct mvs_info *mvi = mvi_dev->mvi_info;
1553 
1554 		int_to_scsilun(cmnd->device->lun, &lun);
1555 		rc = mvs_find_tag(mvi, task, &tag);
1556 		if (rc == 0) {
1557 			rc = TMF_RESP_FUNC_FAILED;
1558 			return rc;
1559 		}
1560 
1561 		tmf_task.tmf = TMF_QUERY_TASK;
1562 		tmf_task.tag_of_task_to_be_managed = cpu_to_le16(tag);
1563 
1564 		rc = mvs_debug_issue_ssp_tmf(dev, lun.scsi_lun, &tmf_task);
1565 		switch (rc) {
1566 		/* The task is still in Lun, release it then */
1567 		case TMF_RESP_FUNC_SUCC:
1568 		/* The task is not in Lun or failed, reset the phy */
1569 		case TMF_RESP_FUNC_FAILED:
1570 		case TMF_RESP_FUNC_COMPLETE:
1571 			break;
1572 		}
1573 	}
1574 	mv_printk("%s:rc= %d\n", __func__, rc);
1575 	return rc;
1576 }
1577 
1578 /*  mandatory SAM-3, still need free task/slot info */
1579 int mvs_abort_task(struct sas_task *task)
1580 {
1581 	struct scsi_lun lun;
1582 	struct mvs_tmf_task tmf_task;
1583 	struct domain_device *dev = task->dev;
1584 	struct mvs_device *mvi_dev = (struct mvs_device *)dev->lldd_dev;
1585 	struct mvs_info *mvi;
1586 	int rc = TMF_RESP_FUNC_FAILED;
1587 	unsigned long flags;
1588 	u32 tag;
1589 
1590 	if (!mvi_dev) {
1591 		mv_printk("Device has removed\n");
1592 		return TMF_RESP_FUNC_FAILED;
1593 	}
1594 
1595 	mvi = mvi_dev->mvi_info;
1596 
1597 	spin_lock_irqsave(&task->task_state_lock, flags);
1598 	if (task->task_state_flags & SAS_TASK_STATE_DONE) {
1599 		spin_unlock_irqrestore(&task->task_state_lock, flags);
1600 		rc = TMF_RESP_FUNC_COMPLETE;
1601 		goto out;
1602 	}
1603 	spin_unlock_irqrestore(&task->task_state_lock, flags);
1604 	mvi_dev->dev_status = MVS_DEV_EH;
1605 	if (task->lldd_task && task->task_proto & SAS_PROTOCOL_SSP) {
1606 		struct scsi_cmnd * cmnd = (struct scsi_cmnd *)task->uldd_task;
1607 
1608 		int_to_scsilun(cmnd->device->lun, &lun);
1609 		rc = mvs_find_tag(mvi, task, &tag);
1610 		if (rc == 0) {
1611 			mv_printk("No such tag in %s\n", __func__);
1612 			rc = TMF_RESP_FUNC_FAILED;
1613 			return rc;
1614 		}
1615 
1616 		tmf_task.tmf = TMF_ABORT_TASK;
1617 		tmf_task.tag_of_task_to_be_managed = cpu_to_le16(tag);
1618 
1619 		rc = mvs_debug_issue_ssp_tmf(dev, lun.scsi_lun, &tmf_task);
1620 
1621 		/* if successful, clear the task and callback forwards.*/
1622 		if (rc == TMF_RESP_FUNC_COMPLETE) {
1623 			u32 slot_no;
1624 			struct mvs_slot_info *slot;
1625 
1626 			if (task->lldd_task) {
1627 				slot = task->lldd_task;
1628 				slot_no = (u32) (slot - mvi->slot_info);
1629 				spin_lock_irqsave(&mvi->lock, flags);
1630 				mvs_slot_complete(mvi, slot_no, 1);
1631 				spin_unlock_irqrestore(&mvi->lock, flags);
1632 			}
1633 		}
1634 
1635 	} else if (task->task_proto & SAS_PROTOCOL_SATA ||
1636 		task->task_proto & SAS_PROTOCOL_STP) {
1637 		if (SAS_SATA_DEV == dev->dev_type) {
1638 			struct mvs_slot_info *slot = task->lldd_task;
1639 			u32 slot_idx = (u32)(slot - mvi->slot_info);
1640 			mv_dprintk("mvs_abort_task() mvi=%p task=%p "
1641 				   "slot=%p slot_idx=x%x\n",
1642 				   mvi, task, slot, slot_idx);
1643 			task->task_state_flags |= SAS_TASK_STATE_ABORTED;
1644 			mvs_slot_task_free(mvi, task, slot, slot_idx);
1645 			rc = TMF_RESP_FUNC_COMPLETE;
1646 			goto out;
1647 		}
1648 
1649 	}
1650 out:
1651 	if (rc != TMF_RESP_FUNC_COMPLETE)
1652 		mv_printk("%s:rc= %d\n", __func__, rc);
1653 	return rc;
1654 }
1655 
1656 int mvs_abort_task_set(struct domain_device *dev, u8 *lun)
1657 {
1658 	int rc = TMF_RESP_FUNC_FAILED;
1659 	struct mvs_tmf_task tmf_task;
1660 
1661 	tmf_task.tmf = TMF_ABORT_TASK_SET;
1662 	rc = mvs_debug_issue_ssp_tmf(dev, lun, &tmf_task);
1663 
1664 	return rc;
1665 }
1666 
1667 int mvs_clear_aca(struct domain_device *dev, u8 *lun)
1668 {
1669 	int rc = TMF_RESP_FUNC_FAILED;
1670 	struct mvs_tmf_task tmf_task;
1671 
1672 	tmf_task.tmf = TMF_CLEAR_ACA;
1673 	rc = mvs_debug_issue_ssp_tmf(dev, lun, &tmf_task);
1674 
1675 	return rc;
1676 }
1677 
1678 int mvs_clear_task_set(struct domain_device *dev, u8 *lun)
1679 {
1680 	int rc = TMF_RESP_FUNC_FAILED;
1681 	struct mvs_tmf_task tmf_task;
1682 
1683 	tmf_task.tmf = TMF_CLEAR_TASK_SET;
1684 	rc = mvs_debug_issue_ssp_tmf(dev, lun, &tmf_task);
1685 
1686 	return rc;
1687 }
1688 
1689 static int mvs_sata_done(struct mvs_info *mvi, struct sas_task *task,
1690 			u32 slot_idx, int err)
1691 {
1692 	struct mvs_device *mvi_dev = task->dev->lldd_dev;
1693 	struct task_status_struct *tstat = &task->task_status;
1694 	struct ata_task_resp *resp = (struct ata_task_resp *)tstat->buf;
1695 	int stat = SAM_STAT_GOOD;
1696 
1697 
1698 	resp->frame_len = sizeof(struct dev_to_host_fis);
1699 	memcpy(&resp->ending_fis[0],
1700 	       SATA_RECEIVED_D2H_FIS(mvi_dev->taskfileset),
1701 	       sizeof(struct dev_to_host_fis));
1702 	tstat->buf_valid_size = sizeof(*resp);
1703 	if (unlikely(err)) {
1704 		if (unlikely(err & CMD_ISS_STPD))
1705 			stat = SAS_OPEN_REJECT;
1706 		else
1707 			stat = SAS_PROTO_RESPONSE;
1708        }
1709 
1710 	return stat;
1711 }
1712 
1713 void mvs_set_sense(u8 *buffer, int len, int d_sense,
1714 		int key, int asc, int ascq)
1715 {
1716 	memset(buffer, 0, len);
1717 
1718 	if (d_sense) {
1719 		/* Descriptor format */
1720 		if (len < 4) {
1721 			mv_printk("Length %d of sense buffer too small to "
1722 				"fit sense %x:%x:%x", len, key, asc, ascq);
1723 		}
1724 
1725 		buffer[0] = 0x72;		/* Response Code	*/
1726 		if (len > 1)
1727 			buffer[1] = key;	/* Sense Key */
1728 		if (len > 2)
1729 			buffer[2] = asc;	/* ASC	*/
1730 		if (len > 3)
1731 			buffer[3] = ascq;	/* ASCQ	*/
1732 	} else {
1733 		if (len < 14) {
1734 			mv_printk("Length %d of sense buffer too small to "
1735 				"fit sense %x:%x:%x", len, key, asc, ascq);
1736 		}
1737 
1738 		buffer[0] = 0x70;		/* Response Code	*/
1739 		if (len > 2)
1740 			buffer[2] = key;	/* Sense Key */
1741 		if (len > 7)
1742 			buffer[7] = 0x0a;	/* Additional Sense Length */
1743 		if (len > 12)
1744 			buffer[12] = asc;	/* ASC */
1745 		if (len > 13)
1746 			buffer[13] = ascq; /* ASCQ */
1747 	}
1748 
1749 	return;
1750 }
1751 
1752 void mvs_fill_ssp_resp_iu(struct ssp_response_iu *iu,
1753 				u8 key, u8 asc, u8 asc_q)
1754 {
1755 	iu->datapres = 2;
1756 	iu->response_data_len = 0;
1757 	iu->sense_data_len = 17;
1758 	iu->status = 02;
1759 	mvs_set_sense(iu->sense_data, 17, 0,
1760 			key, asc, asc_q);
1761 }
1762 
1763 static int mvs_slot_err(struct mvs_info *mvi, struct sas_task *task,
1764 			 u32 slot_idx)
1765 {
1766 	struct mvs_slot_info *slot = &mvi->slot_info[slot_idx];
1767 	int stat;
1768 	u32 err_dw0 = le32_to_cpu(*(u32 *)slot->response);
1769 	u32 err_dw1 = le32_to_cpu(*((u32 *)slot->response + 1));
1770 	u32 tfs = 0;
1771 	enum mvs_port_type type = PORT_TYPE_SAS;
1772 
1773 	if (err_dw0 & CMD_ISS_STPD)
1774 		MVS_CHIP_DISP->issue_stop(mvi, type, tfs);
1775 
1776 	MVS_CHIP_DISP->command_active(mvi, slot_idx);
1777 
1778 	stat = SAM_STAT_CHECK_CONDITION;
1779 	switch (task->task_proto) {
1780 	case SAS_PROTOCOL_SSP:
1781 	{
1782 		stat = SAS_ABORTED_TASK;
1783 		if ((err_dw0 & NO_DEST) || err_dw1 & bit(31)) {
1784 			struct ssp_response_iu *iu = slot->response +
1785 				sizeof(struct mvs_err_info);
1786 			mvs_fill_ssp_resp_iu(iu, NOT_READY, 0x04, 01);
1787 			sas_ssp_task_response(mvi->dev, task, iu);
1788 			stat = SAM_STAT_CHECK_CONDITION;
1789 		}
1790 		if (err_dw1 & bit(31))
1791 			mv_printk("reuse same slot, retry command.\n");
1792 		break;
1793 	}
1794 	case SAS_PROTOCOL_SMP:
1795 		stat = SAM_STAT_CHECK_CONDITION;
1796 		break;
1797 
1798 	case SAS_PROTOCOL_SATA:
1799 	case SAS_PROTOCOL_STP:
1800 	case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
1801 	{
1802 		task->ata_task.use_ncq = 0;
1803 		stat = SAS_PROTO_RESPONSE;
1804 		mvs_sata_done(mvi, task, slot_idx, err_dw0);
1805 	}
1806 		break;
1807 	default:
1808 		break;
1809 	}
1810 
1811 	return stat;
1812 }
1813 
1814 int mvs_slot_complete(struct mvs_info *mvi, u32 rx_desc, u32 flags)
1815 {
1816 	u32 slot_idx = rx_desc & RXQ_SLOT_MASK;
1817 	struct mvs_slot_info *slot = &mvi->slot_info[slot_idx];
1818 	struct sas_task *task = slot->task;
1819 	struct mvs_device *mvi_dev = NULL;
1820 	struct task_status_struct *tstat;
1821 	struct domain_device *dev;
1822 	u32 aborted;
1823 
1824 	void *to;
1825 	enum exec_status sts;
1826 
1827 	if (unlikely(!task || !task->lldd_task || !task->dev))
1828 		return -1;
1829 
1830 	tstat = &task->task_status;
1831 	dev = task->dev;
1832 	mvi_dev = dev->lldd_dev;
1833 
1834 	spin_lock(&task->task_state_lock);
1835 	task->task_state_flags &=
1836 		~(SAS_TASK_STATE_PENDING | SAS_TASK_AT_INITIATOR);
1837 	task->task_state_flags |= SAS_TASK_STATE_DONE;
1838 	/* race condition*/
1839 	aborted = task->task_state_flags & SAS_TASK_STATE_ABORTED;
1840 	spin_unlock(&task->task_state_lock);
1841 
1842 	memset(tstat, 0, sizeof(*tstat));
1843 	tstat->resp = SAS_TASK_COMPLETE;
1844 
1845 	if (unlikely(aborted)) {
1846 		tstat->stat = SAS_ABORTED_TASK;
1847 		if (mvi_dev && mvi_dev->running_req)
1848 			mvi_dev->running_req--;
1849 		if (sas_protocol_ata(task->task_proto))
1850 			mvs_free_reg_set(mvi, mvi_dev);
1851 
1852 		mvs_slot_task_free(mvi, task, slot, slot_idx);
1853 		return -1;
1854 	}
1855 
1856 	/* when no device attaching, go ahead and complete by error handling*/
1857 	if (unlikely(!mvi_dev || flags)) {
1858 		if (!mvi_dev)
1859 			mv_dprintk("port has not device.\n");
1860 		tstat->stat = SAS_PHY_DOWN;
1861 		goto out;
1862 	}
1863 
1864 	/*
1865 	 * error info record present; slot->response is 32 bit aligned but may
1866 	 * not be 64 bit aligned, so check for zero in two 32 bit reads
1867 	 */
1868 	if (unlikely((rx_desc & RXQ_ERR)
1869 		     && (*((u32 *)slot->response)
1870 			 || *(((u32 *)slot->response) + 1)))) {
1871 		mv_dprintk("port %d slot %d rx_desc %X has error info"
1872 			"%016llX.\n", slot->port->sas_port.id, slot_idx,
1873 			 rx_desc, get_unaligned_le64(slot->response));
1874 		tstat->stat = mvs_slot_err(mvi, task, slot_idx);
1875 		tstat->resp = SAS_TASK_COMPLETE;
1876 		goto out;
1877 	}
1878 
1879 	switch (task->task_proto) {
1880 	case SAS_PROTOCOL_SSP:
1881 		/* hw says status == 0, datapres == 0 */
1882 		if (rx_desc & RXQ_GOOD) {
1883 			tstat->stat = SAM_STAT_GOOD;
1884 			tstat->resp = SAS_TASK_COMPLETE;
1885 		}
1886 		/* response frame present */
1887 		else if (rx_desc & RXQ_RSP) {
1888 			struct ssp_response_iu *iu = slot->response +
1889 						sizeof(struct mvs_err_info);
1890 			sas_ssp_task_response(mvi->dev, task, iu);
1891 		} else
1892 			tstat->stat = SAM_STAT_CHECK_CONDITION;
1893 		break;
1894 
1895 	case SAS_PROTOCOL_SMP: {
1896 			struct scatterlist *sg_resp = &task->smp_task.smp_resp;
1897 			tstat->stat = SAM_STAT_GOOD;
1898 			to = kmap_atomic(sg_page(sg_resp));
1899 			memcpy(to + sg_resp->offset,
1900 				slot->response + sizeof(struct mvs_err_info),
1901 				sg_dma_len(sg_resp));
1902 			kunmap_atomic(to);
1903 			break;
1904 		}
1905 
1906 	case SAS_PROTOCOL_SATA:
1907 	case SAS_PROTOCOL_STP:
1908 	case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP: {
1909 			tstat->stat = mvs_sata_done(mvi, task, slot_idx, 0);
1910 			break;
1911 		}
1912 
1913 	default:
1914 		tstat->stat = SAM_STAT_CHECK_CONDITION;
1915 		break;
1916 	}
1917 	if (!slot->port->port_attached) {
1918 		mv_dprintk("port %d has removed.\n", slot->port->sas_port.id);
1919 		tstat->stat = SAS_PHY_DOWN;
1920 	}
1921 
1922 
1923 out:
1924 	if (mvi_dev && mvi_dev->running_req) {
1925 		mvi_dev->running_req--;
1926 		if (sas_protocol_ata(task->task_proto) && !mvi_dev->running_req)
1927 			mvs_free_reg_set(mvi, mvi_dev);
1928 	}
1929 	mvs_slot_task_free(mvi, task, slot, slot_idx);
1930 	sts = tstat->stat;
1931 
1932 	spin_unlock(&mvi->lock);
1933 	if (task->task_done)
1934 		task->task_done(task);
1935 
1936 	spin_lock(&mvi->lock);
1937 
1938 	return sts;
1939 }
1940 
1941 void mvs_do_release_task(struct mvs_info *mvi,
1942 		int phy_no, struct domain_device *dev)
1943 {
1944 	u32 slot_idx;
1945 	struct mvs_phy *phy;
1946 	struct mvs_port *port;
1947 	struct mvs_slot_info *slot, *slot2;
1948 
1949 	phy = &mvi->phy[phy_no];
1950 	port = phy->port;
1951 	if (!port)
1952 		return;
1953 	/* clean cmpl queue in case request is already finished */
1954 	mvs_int_rx(mvi, false);
1955 
1956 
1957 
1958 	list_for_each_entry_safe(slot, slot2, &port->list, entry) {
1959 		struct sas_task *task;
1960 		slot_idx = (u32) (slot - mvi->slot_info);
1961 		task = slot->task;
1962 
1963 		if (dev && task->dev != dev)
1964 			continue;
1965 
1966 		mv_printk("Release slot [%x] tag[%x], task [%p]:\n",
1967 			slot_idx, slot->slot_tag, task);
1968 		MVS_CHIP_DISP->command_active(mvi, slot_idx);
1969 
1970 		mvs_slot_complete(mvi, slot_idx, 1);
1971 	}
1972 }
1973 
1974 void mvs_release_task(struct mvs_info *mvi,
1975 		      struct domain_device *dev)
1976 {
1977 	int i, phyno[WIDE_PORT_MAX_PHY], num;
1978 	num = mvs_find_dev_phyno(dev, phyno);
1979 	for (i = 0; i < num; i++)
1980 		mvs_do_release_task(mvi, phyno[i], dev);
1981 }
1982 
1983 static void mvs_phy_disconnected(struct mvs_phy *phy)
1984 {
1985 	phy->phy_attached = 0;
1986 	phy->att_dev_info = 0;
1987 	phy->att_dev_sas_addr = 0;
1988 }
1989 
1990 static void mvs_work_queue(struct work_struct *work)
1991 {
1992 	struct delayed_work *dw = container_of(work, struct delayed_work, work);
1993 	struct mvs_wq *mwq = container_of(dw, struct mvs_wq, work_q);
1994 	struct mvs_info *mvi = mwq->mvi;
1995 	unsigned long flags;
1996 	u32 phy_no = (unsigned long) mwq->data;
1997 	struct sas_ha_struct *sas_ha = mvi->sas;
1998 	struct mvs_phy *phy = &mvi->phy[phy_no];
1999 	struct asd_sas_phy *sas_phy = &phy->sas_phy;
2000 
2001 	spin_lock_irqsave(&mvi->lock, flags);
2002 	if (mwq->handler & PHY_PLUG_EVENT) {
2003 
2004 		if (phy->phy_event & PHY_PLUG_OUT) {
2005 			u32 tmp;
2006 			struct sas_identify_frame *id;
2007 			id = (struct sas_identify_frame *)phy->frame_rcvd;
2008 			tmp = MVS_CHIP_DISP->read_phy_ctl(mvi, phy_no);
2009 			phy->phy_event &= ~PHY_PLUG_OUT;
2010 			if (!(tmp & PHY_READY_MASK)) {
2011 				sas_phy_disconnected(sas_phy);
2012 				mvs_phy_disconnected(phy);
2013 				sas_ha->notify_phy_event(sas_phy,
2014 					PHYE_LOSS_OF_SIGNAL);
2015 				mv_dprintk("phy%d Removed Device\n", phy_no);
2016 			} else {
2017 				MVS_CHIP_DISP->detect_porttype(mvi, phy_no);
2018 				mvs_update_phyinfo(mvi, phy_no, 1);
2019 				mvs_bytes_dmaed(mvi, phy_no);
2020 				mvs_port_notify_formed(sas_phy, 0);
2021 				mv_dprintk("phy%d Attached Device\n", phy_no);
2022 			}
2023 		}
2024 	} else if (mwq->handler & EXP_BRCT_CHG) {
2025 		phy->phy_event &= ~EXP_BRCT_CHG;
2026 		sas_ha->notify_port_event(sas_phy,
2027 				PORTE_BROADCAST_RCVD);
2028 		mv_dprintk("phy%d Got Broadcast Change\n", phy_no);
2029 	}
2030 	list_del(&mwq->entry);
2031 	spin_unlock_irqrestore(&mvi->lock, flags);
2032 	kfree(mwq);
2033 }
2034 
2035 static int mvs_handle_event(struct mvs_info *mvi, void *data, int handler)
2036 {
2037 	struct mvs_wq *mwq;
2038 	int ret = 0;
2039 
2040 	mwq = kmalloc(sizeof(struct mvs_wq), GFP_ATOMIC);
2041 	if (mwq) {
2042 		mwq->mvi = mvi;
2043 		mwq->data = data;
2044 		mwq->handler = handler;
2045 		MV_INIT_DELAYED_WORK(&mwq->work_q, mvs_work_queue, mwq);
2046 		list_add_tail(&mwq->entry, &mvi->wq_list);
2047 		schedule_delayed_work(&mwq->work_q, HZ * 2);
2048 	} else
2049 		ret = -ENOMEM;
2050 
2051 	return ret;
2052 }
2053 
2054 static void mvs_sig_time_out(unsigned long tphy)
2055 {
2056 	struct mvs_phy *phy = (struct mvs_phy *)tphy;
2057 	struct mvs_info *mvi = phy->mvi;
2058 	u8 phy_no;
2059 
2060 	for (phy_no = 0; phy_no < mvi->chip->n_phy; phy_no++) {
2061 		if (&mvi->phy[phy_no] == phy) {
2062 			mv_dprintk("Get signature time out, reset phy %d\n",
2063 				phy_no+mvi->id*mvi->chip->n_phy);
2064 			MVS_CHIP_DISP->phy_reset(mvi, phy_no, MVS_HARD_RESET);
2065 		}
2066 	}
2067 }
2068 
2069 void mvs_int_port(struct mvs_info *mvi, int phy_no, u32 events)
2070 {
2071 	u32 tmp;
2072 	struct mvs_phy *phy = &mvi->phy[phy_no];
2073 
2074 	phy->irq_status = MVS_CHIP_DISP->read_port_irq_stat(mvi, phy_no);
2075 	MVS_CHIP_DISP->write_port_irq_stat(mvi, phy_no, phy->irq_status);
2076 	mv_dprintk("phy %d ctrl sts=0x%08X.\n", phy_no+mvi->id*mvi->chip->n_phy,
2077 		MVS_CHIP_DISP->read_phy_ctl(mvi, phy_no));
2078 	mv_dprintk("phy %d irq sts = 0x%08X\n", phy_no+mvi->id*mvi->chip->n_phy,
2079 		phy->irq_status);
2080 
2081 	/*
2082 	* events is port event now ,
2083 	* we need check the interrupt status which belongs to per port.
2084 	*/
2085 
2086 	if (phy->irq_status & PHYEV_DCDR_ERR) {
2087 		mv_dprintk("phy %d STP decoding error.\n",
2088 		phy_no + mvi->id*mvi->chip->n_phy);
2089 	}
2090 
2091 	if (phy->irq_status & PHYEV_POOF) {
2092 		mdelay(500);
2093 		if (!(phy->phy_event & PHY_PLUG_OUT)) {
2094 			int dev_sata = phy->phy_type & PORT_TYPE_SATA;
2095 			int ready;
2096 			mvs_do_release_task(mvi, phy_no, NULL);
2097 			phy->phy_event |= PHY_PLUG_OUT;
2098 			MVS_CHIP_DISP->clear_srs_irq(mvi, 0, 1);
2099 			mvs_handle_event(mvi,
2100 				(void *)(unsigned long)phy_no,
2101 				PHY_PLUG_EVENT);
2102 			ready = mvs_is_phy_ready(mvi, phy_no);
2103 			if (ready || dev_sata) {
2104 				if (MVS_CHIP_DISP->stp_reset)
2105 					MVS_CHIP_DISP->stp_reset(mvi,
2106 							phy_no);
2107 				else
2108 					MVS_CHIP_DISP->phy_reset(mvi,
2109 							phy_no, MVS_SOFT_RESET);
2110 				return;
2111 			}
2112 		}
2113 	}
2114 
2115 	if (phy->irq_status & PHYEV_COMWAKE) {
2116 		tmp = MVS_CHIP_DISP->read_port_irq_mask(mvi, phy_no);
2117 		MVS_CHIP_DISP->write_port_irq_mask(mvi, phy_no,
2118 					tmp | PHYEV_SIG_FIS);
2119 		if (phy->timer.function == NULL) {
2120 			phy->timer.data = (unsigned long)phy;
2121 			phy->timer.function = mvs_sig_time_out;
2122 			phy->timer.expires = jiffies + 5*HZ;
2123 			add_timer(&phy->timer);
2124 		}
2125 	}
2126 	if (phy->irq_status & (PHYEV_SIG_FIS | PHYEV_ID_DONE)) {
2127 		phy->phy_status = mvs_is_phy_ready(mvi, phy_no);
2128 		mv_dprintk("notify plug in on phy[%d]\n", phy_no);
2129 		if (phy->phy_status) {
2130 			mdelay(10);
2131 			MVS_CHIP_DISP->detect_porttype(mvi, phy_no);
2132 			if (phy->phy_type & PORT_TYPE_SATA) {
2133 				tmp = MVS_CHIP_DISP->read_port_irq_mask(
2134 						mvi, phy_no);
2135 				tmp &= ~PHYEV_SIG_FIS;
2136 				MVS_CHIP_DISP->write_port_irq_mask(mvi,
2137 							phy_no, tmp);
2138 			}
2139 			mvs_update_phyinfo(mvi, phy_no, 0);
2140 			if (phy->phy_type & PORT_TYPE_SAS) {
2141 				MVS_CHIP_DISP->phy_reset(mvi, phy_no, MVS_PHY_TUNE);
2142 				mdelay(10);
2143 			}
2144 
2145 			mvs_bytes_dmaed(mvi, phy_no);
2146 			/* whether driver is going to handle hot plug */
2147 			if (phy->phy_event & PHY_PLUG_OUT) {
2148 				mvs_port_notify_formed(&phy->sas_phy, 0);
2149 				phy->phy_event &= ~PHY_PLUG_OUT;
2150 			}
2151 		} else {
2152 			mv_dprintk("plugin interrupt but phy%d is gone\n",
2153 				phy_no + mvi->id*mvi->chip->n_phy);
2154 		}
2155 	} else if (phy->irq_status & PHYEV_BROAD_CH) {
2156 		mv_dprintk("phy %d broadcast change.\n",
2157 			phy_no + mvi->id*mvi->chip->n_phy);
2158 		mvs_handle_event(mvi, (void *)(unsigned long)phy_no,
2159 				EXP_BRCT_CHG);
2160 	}
2161 }
2162 
2163 int mvs_int_rx(struct mvs_info *mvi, bool self_clear)
2164 {
2165 	u32 rx_prod_idx, rx_desc;
2166 	bool attn = false;
2167 
2168 	/* the first dword in the RX ring is special: it contains
2169 	 * a mirror of the hardware's RX producer index, so that
2170 	 * we don't have to stall the CPU reading that register.
2171 	 * The actual RX ring is offset by one dword, due to this.
2172 	 */
2173 	rx_prod_idx = mvi->rx_cons;
2174 	mvi->rx_cons = le32_to_cpu(mvi->rx[0]);
2175 	if (mvi->rx_cons == 0xfff)	/* h/w hasn't touched RX ring yet */
2176 		return 0;
2177 
2178 	/* The CMPL_Q may come late, read from register and try again
2179 	* note: if coalescing is enabled,
2180 	* it will need to read from register every time for sure
2181 	*/
2182 	if (unlikely(mvi->rx_cons == rx_prod_idx))
2183 		mvi->rx_cons = MVS_CHIP_DISP->rx_update(mvi) & RX_RING_SZ_MASK;
2184 
2185 	if (mvi->rx_cons == rx_prod_idx)
2186 		return 0;
2187 
2188 	while (mvi->rx_cons != rx_prod_idx) {
2189 		/* increment our internal RX consumer pointer */
2190 		rx_prod_idx = (rx_prod_idx + 1) & (MVS_RX_RING_SZ - 1);
2191 		rx_desc = le32_to_cpu(mvi->rx[rx_prod_idx + 1]);
2192 
2193 		if (likely(rx_desc & RXQ_DONE))
2194 			mvs_slot_complete(mvi, rx_desc, 0);
2195 		if (rx_desc & RXQ_ATTN) {
2196 			attn = true;
2197 		} else if (rx_desc & RXQ_ERR) {
2198 			if (!(rx_desc & RXQ_DONE))
2199 				mvs_slot_complete(mvi, rx_desc, 0);
2200 		} else if (rx_desc & RXQ_SLOT_RESET) {
2201 			mvs_slot_free(mvi, rx_desc);
2202 		}
2203 	}
2204 
2205 	if (attn && self_clear)
2206 		MVS_CHIP_DISP->int_full(mvi);
2207 	return 0;
2208 }
2209 
2210