1 /*
2  * Aic94xx SAS/SATA DDB management
3  *
4  * Copyright (C) 2005 Adaptec, Inc.  All rights reserved.
5  * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
6  *
7  * This file is licensed under GPLv2.
8  *
9  * This file is part of the aic94xx driver.
10  *
11  * The aic94xx driver is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License as
13  * published by the Free Software Foundation; version 2 of the
14  * License.
15  *
16  * The aic94xx driver is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with the aic94xx driver; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
24  *
25  * $Id: //depot/aic94xx/aic94xx_dev.c#21 $
26  */
27 
28 #include "aic94xx.h"
29 #include "aic94xx_hwi.h"
30 #include "aic94xx_reg.h"
31 #include "aic94xx_sas.h"
32 
33 #define FIND_FREE_DDB(_ha) find_first_zero_bit((_ha)->hw_prof.ddb_bitmap, \
34 					       (_ha)->hw_prof.max_ddbs)
35 #define SET_DDB(_ddb, _ha) set_bit(_ddb, (_ha)->hw_prof.ddb_bitmap)
36 #define CLEAR_DDB(_ddb, _ha) clear_bit(_ddb, (_ha)->hw_prof.ddb_bitmap)
37 
38 static int asd_get_ddb(struct asd_ha_struct *asd_ha)
39 {
40 	int ddb, i;
41 
42 	ddb = FIND_FREE_DDB(asd_ha);
43 	if (ddb >= asd_ha->hw_prof.max_ddbs) {
44 		ddb = -ENOMEM;
45 		goto out;
46 	}
47 	SET_DDB(ddb, asd_ha);
48 
49 	for (i = 0; i < sizeof(struct asd_ddb_ssp_smp_target_port); i+= 4)
50 		asd_ddbsite_write_dword(asd_ha, ddb, i, 0);
51 out:
52 	return ddb;
53 }
54 
55 #define INIT_CONN_TAG   offsetof(struct asd_ddb_ssp_smp_target_port, init_conn_tag)
56 #define DEST_SAS_ADDR   offsetof(struct asd_ddb_ssp_smp_target_port, dest_sas_addr)
57 #define SEND_QUEUE_HEAD offsetof(struct asd_ddb_ssp_smp_target_port, send_queue_head)
58 #define DDB_TYPE        offsetof(struct asd_ddb_ssp_smp_target_port, ddb_type)
59 #define CONN_MASK       offsetof(struct asd_ddb_ssp_smp_target_port, conn_mask)
60 #define DDB_TARG_FLAGS  offsetof(struct asd_ddb_ssp_smp_target_port, flags)
61 #define DDB_TARG_FLAGS2 offsetof(struct asd_ddb_stp_sata_target_port, flags2)
62 #define EXEC_QUEUE_TAIL offsetof(struct asd_ddb_ssp_smp_target_port, exec_queue_tail)
63 #define SEND_QUEUE_TAIL offsetof(struct asd_ddb_ssp_smp_target_port, send_queue_tail)
64 #define SISTER_DDB      offsetof(struct asd_ddb_ssp_smp_target_port, sister_ddb)
65 #define MAX_CCONN       offsetof(struct asd_ddb_ssp_smp_target_port, max_concurrent_conn)
66 #define NUM_CTX         offsetof(struct asd_ddb_ssp_smp_target_port, num_contexts)
67 #define ATA_CMD_SCBPTR  offsetof(struct asd_ddb_stp_sata_target_port, ata_cmd_scbptr)
68 #define SATA_TAG_ALLOC_MASK offsetof(struct asd_ddb_stp_sata_target_port, sata_tag_alloc_mask)
69 #define NUM_SATA_TAGS   offsetof(struct asd_ddb_stp_sata_target_port, num_sata_tags)
70 #define SATA_STATUS     offsetof(struct asd_ddb_stp_sata_target_port, sata_status)
71 #define NCQ_DATA_SCB_PTR offsetof(struct asd_ddb_stp_sata_target_port, ncq_data_scb_ptr)
72 #define ITNL_TIMEOUT    offsetof(struct asd_ddb_ssp_smp_target_port, itnl_timeout)
73 
74 static void asd_free_ddb(struct asd_ha_struct *asd_ha, int ddb)
75 {
76 	if (!ddb || ddb >= 0xFFFF)
77 		return;
78 	asd_ddbsite_write_byte(asd_ha, ddb, DDB_TYPE, DDB_TYPE_UNUSED);
79 	CLEAR_DDB(ddb, asd_ha);
80 }
81 
82 static void asd_set_ddb_type(struct domain_device *dev)
83 {
84 	struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
85 	int ddb = (int) (unsigned long) dev->lldd_dev;
86 
87 	if (dev->dev_type == SATA_PM_PORT)
88 		asd_ddbsite_write_byte(asd_ha,ddb, DDB_TYPE, DDB_TYPE_PM_PORT);
89 	else if (dev->tproto)
90 		asd_ddbsite_write_byte(asd_ha,ddb, DDB_TYPE, DDB_TYPE_TARGET);
91 	else
92 		asd_ddbsite_write_byte(asd_ha,ddb,DDB_TYPE,DDB_TYPE_INITIATOR);
93 }
94 
95 static int asd_init_sata_tag_ddb(struct domain_device *dev)
96 {
97 	struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
98 	int ddb, i;
99 
100 	ddb = asd_get_ddb(asd_ha);
101 	if (ddb < 0)
102 		return ddb;
103 
104 	for (i = 0; i < sizeof(struct asd_ddb_sata_tag); i += 2)
105 		asd_ddbsite_write_word(asd_ha, ddb, i, 0xFFFF);
106 
107 	asd_ddbsite_write_word(asd_ha, (int) (unsigned long) dev->lldd_dev,
108 			       SISTER_DDB, ddb);
109 	return 0;
110 }
111 
112 static int asd_init_sata(struct domain_device *dev)
113 {
114 	struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
115 	int ddb = (int) (unsigned long) dev->lldd_dev;
116 	u32 qdepth = 0;
117 	int res = 0;
118 
119 	asd_ddbsite_write_word(asd_ha, ddb, ATA_CMD_SCBPTR, 0xFFFF);
120 	if ((dev->dev_type == SATA_DEV || dev->dev_type == SATA_PM_PORT) &&
121 	    dev->sata_dev.identify_device &&
122 	    dev->sata_dev.identify_device[10] != 0) {
123 		u16 w75 = le16_to_cpu(dev->sata_dev.identify_device[75]);
124 		u16 w76 = le16_to_cpu(dev->sata_dev.identify_device[76]);
125 
126 		if (w76 & 0x100) /* NCQ? */
127 			qdepth = (w75 & 0x1F) + 1;
128 		asd_ddbsite_write_dword(asd_ha, ddb, SATA_TAG_ALLOC_MASK,
129 					(1ULL<<qdepth)-1);
130 		asd_ddbsite_write_byte(asd_ha, ddb, NUM_SATA_TAGS, qdepth);
131 	}
132 	if (dev->dev_type == SATA_DEV || dev->dev_type == SATA_PM ||
133 	    dev->dev_type == SATA_PM_PORT) {
134 		struct dev_to_host_fis *fis = (struct dev_to_host_fis *)
135 			dev->frame_rcvd;
136 		asd_ddbsite_write_byte(asd_ha, ddb, SATA_STATUS, fis->status);
137 	}
138 	asd_ddbsite_write_word(asd_ha, ddb, NCQ_DATA_SCB_PTR, 0xFFFF);
139 	if (qdepth > 0)
140 		res = asd_init_sata_tag_ddb(dev);
141 	return res;
142 }
143 
144 static int asd_init_target_ddb(struct domain_device *dev)
145 {
146 	int ddb, i;
147 	struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
148 	u8 flags = 0;
149 
150 	ddb = asd_get_ddb(asd_ha);
151 	if (ddb < 0)
152 		return ddb;
153 
154 	dev->lldd_dev = (void *) (unsigned long) ddb;
155 
156 	asd_ddbsite_write_byte(asd_ha, ddb, 0, DDB_TP_CONN_TYPE);
157 	asd_ddbsite_write_byte(asd_ha, ddb, 1, 0);
158 	asd_ddbsite_write_word(asd_ha, ddb, INIT_CONN_TAG, 0xFFFF);
159 	for (i = 0; i < SAS_ADDR_SIZE; i++)
160 		asd_ddbsite_write_byte(asd_ha, ddb, DEST_SAS_ADDR+i,
161 				       dev->sas_addr[i]);
162 	asd_ddbsite_write_word(asd_ha, ddb, SEND_QUEUE_HEAD, 0xFFFF);
163 	asd_set_ddb_type(dev);
164 	asd_ddbsite_write_byte(asd_ha, ddb, CONN_MASK, dev->port->phy_mask);
165 	if (dev->port->oob_mode != SATA_OOB_MODE) {
166 		flags |= OPEN_REQUIRED;
167 		if ((dev->dev_type == SATA_DEV) ||
168 		    (dev->tproto & SAS_PROTOCOL_STP)) {
169 			struct smp_resp *rps_resp = &dev->sata_dev.rps_resp;
170 			if (rps_resp->frame_type == SMP_RESPONSE &&
171 			    rps_resp->function == SMP_REPORT_PHY_SATA &&
172 			    rps_resp->result == SMP_RESP_FUNC_ACC) {
173 				if (rps_resp->rps.affil_valid)
174 					flags |= STP_AFFIL_POL;
175 				if (rps_resp->rps.affil_supp)
176 					flags |= SUPPORTS_AFFIL;
177 			}
178 		} else {
179 			flags |= CONCURRENT_CONN_SUPP;
180 			if (!dev->parent &&
181 			    (dev->dev_type == EDGE_DEV ||
182 			     dev->dev_type == FANOUT_DEV))
183 				asd_ddbsite_write_byte(asd_ha, ddb, MAX_CCONN,
184 						       4);
185 			else
186 				asd_ddbsite_write_byte(asd_ha, ddb, MAX_CCONN,
187 						       dev->pathways);
188 			asd_ddbsite_write_byte(asd_ha, ddb, NUM_CTX, 1);
189 		}
190 	}
191 	if (dev->dev_type == SATA_PM)
192 		flags |= SATA_MULTIPORT;
193 	asd_ddbsite_write_byte(asd_ha, ddb, DDB_TARG_FLAGS, flags);
194 
195 	flags = 0;
196 	if (dev->tproto & SAS_PROTOCOL_STP)
197 		flags |= STP_CL_POL_NO_TX;
198 	asd_ddbsite_write_byte(asd_ha, ddb, DDB_TARG_FLAGS2, flags);
199 
200 	asd_ddbsite_write_word(asd_ha, ddb, EXEC_QUEUE_TAIL, 0xFFFF);
201 	asd_ddbsite_write_word(asd_ha, ddb, SEND_QUEUE_TAIL, 0xFFFF);
202 	asd_ddbsite_write_word(asd_ha, ddb, SISTER_DDB, 0xFFFF);
203 
204 	if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
205 		i = asd_init_sata(dev);
206 		if (i < 0) {
207 			asd_free_ddb(asd_ha, ddb);
208 			return i;
209 		}
210 	}
211 
212 	if (dev->dev_type == SAS_END_DEV) {
213 		struct sas_end_device *rdev = rphy_to_end_device(dev->rphy);
214 		if (rdev->I_T_nexus_loss_timeout > 0)
215 			asd_ddbsite_write_word(asd_ha, ddb, ITNL_TIMEOUT,
216 					       min(rdev->I_T_nexus_loss_timeout,
217 						   (u16)ITNL_TIMEOUT_CONST));
218 		else
219 			asd_ddbsite_write_word(asd_ha, ddb, ITNL_TIMEOUT,
220 					       (u16)ITNL_TIMEOUT_CONST);
221 	}
222 	return 0;
223 }
224 
225 static int asd_init_sata_pm_table_ddb(struct domain_device *dev)
226 {
227 	struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
228 	int ddb, i;
229 
230 	ddb = asd_get_ddb(asd_ha);
231 	if (ddb < 0)
232 		return ddb;
233 
234 	for (i = 0; i < 32; i += 2)
235 		asd_ddbsite_write_word(asd_ha, ddb, i, 0xFFFF);
236 
237 	asd_ddbsite_write_word(asd_ha, (int) (unsigned long) dev->lldd_dev,
238 			       SISTER_DDB, ddb);
239 
240 	return 0;
241 }
242 
243 #define PM_PORT_FLAGS offsetof(struct asd_ddb_sata_pm_port, pm_port_flags)
244 #define PARENT_DDB    offsetof(struct asd_ddb_sata_pm_port, parent_ddb)
245 
246 /**
247  * asd_init_sata_pm_port_ddb -- SATA Port Multiplier Port
248  * dev: pointer to domain device
249  *
250  * For SATA Port Multiplier Ports we need to allocate one SATA Port
251  * Multiplier Port DDB and depending on whether the target on it
252  * supports SATA II NCQ, one SATA Tag DDB.
253  */
254 static int asd_init_sata_pm_port_ddb(struct domain_device *dev)
255 {
256 	int ddb, i, parent_ddb, pmtable_ddb;
257 	struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
258 	u8  flags;
259 
260 	ddb = asd_get_ddb(asd_ha);
261 	if (ddb < 0)
262 		return ddb;
263 
264 	asd_set_ddb_type(dev);
265 	flags = (dev->sata_dev.port_no << 4) | PM_PORT_SET;
266 	asd_ddbsite_write_byte(asd_ha, ddb, PM_PORT_FLAGS, flags);
267 	asd_ddbsite_write_word(asd_ha, ddb, SISTER_DDB, 0xFFFF);
268 	asd_ddbsite_write_word(asd_ha, ddb, ATA_CMD_SCBPTR, 0xFFFF);
269 	asd_init_sata(dev);
270 
271 	parent_ddb = (int) (unsigned long) dev->parent->lldd_dev;
272 	asd_ddbsite_write_word(asd_ha, ddb, PARENT_DDB, parent_ddb);
273 	pmtable_ddb = asd_ddbsite_read_word(asd_ha, parent_ddb, SISTER_DDB);
274 	asd_ddbsite_write_word(asd_ha, pmtable_ddb, dev->sata_dev.port_no,ddb);
275 
276 	if (asd_ddbsite_read_byte(asd_ha, ddb, NUM_SATA_TAGS) > 0) {
277 		i = asd_init_sata_tag_ddb(dev);
278 		if (i < 0) {
279 			asd_free_ddb(asd_ha, ddb);
280 			return i;
281 		}
282 	}
283 	return 0;
284 }
285 
286 static int asd_init_initiator_ddb(struct domain_device *dev)
287 {
288 	return -ENODEV;
289 }
290 
291 /**
292  * asd_init_sata_pm_ddb -- SATA Port Multiplier
293  * dev: pointer to domain device
294  *
295  * For STP and direct-attached SATA Port Multipliers we need
296  * one target port DDB entry and one SATA PM table DDB entry.
297  */
298 static int asd_init_sata_pm_ddb(struct domain_device *dev)
299 {
300 	int res = 0;
301 
302 	res = asd_init_target_ddb(dev);
303 	if (res)
304 		goto out;
305 	res = asd_init_sata_pm_table_ddb(dev);
306 	if (res)
307 		asd_free_ddb(dev->port->ha->lldd_ha,
308 			     (int) (unsigned long) dev->lldd_dev);
309 out:
310 	return res;
311 }
312 
313 int asd_dev_found(struct domain_device *dev)
314 {
315 	unsigned long flags;
316 	int res = 0;
317 	struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
318 
319 	spin_lock_irqsave(&asd_ha->hw_prof.ddb_lock, flags);
320 	switch (dev->dev_type) {
321 	case SATA_PM:
322 		res = asd_init_sata_pm_ddb(dev);
323 		break;
324 	case SATA_PM_PORT:
325 		res = asd_init_sata_pm_port_ddb(dev);
326 		break;
327 	default:
328 		if (dev->tproto)
329 			res = asd_init_target_ddb(dev);
330 		else
331 			res = asd_init_initiator_ddb(dev);
332 	}
333 	spin_unlock_irqrestore(&asd_ha->hw_prof.ddb_lock, flags);
334 
335 	return res;
336 }
337 
338 void asd_dev_gone(struct domain_device *dev)
339 {
340 	int ddb, sister_ddb;
341 	unsigned long flags;
342 	struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
343 
344 	spin_lock_irqsave(&asd_ha->hw_prof.ddb_lock, flags);
345 	ddb = (int) (unsigned long) dev->lldd_dev;
346 	sister_ddb = asd_ddbsite_read_word(asd_ha, ddb, SISTER_DDB);
347 
348 	if (sister_ddb != 0xFFFF)
349 		asd_free_ddb(asd_ha, sister_ddb);
350 	asd_free_ddb(asd_ha, ddb);
351 	dev->lldd_dev = NULL;
352 	spin_unlock_irqrestore(&asd_ha->hw_prof.ddb_lock, flags);
353 }
354