1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include <linux/delay.h>
30#include <linux/pci.h>
31#include <linux/module.h>
32#include <linux/firmware.h>
33#include "aic94xx_reg.h"
34#include "aic94xx_hwi.h"
35
36#include "aic94xx_seq.h"
37#include "aic94xx_dump.h"
38
39
40
41
42
43#define PAUSE_DELAY 1
44#define PAUSE_TRIES 1000
45
46static const struct firmware *sequencer_fw;
47static u16 cseq_vecs[CSEQ_NUM_VECS], lseq_vecs[LSEQ_NUM_VECS], mode2_task,
48 cseq_idle_loop, lseq_idle_loop;
49static const u8 *cseq_code, *lseq_code;
50static u32 cseq_code_size, lseq_code_size;
51
52static u16 first_scb_site_no = 0xFFFF;
53static u16 last_scb_site_no;
54
55
56
57
58
59
60
61
62
63static int asd_pause_cseq(struct asd_ha_struct *asd_ha)
64{
65 int count = PAUSE_TRIES;
66 u32 arp2ctl;
67
68 arp2ctl = asd_read_reg_dword(asd_ha, CARP2CTL);
69 if (arp2ctl & PAUSED)
70 return 0;
71
72 asd_write_reg_dword(asd_ha, CARP2CTL, arp2ctl | EPAUSE);
73 do {
74 arp2ctl = asd_read_reg_dword(asd_ha, CARP2CTL);
75 if (arp2ctl & PAUSED)
76 return 0;
77 udelay(PAUSE_DELAY);
78 } while (--count > 0);
79
80 ASD_DPRINTK("couldn't pause CSEQ\n");
81 return -1;
82}
83
84
85
86
87
88
89
90static int asd_unpause_cseq(struct asd_ha_struct *asd_ha)
91{
92 u32 arp2ctl;
93 int count = PAUSE_TRIES;
94
95 arp2ctl = asd_read_reg_dword(asd_ha, CARP2CTL);
96 if (!(arp2ctl & PAUSED))
97 return 0;
98
99 asd_write_reg_dword(asd_ha, CARP2CTL, arp2ctl & ~EPAUSE);
100 do {
101 arp2ctl = asd_read_reg_dword(asd_ha, CARP2CTL);
102 if (!(arp2ctl & PAUSED))
103 return 0;
104 udelay(PAUSE_DELAY);
105 } while (--count > 0);
106
107 ASD_DPRINTK("couldn't unpause the CSEQ\n");
108 return -1;
109}
110
111
112
113
114
115
116
117
118static int asd_seq_pause_lseq(struct asd_ha_struct *asd_ha, int lseq)
119{
120 u32 arp2ctl;
121 int count = PAUSE_TRIES;
122
123 arp2ctl = asd_read_reg_dword(asd_ha, LmARP2CTL(lseq));
124 if (arp2ctl & PAUSED)
125 return 0;
126
127 asd_write_reg_dword(asd_ha, LmARP2CTL(lseq), arp2ctl | EPAUSE);
128 do {
129 arp2ctl = asd_read_reg_dword(asd_ha, LmARP2CTL(lseq));
130 if (arp2ctl & PAUSED)
131 return 0;
132 udelay(PAUSE_DELAY);
133 } while (--count > 0);
134
135 ASD_DPRINTK("couldn't pause LSEQ %d\n", lseq);
136 return -1;
137}
138
139
140
141
142
143
144
145
146static int asd_pause_lseq(struct asd_ha_struct *asd_ha, u8 lseq_mask)
147{
148 int lseq;
149 int err = 0;
150
151 for_each_sequencer(lseq_mask, lseq_mask, lseq) {
152 err = asd_seq_pause_lseq(asd_ha, lseq);
153 if (err)
154 return err;
155 }
156
157 return err;
158}
159
160
161
162
163
164
165
166
167static int asd_seq_unpause_lseq(struct asd_ha_struct *asd_ha, int lseq)
168{
169 u32 arp2ctl;
170 int count = PAUSE_TRIES;
171
172 arp2ctl = asd_read_reg_dword(asd_ha, LmARP2CTL(lseq));
173 if (!(arp2ctl & PAUSED))
174 return 0;
175
176 asd_write_reg_dword(asd_ha, LmARP2CTL(lseq), arp2ctl & ~EPAUSE);
177 do {
178 arp2ctl = asd_read_reg_dword(asd_ha, LmARP2CTL(lseq));
179 if (!(arp2ctl & PAUSED))
180 return 0;
181 udelay(PAUSE_DELAY);
182 } while (--count > 0);
183
184 ASD_DPRINTK("couldn't unpause LSEQ %d\n", lseq);
185 return 0;
186}
187
188
189
190
191static int asd_verify_cseq(struct asd_ha_struct *asd_ha, const u8 *_prog,
192 u32 size)
193{
194 u32 addr = CSEQ_RAM_REG_BASE_ADR;
195 const u32 *prog = (u32 *) _prog;
196 u32 i;
197
198 for (i = 0; i < size; i += 4, prog++, addr += 4) {
199 u32 val = asd_read_reg_dword(asd_ha, addr);
200
201 if (le32_to_cpu(*prog) != val) {
202 asd_printk("%s: cseq verify failed at %u "
203 "read:0x%x, wanted:0x%x\n",
204 pci_name(asd_ha->pcidev),
205 i, val, le32_to_cpu(*prog));
206 return -1;
207 }
208 }
209 ASD_DPRINTK("verified %d bytes, passed\n", size);
210 return 0;
211}
212
213
214
215
216
217
218
219
220
221
222
223
224
225static int asd_verify_lseq(struct asd_ha_struct *asd_ha, const u8 *_prog,
226 u32 size, int lseq)
227{
228#define LSEQ_CODEPAGE_SIZE 4096
229 int pages = (size + LSEQ_CODEPAGE_SIZE - 1) / LSEQ_CODEPAGE_SIZE;
230 u32 page;
231 const u32 *prog = (u32 *) _prog;
232
233 for (page = 0; page < pages; page++) {
234 u32 i;
235
236 asd_write_reg_dword(asd_ha, LmBISTCTL1(lseq),
237 page << LmRAMPAGE_LSHIFT);
238 for (i = 0; size > 0 && i < LSEQ_CODEPAGE_SIZE;
239 i += 4, prog++, size-=4) {
240
241 u32 val = asd_read_reg_dword(asd_ha, LmSEQRAM(lseq)+i);
242
243 if (le32_to_cpu(*prog) != val) {
244 asd_printk("%s: LSEQ%d verify failed "
245 "page:%d, offs:%d\n",
246 pci_name(asd_ha->pcidev),
247 lseq, page, i);
248 return -1;
249 }
250 }
251 }
252 ASD_DPRINTK("LSEQ%d verified %d bytes, passed\n", lseq,
253 (int)((u8 *)prog-_prog));
254 return 0;
255}
256
257
258
259
260
261
262
263
264
265
266static int asd_verify_seq(struct asd_ha_struct *asd_ha, const u8 *prog,
267 u32 size, u8 lseq_mask)
268{
269 if (lseq_mask == 0)
270 return asd_verify_cseq(asd_ha, prog, size);
271 else {
272 int lseq, err;
273
274 for_each_sequencer(lseq_mask, lseq_mask, lseq) {
275 err = asd_verify_lseq(asd_ha, prog, size, lseq);
276 if (err)
277 return err;
278 }
279 }
280
281 return 0;
282}
283#define ASD_DMA_MODE_DOWNLOAD
284#ifdef ASD_DMA_MODE_DOWNLOAD
285
286#define MAX_DMA_OVLY_COUNT ((1U << 14)-1)
287static int asd_download_seq(struct asd_ha_struct *asd_ha,
288 const u8 * const prog, u32 size, u8 lseq_mask)
289{
290 u32 comstaten;
291 u32 reg;
292 int page;
293 const int pages = (size + MAX_DMA_OVLY_COUNT - 1) / MAX_DMA_OVLY_COUNT;
294 struct asd_dma_tok *token;
295 int err = 0;
296
297 if (size % 4) {
298 asd_printk("sequencer program not multiple of 4\n");
299 return -1;
300 }
301
302 asd_pause_cseq(asd_ha);
303 asd_pause_lseq(asd_ha, 0xFF);
304
305
306 comstaten = asd_read_reg_dword(asd_ha, COMSTATEN);
307 asd_write_reg_dword(asd_ha, COMSTATEN, 0);
308 asd_write_reg_dword(asd_ha, COMSTAT, COMSTAT_MASK);
309
310 asd_write_reg_dword(asd_ha, CHIMINTEN, RST_CHIMINTEN);
311 asd_write_reg_dword(asd_ha, CHIMINT, CHIMINT_MASK);
312
313 token = asd_alloc_coherent(asd_ha, MAX_DMA_OVLY_COUNT, GFP_KERNEL);
314 if (!token) {
315 asd_printk("out of memory for dma SEQ download\n");
316 err = -ENOMEM;
317 goto out;
318 }
319 ASD_DPRINTK("dma-ing %d bytes\n", size);
320
321 for (page = 0; page < pages; page++) {
322 int i;
323 u32 left = min(size-page*MAX_DMA_OVLY_COUNT,
324 (u32)MAX_DMA_OVLY_COUNT);
325
326 memcpy(token->vaddr, prog + page*MAX_DMA_OVLY_COUNT, left);
327 asd_write_reg_addr(asd_ha, OVLYDMAADR, token->dma_handle);
328 asd_write_reg_dword(asd_ha, OVLYDMACNT, left);
329 reg = !page ? RESETOVLYDMA : 0;
330 reg |= (STARTOVLYDMA | OVLYHALTERR);
331 reg |= (lseq_mask ? (((u32)lseq_mask) << 8) : OVLYCSEQ);
332
333 asd_write_reg_dword(asd_ha, OVLYDMACTL, reg);
334
335 for (i = PAUSE_TRIES*100; i > 0; i--) {
336 u32 dmadone = asd_read_reg_dword(asd_ha, OVLYDMACTL);
337 if (!(dmadone & OVLYDMAACT))
338 break;
339 udelay(PAUSE_DELAY);
340 }
341 }
342
343 reg = asd_read_reg_dword(asd_ha, COMSTAT);
344 if (!(reg & OVLYDMADONE) || (reg & OVLYERR)
345 || (asd_read_reg_dword(asd_ha, CHIMINT) & DEVEXCEPT_MASK)){
346 asd_printk("%s: error DMA-ing sequencer code\n",
347 pci_name(asd_ha->pcidev));
348 err = -ENODEV;
349 }
350
351 asd_free_coherent(asd_ha, token);
352 out:
353 asd_write_reg_dword(asd_ha, COMSTATEN, comstaten);
354
355 return err ? : asd_verify_seq(asd_ha, prog, size, lseq_mask);
356}
357#else
358static int asd_download_seq(struct asd_ha_struct *asd_ha, const u8 *_prog,
359 u32 size, u8 lseq_mask)
360{
361 int i;
362 u32 reg = 0;
363 const u32 *prog = (u32 *) _prog;
364
365 if (size % 4) {
366 asd_printk("sequencer program not multiple of 4\n");
367 return -1;
368 }
369
370 asd_pause_cseq(asd_ha);
371 asd_pause_lseq(asd_ha, 0xFF);
372
373 reg |= (lseq_mask ? (((u32)lseq_mask) << 8) : OVLYCSEQ);
374 reg |= PIOCMODE;
375
376 asd_write_reg_dword(asd_ha, OVLYDMACNT, size);
377 asd_write_reg_dword(asd_ha, OVLYDMACTL, reg);
378
379 ASD_DPRINTK("downloading %s sequencer%s in PIO mode...\n",
380 lseq_mask ? "LSEQ" : "CSEQ", lseq_mask ? "s" : "");
381
382 for (i = 0; i < size; i += 4, prog++)
383 asd_write_reg_dword(asd_ha, SPIODATA, *prog);
384
385 reg = (reg & ~PIOCMODE) | OVLYHALTERR;
386 asd_write_reg_dword(asd_ha, OVLYDMACTL, reg);
387
388 return asd_verify_seq(asd_ha, _prog, size, lseq_mask);
389}
390#endif
391
392
393
394
395
396
397
398static int asd_seq_download_seqs(struct asd_ha_struct *asd_ha)
399{
400 int err;
401
402 if (!asd_ha->hw_prof.enabled_phys) {
403 asd_printk("%s: no enabled phys!\n", pci_name(asd_ha->pcidev));
404 return -ENODEV;
405 }
406
407
408 ASD_DPRINTK("downloading CSEQ...\n");
409 err = asd_download_seq(asd_ha, cseq_code, cseq_code_size, 0);
410 if (err) {
411 asd_printk("CSEQ download failed:%d\n", err);
412 return err;
413 }
414
415
416
417
418 ASD_DPRINTK("downloading LSEQs...\n");
419 err = asd_download_seq(asd_ha, lseq_code, lseq_code_size,
420 asd_ha->hw_prof.enabled_phys);
421 if (err) {
422
423 u8 lseq;
424 u8 lseq_mask = asd_ha->hw_prof.enabled_phys;
425
426 for_each_sequencer(lseq_mask, lseq_mask, lseq) {
427 err = asd_download_seq(asd_ha, lseq_code,
428 lseq_code_size, 1<<lseq);
429 if (err)
430 break;
431 }
432 }
433 if (err)
434 asd_printk("LSEQs download failed:%d\n", err);
435
436 return err;
437}
438
439
440
441
442
443
444
445static void asd_init_cseq_mip(struct asd_ha_struct *asd_ha)
446{
447
448 asd_write_reg_word(asd_ha, CSEQ_Q_EXE_HEAD, 0xFFFF);
449 asd_write_reg_word(asd_ha, CSEQ_Q_EXE_TAIL, 0xFFFF);
450 asd_write_reg_word(asd_ha, CSEQ_Q_DONE_HEAD, 0xFFFF);
451 asd_write_reg_word(asd_ha, CSEQ_Q_DONE_TAIL, 0xFFFF);
452 asd_write_reg_word(asd_ha, CSEQ_Q_SEND_HEAD, 0xFFFF);
453 asd_write_reg_word(asd_ha, CSEQ_Q_SEND_TAIL, 0xFFFF);
454 asd_write_reg_word(asd_ha, CSEQ_Q_DMA2CHIM_HEAD, 0xFFFF);
455 asd_write_reg_word(asd_ha, CSEQ_Q_DMA2CHIM_TAIL, 0xFFFF);
456 asd_write_reg_word(asd_ha, CSEQ_Q_COPY_HEAD, 0xFFFF);
457 asd_write_reg_word(asd_ha, CSEQ_Q_COPY_TAIL, 0xFFFF);
458 asd_write_reg_word(asd_ha, CSEQ_REG0, 0);
459 asd_write_reg_word(asd_ha, CSEQ_REG1, 0);
460 asd_write_reg_dword(asd_ha, CSEQ_REG2, 0);
461 asd_write_reg_byte(asd_ha, CSEQ_LINK_CTL_Q_MAP, 0);
462 {
463 u8 con = asd_read_reg_byte(asd_ha, CCONEXIST);
464 u8 val = hweight8(con);
465 asd_write_reg_byte(asd_ha, CSEQ_MAX_CSEQ_MODE, (val<<4)|val);
466 }
467 asd_write_reg_word(asd_ha, CSEQ_FREE_LIST_HACK_COUNT, 0);
468
469
470 asd_write_reg_dword(asd_ha, CSEQ_EST_NEXUS_REQ_QUEUE, 0);
471 asd_write_reg_dword(asd_ha, CSEQ_EST_NEXUS_REQ_QUEUE+4, 0);
472 asd_write_reg_dword(asd_ha, CSEQ_EST_NEXUS_REQ_COUNT, 0);
473 asd_write_reg_dword(asd_ha, CSEQ_EST_NEXUS_REQ_COUNT+4, 0);
474 asd_write_reg_word(asd_ha, CSEQ_Q_EST_NEXUS_HEAD, 0xFFFF);
475 asd_write_reg_word(asd_ha, CSEQ_Q_EST_NEXUS_TAIL, 0xFFFF);
476 asd_write_reg_word(asd_ha, CSEQ_NEED_EST_NEXUS_SCB, 0);
477 asd_write_reg_byte(asd_ha, CSEQ_EST_NEXUS_REQ_HEAD, 0);
478 asd_write_reg_byte(asd_ha, CSEQ_EST_NEXUS_REQ_TAIL, 0);
479 asd_write_reg_byte(asd_ha, CSEQ_EST_NEXUS_SCB_OFFSET, 0);
480
481
482 asd_write_reg_word(asd_ha, CSEQ_INT_ROUT_RET_ADDR0, 0);
483 asd_write_reg_word(asd_ha, CSEQ_INT_ROUT_RET_ADDR1, 0);
484 asd_write_reg_word(asd_ha, CSEQ_INT_ROUT_SCBPTR, 0);
485 asd_write_reg_byte(asd_ha, CSEQ_INT_ROUT_MODE, 0);
486 asd_write_reg_byte(asd_ha, CSEQ_ISR_SCRATCH_FLAGS, 0);
487 asd_write_reg_word(asd_ha, CSEQ_ISR_SAVE_SINDEX, 0);
488 asd_write_reg_word(asd_ha, CSEQ_ISR_SAVE_DINDEX, 0);
489 asd_write_reg_word(asd_ha, CSEQ_Q_MONIRTT_HEAD, 0xFFFF);
490 asd_write_reg_word(asd_ha, CSEQ_Q_MONIRTT_TAIL, 0xFFFF);
491
492 {
493 u16 cmdctx = asd_get_cmdctx_size(asd_ha);
494 cmdctx = (~((cmdctx/128)-1)) >> 8;
495 asd_write_reg_byte(asd_ha, CSEQ_FREE_SCB_MASK, (u8)cmdctx);
496 }
497 asd_write_reg_word(asd_ha, CSEQ_BUILTIN_FREE_SCB_HEAD,
498 first_scb_site_no);
499 asd_write_reg_word(asd_ha, CSEQ_BUILTIN_FREE_SCB_TAIL,
500 last_scb_site_no);
501 asd_write_reg_word(asd_ha, CSEQ_EXTENDED_FREE_SCB_HEAD, 0xFFFF);
502 asd_write_reg_word(asd_ha, CSEQ_EXTENDED_FREE_SCB_TAIL, 0xFFFF);
503
504
505 asd_write_reg_dword(asd_ha, CSEQ_EMPTY_REQ_QUEUE, 0);
506 asd_write_reg_dword(asd_ha, CSEQ_EMPTY_REQ_QUEUE+4, 0);
507 asd_write_reg_dword(asd_ha, CSEQ_EMPTY_REQ_COUNT, 0);
508 asd_write_reg_dword(asd_ha, CSEQ_EMPTY_REQ_COUNT+4, 0);
509 asd_write_reg_word(asd_ha, CSEQ_Q_EMPTY_HEAD, 0xFFFF);
510 asd_write_reg_word(asd_ha, CSEQ_Q_EMPTY_TAIL, 0xFFFF);
511 asd_write_reg_word(asd_ha, CSEQ_NEED_EMPTY_SCB, 0);
512 asd_write_reg_byte(asd_ha, CSEQ_EMPTY_REQ_HEAD, 0);
513 asd_write_reg_byte(asd_ha, CSEQ_EMPTY_REQ_TAIL, 0);
514 asd_write_reg_byte(asd_ha, CSEQ_EMPTY_SCB_OFFSET, 0);
515 asd_write_reg_word(asd_ha, CSEQ_PRIMITIVE_DATA, 0);
516 asd_write_reg_dword(asd_ha, CSEQ_TIMEOUT_CONST, 0);
517}
518
519
520
521
522
523static void asd_init_cseq_mdp(struct asd_ha_struct *asd_ha)
524{
525 int i;
526 int moffs;
527
528 moffs = CSEQ_PAGE_SIZE * 2;
529
530
531 for (i = 0; i < 8; i++) {
532 asd_write_reg_word(asd_ha, i*moffs+CSEQ_LRM_SAVE_SINDEX, 0);
533 asd_write_reg_word(asd_ha, i*moffs+CSEQ_LRM_SAVE_SCBPTR, 0);
534 asd_write_reg_word(asd_ha, i*moffs+CSEQ_Q_LINK_HEAD, 0xFFFF);
535 asd_write_reg_word(asd_ha, i*moffs+CSEQ_Q_LINK_TAIL, 0xFFFF);
536 asd_write_reg_byte(asd_ha, i*moffs+CSEQ_LRM_SAVE_SCRPAGE, 0);
537 }
538
539
540
541
542 asd_write_reg_word(asd_ha, CSEQ_RET_ADDR, 0xFFFF);
543 asd_write_reg_word(asd_ha, CSEQ_RET_SCBPTR, 0);
544 asd_write_reg_word(asd_ha, CSEQ_SAVE_SCBPTR, 0);
545 asd_write_reg_word(asd_ha, CSEQ_EMPTY_TRANS_CTX, 0);
546 asd_write_reg_word(asd_ha, CSEQ_RESP_LEN, 0);
547 asd_write_reg_word(asd_ha, CSEQ_TMF_SCBPTR, 0);
548 asd_write_reg_word(asd_ha, CSEQ_GLOBAL_PREV_SCB, 0);
549 asd_write_reg_word(asd_ha, CSEQ_GLOBAL_HEAD, 0);
550 asd_write_reg_word(asd_ha, CSEQ_CLEAR_LU_HEAD, 0);
551 asd_write_reg_byte(asd_ha, CSEQ_TMF_OPCODE, 0);
552 asd_write_reg_byte(asd_ha, CSEQ_SCRATCH_FLAGS, 0);
553 asd_write_reg_word(asd_ha, CSEQ_HSB_SITE, 0);
554 asd_write_reg_word(asd_ha, CSEQ_FIRST_INV_SCB_SITE,
555 (u16)last_scb_site_no+1);
556 asd_write_reg_word(asd_ha, CSEQ_FIRST_INV_DDB_SITE,
557 (u16)asd_ha->hw_prof.max_ddbs);
558
559
560 asd_write_reg_dword(asd_ha, CSEQ_LUN_TO_CLEAR, 0);
561 asd_write_reg_dword(asd_ha, CSEQ_LUN_TO_CLEAR + 4, 0);
562 asd_write_reg_dword(asd_ha, CSEQ_LUN_TO_CHECK, 0);
563 asd_write_reg_dword(asd_ha, CSEQ_LUN_TO_CHECK + 4, 0);
564
565
566
567 asd_write_reg_addr(asd_ha, CSEQ_HQ_NEW_POINTER,
568 asd_ha->seq.next_scb.dma_handle);
569 ASD_DPRINTK("First SCB dma_handle: 0x%llx\n",
570 (unsigned long long)asd_ha->seq.next_scb.dma_handle);
571
572
573 asd_write_reg_addr(asd_ha, CSEQ_HQ_DONE_BASE,
574 asd_ha->seq.actual_dl->dma_handle);
575
576
577
578 asd_write_reg_dword(asd_ha, CSEQ_HQ_DONE_POINTER,
579 ASD_BUSADDR_LO(asd_ha->seq.actual_dl->dma_handle));
580
581 asd_write_reg_byte(asd_ha, CSEQ_HQ_DONE_PASS, ASD_DEF_DL_TOGGLE);
582
583
584}
585
586
587
588
589
590
591
592
593static void asd_init_cseq_scratch(struct asd_ha_struct *asd_ha)
594{
595 asd_init_cseq_mip(asd_ha);
596 asd_init_cseq_mdp(asd_ha);
597}
598
599
600
601
602
603static void asd_init_lseq_mip(struct asd_ha_struct *asd_ha, u8 lseq)
604{
605 int i;
606
607
608 asd_write_reg_word(asd_ha, LmSEQ_Q_TGTXFR_HEAD(lseq), 0xFFFF);
609 asd_write_reg_word(asd_ha, LmSEQ_Q_TGTXFR_TAIL(lseq), 0xFFFF);
610 asd_write_reg_byte(asd_ha, LmSEQ_LINK_NUMBER(lseq), lseq);
611 asd_write_reg_byte(asd_ha, LmSEQ_SCRATCH_FLAGS(lseq),
612 ASD_NOTIFY_ENABLE_SPINUP);
613 asd_write_reg_dword(asd_ha, LmSEQ_CONNECTION_STATE(lseq),0x08000000);
614 asd_write_reg_word(asd_ha, LmSEQ_CONCTL(lseq), 0);
615 asd_write_reg_byte(asd_ha, LmSEQ_CONSTAT(lseq), 0);
616 asd_write_reg_byte(asd_ha, LmSEQ_CONNECTION_MODES(lseq), 0);
617 asd_write_reg_word(asd_ha, LmSEQ_REG1_ISR(lseq), 0);
618 asd_write_reg_word(asd_ha, LmSEQ_REG2_ISR(lseq), 0);
619 asd_write_reg_word(asd_ha, LmSEQ_REG3_ISR(lseq), 0);
620 asd_write_reg_dword(asd_ha, LmSEQ_REG0_ISR(lseq), 0);
621 asd_write_reg_dword(asd_ha, LmSEQ_REG0_ISR(lseq)+4, 0);
622
623
624 asd_write_reg_word(asd_ha, LmSEQ_EST_NEXUS_SCBPTR0(lseq), 0xFFFF);
625 asd_write_reg_word(asd_ha, LmSEQ_EST_NEXUS_SCBPTR1(lseq), 0xFFFF);
626 asd_write_reg_word(asd_ha, LmSEQ_EST_NEXUS_SCBPTR2(lseq), 0xFFFF);
627 asd_write_reg_word(asd_ha, LmSEQ_EST_NEXUS_SCBPTR3(lseq), 0xFFFF);
628 asd_write_reg_byte(asd_ha, LmSEQ_EST_NEXUS_SCB_OPCODE0(lseq), 0);
629 asd_write_reg_byte(asd_ha, LmSEQ_EST_NEXUS_SCB_OPCODE1(lseq), 0);
630 asd_write_reg_byte(asd_ha, LmSEQ_EST_NEXUS_SCB_OPCODE2(lseq), 0);
631 asd_write_reg_byte(asd_ha, LmSEQ_EST_NEXUS_SCB_OPCODE3(lseq), 0);
632 asd_write_reg_byte(asd_ha, LmSEQ_EST_NEXUS_SCB_HEAD(lseq), 0);
633 asd_write_reg_byte(asd_ha, LmSEQ_EST_NEXUS_SCB_TAIL(lseq), 0);
634 asd_write_reg_byte(asd_ha, LmSEQ_EST_NEXUS_BUF_AVAIL(lseq), 0);
635 asd_write_reg_dword(asd_ha, LmSEQ_TIMEOUT_CONST(lseq), 0);
636 asd_write_reg_word(asd_ha, LmSEQ_ISR_SAVE_SINDEX(lseq), 0);
637 asd_write_reg_word(asd_ha, LmSEQ_ISR_SAVE_DINDEX(lseq), 0);
638
639
640 asd_write_reg_word(asd_ha, LmSEQ_EMPTY_SCB_PTR0(lseq), 0xFFFF);
641 asd_write_reg_word(asd_ha, LmSEQ_EMPTY_SCB_PTR1(lseq), 0xFFFF);
642 asd_write_reg_word(asd_ha, LmSEQ_EMPTY_SCB_PTR2(lseq), 0xFFFF);
643 asd_write_reg_word(asd_ha, LmSEQ_EMPTY_SCB_PTR3(lseq), 0xFFFF);
644 asd_write_reg_byte(asd_ha, LmSEQ_EMPTY_SCB_OPCD0(lseq), 0);
645 asd_write_reg_byte(asd_ha, LmSEQ_EMPTY_SCB_OPCD1(lseq), 0);
646 asd_write_reg_byte(asd_ha, LmSEQ_EMPTY_SCB_OPCD2(lseq), 0);
647 asd_write_reg_byte(asd_ha, LmSEQ_EMPTY_SCB_OPCD3(lseq), 0);
648 asd_write_reg_byte(asd_ha, LmSEQ_EMPTY_SCB_HEAD(lseq), 0);
649 asd_write_reg_byte(asd_ha, LmSEQ_EMPTY_SCB_TAIL(lseq), 0);
650 asd_write_reg_byte(asd_ha, LmSEQ_EMPTY_BUFS_AVAIL(lseq), 0);
651 for (i = 0; i < 12; i += 4)
652 asd_write_reg_dword(asd_ha, LmSEQ_ATA_SCR_REGS(lseq) + i, 0);
653
654
655
656
657 asd_write_reg_dword(asd_ha, LmSEQ_DEV_PRES_TMR_TOUT_CONST(lseq),
658 ASD_DEV_PRESENT_TIMEOUT);
659
660
661 asd_write_reg_dword(asd_ha, LmSEQ_SATA_INTERLOCK_TIMEOUT(lseq),
662 ASD_SATA_INTERLOCK_TIMEOUT);
663
664
665
666 asd_write_reg_dword(asd_ha, LmSEQ_STP_SHUTDOWN_TIMEOUT(lseq),
667 ASD_STP_SHUTDOWN_TIMEOUT);
668
669 asd_write_reg_dword(asd_ha, LmSEQ_SRST_ASSERT_TIMEOUT(lseq),
670 ASD_SRST_ASSERT_TIMEOUT);
671
672 asd_write_reg_dword(asd_ha, LmSEQ_RCV_FIS_TIMEOUT(lseq),
673 ASD_RCV_FIS_TIMEOUT);
674
675 asd_write_reg_dword(asd_ha, LmSEQ_ONE_MILLISEC_TIMEOUT(lseq),
676 ASD_ONE_MILLISEC_TIMEOUT);
677
678
679 asd_write_reg_dword(asd_ha, LmSEQ_TEN_MS_COMINIT_TIMEOUT(lseq),
680 ASD_TEN_MILLISEC_TIMEOUT);
681
682 asd_write_reg_dword(asd_ha, LmSEQ_SMP_RCV_TIMEOUT(lseq),
683 ASD_SMP_RCV_TIMEOUT);
684}
685
686
687
688
689
690static void asd_init_lseq_mdp(struct asd_ha_struct *asd_ha, int lseq)
691{
692 int i;
693 u32 moffs;
694 u16 ret_addr[] = {
695 0xFFFF,
696 0xFFFF,
697 mode2_task,
698 0,
699 0xFFFF,
700 0xFFFF,
701 };
702
703
704
705
706
707 for (i = 0; i < 3; i++) {
708 moffs = i * LSEQ_MODE_SCRATCH_SIZE;
709 asd_write_reg_word(asd_ha, LmSEQ_RET_ADDR(lseq)+moffs,
710 ret_addr[i]);
711 asd_write_reg_word(asd_ha, LmSEQ_REG0_MODE(lseq)+moffs, 0);
712 asd_write_reg_word(asd_ha, LmSEQ_MODE_FLAGS(lseq)+moffs, 0);
713 asd_write_reg_word(asd_ha, LmSEQ_RET_ADDR2(lseq)+moffs,0xFFFF);
714 asd_write_reg_word(asd_ha, LmSEQ_RET_ADDR1(lseq)+moffs,0xFFFF);
715 asd_write_reg_byte(asd_ha, LmSEQ_OPCODE_TO_CSEQ(lseq)+moffs,0);
716 asd_write_reg_word(asd_ha, LmSEQ_DATA_TO_CSEQ(lseq)+moffs,0);
717 }
718
719
720
721 asd_write_reg_word(asd_ha,
722 LmSEQ_RET_ADDR(lseq)+LSEQ_MODE5_PAGE0_OFFSET,
723 ret_addr[5]);
724 asd_write_reg_word(asd_ha,
725 LmSEQ_REG0_MODE(lseq)+LSEQ_MODE5_PAGE0_OFFSET,0);
726 asd_write_reg_word(asd_ha,
727 LmSEQ_MODE_FLAGS(lseq)+LSEQ_MODE5_PAGE0_OFFSET, 0);
728 asd_write_reg_word(asd_ha,
729 LmSEQ_RET_ADDR2(lseq)+LSEQ_MODE5_PAGE0_OFFSET,0xFFFF);
730 asd_write_reg_word(asd_ha,
731 LmSEQ_RET_ADDR1(lseq)+LSEQ_MODE5_PAGE0_OFFSET,0xFFFF);
732 asd_write_reg_byte(asd_ha,
733 LmSEQ_OPCODE_TO_CSEQ(lseq)+LSEQ_MODE5_PAGE0_OFFSET,0);
734 asd_write_reg_word(asd_ha,
735 LmSEQ_DATA_TO_CSEQ(lseq)+LSEQ_MODE5_PAGE0_OFFSET, 0);
736
737
738 asd_write_reg_word(asd_ha, LmSEQ_FIRST_INV_DDB_SITE(lseq),
739 (u16)asd_ha->hw_prof.max_ddbs);
740 asd_write_reg_word(asd_ha, LmSEQ_EMPTY_TRANS_CTX(lseq), 0);
741 asd_write_reg_word(asd_ha, LmSEQ_RESP_LEN(lseq), 0);
742 asd_write_reg_word(asd_ha, LmSEQ_FIRST_INV_SCB_SITE(lseq),
743 (u16)last_scb_site_no+1);
744 asd_write_reg_word(asd_ha, LmSEQ_INTEN_SAVE(lseq),
745 (u16) ((LmM0INTEN_MASK & 0xFFFF0000) >> 16));
746 asd_write_reg_word(asd_ha, LmSEQ_INTEN_SAVE(lseq) + 2,
747 (u16) LmM0INTEN_MASK & 0xFFFF);
748 asd_write_reg_byte(asd_ha, LmSEQ_LINK_RST_FRM_LEN(lseq), 0);
749 asd_write_reg_byte(asd_ha, LmSEQ_LINK_RST_PROTOCOL(lseq), 0);
750 asd_write_reg_byte(asd_ha, LmSEQ_RESP_STATUS(lseq), 0);
751 asd_write_reg_byte(asd_ha, LmSEQ_LAST_LOADED_SGE(lseq), 0);
752 asd_write_reg_word(asd_ha, LmSEQ_SAVE_SCBPTR(lseq), 0);
753
754
755 asd_write_reg_word(asd_ha, LmSEQ_Q_XMIT_HEAD(lseq), 0xFFFF);
756 asd_write_reg_word(asd_ha, LmSEQ_M1_EMPTY_TRANS_CTX(lseq), 0);
757 asd_write_reg_word(asd_ha, LmSEQ_INI_CONN_TAG(lseq), 0);
758 asd_write_reg_byte(asd_ha, LmSEQ_FAILED_OPEN_STATUS(lseq), 0);
759 asd_write_reg_byte(asd_ha, LmSEQ_XMIT_REQUEST_TYPE(lseq), 0);
760 asd_write_reg_byte(asd_ha, LmSEQ_M1_RESP_STATUS(lseq), 0);
761 asd_write_reg_byte(asd_ha, LmSEQ_M1_LAST_LOADED_SGE(lseq), 0);
762 asd_write_reg_word(asd_ha, LmSEQ_M1_SAVE_SCBPTR(lseq), 0);
763
764
765 asd_write_reg_word(asd_ha, LmSEQ_PORT_COUNTER(lseq), 0);
766 asd_write_reg_word(asd_ha, LmSEQ_PM_TABLE_PTR(lseq), 0);
767 asd_write_reg_word(asd_ha, LmSEQ_SATA_INTERLOCK_TMR_SAVE(lseq), 0);
768 asd_write_reg_word(asd_ha, LmSEQ_IP_BITL(lseq), 0);
769 asd_write_reg_word(asd_ha, LmSEQ_COPY_SMP_CONN_TAG(lseq), 0);
770 asd_write_reg_byte(asd_ha, LmSEQ_P0M2_OFFS1AH(lseq), 0);
771
772
773 asd_write_reg_byte(asd_ha, LmSEQ_SAVED_OOB_STATUS(lseq), 0);
774 asd_write_reg_byte(asd_ha, LmSEQ_SAVED_OOB_MODE(lseq), 0);
775 asd_write_reg_word(asd_ha, LmSEQ_Q_LINK_HEAD(lseq), 0xFFFF);
776 asd_write_reg_byte(asd_ha, LmSEQ_LINK_RST_ERR(lseq), 0);
777 asd_write_reg_byte(asd_ha, LmSEQ_SAVED_OOB_SIGNALS(lseq), 0);
778 asd_write_reg_byte(asd_ha, LmSEQ_SAS_RESET_MODE(lseq), 0);
779 asd_write_reg_byte(asd_ha, LmSEQ_LINK_RESET_RETRY_COUNT(lseq), 0);
780 asd_write_reg_byte(asd_ha, LmSEQ_NUM_LINK_RESET_RETRIES(lseq), 0);
781 asd_write_reg_word(asd_ha, LmSEQ_OOB_INT_ENABLES(lseq), 0);
782
783
784
785
786 asd_write_reg_word(asd_ha, LmSEQ_NOTIFY_TIMER_TIMEOUT(lseq),
787 ASD_NOTIFY_TIMEOUT - 1);
788
789 asd_write_reg_word(asd_ha, LmSEQ_NOTIFY_TIMER_DOWN_COUNT(lseq),
790 ASD_NOTIFY_DOWN_COUNT);
791 asd_write_reg_word(asd_ha, LmSEQ_NOTIFY_TIMER_INITIAL_COUNT(lseq),
792 ASD_NOTIFY_DOWN_COUNT);
793
794
795 for (i = 0; i < 2; i++) {
796 int j;
797
798 moffs = LSEQ_PAGE_SIZE + i*LSEQ_MODE_SCRATCH_SIZE;
799
800 for (j = 0; j < LSEQ_PAGE_SIZE; j += 4)
801 asd_write_reg_dword(asd_ha, LmSCRATCH(lseq)+moffs+j,0);
802 }
803
804
805 asd_write_reg_dword(asd_ha, LmSEQ_INVALID_DWORD_COUNT(lseq), 0);
806 asd_write_reg_dword(asd_ha, LmSEQ_DISPARITY_ERROR_COUNT(lseq), 0);
807 asd_write_reg_dword(asd_ha, LmSEQ_LOSS_OF_SYNC_COUNT(lseq), 0);
808
809
810 for (i = 0; i < LSEQ_PAGE_SIZE; i+=4)
811 asd_write_reg_dword(asd_ha, LmSEQ_FRAME_TYPE_MASK(lseq)+i, 0);
812 asd_write_reg_byte(asd_ha, LmSEQ_FRAME_TYPE_MASK(lseq), 0xFF);
813 asd_write_reg_byte(asd_ha, LmSEQ_HASHED_DEST_ADDR_MASK(lseq), 0xFF);
814 asd_write_reg_byte(asd_ha, LmSEQ_HASHED_DEST_ADDR_MASK(lseq)+1,0xFF);
815 asd_write_reg_byte(asd_ha, LmSEQ_HASHED_DEST_ADDR_MASK(lseq)+2,0xFF);
816 asd_write_reg_byte(asd_ha, LmSEQ_HASHED_SRC_ADDR_MASK(lseq), 0xFF);
817 asd_write_reg_byte(asd_ha, LmSEQ_HASHED_SRC_ADDR_MASK(lseq)+1, 0xFF);
818 asd_write_reg_byte(asd_ha, LmSEQ_HASHED_SRC_ADDR_MASK(lseq)+2, 0xFF);
819 asd_write_reg_dword(asd_ha, LmSEQ_DATA_OFFSET(lseq), 0xFFFFFFFF);
820
821
822 asd_write_reg_dword(asd_ha, LmSEQ_SMP_RCV_TIMER_TERM_TS(lseq), 0);
823 asd_write_reg_byte(asd_ha, LmSEQ_DEVICE_BITS(lseq), 0);
824 asd_write_reg_word(asd_ha, LmSEQ_SDB_DDB(lseq), 0);
825 asd_write_reg_byte(asd_ha, LmSEQ_SDB_NUM_TAGS(lseq), 0);
826 asd_write_reg_byte(asd_ha, LmSEQ_SDB_CURR_TAG(lseq), 0);
827
828
829 asd_write_reg_dword(asd_ha, LmSEQ_TX_ID_ADDR_FRAME(lseq), 0);
830 asd_write_reg_dword(asd_ha, LmSEQ_TX_ID_ADDR_FRAME(lseq)+4, 0);
831 asd_write_reg_dword(asd_ha, LmSEQ_OPEN_TIMER_TERM_TS(lseq), 0);
832 asd_write_reg_dword(asd_ha, LmSEQ_SRST_AS_TIMER_TERM_TS(lseq), 0);
833 asd_write_reg_dword(asd_ha, LmSEQ_LAST_LOADED_SG_EL(lseq), 0);
834
835
836
837
838 asd_write_reg_dword(asd_ha, LmSEQ_STP_SHUTDOWN_TIMER_TERM_TS(lseq),0);
839 asd_write_reg_dword(asd_ha, LmSEQ_CLOSE_TIMER_TERM_TS(lseq), 0);
840 asd_write_reg_dword(asd_ha, LmSEQ_BREAK_TIMER_TERM_TS(lseq), 0);
841 asd_write_reg_dword(asd_ha, LmSEQ_DWS_RESET_TIMER_TERM_TS(lseq), 0);
842 asd_write_reg_dword(asd_ha,LmSEQ_SATA_INTERLOCK_TIMER_TERM_TS(lseq),0);
843 asd_write_reg_dword(asd_ha, LmSEQ_MCTL_TIMER_TERM_TS(lseq), 0);
844
845
846 asd_write_reg_dword(asd_ha, LmSEQ_COMINIT_TIMER_TERM_TS(lseq), 0);
847 asd_write_reg_dword(asd_ha, LmSEQ_RCV_ID_TIMER_TERM_TS(lseq), 0);
848 asd_write_reg_dword(asd_ha, LmSEQ_RCV_FIS_TIMER_TERM_TS(lseq), 0);
849 asd_write_reg_dword(asd_ha, LmSEQ_DEV_PRES_TIMER_TERM_TS(lseq), 0);
850}
851
852
853
854
855
856static void asd_init_lseq_scratch(struct asd_ha_struct *asd_ha)
857{
858 u8 lseq;
859 u8 lseq_mask;
860
861 lseq_mask = asd_ha->hw_prof.enabled_phys;
862 for_each_sequencer(lseq_mask, lseq_mask, lseq) {
863 asd_init_lseq_mip(asd_ha, lseq);
864 asd_init_lseq_mdp(asd_ha, lseq);
865 }
866}
867
868
869
870
871
872
873
874
875
876static void asd_init_scb_sites(struct asd_ha_struct *asd_ha)
877{
878 u16 site_no;
879 u16 max_scbs = 0;
880
881 for (site_no = asd_ha->hw_prof.max_scbs-1;
882 site_no != (u16) -1;
883 site_no--) {
884 u16 i;
885
886
887 for (i = 0; i < ASD_SCB_SIZE; i += 4)
888 asd_scbsite_write_dword(asd_ha, site_no, i, 0);
889
890
891 asd_scbsite_write_byte(asd_ha, site_no,
892 offsetof(struct scb_header, opcode),
893 0xFF);
894
895
896
897
898 asd_scbsite_write_byte(asd_ha, site_no, 0x49, 0x01);
899
900
901
902 if (!SCB_SITE_VALID(site_no))
903 continue;
904
905 if (last_scb_site_no == 0)
906 last_scb_site_no = site_no;
907
908
909
910
911
912
913 asd_scbsite_write_word(asd_ha, site_no, 0, first_scb_site_no);
914
915 first_scb_site_no = site_no;
916 max_scbs++;
917 }
918 asd_ha->hw_prof.max_scbs = max_scbs;
919 ASD_DPRINTK("max_scbs:%d\n", asd_ha->hw_prof.max_scbs);
920 ASD_DPRINTK("first_scb_site_no:0x%x\n", first_scb_site_no);
921 ASD_DPRINTK("last_scb_site_no:0x%x\n", last_scb_site_no);
922}
923
924
925
926
927
928static void asd_init_cseq_cio(struct asd_ha_struct *asd_ha)
929{
930 int i;
931
932 asd_write_reg_byte(asd_ha, CSEQCOMINTEN, 0);
933 asd_write_reg_byte(asd_ha, CSEQDLCTL, ASD_DL_SIZE_BITS);
934 asd_write_reg_byte(asd_ha, CSEQDLOFFS, 0);
935 asd_write_reg_byte(asd_ha, CSEQDLOFFS+1, 0);
936 asd_ha->seq.scbpro = 0;
937 asd_write_reg_dword(asd_ha, SCBPRO, 0);
938 asd_write_reg_dword(asd_ha, CSEQCON, 0);
939
940
941
942
943
944 asd_write_reg_word(asd_ha, CM11INTVEC0, cseq_vecs[0]);
945 asd_write_reg_word(asd_ha, CM11INTVEC1, cseq_vecs[1]);
946 asd_write_reg_word(asd_ha, CM11INTVEC2, cseq_vecs[2]);
947
948
949 asd_write_reg_byte(asd_ha, CARP2INTEN, EN_ARP2HALTC);
950
951
952 asd_write_reg_byte(asd_ha, CSCRATCHPAGE, 0x04);
953
954
955
956 for (i = 0; i < 9; i++)
957 asd_write_reg_byte(asd_ha, CMnSCRATCHPAGE(i), 0);
958
959
960 asd_write_reg_word(asd_ha, CPRGMCNT, cseq_idle_loop);
961
962 for (i = 0; i < 8; i++) {
963
964 asd_write_reg_dword(asd_ha, CMnINTEN(i), EN_CMnRSPMBXF);
965
966 asd_write_reg_dword(asd_ha, CMnREQMBX(i), 0);
967 }
968}
969
970
971
972
973
974static void asd_init_lseq_cio(struct asd_ha_struct *asd_ha, int lseq)
975{
976 u8 *sas_addr;
977 int i;
978
979
980 asd_write_reg_dword(asd_ha, LmARP2INTEN(lseq), EN_ARP2HALTC);
981
982 asd_write_reg_byte(asd_ha, LmSCRATCHPAGE(lseq), 0);
983
984
985 for (i = 0; i < 3; i++)
986 asd_write_reg_byte(asd_ha, LmMnSCRATCHPAGE(lseq, i), 0);
987
988
989 asd_write_reg_byte(asd_ha, LmMnSCRATCHPAGE(lseq, 5), 0);
990
991 asd_write_reg_dword(asd_ha, LmRSPMBX(lseq), 0);
992
993
994 asd_write_reg_dword(asd_ha, LmMnINTEN(lseq, 0), LmM0INTEN_MASK);
995 asd_write_reg_dword(asd_ha, LmMnINT(lseq, 0), 0xFFFFFFFF);
996
997 asd_write_reg_dword(asd_ha, LmMnINTEN(lseq, 1), LmM1INTEN_MASK);
998 asd_write_reg_dword(asd_ha, LmMnINT(lseq, 1), 0xFFFFFFFF);
999
1000 asd_write_reg_dword(asd_ha, LmMnINTEN(lseq, 2), LmM2INTEN_MASK);
1001 asd_write_reg_dword(asd_ha, LmMnINT(lseq, 2), 0xFFFFFFFF);
1002
1003 asd_write_reg_dword(asd_ha, LmMnINTEN(lseq, 5), LmM5INTEN_MASK);
1004 asd_write_reg_dword(asd_ha, LmMnINT(lseq, 5), 0xFFFFFFFF);
1005
1006
1007 asd_write_reg_byte(asd_ha, LmHWTSTATEN(lseq), LmHWTSTATEN_MASK);
1008
1009
1010 asd_write_reg_dword(asd_ha, LmPRIMSTAT0EN(lseq), LmPRIMSTAT0EN_MASK);
1011 asd_write_reg_dword(asd_ha, LmPRIMSTAT1EN(lseq), LmPRIMSTAT1EN_MASK);
1012
1013
1014 asd_write_reg_dword(asd_ha, LmFRMERREN(lseq), LmFRMERREN_MASK);
1015 asd_write_reg_byte(asd_ha, LmMnHOLDLVL(lseq, 0), 0x50);
1016
1017
1018 asd_write_reg_byte(asd_ha, LmMnXFRLVL(lseq, 0), LmMnXFRLVL_512);
1019
1020 asd_write_reg_byte(asd_ha, LmMnXFRLVL(lseq, 1), LmMnXFRLVL_256);
1021
1022
1023 asd_write_reg_word(asd_ha, LmPRGMCNT(lseq), lseq_idle_loop);
1024
1025
1026 asd_write_reg_dword(asd_ha, LmMODECTL(lseq), LmBLIND48);
1027 asd_write_reg_word(asd_ha, LmM3SATATIMER(lseq),
1028 ASD_SATA_INTERLOCK_TIMEOUT);
1029
1030 (void) asd_read_reg_dword(asd_ha, LmREQMBX(lseq));
1031
1032
1033 asd_write_reg_dword(asd_ha, LmPRMSTAT0(lseq), 0xFFFFFFFF);
1034 asd_write_reg_dword(asd_ha, LmPRMSTAT1(lseq), 0xFFFFFFFF);
1035
1036
1037 asd_write_reg_byte(asd_ha, LmHWTSTAT(lseq), 0xFF);
1038
1039
1040 asd_write_reg_byte(asd_ha, LmMnDMAERRS(lseq, 0), 0xFF);
1041 asd_write_reg_byte(asd_ha, LmMnDMAERRS(lseq, 1), 0xFF);
1042
1043
1044 asd_write_reg_byte(asd_ha, LmMnSGDMAERRS(lseq, 0), 0xFF);
1045 asd_write_reg_byte(asd_ha, LmMnSGDMAERRS(lseq, 1), 0xFF);
1046
1047
1048 asd_write_reg_byte(asd_ha, LmMnBUFSTAT(lseq, 0), LmMnBUFPERR);
1049
1050
1051 asd_write_reg_dword(asd_ha, LmMnFRMERR(lseq, 0), 0xFFFFFFFF);
1052
1053
1054 asd_write_reg_byte(asd_ha, LmARP2INTCTL(lseq), RSTINTCTL);
1055
1056
1057 sas_addr = asd_ha->phys[lseq].phy_desc->sas_addr;
1058 for (i = 0; i < SAS_ADDR_SIZE; i++)
1059 asd_write_reg_byte(asd_ha, LmWWN(lseq) + i, sas_addr[i]);
1060
1061
1062 asd_write_reg_byte(asd_ha, LmMnXMTSIZE(lseq, 1), 0);
1063
1064
1065 asd_write_reg_word(asd_ha, LmBITL_TIMER(lseq), 9);
1066
1067
1068 asd_write_reg_byte(asd_ha, LmMnSATAFS(lseq, 1), 0x80);
1069
1070
1071
1072 asd_write_reg_word(asd_ha, LmM3INTVEC0(lseq), lseq_vecs[0]);
1073 asd_write_reg_word(asd_ha, LmM3INTVEC1(lseq), lseq_vecs[1]);
1074 asd_write_reg_word(asd_ha, LmM3INTVEC2(lseq), lseq_vecs[2]);
1075 asd_write_reg_word(asd_ha, LmM3INTVEC3(lseq), lseq_vecs[3]);
1076 asd_write_reg_word(asd_ha, LmM3INTVEC4(lseq), lseq_vecs[4]);
1077 asd_write_reg_word(asd_ha, LmM3INTVEC5(lseq), lseq_vecs[5]);
1078 asd_write_reg_word(asd_ha, LmM3INTVEC6(lseq), lseq_vecs[6]);
1079 asd_write_reg_word(asd_ha, LmM3INTVEC7(lseq), lseq_vecs[7]);
1080 asd_write_reg_word(asd_ha, LmM3INTVEC8(lseq), lseq_vecs[8]);
1081 asd_write_reg_word(asd_ha, LmM3INTVEC9(lseq), lseq_vecs[9]);
1082 asd_write_reg_word(asd_ha, LmM3INTVEC10(lseq), lseq_vecs[10]);
1083
1084
1085
1086
1087 asd_write_reg_dword(asd_ha, LmCONTROL(lseq),
1088 (LEDTIMER | LEDMODE_TXRX | LEDTIMERS_100ms));
1089
1090
1091 asd_write_reg_byte(asd_ha, LmM1SASALIGN(lseq), SAS_ALIGN_DEFAULT);
1092 asd_write_reg_byte(asd_ha, LmM1STPALIGN(lseq), STP_ALIGN_DEFAULT);
1093}
1094
1095
1096
1097
1098
1099
1100static void asd_post_init_cseq(struct asd_ha_struct *asd_ha)
1101{
1102 int i;
1103
1104 for (i = 0; i < 8; i++)
1105 asd_write_reg_dword(asd_ha, CMnINT(i), 0xFFFFFFFF);
1106 for (i = 0; i < 8; i++)
1107 asd_read_reg_dword(asd_ha, CMnRSPMBX(i));
1108
1109 asd_write_reg_byte(asd_ha, CARP2INTCTL, RSTINTCTL);
1110}
1111
1112
1113
1114
1115
1116
1117
1118static void asd_init_ddb_0(struct asd_ha_struct *asd_ha)
1119{
1120 int i;
1121
1122
1123 for (i = 0; i < sizeof(struct asd_ddb_seq_shared); i+=4)
1124 asd_ddbsite_write_dword(asd_ha, 0, i, 0);
1125
1126 asd_ddbsite_write_word(asd_ha, 0,
1127 offsetof(struct asd_ddb_seq_shared, q_free_ddb_head), 0);
1128 asd_ddbsite_write_word(asd_ha, 0,
1129 offsetof(struct asd_ddb_seq_shared, q_free_ddb_tail),
1130 asd_ha->hw_prof.max_ddbs-1);
1131 asd_ddbsite_write_word(asd_ha, 0,
1132 offsetof(struct asd_ddb_seq_shared, q_free_ddb_cnt), 0);
1133 asd_ddbsite_write_word(asd_ha, 0,
1134 offsetof(struct asd_ddb_seq_shared, q_used_ddb_head), 0xFFFF);
1135 asd_ddbsite_write_word(asd_ha, 0,
1136 offsetof(struct asd_ddb_seq_shared, q_used_ddb_tail), 0xFFFF);
1137 asd_ddbsite_write_word(asd_ha, 0,
1138 offsetof(struct asd_ddb_seq_shared, shared_mem_lock), 0);
1139 asd_ddbsite_write_word(asd_ha, 0,
1140 offsetof(struct asd_ddb_seq_shared, smp_conn_tag), 0);
1141 asd_ddbsite_write_word(asd_ha, 0,
1142 offsetof(struct asd_ddb_seq_shared, est_nexus_buf_cnt), 0);
1143 asd_ddbsite_write_word(asd_ha, 0,
1144 offsetof(struct asd_ddb_seq_shared, est_nexus_buf_thresh),
1145 asd_ha->hw_prof.num_phys * 2);
1146 asd_ddbsite_write_byte(asd_ha, 0,
1147 offsetof(struct asd_ddb_seq_shared, settable_max_contexts),0);
1148 asd_ddbsite_write_byte(asd_ha, 0,
1149 offsetof(struct asd_ddb_seq_shared, conn_not_active), 0xFF);
1150 asd_ddbsite_write_byte(asd_ha, 0,
1151 offsetof(struct asd_ddb_seq_shared, phy_is_up), 0x00);
1152
1153 set_bit(0, asd_ha->hw_prof.ddb_bitmap);
1154}
1155
1156static void asd_seq_init_ddb_sites(struct asd_ha_struct *asd_ha)
1157{
1158 unsigned int i;
1159 unsigned int ddb_site;
1160
1161 for (ddb_site = 0 ; ddb_site < ASD_MAX_DDBS; ddb_site++)
1162 for (i = 0; i < sizeof(struct asd_ddb_ssp_smp_target_port); i+= 4)
1163 asd_ddbsite_write_dword(asd_ha, ddb_site, i, 0);
1164}
1165
1166
1167
1168
1169
1170static void asd_seq_setup_seqs(struct asd_ha_struct *asd_ha)
1171{
1172 int lseq;
1173 u8 lseq_mask;
1174
1175
1176 asd_seq_init_ddb_sites(asd_ha);
1177
1178
1179
1180 asd_init_scb_sites(asd_ha);
1181
1182
1183 asd_init_cseq_scratch(asd_ha);
1184
1185
1186 asd_init_lseq_scratch(asd_ha);
1187
1188
1189 asd_init_cseq_cio(asd_ha);
1190
1191 asd_init_ddb_0(asd_ha);
1192
1193
1194 lseq_mask = asd_ha->hw_prof.enabled_phys;
1195 for_each_sequencer(lseq_mask, lseq_mask, lseq)
1196 asd_init_lseq_cio(asd_ha, lseq);
1197 asd_post_init_cseq(asd_ha);
1198}
1199
1200
1201
1202
1203
1204
1205static int asd_seq_start_cseq(struct asd_ha_struct *asd_ha)
1206{
1207
1208 asd_write_reg_word(asd_ha, CPRGMCNT, cseq_idle_loop);
1209
1210
1211 return asd_unpause_cseq(asd_ha);
1212}
1213
1214
1215
1216
1217
1218
1219static int asd_seq_start_lseq(struct asd_ha_struct *asd_ha, int lseq)
1220{
1221
1222 asd_write_reg_word(asd_ha, LmPRGMCNT(lseq), lseq_idle_loop);
1223
1224
1225 return asd_seq_unpause_lseq(asd_ha, lseq);
1226}
1227
1228int asd_release_firmware(void)
1229{
1230 if (sequencer_fw)
1231 release_firmware(sequencer_fw);
1232 return 0;
1233}
1234
1235static int asd_request_firmware(struct asd_ha_struct *asd_ha)
1236{
1237 int err, i;
1238 struct sequencer_file_header header;
1239 const struct sequencer_file_header *hdr_ptr;
1240 u32 csum = 0;
1241 u16 *ptr_cseq_vecs, *ptr_lseq_vecs;
1242
1243 if (sequencer_fw)
1244
1245 return 0;
1246
1247 err = request_firmware(&sequencer_fw,
1248 SAS_RAZOR_SEQUENCER_FW_FILE,
1249 &asd_ha->pcidev->dev);
1250 if (err)
1251 return err;
1252
1253 hdr_ptr = (const struct sequencer_file_header *)sequencer_fw->data;
1254
1255 header.csum = le32_to_cpu(hdr_ptr->csum);
1256 header.major = le32_to_cpu(hdr_ptr->major);
1257 header.minor = le32_to_cpu(hdr_ptr->minor);
1258 header.cseq_table_offset = le32_to_cpu(hdr_ptr->cseq_table_offset);
1259 header.cseq_table_size = le32_to_cpu(hdr_ptr->cseq_table_size);
1260 header.lseq_table_offset = le32_to_cpu(hdr_ptr->lseq_table_offset);
1261 header.lseq_table_size = le32_to_cpu(hdr_ptr->lseq_table_size);
1262 header.cseq_code_offset = le32_to_cpu(hdr_ptr->cseq_code_offset);
1263 header.cseq_code_size = le32_to_cpu(hdr_ptr->cseq_code_size);
1264 header.lseq_code_offset = le32_to_cpu(hdr_ptr->lseq_code_offset);
1265 header.lseq_code_size = le32_to_cpu(hdr_ptr->lseq_code_size);
1266 header.mode2_task = le16_to_cpu(hdr_ptr->mode2_task);
1267 header.cseq_idle_loop = le16_to_cpu(hdr_ptr->cseq_idle_loop);
1268 header.lseq_idle_loop = le16_to_cpu(hdr_ptr->lseq_idle_loop);
1269
1270 for (i = sizeof(header.csum); i < sequencer_fw->size; i++)
1271 csum += sequencer_fw->data[i];
1272
1273 if (csum != header.csum) {
1274 asd_printk("Firmware file checksum mismatch\n");
1275 return -EINVAL;
1276 }
1277
1278 if (header.cseq_table_size != CSEQ_NUM_VECS ||
1279 header.lseq_table_size != LSEQ_NUM_VECS) {
1280 asd_printk("Firmware file table size mismatch\n");
1281 return -EINVAL;
1282 }
1283
1284 asd_printk("Found sequencer Firmware version %d.%d (%s)\n",
1285 header.major, header.minor, hdr_ptr->version);
1286
1287 if (header.major != SAS_RAZOR_SEQUENCER_FW_MAJOR) {
1288 asd_printk("Firmware Major Version Mismatch;"
1289 "driver requires version %d.X",
1290 SAS_RAZOR_SEQUENCER_FW_MAJOR);
1291 return -EINVAL;
1292 }
1293
1294 ptr_cseq_vecs = (u16 *)&sequencer_fw->data[header.cseq_table_offset];
1295 ptr_lseq_vecs = (u16 *)&sequencer_fw->data[header.lseq_table_offset];
1296 mode2_task = header.mode2_task;
1297 cseq_idle_loop = header.cseq_idle_loop;
1298 lseq_idle_loop = header.lseq_idle_loop;
1299
1300 for (i = 0; i < CSEQ_NUM_VECS; i++)
1301 cseq_vecs[i] = le16_to_cpu(ptr_cseq_vecs[i]);
1302
1303 for (i = 0; i < LSEQ_NUM_VECS; i++)
1304 lseq_vecs[i] = le16_to_cpu(ptr_lseq_vecs[i]);
1305
1306 cseq_code = &sequencer_fw->data[header.cseq_code_offset];
1307 cseq_code_size = header.cseq_code_size;
1308 lseq_code = &sequencer_fw->data[header.lseq_code_offset];
1309 lseq_code_size = header.lseq_code_size;
1310
1311 return 0;
1312}
1313
1314int asd_init_seqs(struct asd_ha_struct *asd_ha)
1315{
1316 int err;
1317
1318 err = asd_request_firmware(asd_ha);
1319
1320 if (err) {
1321 asd_printk("Failed to load sequencer firmware file %s, error %d\n",
1322 SAS_RAZOR_SEQUENCER_FW_FILE, err);
1323 return err;
1324 }
1325
1326 err = asd_seq_download_seqs(asd_ha);
1327 if (err) {
1328 asd_printk("couldn't download sequencers for %s\n",
1329 pci_name(asd_ha->pcidev));
1330 return err;
1331 }
1332
1333 asd_seq_setup_seqs(asd_ha);
1334
1335 return 0;
1336}
1337
1338int asd_start_seqs(struct asd_ha_struct *asd_ha)
1339{
1340 int err;
1341 u8 lseq_mask;
1342 int lseq;
1343
1344 err = asd_seq_start_cseq(asd_ha);
1345 if (err) {
1346 asd_printk("couldn't start CSEQ for %s\n",
1347 pci_name(asd_ha->pcidev));
1348 return err;
1349 }
1350
1351 lseq_mask = asd_ha->hw_prof.enabled_phys;
1352 for_each_sequencer(lseq_mask, lseq_mask, lseq) {
1353 err = asd_seq_start_lseq(asd_ha, lseq);
1354 if (err) {
1355 asd_printk("coudln't start LSEQ %d for %s\n", lseq,
1356 pci_name(asd_ha->pcidev));
1357 return err;
1358 }
1359 }
1360
1361 return 0;
1362}
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381void asd_update_port_links(struct asd_ha_struct *asd_ha, struct asd_phy *phy)
1382{
1383 const u8 phy_mask = (u8) phy->asd_port->phy_mask;
1384 u8 phy_is_up;
1385 u8 mask;
1386 int i, err;
1387 unsigned long flags;
1388
1389 spin_lock_irqsave(&asd_ha->hw_prof.ddb_lock, flags);
1390 for_each_phy(phy_mask, mask, i)
1391 asd_ddbsite_write_byte(asd_ha, 0,
1392 offsetof(struct asd_ddb_seq_shared,
1393 port_map_by_links)+i,phy_mask);
1394
1395 for (i = 0; i < 12; i++) {
1396 phy_is_up = asd_ddbsite_read_byte(asd_ha, 0,
1397 offsetof(struct asd_ddb_seq_shared, phy_is_up));
1398 err = asd_ddbsite_update_byte(asd_ha, 0,
1399 offsetof(struct asd_ddb_seq_shared, phy_is_up),
1400 phy_is_up,
1401 phy_is_up | phy_mask);
1402 if (!err)
1403 break;
1404 else if (err == -EFAULT) {
1405 asd_printk("phy_is_up: parity error in DDB 0\n");
1406 break;
1407 }
1408 }
1409 spin_unlock_irqrestore(&asd_ha->hw_prof.ddb_lock, flags);
1410
1411 if (err)
1412 asd_printk("couldn't update DDB 0:error:%d\n", err);
1413}
1414
1415MODULE_FIRMWARE(SAS_RAZOR_SEQUENCER_FW_FILE);
1416