2 * Copyright 2003 PMC-Sierra
3 * Author: Manish Lachwani (lachwani@pmc-sierra.com)
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2 of the License, or (at your
8 * option) any later version.
10 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
11 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
13 * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
14 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
15 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
16 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
17 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
18 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
19 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
21 * You should have received a copy of the GNU General Public License along
22 * with this program; if not, write to the Free Software Foundation, Inc.,
23 * 675 Mass Ave, Cambridge, MA 02139, USA.
26 #include <linux/config.h>
27 #include <linux/types.h>
28 #include <linux/pci.h>
29 #include <linux/kernel.h>
30 #include <linux/slab.h>
34 #include <linux/init.h>
35 #include <asm/titan_dep.h>
37 #ifdef CONFIG_HYPERTRANSPORT
41 * This function check if the Hypertransport Link Initialization completed. If
42 * it did, then proceed further with scanning bus #2
44 static __inline__
int check_titan_htlink(void)
48 val
= *(volatile uint32_t *)(RM9000x2_HTLINK_REG
);
50 /* HT Link Initialization completed */
56 static int titan_ht_config_read_dword(struct pci_dev
*device
,
60 uint32_t address_reg
, data_reg
;
63 bus
= device
->bus
->number
;
64 dev
= PCI_SLOT(device
->devfn
);
65 func
= PCI_FUNC(device
->devfn
);
67 /* XXX Need to change the Bus # */
69 address
= (bus
<< 16) | (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) |
72 address
= (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) | 0x80000000;
74 address_reg
= RM9000x2_OCD_HTCFGA
;
75 data_reg
= RM9000x2_OCD_HTCFGD
;
77 RM9K_WRITE(address_reg
, address
);
78 RM9K_READ(data_reg
, val
);
80 return PCIBIOS_SUCCESSFUL
;
84 static int titan_ht_config_read_word(struct pci_dev
*device
,
88 uint32_t address_reg
, data_reg
;
91 bus
= device
->bus
->number
;
92 dev
= PCI_SLOT(device
->devfn
);
93 func
= PCI_FUNC(device
->devfn
);
95 /* XXX Need to change the Bus # */
97 address
= (bus
<< 16) | (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) |
100 address
= (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) | 0x80000000;
102 address_reg
= RM9000x2_OCD_HTCFGA
;
103 data_reg
= RM9000x2_OCD_HTCFGD
;
105 if ((offset
& 0x3) == 0)
110 RM9K_WRITE(address_reg
, address
);
111 RM9K_READ_16(data_reg
+ offset
, val
);
113 return PCIBIOS_SUCCESSFUL
;
117 u32
longswap(unsigned long l
)
119 unsigned char b1
,b2
,b3
,b4
;
126 return ((b1
<<24) + (b2
<<16) + (b3
<<8) + b4
);
130 static int titan_ht_config_read_byte(struct pci_dev
*device
,
134 uint32_t address_reg
, data_reg
;
138 bus
= device
->bus
->number
;
139 dev
= PCI_SLOT(device
->devfn
);
140 func
= PCI_FUNC(device
->devfn
);
142 /* XXX Need to change the Bus # */
144 address
= (bus
<< 16) | (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) |
147 address
= (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) | 0x80000000;
149 address_reg
= RM9000x2_OCD_HTCFGA
;
150 data_reg
= RM9000x2_OCD_HTCFGD
;
152 RM9K_WRITE(address_reg
, address
);
154 if ((offset
& 0x3) == 0) {
157 if ((offset
& 0x3) == 1) {
160 if ((offset
& 0x3) == 2) {
163 if ((offset
& 0x3) == 3) {
166 RM9K_READ_8(data_reg
+ offset1
, val
);
168 return PCIBIOS_SUCCESSFUL
;
172 static int titan_ht_config_write_dword(struct pci_dev
*device
,
176 uint32_t address_reg
, data_reg
;
179 bus
= device
->bus
->number
;
180 dev
= PCI_SLOT(device
->devfn
);
181 func
= PCI_FUNC(device
->devfn
);
183 /* XXX Need to change the Bus # */
185 address
= (bus
<< 16) | (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) |
188 address
= (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) | 0x80000000;
190 address_reg
= RM9000x2_OCD_HTCFGA
;
191 data_reg
= RM9000x2_OCD_HTCFGD
;
193 RM9K_WRITE(address_reg
, address
);
194 RM9K_WRITE(data_reg
, val
);
196 return PCIBIOS_SUCCESSFUL
;
199 static int titan_ht_config_write_word(struct pci_dev
*device
,
203 uint32_t address_reg
, data_reg
;
206 bus
= device
->bus
->number
;
207 dev
= PCI_SLOT(device
->devfn
);
208 func
= PCI_FUNC(device
->devfn
);
210 /* XXX Need to change the Bus # */
212 address
= (bus
<< 16) | (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) |
215 address
= (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) | 0x80000000;
217 address_reg
= RM9000x2_OCD_HTCFGA
;
218 data_reg
= RM9000x2_OCD_HTCFGD
;
220 if ((offset
& 0x3) == 0)
225 RM9K_WRITE(address_reg
, address
);
226 RM9K_WRITE_16(data_reg
+ offset
, val
);
228 return PCIBIOS_SUCCESSFUL
;
231 static int titan_ht_config_write_byte(struct pci_dev
*device
,
235 uint32_t address_reg
, data_reg
;
239 bus
= device
->bus
->number
;
240 dev
= PCI_SLOT(device
->devfn
);
241 func
= PCI_FUNC(device
->devfn
);
243 /* XXX Need to change the Bus # */
245 address
= (bus
<< 16) | (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) |
248 address
= (dev
<< 11) | (func
<< 8) | (offset
& 0xfc) | 0x80000000;
250 address_reg
= RM9000x2_OCD_HTCFGA
;
251 data_reg
= RM9000x2_OCD_HTCFGD
;
253 RM9K_WRITE(address_reg
, address
);
255 if ((offset
& 0x3) == 0) {
258 if ((offset
& 0x3) == 1) {
261 if ((offset
& 0x3) == 2) {
264 if ((offset
& 0x3) == 3) {
268 RM9K_WRITE_8(data_reg
+ offset1
, val
);
269 return PCIBIOS_SUCCESSFUL
;
273 static void titan_pcibios_set_master(struct pci_dev
*dev
)
276 int bus
= dev
->bus
->number
;
278 if (check_titan_htlink())
279 titan_ht_config_read_word(dev
, PCI_COMMAND
, &cmd
);
281 cmd
|= PCI_COMMAND_MASTER
;
283 if (check_titan_htlink())
284 titan_ht_config_write_word(dev
, PCI_COMMAND
, cmd
);
288 int pcibios_enable_resources(struct pci_dev
*dev
)
294 int bus
= dev
->bus
->number
;
296 if (check_titan_htlink())
297 titan_ht_config_read_word(dev
, PCI_COMMAND
, &cmd
);
300 for (idx
= 0; idx
< 6; idx
++) {
301 r
= &dev
->resource
[idx
];
302 if (!r
->start
&& r
->end
) {
304 "PCI: Device %s not available because of "
305 "resource collisions\n", pci_name(dev
));
308 if (r
->flags
& IORESOURCE_IO
)
309 cmd
|= PCI_COMMAND_IO
;
310 if (r
->flags
& IORESOURCE_MEM
)
311 cmd
|= PCI_COMMAND_MEMORY
;
313 if (cmd
!= old_cmd
) {
314 if (check_titan_htlink())
315 titan_ht_config_write_word(dev
, PCI_COMMAND
, cmd
);
318 if (check_titan_htlink())
319 titan_ht_config_read_byte(dev
, PCI_CACHE_LINE_SIZE
, &tmp1
);
322 printk(KERN_WARNING
"PCI setting cache line size to 8 from "
326 if (check_titan_htlink())
327 titan_ht_config_write_byte(dev
, PCI_CACHE_LINE_SIZE
, 8);
329 if (check_titan_htlink())
330 titan_ht_config_read_byte(dev
, PCI_LATENCY_TIMER
, &tmp1
);
332 if (tmp1
< 32 || tmp1
== 0xff) {
333 printk(KERN_WARNING
"PCI setting latency timer to 32 from %d\n",
337 if (check_titan_htlink())
338 titan_ht_config_write_byte(dev
, PCI_LATENCY_TIMER
, 32);
344 int pcibios_enable_device(struct pci_dev
*dev
, int mask
)
346 return pcibios_enable_resources(dev
);
351 void pcibios_update_resource(struct pci_dev
*dev
, struct resource
*root
,
352 struct resource
*res
, int resource
)
359 new = res
->start
| (res
->flags
& PCI_REGION_FLAG_MASK
);
361 reg
= PCI_BASE_ADDRESS_0
+ 4 * resource
;
362 } else if (resource
== PCI_ROM_RESOURCE
) {
363 res
->flags
|= IORESOURCE_ROM_ENABLE
;
364 reg
= dev
->rom_base_reg
;
367 * Somebody might have asked allocation of a non-standard
373 pci_write_config_dword(dev
, reg
, new);
374 pci_read_config_dword(dev
, reg
, &check
);
376 ((new & PCI_BASE_ADDRESS_SPACE_IO
) ? PCI_BASE_ADDRESS_IO_MASK
:
377 PCI_BASE_ADDRESS_MEM_MASK
)) {
378 printk(KERN_ERR
"PCI: Error while updating region "
379 "%s/%d (%08x != %08x)\n", pci_name(dev
), resource
,
385 void pcibios_align_resource(void *data
, struct resource
*res
,
386 unsigned long size
, unsigned long align
)
388 struct pci_dev
*dev
= data
;
390 if (res
->flags
& IORESOURCE_IO
) {
391 unsigned long start
= res
->start
;
393 /* We need to avoid collisions with `mirrored' VGA ports
394 and other strange ISA hardware, so we always want the
395 addresses kilobyte aligned. */
397 printk(KERN_ERR
"PCI: I/O Region %s/%d too large"
398 " (%ld bytes)\n", pci_name(dev
),
399 dev
->resource
- res
, size
);
402 start
= (start
+ 1024 - 1) & ~(1024 - 1);
407 struct pci_ops titan_pci_ops
= {
408 titan_ht_config_read_byte
,
409 titan_ht_config_read_word
,
410 titan_ht_config_read_dword
,
411 titan_ht_config_write_byte
,
412 titan_ht_config_write_word
,
413 titan_ht_config_write_dword
416 void __init
pcibios_fixup_bus(struct pci_bus
*c
)
418 titan_ht_pcibios_fixup_bus(c
);
421 void __init
pcibios_init(void)
424 /* Reset PCI I/O and PCI MEM values */
425 /* XXX Need to add the proper values here */
426 ioport_resource
.start
= 0xe0000000;
427 ioport_resource
.end
= 0xe0000000 + 0x20000000 - 1;
428 iomem_resource
.start
= 0xc0000000;
429 iomem_resource
.end
= 0xc0000000 + 0x20000000 - 1;
431 /* XXX Need to add bus values */
432 pci_scan_bus(2, &titan_pci_ops
, NULL
);
433 pci_scan_bus(3, &titan_pci_ops
, NULL
);
437 * for parsing "pci=" kernel boot arguments.
439 char *pcibios_setup(char *str
)
441 printk(KERN_INFO
"rr: pcibios_setup\n");
442 /* Nothing to do for now. */
447 unsigned __init
int pcibios_assign_all_busses(void)
449 /* We want to use the PCI bus detection done by PMON */
453 #endif /* CONFIG_HYPERTRANSPORT */