|
1 #ifndef LINUX_SSB_H_ |
|
2 #define LINUX_SSB_H_ |
|
3 |
|
4 #include <linux/device.h> |
|
5 #include <linux/list.h> |
|
6 #include <linux/types.h> |
|
7 #include <linux/spinlock.h> |
|
8 #include <linux/pci.h> |
|
9 #include <linux/mod_devicetable.h> |
|
10 #include <linux/dma-mapping.h> |
|
11 |
|
12 #include <linux/ssb/ssb_regs.h> |
|
13 |
|
14 |
|
15 struct pcmcia_device; |
|
16 struct ssb_bus; |
|
17 struct ssb_driver; |
|
18 |
|
19 struct ssb_sprom { |
|
20 u8 revision; |
|
21 u8 il0mac[6]; /* MAC address for 802.11b/g */ |
|
22 u8 et0mac[6]; /* MAC address for Ethernet */ |
|
23 u8 et1mac[6]; /* MAC address for 802.11a */ |
|
24 u8 et0phyaddr; /* MII address for enet0 */ |
|
25 u8 et1phyaddr; /* MII address for enet1 */ |
|
26 u8 et0mdcport; /* MDIO for enet0 */ |
|
27 u8 et1mdcport; /* MDIO for enet1 */ |
|
28 u8 board_rev; /* Board revision number from SPROM. */ |
|
29 u8 country_code; /* Country Code */ |
|
30 u8 ant_available_a; /* A-PHY antenna available bits (up to 4) */ |
|
31 u8 ant_available_bg; /* B/G-PHY antenna available bits (up to 4) */ |
|
32 u16 pa0b0; |
|
33 u16 pa0b1; |
|
34 u16 pa0b2; |
|
35 u16 pa1b0; |
|
36 u16 pa1b1; |
|
37 u16 pa1b2; |
|
38 u8 gpio0; /* GPIO pin 0 */ |
|
39 u8 gpio1; /* GPIO pin 1 */ |
|
40 u8 gpio2; /* GPIO pin 2 */ |
|
41 u8 gpio3; /* GPIO pin 3 */ |
|
42 u16 maxpwr_a; /* A-PHY Amplifier Max Power (in dBm Q5.2) */ |
|
43 u16 maxpwr_bg; /* B/G-PHY Amplifier Max Power (in dBm Q5.2) */ |
|
44 u8 itssi_a; /* Idle TSSI Target for A-PHY */ |
|
45 u8 itssi_bg; /* Idle TSSI Target for B/G-PHY */ |
|
46 u16 boardflags_lo; /* Boardflags (low 16 bits) */ |
|
47 u16 boardflags_hi; /* Boardflags (high 16 bits) */ |
|
48 |
|
49 /* Antenna gain values for up to 4 antennas |
|
50 * on each band. Values in dBm/4 (Q5.2). Negative gain means the |
|
51 * loss in the connectors is bigger than the gain. */ |
|
52 struct { |
|
53 struct { |
|
54 s8 a0, a1, a2, a3; |
|
55 } ghz24; /* 2.4GHz band */ |
|
56 struct { |
|
57 s8 a0, a1, a2, a3; |
|
58 } ghz5; /* 5GHz band */ |
|
59 } antenna_gain; |
|
60 |
|
61 /* TODO - add any parameters needed from rev 2, 3, or 4 SPROMs */ |
|
62 }; |
|
63 |
|
64 /* Information about the PCB the circuitry is soldered on. */ |
|
65 struct ssb_boardinfo { |
|
66 u16 vendor; |
|
67 u16 type; |
|
68 u16 rev; |
|
69 }; |
|
70 |
|
71 |
|
72 struct ssb_device; |
|
73 /* Lowlevel read/write operations on the device MMIO. |
|
74 * Internal, don't use that outside of ssb. */ |
|
75 struct ssb_bus_ops { |
|
76 u8 (*read8)(struct ssb_device *dev, u16 offset); |
|
77 u16 (*read16)(struct ssb_device *dev, u16 offset); |
|
78 u32 (*read32)(struct ssb_device *dev, u16 offset); |
|
79 void (*write8)(struct ssb_device *dev, u16 offset, u8 value); |
|
80 void (*write16)(struct ssb_device *dev, u16 offset, u16 value); |
|
81 void (*write32)(struct ssb_device *dev, u16 offset, u32 value); |
|
82 #ifdef CONFIG_SSB_BLOCKIO |
|
83 void (*block_read)(struct ssb_device *dev, void *buffer, |
|
84 size_t count, u16 offset, u8 reg_width); |
|
85 void (*block_write)(struct ssb_device *dev, const void *buffer, |
|
86 size_t count, u16 offset, u8 reg_width); |
|
87 #endif |
|
88 }; |
|
89 |
|
90 |
|
91 /* Core-ID values. */ |
|
92 #define SSB_DEV_CHIPCOMMON 0x800 |
|
93 #define SSB_DEV_ILINE20 0x801 |
|
94 #define SSB_DEV_SDRAM 0x803 |
|
95 #define SSB_DEV_PCI 0x804 |
|
96 #define SSB_DEV_MIPS 0x805 |
|
97 #define SSB_DEV_ETHERNET 0x806 |
|
98 #define SSB_DEV_V90 0x807 |
|
99 #define SSB_DEV_USB11_HOSTDEV 0x808 |
|
100 #define SSB_DEV_ADSL 0x809 |
|
101 #define SSB_DEV_ILINE100 0x80A |
|
102 #define SSB_DEV_IPSEC 0x80B |
|
103 #define SSB_DEV_PCMCIA 0x80D |
|
104 #define SSB_DEV_INTERNAL_MEM 0x80E |
|
105 #define SSB_DEV_MEMC_SDRAM 0x80F |
|
106 #define SSB_DEV_EXTIF 0x811 |
|
107 #define SSB_DEV_80211 0x812 |
|
108 #define SSB_DEV_MIPS_3302 0x816 |
|
109 #define SSB_DEV_USB11_HOST 0x817 |
|
110 #define SSB_DEV_USB11_DEV 0x818 |
|
111 #define SSB_DEV_USB20_HOST 0x819 |
|
112 #define SSB_DEV_USB20_DEV 0x81A |
|
113 #define SSB_DEV_SDIO_HOST 0x81B |
|
114 #define SSB_DEV_ROBOSWITCH 0x81C |
|
115 #define SSB_DEV_PARA_ATA 0x81D |
|
116 #define SSB_DEV_SATA_XORDMA 0x81E |
|
117 #define SSB_DEV_ETHERNET_GBIT 0x81F |
|
118 #define SSB_DEV_PCIE 0x820 |
|
119 #define SSB_DEV_MIMO_PHY 0x821 |
|
120 #define SSB_DEV_SRAM_CTRLR 0x822 |
|
121 #define SSB_DEV_MINI_MACPHY 0x823 |
|
122 #define SSB_DEV_ARM_1176 0x824 |
|
123 #define SSB_DEV_ARM_7TDMI 0x825 |
|
124 |
|
125 /* Vendor-ID values */ |
|
126 #define SSB_VENDOR_BROADCOM 0x4243 |
|
127 |
|
128 /* Some kernel subsystems poke with dev->drvdata, so we must use the |
|
129 * following ugly workaround to get from struct device to struct ssb_device */ |
|
130 struct __ssb_dev_wrapper { |
|
131 struct device dev; |
|
132 struct ssb_device *sdev; |
|
133 }; |
|
134 |
|
135 struct ssb_device { |
|
136 /* Having a copy of the ops pointer in each dev struct |
|
137 * is an optimization. */ |
|
138 const struct ssb_bus_ops *ops; |
|
139 |
|
140 struct device *dev; |
|
141 |
|
142 struct ssb_bus *bus; |
|
143 struct ssb_device_id id; |
|
144 |
|
145 u8 core_index; |
|
146 unsigned int irq; |
|
147 |
|
148 /* Internal-only stuff follows. */ |
|
149 void *drvdata; /* Per-device data */ |
|
150 void *devtypedata; /* Per-devicetype (eg 802.11) data */ |
|
151 }; |
|
152 |
|
153 /* Go from struct device to struct ssb_device. */ |
|
154 static inline |
|
155 struct ssb_device * dev_to_ssb_dev(struct device *dev) |
|
156 { |
|
157 struct __ssb_dev_wrapper *wrap; |
|
158 wrap = container_of(dev, struct __ssb_dev_wrapper, dev); |
|
159 return wrap->sdev; |
|
160 } |
|
161 |
|
162 /* Device specific user data */ |
|
163 static inline |
|
164 void ssb_set_drvdata(struct ssb_device *dev, void *data) |
|
165 { |
|
166 dev->drvdata = data; |
|
167 } |
|
168 static inline |
|
169 void * ssb_get_drvdata(struct ssb_device *dev) |
|
170 { |
|
171 return dev->drvdata; |
|
172 } |
|
173 |
|
174 /* Devicetype specific user data. This is per device-type (not per device) */ |
|
175 void ssb_set_devtypedata(struct ssb_device *dev, void *data); |
|
176 static inline |
|
177 void * ssb_get_devtypedata(struct ssb_device *dev) |
|
178 { |
|
179 return dev->devtypedata; |
|
180 } |
|
181 |
|
182 |
|
183 struct ssb_driver { |
|
184 const char *name; |
|
185 const struct ssb_device_id *id_table; |
|
186 |
|
187 int (*probe)(struct ssb_device *dev, const struct ssb_device_id *id); |
|
188 void (*remove)(struct ssb_device *dev); |
|
189 int (*suspend)(struct ssb_device *dev, pm_message_t state); |
|
190 int (*resume)(struct ssb_device *dev); |
|
191 void (*shutdown)(struct ssb_device *dev); |
|
192 |
|
193 struct device_driver drv; |
|
194 }; |
|
195 #define drv_to_ssb_drv(_drv) container_of(_drv, struct ssb_driver, drv) |
|
196 |
|
197 extern int __ssb_driver_register(struct ssb_driver *drv, struct module *owner); |
|
198 static inline int ssb_driver_register(struct ssb_driver *drv) |
|
199 { |
|
200 return __ssb_driver_register(drv, THIS_MODULE); |
|
201 } |
|
202 extern void ssb_driver_unregister(struct ssb_driver *drv); |
|
203 |
|
204 |
|
205 |
|
206 |
|
207 enum ssb_bustype { |
|
208 SSB_BUSTYPE_SSB, /* This SSB bus is the system bus */ |
|
209 SSB_BUSTYPE_PCI, /* SSB is connected to PCI bus */ |
|
210 SSB_BUSTYPE_PCMCIA, /* SSB is connected to PCMCIA bus */ |
|
211 }; |
|
212 |
|
213 /* board_vendor */ |
|
214 #define SSB_BOARDVENDOR_BCM 0x14E4 /* Broadcom */ |
|
215 #define SSB_BOARDVENDOR_DELL 0x1028 /* Dell */ |
|
216 #define SSB_BOARDVENDOR_HP 0x0E11 /* HP */ |
|
217 /* board_type */ |
|
218 #define SSB_BOARD_BCM94306MP 0x0418 |
|
219 #define SSB_BOARD_BCM4309G 0x0421 |
|
220 #define SSB_BOARD_BCM4306CB 0x0417 |
|
221 #define SSB_BOARD_BCM4309MP 0x040C |
|
222 #define SSB_BOARD_MP4318 0x044A |
|
223 #define SSB_BOARD_BU4306 0x0416 |
|
224 #define SSB_BOARD_BU4309 0x040A |
|
225 /* chip_package */ |
|
226 #define SSB_CHIPPACK_BCM4712S 1 /* Small 200pin 4712 */ |
|
227 #define SSB_CHIPPACK_BCM4712M 2 /* Medium 225pin 4712 */ |
|
228 #define SSB_CHIPPACK_BCM4712L 0 /* Large 340pin 4712 */ |
|
229 |
|
230 #include <linux/ssb/ssb_driver_chipcommon.h> |
|
231 #include <linux/ssb/ssb_driver_mips.h> |
|
232 #include <linux/ssb/ssb_driver_extif.h> |
|
233 #include <linux/ssb/ssb_driver_pci.h> |
|
234 |
|
235 struct ssb_bus { |
|
236 /* The MMIO area. */ |
|
237 void __iomem *mmio; |
|
238 |
|
239 const struct ssb_bus_ops *ops; |
|
240 |
|
241 /* The core in the basic address register window. (PCI bus only) */ |
|
242 struct ssb_device *mapped_device; |
|
243 /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */ |
|
244 u8 mapped_pcmcia_seg; |
|
245 /* Lock for core and segment switching. |
|
246 * On PCMCIA-host busses this is used to protect the whole MMIO access. */ |
|
247 spinlock_t bar_lock; |
|
248 |
|
249 /* The bus this backplane is running on. */ |
|
250 enum ssb_bustype bustype; |
|
251 /* Pointer to the PCI bus (only valid if bustype == SSB_BUSTYPE_PCI). */ |
|
252 struct pci_dev *host_pci; |
|
253 /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */ |
|
254 struct pcmcia_device *host_pcmcia; |
|
255 |
|
256 #ifdef CONFIG_SSB_SPROM |
|
257 /* Mutex to protect the SPROM writing. */ |
|
258 struct mutex sprom_mutex; |
|
259 #endif |
|
260 |
|
261 /* ID information about the Chip. */ |
|
262 u16 chip_id; |
|
263 u16 chip_rev; |
|
264 u16 sprom_size; /* number of words in sprom */ |
|
265 u8 chip_package; |
|
266 |
|
267 /* List of devices (cores) on the backplane. */ |
|
268 struct ssb_device devices[SSB_MAX_NR_CORES]; |
|
269 u8 nr_devices; |
|
270 |
|
271 /* Software ID number for this bus. */ |
|
272 unsigned int busnumber; |
|
273 |
|
274 /* The ChipCommon device (if available). */ |
|
275 struct ssb_chipcommon chipco; |
|
276 /* The PCI-core device (if available). */ |
|
277 struct ssb_pcicore pcicore; |
|
278 /* The MIPS-core device (if available). */ |
|
279 struct ssb_mipscore mipscore; |
|
280 /* The EXTif-core device (if available). */ |
|
281 struct ssb_extif extif; |
|
282 |
|
283 /* The following structure elements are not available in early |
|
284 * SSB initialization. Though, they are available for regular |
|
285 * registered drivers at any stage. So be careful when |
|
286 * using them in the ssb core code. */ |
|
287 |
|
288 /* ID information about the PCB. */ |
|
289 struct ssb_boardinfo boardinfo; |
|
290 /* Contents of the SPROM. */ |
|
291 struct ssb_sprom sprom; |
|
292 /* If the board has a cardbus slot, this is set to true. */ |
|
293 bool has_cardbus_slot; |
|
294 |
|
295 #ifdef CONFIG_SSB_EMBEDDED |
|
296 /* Lock for GPIO register access. */ |
|
297 spinlock_t gpio_lock; |
|
298 #endif /* EMBEDDED */ |
|
299 |
|
300 /* Internal-only stuff follows. Do not touch. */ |
|
301 struct list_head list; |
|
302 #ifdef CONFIG_SSB_DEBUG |
|
303 /* Is the bus already powered up? */ |
|
304 bool powered_up; |
|
305 int power_warn_count; |
|
306 #endif /* DEBUG */ |
|
307 }; |
|
308 |
|
309 /* The initialization-invariants. */ |
|
310 struct ssb_init_invariants { |
|
311 /* Versioning information about the PCB. */ |
|
312 struct ssb_boardinfo boardinfo; |
|
313 /* The SPROM information. That's either stored in an |
|
314 * EEPROM or NVRAM on the board. */ |
|
315 struct ssb_sprom sprom; |
|
316 /* If the board has a cardbus slot, this is set to true. */ |
|
317 bool has_cardbus_slot; |
|
318 }; |
|
319 /* Type of function to fetch the invariants. */ |
|
320 typedef int (*ssb_invariants_func_t)(struct ssb_bus *bus, |
|
321 struct ssb_init_invariants *iv); |
|
322 |
|
323 /* Register a SSB system bus. get_invariants() is called after the |
|
324 * basic system devices are initialized. |
|
325 * The invariants are usually fetched from some NVRAM. |
|
326 * Put the invariants into the struct pointed to by iv. */ |
|
327 extern int ssb_bus_ssbbus_register(struct ssb_bus *bus, |
|
328 unsigned long baseaddr, |
|
329 ssb_invariants_func_t get_invariants); |
|
330 #ifdef CONFIG_SSB_PCIHOST |
|
331 extern int ssb_bus_pcibus_register(struct ssb_bus *bus, |
|
332 struct pci_dev *host_pci); |
|
333 #endif /* CONFIG_SSB_PCIHOST */ |
|
334 #ifdef CONFIG_SSB_PCMCIAHOST |
|
335 extern int ssb_bus_pcmciabus_register(struct ssb_bus *bus, |
|
336 struct pcmcia_device *pcmcia_dev, |
|
337 unsigned long baseaddr); |
|
338 #endif /* CONFIG_SSB_PCMCIAHOST */ |
|
339 |
|
340 extern void ssb_bus_unregister(struct ssb_bus *bus); |
|
341 |
|
342 /* Suspend a SSB bus. |
|
343 * Call this from the parent bus suspend routine. */ |
|
344 extern int ssb_bus_suspend(struct ssb_bus *bus); |
|
345 /* Resume a SSB bus. |
|
346 * Call this from the parent bus resume routine. */ |
|
347 extern int ssb_bus_resume(struct ssb_bus *bus); |
|
348 |
|
349 extern u32 ssb_clockspeed(struct ssb_bus *bus); |
|
350 |
|
351 /* Is the device enabled in hardware? */ |
|
352 int ssb_device_is_enabled(struct ssb_device *dev); |
|
353 /* Enable a device and pass device-specific SSB_TMSLOW flags. |
|
354 * If no device-specific flags are available, use 0. */ |
|
355 void ssb_device_enable(struct ssb_device *dev, u32 core_specific_flags); |
|
356 /* Disable a device in hardware and pass SSB_TMSLOW flags (if any). */ |
|
357 void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags); |
|
358 |
|
359 |
|
360 /* Device MMIO register read/write functions. */ |
|
361 static inline u8 ssb_read8(struct ssb_device *dev, u16 offset) |
|
362 { |
|
363 return dev->ops->read8(dev, offset); |
|
364 } |
|
365 static inline u16 ssb_read16(struct ssb_device *dev, u16 offset) |
|
366 { |
|
367 return dev->ops->read16(dev, offset); |
|
368 } |
|
369 static inline u32 ssb_read32(struct ssb_device *dev, u16 offset) |
|
370 { |
|
371 return dev->ops->read32(dev, offset); |
|
372 } |
|
373 static inline void ssb_write8(struct ssb_device *dev, u16 offset, u8 value) |
|
374 { |
|
375 dev->ops->write8(dev, offset, value); |
|
376 } |
|
377 static inline void ssb_write16(struct ssb_device *dev, u16 offset, u16 value) |
|
378 { |
|
379 dev->ops->write16(dev, offset, value); |
|
380 } |
|
381 static inline void ssb_write32(struct ssb_device *dev, u16 offset, u32 value) |
|
382 { |
|
383 dev->ops->write32(dev, offset, value); |
|
384 } |
|
385 #ifdef CONFIG_SSB_BLOCKIO |
|
386 static inline void ssb_block_read(struct ssb_device *dev, void *buffer, |
|
387 size_t count, u16 offset, u8 reg_width) |
|
388 { |
|
389 dev->ops->block_read(dev, buffer, count, offset, reg_width); |
|
390 } |
|
391 |
|
392 static inline void ssb_block_write(struct ssb_device *dev, const void *buffer, |
|
393 size_t count, u16 offset, u8 reg_width) |
|
394 { |
|
395 dev->ops->block_write(dev, buffer, count, offset, reg_width); |
|
396 } |
|
397 #endif /* CONFIG_SSB_BLOCKIO */ |
|
398 |
|
399 |
|
400 /* The SSB DMA API. Use this API for any DMA operation on the device. |
|
401 * This API basically is a wrapper that calls the correct DMA API for |
|
402 * the host device type the SSB device is attached to. */ |
|
403 |
|
404 /* Translation (routing) bits that need to be ORed to DMA |
|
405 * addresses before they are given to a device. */ |
|
406 extern u32 ssb_dma_translation(struct ssb_device *dev); |
|
407 #define SSB_DMA_TRANSLATION_MASK 0xC0000000 |
|
408 #define SSB_DMA_TRANSLATION_SHIFT 30 |
|
409 |
|
410 extern int ssb_dma_set_mask(struct ssb_device *dev, u64 mask); |
|
411 |
|
412 extern void * ssb_dma_alloc_consistent(struct ssb_device *dev, size_t size, |
|
413 dma_addr_t *dma_handle, gfp_t gfp_flags); |
|
414 extern void ssb_dma_free_consistent(struct ssb_device *dev, size_t size, |
|
415 void *vaddr, dma_addr_t dma_handle, |
|
416 gfp_t gfp_flags); |
|
417 |
|
418 static inline void __cold __ssb_dma_not_implemented(struct ssb_device *dev) |
|
419 { |
|
420 #ifdef CONFIG_SSB_DEBUG |
|
421 printk(KERN_ERR "SSB: BUG! Calling DMA API for " |
|
422 "unsupported bustype %d\n", dev->bus->bustype); |
|
423 #endif /* DEBUG */ |
|
424 } |
|
425 |
|
426 static inline int ssb_dma_mapping_error(struct ssb_device *dev, dma_addr_t addr) |
|
427 { |
|
428 switch (dev->bus->bustype) { |
|
429 case SSB_BUSTYPE_PCI: |
|
430 #ifdef CONFIG_SSB_PCIHOST |
|
431 return pci_dma_mapping_error(dev->bus->host_pci, addr); |
|
432 #endif |
|
433 break; |
|
434 case SSB_BUSTYPE_SSB: |
|
435 return dma_mapping_error(dev->dev, addr); |
|
436 default: |
|
437 break; |
|
438 } |
|
439 __ssb_dma_not_implemented(dev); |
|
440 return -ENOSYS; |
|
441 } |
|
442 |
|
443 static inline dma_addr_t ssb_dma_map_single(struct ssb_device *dev, void *p, |
|
444 size_t size, enum dma_data_direction dir) |
|
445 { |
|
446 switch (dev->bus->bustype) { |
|
447 case SSB_BUSTYPE_PCI: |
|
448 #ifdef CONFIG_SSB_PCIHOST |
|
449 return pci_map_single(dev->bus->host_pci, p, size, dir); |
|
450 #endif |
|
451 break; |
|
452 case SSB_BUSTYPE_SSB: |
|
453 return dma_map_single(dev->dev, p, size, dir); |
|
454 default: |
|
455 break; |
|
456 } |
|
457 __ssb_dma_not_implemented(dev); |
|
458 return 0; |
|
459 } |
|
460 |
|
461 static inline void ssb_dma_unmap_single(struct ssb_device *dev, dma_addr_t dma_addr, |
|
462 size_t size, enum dma_data_direction dir) |
|
463 { |
|
464 switch (dev->bus->bustype) { |
|
465 case SSB_BUSTYPE_PCI: |
|
466 #ifdef CONFIG_SSB_PCIHOST |
|
467 pci_unmap_single(dev->bus->host_pci, dma_addr, size, dir); |
|
468 return; |
|
469 #endif |
|
470 break; |
|
471 case SSB_BUSTYPE_SSB: |
|
472 dma_unmap_single(dev->dev, dma_addr, size, dir); |
|
473 return; |
|
474 default: |
|
475 break; |
|
476 } |
|
477 __ssb_dma_not_implemented(dev); |
|
478 } |
|
479 |
|
480 static inline void ssb_dma_sync_single_for_cpu(struct ssb_device *dev, |
|
481 dma_addr_t dma_addr, |
|
482 size_t size, |
|
483 enum dma_data_direction dir) |
|
484 { |
|
485 switch (dev->bus->bustype) { |
|
486 case SSB_BUSTYPE_PCI: |
|
487 #ifdef CONFIG_SSB_PCIHOST |
|
488 pci_dma_sync_single_for_cpu(dev->bus->host_pci, dma_addr, |
|
489 size, dir); |
|
490 return; |
|
491 #endif |
|
492 break; |
|
493 case SSB_BUSTYPE_SSB: |
|
494 dma_sync_single_for_cpu(dev->dev, dma_addr, size, dir); |
|
495 return; |
|
496 default: |
|
497 break; |
|
498 } |
|
499 __ssb_dma_not_implemented(dev); |
|
500 } |
|
501 |
|
502 static inline void ssb_dma_sync_single_for_device(struct ssb_device *dev, |
|
503 dma_addr_t dma_addr, |
|
504 size_t size, |
|
505 enum dma_data_direction dir) |
|
506 { |
|
507 switch (dev->bus->bustype) { |
|
508 case SSB_BUSTYPE_PCI: |
|
509 #ifdef CONFIG_SSB_PCIHOST |
|
510 pci_dma_sync_single_for_device(dev->bus->host_pci, dma_addr, |
|
511 size, dir); |
|
512 return; |
|
513 #endif |
|
514 break; |
|
515 case SSB_BUSTYPE_SSB: |
|
516 dma_sync_single_for_device(dev->dev, dma_addr, size, dir); |
|
517 return; |
|
518 default: |
|
519 break; |
|
520 } |
|
521 __ssb_dma_not_implemented(dev); |
|
522 } |
|
523 |
|
524 static inline void ssb_dma_sync_single_range_for_cpu(struct ssb_device *dev, |
|
525 dma_addr_t dma_addr, |
|
526 unsigned long offset, |
|
527 size_t size, |
|
528 enum dma_data_direction dir) |
|
529 { |
|
530 switch (dev->bus->bustype) { |
|
531 case SSB_BUSTYPE_PCI: |
|
532 #ifdef CONFIG_SSB_PCIHOST |
|
533 /* Just sync everything. That's all the PCI API can do. */ |
|
534 pci_dma_sync_single_for_cpu(dev->bus->host_pci, dma_addr, |
|
535 offset + size, dir); |
|
536 return; |
|
537 #endif |
|
538 break; |
|
539 case SSB_BUSTYPE_SSB: |
|
540 dma_sync_single_range_for_cpu(dev->dev, dma_addr, offset, |
|
541 size, dir); |
|
542 return; |
|
543 default: |
|
544 break; |
|
545 } |
|
546 __ssb_dma_not_implemented(dev); |
|
547 } |
|
548 |
|
549 static inline void ssb_dma_sync_single_range_for_device(struct ssb_device *dev, |
|
550 dma_addr_t dma_addr, |
|
551 unsigned long offset, |
|
552 size_t size, |
|
553 enum dma_data_direction dir) |
|
554 { |
|
555 switch (dev->bus->bustype) { |
|
556 case SSB_BUSTYPE_PCI: |
|
557 #ifdef CONFIG_SSB_PCIHOST |
|
558 /* Just sync everything. That's all the PCI API can do. */ |
|
559 pci_dma_sync_single_for_device(dev->bus->host_pci, dma_addr, |
|
560 offset + size, dir); |
|
561 return; |
|
562 #endif |
|
563 break; |
|
564 case SSB_BUSTYPE_SSB: |
|
565 dma_sync_single_range_for_device(dev->dev, dma_addr, offset, |
|
566 size, dir); |
|
567 return; |
|
568 default: |
|
569 break; |
|
570 } |
|
571 __ssb_dma_not_implemented(dev); |
|
572 } |
|
573 |
|
574 |
|
575 #ifdef CONFIG_SSB_PCIHOST |
|
576 /* PCI-host wrapper driver */ |
|
577 extern int ssb_pcihost_register(struct pci_driver *driver); |
|
578 static inline void ssb_pcihost_unregister(struct pci_driver *driver) |
|
579 { |
|
580 pci_unregister_driver(driver); |
|
581 } |
|
582 |
|
583 static inline |
|
584 void ssb_pcihost_set_power_state(struct ssb_device *sdev, pci_power_t state) |
|
585 { |
|
586 if (sdev->bus->bustype == SSB_BUSTYPE_PCI) |
|
587 pci_set_power_state(sdev->bus->host_pci, state); |
|
588 } |
|
589 #else |
|
590 static inline void ssb_pcihost_unregister(struct pci_driver *driver) |
|
591 { |
|
592 } |
|
593 |
|
594 static inline |
|
595 void ssb_pcihost_set_power_state(struct ssb_device *sdev, pci_power_t state) |
|
596 { |
|
597 } |
|
598 #endif /* CONFIG_SSB_PCIHOST */ |
|
599 |
|
600 |
|
601 /* If a driver is shutdown or suspended, call this to signal |
|
602 * that the bus may be completely powered down. SSB will decide, |
|
603 * if it's really time to power down the bus, based on if there |
|
604 * are other devices that want to run. */ |
|
605 extern int ssb_bus_may_powerdown(struct ssb_bus *bus); |
|
606 /* Before initializing and enabling a device, call this to power-up the bus. |
|
607 * If you want to allow use of dynamic-power-control, pass the flag. |
|
608 * Otherwise static always-on powercontrol will be used. */ |
|
609 extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl); |
|
610 |
|
611 |
|
612 /* Various helper functions */ |
|
613 extern u32 ssb_admatch_base(u32 adm); |
|
614 extern u32 ssb_admatch_size(u32 adm); |
|
615 |
|
616 /* PCI device mapping and fixup routines. |
|
617 * Called from the architecture pcibios init code. |
|
618 * These are only available on SSB_EMBEDDED configurations. */ |
|
619 #ifdef CONFIG_SSB_EMBEDDED |
|
620 int ssb_pcibios_plat_dev_init(struct pci_dev *dev); |
|
621 int ssb_pcibios_map_irq(const struct pci_dev *dev, u8 slot, u8 pin); |
|
622 #endif /* CONFIG_SSB_EMBEDDED */ |
|
623 |
|
624 #endif /* LINUX_SSB_H_ */ |