]> git.sur5r.net Git - u-boot/blob - cpu/ixp/pci.c
ads5121: fix compiler warnings (unused variables)
[u-boot] / cpu / ixp / pci.c
1 /*
2  * IXP PCI Init
3  * (C) Copyright 2004 eslab.whut.edu.cn
4  * Yue Hu(huyue_whut@yahoo.com.cn), Ligong Xue(lgxue@hotmail.com)
5  *
6  * See file CREDITS for list of people who contributed to this
7  * project.
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License as
11  * published by the Free Software Foundation; either version 2 of
12  * the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
22  * MA 02111-1307 USA
23  */
24
25
26 #include <common.h>
27
28 #ifdef CONFIG_PCI
29
30 #include <asm/processor.h>
31 #include <asm/io.h>
32 #include <pci.h>
33 #include <asm/arch/ixp425.h>
34 #include <asm/arch/ixp425pci.h>
35
36 static void non_prefetch_read (unsigned int addr, unsigned int cmd,
37                                unsigned int *data);
38 static void non_prefetch_write (unsigned int addr, unsigned int cmd,
39                                 unsigned int data);
40 static void configure_pins (void);
41 static void sys_pci_gpio_clock_config (void);
42 static void pci_bus_scan (void);
43 static int pci_device_exists (unsigned int deviceNo);
44 static void sys_pci_bar_info_get (unsigned int devnum, unsigned int bus,
45                                   unsigned int dev, unsigned int func);
46 static void sys_pci_device_bars_write (void);
47 static void calc_bars (PciBar * Bars[], unsigned int nBars,
48                        unsigned int startAddr);
49
50 #define PCI_MEMORY_BUS          0x00000000
51 #define PCI_MEMORY_PHY          0x48000000
52 #define PCI_MEMORY_SIZE         0x04000000
53
54 #define PCI_MEM_BUS             0x40000000
55 #define PCI_MEM_PHY             0x00000000
56 #define PCI_MEM_SIZE            0x04000000
57
58 #define PCI_IO_BUS              0x40000000
59 #define PCI_IO_PHY              0x50000000
60 #define PCI_IO_SIZE             0x10000000
61
62 struct pci_controller hose;
63
64 unsigned int nDevices;
65 unsigned int nMBars;
66 unsigned int nIOBars;
67 PciBar *memBars[IXP425_PCI_MAX_BAR];
68 PciBar *ioBars[IXP425_PCI_MAX_BAR];
69 PciDevice devices[IXP425_PCI_MAX_FUNC_ON_BUS];
70
71 int pci_read_config_dword (pci_dev_t dev, int where, unsigned int *val)
72 {
73         unsigned int retval;
74         unsigned int addr;
75
76         /*address bits 31:28 specify the device 10:8 specify the function */
77         /*Set the address to be read */
78         addr = BIT ((31 - dev)) | (where & ~3);
79         non_prefetch_read (addr, NP_CMD_CONFIGREAD, &retval);
80
81         *val = retval;
82
83         return (OK);
84 }
85
86 int pci_read_config_word (pci_dev_t dev, int where, unsigned short *val)
87 {
88         unsigned int n;
89         unsigned int retval;
90         unsigned int addr;
91         unsigned int byteEnables;
92
93         n = where % 4;
94         /*byte enables are 4 bits active low, the position of each
95            bit maps to the byte that it enables */
96         byteEnables =
97                 (~(BIT (n) | BIT ((n + 1)))) &
98                 IXP425_PCI_BOTTOM_NIBBLE_OF_LONG_MASK;
99         byteEnables = byteEnables << PCI_NP_CBE_BESL;
100         /*address bits 31:28 specify the device 10:8 specify the function */
101         /*Set the address to be read */
102         addr = BIT ((31 - dev)) | (where & ~3);
103         non_prefetch_read (addr, byteEnables | NP_CMD_CONFIGREAD, &retval);
104
105         /*Pick out the word we are interested in */
106         *val = (retval >> (8 * n));
107
108         return (OK);
109 }
110
111 int pci_read_config_byte (pci_dev_t dev, int where, unsigned char *val)
112 {
113         unsigned int retval;
114         unsigned int n;
115         unsigned int byteEnables;
116         unsigned int addr;
117
118         n = where % 4;
119         /*byte enables are 4 bits, active low, the position of each
120            bit maps to the byte that it enables */
121         byteEnables = (~BIT (n)) & IXP425_PCI_BOTTOM_NIBBLE_OF_LONG_MASK;
122         byteEnables = byteEnables << PCI_NP_CBE_BESL;
123
124         /*address bits 31:28 specify the device, 10:8 specify the function */
125         /*Set the address to be read */
126         addr = BIT ((31 - dev)) | (where & ~3);
127         non_prefetch_read (addr, byteEnables | NP_CMD_CONFIGREAD, &retval);
128         /*Pick out the byte we are interested in */
129         *val = (retval >> (8 * n));
130
131         return (OK);
132 }
133
134 int pci_write_config_byte (pci_dev_t dev, int where, unsigned char val)
135 {
136         unsigned int addr;
137         unsigned int byteEnables;
138         unsigned int n;
139         unsigned int ldata;
140
141         n = where % 4;
142         /*byte enables are 4 bits active low, the position of each
143            bit maps to the byte that it enables */
144         byteEnables = (~BIT (n)) & IXP425_PCI_BOTTOM_NIBBLE_OF_LONG_MASK;
145         byteEnables = byteEnables << PCI_NP_CBE_BESL;
146         ldata = val << (8 * n);
147         /*address bits 31:28 specify the device 10:8 specify the function */
148         /*Set the address to be written */
149         addr = BIT ((31 - dev)) | (where & ~3);
150         non_prefetch_write (addr, byteEnables | NP_CMD_CONFIGWRITE, ldata);
151
152         return (OK);
153 }
154
155 int pci_write_config_word (pci_dev_t dev, int where, unsigned short val)
156 {
157         unsigned int addr;
158         unsigned int byteEnables;
159         unsigned int n;
160         unsigned int ldata;
161
162         n = where % 4;
163         /*byte enables are 4 bits active low, the position of each
164            bit maps to the byte that it enables */
165         byteEnables =
166                 (~(BIT (n) | BIT ((n + 1)))) &
167                 IXP425_PCI_BOTTOM_NIBBLE_OF_LONG_MASK;
168         byteEnables = byteEnables << PCI_NP_CBE_BESL;
169         ldata = val << (8 * n);
170         /*address bits 31:28 specify the device 10:8 specify the function */
171         /*Set the address to be written */
172         addr = BIT (31 - dev) | (where & ~3);
173         non_prefetch_write (addr, byteEnables | NP_CMD_CONFIGWRITE, ldata);
174
175         return (OK);
176 }
177
178 int pci_write_config_dword (pci_dev_t dev, int where, unsigned int val)
179 {
180         unsigned int addr;
181
182         /*address bits 31:28 specify the device 10:8 specify the function */
183         /*Set the address to be written */
184         addr = BIT (31 - dev) | (where & ~3);
185         non_prefetch_write (addr, NP_CMD_CONFIGWRITE, val);
186
187         return (OK);
188 }
189
190 void non_prefetch_read (unsigned int addr,
191                         unsigned int cmd, unsigned int *data)
192 {
193         REG_WRITE (PCI_CSR_BASE, PCI_NP_AD_OFFSET, addr);
194
195         /*set up and execute the read */
196         REG_WRITE (PCI_CSR_BASE, PCI_NP_CBE_OFFSET, cmd);
197
198         /*The result of the read is now in np_rdata */
199         REG_READ (PCI_CSR_BASE, PCI_NP_RDATA_OFFSET, *data);
200
201         return;
202 }
203
204 void non_prefetch_write (unsigned int addr,
205                          unsigned int cmd, unsigned int data)
206 {
207
208         REG_WRITE (PCI_CSR_BASE, PCI_NP_AD_OFFSET, addr);
209         /*set up the write */
210         REG_WRITE (PCI_CSR_BASE, PCI_NP_CBE_OFFSET, cmd);
211         /*Execute the write by writing to NP_WDATA */
212         REG_WRITE (PCI_CSR_BASE, PCI_NP_WDATA_OFFSET, data);
213
214         return;
215 }
216
217 /*
218  * PCI controller config registers are accessed through these functions
219  * i.e. these allow us to set up our own BARs etc.
220  */
221 void crp_read (unsigned int offset, unsigned int *data)
222 {
223         REG_WRITE (PCI_CSR_BASE, PCI_CRP_AD_CBE_OFFSET, offset);
224         REG_READ (PCI_CSR_BASE, PCI_CRP_RDATA_OFFSET, *data);
225 }
226
227 void crp_write (unsigned int offset, unsigned int data)
228 {
229         /*The CRP address register bit 16 indicates that we want to do a write */
230         REG_WRITE (PCI_CSR_BASE, PCI_CRP_AD_CBE_OFFSET,
231                    PCI_CRP_WRITE | offset);
232         REG_WRITE (PCI_CSR_BASE, PCI_CRP_WDATA_OFFSET, data);
233 }
234
235 /*struct pci_controller *hose*/
236 void pci_ixp_init (struct pci_controller *hose)
237 {
238         unsigned int regval;
239
240         hose->first_busno = 0;
241         hose->last_busno = 0x00;
242
243         /* System memory space */
244         pci_set_region (hose->regions + 0,
245                         PCI_MEMORY_BUS,
246                         PCI_MEMORY_PHY, PCI_MEMORY_SIZE, PCI_REGION_MEMORY);
247
248         /* PCI memory space */
249         pci_set_region (hose->regions + 1,
250                         PCI_MEM_BUS,
251                         PCI_MEM_PHY, PCI_MEM_SIZE, PCI_REGION_MEM);
252         /* PCI I/O space */
253         pci_set_region (hose->regions + 2,
254                         PCI_IO_BUS, PCI_IO_PHY, PCI_IO_SIZE, PCI_REGION_IO);
255
256         hose->region_count = 3;
257
258         pci_register_hose (hose);
259
260 /*
261  ==========================================================
262                 Init IXP PCI
263  ==========================================================
264 */
265         REG_READ (PCI_CSR_BASE, PCI_CSR_OFFSET, regval);
266         regval |= 1 << 2;
267         REG_WRITE (PCI_CSR_BASE, PCI_CSR_OFFSET, regval);
268
269         configure_pins ();
270
271         READ_GPIO_REG (IXP425_GPIO_GPOUTR, regval);
272         WRITE_GPIO_REG (IXP425_GPIO_GPOUTR, regval & (~(1 << 13)));
273         udelay (533);
274         sys_pci_gpio_clock_config ();
275         REG_WRITE (PCI_CSR_BASE, PCI_INTEN_OFFSET, 0);
276         udelay (100);
277         READ_GPIO_REG (IXP425_GPIO_GPOUTR, regval);
278         WRITE_GPIO_REG (IXP425_GPIO_GPOUTR, regval | (1 << 13));
279         udelay (533);
280         crp_write (PCI_CFG_BASE_ADDRESS_0, IXP425_PCI_BAR_0_DEFAULT);
281         crp_write (PCI_CFG_BASE_ADDRESS_1, IXP425_PCI_BAR_1_DEFAULT);
282         crp_write (PCI_CFG_BASE_ADDRESS_2, IXP425_PCI_BAR_2_DEFAULT);
283         crp_write (PCI_CFG_BASE_ADDRESS_3, IXP425_PCI_BAR_3_DEFAULT);
284         crp_write (PCI_CFG_BASE_ADDRESS_4, IXP425_PCI_BAR_4_DEFAULT);
285         crp_write (PCI_CFG_BASE_ADDRESS_5, IXP425_PCI_BAR_5_DEFAULT);
286         /*Setup PCI-AHB and AHB-PCI address mappings */
287         REG_WRITE (PCI_CSR_BASE, PCI_AHBMEMBASE_OFFSET,
288                    IXP425_PCI_AHBMEMBASE_DEFAULT);
289
290         REG_WRITE (PCI_CSR_BASE, PCI_AHBIOBASE_OFFSET,
291                    IXP425_PCI_AHBIOBASE_DEFAULT);
292
293         REG_WRITE (PCI_CSR_BASE, PCI_PCIMEMBASE_OFFSET,
294                    IXP425_PCI_PCIMEMBASE_DEFAULT);
295
296         crp_write (PCI_CFG_SUB_VENDOR_ID, IXP425_PCI_SUB_VENDOR_SYSTEM);
297
298         REG_READ (PCI_CSR_BASE, PCI_CSR_OFFSET, regval);
299         regval |= PCI_CSR_IC | PCI_CSR_ABE | PCI_CSR_PDS;
300         REG_WRITE (PCI_CSR_BASE, PCI_CSR_OFFSET, regval);
301         crp_write (PCI_CFG_COMMAND, PCI_CFG_CMD_MAE | PCI_CFG_CMD_BME);
302         udelay (1000);
303
304         pci_write_config_word (0, PCI_CFG_COMMAND, INITIAL_PCI_CMD);
305         REG_WRITE (PCI_CSR_BASE, PCI_ISR_OFFSET, PCI_ISR_PSE
306                    | PCI_ISR_PFE | PCI_ISR_PPE | PCI_ISR_AHBE);
307 #ifdef CONFIG_PCI_SCAN_SHOW
308         printf ("Device  bus  dev  func  deviceID  vendorID \n");
309 #endif
310         pci_bus_scan ();
311 }
312
313 void configure_pins (void)
314 {
315         unsigned int regval;
316
317         /* Disable clock on GPIO PIN 14 */
318         READ_GPIO_REG (IXP425_GPIO_GPCLKR, regval);
319         WRITE_GPIO_REG (IXP425_GPIO_GPCLKR, regval & (~(1 << 8)));
320         READ_GPIO_REG (IXP425_GPIO_GPCLKR, regval);
321
322         READ_GPIO_REG (IXP425_GPIO_GPOER, regval);
323         WRITE_GPIO_REG (IXP425_GPIO_GPOER,
324                         (((~(3 << 13)) & regval) | (0xf << 8)));
325         READ_GPIO_REG (IXP425_GPIO_GPOER, regval);
326
327         READ_GPIO_REG (IXP425_GPIO_GPIT2R, regval);
328         WRITE_GPIO_REG (IXP425_GPIO_GPIT2R,
329                         (regval &
330                          ((0x1 << 9) | (0x1 << 6) | (0x1 << 3) | 0x1)));
331         READ_GPIO_REG (IXP425_GPIO_GPIT2R, regval);
332
333         READ_GPIO_REG (IXP425_GPIO_GPISR, regval);
334         WRITE_GPIO_REG (IXP425_GPIO_GPISR, (regval | (0xf << 8)));
335         READ_GPIO_REG (IXP425_GPIO_GPISR, regval);
336 }
337
338 void sys_pci_gpio_clock_config (void)
339 {
340         unsigned int regval;
341
342         READ_GPIO_REG (IXP425_GPIO_GPCLKR, regval);
343         regval |= 0x1 << 4;
344         WRITE_GPIO_REG (IXP425_GPIO_GPCLKR, regval);
345         READ_GPIO_REG (IXP425_GPIO_GPCLKR, regval);
346         regval |= 0x1 << 8;
347         WRITE_GPIO_REG (IXP425_GPIO_GPCLKR, regval);
348 }
349
350 void pci_bus_scan (void)
351 {
352         unsigned int bus = 0, dev, func = 0;
353         unsigned short data16;
354         unsigned int data32;
355         unsigned char intPin;
356
357         /* Assign first device to ourselves */
358         devices[0].bus = 0;
359         devices[0].device = 0;
360         devices[0].func = 0;
361
362         crp_read (PCI_CFG_VENDOR_ID, &data32);
363
364         devices[0].vendor_id = data32 & IXP425_PCI_BOTTOM_WORD_OF_LONG_MASK;
365         devices[0].device_id = data32 >> 16;
366         devices[0].error = FALSE;
367         devices[0].bar[NO_BAR].size = 0;        /*dummy - required */
368
369         nDevices = 1;
370
371         nMBars = 0;
372         nIOBars = 0;
373
374         for (dev = 0; dev < IXP425_PCI_MAX_DEV; dev++) {
375
376                 /*Check whether a device is present */
377                 if (pci_device_exists (dev) != TRUE) {
378
379                         /*Clear error bits in ISR, write 1 to clear */
380                         REG_WRITE (PCI_CSR_BASE, PCI_ISR_OFFSET, PCI_ISR_PSE
381                                    | PCI_ISR_PFE | PCI_ISR_PPE |
382                                    PCI_ISR_AHBE);
383                         continue;
384                 }
385
386                 /*A device is present, add an entry to the array */
387                 devices[nDevices].bus = bus;
388                 devices[nDevices].device = dev;
389                 devices[nDevices].func = func;
390
391                 pci_read_config_word (dev, PCI_CFG_VENDOR_ID, &data16);
392
393                 devices[nDevices].vendor_id = data16;
394
395                 pci_read_config_word (dev, PCI_CFG_DEVICE_ID, &data16);
396                 devices[nDevices].device_id = data16;
397
398                 /*The device is functioning correctly, set error to FALSE */
399                 devices[nDevices].error = FALSE;
400
401                 /*Figure out what BARs are on this device */
402                 sys_pci_bar_info_get (nDevices, bus, dev, func);
403                 /*Figure out what INTX# line the card uses */
404                 pci_read_config_byte (dev, PCI_CFG_DEV_INT_PIN, &intPin);
405
406                 /*assign the appropriate irq line */
407                 if (intPin > PCI_IRQ_LINES) {
408                         devices[nDevices].error = TRUE;
409                 } else if (intPin != 0) {
410                         /*This device uses an interrupt line */
411                         /*devices[nDevices].irq = ixp425PciIntTranslate[dev][intPin-1]; */
412                         devices[nDevices].irq = intPin;
413                 }
414 #ifdef CONFIG_PCI_SCAN_SHOW
415                 printf ("%06d    %03d %03d %04d  %08d      %08x\n", nDevices,
416                         devices[nDevices].vendor_id);
417 #endif
418                 nDevices++;
419
420         }
421
422         calc_bars (memBars, nMBars, IXP425_PCI_BAR_MEM_BASE);
423         sys_pci_device_bars_write ();
424
425         REG_WRITE (PCI_CSR_BASE, PCI_ISR_OFFSET, PCI_ISR_PSE
426                    | PCI_ISR_PFE | PCI_ISR_PPE | PCI_ISR_AHBE);
427 }
428
429 void sys_pci_bar_info_get (unsigned int devnum,
430                            unsigned int bus,
431                            unsigned int dev, unsigned int func)
432 {
433         unsigned int data32;
434         unsigned int tmp;
435         unsigned int size;
436
437         pci_write_config_dword (devnum,
438                                 PCI_CFG_BASE_ADDRESS_0, IXP425_PCI_BAR_QUERY);
439         pci_read_config_dword (devnum, PCI_CFG_BASE_ADDRESS_0, &data32);
440
441         devices[devnum].bar[0].address = (data32 & 1);
442
443         if (data32 & 1) {
444                 /* IO space */
445                 tmp = data32 & ~0x3;
446                 size = ~(tmp - 1);
447                 devices[devnum].bar[0].size = size;
448
449                 if (nIOBars < IXP425_PCI_MAX_BAR) {
450                         ioBars[nIOBars++] = &devices[devnum].bar[0];
451                 }
452         } else {
453                 /* Mem space */
454                 tmp = data32 & ~IXP425_PCI_BOTTOM_NIBBLE_OF_LONG_MASK;
455                 size = ~(tmp - 1);
456                 devices[devnum].bar[0].size = size;
457
458                 if (nMBars < IXP425_PCI_MAX_BAR) {
459                         memBars[nMBars++] = &devices[devnum].bar[0];
460                 } else {
461                         devices[devnum].error = TRUE;
462                 }
463
464         }
465
466         devices[devnum].bar[1].size = 0;
467 }
468
469 void sortBars (PciBar * Bars[], unsigned int nBars)
470 {
471         unsigned int i, j;
472         PciBar *tmp;
473
474         if (nBars == 0) {
475                 return;
476         }
477
478         /* Sort biggest to smallest */
479         for (i = 0; i < nBars - 1; i++) {
480                 for (j = i + 1; j < nBars; j++) {
481                         if (Bars[j]->size > Bars[i]->size) {
482                                 /* swap them */
483                                 tmp = Bars[i];
484                                 Bars[i] = Bars[j];
485                                 Bars[j] = tmp;
486                         }
487                 }
488         }
489 }
490
491 void calc_bars (PciBar * Bars[], unsigned int nBars, unsigned int startAddr)
492 {
493         unsigned int i;
494
495         if (nBars == 0) {
496                 return;
497         }
498
499         for (i = 0; i < nBars; i++) {
500                 Bars[i]->address |= startAddr;
501                 startAddr += Bars[i]->size;
502         }
503 }
504
505 void sys_pci_device_bars_write (void)
506 {
507         unsigned int i;
508         int addr;
509
510         for (i = 1; i < nDevices; i++) {
511                 if (devices[i].error) {
512                         continue;
513                 }
514
515                 pci_write_config_dword (devices[i].device,
516                                         PCI_CFG_BASE_ADDRESS_0,
517                                         devices[i].bar[0].address);
518                 addr = BIT (31 - devices[i].device) |
519                         (0 << PCI_NP_AD_FUNCSL) |
520                         (PCI_CFG_BASE_ADDRESS_0 & ~3);
521                 pci_write_config_dword (devices[i].device,
522                                         PCI_CFG_DEV_INT_LINE, devices[i].irq);
523
524                 pci_write_config_word (devices[i].device,
525                                        PCI_CFG_COMMAND, INITIAL_PCI_CMD);
526
527         }
528 }
529
530
531 int pci_device_exists (unsigned int deviceNo)
532 {
533         unsigned int vendorId;
534         unsigned int regval;
535
536         pci_read_config_dword (deviceNo, PCI_CFG_VENDOR_ID, &vendorId);
537
538         /* There are two ways to find out an empty device.
539          *   1. check Master Abort bit after the access.
540          *   2. check whether the vendor id read back is 0x0.
541          */
542         REG_READ (PCI_CSR_BASE, PCI_ISR_OFFSET, regval);
543         if ((vendorId != 0x0) && ((regval & PCI_ISR_PFE) == 0)) {
544                 return TRUE;
545         }
546         /*no device present, make sure that the master abort bit is reset */
547
548         REG_WRITE (PCI_CSR_BASE, PCI_ISR_OFFSET, PCI_ISR_PFE);
549         return FALSE;
550 }
551
552 pci_dev_t pci_find_devices (struct pci_device_id * ids, int devNo)
553 {
554         unsigned int i;
555         unsigned int devdidvid;
556         unsigned int didvid;
557         unsigned int vendorId, deviceId;
558
559         vendorId = ids->vendor;
560         deviceId = ids->device;
561         didvid = ((deviceId << 16) & IXP425_PCI_TOP_WORD_OF_LONG_MASK) |
562                 (vendorId & IXP425_PCI_BOTTOM_WORD_OF_LONG_MASK);
563
564         for (i = devNo + 1; i < nDevices; i++) {
565
566                 pci_read_config_dword (devices[i].device, PCI_CFG_VENDOR_ID,
567                                        &devdidvid);
568
569                 if (devdidvid == didvid) {
570                         return devices[i].device;
571                 }
572         }
573         return -1;
574 }
575 #endif  /* CONFIG_PCI */