← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to arch/tile/kernel/pci.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/tile/kernel/pci.c
 
1
/*
 
2
 * Copyright 2011 Tilera Corporation. All Rights Reserved.
 
3
 *
 
4
 *   This program is free software; you can redistribute it and/or
 
5
 *   modify it under the terms of the GNU General Public License
 
6
 *   as published by the Free Software Foundation, version 2.
 
7
 *
 
8
 *   This program is distributed in the hope that it will be useful, but
 
9
 *   WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 
11
 *   NON INFRINGEMENT.  See the GNU General Public License for
 
12
 *   more details.
 
13
 */
 
14
 
 
15
#include <linux/kernel.h>
 
16
#include <linux/pci.h>
 
17
#include <linux/delay.h>
 
18
#include <linux/string.h>
 
19
#include <linux/init.h>
 
20
#include <linux/capability.h>
 
21
#include <linux/sched.h>
 
22
#include <linux/errno.h>
 
23
#include <linux/bootmem.h>
 
24
#include <linux/irq.h>
 
25
#include <linux/io.h>
 
26
#include <linux/uaccess.h>
 
27
#include <linux/export.h>
 
28
 
 
29
#include <asm/processor.h>
 
30
#include <asm/sections.h>
 
31
#include <asm/byteorder.h>
 
32
#include <asm/hv_driver.h>
 
33
#include <hv/drv_pcie_rc_intf.h>
 
34
 
 
35
 
 
36
/*
 
37
 * Initialization flow and process
 
38
 * -------------------------------
 
39
 *
 
40
 * This files contains the routines to search for PCI buses,
 
41
 * enumerate the buses, and configure any attached devices.
 
42
 *
 
43
 * There are two entry points here:
 
44
 * 1) tile_pci_init
 
45
 *    This sets up the pci_controller structs, and opens the
 
46
 *    FDs to the hypervisor.  This is called from setup_arch() early
 
47
 *    in the boot process.
 
48
 * 2) pcibios_init
 
49
 *    This probes the PCI bus(es) for any attached hardware.  It's
 
50
 *    called by subsys_initcall.  All of the real work is done by the
 
51
 *    generic Linux PCI layer.
 
52
 *
 
53
 */
 
54
 
 
55
/*
 
56
 * This flag tells if the platform is TILEmpower that needs
 
57
 * special configuration for the PLX switch chip.
 
58
 */
 
59
int __write_once tile_plx_gen1;
 
60
 
 
61
static struct pci_controller controllers[TILE_NUM_PCIE];
 
62
static int num_controllers;
 
63
static int pci_scan_flags[TILE_NUM_PCIE];
 
64
 
 
65
static struct pci_ops tile_cfg_ops;
 
66
 
 
67
 
 
68
/*
 
69
 * We don't need to worry about the alignment of resources.
 
70
 */
 
71
resource_size_t pcibios_align_resource(void *data, const struct resource *res,
 
72
                            resource_size_t size, resource_size_t align)
 
73
{
 
74
        return res->start;
 
75
}
 
76
EXPORT_SYMBOL(pcibios_align_resource);
 
77
 
 
78
/*
 
79
 * Open a FD to the hypervisor PCI device.
 
80
 *
 
81
 * controller_id is the controller number, config type is 0 or 1 for
 
82
 * config0 or config1 operations.
 
83
 */
 
84
static int __devinit tile_pcie_open(int controller_id, int config_type)
 
85
{
 
86
        char filename[32];
 
87
        int fd;
 
88
 
 
89
        sprintf(filename, "pcie/%d/config%d", controller_id, config_type);
 
90
 
 
91
        fd = hv_dev_open((HV_VirtAddr)filename, 0);
 
92
 
 
93
        return fd;
 
94
}
 
95
 
 
96
 
 
97
/*
 
98
 * Get the IRQ numbers from the HV and set up the handlers for them.
 
99
 */
 
100
static int __devinit tile_init_irqs(int controller_id,
 
101
                                 struct pci_controller *controller)
 
102
{
 
103
        char filename[32];
 
104
        int fd;
 
105
        int ret;
 
106
        int x;
 
107
        struct pcie_rc_config rc_config;
 
108
 
 
109
        sprintf(filename, "pcie/%d/ctl", controller_id);
 
110
        fd = hv_dev_open((HV_VirtAddr)filename, 0);
 
111
        if (fd < 0) {
 
112
                pr_err("PCI: hv_dev_open(%s) failed\n", filename);
 
113
                return -1;
 
114
        }
 
115
        ret = hv_dev_pread(fd, 0, (HV_VirtAddr)(&rc_config),
 
116
                           sizeof(rc_config), PCIE_RC_CONFIG_MASK_OFF);
 
117
        hv_dev_close(fd);
 
118
        if (ret != sizeof(rc_config)) {
 
119
                pr_err("PCI: wanted %zd bytes, got %d\n",
 
120
                       sizeof(rc_config), ret);
 
121
                return -1;
 
122
        }
 
123
        /* Record irq_base so that we can map INTx to IRQ # later. */
 
124
        controller->irq_base = rc_config.intr;
 
125
 
 
126
        for (x = 0; x < 4; x++)
 
127
                tile_irq_activate(rc_config.intr + x,
 
128
                                  TILE_IRQ_HW_CLEAR);
 
129
 
 
130
        if (rc_config.plx_gen1)
 
131
                controller->plx_gen1 = 1;
 
132
 
 
133
        return 0;
 
134
}
 
135
 
 
136
/*
 
137
 * First initialization entry point, called from setup_arch().
 
138
 *
 
139
 * Find valid controllers and fill in pci_controller structs for each
 
140
 * of them.
 
141
 *
 
142
 * Returns the number of controllers discovered.
 
143
 */
 
144
int __devinit tile_pci_init(void)
 
145
{
 
146
        int i;
 
147
 
 
148
        pr_info("PCI: Searching for controllers...\n");
 
149
 
 
150
        /* Re-init number of PCIe controllers to support hot-plug feature. */
 
151
        num_controllers = 0;
 
152
 
 
153
        /* Do any configuration we need before using the PCIe */
 
154
 
 
155
        for (i = 0; i < TILE_NUM_PCIE; i++) {
 
156
                /*
 
157
                 * To see whether we need a real config op based on
 
158
                 * the results of pcibios_init(), to support PCIe hot-plug.
 
159
                 */
 
160
                if (pci_scan_flags[i] == 0) {
 
161
                        int hv_cfg_fd0 = -1;
 
162
                        int hv_cfg_fd1 = -1;
 
163
                        int hv_mem_fd = -1;
 
164
                        char name[32];
 
165
                        struct pci_controller *controller;
 
166
 
 
167
                        /*
 
168
                         * Open the fd to the HV.  If it fails then this
 
169
                         * device doesn't exist.
 
170
                         */
 
171
                        hv_cfg_fd0 = tile_pcie_open(i, 0);
 
172
                        if (hv_cfg_fd0 < 0)
 
173
                                continue;
 
174
                        hv_cfg_fd1 = tile_pcie_open(i, 1);
 
175
                        if (hv_cfg_fd1 < 0) {
 
176
                                pr_err("PCI: Couldn't open config fd to HV "
 
177
                                    "for controller %d\n", i);
 
178
                                goto err_cont;
 
179
                        }
 
180
 
 
181
                        sprintf(name, "pcie/%d/mem", i);
 
182
                        hv_mem_fd = hv_dev_open((HV_VirtAddr)name, 0);
 
183
                        if (hv_mem_fd < 0) {
 
184
                                pr_err("PCI: Could not open mem fd to HV!\n");
 
185
                                goto err_cont;
 
186
                        }
 
187
 
 
188
                        pr_info("PCI: Found PCI controller #%d\n", i);
 
189
 
 
190
                        controller = &controllers[i];
 
191
 
 
192
                        controller->index = i;
 
193
                        controller->hv_cfg_fd[0] = hv_cfg_fd0;
 
194
                        controller->hv_cfg_fd[1] = hv_cfg_fd1;
 
195
                        controller->hv_mem_fd = hv_mem_fd;
 
196
                        controller->first_busno = 0;
 
197
                        controller->last_busno = 0xff;
 
198
                        controller->ops = &tile_cfg_ops;
 
199
 
 
200
                        num_controllers++;
 
201
                        continue;
 
202
 
 
203
err_cont:
 
204
                        if (hv_cfg_fd0 >= 0)
 
205
                                hv_dev_close(hv_cfg_fd0);
 
206
                        if (hv_cfg_fd1 >= 0)
 
207
                                hv_dev_close(hv_cfg_fd1);
 
208
                        if (hv_mem_fd >= 0)
 
209
                                hv_dev_close(hv_mem_fd);
 
210
                        continue;
 
211
                }
 
212
        }
 
213
 
 
214
        /*
 
215
         * Before using the PCIe, see if we need to do any platform-specific
 
216
         * configuration, such as the PLX switch Gen 1 issue on TILEmpower.
 
217
         */
 
218
        for (i = 0; i < num_controllers; i++) {
 
219
                struct pci_controller *controller = &controllers[i];
 
220
 
 
221
                if (controller->plx_gen1)
 
222
                        tile_plx_gen1 = 1;
 
223
        }
 
224
 
 
225
        return num_controllers;
 
226
}
 
227
 
 
228
/*
 
229
 * (pin - 1) converts from the PCI standard's [1:4] convention to
 
230
 * a normal [0:3] range.
 
231
 */
 
232
static int tile_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
 
233
{
 
234
        struct pci_controller *controller =
 
235
                (struct pci_controller *)dev->sysdata;
 
236
        return (pin - 1) + controller->irq_base;
 
237
}
 
238
 
 
239
 
 
240
static void __devinit fixup_read_and_payload_sizes(void)
 
241
{
 
242
        struct pci_dev *dev = NULL;
 
243
        int smallest_max_payload = 0x1; /* Tile maxes out at 256 bytes. */
 
244
        int max_read_size = 0x2; /* Limit to 512 byte reads. */
 
245
        u16 new_values;
 
246
 
 
247
        /* Scan for the smallest maximum payload size. */
 
248
        while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
 
249
                int pcie_caps_offset;
 
250
                u32 devcap;
 
251
                int max_payload;
 
252
 
 
253
                pcie_caps_offset = pci_find_capability(dev, PCI_CAP_ID_EXP);
 
254
                if (pcie_caps_offset == 0)
 
255
                        continue;
 
256
 
 
257
                pci_read_config_dword(dev, pcie_caps_offset + PCI_EXP_DEVCAP,
 
258
                                      &devcap);
 
259
                max_payload = devcap & PCI_EXP_DEVCAP_PAYLOAD;
 
260
                if (max_payload < smallest_max_payload)
 
261
                        smallest_max_payload = max_payload;
 
262
        }
 
263
 
 
264
        /* Now, set the max_payload_size for all devices to that value. */
 
265
        new_values = (max_read_size << 12) | (smallest_max_payload << 5);
 
266
        while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
 
267
                int pcie_caps_offset;
 
268
                u16 devctl;
 
269
 
 
270
                pcie_caps_offset = pci_find_capability(dev, PCI_CAP_ID_EXP);
 
271
                if (pcie_caps_offset == 0)
 
272
                        continue;
 
273
 
 
274
                pci_read_config_word(dev, pcie_caps_offset + PCI_EXP_DEVCTL,
 
275
                                     &devctl);
 
276
                devctl &= ~(PCI_EXP_DEVCTL_PAYLOAD | PCI_EXP_DEVCTL_READRQ);
 
277
                devctl |= new_values;
 
278
                pci_write_config_word(dev, pcie_caps_offset + PCI_EXP_DEVCTL,
 
279
                                      devctl);
 
280
        }
 
281
}
 
282
 
 
283
 
 
284
/*
 
285
 * Second PCI initialization entry point, called by subsys_initcall.
 
286
 *
 
287
 * The controllers have been set up by the time we get here, by a call to
 
288
 * tile_pci_init.
 
289
 */
 
290
int __devinit pcibios_init(void)
 
291
{
 
292
        int i;
 
293
 
 
294
        pr_info("PCI: Probing PCI hardware\n");
 
295
 
 
296
        /*
 
297
         * Delay a bit in case devices aren't ready.  Some devices are
 
298
         * known to require at least 20ms here, but we use a more
 
299
         * conservative value.
 
300
         */
 
301
        mdelay(250);
 
302
 
 
303
        /* Scan all of the recorded PCI controllers.  */
 
304
        for (i = 0; i < TILE_NUM_PCIE; i++) {
 
305
                /*
 
306
                 * Do real pcibios init ops if the controller is initialized
 
307
                 * by tile_pci_init() successfully and not initialized by
 
308
                 * pcibios_init() yet to support PCIe hot-plug.
 
309
                 */
 
310
                if (pci_scan_flags[i] == 0 && controllers[i].ops != NULL) {
 
311
                        struct pci_controller *controller = &controllers[i];
 
312
                        struct pci_bus *bus;
 
313
 
 
314
                        if (tile_init_irqs(i, controller)) {
 
315
                                pr_err("PCI: Could not initialize IRQs\n");
 
316
                                continue;
 
317
                        }
 
318
 
 
319
                        pr_info("PCI: initializing controller #%d\n", i);
 
320
 
 
321
                        /*
 
322
                         * This comes from the generic Linux PCI driver.
 
323
                         *
 
324
                         * It reads the PCI tree for this bus into the Linux
 
325
                         * data structures.
 
326
                         *
 
327
                         * This is inlined in linux/pci.h and calls into
 
328
                         * pci_scan_bus_parented() in probe.c.
 
329
                         */
 
330
                        bus = pci_scan_bus(0, controller->ops, controller);
 
331
                        controller->root_bus = bus;
 
332
                        controller->last_busno = bus->subordinate;
 
333
                }
 
334
        }
 
335
 
 
336
        /* Do machine dependent PCI interrupt routing */
 
337
        pci_fixup_irqs(pci_common_swizzle, tile_map_irq);
 
338
 
 
339
        /*
 
340
         * This comes from the generic Linux PCI driver.
 
341
         *
 
342
         * It allocates all of the resources (I/O memory, etc)
 
343
         * associated with the devices read in above.
 
344
         */
 
345
        pci_assign_unassigned_resources();
 
346
 
 
347
        /* Configure the max_read_size and max_payload_size values. */
 
348
        fixup_read_and_payload_sizes();
 
349
 
 
350
        /* Record the I/O resources in the PCI controller structure. */
 
351
        for (i = 0; i < TILE_NUM_PCIE; i++) {
 
352
                /*
 
353
                 * Do real pcibios init ops if the controller is initialized
 
354
                 * by tile_pci_init() successfully and not initialized by
 
355
                 * pcibios_init() yet to support PCIe hot-plug.
 
356
                 */
 
357
                if (pci_scan_flags[i] == 0 && controllers[i].ops != NULL) {
 
358
                        struct pci_bus *root_bus = controllers[i].root_bus;
 
359
                        struct pci_bus *next_bus;
 
360
                        struct pci_dev *dev;
 
361
 
 
362
                        list_for_each_entry(dev, &root_bus->devices, bus_list) {
 
363
                                /*
 
364
                                 * Find the PCI host controller, ie. the 1st
 
365
                                 * bridge.
 
366
                                 */
 
367
                                if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI &&
 
368
                                        (PCI_SLOT(dev->devfn) == 0)) {
 
369
                                        next_bus = dev->subordinate;
 
370
                                        controllers[i].mem_resources[0] =
 
371
                                                *next_bus->resource[0];
 
372
                                        controllers[i].mem_resources[1] =
 
373
                                                 *next_bus->resource[1];
 
374
                                        controllers[i].mem_resources[2] =
 
375
                                                 *next_bus->resource[2];
 
376
 
 
377
                                        /* Setup flags. */
 
378
                                        pci_scan_flags[i] = 1;
 
379
 
 
380
                                        break;
 
381
                                }
 
382
                        }
 
383
                }
 
384
        }
 
385
 
 
386
        return 0;
 
387
}
 
388
subsys_initcall(pcibios_init);
 
389
 
 
390
/*
 
391
 * No bus fixups needed.
 
392
 */
 
393
void __devinit pcibios_fixup_bus(struct pci_bus *bus)
 
394
{
 
395
        /* Nothing needs to be done. */
 
396
}
 
397
 
 
398
/*
 
399
 * This can be called from the generic PCI layer, but doesn't need to
 
400
 * do anything.
 
401
 */
 
402
char __devinit *pcibios_setup(char *str)
 
403
{
 
404
        /* Nothing needs to be done. */
 
405
        return str;
 
406
}
 
407
 
 
408
/*
 
409
 * This is called from the generic Linux layer.
 
410
 */
 
411
void __devinit pcibios_update_irq(struct pci_dev *dev, int irq)
 
412
{
 
413
        pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
 
414
}
 
415
 
 
416
/*
 
417
 * Enable memory and/or address decoding, as appropriate, for the
 
418
 * device described by the 'dev' struct.
 
419
 *
 
420
 * This is called from the generic PCI layer, and can be called
 
421
 * for bridges or endpoints.
 
422
 */
 
423
int pcibios_enable_device(struct pci_dev *dev, int mask)
 
424
{
 
425
        u16 cmd, old_cmd;
 
426
        u8 header_type;
 
427
        int i;
 
428
        struct resource *r;
 
429
 
 
430
        pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
 
431
 
 
432
        pci_read_config_word(dev, PCI_COMMAND, &cmd);
 
433
        old_cmd = cmd;
 
434
        if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
 
435
                /*
 
436
                 * For bridges, we enable both memory and I/O decoding
 
437
                 * in call cases.
 
438
                 */
 
439
                cmd |= PCI_COMMAND_IO;
 
440
                cmd |= PCI_COMMAND_MEMORY;
 
441
        } else {
 
442
                /*
 
443
                 * For endpoints, we enable memory and/or I/O decoding
 
444
                 * only if they have a memory resource of that type.
 
445
                 */
 
446
                for (i = 0; i < 6; i++) {
 
447
                        r = &dev->resource[i];
 
448
                        if (r->flags & IORESOURCE_UNSET) {
 
449
                                pr_err("PCI: Device %s not available "
 
450
                                       "because of resource collisions\n",
 
451
                                       pci_name(dev));
 
452
                                return -EINVAL;
 
453
                        }
 
454
                        if (r->flags & IORESOURCE_IO)
 
455
                                cmd |= PCI_COMMAND_IO;
 
456
                        if (r->flags & IORESOURCE_MEM)
 
457
                                cmd |= PCI_COMMAND_MEMORY;
 
458
                }
 
459
        }
 
460
 
 
461
        /*
 
462
         * We only write the command if it changed.
 
463
         */
 
464
        if (cmd != old_cmd)
 
465
                pci_write_config_word(dev, PCI_COMMAND, cmd);
 
466
        return 0;
 
467
}
 
468
 
 
469
void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max)
 
470
{
 
471
        unsigned long start = pci_resource_start(dev, bar);
 
472
        unsigned long len = pci_resource_len(dev, bar);
 
473
        unsigned long flags = pci_resource_flags(dev, bar);
 
474
 
 
475
        if (!len)
 
476
                return NULL;
 
477
        if (max && len > max)
 
478
                len = max;
 
479
 
 
480
        if (!(flags & IORESOURCE_MEM)) {
 
481
                pr_info("PCI: Trying to map invalid resource %#lx\n", flags);
 
482
                start = 0;
 
483
        }
 
484
 
 
485
        return (void __iomem *)start;
 
486
}
 
487
EXPORT_SYMBOL(pci_iomap);
 
488
 
 
489
 
 
490
/****************************************************************
 
491
 *
 
492
 * Tile PCI config space read/write routines
 
493
 *
 
494
 ****************************************************************/
 
495
 
 
496
/*
 
497
 * These are the normal read and write ops
 
498
 * These are expanded with macros from  pci_bus_read_config_byte() etc.
 
499
 *
 
500
 * devfn is the combined PCI slot & function.
 
501
 *
 
502
 * offset is in bytes, from the start of config space for the
 
503
 * specified bus & slot.
 
504
 */
 
505
 
 
506
static int __devinit tile_cfg_read(struct pci_bus *bus,
 
507
                                   unsigned int devfn,
 
508
                                   int offset,
 
509
                                   int size,
 
510
                                   u32 *val)
 
511
{
 
512
        struct pci_controller *controller = bus->sysdata;
 
513
        int busnum = bus->number & 0xff;
 
514
        int slot = (devfn >> 3) & 0x1f;
 
515
        int function = devfn & 0x7;
 
516
        u32 addr;
 
517
        int config_mode = 1;
 
518
 
 
519
        /*
 
520
         * There is no bridge between the Tile and bus 0, so we
 
521
         * use config0 to talk to bus 0.
 
522
         *
 
523
         * If we're talking to a bus other than zero then we
 
524
         * must have found a bridge.
 
525
         */
 
526
        if (busnum == 0) {
 
527
                /*
 
528
                 * We fake an empty slot for (busnum == 0) && (slot > 0),
 
529
                 * since there is only one slot on bus 0.
 
530
                 */
 
531
                if (slot) {
 
532
                        *val = 0xFFFFFFFF;
 
533
                        return 0;
 
534
                }
 
535
                config_mode = 0;
 
536
        }
 
537
 
 
538
        addr = busnum << 20;            /* Bus in 27:20 */
 
539
        addr |= slot << 15;             /* Slot (device) in 19:15 */
 
540
        addr |= function << 12;         /* Function is in 14:12 */
 
541
        addr |= (offset & 0xFFF);       /* byte address in 0:11 */
 
542
 
 
543
        return hv_dev_pread(controller->hv_cfg_fd[config_mode], 0,
 
544
                            (HV_VirtAddr)(val), size, addr);
 
545
}
 
546
 
 
547
 
 
548
/*
 
549
 * See tile_cfg_read() for relevant comments.
 
550
 * Note that "val" is the value to write, not a pointer to that value.
 
551
 */
 
552
static int __devinit tile_cfg_write(struct pci_bus *bus,
 
553
                                    unsigned int devfn,
 
554
                                    int offset,
 
555
                                    int size,
 
556
                                    u32 val)
 
557
{
 
558
        struct pci_controller *controller = bus->sysdata;
 
559
        int busnum = bus->number & 0xff;
 
560
        int slot = (devfn >> 3) & 0x1f;
 
561
        int function = devfn & 0x7;
 
562
        u32 addr;
 
563
        int config_mode = 1;
 
564
        HV_VirtAddr valp = (HV_VirtAddr)&val;
 
565
 
 
566
        /*
 
567
         * For bus 0 slot 0 we use config 0 accesses.
 
568
         */
 
569
        if (busnum == 0) {
 
570
                /*
 
571
                 * We fake an empty slot for (busnum == 0) && (slot > 0),
 
572
                 * since there is only one slot on bus 0.
 
573
                 */
 
574
                if (slot)
 
575
                        return 0;
 
576
                config_mode = 0;
 
577
        }
 
578
 
 
579
        addr = busnum << 20;            /* Bus in 27:20 */
 
580
        addr |= slot << 15;             /* Slot (device) in 19:15 */
 
581
        addr |= function << 12;         /* Function is in 14:12 */
 
582
        addr |= (offset & 0xFFF);       /* byte address in 0:11 */
 
583
 
 
584
#ifdef __BIG_ENDIAN
 
585
        /* Point to the correct part of the 32-bit "val". */
 
586
        valp += 4 - size;
 
587
#endif
 
588
 
 
589
        return hv_dev_pwrite(controller->hv_cfg_fd[config_mode], 0,
 
590
                             valp, size, addr);
 
591
}
 
592
 
 
593
 
 
594
static struct pci_ops tile_cfg_ops = {
 
595
        .read =         tile_cfg_read,
 
596
        .write =        tile_cfg_write,
 
597
};
 
598
 
 
599
 
 
600
/*
 
601
 * In the following, each PCI controller's mem_resources[1]
 
602
 * represents its (non-prefetchable) PCI memory resource.
 
603
 * mem_resources[0] and mem_resources[2] refer to its PCI I/O and
 
604
 * prefetchable PCI memory resources, respectively.
 
605
 * For more details, see pci_setup_bridge() in setup-bus.c.
 
606
 * By comparing the target PCI memory address against the
 
607
 * end address of controller 0, we can determine the controller
 
608
 * that should accept the PCI memory access.
 
609
 */
 
610
#define TILE_READ(size, type)                                           \
 
611
type _tile_read##size(unsigned long addr)                               \
 
612
{                                                                       \
 
613
        type val;                                                       \
 
614
        int idx = 0;                                                    \
 
615
        if (addr > controllers[0].mem_resources[1].end &&               \
 
616
            addr > controllers[0].mem_resources[2].end)                 \
 
617
                idx = 1;                                                \
 
618
        if (hv_dev_pread(controllers[idx].hv_mem_fd, 0,                 \
 
619
                         (HV_VirtAddr)(&val), sizeof(type), addr))      \
 
620
                pr_err("PCI: read %zd bytes at 0x%lX failed\n",         \
 
621
                       sizeof(type), addr);                             \
 
622
        return val;                                                     \
 
623
}                                                                       \
 
624
EXPORT_SYMBOL(_tile_read##size)
 
625
 
 
626
TILE_READ(b, u8);
 
627
TILE_READ(w, u16);
 
628
TILE_READ(l, u32);
 
629
TILE_READ(q, u64);
 
630
 
 
631
#define TILE_WRITE(size, type)                                          \
 
632
void _tile_write##size(type val, unsigned long addr)                    \
 
633
{                                                                       \
 
634
        int idx = 0;                                                    \
 
635
        if (addr > controllers[0].mem_resources[1].end &&               \
 
636
            addr > controllers[0].mem_resources[2].end)                 \
 
637
                idx = 1;                                                \
 
638
        if (hv_dev_pwrite(controllers[idx].hv_mem_fd, 0,                \
 
639
                          (HV_VirtAddr)(&val), sizeof(type), addr))     \
 
640
                pr_err("PCI: write %zd bytes at 0x%lX failed\n",        \
 
641
                       sizeof(type), addr);                             \
 
642
}                                                                       \
 
643
EXPORT_SYMBOL(_tile_write##size)
 
644
 
 
645
TILE_WRITE(b, u8);
 
646
TILE_WRITE(w, u16);
 
647
TILE_WRITE(l, u32);
 
648
TILE_WRITE(q, u64);