Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
aic94xx_scb.c
Go to the documentation of this file.
1 /*
2  * Aic94xx SAS/SATA driver SCB 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  */
26 
27 #include <linux/gfp.h>
28 #include <scsi/scsi_host.h>
29 
30 #include "aic94xx.h"
31 #include "aic94xx_reg.h"
32 #include "aic94xx_hwi.h"
33 #include "aic94xx_seq.h"
34 
35 #include "aic94xx_dump.h"
36 
37 /* ---------- EMPTY SCB ---------- */
38 
39 #define DL_PHY_MASK 7
40 #define BYTES_DMAED 0
41 #define PRIMITIVE_RECVD 0x08
42 #define PHY_EVENT 0x10
43 #define LINK_RESET_ERROR 0x18
44 #define TIMER_EVENT 0x20
45 #define REQ_TASK_ABORT 0xF0
46 #define REQ_DEVICE_RESET 0xF1
47 #define SIGNAL_NCQ_ERROR 0xF2
48 #define CLEAR_NCQ_ERROR 0xF3
49 
50 #define PHY_EVENTS_STATUS (CURRENT_LOSS_OF_SIGNAL | CURRENT_OOB_DONE \
51  | CURRENT_SPINUP_HOLD | CURRENT_GTO_TIMEOUT \
52  | CURRENT_OOB_ERROR)
53 
54 static void get_lrate_mode(struct asd_phy *phy, u8 oob_mode)
55 {
56  struct sas_phy *sas_phy = phy->sas_phy.phy;
57 
58  switch (oob_mode & 7) {
59  case PHY_SPEED_60:
60  /* FIXME: sas transport class doesn't have this */
61  phy->sas_phy.linkrate = SAS_LINK_RATE_6_0_GBPS;
62  phy->sas_phy.phy->negotiated_linkrate = SAS_LINK_RATE_6_0_GBPS;
63  break;
64  case PHY_SPEED_30:
65  phy->sas_phy.linkrate = SAS_LINK_RATE_3_0_GBPS;
66  phy->sas_phy.phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
67  break;
68  case PHY_SPEED_15:
69  phy->sas_phy.linkrate = SAS_LINK_RATE_1_5_GBPS;
70  phy->sas_phy.phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
71  break;
72  }
73  sas_phy->negotiated_linkrate = phy->sas_phy.linkrate;
76  sas_phy->maximum_linkrate = phy->phy_desc->max_sas_lrate;
77  sas_phy->minimum_linkrate = phy->phy_desc->min_sas_lrate;
78 
79  if (oob_mode & SAS_MODE)
80  phy->sas_phy.oob_mode = SAS_OOB_MODE;
81  else if (oob_mode & SATA_MODE)
82  phy->sas_phy.oob_mode = SATA_OOB_MODE;
83 }
84 
85 static void asd_phy_event_tasklet(struct asd_ascb *ascb,
86  struct done_list_struct *dl)
87 {
88  struct asd_ha_struct *asd_ha = ascb->ha;
89  struct sas_ha_struct *sas_ha = &asd_ha->sas_ha;
90  int phy_id = dl->status_block[0] & DL_PHY_MASK;
91  struct asd_phy *phy = &asd_ha->phys[phy_id];
92 
93  u8 oob_status = dl->status_block[1] & PHY_EVENTS_STATUS;
94  u8 oob_mode = dl->status_block[2];
95 
96  switch (oob_status) {
98  /* directly attached device was removed */
99  ASD_DPRINTK("phy%d: device unplugged\n", phy_id);
100  asd_turn_led(asd_ha, phy_id, 0);
101  sas_phy_disconnected(&phy->sas_phy);
103  break;
104  case CURRENT_OOB_DONE:
105  /* hot plugged device */
106  asd_turn_led(asd_ha, phy_id, 1);
107  get_lrate_mode(phy, oob_mode);
108  ASD_DPRINTK("phy%d device plugged: lrate:0x%x, proto:0x%x\n",
109  phy_id, phy->sas_phy.linkrate, phy->sas_phy.iproto);
110  sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
111  break;
112  case CURRENT_SPINUP_HOLD:
113  /* hot plug SATA, no COMWAKE sent */
114  asd_turn_led(asd_ha, phy_id, 1);
115  sas_ha->notify_phy_event(&phy->sas_phy, PHYE_SPINUP_HOLD);
116  break;
117  case CURRENT_GTO_TIMEOUT:
118  case CURRENT_OOB_ERROR:
119  ASD_DPRINTK("phy%d error while OOB: oob status:0x%x\n", phy_id,
120  dl->status_block[1]);
121  asd_turn_led(asd_ha, phy_id, 0);
122  sas_phy_disconnected(&phy->sas_phy);
123  sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_ERROR);
124  break;
125  }
126 }
127 
128 /* If phys are enabled sparsely, this will do the right thing. */
129 static unsigned ord_phy(struct asd_ha_struct *asd_ha, struct asd_phy *phy)
130 {
131  u8 enabled_mask = asd_ha->hw_prof.enabled_phys;
132  int i, k = 0;
133 
134  for_each_phy(enabled_mask, enabled_mask, i) {
135  if (&asd_ha->phys[i] == phy)
136  return k;
137  k++;
138  }
139  return 0;
140 }
141 
154 static void asd_get_attached_sas_addr(struct asd_phy *phy, u8 *sas_addr)
155 {
156  if (phy->sas_phy.frame_rcvd[0] == 0x34
157  && phy->sas_phy.oob_mode == SATA_OOB_MODE) {
158  struct asd_ha_struct *asd_ha = phy->sas_phy.ha->lldd_ha;
159  /* FIS device-to-host */
160  u64 addr = be64_to_cpu(*(__be64 *)phy->phy_desc->sas_addr);
161 
162  addr += asd_ha->hw_prof.sata_name_base + ord_phy(asd_ha, phy);
163  *(__be64 *)sas_addr = cpu_to_be64(addr);
164  } else {
165  struct sas_identify_frame *idframe =
166  (void *) phy->sas_phy.frame_rcvd;
167  memcpy(sas_addr, idframe->sas_addr, SAS_ADDR_SIZE);
168  }
169 }
170 
171 static void asd_form_port(struct asd_ha_struct *asd_ha, struct asd_phy *phy)
172 {
173  int i;
174  struct asd_port *free_port = NULL;
175  struct asd_port *port;
176  struct asd_sas_phy *sas_phy = &phy->sas_phy;
177  unsigned long flags;
178 
179  spin_lock_irqsave(&asd_ha->asd_ports_lock, flags);
180  if (!phy->asd_port) {
181  for (i = 0; i < ASD_MAX_PHYS; i++) {
182  port = &asd_ha->asd_ports[i];
183 
184  /* Check for wide port */
185  if (port->num_phys > 0 &&
186  memcmp(port->sas_addr, sas_phy->sas_addr,
187  SAS_ADDR_SIZE) == 0 &&
189  sas_phy->attached_sas_addr,
190  SAS_ADDR_SIZE) == 0) {
191  break;
192  }
193 
194  /* Find a free port */
195  if (port->num_phys == 0 && free_port == NULL) {
196  free_port = port;
197  }
198  }
199 
200  /* Use a free port if this doesn't form a wide port */
201  if (i >= ASD_MAX_PHYS) {
202  port = free_port;
203  BUG_ON(!port);
204  memcpy(port->sas_addr, sas_phy->sas_addr,
205  SAS_ADDR_SIZE);
207  sas_phy->attached_sas_addr,
208  SAS_ADDR_SIZE);
209  }
210  port->num_phys++;
211  port->phy_mask |= (1U << sas_phy->id);
212  phy->asd_port = port;
213  }
214  ASD_DPRINTK("%s: updating phy_mask 0x%x for phy%d\n",
215  __func__, phy->asd_port->phy_mask, sas_phy->id);
216  asd_update_port_links(asd_ha, phy);
217  spin_unlock_irqrestore(&asd_ha->asd_ports_lock, flags);
218 }
219 
220 static void asd_deform_port(struct asd_ha_struct *asd_ha, struct asd_phy *phy)
221 {
222  struct asd_port *port = phy->asd_port;
223  struct asd_sas_phy *sas_phy = &phy->sas_phy;
224  unsigned long flags;
225 
226  spin_lock_irqsave(&asd_ha->asd_ports_lock, flags);
227  if (port) {
228  port->num_phys--;
229  port->phy_mask &= ~(1U << sas_phy->id);
230  phy->asd_port = NULL;
231  }
232  spin_unlock_irqrestore(&asd_ha->asd_ports_lock, flags);
233 }
234 
235 static void asd_bytes_dmaed_tasklet(struct asd_ascb *ascb,
236  struct done_list_struct *dl,
237  int edb_id, int phy_id)
238 {
239  unsigned long flags;
240  int edb_el = edb_id + ascb->edb_index;
241  struct asd_dma_tok *edb = ascb->ha->seq.edb_arr[edb_el];
242  struct asd_phy *phy = &ascb->ha->phys[phy_id];
243  struct sas_ha_struct *sas_ha = phy->sas_phy.ha;
244  u16 size = ((dl->status_block[3] & 7) << 8) | dl->status_block[2];
245 
246  size = min(size, (u16) sizeof(phy->frame_rcvd));
247 
248  spin_lock_irqsave(&phy->sas_phy.frame_rcvd_lock, flags);
249  memcpy(phy->sas_phy.frame_rcvd, edb->vaddr, size);
250  phy->sas_phy.frame_rcvd_size = size;
251  asd_get_attached_sas_addr(phy, phy->sas_phy.attached_sas_addr);
252  spin_unlock_irqrestore(&phy->sas_phy.frame_rcvd_lock, flags);
253  asd_dump_frame_rcvd(phy, dl);
254  asd_form_port(ascb->ha, phy);
256 }
257 
258 static void asd_link_reset_err_tasklet(struct asd_ascb *ascb,
259  struct done_list_struct *dl,
260  int phy_id)
261 {
262  struct asd_ha_struct *asd_ha = ascb->ha;
263  struct sas_ha_struct *sas_ha = &asd_ha->sas_ha;
264  struct asd_sas_phy *sas_phy = sas_ha->sas_phy[phy_id];
265  struct asd_phy *phy = &asd_ha->phys[phy_id];
266  u8 lr_error = dl->status_block[1];
267  u8 retries_left = dl->status_block[2];
268 
269  switch (lr_error) {
270  case 0:
271  ASD_DPRINTK("phy%d: Receive ID timer expired\n", phy_id);
272  break;
273  case 1:
274  ASD_DPRINTK("phy%d: Loss of signal\n", phy_id);
275  break;
276  case 2:
277  ASD_DPRINTK("phy%d: Loss of dword sync\n", phy_id);
278  break;
279  case 3:
280  ASD_DPRINTK("phy%d: Receive FIS timeout\n", phy_id);
281  break;
282  default:
283  ASD_DPRINTK("phy%d: unknown link reset error code: 0x%x\n",
284  phy_id, lr_error);
285  break;
286  }
287 
288  asd_turn_led(asd_ha, phy_id, 0);
289  sas_phy_disconnected(sas_phy);
290  asd_deform_port(asd_ha, phy);
291  sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
292 
293  if (retries_left == 0) {
294  int num = 1;
295  struct asd_ascb *cp = asd_ascb_alloc_list(ascb->ha, &num,
296  GFP_ATOMIC);
297  if (!cp) {
298  asd_printk("%s: out of memory\n", __func__);
299  goto out;
300  }
301  ASD_DPRINTK("phy%d: retries:0 performing link reset seq\n",
302  phy_id);
303  asd_build_control_phy(cp, phy_id, ENABLE_PHY);
304  if (asd_post_ascb_list(ascb->ha, cp, 1) != 0)
305  asd_ascb_free(cp);
306  }
307 out:
308  ;
309 }
310 
311 static void asd_primitive_rcvd_tasklet(struct asd_ascb *ascb,
312  struct done_list_struct *dl,
313  int phy_id)
314 {
315  unsigned long flags;
316  struct sas_ha_struct *sas_ha = &ascb->ha->sas_ha;
317  struct asd_sas_phy *sas_phy = sas_ha->sas_phy[phy_id];
318  struct asd_ha_struct *asd_ha = ascb->ha;
319  struct asd_phy *phy = &asd_ha->phys[phy_id];
320  u8 reg = dl->status_block[1];
321  u32 cont = dl->status_block[2] << ((reg & 3)*8);
322 
323  reg &= ~3;
324  switch (reg) {
325  case LmPRMSTAT0BYTE0:
326  switch (cont) {
327  case LmBROADCH:
328  case LmBROADRVCH0:
329  case LmBROADRVCH1:
330  case LmBROADSES:
331  ASD_DPRINTK("phy%d: BROADCAST change received:%d\n",
332  phy_id, cont);
333  spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
334  sas_phy->sas_prim = ffs(cont);
335  spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
336  sas_ha->notify_port_event(sas_phy,PORTE_BROADCAST_RCVD);
337  break;
338 
339  case LmUNKNOWNP:
340  ASD_DPRINTK("phy%d: unknown BREAK\n", phy_id);
341  break;
342 
343  default:
344  ASD_DPRINTK("phy%d: primitive reg:0x%x, cont:0x%04x\n",
345  phy_id, reg, cont);
346  break;
347  }
348  break;
349  case LmPRMSTAT1BYTE0:
350  switch (cont) {
351  case LmHARDRST:
352  ASD_DPRINTK("phy%d: HARD_RESET primitive rcvd\n",
353  phy_id);
354  /* The sequencer disables all phys on that port.
355  * We have to re-enable the phys ourselves. */
356  asd_deform_port(asd_ha, phy);
357  sas_ha->notify_port_event(sas_phy, PORTE_HARD_RESET);
358  break;
359 
360  default:
361  ASD_DPRINTK("phy%d: primitive reg:0x%x, cont:0x%04x\n",
362  phy_id, reg, cont);
363  break;
364  }
365  break;
366  default:
367  ASD_DPRINTK("unknown primitive register:0x%x\n",
368  dl->status_block[1]);
369  break;
370  }
371 }
372 
382 void asd_invalidate_edb(struct asd_ascb *ascb, int edb_id)
383 {
384  struct asd_seq_data *seq = &ascb->ha->seq;
385  struct empty_scb *escb = &ascb->scb->escb;
386  struct sg_el *eb = &escb->eb[edb_id];
387  struct asd_dma_tok *edb = seq->edb_arr[ascb->edb_index + edb_id];
388 
389  memset(edb->vaddr, 0, ASD_EDB_SIZE);
390  eb->flags |= ELEMENT_NOT_VALID;
391  escb->num_valid--;
392 
393  if (escb->num_valid == 0) {
394  int i;
395  /* ASD_DPRINTK("reposting escb: vaddr: 0x%p, "
396  "dma_handle: 0x%08llx, next: 0x%08llx, "
397  "index:%d, opcode:0x%02x\n",
398  ascb->dma_scb.vaddr,
399  (u64)ascb->dma_scb.dma_handle,
400  le64_to_cpu(ascb->scb->header.next_scb),
401  le16_to_cpu(ascb->scb->header.index),
402  ascb->scb->header.opcode);
403  */
404  escb->num_valid = ASD_EDBS_PER_SCB;
405  for (i = 0; i < ASD_EDBS_PER_SCB; i++)
406  escb->eb[i].flags = 0;
407  if (!list_empty(&ascb->list))
408  list_del_init(&ascb->list);
409  i = asd_post_escb_list(ascb->ha, ascb, 1);
410  if (i)
411  asd_printk("couldn't post escb, err:%d\n", i);
412  }
413 }
414 
415 static void escb_tasklet_complete(struct asd_ascb *ascb,
416  struct done_list_struct *dl)
417 {
418  struct asd_ha_struct *asd_ha = ascb->ha;
419  struct sas_ha_struct *sas_ha = &asd_ha->sas_ha;
420  int edb = (dl->opcode & DL_PHY_MASK) - 1; /* [0xc1,0xc7] -> [0,6] */
421  u8 sb_opcode = dl->status_block[0];
422  int phy_id = sb_opcode & DL_PHY_MASK;
423  struct asd_sas_phy *sas_phy = sas_ha->sas_phy[phy_id];
424  struct asd_phy *phy = &asd_ha->phys[phy_id];
425 
426  if (edb > 6 || edb < 0) {
427  ASD_DPRINTK("edb is 0x%x! dl->opcode is 0x%x\n",
428  edb, dl->opcode);
429  ASD_DPRINTK("sb_opcode : 0x%x, phy_id: 0x%x\n",
430  sb_opcode, phy_id);
431  ASD_DPRINTK("escb: vaddr: 0x%p, "
432  "dma_handle: 0x%llx, next: 0x%llx, "
433  "index:%d, opcode:0x%02x\n",
434  ascb->dma_scb.vaddr,
435  (unsigned long long)ascb->dma_scb.dma_handle,
436  (unsigned long long)
437  le64_to_cpu(ascb->scb->header.next_scb),
438  le16_to_cpu(ascb->scb->header.index),
439  ascb->scb->header.opcode);
440  }
441 
442  /* Catch these before we mask off the sb_opcode bits */
443  switch (sb_opcode) {
444  case REQ_TASK_ABORT: {
445  struct asd_ascb *a, *b;
446  u16 tc_abort;
447  struct domain_device *failed_dev = NULL;
448 
449  ASD_DPRINTK("%s: REQ_TASK_ABORT, reason=0x%X\n",
450  __func__, dl->status_block[3]);
451 
452  /*
453  * Find the task that caused the abort and abort it first.
454  * The sequencer won't put anything on the done list until
455  * that happens.
456  */
457  tc_abort = *((u16*)(&dl->status_block[1]));
458  tc_abort = le16_to_cpu(tc_abort);
459 
460  list_for_each_entry_safe(a, b, &asd_ha->seq.pend_q, list) {
461  struct sas_task *task = a->uldd_task;
462 
463  if (a->tc_index != tc_abort)
464  continue;
465 
466  if (task) {
467  failed_dev = task->dev;
468  sas_task_abort(task);
469  } else {
470  ASD_DPRINTK("R_T_A for non TASK scb 0x%x\n",
471  a->scb->header.opcode);
472  }
473  break;
474  }
475 
476  if (!failed_dev) {
477  ASD_DPRINTK("%s: Can't find task (tc=%d) to abort!\n",
478  __func__, tc_abort);
479  goto out;
480  }
481 
482  /*
483  * Now abort everything else for that device (hba?) so
484  * that the EH will wake up and do something.
485  */
486  list_for_each_entry_safe(a, b, &asd_ha->seq.pend_q, list) {
487  struct sas_task *task = a->uldd_task;
488 
489  if (task &&
490  task->dev == failed_dev &&
491  a->tc_index != tc_abort)
492  sas_task_abort(task);
493  }
494 
495  goto out;
496  }
497  case REQ_DEVICE_RESET: {
498  struct asd_ascb *a;
500  unsigned long flags;
501  struct sas_task *last_dev_task = NULL;
502 
503  conn_handle = *((u16*)(&dl->status_block[1]));
504  conn_handle = le16_to_cpu(conn_handle);
505 
506  ASD_DPRINTK("%s: REQ_DEVICE_RESET, reason=0x%X\n", __func__,
507  dl->status_block[3]);
508 
509  /* Find the last pending task for the device... */
510  list_for_each_entry(a, &asd_ha->seq.pend_q, list) {
511  u16 x;
512  struct domain_device *dev;
513  struct sas_task *task = a->uldd_task;
514 
515  if (!task)
516  continue;
517  dev = task->dev;
518 
519  x = (unsigned long)dev->lldd_dev;
520  if (x == conn_handle)
521  last_dev_task = task;
522  }
523 
524  if (!last_dev_task) {
525  ASD_DPRINTK("%s: Device reset for idle device %d?\n",
526  __func__, conn_handle);
527  goto out;
528  }
529 
530  /* ...and set the reset flag */
531  spin_lock_irqsave(&last_dev_task->task_state_lock, flags);
532  last_dev_task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
533  spin_unlock_irqrestore(&last_dev_task->task_state_lock, flags);
534 
535  /* Kill all pending tasks for the device */
536  list_for_each_entry(a, &asd_ha->seq.pend_q, list) {
537  u16 x;
538  struct domain_device *dev;
539  struct sas_task *task = a->uldd_task;
540 
541  if (!task)
542  continue;
543  dev = task->dev;
544 
545  x = (unsigned long)dev->lldd_dev;
546  if (x == conn_handle)
547  sas_task_abort(task);
548  }
549 
550  goto out;
551  }
552  case SIGNAL_NCQ_ERROR:
553  ASD_DPRINTK("%s: SIGNAL_NCQ_ERROR\n", __func__);
554  goto out;
555  case CLEAR_NCQ_ERROR:
556  ASD_DPRINTK("%s: CLEAR_NCQ_ERROR\n", __func__);
557  goto out;
558  }
559 
560  sb_opcode &= ~DL_PHY_MASK;
561 
562  switch (sb_opcode) {
563  case BYTES_DMAED:
564  ASD_DPRINTK("%s: phy%d: BYTES_DMAED\n", __func__, phy_id);
565  asd_bytes_dmaed_tasklet(ascb, dl, edb, phy_id);
566  break;
567  case PRIMITIVE_RECVD:
568  ASD_DPRINTK("%s: phy%d: PRIMITIVE_RECVD\n", __func__,
569  phy_id);
570  asd_primitive_rcvd_tasklet(ascb, dl, phy_id);
571  break;
572  case PHY_EVENT:
573  ASD_DPRINTK("%s: phy%d: PHY_EVENT\n", __func__, phy_id);
574  asd_phy_event_tasklet(ascb, dl);
575  break;
576  case LINK_RESET_ERROR:
577  ASD_DPRINTK("%s: phy%d: LINK_RESET_ERROR\n", __func__,
578  phy_id);
579  asd_link_reset_err_tasklet(ascb, dl, phy_id);
580  break;
581  case TIMER_EVENT:
582  ASD_DPRINTK("%s: phy%d: TIMER_EVENT, lost dw sync\n",
583  __func__, phy_id);
584  asd_turn_led(asd_ha, phy_id, 0);
585  /* the device is gone */
586  sas_phy_disconnected(sas_phy);
587  asd_deform_port(asd_ha, phy);
588  sas_ha->notify_port_event(sas_phy, PORTE_TIMER_EVENT);
589  break;
590  default:
591  ASD_DPRINTK("%s: phy%d: unknown event:0x%x\n", __func__,
592  phy_id, sb_opcode);
593  ASD_DPRINTK("edb is 0x%x! dl->opcode is 0x%x\n",
594  edb, dl->opcode);
595  ASD_DPRINTK("sb_opcode : 0x%x, phy_id: 0x%x\n",
596  sb_opcode, phy_id);
597  ASD_DPRINTK("escb: vaddr: 0x%p, "
598  "dma_handle: 0x%llx, next: 0x%llx, "
599  "index:%d, opcode:0x%02x\n",
600  ascb->dma_scb.vaddr,
601  (unsigned long long)ascb->dma_scb.dma_handle,
602  (unsigned long long)
603  le64_to_cpu(ascb->scb->header.next_scb),
604  le16_to_cpu(ascb->scb->header.index),
605  ascb->scb->header.opcode);
606 
607  break;
608  }
609 out:
610  asd_invalidate_edb(ascb, edb);
611 }
612 
614 {
615  struct asd_seq_data *seq = &asd_ha->seq;
616  int i;
617 
618  for (i = 0; i < seq->num_escbs; i++)
619  seq->escb_arr[i]->tasklet_complete = escb_tasklet_complete;
620 
621  ASD_DPRINTK("posting %d escbs\n", i);
622  return asd_post_escb_list(asd_ha, seq->escb_arr[0], seq->num_escbs);
623 }
624 
625 /* ---------- CONTROL PHY ---------- */
626 
627 #define CONTROL_PHY_STATUS (CURRENT_DEVICE_PRESENT | CURRENT_OOB_DONE \
628  | CURRENT_SPINUP_HOLD | CURRENT_GTO_TIMEOUT \
629  | CURRENT_OOB_ERROR)
630 
642 static void control_phy_tasklet_complete(struct asd_ascb *ascb,
643  struct done_list_struct *dl)
644 {
645  struct asd_ha_struct *asd_ha = ascb->ha;
646  struct scb *scb = ascb->scb;
647  struct control_phy *control_phy = &scb->control_phy;
648  u8 phy_id = control_phy->phy_id;
649  struct asd_phy *phy = &ascb->ha->phys[phy_id];
650 
651  u8 status = dl->status_block[0];
652  u8 oob_status = dl->status_block[1];
653  u8 oob_mode = dl->status_block[2];
654  /* u8 oob_signals= dl->status_block[3]; */
655 
656  if (status != 0) {
657  ASD_DPRINTK("%s: phy%d status block opcode:0x%x\n",
658  __func__, phy_id, status);
659  goto out;
660  }
661 
662  switch (control_phy->sub_func) {
663  case DISABLE_PHY:
664  asd_ha->hw_prof.enabled_phys &= ~(1 << phy_id);
665  asd_turn_led(asd_ha, phy_id, 0);
666  asd_control_led(asd_ha, phy_id, 0);
667  ASD_DPRINTK("%s: disable phy%d\n", __func__, phy_id);
668  break;
669 
670  case ENABLE_PHY:
671  asd_control_led(asd_ha, phy_id, 1);
672  if (oob_status & CURRENT_OOB_DONE) {
673  asd_ha->hw_prof.enabled_phys |= (1 << phy_id);
674  get_lrate_mode(phy, oob_mode);
675  asd_turn_led(asd_ha, phy_id, 1);
676  ASD_DPRINTK("%s: phy%d, lrate:0x%x, proto:0x%x\n",
677  __func__, phy_id,phy->sas_phy.linkrate,
678  phy->sas_phy.iproto);
679  } else if (oob_status & CURRENT_SPINUP_HOLD) {
680  asd_ha->hw_prof.enabled_phys |= (1 << phy_id);
681  asd_turn_led(asd_ha, phy_id, 1);
682  ASD_DPRINTK("%s: phy%d, spinup hold\n", __func__,
683  phy_id);
684  } else if (oob_status & CURRENT_ERR_MASK) {
685  asd_turn_led(asd_ha, phy_id, 0);
686  ASD_DPRINTK("%s: phy%d: error: oob status:0x%02x\n",
687  __func__, phy_id, oob_status);
688  } else if (oob_status & (CURRENT_HOT_PLUG_CNCT
690  asd_ha->hw_prof.enabled_phys |= (1 << phy_id);
691  asd_turn_led(asd_ha, phy_id, 1);
692  ASD_DPRINTK("%s: phy%d: hot plug or device present\n",
693  __func__, phy_id);
694  } else {
695  asd_ha->hw_prof.enabled_phys |= (1 << phy_id);
696  asd_turn_led(asd_ha, phy_id, 0);
697  ASD_DPRINTK("%s: phy%d: no device present: "
698  "oob_status:0x%x\n",
699  __func__, phy_id, oob_status);
700  }
701  break;
702  case RELEASE_SPINUP_HOLD:
703  case PHY_NO_OP:
704  case EXECUTE_HARD_RESET:
705  ASD_DPRINTK("%s: phy%d: sub_func:0x%x\n", __func__,
706  phy_id, control_phy->sub_func);
707  /* XXX finish */
708  break;
709  default:
710  ASD_DPRINTK("%s: phy%d: sub_func:0x%x?\n", __func__,
711  phy_id, control_phy->sub_func);
712  break;
713  }
714 out:
715  asd_ascb_free(ascb);
716 }
717 
718 static void set_speed_mask(u8 *speed_mask, struct asd_phy_desc *pd)
719 {
720  /* disable all speeds, then enable defaults */
723 
724  switch (pd->max_sas_lrate) {
726  *speed_mask &= ~SAS_SPEED_60_DIS;
727  default:
729  *speed_mask &= ~SAS_SPEED_30_DIS;
731  *speed_mask &= ~SAS_SPEED_15_DIS;
732  }
733 
734  switch (pd->min_sas_lrate) {
736  *speed_mask |= SAS_SPEED_30_DIS;
738  *speed_mask |= SAS_SPEED_15_DIS;
739  default:
741  /* nothing to do */
742  ;
743  }
744 
745  switch (pd->max_sata_lrate) {
747  *speed_mask &= ~SATA_SPEED_30_DIS;
748  default:
750  *speed_mask &= ~SATA_SPEED_15_DIS;
751  }
752 
753  switch (pd->min_sata_lrate) {
755  *speed_mask |= SATA_SPEED_15_DIS;
756  default:
758  /* nothing to do */
759  ;
760  }
761 }
762 
776 void asd_build_control_phy(struct asd_ascb *ascb, int phy_id, u8 subfunc)
777 {
778  struct asd_phy *phy = &ascb->ha->phys[phy_id];
779  struct scb *scb = ascb->scb;
780  struct control_phy *control_phy = &scb->control_phy;
781 
782  scb->header.opcode = CONTROL_PHY;
783  control_phy->phy_id = (u8) phy_id;
784  control_phy->sub_func = subfunc;
785 
786  switch (subfunc) {
787  case EXECUTE_HARD_RESET: /* 0x81 */
788  case ENABLE_PHY: /* 0x01 */
789  /* decide hot plug delay */
790  control_phy->hot_plug_delay = HOTPLUG_DELAY_TIMEOUT;
791 
792  /* decide speed mask */
793  set_speed_mask(&control_phy->speed_mask, phy->phy_desc);
794 
795  /* initiator port settings are in the hi nibble */
796  if (phy->sas_phy.role == PHY_ROLE_INITIATOR)
797  control_phy->port_type = SAS_PROTOCOL_ALL << 4;
798  else if (phy->sas_phy.role == PHY_ROLE_TARGET)
799  control_phy->port_type = SAS_PROTOCOL_ALL;
800  else
801  control_phy->port_type =
803 
804  /* link reset retries, this should be nominal */
805  control_phy->link_reset_retries = 10;
806 
807  case RELEASE_SPINUP_HOLD: /* 0x02 */
808  /* decide the func_mask */
809  control_phy->func_mask = FUNCTION_MASK_DEFAULT;
810  if (phy->phy_desc->flags & ASD_SATA_SPINUP_HOLD)
811  control_phy->func_mask &= ~SPINUP_HOLD_DIS;
812  else
813  control_phy->func_mask |= SPINUP_HOLD_DIS;
814  }
815 
816  control_phy->conn_handle = cpu_to_le16(0xFFFF);
817 
818  ascb->tasklet_complete = control_phy_tasklet_complete;
819 }
820 
821 /* ---------- INITIATE LINK ADM TASK ---------- */
822 
823 #if 0
824 
825 static void link_adm_tasklet_complete(struct asd_ascb *ascb,
826  struct done_list_struct *dl)
827 {
828  u8 opcode = dl->opcode;
829  struct initiate_link_adm *link_adm = &ascb->scb->link_adm;
830  u8 phy_id = link_adm->phy_id;
831 
832  if (opcode != TC_NO_ERROR) {
833  asd_printk("phy%d: link adm task 0x%x completed with error "
834  "0x%x\n", phy_id, link_adm->sub_func, opcode);
835  }
836  ASD_DPRINTK("phy%d: link adm task 0x%x: 0x%x\n",
837  phy_id, link_adm->sub_func, opcode);
838 
839  asd_ascb_free(ascb);
840 }
841 
842 void asd_build_initiate_link_adm_task(struct asd_ascb *ascb, int phy_id,
843  u8 subfunc)
844 {
845  struct scb *scb = ascb->scb;
846  struct initiate_link_adm *link_adm = &scb->link_adm;
847 
848  scb->header.opcode = INITIATE_LINK_ADM_TASK;
849 
850  link_adm->phy_id = phy_id;
851  link_adm->sub_func = subfunc;
852  link_adm->conn_handle = cpu_to_le16(0xFFFF);
853 
854  ascb->tasklet_complete = link_adm_tasklet_complete;
855 }
856 
857 #endif /* 0 */
858 
859 /* ---------- SCB timer ---------- */
860 
872 void asd_ascb_timedout(unsigned long data)
873 {
874  struct asd_ascb *ascb = (void *) data;
875  struct asd_seq_data *seq = &ascb->ha->seq;
876  unsigned long flags;
877 
878  ASD_DPRINTK("scb:0x%x timed out\n", ascb->scb->header.opcode);
879 
880  spin_lock_irqsave(&seq->pend_q_lock, flags);
881  seq->pending--;
882  list_del_init(&ascb->list);
883  spin_unlock_irqrestore(&seq->pend_q_lock, flags);
884 
885  asd_ascb_free(ascb);
886 }
887 
888 /* ---------- CONTROL PHY ---------- */
889 
890 /* Given the spec value, return a driver value. */
891 static const int phy_func_table[] = {
897 };
898 
899 int asd_control_phy(struct asd_sas_phy *phy, enum phy_func func, void *arg)
900 {
901  struct asd_ha_struct *asd_ha = phy->ha->lldd_ha;
902  struct asd_phy_desc *pd = asd_ha->phys[phy->id].phy_desc;
903  struct asd_ascb *ascb;
904  struct sas_phy_linkrates *rates;
905  int res = 1;
906 
907  switch (func) {
909  case PHY_FUNC_GET_EVENTS:
910  return -ENOSYS;
912  rates = arg;
913  if (rates->minimum_linkrate) {
914  pd->min_sas_lrate = rates->minimum_linkrate;
915  pd->min_sata_lrate = rates->minimum_linkrate;
916  }
917  if (rates->maximum_linkrate) {
918  pd->max_sas_lrate = rates->maximum_linkrate;
919  pd->max_sata_lrate = rates->maximum_linkrate;
920  }
921  func = PHY_FUNC_LINK_RESET;
922  break;
923  default:
924  break;
925  }
926 
927  ascb = asd_ascb_alloc_list(asd_ha, &res, GFP_KERNEL);
928  if (!ascb)
929  return -ENOMEM;
930 
931  asd_build_control_phy(ascb, phy->id, phy_func_table[func]);
932  res = asd_post_ascb_list(asd_ha, ascb , 1);
933  if (res)
934  asd_ascb_free(ascb);
935 
936  return res;
937 }