home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / ssb / ssb.h < prev   
Encoding:
C/C++ Source or Header  |  2008-12-24  |  17.8 KB  |  625 lines
  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_ */
  625.