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