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 orinoco.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 */ 60static int orinoco_tmd_cor_reset(struct orinoco_private *priv) 61{ 62 hermes_t *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 + (TMD_RESET_TIME * HZ / 1000); 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 91static 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 struct net_device *dev; 98 void __iomem *hermes_io, *bridge_io; 99 100 err = pci_enable_device(pdev); 101 if (err) { 102 printk(KERN_ERR PFX "Cannot enable PCI device\n"); 103 return err; 104 } 105 106 err = pci_request_regions(pdev, DRIVER_NAME); 107 if (err) { 108 printk(KERN_ERR PFX "Cannot obtain PCI resources\n"); 109 goto fail_resources; 110 } 111 112 bridge_io = pci_iomap(pdev, 1, 0); 113 if (!bridge_io) { 114 printk(KERN_ERR PFX "Cannot map bridge registers\n"); 115 err = -EIO; 116 goto fail_map_bridge; 117 } 118 119 hermes_io = pci_iomap(pdev, 2, 0); 120 if (!hermes_io) { 121 printk(KERN_ERR PFX "Cannot map chipset registers\n"); 122 err = -EIO; 123 goto fail_map_hermes; 124 } 125 126 /* Allocate network device */ 127 dev = alloc_orinocodev(sizeof(*card), orinoco_tmd_cor_reset); 128 if (!dev) { 129 printk(KERN_ERR PFX "Cannot allocate network device\n"); 130 err = -ENOMEM; 131 goto fail_alloc; 132 } 133 134 priv = netdev_priv(dev); 135 card = priv->card; 136 card->bridge_io = bridge_io; 137 SET_MODULE_OWNER(dev); 138 SET_NETDEV_DEV(dev, &pdev->dev); 139 140 hermes_struct_init(&priv->hw, hermes_io, HERMES_16BIT_REGSPACING); 141 142 err = request_irq(pdev->irq, orinoco_interrupt, IRQF_SHARED, 143 dev->name, dev); 144 if (err) { 145 printk(KERN_ERR PFX "Cannot allocate IRQ %d\n", pdev->irq); 146 err = -EBUSY; 147 goto fail_irq; 148 } 149 150 err = orinoco_tmd_cor_reset(priv); 151 if (err) { 152 printk(KERN_ERR PFX "Initial reset failed\n"); 153 goto fail; 154 } 155 156 err = register_netdev(dev); 157 if (err) { 158 printk(KERN_ERR PFX "Cannot register network device\n"); 159 goto fail; 160 } 161 162 pci_set_drvdata(pdev, dev); 163 printk(KERN_DEBUG "%s: " DRIVER_NAME " at %s\n", dev->name, 164 pci_name(pdev)); 165 166 return 0; 167 168 fail: 169 free_irq(pdev->irq, dev); 170 171 fail_irq: 172 pci_set_drvdata(pdev, NULL); 173 free_orinocodev(dev); 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 190static void __devexit orinoco_tmd_remove_one(struct pci_dev *pdev) 191{ 192 struct net_device *dev = pci_get_drvdata(pdev); 193 struct orinoco_private *priv = dev->priv; 194 struct orinoco_pci_card *card = priv->card; 195 196 unregister_netdev(dev); 197 free_irq(pdev->irq, dev); 198 pci_set_drvdata(pdev, NULL); 199 free_orinocodev(dev); 200 pci_iounmap(pdev, priv->hw.iobase); 201 pci_iounmap(pdev, card->bridge_io); 202 pci_release_regions(pdev); 203 pci_disable_device(pdev); 204} 205 206static struct pci_device_id orinoco_tmd_id_table[] = { 207 {0x15e8, 0x0131, PCI_ANY_ID, PCI_ANY_ID,}, /* NDC and OEMs, e.g. pheecom */ 208 {0,}, 209}; 210 211MODULE_DEVICE_TABLE(pci, orinoco_tmd_id_table); 212 213static struct pci_driver orinoco_tmd_driver = { 214 .name = DRIVER_NAME, 215 .id_table = orinoco_tmd_id_table, 216 .probe = orinoco_tmd_init_one, 217 .remove = __devexit_p(orinoco_tmd_remove_one), 218 .suspend = orinoco_pci_suspend, 219 .resume = orinoco_pci_resume, 220}; 221 222static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION 223 " (Joerg Dorchain <joerg@dorchain.net>)"; 224MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>"); 225MODULE_DESCRIPTION("Driver for wireless LAN cards using the TMD7160 PCI bridge"); 226MODULE_LICENSE("Dual MPL/GPL"); 227 228static int __init orinoco_tmd_init(void) 229{ 230 printk(KERN_DEBUG "%s\n", version); 231 return pci_register_driver(&orinoco_tmd_driver); 232} 233 234static void __exit orinoco_tmd_exit(void) 235{ 236 pci_unregister_driver(&orinoco_tmd_driver); 237} 238 239module_init(orinoco_tmd_init); 240module_exit(orinoco_tmd_exit); 241 242/* 243 * Local variables: 244 * c-indent-level: 8 245 * c-basic-offset: 8 246 * tab-width: 8 247 * End: 248 */ 249