Loading...
1/*
2 * Aic94xx SAS/SATA driver hardware interface.
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 */
26
27#include <linux/pci.h>
28#include <linux/slab.h>
29#include <linux/delay.h>
30#include <linux/module.h>
31#include <linux/firmware.h>
32
33#include "aic94xx.h"
34#include "aic94xx_reg.h"
35#include "aic94xx_hwi.h"
36#include "aic94xx_seq.h"
37#include "aic94xx_dump.h"
38
39u32 MBAR0_SWB_SIZE;
40
41/* ---------- Initialization ---------- */
42
43static int asd_get_user_sas_addr(struct asd_ha_struct *asd_ha)
44{
45 /* adapter came with a sas address */
46 if (asd_ha->hw_prof.sas_addr[0])
47 return 0;
48
49 return sas_request_addr(asd_ha->sas_ha.core.shost,
50 asd_ha->hw_prof.sas_addr);
51}
52
53static void asd_propagate_sas_addr(struct asd_ha_struct *asd_ha)
54{
55 int i;
56
57 for (i = 0; i < ASD_MAX_PHYS; i++) {
58 if (asd_ha->hw_prof.phy_desc[i].sas_addr[0] == 0)
59 continue;
60 /* Set a phy's address only if it has none.
61 */
62 ASD_DPRINTK("setting phy%d addr to %llx\n", i,
63 SAS_ADDR(asd_ha->hw_prof.sas_addr));
64 memcpy(asd_ha->hw_prof.phy_desc[i].sas_addr,
65 asd_ha->hw_prof.sas_addr, SAS_ADDR_SIZE);
66 }
67}
68
69/* ---------- PHY initialization ---------- */
70
71static void asd_init_phy_identify(struct asd_phy *phy)
72{
73 phy->identify_frame = phy->id_frm_tok->vaddr;
74
75 memset(phy->identify_frame, 0, sizeof(*phy->identify_frame));
76
77 phy->identify_frame->dev_type = SAS_END_DEV;
78 if (phy->sas_phy.role & PHY_ROLE_INITIATOR)
79 phy->identify_frame->initiator_bits = phy->sas_phy.iproto;
80 if (phy->sas_phy.role & PHY_ROLE_TARGET)
81 phy->identify_frame->target_bits = phy->sas_phy.tproto;
82 memcpy(phy->identify_frame->sas_addr, phy->phy_desc->sas_addr,
83 SAS_ADDR_SIZE);
84 phy->identify_frame->phy_id = phy->sas_phy.id;
85}
86
87static int asd_init_phy(struct asd_phy *phy)
88{
89 struct asd_ha_struct *asd_ha = phy->sas_phy.ha->lldd_ha;
90 struct asd_sas_phy *sas_phy = &phy->sas_phy;
91
92 sas_phy->enabled = 1;
93 sas_phy->class = SAS;
94 sas_phy->iproto = SAS_PROTOCOL_ALL;
95 sas_phy->tproto = 0;
96 sas_phy->type = PHY_TYPE_PHYSICAL;
97 sas_phy->role = PHY_ROLE_INITIATOR;
98 sas_phy->oob_mode = OOB_NOT_CONNECTED;
99 sas_phy->linkrate = SAS_LINK_RATE_UNKNOWN;
100
101 phy->id_frm_tok = asd_alloc_coherent(asd_ha,
102 sizeof(*phy->identify_frame),
103 GFP_KERNEL);
104 if (!phy->id_frm_tok) {
105 asd_printk("no mem for IDENTIFY for phy%d\n", sas_phy->id);
106 return -ENOMEM;
107 } else
108 asd_init_phy_identify(phy);
109
110 memset(phy->frame_rcvd, 0, sizeof(phy->frame_rcvd));
111
112 return 0;
113}
114
115static void asd_init_ports(struct asd_ha_struct *asd_ha)
116{
117 int i;
118
119 spin_lock_init(&asd_ha->asd_ports_lock);
120 for (i = 0; i < ASD_MAX_PHYS; i++) {
121 struct asd_port *asd_port = &asd_ha->asd_ports[i];
122
123 memset(asd_port->sas_addr, 0, SAS_ADDR_SIZE);
124 memset(asd_port->attached_sas_addr, 0, SAS_ADDR_SIZE);
125 asd_port->phy_mask = 0;
126 asd_port->num_phys = 0;
127 }
128}
129
130static int asd_init_phys(struct asd_ha_struct *asd_ha)
131{
132 u8 i;
133 u8 phy_mask = asd_ha->hw_prof.enabled_phys;
134
135 for (i = 0; i < ASD_MAX_PHYS; i++) {
136 struct asd_phy *phy = &asd_ha->phys[i];
137
138 phy->phy_desc = &asd_ha->hw_prof.phy_desc[i];
139 phy->asd_port = NULL;
140
141 phy->sas_phy.enabled = 0;
142 phy->sas_phy.id = i;
143 phy->sas_phy.sas_addr = &phy->phy_desc->sas_addr[0];
144 phy->sas_phy.frame_rcvd = &phy->frame_rcvd[0];
145 phy->sas_phy.ha = &asd_ha->sas_ha;
146 phy->sas_phy.lldd_phy = phy;
147 }
148
149 /* Now enable and initialize only the enabled phys. */
150 for_each_phy(phy_mask, phy_mask, i) {
151 int err = asd_init_phy(&asd_ha->phys[i]);
152 if (err)
153 return err;
154 }
155
156 return 0;
157}
158
159/* ---------- Sliding windows ---------- */
160
161static int asd_init_sw(struct asd_ha_struct *asd_ha)
162{
163 struct pci_dev *pcidev = asd_ha->pcidev;
164 int err;
165 u32 v;
166
167 /* Unlock MBARs */
168 err = pci_read_config_dword(pcidev, PCI_CONF_MBAR_KEY, &v);
169 if (err) {
170 asd_printk("couldn't access conf. space of %s\n",
171 pci_name(pcidev));
172 goto Err;
173 }
174 if (v)
175 err = pci_write_config_dword(pcidev, PCI_CONF_MBAR_KEY, v);
176 if (err) {
177 asd_printk("couldn't write to MBAR_KEY of %s\n",
178 pci_name(pcidev));
179 goto Err;
180 }
181
182 /* Set sliding windows A, B and C to point to proper internal
183 * memory regions.
184 */
185 pci_write_config_dword(pcidev, PCI_CONF_MBAR0_SWA, REG_BASE_ADDR);
186 pci_write_config_dword(pcidev, PCI_CONF_MBAR0_SWB,
187 REG_BASE_ADDR_CSEQCIO);
188 pci_write_config_dword(pcidev, PCI_CONF_MBAR0_SWC, REG_BASE_ADDR_EXSI);
189 asd_ha->io_handle[0].swa_base = REG_BASE_ADDR;
190 asd_ha->io_handle[0].swb_base = REG_BASE_ADDR_CSEQCIO;
191 asd_ha->io_handle[0].swc_base = REG_BASE_ADDR_EXSI;
192 MBAR0_SWB_SIZE = asd_ha->io_handle[0].len - 0x80;
193 if (!asd_ha->iospace) {
194 /* MBAR1 will point to OCM (On Chip Memory) */
195 pci_write_config_dword(pcidev, PCI_CONF_MBAR1, OCM_BASE_ADDR);
196 asd_ha->io_handle[1].swa_base = OCM_BASE_ADDR;
197 }
198 spin_lock_init(&asd_ha->iolock);
199Err:
200 return err;
201}
202
203/* ---------- SCB initialization ---------- */
204
205/**
206 * asd_init_scbs - manually allocate the first SCB.
207 * @asd_ha: pointer to host adapter structure
208 *
209 * This allocates the very first SCB which would be sent to the
210 * sequencer for execution. Its bus address is written to
211 * CSEQ_Q_NEW_POINTER, mode page 2, mode 8. Since the bus address of
212 * the _next_ scb to be DMA-ed to the host adapter is read from the last
213 * SCB DMA-ed to the host adapter, we have to always stay one step
214 * ahead of the sequencer and keep one SCB already allocated.
215 */
216static int asd_init_scbs(struct asd_ha_struct *asd_ha)
217{
218 struct asd_seq_data *seq = &asd_ha->seq;
219 int bitmap_bytes;
220
221 /* allocate the index array and bitmap */
222 asd_ha->seq.tc_index_bitmap_bits = asd_ha->hw_prof.max_scbs;
223 asd_ha->seq.tc_index_array = kzalloc(asd_ha->seq.tc_index_bitmap_bits*
224 sizeof(void *), GFP_KERNEL);
225 if (!asd_ha->seq.tc_index_array)
226 return -ENOMEM;
227
228 bitmap_bytes = (asd_ha->seq.tc_index_bitmap_bits+7)/8;
229 bitmap_bytes = BITS_TO_LONGS(bitmap_bytes*8)*sizeof(unsigned long);
230 asd_ha->seq.tc_index_bitmap = kzalloc(bitmap_bytes, GFP_KERNEL);
231 if (!asd_ha->seq.tc_index_bitmap)
232 return -ENOMEM;
233
234 spin_lock_init(&seq->tc_index_lock);
235
236 seq->next_scb.size = sizeof(struct scb);
237 seq->next_scb.vaddr = dma_pool_alloc(asd_ha->scb_pool, GFP_KERNEL,
238 &seq->next_scb.dma_handle);
239 if (!seq->next_scb.vaddr) {
240 kfree(asd_ha->seq.tc_index_bitmap);
241 kfree(asd_ha->seq.tc_index_array);
242 asd_ha->seq.tc_index_bitmap = NULL;
243 asd_ha->seq.tc_index_array = NULL;
244 return -ENOMEM;
245 }
246
247 seq->pending = 0;
248 spin_lock_init(&seq->pend_q_lock);
249 INIT_LIST_HEAD(&seq->pend_q);
250
251 return 0;
252}
253
254static void asd_get_max_scb_ddb(struct asd_ha_struct *asd_ha)
255{
256 asd_ha->hw_prof.max_scbs = asd_get_cmdctx_size(asd_ha)/ASD_SCB_SIZE;
257 asd_ha->hw_prof.max_ddbs = asd_get_devctx_size(asd_ha)/ASD_DDB_SIZE;
258 ASD_DPRINTK("max_scbs:%d, max_ddbs:%d\n",
259 asd_ha->hw_prof.max_scbs,
260 asd_ha->hw_prof.max_ddbs);
261}
262
263/* ---------- Done List initialization ---------- */
264
265static void asd_dl_tasklet_handler(unsigned long);
266
267static int asd_init_dl(struct asd_ha_struct *asd_ha)
268{
269 asd_ha->seq.actual_dl
270 = asd_alloc_coherent(asd_ha,
271 ASD_DL_SIZE * sizeof(struct done_list_struct),
272 GFP_KERNEL);
273 if (!asd_ha->seq.actual_dl)
274 return -ENOMEM;
275 asd_ha->seq.dl = asd_ha->seq.actual_dl->vaddr;
276 asd_ha->seq.dl_toggle = ASD_DEF_DL_TOGGLE;
277 asd_ha->seq.dl_next = 0;
278 tasklet_init(&asd_ha->seq.dl_tasklet, asd_dl_tasklet_handler,
279 (unsigned long) asd_ha);
280
281 return 0;
282}
283
284/* ---------- EDB and ESCB init ---------- */
285
286static int asd_alloc_edbs(struct asd_ha_struct *asd_ha, gfp_t gfp_flags)
287{
288 struct asd_seq_data *seq = &asd_ha->seq;
289 int i;
290
291 seq->edb_arr = kmalloc(seq->num_edbs*sizeof(*seq->edb_arr), gfp_flags);
292 if (!seq->edb_arr)
293 return -ENOMEM;
294
295 for (i = 0; i < seq->num_edbs; i++) {
296 seq->edb_arr[i] = asd_alloc_coherent(asd_ha, ASD_EDB_SIZE,
297 gfp_flags);
298 if (!seq->edb_arr[i])
299 goto Err_unroll;
300 memset(seq->edb_arr[i]->vaddr, 0, ASD_EDB_SIZE);
301 }
302
303 ASD_DPRINTK("num_edbs:%d\n", seq->num_edbs);
304
305 return 0;
306
307Err_unroll:
308 for (i-- ; i >= 0; i--)
309 asd_free_coherent(asd_ha, seq->edb_arr[i]);
310 kfree(seq->edb_arr);
311 seq->edb_arr = NULL;
312
313 return -ENOMEM;
314}
315
316static int asd_alloc_escbs(struct asd_ha_struct *asd_ha,
317 gfp_t gfp_flags)
318{
319 struct asd_seq_data *seq = &asd_ha->seq;
320 struct asd_ascb *escb;
321 int i, escbs;
322
323 seq->escb_arr = kmalloc(seq->num_escbs*sizeof(*seq->escb_arr),
324 gfp_flags);
325 if (!seq->escb_arr)
326 return -ENOMEM;
327
328 escbs = seq->num_escbs;
329 escb = asd_ascb_alloc_list(asd_ha, &escbs, gfp_flags);
330 if (!escb) {
331 asd_printk("couldn't allocate list of escbs\n");
332 goto Err;
333 }
334 seq->num_escbs -= escbs; /* subtract what was not allocated */
335 ASD_DPRINTK("num_escbs:%d\n", seq->num_escbs);
336
337 for (i = 0; i < seq->num_escbs; i++, escb = list_entry(escb->list.next,
338 struct asd_ascb,
339 list)) {
340 seq->escb_arr[i] = escb;
341 escb->scb->header.opcode = EMPTY_SCB;
342 }
343
344 return 0;
345Err:
346 kfree(seq->escb_arr);
347 seq->escb_arr = NULL;
348 return -ENOMEM;
349
350}
351
352static void asd_assign_edbs2escbs(struct asd_ha_struct *asd_ha)
353{
354 struct asd_seq_data *seq = &asd_ha->seq;
355 int i, k, z = 0;
356
357 for (i = 0; i < seq->num_escbs; i++) {
358 struct asd_ascb *ascb = seq->escb_arr[i];
359 struct empty_scb *escb = &ascb->scb->escb;
360
361 ascb->edb_index = z;
362
363 escb->num_valid = ASD_EDBS_PER_SCB;
364
365 for (k = 0; k < ASD_EDBS_PER_SCB; k++) {
366 struct sg_el *eb = &escb->eb[k];
367 struct asd_dma_tok *edb = seq->edb_arr[z++];
368
369 memset(eb, 0, sizeof(*eb));
370 eb->bus_addr = cpu_to_le64(((u64) edb->dma_handle));
371 eb->size = cpu_to_le32(((u32) edb->size));
372 }
373 }
374}
375
376/**
377 * asd_init_escbs -- allocate and initialize empty scbs
378 * @asd_ha: pointer to host adapter structure
379 *
380 * An empty SCB has sg_elements of ASD_EDBS_PER_SCB (7) buffers.
381 * They transport sense data, etc.
382 */
383static int asd_init_escbs(struct asd_ha_struct *asd_ha)
384{
385 struct asd_seq_data *seq = &asd_ha->seq;
386 int err = 0;
387
388 /* Allocate two empty data buffers (edb) per sequencer. */
389 int edbs = 2*(1+asd_ha->hw_prof.num_phys);
390
391 seq->num_escbs = (edbs+ASD_EDBS_PER_SCB-1)/ASD_EDBS_PER_SCB;
392 seq->num_edbs = seq->num_escbs * ASD_EDBS_PER_SCB;
393
394 err = asd_alloc_edbs(asd_ha, GFP_KERNEL);
395 if (err) {
396 asd_printk("couldn't allocate edbs\n");
397 return err;
398 }
399
400 err = asd_alloc_escbs(asd_ha, GFP_KERNEL);
401 if (err) {
402 asd_printk("couldn't allocate escbs\n");
403 return err;
404 }
405
406 asd_assign_edbs2escbs(asd_ha);
407 /* In order to insure that normal SCBs do not overfill sequencer
408 * memory and leave no space for escbs (halting condition),
409 * we increment pending here by the number of escbs. However,
410 * escbs are never pending.
411 */
412 seq->pending = seq->num_escbs;
413 seq->can_queue = 1 + (asd_ha->hw_prof.max_scbs - seq->pending)/2;
414
415 return 0;
416}
417
418/* ---------- HW initialization ---------- */
419
420/**
421 * asd_chip_hardrst -- hard reset the chip
422 * @asd_ha: pointer to host adapter structure
423 *
424 * This takes 16 cycles and is synchronous to CFCLK, which runs
425 * at 200 MHz, so this should take at most 80 nanoseconds.
426 */
427int asd_chip_hardrst(struct asd_ha_struct *asd_ha)
428{
429 int i;
430 int count = 100;
431 u32 reg;
432
433 for (i = 0 ; i < 4 ; i++) {
434 asd_write_reg_dword(asd_ha, COMBIST, HARDRST);
435 }
436
437 do {
438 udelay(1);
439 reg = asd_read_reg_dword(asd_ha, CHIMINT);
440 if (reg & HARDRSTDET) {
441 asd_write_reg_dword(asd_ha, CHIMINT,
442 HARDRSTDET|PORRSTDET);
443 return 0;
444 }
445 } while (--count > 0);
446
447 return -ENODEV;
448}
449
450/**
451 * asd_init_chip -- initialize the chip
452 * @asd_ha: pointer to host adapter structure
453 *
454 * Hard resets the chip, disables HA interrupts, downloads the sequnecer
455 * microcode and starts the sequencers. The caller has to explicitly
456 * enable HA interrupts with asd_enable_ints(asd_ha).
457 */
458static int asd_init_chip(struct asd_ha_struct *asd_ha)
459{
460 int err;
461
462 err = asd_chip_hardrst(asd_ha);
463 if (err) {
464 asd_printk("couldn't hard reset %s\n",
465 pci_name(asd_ha->pcidev));
466 goto out;
467 }
468
469 asd_disable_ints(asd_ha);
470
471 err = asd_init_seqs(asd_ha);
472 if (err) {
473 asd_printk("couldn't init seqs for %s\n",
474 pci_name(asd_ha->pcidev));
475 goto out;
476 }
477
478 err = asd_start_seqs(asd_ha);
479 if (err) {
480 asd_printk("coudln't start seqs for %s\n",
481 pci_name(asd_ha->pcidev));
482 goto out;
483 }
484out:
485 return err;
486}
487
488#define MAX_DEVS ((OCM_MAX_SIZE) / (ASD_DDB_SIZE))
489
490static int max_devs = 0;
491module_param_named(max_devs, max_devs, int, S_IRUGO);
492MODULE_PARM_DESC(max_devs, "\n"
493 "\tMaximum number of SAS devices to support (not LUs).\n"
494 "\tDefault: 2176, Maximum: 65663.\n");
495
496static int max_cmnds = 0;
497module_param_named(max_cmnds, max_cmnds, int, S_IRUGO);
498MODULE_PARM_DESC(max_cmnds, "\n"
499 "\tMaximum number of commands queuable.\n"
500 "\tDefault: 512, Maximum: 66047.\n");
501
502static void asd_extend_devctx_ocm(struct asd_ha_struct *asd_ha)
503{
504 unsigned long dma_addr = OCM_BASE_ADDR;
505 u32 d;
506
507 dma_addr -= asd_ha->hw_prof.max_ddbs * ASD_DDB_SIZE;
508 asd_write_reg_addr(asd_ha, DEVCTXBASE, (dma_addr_t) dma_addr);
509 d = asd_read_reg_dword(asd_ha, CTXDOMAIN);
510 d |= 4;
511 asd_write_reg_dword(asd_ha, CTXDOMAIN, d);
512 asd_ha->hw_prof.max_ddbs += MAX_DEVS;
513}
514
515static int asd_extend_devctx(struct asd_ha_struct *asd_ha)
516{
517 dma_addr_t dma_handle;
518 unsigned long dma_addr;
519 u32 d;
520 int size;
521
522 asd_extend_devctx_ocm(asd_ha);
523
524 asd_ha->hw_prof.ddb_ext = NULL;
525 if (max_devs <= asd_ha->hw_prof.max_ddbs || max_devs > 0xFFFF) {
526 max_devs = asd_ha->hw_prof.max_ddbs;
527 return 0;
528 }
529
530 size = (max_devs - asd_ha->hw_prof.max_ddbs + 1) * ASD_DDB_SIZE;
531
532 asd_ha->hw_prof.ddb_ext = asd_alloc_coherent(asd_ha, size, GFP_KERNEL);
533 if (!asd_ha->hw_prof.ddb_ext) {
534 asd_printk("couldn't allocate memory for %d devices\n",
535 max_devs);
536 max_devs = asd_ha->hw_prof.max_ddbs;
537 return -ENOMEM;
538 }
539 dma_handle = asd_ha->hw_prof.ddb_ext->dma_handle;
540 dma_addr = ALIGN((unsigned long) dma_handle, ASD_DDB_SIZE);
541 dma_addr -= asd_ha->hw_prof.max_ddbs * ASD_DDB_SIZE;
542 dma_handle = (dma_addr_t) dma_addr;
543 asd_write_reg_addr(asd_ha, DEVCTXBASE, dma_handle);
544 d = asd_read_reg_dword(asd_ha, CTXDOMAIN);
545 d &= ~4;
546 asd_write_reg_dword(asd_ha, CTXDOMAIN, d);
547
548 asd_ha->hw_prof.max_ddbs = max_devs;
549
550 return 0;
551}
552
553static int asd_extend_cmdctx(struct asd_ha_struct *asd_ha)
554{
555 dma_addr_t dma_handle;
556 unsigned long dma_addr;
557 u32 d;
558 int size;
559
560 asd_ha->hw_prof.scb_ext = NULL;
561 if (max_cmnds <= asd_ha->hw_prof.max_scbs || max_cmnds > 0xFFFF) {
562 max_cmnds = asd_ha->hw_prof.max_scbs;
563 return 0;
564 }
565
566 size = (max_cmnds - asd_ha->hw_prof.max_scbs + 1) * ASD_SCB_SIZE;
567
568 asd_ha->hw_prof.scb_ext = asd_alloc_coherent(asd_ha, size, GFP_KERNEL);
569 if (!asd_ha->hw_prof.scb_ext) {
570 asd_printk("couldn't allocate memory for %d commands\n",
571 max_cmnds);
572 max_cmnds = asd_ha->hw_prof.max_scbs;
573 return -ENOMEM;
574 }
575 dma_handle = asd_ha->hw_prof.scb_ext->dma_handle;
576 dma_addr = ALIGN((unsigned long) dma_handle, ASD_SCB_SIZE);
577 dma_addr -= asd_ha->hw_prof.max_scbs * ASD_SCB_SIZE;
578 dma_handle = (dma_addr_t) dma_addr;
579 asd_write_reg_addr(asd_ha, CMDCTXBASE, dma_handle);
580 d = asd_read_reg_dword(asd_ha, CTXDOMAIN);
581 d &= ~1;
582 asd_write_reg_dword(asd_ha, CTXDOMAIN, d);
583
584 asd_ha->hw_prof.max_scbs = max_cmnds;
585
586 return 0;
587}
588
589/**
590 * asd_init_ctxmem -- initialize context memory
591 * asd_ha: pointer to host adapter structure
592 *
593 * This function sets the maximum number of SCBs and
594 * DDBs which can be used by the sequencer. This is normally
595 * 512 and 128 respectively. If support for more SCBs or more DDBs
596 * is required then CMDCTXBASE, DEVCTXBASE and CTXDOMAIN are
597 * initialized here to extend context memory to point to host memory,
598 * thus allowing unlimited support for SCBs and DDBs -- only limited
599 * by host memory.
600 */
601static int asd_init_ctxmem(struct asd_ha_struct *asd_ha)
602{
603 int bitmap_bytes;
604
605 asd_get_max_scb_ddb(asd_ha);
606 asd_extend_devctx(asd_ha);
607 asd_extend_cmdctx(asd_ha);
608
609 /* The kernel wants bitmaps to be unsigned long sized. */
610 bitmap_bytes = (asd_ha->hw_prof.max_ddbs+7)/8;
611 bitmap_bytes = BITS_TO_LONGS(bitmap_bytes*8)*sizeof(unsigned long);
612 asd_ha->hw_prof.ddb_bitmap = kzalloc(bitmap_bytes, GFP_KERNEL);
613 if (!asd_ha->hw_prof.ddb_bitmap)
614 return -ENOMEM;
615 spin_lock_init(&asd_ha->hw_prof.ddb_lock);
616
617 return 0;
618}
619
620int asd_init_hw(struct asd_ha_struct *asd_ha)
621{
622 int err;
623 u32 v;
624
625 err = asd_init_sw(asd_ha);
626 if (err)
627 return err;
628
629 err = pci_read_config_dword(asd_ha->pcidev, PCIC_HSTPCIX_CNTRL, &v);
630 if (err) {
631 asd_printk("couldn't read PCIC_HSTPCIX_CNTRL of %s\n",
632 pci_name(asd_ha->pcidev));
633 return err;
634 }
635 pci_write_config_dword(asd_ha->pcidev, PCIC_HSTPCIX_CNTRL,
636 v | SC_TMR_DIS);
637 if (err) {
638 asd_printk("couldn't disable split completion timer of %s\n",
639 pci_name(asd_ha->pcidev));
640 return err;
641 }
642
643 err = asd_read_ocm(asd_ha);
644 if (err) {
645 asd_printk("couldn't read ocm(%d)\n", err);
646 /* While suspicios, it is not an error that we
647 * couldn't read the OCM. */
648 }
649
650 err = asd_read_flash(asd_ha);
651 if (err) {
652 asd_printk("couldn't read flash(%d)\n", err);
653 /* While suspicios, it is not an error that we
654 * couldn't read FLASH memory.
655 */
656 }
657
658 asd_init_ctxmem(asd_ha);
659
660 if (asd_get_user_sas_addr(asd_ha)) {
661 asd_printk("No SAS Address provided for %s\n",
662 pci_name(asd_ha->pcidev));
663 err = -ENODEV;
664 goto Out;
665 }
666
667 asd_propagate_sas_addr(asd_ha);
668
669 err = asd_init_phys(asd_ha);
670 if (err) {
671 asd_printk("couldn't initialize phys for %s\n",
672 pci_name(asd_ha->pcidev));
673 goto Out;
674 }
675
676 asd_init_ports(asd_ha);
677
678 err = asd_init_scbs(asd_ha);
679 if (err) {
680 asd_printk("couldn't initialize scbs for %s\n",
681 pci_name(asd_ha->pcidev));
682 goto Out;
683 }
684
685 err = asd_init_dl(asd_ha);
686 if (err) {
687 asd_printk("couldn't initialize the done list:%d\n",
688 err);
689 goto Out;
690 }
691
692 err = asd_init_escbs(asd_ha);
693 if (err) {
694 asd_printk("couldn't initialize escbs\n");
695 goto Out;
696 }
697
698 err = asd_init_chip(asd_ha);
699 if (err) {
700 asd_printk("couldn't init the chip\n");
701 goto Out;
702 }
703Out:
704 return err;
705}
706
707/* ---------- Chip reset ---------- */
708
709/**
710 * asd_chip_reset -- reset the host adapter, etc
711 * @asd_ha: pointer to host adapter structure of interest
712 *
713 * Called from the ISR. Hard reset the chip. Let everything
714 * timeout. This should be no different than hot-unplugging the
715 * host adapter. Once everything times out we'll init the chip with
716 * a call to asd_init_chip() and enable interrupts with asd_enable_ints().
717 * XXX finish.
718 */
719static void asd_chip_reset(struct asd_ha_struct *asd_ha)
720{
721 struct sas_ha_struct *sas_ha = &asd_ha->sas_ha;
722
723 ASD_DPRINTK("chip reset for %s\n", pci_name(asd_ha->pcidev));
724 asd_chip_hardrst(asd_ha);
725 sas_ha->notify_ha_event(sas_ha, HAE_RESET);
726}
727
728/* ---------- Done List Routines ---------- */
729
730static void asd_dl_tasklet_handler(unsigned long data)
731{
732 struct asd_ha_struct *asd_ha = (struct asd_ha_struct *) data;
733 struct asd_seq_data *seq = &asd_ha->seq;
734 unsigned long flags;
735
736 while (1) {
737 struct done_list_struct *dl = &seq->dl[seq->dl_next];
738 struct asd_ascb *ascb;
739
740 if ((dl->toggle & DL_TOGGLE_MASK) != seq->dl_toggle)
741 break;
742
743 /* find the aSCB */
744 spin_lock_irqsave(&seq->tc_index_lock, flags);
745 ascb = asd_tc_index_find(seq, (int)le16_to_cpu(dl->index));
746 spin_unlock_irqrestore(&seq->tc_index_lock, flags);
747 if (unlikely(!ascb)) {
748 ASD_DPRINTK("BUG:sequencer:dl:no ascb?!\n");
749 goto next_1;
750 } else if (ascb->scb->header.opcode == EMPTY_SCB) {
751 goto out;
752 } else if (!ascb->uldd_timer && !del_timer(&ascb->timer)) {
753 goto next_1;
754 }
755 spin_lock_irqsave(&seq->pend_q_lock, flags);
756 list_del_init(&ascb->list);
757 seq->pending--;
758 spin_unlock_irqrestore(&seq->pend_q_lock, flags);
759 out:
760 ascb->tasklet_complete(ascb, dl);
761
762 next_1:
763 seq->dl_next = (seq->dl_next + 1) & (ASD_DL_SIZE-1);
764 if (!seq->dl_next)
765 seq->dl_toggle ^= DL_TOGGLE_MASK;
766 }
767}
768
769/* ---------- Interrupt Service Routines ---------- */
770
771/**
772 * asd_process_donelist_isr -- schedule processing of done list entries
773 * @asd_ha: pointer to host adapter structure
774 */
775static void asd_process_donelist_isr(struct asd_ha_struct *asd_ha)
776{
777 tasklet_schedule(&asd_ha->seq.dl_tasklet);
778}
779
780/**
781 * asd_com_sas_isr -- process device communication interrupt (COMINT)
782 * @asd_ha: pointer to host adapter structure
783 */
784static void asd_com_sas_isr(struct asd_ha_struct *asd_ha)
785{
786 u32 comstat = asd_read_reg_dword(asd_ha, COMSTAT);
787
788 /* clear COMSTAT int */
789 asd_write_reg_dword(asd_ha, COMSTAT, 0xFFFFFFFF);
790
791 if (comstat & CSBUFPERR) {
792 asd_printk("%s: command/status buffer dma parity error\n",
793 pci_name(asd_ha->pcidev));
794 } else if (comstat & CSERR) {
795 int i;
796 u32 dmaerr = asd_read_reg_dword(asd_ha, DMAERR);
797 dmaerr &= 0xFF;
798 asd_printk("%s: command/status dma error, DMAERR: 0x%02x, "
799 "CSDMAADR: 0x%04x, CSDMAADR+4: 0x%04x\n",
800 pci_name(asd_ha->pcidev),
801 dmaerr,
802 asd_read_reg_dword(asd_ha, CSDMAADR),
803 asd_read_reg_dword(asd_ha, CSDMAADR+4));
804 asd_printk("CSBUFFER:\n");
805 for (i = 0; i < 8; i++) {
806 asd_printk("%08x %08x %08x %08x\n",
807 asd_read_reg_dword(asd_ha, CSBUFFER),
808 asd_read_reg_dword(asd_ha, CSBUFFER+4),
809 asd_read_reg_dword(asd_ha, CSBUFFER+8),
810 asd_read_reg_dword(asd_ha, CSBUFFER+12));
811 }
812 asd_dump_seq_state(asd_ha, 0);
813 } else if (comstat & OVLYERR) {
814 u32 dmaerr = asd_read_reg_dword(asd_ha, DMAERR);
815 dmaerr = (dmaerr >> 8) & 0xFF;
816 asd_printk("%s: overlay dma error:0x%x\n",
817 pci_name(asd_ha->pcidev),
818 dmaerr);
819 }
820 asd_chip_reset(asd_ha);
821}
822
823static void asd_arp2_err(struct asd_ha_struct *asd_ha, u32 dchstatus)
824{
825 static const char *halt_code[256] = {
826 "UNEXPECTED_INTERRUPT0",
827 "UNEXPECTED_INTERRUPT1",
828 "UNEXPECTED_INTERRUPT2",
829 "UNEXPECTED_INTERRUPT3",
830 "UNEXPECTED_INTERRUPT4",
831 "UNEXPECTED_INTERRUPT5",
832 "UNEXPECTED_INTERRUPT6",
833 "UNEXPECTED_INTERRUPT7",
834 "UNEXPECTED_INTERRUPT8",
835 "UNEXPECTED_INTERRUPT9",
836 "UNEXPECTED_INTERRUPT10",
837 [11 ... 19] = "unknown[11,19]",
838 "NO_FREE_SCB_AVAILABLE",
839 "INVALID_SCB_OPCODE",
840 "INVALID_MBX_OPCODE",
841 "INVALID_ATA_STATE",
842 "ATA_QUEUE_FULL",
843 "ATA_TAG_TABLE_FAULT",
844 "ATA_TAG_MASK_FAULT",
845 "BAD_LINK_QUEUE_STATE",
846 "DMA2CHIM_QUEUE_ERROR",
847 "EMPTY_SCB_LIST_FULL",
848 "unknown[30]",
849 "IN_USE_SCB_ON_FREE_LIST",
850 "BAD_OPEN_WAIT_STATE",
851 "INVALID_STP_AFFILIATION",
852 "unknown[34]",
853 "EXEC_QUEUE_ERROR",
854 "TOO_MANY_EMPTIES_NEEDED",
855 "EMPTY_REQ_QUEUE_ERROR",
856 "Q_MONIRTT_MGMT_ERROR",
857 "TARGET_MODE_FLOW_ERROR",
858 "DEVICE_QUEUE_NOT_FOUND",
859 "START_IRTT_TIMER_ERROR",
860 "ABORT_TASK_ILLEGAL_REQ",
861 [43 ... 255] = "unknown[43,255]"
862 };
863
864 if (dchstatus & CSEQINT) {
865 u32 arp2int = asd_read_reg_dword(asd_ha, CARP2INT);
866
867 if (arp2int & (ARP2WAITTO|ARP2ILLOPC|ARP2PERR|ARP2CIOPERR)) {
868 asd_printk("%s: CSEQ arp2int:0x%x\n",
869 pci_name(asd_ha->pcidev),
870 arp2int);
871 } else if (arp2int & ARP2HALTC)
872 asd_printk("%s: CSEQ halted: %s\n",
873 pci_name(asd_ha->pcidev),
874 halt_code[(arp2int>>16)&0xFF]);
875 else
876 asd_printk("%s: CARP2INT:0x%x\n",
877 pci_name(asd_ha->pcidev),
878 arp2int);
879 }
880 if (dchstatus & LSEQINT_MASK) {
881 int lseq;
882 u8 lseq_mask = dchstatus & LSEQINT_MASK;
883
884 for_each_sequencer(lseq_mask, lseq_mask, lseq) {
885 u32 arp2int = asd_read_reg_dword(asd_ha,
886 LmARP2INT(lseq));
887 if (arp2int & (ARP2WAITTO | ARP2ILLOPC | ARP2PERR
888 | ARP2CIOPERR)) {
889 asd_printk("%s: LSEQ%d arp2int:0x%x\n",
890 pci_name(asd_ha->pcidev),
891 lseq, arp2int);
892 /* XXX we should only do lseq reset */
893 } else if (arp2int & ARP2HALTC)
894 asd_printk("%s: LSEQ%d halted: %s\n",
895 pci_name(asd_ha->pcidev),
896 lseq,halt_code[(arp2int>>16)&0xFF]);
897 else
898 asd_printk("%s: LSEQ%d ARP2INT:0x%x\n",
899 pci_name(asd_ha->pcidev), lseq,
900 arp2int);
901 }
902 }
903 asd_chip_reset(asd_ha);
904}
905
906/**
907 * asd_dch_sas_isr -- process device channel interrupt (DEVINT)
908 * @asd_ha: pointer to host adapter structure
909 */
910static void asd_dch_sas_isr(struct asd_ha_struct *asd_ha)
911{
912 u32 dchstatus = asd_read_reg_dword(asd_ha, DCHSTATUS);
913
914 if (dchstatus & CFIFTOERR) {
915 asd_printk("%s: CFIFTOERR\n", pci_name(asd_ha->pcidev));
916 asd_chip_reset(asd_ha);
917 } else
918 asd_arp2_err(asd_ha, dchstatus);
919}
920
921/**
922 * ads_rbi_exsi_isr -- process external system interface interrupt (INITERR)
923 * @asd_ha: pointer to host adapter structure
924 */
925static void asd_rbi_exsi_isr(struct asd_ha_struct *asd_ha)
926{
927 u32 stat0r = asd_read_reg_dword(asd_ha, ASISTAT0R);
928
929 if (!(stat0r & ASIERR)) {
930 asd_printk("hmm, EXSI interrupted but no error?\n");
931 return;
932 }
933
934 if (stat0r & ASIFMTERR) {
935 asd_printk("ASI SEEPROM format error for %s\n",
936 pci_name(asd_ha->pcidev));
937 } else if (stat0r & ASISEECHKERR) {
938 u32 stat1r = asd_read_reg_dword(asd_ha, ASISTAT1R);
939 asd_printk("ASI SEEPROM checksum 0x%x error for %s\n",
940 stat1r & CHECKSUM_MASK,
941 pci_name(asd_ha->pcidev));
942 } else {
943 u32 statr = asd_read_reg_dword(asd_ha, ASIERRSTATR);
944
945 if (!(statr & CPI2ASIMSTERR_MASK)) {
946 ASD_DPRINTK("hmm, ASIERR?\n");
947 return;
948 } else {
949 u32 addr = asd_read_reg_dword(asd_ha, ASIERRADDR);
950 u32 data = asd_read_reg_dword(asd_ha, ASIERRDATAR);
951
952 asd_printk("%s: CPI2 xfer err: addr: 0x%x, wdata: 0x%x, "
953 "count: 0x%x, byteen: 0x%x, targerr: 0x%x "
954 "master id: 0x%x, master err: 0x%x\n",
955 pci_name(asd_ha->pcidev),
956 addr, data,
957 (statr & CPI2ASIBYTECNT_MASK) >> 16,
958 (statr & CPI2ASIBYTEEN_MASK) >> 12,
959 (statr & CPI2ASITARGERR_MASK) >> 8,
960 (statr & CPI2ASITARGMID_MASK) >> 4,
961 (statr & CPI2ASIMSTERR_MASK));
962 }
963 }
964 asd_chip_reset(asd_ha);
965}
966
967/**
968 * asd_hst_pcix_isr -- process host interface interrupts
969 * @asd_ha: pointer to host adapter structure
970 *
971 * Asserted on PCIX errors: target abort, etc.
972 */
973static void asd_hst_pcix_isr(struct asd_ha_struct *asd_ha)
974{
975 u16 status;
976 u32 pcix_status;
977 u32 ecc_status;
978
979 pci_read_config_word(asd_ha->pcidev, PCI_STATUS, &status);
980 pci_read_config_dword(asd_ha->pcidev, PCIX_STATUS, &pcix_status);
981 pci_read_config_dword(asd_ha->pcidev, ECC_CTRL_STAT, &ecc_status);
982
983 if (status & PCI_STATUS_DETECTED_PARITY)
984 asd_printk("parity error for %s\n", pci_name(asd_ha->pcidev));
985 else if (status & PCI_STATUS_REC_MASTER_ABORT)
986 asd_printk("master abort for %s\n", pci_name(asd_ha->pcidev));
987 else if (status & PCI_STATUS_REC_TARGET_ABORT)
988 asd_printk("target abort for %s\n", pci_name(asd_ha->pcidev));
989 else if (status & PCI_STATUS_PARITY)
990 asd_printk("data parity for %s\n", pci_name(asd_ha->pcidev));
991 else if (pcix_status & RCV_SCE) {
992 asd_printk("received split completion error for %s\n",
993 pci_name(asd_ha->pcidev));
994 pci_write_config_dword(asd_ha->pcidev,PCIX_STATUS,pcix_status);
995 /* XXX: Abort task? */
996 return;
997 } else if (pcix_status & UNEXP_SC) {
998 asd_printk("unexpected split completion for %s\n",
999 pci_name(asd_ha->pcidev));
1000 pci_write_config_dword(asd_ha->pcidev,PCIX_STATUS,pcix_status);
1001 /* ignore */
1002 return;
1003 } else if (pcix_status & SC_DISCARD)
1004 asd_printk("split completion discarded for %s\n",
1005 pci_name(asd_ha->pcidev));
1006 else if (ecc_status & UNCOR_ECCERR)
1007 asd_printk("uncorrectable ECC error for %s\n",
1008 pci_name(asd_ha->pcidev));
1009 asd_chip_reset(asd_ha);
1010}
1011
1012/**
1013 * asd_hw_isr -- host adapter interrupt service routine
1014 * @irq: ignored
1015 * @dev_id: pointer to host adapter structure
1016 *
1017 * The ISR processes done list entries and level 3 error handling.
1018 */
1019irqreturn_t asd_hw_isr(int irq, void *dev_id)
1020{
1021 struct asd_ha_struct *asd_ha = dev_id;
1022 u32 chimint = asd_read_reg_dword(asd_ha, CHIMINT);
1023
1024 if (!chimint)
1025 return IRQ_NONE;
1026
1027 asd_write_reg_dword(asd_ha, CHIMINT, chimint);
1028 (void) asd_read_reg_dword(asd_ha, CHIMINT);
1029
1030 if (chimint & DLAVAIL)
1031 asd_process_donelist_isr(asd_ha);
1032 if (chimint & COMINT)
1033 asd_com_sas_isr(asd_ha);
1034 if (chimint & DEVINT)
1035 asd_dch_sas_isr(asd_ha);
1036 if (chimint & INITERR)
1037 asd_rbi_exsi_isr(asd_ha);
1038 if (chimint & HOSTERR)
1039 asd_hst_pcix_isr(asd_ha);
1040
1041 return IRQ_HANDLED;
1042}
1043
1044/* ---------- SCB handling ---------- */
1045
1046static struct asd_ascb *asd_ascb_alloc(struct asd_ha_struct *asd_ha,
1047 gfp_t gfp_flags)
1048{
1049 extern struct kmem_cache *asd_ascb_cache;
1050 struct asd_seq_data *seq = &asd_ha->seq;
1051 struct asd_ascb *ascb;
1052 unsigned long flags;
1053
1054 ascb = kmem_cache_zalloc(asd_ascb_cache, gfp_flags);
1055
1056 if (ascb) {
1057 ascb->dma_scb.size = sizeof(struct scb);
1058 ascb->dma_scb.vaddr = dma_pool_alloc(asd_ha->scb_pool,
1059 gfp_flags,
1060 &ascb->dma_scb.dma_handle);
1061 if (!ascb->dma_scb.vaddr) {
1062 kmem_cache_free(asd_ascb_cache, ascb);
1063 return NULL;
1064 }
1065 memset(ascb->dma_scb.vaddr, 0, sizeof(struct scb));
1066 asd_init_ascb(asd_ha, ascb);
1067
1068 spin_lock_irqsave(&seq->tc_index_lock, flags);
1069 ascb->tc_index = asd_tc_index_get(seq, ascb);
1070 spin_unlock_irqrestore(&seq->tc_index_lock, flags);
1071 if (ascb->tc_index == -1)
1072 goto undo;
1073
1074 ascb->scb->header.index = cpu_to_le16((u16)ascb->tc_index);
1075 }
1076
1077 return ascb;
1078undo:
1079 dma_pool_free(asd_ha->scb_pool, ascb->dma_scb.vaddr,
1080 ascb->dma_scb.dma_handle);
1081 kmem_cache_free(asd_ascb_cache, ascb);
1082 ASD_DPRINTK("no index for ascb\n");
1083 return NULL;
1084}
1085
1086/**
1087 * asd_ascb_alloc_list -- allocate a list of aSCBs
1088 * @asd_ha: pointer to host adapter structure
1089 * @num: pointer to integer number of aSCBs
1090 * @gfp_flags: GFP_ flags.
1091 *
1092 * This is the only function which is used to allocate aSCBs.
1093 * It can allocate one or many. If more than one, then they form
1094 * a linked list in two ways: by their list field of the ascb struct
1095 * and by the next_scb field of the scb_header.
1096 *
1097 * Returns NULL if no memory was available, else pointer to a list
1098 * of ascbs. When this function returns, @num would be the number
1099 * of SCBs which were not able to be allocated, 0 if all requested
1100 * were able to be allocated.
1101 */
1102struct asd_ascb *asd_ascb_alloc_list(struct asd_ha_struct
1103 *asd_ha, int *num,
1104 gfp_t gfp_flags)
1105{
1106 struct asd_ascb *first = NULL;
1107
1108 for ( ; *num > 0; --*num) {
1109 struct asd_ascb *ascb = asd_ascb_alloc(asd_ha, gfp_flags);
1110
1111 if (!ascb)
1112 break;
1113 else if (!first)
1114 first = ascb;
1115 else {
1116 struct asd_ascb *last = list_entry(first->list.prev,
1117 struct asd_ascb,
1118 list);
1119 list_add_tail(&ascb->list, &first->list);
1120 last->scb->header.next_scb =
1121 cpu_to_le64(((u64)ascb->dma_scb.dma_handle));
1122 }
1123 }
1124
1125 return first;
1126}
1127
1128/**
1129 * asd_swap_head_scb -- swap the head scb
1130 * @asd_ha: pointer to host adapter structure
1131 * @ascb: pointer to the head of an ascb list
1132 *
1133 * The sequencer knows the DMA address of the next SCB to be DMAed to
1134 * the host adapter, from initialization or from the last list DMAed.
1135 * seq->next_scb keeps the address of this SCB. The sequencer will
1136 * DMA to the host adapter this list of SCBs. But the head (first
1137 * element) of this list is not known to the sequencer. Here we swap
1138 * the head of the list with the known SCB (memcpy()).
1139 * Only one memcpy() is required per list so it is in our interest
1140 * to keep the list of SCB as long as possible so that the ratio
1141 * of number of memcpy calls to the number of SCB DMA-ed is as small
1142 * as possible.
1143 *
1144 * LOCKING: called with the pending list lock held.
1145 */
1146static void asd_swap_head_scb(struct asd_ha_struct *asd_ha,
1147 struct asd_ascb *ascb)
1148{
1149 struct asd_seq_data *seq = &asd_ha->seq;
1150 struct asd_ascb *last = list_entry(ascb->list.prev,
1151 struct asd_ascb,
1152 list);
1153 struct asd_dma_tok t = ascb->dma_scb;
1154
1155 memcpy(seq->next_scb.vaddr, ascb->scb, sizeof(*ascb->scb));
1156 ascb->dma_scb = seq->next_scb;
1157 ascb->scb = ascb->dma_scb.vaddr;
1158 seq->next_scb = t;
1159 last->scb->header.next_scb =
1160 cpu_to_le64(((u64)seq->next_scb.dma_handle));
1161}
1162
1163/**
1164 * asd_start_timers -- (add and) start timers of SCBs
1165 * @list: pointer to struct list_head of the scbs
1166 * @to: timeout in jiffies
1167 *
1168 * If an SCB in the @list has no timer function, assign the default
1169 * one, then start the timer of the SCB. This function is
1170 * intended to be called from asd_post_ascb_list(), just prior to
1171 * posting the SCBs to the sequencer.
1172 */
1173static void asd_start_scb_timers(struct list_head *list)
1174{
1175 struct asd_ascb *ascb;
1176 list_for_each_entry(ascb, list, list) {
1177 if (!ascb->uldd_timer) {
1178 ascb->timer.data = (unsigned long) ascb;
1179 ascb->timer.function = asd_ascb_timedout;
1180 ascb->timer.expires = jiffies + AIC94XX_SCB_TIMEOUT;
1181 add_timer(&ascb->timer);
1182 }
1183 }
1184}
1185
1186/**
1187 * asd_post_ascb_list -- post a list of 1 or more aSCBs to the host adapter
1188 * @asd_ha: pointer to a host adapter structure
1189 * @ascb: pointer to the first aSCB in the list
1190 * @num: number of aSCBs in the list (to be posted)
1191 *
1192 * See queueing comment in asd_post_escb_list().
1193 *
1194 * Additional note on queuing: In order to minimize the ratio of memcpy()
1195 * to the number of ascbs sent, we try to batch-send as many ascbs as possible
1196 * in one go.
1197 * Two cases are possible:
1198 * A) can_queue >= num,
1199 * B) can_queue < num.
1200 * Case A: we can send the whole batch at once. Increment "pending"
1201 * in the beginning of this function, when it is checked, in order to
1202 * eliminate races when this function is called by multiple processes.
1203 * Case B: should never happen if the managing layer considers
1204 * lldd_queue_size.
1205 */
1206int asd_post_ascb_list(struct asd_ha_struct *asd_ha, struct asd_ascb *ascb,
1207 int num)
1208{
1209 unsigned long flags;
1210 LIST_HEAD(list);
1211 int can_queue;
1212
1213 spin_lock_irqsave(&asd_ha->seq.pend_q_lock, flags);
1214 can_queue = asd_ha->hw_prof.max_scbs - asd_ha->seq.pending;
1215 if (can_queue >= num)
1216 asd_ha->seq.pending += num;
1217 else
1218 can_queue = 0;
1219
1220 if (!can_queue) {
1221 spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags);
1222 asd_printk("%s: scb queue full\n", pci_name(asd_ha->pcidev));
1223 return -SAS_QUEUE_FULL;
1224 }
1225
1226 asd_swap_head_scb(asd_ha, ascb);
1227
1228 __list_add(&list, ascb->list.prev, &ascb->list);
1229
1230 asd_start_scb_timers(&list);
1231
1232 asd_ha->seq.scbpro += num;
1233 list_splice_init(&list, asd_ha->seq.pend_q.prev);
1234 asd_write_reg_dword(asd_ha, SCBPRO, (u32)asd_ha->seq.scbpro);
1235 spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags);
1236
1237 return 0;
1238}
1239
1240/**
1241 * asd_post_escb_list -- post a list of 1 or more empty scb
1242 * @asd_ha: pointer to a host adapter structure
1243 * @ascb: pointer to the first empty SCB in the list
1244 * @num: number of aSCBs in the list (to be posted)
1245 *
1246 * This is essentially the same as asd_post_ascb_list, but we do not
1247 * increment pending, add those to the pending list or get indexes.
1248 * See asd_init_escbs() and asd_init_post_escbs().
1249 *
1250 * Since sending a list of ascbs is a superset of sending a single
1251 * ascb, this function exists to generalize this. More specifically,
1252 * when sending a list of those, we want to do only a _single_
1253 * memcpy() at swap head, as opposed to for each ascb sent (in the
1254 * case of sending them one by one). That is, we want to minimize the
1255 * ratio of memcpy() operations to the number of ascbs sent. The same
1256 * logic applies to asd_post_ascb_list().
1257 */
1258int asd_post_escb_list(struct asd_ha_struct *asd_ha, struct asd_ascb *ascb,
1259 int num)
1260{
1261 unsigned long flags;
1262
1263 spin_lock_irqsave(&asd_ha->seq.pend_q_lock, flags);
1264 asd_swap_head_scb(asd_ha, ascb);
1265 asd_ha->seq.scbpro += num;
1266 asd_write_reg_dword(asd_ha, SCBPRO, (u32)asd_ha->seq.scbpro);
1267 spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags);
1268
1269 return 0;
1270}
1271
1272/* ---------- LED ---------- */
1273
1274/**
1275 * asd_turn_led -- turn on/off an LED
1276 * @asd_ha: pointer to host adapter structure
1277 * @phy_id: the PHY id whose LED we want to manupulate
1278 * @op: 1 to turn on, 0 to turn off
1279 */
1280void asd_turn_led(struct asd_ha_struct *asd_ha, int phy_id, int op)
1281{
1282 if (phy_id < ASD_MAX_PHYS) {
1283 u32 v = asd_read_reg_dword(asd_ha, LmCONTROL(phy_id));
1284 if (op)
1285 v |= LEDPOL;
1286 else
1287 v &= ~LEDPOL;
1288 asd_write_reg_dword(asd_ha, LmCONTROL(phy_id), v);
1289 }
1290}
1291
1292/**
1293 * asd_control_led -- enable/disable an LED on the board
1294 * @asd_ha: pointer to host adapter structure
1295 * @phy_id: integer, the phy id
1296 * @op: integer, 1 to enable, 0 to disable the LED
1297 *
1298 * First we output enable the LED, then we set the source
1299 * to be an external module.
1300 */
1301void asd_control_led(struct asd_ha_struct *asd_ha, int phy_id, int op)
1302{
1303 if (phy_id < ASD_MAX_PHYS) {
1304 u32 v;
1305
1306 v = asd_read_reg_dword(asd_ha, GPIOOER);
1307 if (op)
1308 v |= (1 << phy_id);
1309 else
1310 v &= ~(1 << phy_id);
1311 asd_write_reg_dword(asd_ha, GPIOOER, v);
1312
1313 v = asd_read_reg_dword(asd_ha, GPIOCNFGR);
1314 if (op)
1315 v |= (1 << phy_id);
1316 else
1317 v &= ~(1 << phy_id);
1318 asd_write_reg_dword(asd_ha, GPIOCNFGR, v);
1319 }
1320}
1321
1322/* ---------- PHY enable ---------- */
1323
1324static int asd_enable_phy(struct asd_ha_struct *asd_ha, int phy_id)
1325{
1326 struct asd_phy *phy = &asd_ha->phys[phy_id];
1327
1328 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, INT_ENABLE_2), 0);
1329 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, HOT_PLUG_DELAY),
1330 HOTPLUG_DELAY_TIMEOUT);
1331
1332 /* Get defaults from manuf. sector */
1333 /* XXX we need defaults for those in case MS is broken. */
1334 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, PHY_CONTROL_0),
1335 phy->phy_desc->phy_control_0);
1336 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, PHY_CONTROL_1),
1337 phy->phy_desc->phy_control_1);
1338 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, PHY_CONTROL_2),
1339 phy->phy_desc->phy_control_2);
1340 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, PHY_CONTROL_3),
1341 phy->phy_desc->phy_control_3);
1342
1343 asd_write_reg_dword(asd_ha, LmSEQ_TEN_MS_COMINIT_TIMEOUT(phy_id),
1344 ASD_COMINIT_TIMEOUT);
1345
1346 asd_write_reg_addr(asd_ha, LmSEQ_TX_ID_ADDR_FRAME(phy_id),
1347 phy->id_frm_tok->dma_handle);
1348
1349 asd_control_led(asd_ha, phy_id, 1);
1350
1351 return 0;
1352}
1353
1354int asd_enable_phys(struct asd_ha_struct *asd_ha, const u8 phy_mask)
1355{
1356 u8 phy_m;
1357 u8 i;
1358 int num = 0, k;
1359 struct asd_ascb *ascb;
1360 struct asd_ascb *ascb_list;
1361
1362 if (!phy_mask) {
1363 asd_printk("%s called with phy_mask of 0!?\n", __func__);
1364 return 0;
1365 }
1366
1367 for_each_phy(phy_mask, phy_m, i) {
1368 num++;
1369 asd_enable_phy(asd_ha, i);
1370 }
1371
1372 k = num;
1373 ascb_list = asd_ascb_alloc_list(asd_ha, &k, GFP_KERNEL);
1374 if (!ascb_list) {
1375 asd_printk("no memory for control phy ascb list\n");
1376 return -ENOMEM;
1377 }
1378 num -= k;
1379
1380 ascb = ascb_list;
1381 for_each_phy(phy_mask, phy_m, i) {
1382 asd_build_control_phy(ascb, i, ENABLE_PHY);
1383 ascb = list_entry(ascb->list.next, struct asd_ascb, list);
1384 }
1385 ASD_DPRINTK("posting %d control phy scbs\n", num);
1386 k = asd_post_ascb_list(asd_ha, ascb_list, num);
1387 if (k)
1388 asd_ascb_free_list(ascb_list);
1389
1390 return k;
1391}
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Aic94xx SAS/SATA driver hardware interface.
4 *
5 * Copyright (C) 2005 Adaptec, Inc. All rights reserved.
6 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
7 */
8
9#include <linux/pci.h>
10#include <linux/slab.h>
11#include <linux/delay.h>
12#include <linux/module.h>
13#include <linux/firmware.h>
14
15#include "aic94xx.h"
16#include "aic94xx_reg.h"
17#include "aic94xx_hwi.h"
18#include "aic94xx_seq.h"
19#include "aic94xx_dump.h"
20
21u32 MBAR0_SWB_SIZE;
22
23/* ---------- Initialization ---------- */
24
25static int asd_get_user_sas_addr(struct asd_ha_struct *asd_ha)
26{
27 /* adapter came with a sas address */
28 if (asd_ha->hw_prof.sas_addr[0])
29 return 0;
30
31 return sas_request_addr(asd_ha->sas_ha.core.shost,
32 asd_ha->hw_prof.sas_addr);
33}
34
35static void asd_propagate_sas_addr(struct asd_ha_struct *asd_ha)
36{
37 int i;
38
39 for (i = 0; i < ASD_MAX_PHYS; i++) {
40 if (asd_ha->hw_prof.phy_desc[i].sas_addr[0] == 0)
41 continue;
42 /* Set a phy's address only if it has none.
43 */
44 ASD_DPRINTK("setting phy%d addr to %llx\n", i,
45 SAS_ADDR(asd_ha->hw_prof.sas_addr));
46 memcpy(asd_ha->hw_prof.phy_desc[i].sas_addr,
47 asd_ha->hw_prof.sas_addr, SAS_ADDR_SIZE);
48 }
49}
50
51/* ---------- PHY initialization ---------- */
52
53static void asd_init_phy_identify(struct asd_phy *phy)
54{
55 phy->identify_frame = phy->id_frm_tok->vaddr;
56
57 memset(phy->identify_frame, 0, sizeof(*phy->identify_frame));
58
59 phy->identify_frame->dev_type = SAS_END_DEVICE;
60 if (phy->sas_phy.role & PHY_ROLE_INITIATOR)
61 phy->identify_frame->initiator_bits = phy->sas_phy.iproto;
62 if (phy->sas_phy.role & PHY_ROLE_TARGET)
63 phy->identify_frame->target_bits = phy->sas_phy.tproto;
64 memcpy(phy->identify_frame->sas_addr, phy->phy_desc->sas_addr,
65 SAS_ADDR_SIZE);
66 phy->identify_frame->phy_id = phy->sas_phy.id;
67}
68
69static int asd_init_phy(struct asd_phy *phy)
70{
71 struct asd_ha_struct *asd_ha = phy->sas_phy.ha->lldd_ha;
72 struct asd_sas_phy *sas_phy = &phy->sas_phy;
73
74 sas_phy->enabled = 1;
75 sas_phy->class = SAS;
76 sas_phy->iproto = SAS_PROTOCOL_ALL;
77 sas_phy->tproto = 0;
78 sas_phy->type = PHY_TYPE_PHYSICAL;
79 sas_phy->role = PHY_ROLE_INITIATOR;
80 sas_phy->oob_mode = OOB_NOT_CONNECTED;
81 sas_phy->linkrate = SAS_LINK_RATE_UNKNOWN;
82
83 phy->id_frm_tok = asd_alloc_coherent(asd_ha,
84 sizeof(*phy->identify_frame),
85 GFP_KERNEL);
86 if (!phy->id_frm_tok) {
87 asd_printk("no mem for IDENTIFY for phy%d\n", sas_phy->id);
88 return -ENOMEM;
89 } else
90 asd_init_phy_identify(phy);
91
92 memset(phy->frame_rcvd, 0, sizeof(phy->frame_rcvd));
93
94 return 0;
95}
96
97static void asd_init_ports(struct asd_ha_struct *asd_ha)
98{
99 int i;
100
101 spin_lock_init(&asd_ha->asd_ports_lock);
102 for (i = 0; i < ASD_MAX_PHYS; i++) {
103 struct asd_port *asd_port = &asd_ha->asd_ports[i];
104
105 memset(asd_port->sas_addr, 0, SAS_ADDR_SIZE);
106 memset(asd_port->attached_sas_addr, 0, SAS_ADDR_SIZE);
107 asd_port->phy_mask = 0;
108 asd_port->num_phys = 0;
109 }
110}
111
112static int asd_init_phys(struct asd_ha_struct *asd_ha)
113{
114 u8 i;
115 u8 phy_mask = asd_ha->hw_prof.enabled_phys;
116
117 for (i = 0; i < ASD_MAX_PHYS; i++) {
118 struct asd_phy *phy = &asd_ha->phys[i];
119
120 phy->phy_desc = &asd_ha->hw_prof.phy_desc[i];
121 phy->asd_port = NULL;
122
123 phy->sas_phy.enabled = 0;
124 phy->sas_phy.id = i;
125 phy->sas_phy.sas_addr = &phy->phy_desc->sas_addr[0];
126 phy->sas_phy.frame_rcvd = &phy->frame_rcvd[0];
127 phy->sas_phy.ha = &asd_ha->sas_ha;
128 phy->sas_phy.lldd_phy = phy;
129 }
130
131 /* Now enable and initialize only the enabled phys. */
132 for_each_phy(phy_mask, phy_mask, i) {
133 int err = asd_init_phy(&asd_ha->phys[i]);
134 if (err)
135 return err;
136 }
137
138 return 0;
139}
140
141/* ---------- Sliding windows ---------- */
142
143static int asd_init_sw(struct asd_ha_struct *asd_ha)
144{
145 struct pci_dev *pcidev = asd_ha->pcidev;
146 int err;
147 u32 v;
148
149 /* Unlock MBARs */
150 err = pci_read_config_dword(pcidev, PCI_CONF_MBAR_KEY, &v);
151 if (err) {
152 asd_printk("couldn't access conf. space of %s\n",
153 pci_name(pcidev));
154 goto Err;
155 }
156 if (v)
157 err = pci_write_config_dword(pcidev, PCI_CONF_MBAR_KEY, v);
158 if (err) {
159 asd_printk("couldn't write to MBAR_KEY of %s\n",
160 pci_name(pcidev));
161 goto Err;
162 }
163
164 /* Set sliding windows A, B and C to point to proper internal
165 * memory regions.
166 */
167 pci_write_config_dword(pcidev, PCI_CONF_MBAR0_SWA, REG_BASE_ADDR);
168 pci_write_config_dword(pcidev, PCI_CONF_MBAR0_SWB,
169 REG_BASE_ADDR_CSEQCIO);
170 pci_write_config_dword(pcidev, PCI_CONF_MBAR0_SWC, REG_BASE_ADDR_EXSI);
171 asd_ha->io_handle[0].swa_base = REG_BASE_ADDR;
172 asd_ha->io_handle[0].swb_base = REG_BASE_ADDR_CSEQCIO;
173 asd_ha->io_handle[0].swc_base = REG_BASE_ADDR_EXSI;
174 MBAR0_SWB_SIZE = asd_ha->io_handle[0].len - 0x80;
175 if (!asd_ha->iospace) {
176 /* MBAR1 will point to OCM (On Chip Memory) */
177 pci_write_config_dword(pcidev, PCI_CONF_MBAR1, OCM_BASE_ADDR);
178 asd_ha->io_handle[1].swa_base = OCM_BASE_ADDR;
179 }
180 spin_lock_init(&asd_ha->iolock);
181Err:
182 return err;
183}
184
185/* ---------- SCB initialization ---------- */
186
187/**
188 * asd_init_scbs - manually allocate the first SCB.
189 * @asd_ha: pointer to host adapter structure
190 *
191 * This allocates the very first SCB which would be sent to the
192 * sequencer for execution. Its bus address is written to
193 * CSEQ_Q_NEW_POINTER, mode page 2, mode 8. Since the bus address of
194 * the _next_ scb to be DMA-ed to the host adapter is read from the last
195 * SCB DMA-ed to the host adapter, we have to always stay one step
196 * ahead of the sequencer and keep one SCB already allocated.
197 */
198static int asd_init_scbs(struct asd_ha_struct *asd_ha)
199{
200 struct asd_seq_data *seq = &asd_ha->seq;
201 int bitmap_bytes;
202
203 /* allocate the index array and bitmap */
204 asd_ha->seq.tc_index_bitmap_bits = asd_ha->hw_prof.max_scbs;
205 asd_ha->seq.tc_index_array = kcalloc(asd_ha->seq.tc_index_bitmap_bits,
206 sizeof(void *),
207 GFP_KERNEL);
208 if (!asd_ha->seq.tc_index_array)
209 return -ENOMEM;
210
211 bitmap_bytes = (asd_ha->seq.tc_index_bitmap_bits+7)/8;
212 bitmap_bytes = BITS_TO_LONGS(bitmap_bytes*8)*sizeof(unsigned long);
213 asd_ha->seq.tc_index_bitmap = kzalloc(bitmap_bytes, GFP_KERNEL);
214 if (!asd_ha->seq.tc_index_bitmap) {
215 kfree(asd_ha->seq.tc_index_array);
216 asd_ha->seq.tc_index_array = NULL;
217 return -ENOMEM;
218 }
219
220 spin_lock_init(&seq->tc_index_lock);
221
222 seq->next_scb.size = sizeof(struct scb);
223 seq->next_scb.vaddr = dma_pool_alloc(asd_ha->scb_pool, GFP_KERNEL,
224 &seq->next_scb.dma_handle);
225 if (!seq->next_scb.vaddr) {
226 kfree(asd_ha->seq.tc_index_bitmap);
227 kfree(asd_ha->seq.tc_index_array);
228 asd_ha->seq.tc_index_bitmap = NULL;
229 asd_ha->seq.tc_index_array = NULL;
230 return -ENOMEM;
231 }
232
233 seq->pending = 0;
234 spin_lock_init(&seq->pend_q_lock);
235 INIT_LIST_HEAD(&seq->pend_q);
236
237 return 0;
238}
239
240static void asd_get_max_scb_ddb(struct asd_ha_struct *asd_ha)
241{
242 asd_ha->hw_prof.max_scbs = asd_get_cmdctx_size(asd_ha)/ASD_SCB_SIZE;
243 asd_ha->hw_prof.max_ddbs = asd_get_devctx_size(asd_ha)/ASD_DDB_SIZE;
244 ASD_DPRINTK("max_scbs:%d, max_ddbs:%d\n",
245 asd_ha->hw_prof.max_scbs,
246 asd_ha->hw_prof.max_ddbs);
247}
248
249/* ---------- Done List initialization ---------- */
250
251static void asd_dl_tasklet_handler(unsigned long);
252
253static int asd_init_dl(struct asd_ha_struct *asd_ha)
254{
255 asd_ha->seq.actual_dl
256 = asd_alloc_coherent(asd_ha,
257 ASD_DL_SIZE * sizeof(struct done_list_struct),
258 GFP_KERNEL);
259 if (!asd_ha->seq.actual_dl)
260 return -ENOMEM;
261 asd_ha->seq.dl = asd_ha->seq.actual_dl->vaddr;
262 asd_ha->seq.dl_toggle = ASD_DEF_DL_TOGGLE;
263 asd_ha->seq.dl_next = 0;
264 tasklet_init(&asd_ha->seq.dl_tasklet, asd_dl_tasklet_handler,
265 (unsigned long) asd_ha);
266
267 return 0;
268}
269
270/* ---------- EDB and ESCB init ---------- */
271
272static int asd_alloc_edbs(struct asd_ha_struct *asd_ha, gfp_t gfp_flags)
273{
274 struct asd_seq_data *seq = &asd_ha->seq;
275 int i;
276
277 seq->edb_arr = kmalloc_array(seq->num_edbs, sizeof(*seq->edb_arr),
278 gfp_flags);
279 if (!seq->edb_arr)
280 return -ENOMEM;
281
282 for (i = 0; i < seq->num_edbs; i++) {
283 seq->edb_arr[i] = asd_alloc_coherent(asd_ha, ASD_EDB_SIZE,
284 gfp_flags);
285 if (!seq->edb_arr[i])
286 goto Err_unroll;
287 memset(seq->edb_arr[i]->vaddr, 0, ASD_EDB_SIZE);
288 }
289
290 ASD_DPRINTK("num_edbs:%d\n", seq->num_edbs);
291
292 return 0;
293
294Err_unroll:
295 for (i-- ; i >= 0; i--)
296 asd_free_coherent(asd_ha, seq->edb_arr[i]);
297 kfree(seq->edb_arr);
298 seq->edb_arr = NULL;
299
300 return -ENOMEM;
301}
302
303static int asd_alloc_escbs(struct asd_ha_struct *asd_ha,
304 gfp_t gfp_flags)
305{
306 struct asd_seq_data *seq = &asd_ha->seq;
307 struct asd_ascb *escb;
308 int i, escbs;
309
310 seq->escb_arr = kmalloc_array(seq->num_escbs, sizeof(*seq->escb_arr),
311 gfp_flags);
312 if (!seq->escb_arr)
313 return -ENOMEM;
314
315 escbs = seq->num_escbs;
316 escb = asd_ascb_alloc_list(asd_ha, &escbs, gfp_flags);
317 if (!escb) {
318 asd_printk("couldn't allocate list of escbs\n");
319 goto Err;
320 }
321 seq->num_escbs -= escbs; /* subtract what was not allocated */
322 ASD_DPRINTK("num_escbs:%d\n", seq->num_escbs);
323
324 for (i = 0; i < seq->num_escbs; i++, escb = list_entry(escb->list.next,
325 struct asd_ascb,
326 list)) {
327 seq->escb_arr[i] = escb;
328 escb->scb->header.opcode = EMPTY_SCB;
329 }
330
331 return 0;
332Err:
333 kfree(seq->escb_arr);
334 seq->escb_arr = NULL;
335 return -ENOMEM;
336
337}
338
339static void asd_assign_edbs2escbs(struct asd_ha_struct *asd_ha)
340{
341 struct asd_seq_data *seq = &asd_ha->seq;
342 int i, k, z = 0;
343
344 for (i = 0; i < seq->num_escbs; i++) {
345 struct asd_ascb *ascb = seq->escb_arr[i];
346 struct empty_scb *escb = &ascb->scb->escb;
347
348 ascb->edb_index = z;
349
350 escb->num_valid = ASD_EDBS_PER_SCB;
351
352 for (k = 0; k < ASD_EDBS_PER_SCB; k++) {
353 struct sg_el *eb = &escb->eb[k];
354 struct asd_dma_tok *edb = seq->edb_arr[z++];
355
356 memset(eb, 0, sizeof(*eb));
357 eb->bus_addr = cpu_to_le64(((u64) edb->dma_handle));
358 eb->size = cpu_to_le32(((u32) edb->size));
359 }
360 }
361}
362
363/**
364 * asd_init_escbs -- allocate and initialize empty scbs
365 * @asd_ha: pointer to host adapter structure
366 *
367 * An empty SCB has sg_elements of ASD_EDBS_PER_SCB (7) buffers.
368 * They transport sense data, etc.
369 */
370static int asd_init_escbs(struct asd_ha_struct *asd_ha)
371{
372 struct asd_seq_data *seq = &asd_ha->seq;
373 int err = 0;
374
375 /* Allocate two empty data buffers (edb) per sequencer. */
376 int edbs = 2*(1+asd_ha->hw_prof.num_phys);
377
378 seq->num_escbs = (edbs+ASD_EDBS_PER_SCB-1)/ASD_EDBS_PER_SCB;
379 seq->num_edbs = seq->num_escbs * ASD_EDBS_PER_SCB;
380
381 err = asd_alloc_edbs(asd_ha, GFP_KERNEL);
382 if (err) {
383 asd_printk("couldn't allocate edbs\n");
384 return err;
385 }
386
387 err = asd_alloc_escbs(asd_ha, GFP_KERNEL);
388 if (err) {
389 asd_printk("couldn't allocate escbs\n");
390 return err;
391 }
392
393 asd_assign_edbs2escbs(asd_ha);
394 /* In order to insure that normal SCBs do not overfill sequencer
395 * memory and leave no space for escbs (halting condition),
396 * we increment pending here by the number of escbs. However,
397 * escbs are never pending.
398 */
399 seq->pending = seq->num_escbs;
400 seq->can_queue = 1 + (asd_ha->hw_prof.max_scbs - seq->pending)/2;
401
402 return 0;
403}
404
405/* ---------- HW initialization ---------- */
406
407/**
408 * asd_chip_hardrst -- hard reset the chip
409 * @asd_ha: pointer to host adapter structure
410 *
411 * This takes 16 cycles and is synchronous to CFCLK, which runs
412 * at 200 MHz, so this should take at most 80 nanoseconds.
413 */
414int asd_chip_hardrst(struct asd_ha_struct *asd_ha)
415{
416 int i;
417 int count = 100;
418 u32 reg;
419
420 for (i = 0 ; i < 4 ; i++) {
421 asd_write_reg_dword(asd_ha, COMBIST, HARDRST);
422 }
423
424 do {
425 udelay(1);
426 reg = asd_read_reg_dword(asd_ha, CHIMINT);
427 if (reg & HARDRSTDET) {
428 asd_write_reg_dword(asd_ha, CHIMINT,
429 HARDRSTDET|PORRSTDET);
430 return 0;
431 }
432 } while (--count > 0);
433
434 return -ENODEV;
435}
436
437/**
438 * asd_init_chip -- initialize the chip
439 * @asd_ha: pointer to host adapter structure
440 *
441 * Hard resets the chip, disables HA interrupts, downloads the sequnecer
442 * microcode and starts the sequencers. The caller has to explicitly
443 * enable HA interrupts with asd_enable_ints(asd_ha).
444 */
445static int asd_init_chip(struct asd_ha_struct *asd_ha)
446{
447 int err;
448
449 err = asd_chip_hardrst(asd_ha);
450 if (err) {
451 asd_printk("couldn't hard reset %s\n",
452 pci_name(asd_ha->pcidev));
453 goto out;
454 }
455
456 asd_disable_ints(asd_ha);
457
458 err = asd_init_seqs(asd_ha);
459 if (err) {
460 asd_printk("couldn't init seqs for %s\n",
461 pci_name(asd_ha->pcidev));
462 goto out;
463 }
464
465 err = asd_start_seqs(asd_ha);
466 if (err) {
467 asd_printk("couldn't start seqs for %s\n",
468 pci_name(asd_ha->pcidev));
469 goto out;
470 }
471out:
472 return err;
473}
474
475#define MAX_DEVS ((OCM_MAX_SIZE) / (ASD_DDB_SIZE))
476
477static int max_devs = 0;
478module_param_named(max_devs, max_devs, int, S_IRUGO);
479MODULE_PARM_DESC(max_devs, "\n"
480 "\tMaximum number of SAS devices to support (not LUs).\n"
481 "\tDefault: 2176, Maximum: 65663.\n");
482
483static int max_cmnds = 0;
484module_param_named(max_cmnds, max_cmnds, int, S_IRUGO);
485MODULE_PARM_DESC(max_cmnds, "\n"
486 "\tMaximum number of commands queuable.\n"
487 "\tDefault: 512, Maximum: 66047.\n");
488
489static void asd_extend_devctx_ocm(struct asd_ha_struct *asd_ha)
490{
491 unsigned long dma_addr = OCM_BASE_ADDR;
492 u32 d;
493
494 dma_addr -= asd_ha->hw_prof.max_ddbs * ASD_DDB_SIZE;
495 asd_write_reg_addr(asd_ha, DEVCTXBASE, (dma_addr_t) dma_addr);
496 d = asd_read_reg_dword(asd_ha, CTXDOMAIN);
497 d |= 4;
498 asd_write_reg_dword(asd_ha, CTXDOMAIN, d);
499 asd_ha->hw_prof.max_ddbs += MAX_DEVS;
500}
501
502static int asd_extend_devctx(struct asd_ha_struct *asd_ha)
503{
504 dma_addr_t dma_handle;
505 unsigned long dma_addr;
506 u32 d;
507 int size;
508
509 asd_extend_devctx_ocm(asd_ha);
510
511 asd_ha->hw_prof.ddb_ext = NULL;
512 if (max_devs <= asd_ha->hw_prof.max_ddbs || max_devs > 0xFFFF) {
513 max_devs = asd_ha->hw_prof.max_ddbs;
514 return 0;
515 }
516
517 size = (max_devs - asd_ha->hw_prof.max_ddbs + 1) * ASD_DDB_SIZE;
518
519 asd_ha->hw_prof.ddb_ext = asd_alloc_coherent(asd_ha, size, GFP_KERNEL);
520 if (!asd_ha->hw_prof.ddb_ext) {
521 asd_printk("couldn't allocate memory for %d devices\n",
522 max_devs);
523 max_devs = asd_ha->hw_prof.max_ddbs;
524 return -ENOMEM;
525 }
526 dma_handle = asd_ha->hw_prof.ddb_ext->dma_handle;
527 dma_addr = ALIGN((unsigned long) dma_handle, ASD_DDB_SIZE);
528 dma_addr -= asd_ha->hw_prof.max_ddbs * ASD_DDB_SIZE;
529 dma_handle = (dma_addr_t) dma_addr;
530 asd_write_reg_addr(asd_ha, DEVCTXBASE, dma_handle);
531 d = asd_read_reg_dword(asd_ha, CTXDOMAIN);
532 d &= ~4;
533 asd_write_reg_dword(asd_ha, CTXDOMAIN, d);
534
535 asd_ha->hw_prof.max_ddbs = max_devs;
536
537 return 0;
538}
539
540static int asd_extend_cmdctx(struct asd_ha_struct *asd_ha)
541{
542 dma_addr_t dma_handle;
543 unsigned long dma_addr;
544 u32 d;
545 int size;
546
547 asd_ha->hw_prof.scb_ext = NULL;
548 if (max_cmnds <= asd_ha->hw_prof.max_scbs || max_cmnds > 0xFFFF) {
549 max_cmnds = asd_ha->hw_prof.max_scbs;
550 return 0;
551 }
552
553 size = (max_cmnds - asd_ha->hw_prof.max_scbs + 1) * ASD_SCB_SIZE;
554
555 asd_ha->hw_prof.scb_ext = asd_alloc_coherent(asd_ha, size, GFP_KERNEL);
556 if (!asd_ha->hw_prof.scb_ext) {
557 asd_printk("couldn't allocate memory for %d commands\n",
558 max_cmnds);
559 max_cmnds = asd_ha->hw_prof.max_scbs;
560 return -ENOMEM;
561 }
562 dma_handle = asd_ha->hw_prof.scb_ext->dma_handle;
563 dma_addr = ALIGN((unsigned long) dma_handle, ASD_SCB_SIZE);
564 dma_addr -= asd_ha->hw_prof.max_scbs * ASD_SCB_SIZE;
565 dma_handle = (dma_addr_t) dma_addr;
566 asd_write_reg_addr(asd_ha, CMDCTXBASE, dma_handle);
567 d = asd_read_reg_dword(asd_ha, CTXDOMAIN);
568 d &= ~1;
569 asd_write_reg_dword(asd_ha, CTXDOMAIN, d);
570
571 asd_ha->hw_prof.max_scbs = max_cmnds;
572
573 return 0;
574}
575
576/**
577 * asd_init_ctxmem -- initialize context memory
578 * @asd_ha: pointer to host adapter structure
579 *
580 * This function sets the maximum number of SCBs and
581 * DDBs which can be used by the sequencer. This is normally
582 * 512 and 128 respectively. If support for more SCBs or more DDBs
583 * is required then CMDCTXBASE, DEVCTXBASE and CTXDOMAIN are
584 * initialized here to extend context memory to point to host memory,
585 * thus allowing unlimited support for SCBs and DDBs -- only limited
586 * by host memory.
587 */
588static int asd_init_ctxmem(struct asd_ha_struct *asd_ha)
589{
590 int bitmap_bytes;
591
592 asd_get_max_scb_ddb(asd_ha);
593 asd_extend_devctx(asd_ha);
594 asd_extend_cmdctx(asd_ha);
595
596 /* The kernel wants bitmaps to be unsigned long sized. */
597 bitmap_bytes = (asd_ha->hw_prof.max_ddbs+7)/8;
598 bitmap_bytes = BITS_TO_LONGS(bitmap_bytes*8)*sizeof(unsigned long);
599 asd_ha->hw_prof.ddb_bitmap = kzalloc(bitmap_bytes, GFP_KERNEL);
600 if (!asd_ha->hw_prof.ddb_bitmap)
601 return -ENOMEM;
602 spin_lock_init(&asd_ha->hw_prof.ddb_lock);
603
604 return 0;
605}
606
607int asd_init_hw(struct asd_ha_struct *asd_ha)
608{
609 int err;
610 u32 v;
611
612 err = asd_init_sw(asd_ha);
613 if (err)
614 return err;
615
616 err = pci_read_config_dword(asd_ha->pcidev, PCIC_HSTPCIX_CNTRL, &v);
617 if (err) {
618 asd_printk("couldn't read PCIC_HSTPCIX_CNTRL of %s\n",
619 pci_name(asd_ha->pcidev));
620 return err;
621 }
622 err = pci_write_config_dword(asd_ha->pcidev, PCIC_HSTPCIX_CNTRL,
623 v | SC_TMR_DIS);
624 if (err) {
625 asd_printk("couldn't disable split completion timer of %s\n",
626 pci_name(asd_ha->pcidev));
627 return err;
628 }
629
630 err = asd_read_ocm(asd_ha);
631 if (err) {
632 asd_printk("couldn't read ocm(%d)\n", err);
633 /* While suspicios, it is not an error that we
634 * couldn't read the OCM. */
635 }
636
637 err = asd_read_flash(asd_ha);
638 if (err) {
639 asd_printk("couldn't read flash(%d)\n", err);
640 /* While suspicios, it is not an error that we
641 * couldn't read FLASH memory.
642 */
643 }
644
645 asd_init_ctxmem(asd_ha);
646
647 if (asd_get_user_sas_addr(asd_ha)) {
648 asd_printk("No SAS Address provided for %s\n",
649 pci_name(asd_ha->pcidev));
650 err = -ENODEV;
651 goto Out;
652 }
653
654 asd_propagate_sas_addr(asd_ha);
655
656 err = asd_init_phys(asd_ha);
657 if (err) {
658 asd_printk("couldn't initialize phys for %s\n",
659 pci_name(asd_ha->pcidev));
660 goto Out;
661 }
662
663 asd_init_ports(asd_ha);
664
665 err = asd_init_scbs(asd_ha);
666 if (err) {
667 asd_printk("couldn't initialize scbs for %s\n",
668 pci_name(asd_ha->pcidev));
669 goto Out;
670 }
671
672 err = asd_init_dl(asd_ha);
673 if (err) {
674 asd_printk("couldn't initialize the done list:%d\n",
675 err);
676 goto Out;
677 }
678
679 err = asd_init_escbs(asd_ha);
680 if (err) {
681 asd_printk("couldn't initialize escbs\n");
682 goto Out;
683 }
684
685 err = asd_init_chip(asd_ha);
686 if (err) {
687 asd_printk("couldn't init the chip\n");
688 goto Out;
689 }
690Out:
691 return err;
692}
693
694/* ---------- Chip reset ---------- */
695
696/**
697 * asd_chip_reset -- reset the host adapter, etc
698 * @asd_ha: pointer to host adapter structure of interest
699 *
700 * Called from the ISR. Hard reset the chip. Let everything
701 * timeout. This should be no different than hot-unplugging the
702 * host adapter. Once everything times out we'll init the chip with
703 * a call to asd_init_chip() and enable interrupts with asd_enable_ints().
704 * XXX finish.
705 */
706static void asd_chip_reset(struct asd_ha_struct *asd_ha)
707{
708 ASD_DPRINTK("chip reset for %s\n", pci_name(asd_ha->pcidev));
709 asd_chip_hardrst(asd_ha);
710}
711
712/* ---------- Done List Routines ---------- */
713
714static void asd_dl_tasklet_handler(unsigned long data)
715{
716 struct asd_ha_struct *asd_ha = (struct asd_ha_struct *) data;
717 struct asd_seq_data *seq = &asd_ha->seq;
718 unsigned long flags;
719
720 while (1) {
721 struct done_list_struct *dl = &seq->dl[seq->dl_next];
722 struct asd_ascb *ascb;
723
724 if ((dl->toggle & DL_TOGGLE_MASK) != seq->dl_toggle)
725 break;
726
727 /* find the aSCB */
728 spin_lock_irqsave(&seq->tc_index_lock, flags);
729 ascb = asd_tc_index_find(seq, (int)le16_to_cpu(dl->index));
730 spin_unlock_irqrestore(&seq->tc_index_lock, flags);
731 if (unlikely(!ascb)) {
732 ASD_DPRINTK("BUG:sequencer:dl:no ascb?!\n");
733 goto next_1;
734 } else if (ascb->scb->header.opcode == EMPTY_SCB) {
735 goto out;
736 } else if (!ascb->uldd_timer && !del_timer(&ascb->timer)) {
737 goto next_1;
738 }
739 spin_lock_irqsave(&seq->pend_q_lock, flags);
740 list_del_init(&ascb->list);
741 seq->pending--;
742 spin_unlock_irqrestore(&seq->pend_q_lock, flags);
743 out:
744 ascb->tasklet_complete(ascb, dl);
745
746 next_1:
747 seq->dl_next = (seq->dl_next + 1) & (ASD_DL_SIZE-1);
748 if (!seq->dl_next)
749 seq->dl_toggle ^= DL_TOGGLE_MASK;
750 }
751}
752
753/* ---------- Interrupt Service Routines ---------- */
754
755/**
756 * asd_process_donelist_isr -- schedule processing of done list entries
757 * @asd_ha: pointer to host adapter structure
758 */
759static void asd_process_donelist_isr(struct asd_ha_struct *asd_ha)
760{
761 tasklet_schedule(&asd_ha->seq.dl_tasklet);
762}
763
764/**
765 * asd_com_sas_isr -- process device communication interrupt (COMINT)
766 * @asd_ha: pointer to host adapter structure
767 */
768static void asd_com_sas_isr(struct asd_ha_struct *asd_ha)
769{
770 u32 comstat = asd_read_reg_dword(asd_ha, COMSTAT);
771
772 /* clear COMSTAT int */
773 asd_write_reg_dword(asd_ha, COMSTAT, 0xFFFFFFFF);
774
775 if (comstat & CSBUFPERR) {
776 asd_printk("%s: command/status buffer dma parity error\n",
777 pci_name(asd_ha->pcidev));
778 } else if (comstat & CSERR) {
779 int i;
780 u32 dmaerr = asd_read_reg_dword(asd_ha, DMAERR);
781 dmaerr &= 0xFF;
782 asd_printk("%s: command/status dma error, DMAERR: 0x%02x, "
783 "CSDMAADR: 0x%04x, CSDMAADR+4: 0x%04x\n",
784 pci_name(asd_ha->pcidev),
785 dmaerr,
786 asd_read_reg_dword(asd_ha, CSDMAADR),
787 asd_read_reg_dword(asd_ha, CSDMAADR+4));
788 asd_printk("CSBUFFER:\n");
789 for (i = 0; i < 8; i++) {
790 asd_printk("%08x %08x %08x %08x\n",
791 asd_read_reg_dword(asd_ha, CSBUFFER),
792 asd_read_reg_dword(asd_ha, CSBUFFER+4),
793 asd_read_reg_dword(asd_ha, CSBUFFER+8),
794 asd_read_reg_dword(asd_ha, CSBUFFER+12));
795 }
796 asd_dump_seq_state(asd_ha, 0);
797 } else if (comstat & OVLYERR) {
798 u32 dmaerr = asd_read_reg_dword(asd_ha, DMAERR);
799 dmaerr = (dmaerr >> 8) & 0xFF;
800 asd_printk("%s: overlay dma error:0x%x\n",
801 pci_name(asd_ha->pcidev),
802 dmaerr);
803 }
804 asd_chip_reset(asd_ha);
805}
806
807static void asd_arp2_err(struct asd_ha_struct *asd_ha, u32 dchstatus)
808{
809 static const char *halt_code[256] = {
810 "UNEXPECTED_INTERRUPT0",
811 "UNEXPECTED_INTERRUPT1",
812 "UNEXPECTED_INTERRUPT2",
813 "UNEXPECTED_INTERRUPT3",
814 "UNEXPECTED_INTERRUPT4",
815 "UNEXPECTED_INTERRUPT5",
816 "UNEXPECTED_INTERRUPT6",
817 "UNEXPECTED_INTERRUPT7",
818 "UNEXPECTED_INTERRUPT8",
819 "UNEXPECTED_INTERRUPT9",
820 "UNEXPECTED_INTERRUPT10",
821 [11 ... 19] = "unknown[11,19]",
822 "NO_FREE_SCB_AVAILABLE",
823 "INVALID_SCB_OPCODE",
824 "INVALID_MBX_OPCODE",
825 "INVALID_ATA_STATE",
826 "ATA_QUEUE_FULL",
827 "ATA_TAG_TABLE_FAULT",
828 "ATA_TAG_MASK_FAULT",
829 "BAD_LINK_QUEUE_STATE",
830 "DMA2CHIM_QUEUE_ERROR",
831 "EMPTY_SCB_LIST_FULL",
832 "unknown[30]",
833 "IN_USE_SCB_ON_FREE_LIST",
834 "BAD_OPEN_WAIT_STATE",
835 "INVALID_STP_AFFILIATION",
836 "unknown[34]",
837 "EXEC_QUEUE_ERROR",
838 "TOO_MANY_EMPTIES_NEEDED",
839 "EMPTY_REQ_QUEUE_ERROR",
840 "Q_MONIRTT_MGMT_ERROR",
841 "TARGET_MODE_FLOW_ERROR",
842 "DEVICE_QUEUE_NOT_FOUND",
843 "START_IRTT_TIMER_ERROR",
844 "ABORT_TASK_ILLEGAL_REQ",
845 [43 ... 255] = "unknown[43,255]"
846 };
847
848 if (dchstatus & CSEQINT) {
849 u32 arp2int = asd_read_reg_dword(asd_ha, CARP2INT);
850
851 if (arp2int & (ARP2WAITTO|ARP2ILLOPC|ARP2PERR|ARP2CIOPERR)) {
852 asd_printk("%s: CSEQ arp2int:0x%x\n",
853 pci_name(asd_ha->pcidev),
854 arp2int);
855 } else if (arp2int & ARP2HALTC)
856 asd_printk("%s: CSEQ halted: %s\n",
857 pci_name(asd_ha->pcidev),
858 halt_code[(arp2int>>16)&0xFF]);
859 else
860 asd_printk("%s: CARP2INT:0x%x\n",
861 pci_name(asd_ha->pcidev),
862 arp2int);
863 }
864 if (dchstatus & LSEQINT_MASK) {
865 int lseq;
866 u8 lseq_mask = dchstatus & LSEQINT_MASK;
867
868 for_each_sequencer(lseq_mask, lseq_mask, lseq) {
869 u32 arp2int = asd_read_reg_dword(asd_ha,
870 LmARP2INT(lseq));
871 if (arp2int & (ARP2WAITTO | ARP2ILLOPC | ARP2PERR
872 | ARP2CIOPERR)) {
873 asd_printk("%s: LSEQ%d arp2int:0x%x\n",
874 pci_name(asd_ha->pcidev),
875 lseq, arp2int);
876 /* XXX we should only do lseq reset */
877 } else if (arp2int & ARP2HALTC)
878 asd_printk("%s: LSEQ%d halted: %s\n",
879 pci_name(asd_ha->pcidev),
880 lseq,halt_code[(arp2int>>16)&0xFF]);
881 else
882 asd_printk("%s: LSEQ%d ARP2INT:0x%x\n",
883 pci_name(asd_ha->pcidev), lseq,
884 arp2int);
885 }
886 }
887 asd_chip_reset(asd_ha);
888}
889
890/**
891 * asd_dch_sas_isr -- process device channel interrupt (DEVINT)
892 * @asd_ha: pointer to host adapter structure
893 */
894static void asd_dch_sas_isr(struct asd_ha_struct *asd_ha)
895{
896 u32 dchstatus = asd_read_reg_dword(asd_ha, DCHSTATUS);
897
898 if (dchstatus & CFIFTOERR) {
899 asd_printk("%s: CFIFTOERR\n", pci_name(asd_ha->pcidev));
900 asd_chip_reset(asd_ha);
901 } else
902 asd_arp2_err(asd_ha, dchstatus);
903}
904
905/**
906 * ads_rbi_exsi_isr -- process external system interface interrupt (INITERR)
907 * @asd_ha: pointer to host adapter structure
908 */
909static void asd_rbi_exsi_isr(struct asd_ha_struct *asd_ha)
910{
911 u32 stat0r = asd_read_reg_dword(asd_ha, ASISTAT0R);
912
913 if (!(stat0r & ASIERR)) {
914 asd_printk("hmm, EXSI interrupted but no error?\n");
915 return;
916 }
917
918 if (stat0r & ASIFMTERR) {
919 asd_printk("ASI SEEPROM format error for %s\n",
920 pci_name(asd_ha->pcidev));
921 } else if (stat0r & ASISEECHKERR) {
922 u32 stat1r = asd_read_reg_dword(asd_ha, ASISTAT1R);
923 asd_printk("ASI SEEPROM checksum 0x%x error for %s\n",
924 stat1r & CHECKSUM_MASK,
925 pci_name(asd_ha->pcidev));
926 } else {
927 u32 statr = asd_read_reg_dword(asd_ha, ASIERRSTATR);
928
929 if (!(statr & CPI2ASIMSTERR_MASK)) {
930 ASD_DPRINTK("hmm, ASIERR?\n");
931 return;
932 } else {
933 u32 addr = asd_read_reg_dword(asd_ha, ASIERRADDR);
934 u32 data = asd_read_reg_dword(asd_ha, ASIERRDATAR);
935
936 asd_printk("%s: CPI2 xfer err: addr: 0x%x, wdata: 0x%x, "
937 "count: 0x%x, byteen: 0x%x, targerr: 0x%x "
938 "master id: 0x%x, master err: 0x%x\n",
939 pci_name(asd_ha->pcidev),
940 addr, data,
941 (statr & CPI2ASIBYTECNT_MASK) >> 16,
942 (statr & CPI2ASIBYTEEN_MASK) >> 12,
943 (statr & CPI2ASITARGERR_MASK) >> 8,
944 (statr & CPI2ASITARGMID_MASK) >> 4,
945 (statr & CPI2ASIMSTERR_MASK));
946 }
947 }
948 asd_chip_reset(asd_ha);
949}
950
951/**
952 * asd_hst_pcix_isr -- process host interface interrupts
953 * @asd_ha: pointer to host adapter structure
954 *
955 * Asserted on PCIX errors: target abort, etc.
956 */
957static void asd_hst_pcix_isr(struct asd_ha_struct *asd_ha)
958{
959 u16 status;
960 u32 pcix_status;
961 u32 ecc_status;
962
963 pci_read_config_word(asd_ha->pcidev, PCI_STATUS, &status);
964 pci_read_config_dword(asd_ha->pcidev, PCIX_STATUS, &pcix_status);
965 pci_read_config_dword(asd_ha->pcidev, ECC_CTRL_STAT, &ecc_status);
966
967 if (status & PCI_STATUS_DETECTED_PARITY)
968 asd_printk("parity error for %s\n", pci_name(asd_ha->pcidev));
969 else if (status & PCI_STATUS_REC_MASTER_ABORT)
970 asd_printk("master abort for %s\n", pci_name(asd_ha->pcidev));
971 else if (status & PCI_STATUS_REC_TARGET_ABORT)
972 asd_printk("target abort for %s\n", pci_name(asd_ha->pcidev));
973 else if (status & PCI_STATUS_PARITY)
974 asd_printk("data parity for %s\n", pci_name(asd_ha->pcidev));
975 else if (pcix_status & RCV_SCE) {
976 asd_printk("received split completion error for %s\n",
977 pci_name(asd_ha->pcidev));
978 pci_write_config_dword(asd_ha->pcidev,PCIX_STATUS,pcix_status);
979 /* XXX: Abort task? */
980 return;
981 } else if (pcix_status & UNEXP_SC) {
982 asd_printk("unexpected split completion for %s\n",
983 pci_name(asd_ha->pcidev));
984 pci_write_config_dword(asd_ha->pcidev,PCIX_STATUS,pcix_status);
985 /* ignore */
986 return;
987 } else if (pcix_status & SC_DISCARD)
988 asd_printk("split completion discarded for %s\n",
989 pci_name(asd_ha->pcidev));
990 else if (ecc_status & UNCOR_ECCERR)
991 asd_printk("uncorrectable ECC error for %s\n",
992 pci_name(asd_ha->pcidev));
993 asd_chip_reset(asd_ha);
994}
995
996/**
997 * asd_hw_isr -- host adapter interrupt service routine
998 * @irq: ignored
999 * @dev_id: pointer to host adapter structure
1000 *
1001 * The ISR processes done list entries and level 3 error handling.
1002 */
1003irqreturn_t asd_hw_isr(int irq, void *dev_id)
1004{
1005 struct asd_ha_struct *asd_ha = dev_id;
1006 u32 chimint = asd_read_reg_dword(asd_ha, CHIMINT);
1007
1008 if (!chimint)
1009 return IRQ_NONE;
1010
1011 asd_write_reg_dword(asd_ha, CHIMINT, chimint);
1012 (void) asd_read_reg_dword(asd_ha, CHIMINT);
1013
1014 if (chimint & DLAVAIL)
1015 asd_process_donelist_isr(asd_ha);
1016 if (chimint & COMINT)
1017 asd_com_sas_isr(asd_ha);
1018 if (chimint & DEVINT)
1019 asd_dch_sas_isr(asd_ha);
1020 if (chimint & INITERR)
1021 asd_rbi_exsi_isr(asd_ha);
1022 if (chimint & HOSTERR)
1023 asd_hst_pcix_isr(asd_ha);
1024
1025 return IRQ_HANDLED;
1026}
1027
1028/* ---------- SCB handling ---------- */
1029
1030static struct asd_ascb *asd_ascb_alloc(struct asd_ha_struct *asd_ha,
1031 gfp_t gfp_flags)
1032{
1033 extern struct kmem_cache *asd_ascb_cache;
1034 struct asd_seq_data *seq = &asd_ha->seq;
1035 struct asd_ascb *ascb;
1036 unsigned long flags;
1037
1038 ascb = kmem_cache_zalloc(asd_ascb_cache, gfp_flags);
1039
1040 if (ascb) {
1041 ascb->dma_scb.size = sizeof(struct scb);
1042 ascb->dma_scb.vaddr = dma_pool_zalloc(asd_ha->scb_pool,
1043 gfp_flags,
1044 &ascb->dma_scb.dma_handle);
1045 if (!ascb->dma_scb.vaddr) {
1046 kmem_cache_free(asd_ascb_cache, ascb);
1047 return NULL;
1048 }
1049 asd_init_ascb(asd_ha, ascb);
1050
1051 spin_lock_irqsave(&seq->tc_index_lock, flags);
1052 ascb->tc_index = asd_tc_index_get(seq, ascb);
1053 spin_unlock_irqrestore(&seq->tc_index_lock, flags);
1054 if (ascb->tc_index == -1)
1055 goto undo;
1056
1057 ascb->scb->header.index = cpu_to_le16((u16)ascb->tc_index);
1058 }
1059
1060 return ascb;
1061undo:
1062 dma_pool_free(asd_ha->scb_pool, ascb->dma_scb.vaddr,
1063 ascb->dma_scb.dma_handle);
1064 kmem_cache_free(asd_ascb_cache, ascb);
1065 ASD_DPRINTK("no index for ascb\n");
1066 return NULL;
1067}
1068
1069/**
1070 * asd_ascb_alloc_list -- allocate a list of aSCBs
1071 * @asd_ha: pointer to host adapter structure
1072 * @num: pointer to integer number of aSCBs
1073 * @gfp_flags: GFP_ flags.
1074 *
1075 * This is the only function which is used to allocate aSCBs.
1076 * It can allocate one or many. If more than one, then they form
1077 * a linked list in two ways: by their list field of the ascb struct
1078 * and by the next_scb field of the scb_header.
1079 *
1080 * Returns NULL if no memory was available, else pointer to a list
1081 * of ascbs. When this function returns, @num would be the number
1082 * of SCBs which were not able to be allocated, 0 if all requested
1083 * were able to be allocated.
1084 */
1085struct asd_ascb *asd_ascb_alloc_list(struct asd_ha_struct
1086 *asd_ha, int *num,
1087 gfp_t gfp_flags)
1088{
1089 struct asd_ascb *first = NULL;
1090
1091 for ( ; *num > 0; --*num) {
1092 struct asd_ascb *ascb = asd_ascb_alloc(asd_ha, gfp_flags);
1093
1094 if (!ascb)
1095 break;
1096 else if (!first)
1097 first = ascb;
1098 else {
1099 struct asd_ascb *last = list_entry(first->list.prev,
1100 struct asd_ascb,
1101 list);
1102 list_add_tail(&ascb->list, &first->list);
1103 last->scb->header.next_scb =
1104 cpu_to_le64(((u64)ascb->dma_scb.dma_handle));
1105 }
1106 }
1107
1108 return first;
1109}
1110
1111/**
1112 * asd_swap_head_scb -- swap the head scb
1113 * @asd_ha: pointer to host adapter structure
1114 * @ascb: pointer to the head of an ascb list
1115 *
1116 * The sequencer knows the DMA address of the next SCB to be DMAed to
1117 * the host adapter, from initialization or from the last list DMAed.
1118 * seq->next_scb keeps the address of this SCB. The sequencer will
1119 * DMA to the host adapter this list of SCBs. But the head (first
1120 * element) of this list is not known to the sequencer. Here we swap
1121 * the head of the list with the known SCB (memcpy()).
1122 * Only one memcpy() is required per list so it is in our interest
1123 * to keep the list of SCB as long as possible so that the ratio
1124 * of number of memcpy calls to the number of SCB DMA-ed is as small
1125 * as possible.
1126 *
1127 * LOCKING: called with the pending list lock held.
1128 */
1129static void asd_swap_head_scb(struct asd_ha_struct *asd_ha,
1130 struct asd_ascb *ascb)
1131{
1132 struct asd_seq_data *seq = &asd_ha->seq;
1133 struct asd_ascb *last = list_entry(ascb->list.prev,
1134 struct asd_ascb,
1135 list);
1136 struct asd_dma_tok t = ascb->dma_scb;
1137
1138 memcpy(seq->next_scb.vaddr, ascb->scb, sizeof(*ascb->scb));
1139 ascb->dma_scb = seq->next_scb;
1140 ascb->scb = ascb->dma_scb.vaddr;
1141 seq->next_scb = t;
1142 last->scb->header.next_scb =
1143 cpu_to_le64(((u64)seq->next_scb.dma_handle));
1144}
1145
1146/**
1147 * asd_start_timers -- (add and) start timers of SCBs
1148 * @list: pointer to struct list_head of the scbs
1149 *
1150 * If an SCB in the @list has no timer function, assign the default
1151 * one, then start the timer of the SCB. This function is
1152 * intended to be called from asd_post_ascb_list(), just prior to
1153 * posting the SCBs to the sequencer.
1154 */
1155static void asd_start_scb_timers(struct list_head *list)
1156{
1157 struct asd_ascb *ascb;
1158 list_for_each_entry(ascb, list, list) {
1159 if (!ascb->uldd_timer) {
1160 ascb->timer.function = asd_ascb_timedout;
1161 ascb->timer.expires = jiffies + AIC94XX_SCB_TIMEOUT;
1162 add_timer(&ascb->timer);
1163 }
1164 }
1165}
1166
1167/**
1168 * asd_post_ascb_list -- post a list of 1 or more aSCBs to the host adapter
1169 * @asd_ha: pointer to a host adapter structure
1170 * @ascb: pointer to the first aSCB in the list
1171 * @num: number of aSCBs in the list (to be posted)
1172 *
1173 * See queueing comment in asd_post_escb_list().
1174 *
1175 * Additional note on queuing: In order to minimize the ratio of memcpy()
1176 * to the number of ascbs sent, we try to batch-send as many ascbs as possible
1177 * in one go.
1178 * Two cases are possible:
1179 * A) can_queue >= num,
1180 * B) can_queue < num.
1181 * Case A: we can send the whole batch at once. Increment "pending"
1182 * in the beginning of this function, when it is checked, in order to
1183 * eliminate races when this function is called by multiple processes.
1184 * Case B: should never happen.
1185 */
1186int asd_post_ascb_list(struct asd_ha_struct *asd_ha, struct asd_ascb *ascb,
1187 int num)
1188{
1189 unsigned long flags;
1190 LIST_HEAD(list);
1191 int can_queue;
1192
1193 spin_lock_irqsave(&asd_ha->seq.pend_q_lock, flags);
1194 can_queue = asd_ha->hw_prof.max_scbs - asd_ha->seq.pending;
1195 if (can_queue >= num)
1196 asd_ha->seq.pending += num;
1197 else
1198 can_queue = 0;
1199
1200 if (!can_queue) {
1201 spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags);
1202 asd_printk("%s: scb queue full\n", pci_name(asd_ha->pcidev));
1203 return -SAS_QUEUE_FULL;
1204 }
1205
1206 asd_swap_head_scb(asd_ha, ascb);
1207
1208 __list_add(&list, ascb->list.prev, &ascb->list);
1209
1210 asd_start_scb_timers(&list);
1211
1212 asd_ha->seq.scbpro += num;
1213 list_splice_init(&list, asd_ha->seq.pend_q.prev);
1214 asd_write_reg_dword(asd_ha, SCBPRO, (u32)asd_ha->seq.scbpro);
1215 spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags);
1216
1217 return 0;
1218}
1219
1220/**
1221 * asd_post_escb_list -- post a list of 1 or more empty scb
1222 * @asd_ha: pointer to a host adapter structure
1223 * @ascb: pointer to the first empty SCB in the list
1224 * @num: number of aSCBs in the list (to be posted)
1225 *
1226 * This is essentially the same as asd_post_ascb_list, but we do not
1227 * increment pending, add those to the pending list or get indexes.
1228 * See asd_init_escbs() and asd_init_post_escbs().
1229 *
1230 * Since sending a list of ascbs is a superset of sending a single
1231 * ascb, this function exists to generalize this. More specifically,
1232 * when sending a list of those, we want to do only a _single_
1233 * memcpy() at swap head, as opposed to for each ascb sent (in the
1234 * case of sending them one by one). That is, we want to minimize the
1235 * ratio of memcpy() operations to the number of ascbs sent. The same
1236 * logic applies to asd_post_ascb_list().
1237 */
1238int asd_post_escb_list(struct asd_ha_struct *asd_ha, struct asd_ascb *ascb,
1239 int num)
1240{
1241 unsigned long flags;
1242
1243 spin_lock_irqsave(&asd_ha->seq.pend_q_lock, flags);
1244 asd_swap_head_scb(asd_ha, ascb);
1245 asd_ha->seq.scbpro += num;
1246 asd_write_reg_dword(asd_ha, SCBPRO, (u32)asd_ha->seq.scbpro);
1247 spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags);
1248
1249 return 0;
1250}
1251
1252/* ---------- LED ---------- */
1253
1254/**
1255 * asd_turn_led -- turn on/off an LED
1256 * @asd_ha: pointer to host adapter structure
1257 * @phy_id: the PHY id whose LED we want to manupulate
1258 * @op: 1 to turn on, 0 to turn off
1259 */
1260void asd_turn_led(struct asd_ha_struct *asd_ha, int phy_id, int op)
1261{
1262 if (phy_id < ASD_MAX_PHYS) {
1263 u32 v = asd_read_reg_dword(asd_ha, LmCONTROL(phy_id));
1264 if (op)
1265 v |= LEDPOL;
1266 else
1267 v &= ~LEDPOL;
1268 asd_write_reg_dword(asd_ha, LmCONTROL(phy_id), v);
1269 }
1270}
1271
1272/**
1273 * asd_control_led -- enable/disable an LED on the board
1274 * @asd_ha: pointer to host adapter structure
1275 * @phy_id: integer, the phy id
1276 * @op: integer, 1 to enable, 0 to disable the LED
1277 *
1278 * First we output enable the LED, then we set the source
1279 * to be an external module.
1280 */
1281void asd_control_led(struct asd_ha_struct *asd_ha, int phy_id, int op)
1282{
1283 if (phy_id < ASD_MAX_PHYS) {
1284 u32 v;
1285
1286 v = asd_read_reg_dword(asd_ha, GPIOOER);
1287 if (op)
1288 v |= (1 << phy_id);
1289 else
1290 v &= ~(1 << phy_id);
1291 asd_write_reg_dword(asd_ha, GPIOOER, v);
1292
1293 v = asd_read_reg_dword(asd_ha, GPIOCNFGR);
1294 if (op)
1295 v |= (1 << phy_id);
1296 else
1297 v &= ~(1 << phy_id);
1298 asd_write_reg_dword(asd_ha, GPIOCNFGR, v);
1299 }
1300}
1301
1302/* ---------- PHY enable ---------- */
1303
1304static int asd_enable_phy(struct asd_ha_struct *asd_ha, int phy_id)
1305{
1306 struct asd_phy *phy = &asd_ha->phys[phy_id];
1307
1308 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, INT_ENABLE_2), 0);
1309 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, HOT_PLUG_DELAY),
1310 HOTPLUG_DELAY_TIMEOUT);
1311
1312 /* Get defaults from manuf. sector */
1313 /* XXX we need defaults for those in case MS is broken. */
1314 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, PHY_CONTROL_0),
1315 phy->phy_desc->phy_control_0);
1316 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, PHY_CONTROL_1),
1317 phy->phy_desc->phy_control_1);
1318 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, PHY_CONTROL_2),
1319 phy->phy_desc->phy_control_2);
1320 asd_write_reg_byte(asd_ha, LmSEQ_OOB_REG(phy_id, PHY_CONTROL_3),
1321 phy->phy_desc->phy_control_3);
1322
1323 asd_write_reg_dword(asd_ha, LmSEQ_TEN_MS_COMINIT_TIMEOUT(phy_id),
1324 ASD_COMINIT_TIMEOUT);
1325
1326 asd_write_reg_addr(asd_ha, LmSEQ_TX_ID_ADDR_FRAME(phy_id),
1327 phy->id_frm_tok->dma_handle);
1328
1329 asd_control_led(asd_ha, phy_id, 1);
1330
1331 return 0;
1332}
1333
1334int asd_enable_phys(struct asd_ha_struct *asd_ha, const u8 phy_mask)
1335{
1336 u8 phy_m;
1337 u8 i;
1338 int num = 0, k;
1339 struct asd_ascb *ascb;
1340 struct asd_ascb *ascb_list;
1341
1342 if (!phy_mask) {
1343 asd_printk("%s called with phy_mask of 0!?\n", __func__);
1344 return 0;
1345 }
1346
1347 for_each_phy(phy_mask, phy_m, i) {
1348 num++;
1349 asd_enable_phy(asd_ha, i);
1350 }
1351
1352 k = num;
1353 ascb_list = asd_ascb_alloc_list(asd_ha, &k, GFP_KERNEL);
1354 if (!ascb_list) {
1355 asd_printk("no memory for control phy ascb list\n");
1356 return -ENOMEM;
1357 }
1358 num -= k;
1359
1360 ascb = ascb_list;
1361 for_each_phy(phy_mask, phy_m, i) {
1362 asd_build_control_phy(ascb, i, ENABLE_PHY);
1363 ascb = list_entry(ascb->list.next, struct asd_ascb, list);
1364 }
1365 ASD_DPRINTK("posting %d control phy scbs\n", num);
1366 k = asd_post_ascb_list(asd_ha, ascb_list, num);
1367 if (k)
1368 asd_ascb_free_list(ascb_list);
1369
1370 return k;
1371}