source: rtems/c/src/lib/libbsp/sparc/shared/pci/grpci2.c @ 3c236cc

4.11
Last change on this file since 3c236cc was 3c236cc, checked in by Daniel Hellstrom <daniel@…>, on Feb 5, 2014 at 4:17:53 PM

LEON PCI: fix for PCI host bridge driver CFG space access

  • Property mode set to 100644
File size: 24.0 KB
Line 
1/*  GRLIB GRPCI2 PCI HOST driver.
2 *
3 *  COPYRIGHT (c) 2011
4 *  Cobham Gaisler AB.
5 *
6 *  The license and distribution terms for this file may be
7 *  found in found in the file LICENSE in this distribution or at
8 *  http://www.rtems.com/license/LICENSE.
9 */
10
11/* Configures the GRPCI2 core and initialize,
12 *  - the PCI Library (pci.c)
13 *  - the general part of the PCI Bus driver (pci_bus.c)
14 * 
15 * System interrupt assigned to PCI interrupt (INTA#..INTD#) is by
16 * default taken from Plug and Play, but may be overridden by the
17 * driver resources INTA#..INTD#. GRPCI2 handles differently depending
18 * on the design (4 different ways).
19 *
20 * GRPCI2 IRQ implementation notes
21 * -------------------------------
22 * Since the Driver Manager pci_bus layer implements IRQ by calling
23 * pci_interrupt_* which translates into BSP_shared_interrupt_*, and the
24 * root-bus also relies on BSP_shared_interrupt_*, it is safe for the GRPCI2
25 * driver to use the drvmgr_interrupt_* routines since they will be
26 * accessing the same routines in the end. Otherwise the GRPCI2 driver must
27 * have used the pci_interrupt_* routines.
28 */
29
30#include <stdlib.h>
31#include <stdio.h>
32#include <string.h>
33#include <rtems/bspIo.h>
34#include <libcpu/byteorder.h>
35#include <libcpu/access.h>
36#include <pci.h>
37#include <pci/cfg.h>
38
39#include <drvmgr/drvmgr.h>
40#include <drvmgr/ambapp_bus.h>
41#include <ambapp.h>
42#include <drvmgr/pci_bus.h>
43#include <grpci2.h>
44
45#ifndef IRQ_GLOBAL_PREPARE
46 #define IRQ_GLOBAL_PREPARE(level) rtems_interrupt_level level
47#endif
48
49#ifndef IRQ_GLOBAL_DISABLE
50 #define IRQ_GLOBAL_DISABLE(level) rtems_interrupt_disable(level)
51#endif
52
53#ifndef IRQ_GLOBAL_ENABLE
54 #define IRQ_GLOBAL_ENABLE(level) rtems_interrupt_enable(level)
55#endif
56
57/* If defined to 1 - byte twisting is enabled by default */
58#define DEFAULT_BT_ENABLED 0
59
60/* Interrupt assignment. Set to other value than 0xff in order to
61 * override defaults and plug&play information
62 */
63#ifndef GRPCI2_INTA_SYSIRQ
64 #define GRPCI2_INTA_SYSIRQ 0xff
65#endif
66#ifndef GRPCI2_INTB_SYSIRQ
67 #define GRPCI2_INTB_SYSIRQ 0xff
68#endif
69#ifndef GRPCI2_INTC_SYSIRQ
70 #define GRPCI2_INTC_SYSIRQ 0xff
71#endif
72#ifndef GRPCI2_INTD_SYSIRQ
73 #define GRPCI2_INTD_SYSIRQ 0xff
74#endif
75
76/*#define DEBUG 1*/
77
78#ifdef DEBUG
79#define DBG(x...) printk(x)
80#else
81#define DBG(x...)
82#endif
83
84#define PCI_INVALID_VENDORDEVICEID      0xffffffff
85#define PCI_MULTI_FUNCTION              0x80
86
87/*
88 * GRPCI2 APB Register MAP
89 */
90struct grpci2_regs {
91        volatile unsigned int ctrl;             /* 0x00 */
92        volatile unsigned int sts_cap;          /* 0x04 */
93        volatile unsigned int ppref;            /* 0x08 */
94        volatile unsigned int io_map;           /* 0x0C */
95        volatile unsigned int dma_ctrl;         /* 0x10 */
96        volatile unsigned int dma_bdbase;       /* 0x14 */
97        volatile unsigned int dma_chact;        /* 0x18 */
98        int res1;                               /* 0x1C */
99        volatile unsigned int bars[6];          /* 0x20 */
100        int res2[2];                            /* 0x38 */
101        volatile unsigned int ahbmst_map[16];   /* 0x40 */
102};
103
104#define CTRL_BUS_BIT 16
105
106#define CTRL_SI (1<<27)
107#define CTRL_PE (1<<26)
108#define CTRL_EI (1<<25)
109#define CTRL_ER (1<<24)
110#define CTRL_BUS (0xff<<CTRL_BUS_BIT)
111#define CTRL_HOSTINT 0xf
112
113#define STS_HOST_BIT    31
114#define STS_MST_BIT     30
115#define STS_TAR_BIT     29
116#define STS_DMA_BIT     28
117#define STS_DI_BIT      27
118#define STS_HI_BIT      26
119#define STS_IRQMODE_BIT 24
120#define STS_TRACE_BIT   23
121#define STS_CFGERRVALID_BIT 20
122#define STS_CFGERR_BIT  19
123#define STS_INTTYPE_BIT 12
124#define STS_INTSTS_BIT  8
125#define STS_FDEPTH_BIT  2
126#define STS_FNUM_BIT    0
127
128#define STS_HOST        (1<<STS_HOST_BIT)
129#define STS_MST         (1<<STS_MST_BIT)
130#define STS_TAR         (1<<STS_TAR_BIT)
131#define STS_DMA         (1<<STS_DMA_BIT)
132#define STS_DI          (1<<STS_DI_BIT)
133#define STS_HI          (1<<STS_HI_BIT)
134#define STS_IRQMODE     (0x3<<STS_IRQMODE_BIT)
135#define STS_TRACE       (1<<STS_TRACE_BIT)
136#define STS_CFGERRVALID (1<<STS_CFGERRVALID_BIT)
137#define STS_CFGERR      (1<<STS_CFGERR_BIT)
138#define STS_INTTYPE     (0x3f<<STS_INTTYPE_BIT)
139#define STS_INTSTS      (0xf<<STS_INTSTS_BIT)
140#define STS_FDEPTH      (0x7<<STS_FDEPTH_BIT)
141#define STS_FNUM        (0x3<<STS_FNUM_BIT)
142
143#define STS_ISYSERR     (1<<17)
144#define STS_IDMA        (1<<16)
145#define STS_IDMAERR     (1<<15)
146#define STS_IMSTABRT    (1<<14)
147#define STS_ITGTABRT    (1<<13)
148#define STS_IPARERR     (1<<12)
149
150struct grpci2_bd_chan {
151        volatile unsigned int ctrl;     /* 0x00 DMA Control */
152        volatile unsigned int nchan;    /* 0x04 Next DMA Channel Address */
153        volatile unsigned int nbd;      /* 0x08 Next Data Descriptor in channel */
154        volatile unsigned int res;      /* 0x0C Reserved */
155};
156
157#define BD_CHAN_EN              0x80000000
158#define BD_CHAN_TYPE            0x00300000
159#define BD_CHAN_BDCNT           0x0000ffff
160#define BD_CHAN_EN_BIT          31
161#define BD_CHAN_TYPE_BIT        20
162#define BD_CHAN_BDCNT_BIT       0
163
164struct grpci2_bd_data {
165        volatile unsigned int ctrl;     /* 0x00 DMA Data Control */
166        volatile unsigned int pci_adr;  /* 0x04 PCI Start Address */
167        volatile unsigned int ahb_adr;  /* 0x08 AHB Start address */
168        volatile unsigned int next;     /* 0x0C Next Data Descriptor in channel */
169};
170
171#define BD_DATA_EN              0x80000000
172#define BD_DATA_IE              0x40000000
173#define BD_DATA_DR              0x20000000
174#define BD_DATA_TYPE            0x00300000
175#define BD_DATA_ER              0x00080000
176#define BD_DATA_LEN             0x0000ffff
177#define BD_DATA_EN_BIT          31
178#define BD_DATA_IE_BIT          30
179#define BD_DATA_DR_BIT          29
180#define BD_DATA_TYPE_BIT        20
181#define BD_DATA_ER_BIT          19
182#define BD_DATA_LEN_BIT         0
183
184/* GRPCI2 Capability */
185struct grpci2_cap_first {
186        unsigned int ctrl;
187        unsigned int pci2ahb_map[6];
188        unsigned int ext2ahb_map;
189        unsigned int io_map;
190        unsigned int pcibar_size[6];
191        unsigned int ahb_pref;
192};
193#define CAP9_CTRL_OFS 0
194#define CAP9_BAR_OFS 0x4
195#define CAP9_IOMAP_OFS 0x20
196#define CAP9_BARSIZE_OFS 0x24
197#define CAP9_AHBPREF_OFS 0x3C
198
199/* Used internally for accessing the PCI bridge's configuration space itself */
200#define HOST_TGT PCI_DEV(0xff, 0, 0)
201
202struct grpci2_priv *grpci2priv = NULL;
203
204/* PCI Interrupt assignment. Connects an PCI interrupt pin (INTA#..INTD#)
205 * to a system interrupt number.
206 */
207unsigned char grpci2_pci_irq_table[4] =
208{
209        /* INTA# */     GRPCI2_INTA_SYSIRQ,
210        /* INTB# */     GRPCI2_INTB_SYSIRQ,
211        /* INTC# */     GRPCI2_INTC_SYSIRQ,
212        /* INTD# */     GRPCI2_INTD_SYSIRQ
213};
214
215/* Start of workspace/dynamical area */
216extern unsigned int _end;
217#define DMA_START ((unsigned int) &_end)
218
219/* Default BAR mapping, set BAR0 256MB 1:1 mapped base of CPU RAM */
220struct grpci2_pcibar_cfg grpci2_default_bar_mapping[6] = {
221        /* BAR0 */ {DMA_START, DMA_START, 0x10000000},
222        /* BAR1 */ {0, 0, 0},
223        /* BAR2 */ {0, 0, 0},
224        /* BAR3 */ {0, 0, 0},
225        /* BAR4 */ {0, 0, 0},
226        /* BAR5 */ {0, 0, 0},
227};
228
229/* Driver private data struture */
230struct grpci2_priv {
231        struct drvmgr_dev       *dev;
232        struct grpci2_regs              *regs;
233        unsigned char                   ver;
234        char                            irq;
235        char                            irq_mode; /* IRQ Mode from CAPSTS REG */
236        char                            bt_enabled;
237        unsigned int                    irq_mask;
238
239        struct grpci2_pcibar_cfg        *barcfg;
240
241        unsigned int                    pci_area;
242        unsigned int                    pci_area_end;
243        unsigned int                    pci_io;   
244        unsigned int                    pci_conf;
245        unsigned int                    pci_conf_end;
246
247        uint32_t                        devVend; /* Host PCI Device/Vendor ID */
248
249        struct drvmgr_map_entry         maps_up[7];
250        struct drvmgr_map_entry         maps_down[2];
251        struct pcibus_config            config;
252};
253
254int grpci2_init1(struct drvmgr_dev *dev);
255int grpci2_init3(struct drvmgr_dev *dev);
256
257/* GRPCI2 DRIVER */
258
259struct drvmgr_drv_ops grpci2_ops = 
260{
261        .init = {grpci2_init1, NULL, grpci2_init3, NULL},
262        .remove = NULL,
263        .info = NULL
264};
265
266struct amba_dev_id grpci2_ids[] = 
267{
268        {VENDOR_GAISLER, GAISLER_GRPCI2},
269        {0, 0}          /* Mark end of table */
270};
271
272struct amba_drv_info grpci2_info =
273{
274        {
275                DRVMGR_OBJ_DRV,                 /* Driver */
276                NULL,                           /* Next driver */
277                NULL,                           /* Device list */
278                DRIVER_AMBAPP_GAISLER_GRPCI2_ID,/* Driver ID */
279                "GRPCI2_DRV",                   /* Driver Name */
280                DRVMGR_BUS_TYPE_AMBAPP,         /* Bus Type */
281                &grpci2_ops,
282                NULL,                           /* Funcs */
283                0,                              /* No devices yet */
284                sizeof(struct grpci2_priv),     /* Make drvmgr alloc private */
285        },
286        &grpci2_ids[0]
287};
288
289void grpci2_register_drv(void)
290{
291        DBG("Registering GRPCI2 driver\n");
292        drvmgr_drv_register(&grpci2_info.general);
293}
294
295int grpci2_cfg_r32(pci_dev_t dev, int ofs, uint32_t *val)
296{
297        struct grpci2_priv *priv = grpci2priv;
298        volatile uint32_t *pci_conf;
299        unsigned int tmp, devfn;
300        IRQ_GLOBAL_PREPARE(oldLevel);
301        int retval, bus = PCI_DEV_BUS(dev);
302
303        if ((unsigned int)ofs & 0xffffff03) {
304                retval = PCISTS_EINVAL;
305                goto out2;
306        }
307
308        if (PCI_DEV_SLOT(dev) > 15) {
309                retval = PCISTS_MSTABRT;
310                goto out;
311        }
312
313        /* GRPCI2 can access "non-standard" devices on bus0 (on AD11.AD16),
314         * we skip them.
315         */
316        if (dev == HOST_TGT)
317                bus = devfn = 0;
318        else if (bus == 0)
319                devfn = PCI_DEV_DEVFUNC(dev) + PCI_DEV(0, 6, 0);
320        else
321                devfn = PCI_DEV_DEVFUNC(dev);
322
323        pci_conf = (volatile uint32_t *) (priv->pci_conf | (devfn << 8) | ofs);
324
325        IRQ_GLOBAL_DISABLE(oldLevel); /* protect regs */
326
327        /* Select bus */
328        priv->regs->ctrl = (priv->regs->ctrl & ~(0xff<<16)) | (bus<<16);
329        /* clear old status */
330        priv->regs->sts_cap = (STS_CFGERR | STS_CFGERRVALID);
331
332        tmp = *pci_conf;
333
334        /* Wait until GRPCI2 signals that CFG access is done, it should be
335         * done instantaneously unless a DMA operation is ongoing...
336         */
337        while ((priv->regs->sts_cap & STS_CFGERRVALID) == 0)
338                ;
339
340        if (priv->regs->sts_cap & STS_CFGERR) {
341                retval = PCISTS_MSTABRT;
342        } else {
343                /* Bus always little endian (unaffected by byte-swapping) */
344                *val = CPU_swap_u32(tmp);
345                retval = PCISTS_OK;
346        }
347
348        IRQ_GLOBAL_ENABLE(oldLevel);
349
350out:
351        if (retval != PCISTS_OK)
352                *val = 0xffffffff;
353
354        DBG("pci_read: [%x:%x:%x] reg: 0x%x => addr: 0x%x, val: 0x%x  (%d)\n",
355                PCI_DEV_EXPAND(dev), ofs, pci_conf, *val, retval);
356
357out2:
358        return retval;
359}
360
361int grpci2_cfg_r16(pci_dev_t dev, int ofs, uint16_t *val)
362{
363        uint32_t v;
364        int retval;
365
366        if (ofs & 1)
367                return PCISTS_EINVAL;
368
369        retval = grpci2_cfg_r32(dev, ofs & ~0x3, &v);
370        *val = 0xffff & (v >> (8*(ofs & 0x3)));
371
372        return retval;
373}
374
375int grpci2_cfg_r8(pci_dev_t dev, int ofs, uint8_t *val)
376{
377        uint32_t v;
378        int retval;
379
380        retval = grpci2_cfg_r32(dev, ofs & ~0x3, &v);
381
382        *val = 0xff & (v >> (8*(ofs & 3)));
383
384        return retval;
385}
386
387int grpci2_cfg_w32(pci_dev_t dev, int ofs, uint32_t val)
388{
389        struct grpci2_priv *priv = grpci2priv;
390        volatile uint32_t *pci_conf;
391        uint32_t value, devfn;
392        int retval, bus = PCI_DEV_BUS(dev);
393        IRQ_GLOBAL_PREPARE(oldLevel);
394
395        if ((unsigned int)ofs & 0xffffff03)
396                return PCISTS_EINVAL;
397
398        if (PCI_DEV_SLOT(dev) > 15)
399                return PCISTS_MSTABRT;
400
401        value = CPU_swap_u32(val);
402
403        /* GRPCI2 can access "non-standard" devices on bus0 (on AD11.AD16),
404         * we skip them.
405         */
406        if (dev == HOST_TGT)
407                bus = devfn = 0;
408        else if (bus == 0)
409                devfn = PCI_DEV_DEVFUNC(dev) + PCI_DEV(0, 6, 0);
410        else
411                devfn = PCI_DEV_DEVFUNC(dev);
412
413        pci_conf = (volatile uint32_t *) (priv->pci_conf | (devfn << 8) | ofs);
414
415        IRQ_GLOBAL_DISABLE(oldLevel); /* protect regs */
416
417        /* Select bus */
418        priv->regs->ctrl = (priv->regs->ctrl & ~(0xff<<16)) | (bus<<16);
419        /* clear old status */
420        priv->regs->sts_cap = (STS_CFGERR | STS_CFGERRVALID);
421
422        *pci_conf = value;
423
424        /* Wait until GRPCI2 signals that CFG access is done, it should be
425         * done instantaneously unless a DMA operation is ongoing...
426         */
427        while ((priv->regs->sts_cap & STS_CFGERRVALID) == 0)
428                ;
429
430        if (priv->regs->sts_cap & STS_CFGERR)
431                retval = PCISTS_MSTABRT;
432        else
433                retval = PCISTS_OK;
434
435        IRQ_GLOBAL_ENABLE(oldLevel);
436
437        DBG("pci_write - [%x:%x:%x] reg: 0x%x => addr: 0x%x, val: 0x%x  (%d)\n",
438                PCI_DEV_EXPAND(dev), ofs, pci_conf, value, retval);
439
440        return retval;
441}
442
443int grpci2_cfg_w16(pci_dev_t dev, int ofs, uint16_t val)
444{
445        uint32_t v;
446        int retval;
447
448        if (ofs & 1)
449                return PCISTS_EINVAL;
450
451        retval = grpci2_cfg_r32(dev, ofs & ~0x3, &v);
452        if (retval != PCISTS_OK)
453                return retval;
454
455        v = (v & ~(0xffff << (8*(ofs&3)))) | ((0xffff&val) << (8*(ofs&3)));
456
457        return grpci2_cfg_w32(dev, ofs & ~0x3, v);
458}
459
460int grpci2_cfg_w8(pci_dev_t dev, int ofs, uint8_t val)
461{
462        uint32_t v;
463        int retval;
464
465        retval = grpci2_cfg_r32(dev, ofs & ~0x3, &v);
466        if (retval != PCISTS_OK)
467                return retval;
468
469        v = (v & ~(0xff << (8*(ofs&3)))) | ((0xff&val) << (8*(ofs&3)));
470
471        return grpci2_cfg_w32(dev, ofs & ~0x3, v);
472}
473
474/* Return the assigned system IRQ number that corresponds to the PCI
475 * "Interrupt Pin" information from configuration space.
476 *
477 * The IRQ information is stored in the grpci2_pci_irq_table configurable
478 * by the user.
479 *
480 * Returns the "system IRQ" for the PCI INTA#..INTD# pin in irq_pin. Returns
481 * 0xff if not assigned.
482 */
483uint8_t grpci2_bus0_irq_map(pci_dev_t dev, int irq_pin)
484{
485        uint8_t sysIrqNr = 0; /* not assigned */
486        int irq_group;
487
488        if ( (irq_pin >= 1) && (irq_pin <= 4) ) {
489                /* Use default IRQ decoding on PCI BUS0 according slot numbering */
490                irq_group = PCI_DEV_SLOT(dev) & 0x3;
491                irq_pin = ((irq_pin - 1) + irq_group) & 0x3;
492                /* Valid PCI "Interrupt Pin" number */
493                sysIrqNr = grpci2_pci_irq_table[irq_pin];
494        }
495        return sysIrqNr;
496}
497
498int grpci2_translate(uint32_t *address, int type, int dir)
499{
500        uint32_t adr, start, end;
501        struct grpci2_priv *priv = grpci2priv;
502        int i;
503
504        if (type == 1) {
505                /* I/O */
506                if (dir != 0) {
507                        /* The PCI bus can not access the CPU bus from I/O
508                         * because GRPCI2 core does not support I/O BARs
509                         */
510                        return -1;
511                }
512
513                /* We have got a PCI IO BAR address that the CPU want to access.
514                 * Check that it is within the PCI I/O window, I/O adresses
515                 * are NOT mapped 1:1 with GRPCI2 driver... translation needed.
516                 */
517                adr = *(uint32_t *)address;
518                if (adr < 0x100 || adr > 0x10000)
519                        return -1;
520                *address = adr + priv->pci_io;
521        } else {
522                /* MEMIO and MEM.
523                 * Memory space is mapped 1:1 so no translation is needed.
524                 * Check that address is within accessible windows.
525                 */
526                adr = *(uint32_t *)address;
527                if (dir == 0) {
528                        /* PCI BAR to AMBA-CPU address.. check that it is
529                         * located within GRPCI2 PCI Memory Window
530                         * adr = PCI address.
531                         */
532                        if (adr < priv->pci_area || adr >= priv->pci_area_end)
533                                return -1;
534                } else {
535                        /* We have a CPU address and want to get access to it
536                         * from PCI space, typically when doing DMA into CPU
537                         * RAM. The GRPCI2 core may have multiple target BARs
538                         * that PCI masters can access, the BARs are user
539                         * configurable in the following ways:
540                         *  BAR_SIZE, PCI_BAR Address and MAPPING (AMBA ADR)
541                         *
542                         * The below code tries to find a BAR for which the
543                         * AMBA bar may have been mapped onto, and translate
544                         * the AMBA-CPU address into a PCI address using the
545                         * given mapping.
546                         *
547                         * adr = AMBA address.
548                         */
549                        for(i=0; i<6; i++) {
550                                start = priv->barcfg[i].ahbadr;
551                                end = priv->barcfg[i].ahbadr +
552                                        priv->barcfg[i].barsize;
553                                if (adr >= start && adr < end) {
554                                        /* BAR match: Translate address */
555                                        *address = (adr - start) +
556                                                priv->barcfg[i].pciadr;
557                                        return 0;
558                                }
559                        }
560                        return -1;
561                }
562        }
563
564        return 0;
565}
566
567extern struct pci_memreg_ops pci_memreg_sparc_le_ops;
568extern struct pci_memreg_ops pci_memreg_sparc_be_ops;
569
570/* GRPCI2 PCI access routines, default to Little-endian PCI Bus */
571struct pci_access_drv grpci2_access_drv = {
572        .cfg =
573        {
574                grpci2_cfg_r8,
575                grpci2_cfg_r16,
576                grpci2_cfg_r32,
577                grpci2_cfg_w8,
578                grpci2_cfg_w16,
579                grpci2_cfg_w32,
580        },
581        .io =
582        {
583                _ld8,
584                _ld_le16,
585                _ld_le32,
586                _st8,
587                _st_le16,
588                _st_le32,
589        },
590        .memreg = &pci_memreg_sparc_le_ops,
591        .translate = grpci2_translate,
592};
593
594struct pci_io_ops grpci2_io_ops_be =
595{
596        _ld8,
597        _ld_be16,
598        _ld_be32,
599        _st8,
600        _st_be16,
601        _st_be32,
602};
603
604/* PCI Error Interrupt handler, called when there may be a PCI Target/Master
605 * Abort.
606 */
607void grpci2_err_isr(void *arg)
608{
609        struct grpci2_priv *priv = arg;
610        unsigned int sts = priv->regs->sts_cap;
611
612        if (sts & (STS_IMSTABRT | STS_ITGTABRT | STS_IPARERR | STS_ISYSERR)) {
613                /* A PCI error IRQ ... Error handler unimplemented
614                 * add your code here...
615                 */
616                if (sts & STS_IMSTABRT) {
617                        printk("GRPCI2: unhandled Master Abort IRQ\n");
618                }
619                if (sts & STS_ITGTABRT) {
620                        printk("GRPCI2: unhandled Target Abort IRQ\n");
621                }
622                if (sts & STS_IPARERR) {
623                        printk("GRPCI2: unhandled Parity Error IRQ\n");
624                }
625                if (sts & STS_ISYSERR) {
626                        printk("GRPCI2: unhandled System Error IRQ\n");
627                }
628        }
629}
630
631int grpci2_hw_init(struct grpci2_priv *priv)
632{
633        struct grpci2_regs *regs = priv->regs;
634        int i;
635        uint8_t capptr;
636        uint32_t data, io_map, ahbadr, pciadr, size;
637        pci_dev_t host = HOST_TGT;
638        struct grpci2_pcibar_cfg *barcfg = priv->barcfg;
639
640        /* Reset any earlier setup */
641        regs->ctrl = 0;
642        regs->sts_cap = ~0; /* Clear Status */
643        regs->dma_ctrl = 0;
644        regs->dma_bdbase = 0;
645
646        /* Translate I/O accesses 1:1, (will not work for PCI 2.3) */
647        regs->io_map = priv->pci_io & 0xffff0000;
648
649        /* set 1:1 mapping between AHB -> PCI memory space, for all Masters
650         * Each AHB master has it's own mapping registers. Max 16 AHB masters.
651         */
652        for (i=0; i<16; i++)
653                regs->ahbmst_map[i] = priv->pci_area;
654
655        /* Get the GRPCI2 Host PCI ID */
656        grpci2_cfg_r32(host, PCI_VENDOR_ID, &priv->devVend);
657
658        /* Get address to first (always defined) capability structure */
659        grpci2_cfg_r8(host, PCI_CAP_PTR, &capptr);
660        if (capptr == 0)
661                return -1;
662
663        /* Limit the prefetch for GRPCI2 version 0. */
664        if (priv->ver == 0)
665                grpci2_cfg_w32(host, capptr+CAP9_AHBPREF_OFS, 0);
666
667        /* Enable/Disable Byte twisting */
668        grpci2_cfg_r32(host, capptr+CAP9_IOMAP_OFS, &io_map);
669        io_map = (io_map & ~0x1) | (priv->bt_enabled ? 1 : 0);
670        grpci2_cfg_w32(host, capptr+CAP9_IOMAP_OFS, io_map);
671
672        /* Setup the Host's PCI Target BARs for others to access (DMA) */
673        for (i=0; i<6; i++) {
674                /* Make sure address is properly aligned */
675                size = ~(barcfg[i].barsize-1);
676                barcfg[i].pciadr &= size;
677                barcfg[i].ahbadr &= size;
678
679                pciadr = barcfg[i].pciadr;
680                ahbadr = barcfg[i].ahbadr;
681                size |= PCI_BASE_ADDRESS_MEM_PREFETCH;
682
683                grpci2_cfg_w32(host, capptr+CAP9_BARSIZE_OFS+i*4, size);
684                grpci2_cfg_w32(host, capptr+CAP9_BAR_OFS+i*4, ahbadr);
685                grpci2_cfg_w32(host, PCI_BASE_ADDRESS_0+i*4, pciadr);
686        }
687
688        /* set as bus master and enable pci memory responses */ 
689        grpci2_cfg_r32(host, PCI_COMMAND, &data);
690        data |= (PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
691        grpci2_cfg_w32(host, PCI_COMMAND, data);
692
693        /* Enable Error respone (CPU-TRAP) on illegal memory access */
694        regs->ctrl = CTRL_ER | CTRL_PE;
695
696        /* Successful */
697        return 0;
698}
699
700/* Initializes the GRPCI2 core and driver, must be called before calling
701 * init_pci()
702 *
703 * Return values
704 *  0             Successful initalization
705 *  -1            Error during initialization, for example "PCI core not found".
706 *  -2            Error PCI controller not HOST (targets not supported)
707 *  -3            Error due to GRPCI2 hardware initialization
708 */
709int grpci2_init(struct grpci2_priv *priv)
710{
711        struct ambapp_apb_info *apb;
712        struct ambapp_ahb_info *ahb;
713        int pin, i, j;
714        union drvmgr_key_value *value;
715        char keyname[6];
716        struct amba_dev_info *ainfo = priv->dev->businfo;
717        struct grpci2_pcibar_cfg *barcfg;
718        unsigned int size;
719
720        /* Find PCI core from Plug&Play information */
721        apb = ainfo->info.apb_slv;
722        ahb = ainfo->info.ahb_slv;
723
724        /* Found PCI core, init private structure */
725        priv->irq = apb->irq;
726        priv->ver = apb->ver;
727        priv->regs = (struct grpci2_regs *)apb->start;
728        priv->bt_enabled = DEFAULT_BT_ENABLED;
729        priv->irq_mode = (priv->regs->sts_cap & STS_IRQMODE) >> STS_IRQMODE_BIT;
730
731        /* Calculate the PCI windows
732         *  AMBA->PCI Window:                       AHB SLAVE AREA0
733         *  AMBA->PCI I/O cycles Window:            AHB SLAVE AREA1 Lower half
734         *  AMBA->PCI Configuration cycles Window:  AHB SLAVE AREA1 Upper half
735         */
736        priv->pci_area     = ahb->start[0];
737        priv->pci_area_end = ahb->start[0] + ahb->mask[0];
738        priv->pci_io       = ahb->start[1];
739        priv->pci_conf     = ahb->start[1] + 0x10000;
740        priv->pci_conf_end = priv->pci_conf + 0x10000;
741
742        /* On systems where PCI I/O area and configuration area is apart of the
743         * "PCI Window" the PCI Window stops at the start of the PCI I/O area
744         */
745        if ((priv->pci_io > priv->pci_area) &&
746            (priv->pci_io < (priv->pci_area_end-1))) {
747                priv->pci_area_end = priv->pci_io;
748        }
749
750        /* Init PCI interrupt assignment table to all use the interrupt routed
751         * through the GRPCI2 core.
752         */
753        strcpy(keyname, "INTX#");
754        for (pin=1; pin<5; pin++) {
755                if (grpci2_pci_irq_table[pin-1] == 0xff) {
756                        if (priv->irq_mode < 2) {
757                                /* PCI Interrupts are shared */
758                                grpci2_pci_irq_table[pin-1] = priv->irq;
759                        } else {
760                                /* Unique IRQ per PCI INT Pin */
761                                grpci2_pci_irq_table[pin-1] = priv->irq + pin-1;
762                        }
763
764                        /* User may override Both hardcoded IRQ setup and Plug & Play IRQ */
765                        keyname[3] = 'A' + (pin-1);
766                        value = drvmgr_dev_key_get(priv->dev, keyname, KEY_TYPE_INT);
767                        if (value)
768                                grpci2_pci_irq_table[pin-1] = value->i;
769                }
770
771                /* Remember which IRQs are enabled */
772                if (grpci2_pci_irq_table[pin-1] != 0)
773                        priv->irq_mask |= 1 << (pin-1);
774        }
775
776        /* User may override DEFAULT_BT_ENABLED to enable/disable byte twisting */
777        value = drvmgr_dev_key_get(priv->dev, "byteTwisting", KEY_TYPE_INT);
778        if (value)
779                priv->bt_enabled = value->i;
780
781        /* Let user Configure the 6 target BARs */
782        value = drvmgr_dev_key_get(priv->dev, "tgtBarCfg", KEY_TYPE_POINTER);
783        if (value)
784                priv->barcfg = value->ptr;
785        else
786                priv->barcfg = grpci2_default_bar_mapping;
787
788        /* This driver only support HOST systems, we check that it can act as a
789         * PCI Master and that it is in the Host slot. */
790        if ((priv->regs->sts_cap&STS_HOST) || !(priv->regs->sts_cap&STS_MST))
791                return -2; /* Target not supported */
792
793        /* Init the PCI Core */
794        if (grpci2_hw_init(priv))
795                return -3;
796
797        /* Down streams translation table */
798        priv->maps_down[0].name = "AMBA -> PCI MEM Window";
799        priv->maps_down[0].size = priv->pci_area_end - priv->pci_area;
800        priv->maps_down[0].from_adr = (void *)priv->pci_area;
801        priv->maps_down[0].to_adr = (void *)priv->pci_area;
802        /* End table */
803        priv->maps_down[1].size = 0;
804
805        /* Up streams translation table */
806        /* Setup the Host's PCI Target BARs for others to access (DMA) */
807        barcfg = priv->barcfg;
808        for (i=0,j=0; i<6; i++) {
809                size = barcfg[i].barsize;
810                if (size == 0)
811                        continue;
812
813                /* Make sure address is properly aligned */
814                priv->maps_up[j].name = "Target BAR[I] -> AMBA";
815                priv->maps_up[j].size = size;
816                priv->maps_up[j].from_adr = (void *)
817                                        (barcfg[i].pciadr & ~(size - 1));
818                priv->maps_up[j].to_adr = (void *)
819                                        (barcfg[i].ahbadr & ~(size - 1));
820                j++;
821        }
822
823        /* End table */
824        priv->maps_up[j].size = 0;
825
826        return 0;
827}
828
829/* Called when a core is found with the AMBA device and vendor ID
830 * given in grpci2_ids[]. IRQ, Console does not work here
831 */
832int grpci2_init1(struct drvmgr_dev *dev)
833{
834        int status;
835        struct grpci2_priv *priv;
836        struct pci_auto_setup grpci2_auto_cfg;
837
838        DBG("GRPCI2[%d] on bus %s\n", dev->minor_drv, dev->parent->dev->name);
839
840        if (grpci2priv) {
841                DBG("Driver only supports one PCI core\n");
842                return DRVMGR_FAIL;
843        }
844
845        if ((strcmp(dev->parent->dev->drv->name, "AMBAPP_GRLIB_DRV") != 0) &&
846            (strcmp(dev->parent->dev->drv->name, "AMBAPP_LEON2_DRV") != 0)) {
847                /* We only support GRPCI2 driver on local bus */
848                return DRVMGR_FAIL;
849        }
850
851        priv = dev->priv;
852        if (!priv)
853                return DRVMGR_NOMEM;
854
855        priv->dev = dev;
856        grpci2priv = priv;
857
858        /* Initialize GRPCI2 Hardware */
859        status = grpci2_init(priv);
860        if (status) {
861                printf("Failed to initialize grpci2 driver %d\n", status);
862                return -1;
863        }
864
865        /* Register the PCI core at the PCI layers */
866
867        if (priv->bt_enabled == 0) {
868                /* Host is Big-Endian */
869                pci_endian = PCI_BIG_ENDIAN;
870
871                memcpy(&grpci2_access_drv.io, &grpci2_io_ops_be,
872                                                sizeof(grpci2_io_ops_be));
873                grpci2_access_drv.memreg = &pci_memreg_sparc_be_ops;
874        }
875
876        if (pci_access_drv_register(&grpci2_access_drv)) {
877                /* Access routines registration failed */
878                return DRVMGR_FAIL;
879        }
880
881        /* Prepare memory MAP */
882        grpci2_auto_cfg.options = 0;
883        grpci2_auto_cfg.mem_start = 0;
884        grpci2_auto_cfg.mem_size = 0;
885        grpci2_auto_cfg.memio_start = priv->pci_area;
886        grpci2_auto_cfg.memio_size = priv->pci_area_end - priv->pci_area;
887        grpci2_auto_cfg.io_start = 0x100; /* avoid PCI address 0 */
888        grpci2_auto_cfg.io_size = 0x10000 - 0x100; /* lower 64kB I/O 16 */
889        grpci2_auto_cfg.irq_map = grpci2_bus0_irq_map;
890        grpci2_auto_cfg.irq_route = NULL; /* use standard routing */
891        pci_config_register(&grpci2_auto_cfg);
892
893        if (pci_config_init()) {
894                /* PCI configuration failed */
895                return DRVMGR_FAIL;
896        }
897
898        /* Initialize/Register Driver Manager PCI Bus */
899        priv->config.maps_down = &priv->maps_down[0];
900        priv->config.maps_up = &priv->maps_up[0];
901        return pcibus_register(dev, &priv->config);
902}
903
904int grpci2_init3(struct drvmgr_dev *dev)
905{
906        struct grpci2_priv *priv = dev->priv;
907
908        /* Install and Enable PCI Error interrupt handler */
909        drvmgr_interrupt_register(dev, 0, "grpci2", grpci2_err_isr, priv);
910
911        /* Unmask Error IRQ and all PCI interrupts at PCI Core. For this to be
912         * safe every PCI board have to be resetted (no IRQ generation) before
913         * Global IRQs are enabled (Init is reached or similar)
914         */
915        priv->regs->ctrl |= (CTRL_EI | priv->irq_mask);
916
917        return DRVMGR_OK;
918}
Note: See TracBrowser for help on using the repository browser.