Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
aic94xx_dev.c
Go to the documentation of this file.
1 /*
2  * Aic94xx SAS/SATA DDB management
3  *
4  * Copyright (C) 2005 Adaptec, Inc. All rights reserved.
5  * Copyright (C) 2005 Luben Tuikov <[email protected]>
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 void asd_set_dmamode(struct domain_device *dev)
113 {
114  struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
115  struct ata_device *ata_dev = sas_to_ata_dev(dev);
116  int ddb = (int) (unsigned long) dev->lldd_dev;
117  u32 qdepth = 0;
118 
119  if (dev->dev_type == SATA_DEV || dev->dev_type == SATA_PM_PORT) {
120  if (ata_id_has_ncq(ata_dev->id))
121  qdepth = ata_id_queue_depth(ata_dev->id);
122  asd_ddbsite_write_dword(asd_ha, ddb, SATA_TAG_ALLOC_MASK,
123  (1ULL<<qdepth)-1);
124  asd_ddbsite_write_byte(asd_ha, ddb, NUM_SATA_TAGS, qdepth);
125  }
126 
127  if (qdepth > 0)
128  if (asd_init_sata_tag_ddb(dev) != 0) {
129  unsigned long flags;
130 
131  spin_lock_irqsave(dev->sata_dev.ap->lock, flags);
132  ata_dev->flags |= ATA_DFLAG_NCQ_OFF;
133  spin_unlock_irqrestore(dev->sata_dev.ap->lock, flags);
134  }
135 }
136 
137 static int asd_init_sata(struct domain_device *dev)
138 {
139  struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
140  int ddb = (int) (unsigned long) dev->lldd_dev;
141 
142  asd_ddbsite_write_word(asd_ha, ddb, ATA_CMD_SCBPTR, 0xFFFF);
143  if (dev->dev_type == SATA_DEV || dev->dev_type == SATA_PM ||
144  dev->dev_type == SATA_PM_PORT) {
145  struct dev_to_host_fis *fis = (struct dev_to_host_fis *)
146  dev->frame_rcvd;
147  asd_ddbsite_write_byte(asd_ha, ddb, SATA_STATUS, fis->status);
148  }
149  asd_ddbsite_write_word(asd_ha, ddb, NCQ_DATA_SCB_PTR, 0xFFFF);
150 
151  return 0;
152 }
153 
154 static int asd_init_target_ddb(struct domain_device *dev)
155 {
156  int ddb, i;
157  struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
158  u8 flags = 0;
159 
160  ddb = asd_get_ddb(asd_ha);
161  if (ddb < 0)
162  return ddb;
163 
164  dev->lldd_dev = (void *) (unsigned long) ddb;
165 
166  asd_ddbsite_write_byte(asd_ha, ddb, 0, DDB_TP_CONN_TYPE);
167  asd_ddbsite_write_byte(asd_ha, ddb, 1, 0);
168  asd_ddbsite_write_word(asd_ha, ddb, INIT_CONN_TAG, 0xFFFF);
169  for (i = 0; i < SAS_ADDR_SIZE; i++)
170  asd_ddbsite_write_byte(asd_ha, ddb, DEST_SAS_ADDR+i,
171  dev->sas_addr[i]);
172  asd_ddbsite_write_word(asd_ha, ddb, SEND_QUEUE_HEAD, 0xFFFF);
173  asd_set_ddb_type(dev);
174  asd_ddbsite_write_byte(asd_ha, ddb, CONN_MASK, dev->port->phy_mask);
175  if (dev->port->oob_mode != SATA_OOB_MODE) {
176  flags |= OPEN_REQUIRED;
177  if ((dev->dev_type == SATA_DEV) ||
178  (dev->tproto & SAS_PROTOCOL_STP)) {
179  struct smp_resp *rps_resp = &dev->sata_dev.rps_resp;
180  if (rps_resp->frame_type == SMP_RESPONSE &&
181  rps_resp->function == SMP_REPORT_PHY_SATA &&
182  rps_resp->result == SMP_RESP_FUNC_ACC) {
183  if (rps_resp->rps.affil_valid)
184  flags |= STP_AFFIL_POL;
185  if (rps_resp->rps.affil_supp)
186  flags |= SUPPORTS_AFFIL;
187  }
188  } else {
189  flags |= CONCURRENT_CONN_SUPP;
190  if (!dev->parent &&
191  (dev->dev_type == EDGE_DEV ||
192  dev->dev_type == FANOUT_DEV))
193  asd_ddbsite_write_byte(asd_ha, ddb, MAX_CCONN,
194  4);
195  else
196  asd_ddbsite_write_byte(asd_ha, ddb, MAX_CCONN,
197  dev->pathways);
198  asd_ddbsite_write_byte(asd_ha, ddb, NUM_CTX, 1);
199  }
200  }
201  if (dev->dev_type == SATA_PM)
202  flags |= SATA_MULTIPORT;
203  asd_ddbsite_write_byte(asd_ha, ddb, DDB_TARG_FLAGS, flags);
204 
205  flags = 0;
206  if (dev->tproto & SAS_PROTOCOL_STP)
207  flags |= STP_CL_POL_NO_TX;
208  asd_ddbsite_write_byte(asd_ha, ddb, DDB_TARG_FLAGS2, flags);
209 
210  asd_ddbsite_write_word(asd_ha, ddb, EXEC_QUEUE_TAIL, 0xFFFF);
211  asd_ddbsite_write_word(asd_ha, ddb, SEND_QUEUE_TAIL, 0xFFFF);
212  asd_ddbsite_write_word(asd_ha, ddb, SISTER_DDB, 0xFFFF);
213 
214  if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
215  i = asd_init_sata(dev);
216  if (i < 0) {
217  asd_free_ddb(asd_ha, ddb);
218  return i;
219  }
220  }
221 
222  if (dev->dev_type == SAS_END_DEV) {
223  struct sas_end_device *rdev = rphy_to_end_device(dev->rphy);
224  if (rdev->I_T_nexus_loss_timeout > 0)
225  asd_ddbsite_write_word(asd_ha, ddb, ITNL_TIMEOUT,
226  min(rdev->I_T_nexus_loss_timeout,
227  (u16)ITNL_TIMEOUT_CONST));
228  else
229  asd_ddbsite_write_word(asd_ha, ddb, ITNL_TIMEOUT,
230  (u16)ITNL_TIMEOUT_CONST);
231  }
232  return 0;
233 }
234 
235 static int asd_init_sata_pm_table_ddb(struct domain_device *dev)
236 {
237  struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
238  int ddb, i;
239 
240  ddb = asd_get_ddb(asd_ha);
241  if (ddb < 0)
242  return ddb;
243 
244  for (i = 0; i < 32; i += 2)
245  asd_ddbsite_write_word(asd_ha, ddb, i, 0xFFFF);
246 
247  asd_ddbsite_write_word(asd_ha, (int) (unsigned long) dev->lldd_dev,
248  SISTER_DDB, ddb);
249 
250  return 0;
251 }
252 
253 #define PM_PORT_FLAGS offsetof(struct asd_ddb_sata_pm_port, pm_port_flags)
254 #define PARENT_DDB offsetof(struct asd_ddb_sata_pm_port, parent_ddb)
255 
264 static int asd_init_sata_pm_port_ddb(struct domain_device *dev)
265 {
266  int ddb, i, parent_ddb, pmtable_ddb;
267  struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
268  u8 flags;
269 
270  ddb = asd_get_ddb(asd_ha);
271  if (ddb < 0)
272  return ddb;
273 
274  asd_set_ddb_type(dev);
275  flags = (dev->sata_dev.port_no << 4) | PM_PORT_SET;
276  asd_ddbsite_write_byte(asd_ha, ddb, PM_PORT_FLAGS, flags);
277  asd_ddbsite_write_word(asd_ha, ddb, SISTER_DDB, 0xFFFF);
278  asd_ddbsite_write_word(asd_ha, ddb, ATA_CMD_SCBPTR, 0xFFFF);
279  asd_init_sata(dev);
280 
281  parent_ddb = (int) (unsigned long) dev->parent->lldd_dev;
282  asd_ddbsite_write_word(asd_ha, ddb, PARENT_DDB, parent_ddb);
283  pmtable_ddb = asd_ddbsite_read_word(asd_ha, parent_ddb, SISTER_DDB);
284  asd_ddbsite_write_word(asd_ha, pmtable_ddb, dev->sata_dev.port_no,ddb);
285 
286  if (asd_ddbsite_read_byte(asd_ha, ddb, NUM_SATA_TAGS) > 0) {
287  i = asd_init_sata_tag_ddb(dev);
288  if (i < 0) {
289  asd_free_ddb(asd_ha, ddb);
290  return i;
291  }
292  }
293  return 0;
294 }
295 
296 static int asd_init_initiator_ddb(struct domain_device *dev)
297 {
298  return -ENODEV;
299 }
300 
308 static int asd_init_sata_pm_ddb(struct domain_device *dev)
309 {
310  int res = 0;
311 
312  res = asd_init_target_ddb(dev);
313  if (res)
314  goto out;
315  res = asd_init_sata_pm_table_ddb(dev);
316  if (res)
317  asd_free_ddb(dev->port->ha->lldd_ha,
318  (int) (unsigned long) dev->lldd_dev);
319 out:
320  return res;
321 }
322 
323 int asd_dev_found(struct domain_device *dev)
324 {
325  unsigned long flags;
326  int res = 0;
327  struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
328 
329  spin_lock_irqsave(&asd_ha->hw_prof.ddb_lock, flags);
330  switch (dev->dev_type) {
331  case SATA_PM:
332  res = asd_init_sata_pm_ddb(dev);
333  break;
334  case SATA_PM_PORT:
335  res = asd_init_sata_pm_port_ddb(dev);
336  break;
337  default:
338  if (dev->tproto)
339  res = asd_init_target_ddb(dev);
340  else
341  res = asd_init_initiator_ddb(dev);
342  }
343  spin_unlock_irqrestore(&asd_ha->hw_prof.ddb_lock, flags);
344 
345  return res;
346 }
347 
348 void asd_dev_gone(struct domain_device *dev)
349 {
350  int ddb, sister_ddb;
351  unsigned long flags;
352  struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
353 
354  spin_lock_irqsave(&asd_ha->hw_prof.ddb_lock, flags);
355  ddb = (int) (unsigned long) dev->lldd_dev;
356  sister_ddb = asd_ddbsite_read_word(asd_ha, ddb, SISTER_DDB);
357 
358  if (sister_ddb != 0xFFFF)
359  asd_free_ddb(asd_ha, sister_ddb);
360  asd_free_ddb(asd_ha, ddb);
361  dev->lldd_dev = NULL;
362  spin_unlock_irqrestore(&asd_ha->hw_prof.ddb_lock, flags);
363 }
Generated on Thu Jan 10 2013 14:19:14 for Linux Kernel by   doxygen 1.8.2