Linux-2.6.12-rc2
[linux-3.10.git] / arch / alpha / kernel / pci-noop.c
1 /*
2  *      linux/arch/alpha/kernel/pci-noop.c
3  *
4  * Stub PCI interfaces for Jensen-specific kernels.
5  */
6
7 #include <linux/pci.h>
8 #include <linux/init.h>
9 #include <linux/bootmem.h>
10 #include <linux/mm.h>
11 #include <linux/errno.h>
12 #include <linux/sched.h>
13 #include <linux/dma-mapping.h>
14
15 #include "proto.h"
16
17
18 /*
19  * The PCI controller list.
20  */
21
22 struct pci_controller *hose_head, **hose_tail = &hose_head;
23 struct pci_controller *pci_isa_hose;
24
25
26 struct pci_controller * __init
27 alloc_pci_controller(void)
28 {
29         struct pci_controller *hose;
30
31         hose = alloc_bootmem(sizeof(*hose));
32
33         *hose_tail = hose;
34         hose_tail = &hose->next;
35
36         return hose;
37 }
38
39 struct resource * __init
40 alloc_resource(void)
41 {
42         struct resource *res;
43
44         res = alloc_bootmem(sizeof(*res));
45
46         return res;
47 }
48
49 asmlinkage long
50 sys_pciconfig_iobase(long which, unsigned long bus, unsigned long dfn)
51 {
52         struct pci_controller *hose;
53
54         /* from hose or from bus.devfn */
55         if (which & IOBASE_FROM_HOSE) {
56                 for (hose = hose_head; hose; hose = hose->next) 
57                         if (hose->index == bus)
58                                 break;
59                 if (!hose)
60                         return -ENODEV;
61         } else {
62                 /* Special hook for ISA access.  */
63                 if (bus == 0 && dfn == 0)
64                         hose = pci_isa_hose;
65                 else
66                         return -ENODEV;
67         }
68
69         switch (which & ~IOBASE_FROM_HOSE) {
70         case IOBASE_HOSE:
71                 return hose->index;
72         case IOBASE_SPARSE_MEM:
73                 return hose->sparse_mem_base;
74         case IOBASE_DENSE_MEM:
75                 return hose->dense_mem_base;
76         case IOBASE_SPARSE_IO:
77                 return hose->sparse_io_base;
78         case IOBASE_DENSE_IO:
79                 return hose->dense_io_base;
80         case IOBASE_ROOT_BUS:
81                 return hose->bus->number;
82         }
83
84         return -EOPNOTSUPP;
85 }
86
87 asmlinkage long
88 sys_pciconfig_read(unsigned long bus, unsigned long dfn,
89                    unsigned long off, unsigned long len, void *buf)
90 {
91         if (!capable(CAP_SYS_ADMIN))
92                 return -EPERM;
93         else
94                 return -ENODEV;
95 }
96
97 asmlinkage long
98 sys_pciconfig_write(unsigned long bus, unsigned long dfn,
99                     unsigned long off, unsigned long len, void *buf)
100 {
101         if (!capable(CAP_SYS_ADMIN))
102                 return -EPERM;
103         else
104                 return -ENODEV;
105 }
106
107 /* Stubs for the routines in pci_iommu.c: */
108
109 void *
110 pci_alloc_consistent(struct pci_dev *pdev, size_t size, dma_addr_t *dma_addrp)
111 {
112         return NULL;
113 }
114
115 void
116 pci_free_consistent(struct pci_dev *pdev, size_t size, void *cpu_addr,
117                     dma_addr_t dma_addr)
118 {
119 }
120
121 dma_addr_t
122 pci_map_single(struct pci_dev *pdev, void *cpu_addr, size_t size,
123                int direction)
124 {
125         return (dma_addr_t) 0;
126 }
127
128 void
129 pci_unmap_single(struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
130                  int direction)
131 {
132 }
133
134 int
135 pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents,
136            int direction)
137 {
138         return 0;
139 }
140
141 void
142 pci_unmap_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents,
143              int direction)
144 {
145 }
146
147 int
148 pci_dma_supported(struct pci_dev *hwdev, dma_addr_t mask)
149 {
150         return 0;
151 }
152
153 /* Generic DMA mapping functions: */
154
155 void *
156 dma_alloc_coherent(struct device *dev, size_t size,
157                    dma_addr_t *dma_handle, int gfp)
158 {
159         void *ret;
160
161         if (!dev || *dev->dma_mask >= 0xffffffffUL)
162                 gfp &= ~GFP_DMA;
163         ret = (void *)__get_free_pages(gfp, get_order(size));
164         if (ret) {
165                 memset(ret, 0, size);
166                 *dma_handle = virt_to_bus(ret);
167         }
168         return ret;
169 }
170
171 EXPORT_SYMBOL(dma_alloc_coherent);
172
173 int
174 dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
175            enum dma_data_direction direction)
176 {
177         int i;
178
179         for (i = 0; i < nents; i++ ) {
180                 void *va;
181
182                 BUG_ON(!sg[i].page);
183                 va = page_address(sg[i].page) + sg[i].offset;
184                 sg_dma_address(sg + i) = (dma_addr_t)virt_to_bus(va);
185                 sg_dma_len(sg + i) = sg[i].length;
186         }
187
188         return nents;
189 }
190
191 EXPORT_SYMBOL(dma_map_sg);
192
193 int
194 dma_set_mask(struct device *dev, u64 mask)
195 {
196         if (!dev->dma_mask || !dma_supported(dev, mask))
197                 return -EIO;
198
199         *dev->dma_mask = mask;
200
201         return 0;
202 }
203
204 void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
205 {
206         return NULL;
207 }
208
209 void pci_iounmap(struct pci_dev *dev, void __iomem * addr)
210 {
211 }
212
213 EXPORT_SYMBOL(pci_iomap);
214 EXPORT_SYMBOL(pci_iounmap);