2 * IBM Accelerator Family 'GenWQE'
4 * (C) Copyright IBM Corp. 2013
6 * Author: Frank Haverkamp <haver@linux.vnet.ibm.com>
7 * Author: Joerg-Stephan Vogt <jsvogt@de.ibm.com>
8 * Author: Michael Jung <mijung@de.ibm.com>
9 * Author: Michael Ruettger <michael@ibmra.de>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License (version 2 only)
13 * as published by the Free Software Foundation.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
22 * Miscelanous functionality used in the other GenWQE driver parts.
25 #include <linux/kernel.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/sched.h>
28 #include <linux/vmalloc.h>
29 #include <linux/page-flags.h>
30 #include <linux/scatterlist.h>
31 #include <linux/hugetlb.h>
32 #include <linux/iommu.h>
33 #include <linux/delay.h>
34 #include <linux/pci.h>
35 #include <linux/dma-mapping.h>
36 #include <linux/ctype.h>
37 #include <linux/module.h>
38 #include <linux/platform_device.h>
39 #include <linux/delay.h>
40 #include <asm/pgtable.h>
42 #include "genwqe_driver.h"
43 #include "card_base.h"
44 #include "card_ddcb.h"
47 * __genwqe_writeq() - Write 64-bit register
48 * @cd: genwqe device descriptor
49 * @byte_offs: byte offset within BAR
52 * Return: 0 if success; < 0 if error
54 int __genwqe_writeq(struct genwqe_dev
*cd
, u64 byte_offs
, u64 val
)
56 if (cd
->err_inject
& GENWQE_INJECT_HARDWARE_FAILURE
)
62 __raw_writeq((__force u64
)cpu_to_be64(val
), cd
->mmio
+ byte_offs
);
67 * __genwqe_readq() - Read 64-bit register
68 * @cd: genwqe device descriptor
69 * @byte_offs: offset within BAR
71 * Return: value from register
73 u64
__genwqe_readq(struct genwqe_dev
*cd
, u64 byte_offs
)
75 if (cd
->err_inject
& GENWQE_INJECT_HARDWARE_FAILURE
)
76 return 0xffffffffffffffffull
;
78 if ((cd
->err_inject
& GENWQE_INJECT_GFIR_FATAL
) &&
79 (byte_offs
== IO_SLC_CFGREG_GFIR
))
80 return 0x000000000000ffffull
;
82 if ((cd
->err_inject
& GENWQE_INJECT_GFIR_INFO
) &&
83 (byte_offs
== IO_SLC_CFGREG_GFIR
))
84 return 0x00000000ffff0000ull
;
87 return 0xffffffffffffffffull
;
89 return be64_to_cpu((__force __be64
)__raw_readq(cd
->mmio
+ byte_offs
));
93 * __genwqe_writel() - Write 32-bit register
94 * @cd: genwqe device descriptor
95 * @byte_offs: byte offset within BAR
98 * Return: 0 if success; < 0 if error
100 int __genwqe_writel(struct genwqe_dev
*cd
, u64 byte_offs
, u32 val
)
102 if (cd
->err_inject
& GENWQE_INJECT_HARDWARE_FAILURE
)
105 if (cd
->mmio
== NULL
)
108 __raw_writel((__force u32
)cpu_to_be32(val
), cd
->mmio
+ byte_offs
);
113 * __genwqe_readl() - Read 32-bit register
114 * @cd: genwqe device descriptor
115 * @byte_offs: offset within BAR
117 * Return: Value from register
119 u32
__genwqe_readl(struct genwqe_dev
*cd
, u64 byte_offs
)
121 if (cd
->err_inject
& GENWQE_INJECT_HARDWARE_FAILURE
)
124 if (cd
->mmio
== NULL
)
127 return be32_to_cpu((__force __be32
)__raw_readl(cd
->mmio
+ byte_offs
));
131 * genwqe_read_app_id() - Extract app_id
133 * app_unitcfg need to be filled with valid data first
135 int genwqe_read_app_id(struct genwqe_dev
*cd
, char *app_name
, int len
)
138 u32 app_id
= (u32
)cd
->app_unitcfg
;
140 memset(app_name
, 0, len
);
141 for (i
= 0, j
= 0; j
< min(len
, 4); j
++) {
142 char ch
= (char)((app_id
>> (24 - j
*8)) & 0xff);
145 app_name
[i
++] = isprint(ch
) ? ch
: 'X';
151 * genwqe_init_crc32() - Prepare a lookup table for fast crc32 calculations
153 * Existing kernel functions seem to use a different polynom,
154 * therefore we could not use them here.
156 * Genwqe's Polynomial = 0x20044009
158 #define CRC32_POLYNOMIAL 0x20044009
159 static u32 crc32_tab
[256]; /* crc32 lookup table */
161 void genwqe_init_crc32(void)
166 for (i
= 0; i
< 256; i
++) {
168 for (j
= 0; j
< 8; j
++) {
169 if (crc
& 0x80000000)
170 crc
= (crc
<< 1) ^ CRC32_POLYNOMIAL
;
179 * genwqe_crc32() - Generate 32-bit crc as required for DDCBs
180 * @buff: pointer to data buffer
181 * @len: length of data for calculation
182 * @init: initial crc (0xffffffff at start)
184 * polynomial = x^32 * + x^29 + x^18 + x^14 + x^3 + 1 (0x20044009)
186 * Example: 4 bytes 0x01 0x02 0x03 0x04 with init=0xffffffff should
187 * result in a crc32 of 0xf33cb7d3.
189 * The existing kernel crc functions did not cover this polynom yet.
191 * Return: crc32 checksum.
193 u32
genwqe_crc32(u8
*buff
, size_t len
, u32 init
)
200 i
= ((crc
>> 24) ^ *buff
++) & 0xFF;
201 crc
= (crc
<< 8) ^ crc32_tab
[i
];
206 void *__genwqe_alloc_consistent(struct genwqe_dev
*cd
, size_t size
,
207 dma_addr_t
*dma_handle
)
209 if (get_order(size
) > MAX_ORDER
)
212 return pci_alloc_consistent(cd
->pci_dev
, size
, dma_handle
);
215 void __genwqe_free_consistent(struct genwqe_dev
*cd
, size_t size
,
216 void *vaddr
, dma_addr_t dma_handle
)
221 pci_free_consistent(cd
->pci_dev
, size
, vaddr
, dma_handle
);
224 static void genwqe_unmap_pages(struct genwqe_dev
*cd
, dma_addr_t
*dma_list
,
228 struct pci_dev
*pci_dev
= cd
->pci_dev
;
230 for (i
= 0; (i
< num_pages
) && (dma_list
[i
] != 0x0); i
++) {
231 pci_unmap_page(pci_dev
, dma_list
[i
],
232 PAGE_SIZE
, PCI_DMA_BIDIRECTIONAL
);
237 static int genwqe_map_pages(struct genwqe_dev
*cd
,
238 struct page
**page_list
, int num_pages
,
239 dma_addr_t
*dma_list
)
242 struct pci_dev
*pci_dev
= cd
->pci_dev
;
244 /* establish DMA mapping for requested pages */
245 for (i
= 0; i
< num_pages
; i
++) {
249 daddr
= pci_map_page(pci_dev
, page_list
[i
],
252 PCI_DMA_BIDIRECTIONAL
); /* FIXME rd/rw */
254 if (pci_dma_mapping_error(pci_dev
, daddr
)) {
255 dev_err(&pci_dev
->dev
,
256 "[%s] err: no dma addr daddr=%016llx!\n",
257 __func__
, (long long)daddr
);
266 genwqe_unmap_pages(cd
, dma_list
, num_pages
);
270 static int genwqe_sgl_size(int num_pages
)
272 int len
, num_tlb
= num_pages
/ 7;
274 len
= sizeof(struct sg_entry
) * (num_pages
+num_tlb
+ 1);
275 return roundup(len
, PAGE_SIZE
);
279 * genwqe_alloc_sync_sgl() - Allocate memory for sgl and overlapping pages
281 * Allocates memory for sgl and overlapping pages. Pages which might
282 * overlap other user-space memory blocks are being cached for DMAs,
283 * such that we do not run into syncronization issues. Data is copied
284 * from user-space into the cached pages.
286 int genwqe_alloc_sync_sgl(struct genwqe_dev
*cd
, struct genwqe_sgl
*sgl
,
287 void __user
*user_addr
, size_t user_size
)
290 struct pci_dev
*pci_dev
= cd
->pci_dev
;
292 sgl
->fpage_offs
= offset_in_page((unsigned long)user_addr
);
293 sgl
->fpage_size
= min_t(size_t, PAGE_SIZE
-sgl
->fpage_offs
, user_size
);
294 sgl
->nr_pages
= DIV_ROUND_UP(sgl
->fpage_offs
+ user_size
, PAGE_SIZE
);
295 sgl
->lpage_size
= (user_size
- sgl
->fpage_size
) % PAGE_SIZE
;
297 dev_dbg(&pci_dev
->dev
, "[%s] uaddr=%p usize=%8ld nr_pages=%ld "
298 "fpage_offs=%lx fpage_size=%ld lpage_size=%ld\n",
299 __func__
, user_addr
, user_size
, sgl
->nr_pages
,
300 sgl
->fpage_offs
, sgl
->fpage_size
, sgl
->lpage_size
);
302 sgl
->user_addr
= user_addr
;
303 sgl
->user_size
= user_size
;
304 sgl
->sgl_size
= genwqe_sgl_size(sgl
->nr_pages
);
306 if (get_order(sgl
->sgl_size
) > MAX_ORDER
) {
307 dev_err(&pci_dev
->dev
,
308 "[%s] err: too much memory requested!\n", __func__
);
312 sgl
->sgl
= __genwqe_alloc_consistent(cd
, sgl
->sgl_size
,
314 if (sgl
->sgl
== NULL
) {
315 dev_err(&pci_dev
->dev
,
316 "[%s] err: no memory available!\n", __func__
);
320 /* Only use buffering on incomplete pages */
321 if ((sgl
->fpage_size
!= 0) && (sgl
->fpage_size
!= PAGE_SIZE
)) {
322 sgl
->fpage
= __genwqe_alloc_consistent(cd
, PAGE_SIZE
,
323 &sgl
->fpage_dma_addr
);
324 if (sgl
->fpage
== NULL
)
327 /* Sync with user memory */
328 if (copy_from_user(sgl
->fpage
+ sgl
->fpage_offs
,
329 user_addr
, sgl
->fpage_size
)) {
334 if (sgl
->lpage_size
!= 0) {
335 sgl
->lpage
= __genwqe_alloc_consistent(cd
, PAGE_SIZE
,
336 &sgl
->lpage_dma_addr
);
337 if (sgl
->lpage
== NULL
)
340 /* Sync with user memory */
341 if (copy_from_user(sgl
->lpage
, user_addr
+ user_size
-
342 sgl
->lpage_size
, sgl
->lpage_size
)) {
350 __genwqe_free_consistent(cd
, PAGE_SIZE
, sgl
->fpage
,
351 sgl
->fpage_dma_addr
);
353 __genwqe_free_consistent(cd
, sgl
->sgl_size
, sgl
->sgl
,
358 int genwqe_setup_sgl(struct genwqe_dev
*cd
, struct genwqe_sgl
*sgl
,
359 dma_addr_t
*dma_list
)
362 unsigned long dma_offs
, map_offs
;
363 dma_addr_t prev_daddr
= 0;
364 struct sg_entry
*s
, *last_s
= NULL
;
365 size_t size
= sgl
->user_size
;
367 dma_offs
= 128; /* next block if needed/dma_offset */
368 map_offs
= sgl
->fpage_offs
; /* offset in first page */
370 s
= &sgl
->sgl
[0]; /* first set of 8 entries */
372 while (p
< sgl
->nr_pages
) {
374 unsigned int size_to_map
;
376 /* always write the chaining entry, cleanup is done later */
378 s
[j
].target_addr
= cpu_to_be64(sgl
->sgl_dma_addr
+ dma_offs
);
379 s
[j
].len
= cpu_to_be32(128);
380 s
[j
].flags
= cpu_to_be32(SG_CHAINED
);
384 /* DMA mapping for requested page, offs, size */
385 size_to_map
= min(size
, PAGE_SIZE
- map_offs
);
387 if ((p
== 0) && (sgl
->fpage
!= NULL
)) {
388 daddr
= sgl
->fpage_dma_addr
+ map_offs
;
390 } else if ((p
== sgl
->nr_pages
- 1) &&
391 (sgl
->lpage
!= NULL
)) {
392 daddr
= sgl
->lpage_dma_addr
;
394 daddr
= dma_list
[p
] + map_offs
;
400 if (prev_daddr
== daddr
) {
401 u32 prev_len
= be32_to_cpu(last_s
->len
);
403 /* pr_info("daddr combining: "
404 "%016llx/%08x -> %016llx\n",
405 prev_daddr, prev_len, daddr); */
407 last_s
->len
= cpu_to_be32(prev_len
+
410 p
++; /* process next page */
411 if (p
== sgl
->nr_pages
)
412 goto fixup
; /* nothing to do */
414 prev_daddr
= daddr
+ size_to_map
;
418 /* start new entry */
419 s
[j
].target_addr
= cpu_to_be64(daddr
);
420 s
[j
].len
= cpu_to_be32(size_to_map
);
421 s
[j
].flags
= cpu_to_be32(SG_DATA
);
422 prev_daddr
= daddr
+ size_to_map
;
426 p
++; /* process next page */
427 if (p
== sgl
->nr_pages
)
428 goto fixup
; /* nothing to do */
431 s
+= 8; /* continue 8 elements further */
434 if (j
== 1) { /* combining happend on last entry! */
435 s
-= 8; /* full shift needed on previous sgl block */
436 j
= 7; /* shift all elements */
439 for (i
= 0; i
< j
; i
++) /* move elements 1 up */
442 s
[i
].target_addr
= cpu_to_be64(0);
443 s
[i
].len
= cpu_to_be32(0);
444 s
[i
].flags
= cpu_to_be32(SG_END_LIST
);
449 * genwqe_free_sync_sgl() - Free memory for sgl and overlapping pages
451 * After the DMA transfer has been completed we free the memory for
452 * the sgl and the cached pages. Data is being transfered from cached
453 * pages into user-space buffers.
455 int genwqe_free_sync_sgl(struct genwqe_dev
*cd
, struct genwqe_sgl
*sgl
)
458 struct pci_dev
*pci_dev
= cd
->pci_dev
;
461 if (copy_to_user(sgl
->user_addr
, sgl
->fpage
+ sgl
->fpage_offs
,
463 dev_err(&pci_dev
->dev
, "[%s] err: copying fpage!\n",
467 __genwqe_free_consistent(cd
, PAGE_SIZE
, sgl
->fpage
,
468 sgl
->fpage_dma_addr
);
470 sgl
->fpage_dma_addr
= 0;
473 if (copy_to_user(sgl
->user_addr
+ sgl
->user_size
-
474 sgl
->lpage_size
, sgl
->lpage
,
476 dev_err(&pci_dev
->dev
, "[%s] err: copying lpage!\n",
480 __genwqe_free_consistent(cd
, PAGE_SIZE
, sgl
->lpage
,
481 sgl
->lpage_dma_addr
);
483 sgl
->lpage_dma_addr
= 0;
485 __genwqe_free_consistent(cd
, sgl
->sgl_size
, sgl
->sgl
,
489 sgl
->sgl_dma_addr
= 0x0;
495 * free_user_pages() - Give pinned pages back
497 * Documentation of get_user_pages is in mm/memory.c:
499 * If the page is written to, set_page_dirty (or set_page_dirty_lock,
500 * as appropriate) must be called after the page is finished with, and
501 * before put_page is called.
503 * FIXME Could be of use to others and might belong in the generic
504 * code, if others agree. E.g.
505 * ll_free_user_pages in drivers/staging/lustre/lustre/llite/rw26.c
506 * ceph_put_page_vector in net/ceph/pagevec.c
509 static int free_user_pages(struct page
**page_list
, unsigned int nr_pages
,
514 for (i
= 0; i
< nr_pages
; i
++) {
515 if (page_list
[i
] != NULL
) {
517 set_page_dirty_lock(page_list
[i
]);
518 put_page(page_list
[i
]);
525 * genwqe_user_vmap() - Map user-space memory to virtual kernel memory
526 * @cd: pointer to genwqe device
528 * @uaddr: user virtual address
529 * @size: size of memory to be mapped
531 * We need to think about how we could speed this up. Of course it is
532 * not a good idea to do this over and over again, like we are
533 * currently doing it. Nevertheless, I am curious where on the path
534 * the performance is spend. Most probably within the memory
535 * allocation functions, but maybe also in the DMA mapping code.
537 * Restrictions: The maximum size of the possible mapping currently depends
538 * on the amount of memory we can get using kzalloc() for the
539 * page_list and pci_alloc_consistent for the sg_list.
540 * The sg_list is currently itself not scattered, which could
541 * be fixed with some effort. The page_list must be split into
542 * PAGE_SIZE chunks too. All that will make the complicated
543 * code more complicated.
545 * Return: 0 if success
547 int genwqe_user_vmap(struct genwqe_dev
*cd
, struct dma_mapping
*m
, void *uaddr
,
548 unsigned long size
, struct ddcb_requ
*req
)
551 unsigned long data
, offs
;
552 struct pci_dev
*pci_dev
= cd
->pci_dev
;
554 if ((uaddr
== NULL
) || (size
== 0)) {
555 m
->size
= 0; /* mark unused and not added */
561 /* determine space needed for page_list. */
562 data
= (unsigned long)uaddr
;
563 offs
= offset_in_page(data
);
564 m
->nr_pages
= DIV_ROUND_UP(offs
+ size
, PAGE_SIZE
);
566 m
->page_list
= kcalloc(m
->nr_pages
,
567 sizeof(struct page
*) + sizeof(dma_addr_t
),
570 dev_err(&pci_dev
->dev
, "err: alloc page_list failed\n");
573 m
->size
= 0; /* mark unused and not added */
576 m
->dma_list
= (dma_addr_t
*)(m
->page_list
+ m
->nr_pages
);
578 /* pin user pages in memory */
579 rc
= get_user_pages_fast(data
& PAGE_MASK
, /* page aligned addr */
581 1, /* write by caller */
582 m
->page_list
); /* ptrs to pages */
584 /* assumption: get_user_pages can be killed by signals. */
585 if (rc
< m
->nr_pages
) {
586 free_user_pages(m
->page_list
, rc
, 0);
588 goto fail_get_user_pages
;
591 rc
= genwqe_map_pages(cd
, m
->page_list
, m
->nr_pages
, m
->dma_list
);
593 goto fail_free_user_pages
;
597 fail_free_user_pages
:
598 free_user_pages(m
->page_list
, m
->nr_pages
, 0);
606 m
->size
= 0; /* mark unused and not added */
611 * genwqe_user_vunmap() - Undo mapping of user-space mem to virtual kernel
613 * @cd: pointer to genwqe device
616 int genwqe_user_vunmap(struct genwqe_dev
*cd
, struct dma_mapping
*m
,
617 struct ddcb_requ
*req
)
619 struct pci_dev
*pci_dev
= cd
->pci_dev
;
621 if (!dma_mapping_used(m
)) {
622 dev_err(&pci_dev
->dev
, "[%s] err: mapping %p not used!\n",
628 genwqe_unmap_pages(cd
, m
->dma_list
, m
->nr_pages
);
631 free_user_pages(m
->page_list
, m
->nr_pages
, 1);
640 m
->size
= 0; /* mark as unused and not added */
645 * genwqe_card_type() - Get chip type SLU Configuration Register
646 * @cd: pointer to the genwqe device descriptor
647 * Return: 0: Altera Stratix-IV 230
648 * 1: Altera Stratix-IV 530
649 * 2: Altera Stratix-V A4
650 * 3: Altera Stratix-V A7
652 u8
genwqe_card_type(struct genwqe_dev
*cd
)
654 u64 card_type
= cd
->slu_unitcfg
;
655 return (u8
)((card_type
& IO_SLU_UNITCFG_TYPE_MASK
) >> 20);
659 * genwqe_card_reset() - Reset the card
660 * @cd: pointer to the genwqe device descriptor
662 int genwqe_card_reset(struct genwqe_dev
*cd
)
665 struct pci_dev
*pci_dev
= cd
->pci_dev
;
667 if (!genwqe_is_privileged(cd
))
671 __genwqe_writeq(cd
, IO_SLC_CFGREG_SOFTRESET
, 0x1ull
);
673 __genwqe_readq(cd
, IO_HSU_FIR_CLR
);
674 __genwqe_readq(cd
, IO_APP_FIR_CLR
);
675 __genwqe_readq(cd
, IO_SLU_FIR_CLR
);
678 * Read-modify-write to preserve the stealth bits
680 * For SL >= 039, Stealth WE bit allows removing
681 * the read-modify-wrote.
682 * r-m-w may require a mask 0x3C to avoid hitting hard
683 * reset again for error reset (should be 0, chicken).
685 softrst
= __genwqe_readq(cd
, IO_SLC_CFGREG_SOFTRESET
) & 0x3cull
;
686 __genwqe_writeq(cd
, IO_SLC_CFGREG_SOFTRESET
, softrst
| 0x2ull
);
688 /* give ERRORRESET some time to finish */
691 if (genwqe_need_err_masking(cd
)) {
692 dev_info(&pci_dev
->dev
,
693 "[%s] masking errors for old bitstreams\n", __func__
);
694 __genwqe_writeq(cd
, IO_SLC_MISC_DEBUG
, 0x0aull
);
699 int genwqe_read_softreset(struct genwqe_dev
*cd
)
703 if (!genwqe_is_privileged(cd
))
706 bitstream
= __genwqe_readq(cd
, IO_SLU_BITSTREAM
) & 0x1;
707 cd
->softreset
= (bitstream
== 0) ? 0x8ull
: 0xcull
;
712 * genwqe_set_interrupt_capability() - Configure MSI capability structure
713 * @cd: pointer to the device
714 * Return: 0 if no error
716 int genwqe_set_interrupt_capability(struct genwqe_dev
*cd
, int count
)
719 struct pci_dev
*pci_dev
= cd
->pci_dev
;
721 rc
= pci_enable_msi_block(pci_dev
, count
);
723 cd
->flags
|= GENWQE_FLAG_MSI_ENABLED
;
728 * genwqe_reset_interrupt_capability() - Undo genwqe_set_interrupt_capability()
729 * @cd: pointer to the device
731 void genwqe_reset_interrupt_capability(struct genwqe_dev
*cd
)
733 struct pci_dev
*pci_dev
= cd
->pci_dev
;
735 if (cd
->flags
& GENWQE_FLAG_MSI_ENABLED
) {
736 pci_disable_msi(pci_dev
);
737 cd
->flags
&= ~GENWQE_FLAG_MSI_ENABLED
;
742 * set_reg_idx() - Fill array with data. Ignore illegal offsets.
744 * @r: debug register array
745 * @i: index to desired entry
746 * @m: maximum possible entries
747 * @addr: addr which is read
748 * @index: index in debug array
751 static int set_reg_idx(struct genwqe_dev
*cd
, struct genwqe_reg
*r
,
752 unsigned int *i
, unsigned int m
, u32 addr
, u32 idx
,
755 if (WARN_ON_ONCE(*i
>= m
))
765 static int set_reg(struct genwqe_dev
*cd
, struct genwqe_reg
*r
,
766 unsigned int *i
, unsigned int m
, u32 addr
, u64 val
)
768 return set_reg_idx(cd
, r
, i
, m
, addr
, 0, val
);
771 int genwqe_read_ffdc_regs(struct genwqe_dev
*cd
, struct genwqe_reg
*regs
,
772 unsigned int max_regs
, int all
)
774 unsigned int i
, j
, idx
= 0;
775 u32 ufir_addr
, ufec_addr
, sfir_addr
, sfec_addr
;
776 u64 gfir
, sluid
, appid
, ufir
, ufec
, sfir
, sfec
;
779 gfir
= __genwqe_readq(cd
, IO_SLC_CFGREG_GFIR
);
780 set_reg(cd
, regs
, &idx
, max_regs
, IO_SLC_CFGREG_GFIR
, gfir
);
782 /* UnitCfg for SLU */
783 sluid
= __genwqe_readq(cd
, IO_SLU_UNITCFG
); /* 0x00000000 */
784 set_reg(cd
, regs
, &idx
, max_regs
, IO_SLU_UNITCFG
, sluid
);
786 /* UnitCfg for APP */
787 appid
= __genwqe_readq(cd
, IO_APP_UNITCFG
); /* 0x02000000 */
788 set_reg(cd
, regs
, &idx
, max_regs
, IO_APP_UNITCFG
, appid
);
790 /* Check all chip Units */
791 for (i
= 0; i
< GENWQE_MAX_UNITS
; i
++) {
794 ufir_addr
= (i
<< 24) | 0x008;
795 ufir
= __genwqe_readq(cd
, ufir_addr
);
796 set_reg(cd
, regs
, &idx
, max_regs
, ufir_addr
, ufir
);
799 ufec_addr
= (i
<< 24) | 0x018;
800 ufec
= __genwqe_readq(cd
, ufec_addr
);
801 set_reg(cd
, regs
, &idx
, max_regs
, ufec_addr
, ufec
);
803 for (j
= 0; j
< 64; j
++) {
804 /* wherever there is a primary 1, read the 2ndary */
805 if (!all
&& (!(ufir
& (1ull << j
))))
808 sfir_addr
= (i
<< 24) | (0x100 + 8 * j
);
809 sfir
= __genwqe_readq(cd
, sfir_addr
);
810 set_reg(cd
, regs
, &idx
, max_regs
, sfir_addr
, sfir
);
812 sfec_addr
= (i
<< 24) | (0x300 + 8 * j
);
813 sfec
= __genwqe_readq(cd
, sfec_addr
);
814 set_reg(cd
, regs
, &idx
, max_regs
, sfec_addr
, sfec
);
818 /* fill with invalid data until end */
819 for (i
= idx
; i
< max_regs
; i
++) {
820 regs
[i
].addr
= 0xffffffff;
821 regs
[i
].val
= 0xffffffffffffffffull
;
827 * genwqe_ffdc_buff_size() - Calculates the number of dump registers
829 int genwqe_ffdc_buff_size(struct genwqe_dev
*cd
, int uid
)
831 int entries
= 0, ring
, traps
, traces
, trace_entries
;
832 u32 eevptr_addr
, l_addr
, d_len
, d_type
;
833 u64 eevptr
, val
, addr
;
835 eevptr_addr
= GENWQE_UID_OFFS(uid
) | IO_EXTENDED_ERROR_POINTER
;
836 eevptr
= __genwqe_readq(cd
, eevptr_addr
);
838 if ((eevptr
!= 0x0) && (eevptr
!= -1ull)) {
839 l_addr
= GENWQE_UID_OFFS(uid
) | eevptr
;
842 val
= __genwqe_readq(cd
, l_addr
);
844 if ((val
== 0x0) || (val
== -1ull))
848 d_len
= (val
& 0x0000007fff000000ull
) >> 24;
851 d_type
= (val
& 0x0000008000000000ull
) >> 36;
853 if (d_type
) { /* repeat */
855 } else { /* size in bytes! */
856 entries
+= d_len
>> 3;
863 for (ring
= 0; ring
< 8; ring
++) {
864 addr
= GENWQE_UID_OFFS(uid
) | IO_EXTENDED_DIAG_MAP(ring
);
865 val
= __genwqe_readq(cd
, addr
);
867 if ((val
== 0x0ull
) || (val
== -1ull))
870 traps
= (val
>> 24) & 0xff;
871 traces
= (val
>> 16) & 0xff;
872 trace_entries
= val
& 0xffff;
874 entries
+= traps
+ (traces
* trace_entries
);
880 * genwqe_ffdc_buff_read() - Implements LogoutExtendedErrorRegisters procedure
882 int genwqe_ffdc_buff_read(struct genwqe_dev
*cd
, int uid
,
883 struct genwqe_reg
*regs
, unsigned int max_regs
)
885 int i
, traps
, traces
, trace
, trace_entries
, trace_entry
, ring
;
886 unsigned int idx
= 0;
887 u32 eevptr_addr
, l_addr
, d_addr
, d_len
, d_type
;
888 u64 eevptr
, e
, val
, addr
;
890 eevptr_addr
= GENWQE_UID_OFFS(uid
) | IO_EXTENDED_ERROR_POINTER
;
891 eevptr
= __genwqe_readq(cd
, eevptr_addr
);
893 if ((eevptr
!= 0x0) && (eevptr
!= 0xffffffffffffffffull
)) {
894 l_addr
= GENWQE_UID_OFFS(uid
) | eevptr
;
896 e
= __genwqe_readq(cd
, l_addr
);
897 if ((e
== 0x0) || (e
== 0xffffffffffffffffull
))
900 d_addr
= (e
& 0x0000000000ffffffull
); /* 23:0 */
901 d_len
= (e
& 0x0000007fff000000ull
) >> 24; /* 38:24 */
902 d_type
= (e
& 0x0000008000000000ull
) >> 36; /* 39 */
903 d_addr
|= GENWQE_UID_OFFS(uid
);
906 for (i
= 0; i
< (int)d_len
; i
++) {
907 val
= __genwqe_readq(cd
, d_addr
);
908 set_reg_idx(cd
, regs
, &idx
, max_regs
,
912 d_len
>>= 3; /* Size in bytes! */
913 for (i
= 0; i
< (int)d_len
; i
++, d_addr
+= 8) {
914 val
= __genwqe_readq(cd
, d_addr
);
915 set_reg_idx(cd
, regs
, &idx
, max_regs
,
924 * To save time, there are only 6 traces poplulated on Uid=2,
925 * Ring=1. each with iters=512.
927 for (ring
= 0; ring
< 8; ring
++) { /* 0 is fls, 1 is fds,
928 2...7 are ASI rings */
929 addr
= GENWQE_UID_OFFS(uid
) | IO_EXTENDED_DIAG_MAP(ring
);
930 val
= __genwqe_readq(cd
, addr
);
932 if ((val
== 0x0ull
) || (val
== -1ull))
935 traps
= (val
>> 24) & 0xff; /* Number of Traps */
936 traces
= (val
>> 16) & 0xff; /* Number of Traces */
937 trace_entries
= val
& 0xffff; /* Entries per trace */
939 /* Note: This is a combined loop that dumps both the traps */
940 /* (for the trace == 0 case) as well as the traces 1 to */
942 for (trace
= 0; trace
<= traces
; trace
++) {
944 GENWQE_EXTENDED_DIAG_SELECTOR(ring
, trace
);
946 addr
= (GENWQE_UID_OFFS(uid
) |
947 IO_EXTENDED_DIAG_SELECTOR
);
948 __genwqe_writeq(cd
, addr
, diag_sel
);
950 for (trace_entry
= 0;
951 trace_entry
< (trace
? trace_entries
: traps
);
953 addr
= (GENWQE_UID_OFFS(uid
) |
954 IO_EXTENDED_DIAG_READ_MBX
);
955 val
= __genwqe_readq(cd
, addr
);
956 set_reg_idx(cd
, regs
, &idx
, max_regs
, addr
,
957 (diag_sel
<<16) | trace_entry
, val
);
965 * genwqe_write_vreg() - Write register in virtual window
967 * Note, these registers are only accessible to the PF through the
968 * VF-window. It is not intended for the VF to access.
970 int genwqe_write_vreg(struct genwqe_dev
*cd
, u32 reg
, u64 val
, int func
)
972 __genwqe_writeq(cd
, IO_PF_SLC_VIRTUAL_WINDOW
, func
& 0xf);
973 __genwqe_writeq(cd
, reg
, val
);
978 * genwqe_read_vreg() - Read register in virtual window
980 * Note, these registers are only accessible to the PF through the
981 * VF-window. It is not intended for the VF to access.
983 u64
genwqe_read_vreg(struct genwqe_dev
*cd
, u32 reg
, int func
)
985 __genwqe_writeq(cd
, IO_PF_SLC_VIRTUAL_WINDOW
, func
& 0xf);
986 return __genwqe_readq(cd
, reg
);
990 * genwqe_base_clock_frequency() - Deteremine base clock frequency of the card
992 * Note: From a design perspective it turned out to be a bad idea to
993 * use codes here to specifiy the frequency/speed values. An old
994 * driver cannot understand new codes and is therefore always a
995 * problem. Better is to measure out the value or put the
996 * speed/frequency directly into a register which is always a valid
997 * value for old as well as for new software.
999 * Return: Card clock in MHz
1001 int genwqe_base_clock_frequency(struct genwqe_dev
*cd
)
1003 u16 speed
; /* MHz MHz MHz MHz */
1004 static const int speed_grade
[] = { 250, 200, 166, 175 };
1006 speed
= (u16
)((cd
->slu_unitcfg
>> 28) & 0x0full
);
1007 if (speed
>= ARRAY_SIZE(speed_grade
))
1008 return 0; /* illegal value */
1010 return speed_grade
[speed
];
1014 * genwqe_stop_traps() - Stop traps
1016 * Before reading out the analysis data, we need to stop the traps.
1018 void genwqe_stop_traps(struct genwqe_dev
*cd
)
1020 __genwqe_writeq(cd
, IO_SLC_MISC_DEBUG_SET
, 0xcull
);
1024 * genwqe_start_traps() - Start traps
1026 * After having read the data, we can/must enable the traps again.
1028 void genwqe_start_traps(struct genwqe_dev
*cd
)
1030 __genwqe_writeq(cd
, IO_SLC_MISC_DEBUG_CLR
, 0xcull
);
1032 if (genwqe_need_err_masking(cd
))
1033 __genwqe_writeq(cd
, IO_SLC_MISC_DEBUG
, 0x0aull
);