1 /* 2 Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com> 3 <http://rt2x00.serialmonkey.com> 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 2 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, see <http://www.gnu.org/licenses/>. 17 */ 18 19 /* 20 Module: rt2x00pci 21 Abstract: rt2x00 generic pci device routines. 22 */ 23 24 #include <linux/dma-mapping.h> 25 #include <linux/kernel.h> 26 #include <linux/module.h> 27 #include <linux/pci.h> 28 #include <linux/slab.h> 29 30 #include "rt2x00.h" 31 #include "rt2x00pci.h" 32 33 /* 34 * PCI driver handlers. 35 */ 36 static void rt2x00pci_free_reg(struct rt2x00_dev *rt2x00dev) 37 { 38 kfree(rt2x00dev->rf); 39 rt2x00dev->rf = NULL; 40 41 kfree(rt2x00dev->eeprom); 42 rt2x00dev->eeprom = NULL; 43 44 if (rt2x00dev->csr.base) { 45 iounmap(rt2x00dev->csr.base); 46 rt2x00dev->csr.base = NULL; 47 } 48 } 49 50 static int rt2x00pci_alloc_reg(struct rt2x00_dev *rt2x00dev) 51 { 52 struct pci_dev *pci_dev = to_pci_dev(rt2x00dev->dev); 53 54 rt2x00dev->csr.base = pci_ioremap_bar(pci_dev, 0); 55 if (!rt2x00dev->csr.base) 56 goto exit; 57 58 rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL); 59 if (!rt2x00dev->eeprom) 60 goto exit; 61 62 rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL); 63 if (!rt2x00dev->rf) 64 goto exit; 65 66 return 0; 67 68 exit: 69 rt2x00_probe_err("Failed to allocate registers\n"); 70 71 rt2x00pci_free_reg(rt2x00dev); 72 73 return -ENOMEM; 74 } 75 76 int rt2x00pci_probe(struct pci_dev *pci_dev, const struct rt2x00_ops *ops) 77 { 78 struct ieee80211_hw *hw; 79 struct rt2x00_dev *rt2x00dev; 80 int retval; 81 u16 chip; 82 83 retval = pci_enable_device(pci_dev); 84 if (retval) { 85 rt2x00_probe_err("Enable device failed\n"); 86 return retval; 87 } 88 89 retval = pci_request_regions(pci_dev, pci_name(pci_dev)); 90 if (retval) { 91 rt2x00_probe_err("PCI request regions failed\n"); 92 goto exit_disable_device; 93 } 94 95 pci_set_master(pci_dev); 96 97 if (pci_set_mwi(pci_dev)) 98 rt2x00_probe_err("MWI not available\n"); 99 100 if (dma_set_mask(&pci_dev->dev, DMA_BIT_MASK(32))) { 101 rt2x00_probe_err("PCI DMA not supported\n"); 102 retval = -EIO; 103 goto exit_release_regions; 104 } 105 106 hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw); 107 if (!hw) { 108 rt2x00_probe_err("Failed to allocate hardware\n"); 109 retval = -ENOMEM; 110 goto exit_release_regions; 111 } 112 113 pci_set_drvdata(pci_dev, hw); 114 115 rt2x00dev = hw->priv; 116 rt2x00dev->dev = &pci_dev->dev; 117 rt2x00dev->ops = ops; 118 rt2x00dev->hw = hw; 119 rt2x00dev->irq = pci_dev->irq; 120 rt2x00dev->name = ops->name; 121 122 if (pci_is_pcie(pci_dev)) 123 rt2x00_set_chip_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE); 124 else 125 rt2x00_set_chip_intf(rt2x00dev, RT2X00_CHIP_INTF_PCI); 126 127 retval = rt2x00pci_alloc_reg(rt2x00dev); 128 if (retval) 129 goto exit_free_device; 130 131 /* 132 * Because rt3290 chip use different efuse offset to read efuse data. 133 * So before read efuse it need to indicate it is the 134 * rt3290 or not. 135 */ 136 pci_read_config_word(pci_dev, PCI_DEVICE_ID, &chip); 137 rt2x00dev->chip.rt = chip; 138 139 retval = rt2x00lib_probe_dev(rt2x00dev); 140 if (retval) 141 goto exit_free_reg; 142 143 return 0; 144 145 exit_free_reg: 146 rt2x00pci_free_reg(rt2x00dev); 147 148 exit_free_device: 149 ieee80211_free_hw(hw); 150 151 exit_release_regions: 152 pci_clear_mwi(pci_dev); 153 pci_release_regions(pci_dev); 154 155 exit_disable_device: 156 pci_disable_device(pci_dev); 157 158 return retval; 159 } 160 EXPORT_SYMBOL_GPL(rt2x00pci_probe); 161 162 void rt2x00pci_remove(struct pci_dev *pci_dev) 163 { 164 struct ieee80211_hw *hw = pci_get_drvdata(pci_dev); 165 struct rt2x00_dev *rt2x00dev = hw->priv; 166 167 /* 168 * Free all allocated data. 169 */ 170 rt2x00lib_remove_dev(rt2x00dev); 171 rt2x00pci_free_reg(rt2x00dev); 172 ieee80211_free_hw(hw); 173 174 /* 175 * Free the PCI device data. 176 */ 177 pci_clear_mwi(pci_dev); 178 pci_disable_device(pci_dev); 179 pci_release_regions(pci_dev); 180 } 181 EXPORT_SYMBOL_GPL(rt2x00pci_remove); 182 183 #ifdef CONFIG_PM 184 int rt2x00pci_suspend(struct pci_dev *pci_dev, pm_message_t state) 185 { 186 struct ieee80211_hw *hw = pci_get_drvdata(pci_dev); 187 struct rt2x00_dev *rt2x00dev = hw->priv; 188 int retval; 189 190 retval = rt2x00lib_suspend(rt2x00dev, state); 191 if (retval) 192 return retval; 193 194 pci_save_state(pci_dev); 195 pci_disable_device(pci_dev); 196 return pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state)); 197 } 198 EXPORT_SYMBOL_GPL(rt2x00pci_suspend); 199 200 int rt2x00pci_resume(struct pci_dev *pci_dev) 201 { 202 struct ieee80211_hw *hw = pci_get_drvdata(pci_dev); 203 struct rt2x00_dev *rt2x00dev = hw->priv; 204 205 if (pci_set_power_state(pci_dev, PCI_D0) || 206 pci_enable_device(pci_dev)) { 207 rt2x00_err(rt2x00dev, "Failed to resume device\n"); 208 return -EIO; 209 } 210 211 pci_restore_state(pci_dev); 212 return rt2x00lib_resume(rt2x00dev); 213 } 214 EXPORT_SYMBOL_GPL(rt2x00pci_resume); 215 #endif /* CONFIG_PM */ 216 217 /* 218 * rt2x00pci module information. 219 */ 220 MODULE_AUTHOR(DRV_PROJECT); 221 MODULE_VERSION(DRV_VERSION); 222 MODULE_DESCRIPTION("rt2x00 pci library"); 223 MODULE_LICENSE("GPL"); 224