1 /* orinoco_tmd.c 2 * 3 * Driver for Prism II devices which would usually be driven by orinoco_cs, 4 * but are connected to the PCI bus by a TMD7160. 5 * 6 * Copyright (C) 2003 Joerg Dorchain <joerg AT dorchain.net> 7 * based heavily upon orinoco_plx.c Copyright (C) 2001 Daniel Barlow 8 * 9 * The contents of this file are subject to the Mozilla Public License 10 * Version 1.1 (the "License"); you may not use this file except in 11 * compliance with the License. You may obtain a copy of the License 12 * at http://www.mozilla.org/MPL/ 13 * 14 * Software distributed under the License is distributed on an "AS IS" 15 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See 16 * the License for the specific language governing rights and 17 * limitations under the License. 18 * 19 * Alternatively, the contents of this file may be used under the 20 * terms of the GNU General Public License version 2 (the "GPL"), in 21 * which case the provisions of the GPL are applicable instead of the 22 * above. If you wish to allow the use of your version of this file 23 * only under the terms of the GPL and not to allow others to use your 24 * version of this file under the MPL, indicate your decision by 25 * deleting the provisions above and replace them with the notice and 26 * other provisions required by the GPL. If you do not delete the 27 * provisions above, a recipient may use your version of this file 28 * under either the MPL or the GPL. 29 * 30 * The actual driving is done by main.c, this is just resource 31 * allocation stuff. 32 * 33 * This driver is modeled after the orinoco_plx driver. The main 34 * difference is that the TMD chip has only IO port ranges and doesn't 35 * provide access to the PCMCIA attribute space. 36 * 37 * Pheecom sells cards with the TMD chip as "ASIC version" 38 */ 39 40 #define DRIVER_NAME "orinoco_tmd" 41 #define PFX DRIVER_NAME ": " 42 43 #include <linux/module.h> 44 #include <linux/kernel.h> 45 #include <linux/init.h> 46 #include <linux/delay.h> 47 #include <linux/pci.h> 48 #include <pcmcia/cisreg.h> 49 50 #include "orinoco.h" 51 #include "orinoco_pci.h" 52 53 #define COR_VALUE (COR_LEVEL_REQ | COR_FUNC_ENA) /* Enable PC card with interrupt in level trigger */ 54 #define COR_RESET (0x80) /* reset bit in the COR register */ 55 #define TMD_RESET_TIME (500) /* milliseconds */ 56 57 /* 58 * Do a soft reset of the card using the Configuration Option Register 59 */ 60 static int orinoco_tmd_cor_reset(struct orinoco_private *priv) 61 { 62 struct hermes *hw = &priv->hw; 63 struct orinoco_pci_card *card = priv->card; 64 unsigned long timeout; 65 u16 reg; 66 67 iowrite8(COR_VALUE | COR_RESET, card->bridge_io); 68 mdelay(1); 69 70 iowrite8(COR_VALUE, card->bridge_io); 71 mdelay(1); 72 73 /* Just in case, wait more until the card is no longer busy */ 74 timeout = jiffies + msecs_to_jiffies(TMD_RESET_TIME); 75 reg = hermes_read_regn(hw, CMD); 76 while (time_before(jiffies, timeout) && (reg & HERMES_CMD_BUSY)) { 77 mdelay(1); 78 reg = hermes_read_regn(hw, CMD); 79 } 80 81 /* Still busy? */ 82 if (reg & HERMES_CMD_BUSY) { 83 printk(KERN_ERR PFX "Busy timeout\n"); 84 return -ETIMEDOUT; 85 } 86 87 return 0; 88 } 89 90 91 static int orinoco_tmd_init_one(struct pci_dev *pdev, 92 const struct pci_device_id *ent) 93 { 94 int err; 95 struct orinoco_private *priv; 96 struct orinoco_pci_card *card; 97 void __iomem *hermes_io, *bridge_io; 98 99 err = pci_enable_device(pdev); 100 if (err) { 101 printk(KERN_ERR PFX "Cannot enable PCI device\n"); 102 return err; 103 } 104 105 err = pci_request_regions(pdev, DRIVER_NAME); 106 if (err) { 107 printk(KERN_ERR PFX "Cannot obtain PCI resources\n"); 108 goto fail_resources; 109 } 110 111 bridge_io = pci_iomap(pdev, 1, 0); 112 if (!bridge_io) { 113 printk(KERN_ERR PFX "Cannot map bridge registers\n"); 114 err = -EIO; 115 goto fail_map_bridge; 116 } 117 118 hermes_io = pci_iomap(pdev, 2, 0); 119 if (!hermes_io) { 120 printk(KERN_ERR PFX "Cannot map chipset registers\n"); 121 err = -EIO; 122 goto fail_map_hermes; 123 } 124 125 /* Allocate network device */ 126 priv = alloc_orinocodev(sizeof(*card), &pdev->dev, 127 orinoco_tmd_cor_reset, NULL); 128 if (!priv) { 129 printk(KERN_ERR PFX "Cannot allocate network device\n"); 130 err = -ENOMEM; 131 goto fail_alloc; 132 } 133 134 card = priv->card; 135 card->bridge_io = bridge_io; 136 137 hermes_struct_init(&priv->hw, hermes_io, HERMES_16BIT_REGSPACING); 138 139 err = request_irq(pdev->irq, orinoco_interrupt, IRQF_SHARED, 140 DRIVER_NAME, priv); 141 if (err) { 142 printk(KERN_ERR PFX "Cannot allocate IRQ %d\n", pdev->irq); 143 err = -EBUSY; 144 goto fail_irq; 145 } 146 147 err = orinoco_tmd_cor_reset(priv); 148 if (err) { 149 printk(KERN_ERR PFX "Initial reset failed\n"); 150 goto fail; 151 } 152 153 err = orinoco_init(priv); 154 if (err) { 155 printk(KERN_ERR PFX "orinoco_init() failed\n"); 156 goto fail; 157 } 158 159 err = orinoco_if_add(priv, 0, 0, NULL); 160 if (err) { 161 printk(KERN_ERR PFX "orinoco_if_add() failed\n"); 162 goto fail; 163 } 164 165 pci_set_drvdata(pdev, priv); 166 167 return 0; 168 169 fail: 170 free_irq(pdev->irq, priv); 171 172 fail_irq: 173 free_orinocodev(priv); 174 175 fail_alloc: 176 pci_iounmap(pdev, hermes_io); 177 178 fail_map_hermes: 179 pci_iounmap(pdev, bridge_io); 180 181 fail_map_bridge: 182 pci_release_regions(pdev); 183 184 fail_resources: 185 pci_disable_device(pdev); 186 187 return err; 188 } 189 190 static void orinoco_tmd_remove_one(struct pci_dev *pdev) 191 { 192 struct orinoco_private *priv = pci_get_drvdata(pdev); 193 struct orinoco_pci_card *card = priv->card; 194 195 orinoco_if_del(priv); 196 free_irq(pdev->irq, priv); 197 free_orinocodev(priv); 198 pci_iounmap(pdev, priv->hw.iobase); 199 pci_iounmap(pdev, card->bridge_io); 200 pci_release_regions(pdev); 201 pci_disable_device(pdev); 202 } 203 204 static const struct pci_device_id orinoco_tmd_id_table[] = { 205 {0x15e8, 0x0131, PCI_ANY_ID, PCI_ANY_ID,}, /* NDC and OEMs, e.g. pheecom */ 206 {0,}, 207 }; 208 209 MODULE_DEVICE_TABLE(pci, orinoco_tmd_id_table); 210 211 static struct pci_driver orinoco_tmd_driver = { 212 .name = DRIVER_NAME, 213 .id_table = orinoco_tmd_id_table, 214 .probe = orinoco_tmd_init_one, 215 .remove = orinoco_tmd_remove_one, 216 .driver.pm = &orinoco_pci_pm_ops, 217 }; 218 219 static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION 220 " (Joerg Dorchain <joerg@dorchain.net>)"; 221 MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>"); 222 MODULE_DESCRIPTION("Driver for wireless LAN cards using the TMD7160 PCI bridge"); 223 MODULE_LICENSE("Dual MPL/GPL"); 224 225 static int __init orinoco_tmd_init(void) 226 { 227 printk(KERN_DEBUG "%s\n", version); 228 return pci_register_driver(&orinoco_tmd_driver); 229 } 230 231 static void __exit orinoco_tmd_exit(void) 232 { 233 pci_unregister_driver(&orinoco_tmd_driver); 234 } 235 236 module_init(orinoco_tmd_init); 237 module_exit(orinoco_tmd_exit); 238 239 /* 240 * Local variables: 241 * c-indent-level: 8 242 * c-basic-offset: 8 243 * tab-width: 8 244 * End: 245 */ 246