diff options
author | David Kilroy <kilroyd@googlemail.com> | 2008-10-31 09:35:21 -0400 |
---|---|---|
committer | John W. Linville <linville@tuxdriver.com> | 2008-11-10 15:17:42 -0500 |
commit | b2e53b338b7b4608372d070bb477f3bae3971e5a (patch) | |
tree | 1d2bc35201029e8cd0b8007c5ebc0b07fd1a03ec /drivers/net/wireless/airport.c | |
parent | 5166ccd220f187b2e9edfc5f01eb49f4a0ebf586 (diff) |
orinoco: Move sources to a subdirectory
Keeping all the orinoco drivers in a common directory will make
maintenance easier.
Signed-off by: David Kilroy <kilroyd@googlemail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
Diffstat (limited to 'drivers/net/wireless/airport.c')
-rw-r--r-- | drivers/net/wireless/airport.c | 286 |
1 files changed, 0 insertions, 286 deletions
diff --git a/drivers/net/wireless/airport.c b/drivers/net/wireless/airport.c deleted file mode 100644 index ce03a2e865fa..000000000000 --- a/drivers/net/wireless/airport.c +++ /dev/null | |||
@@ -1,286 +0,0 @@ | |||
1 | /* airport.c | ||
2 | * | ||
3 | * A driver for "Hermes" chipset based Apple Airport wireless | ||
4 | * card. | ||
5 | * | ||
6 | * Copyright notice & release notes in file orinoco.c | ||
7 | * | ||
8 | * Note specific to airport stub: | ||
9 | * | ||
10 | * 0.05 : first version of the new split driver | ||
11 | * 0.06 : fix possible hang on powerup, add sleep support | ||
12 | */ | ||
13 | |||
14 | #define DRIVER_NAME "airport" | ||
15 | #define PFX DRIVER_NAME ": " | ||
16 | |||
17 | #include <linux/module.h> | ||
18 | #include <linux/kernel.h> | ||
19 | #include <linux/init.h> | ||
20 | #include <linux/delay.h> | ||
21 | #include <asm/pmac_feature.h> | ||
22 | |||
23 | #include "orinoco.h" | ||
24 | |||
25 | #define AIRPORT_IO_LEN (0x1000) /* one page */ | ||
26 | |||
27 | struct airport { | ||
28 | struct macio_dev *mdev; | ||
29 | void __iomem *vaddr; | ||
30 | int irq_requested; | ||
31 | int ndev_registered; | ||
32 | }; | ||
33 | |||
34 | static int | ||
35 | airport_suspend(struct macio_dev *mdev, pm_message_t state) | ||
36 | { | ||
37 | struct net_device *dev = dev_get_drvdata(&mdev->ofdev.dev); | ||
38 | struct orinoco_private *priv = netdev_priv(dev); | ||
39 | unsigned long flags; | ||
40 | int err; | ||
41 | |||
42 | printk(KERN_DEBUG "%s: Airport entering sleep mode\n", dev->name); | ||
43 | |||
44 | err = orinoco_lock(priv, &flags); | ||
45 | if (err) { | ||
46 | printk(KERN_ERR "%s: hw_unavailable on PBOOK_SLEEP_NOW\n", | ||
47 | dev->name); | ||
48 | return 0; | ||
49 | } | ||
50 | |||
51 | err = __orinoco_down(dev); | ||
52 | if (err) | ||
53 | printk(KERN_WARNING "%s: PBOOK_SLEEP_NOW: Error %d downing interface\n", | ||
54 | dev->name, err); | ||
55 | |||
56 | netif_device_detach(dev); | ||
57 | |||
58 | priv->hw_unavailable++; | ||
59 | |||
60 | orinoco_unlock(priv, &flags); | ||
61 | |||
62 | disable_irq(dev->irq); | ||
63 | pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(mdev), 0, 0); | ||
64 | |||
65 | return 0; | ||
66 | } | ||
67 | |||
68 | static int | ||
69 | airport_resume(struct macio_dev *mdev) | ||
70 | { | ||
71 | struct net_device *dev = dev_get_drvdata(&mdev->ofdev.dev); | ||
72 | struct orinoco_private *priv = netdev_priv(dev); | ||
73 | unsigned long flags; | ||
74 | int err; | ||
75 | |||
76 | printk(KERN_DEBUG "%s: Airport waking up\n", dev->name); | ||
77 | |||
78 | pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(mdev), 0, 1); | ||
79 | msleep(200); | ||
80 | |||
81 | enable_irq(dev->irq); | ||
82 | |||
83 | err = orinoco_reinit_firmware(dev); | ||
84 | if (err) { | ||
85 | printk(KERN_ERR "%s: Error %d re-initializing firmware on PBOOK_WAKE\n", | ||
86 | dev->name, err); | ||
87 | return 0; | ||
88 | } | ||
89 | |||
90 | spin_lock_irqsave(&priv->lock, flags); | ||
91 | |||
92 | netif_device_attach(dev); | ||
93 | |||
94 | priv->hw_unavailable--; | ||
95 | |||
96 | if (priv->open && (! priv->hw_unavailable)) { | ||
97 | err = __orinoco_up(dev); | ||
98 | if (err) | ||
99 | printk(KERN_ERR "%s: Error %d restarting card on PBOOK_WAKE\n", | ||
100 | dev->name, err); | ||
101 | } | ||
102 | |||
103 | |||
104 | spin_unlock_irqrestore(&priv->lock, flags); | ||
105 | |||
106 | return 0; | ||
107 | } | ||
108 | |||
109 | static int | ||
110 | airport_detach(struct macio_dev *mdev) | ||
111 | { | ||
112 | struct net_device *dev = dev_get_drvdata(&mdev->ofdev.dev); | ||
113 | struct orinoco_private *priv = netdev_priv(dev); | ||
114 | struct airport *card = priv->card; | ||
115 | |||
116 | if (card->ndev_registered) | ||
117 | unregister_netdev(dev); | ||
118 | card->ndev_registered = 0; | ||
119 | |||
120 | if (card->irq_requested) | ||
121 | free_irq(dev->irq, dev); | ||
122 | card->irq_requested = 0; | ||
123 | |||
124 | if (card->vaddr) | ||
125 | iounmap(card->vaddr); | ||
126 | card->vaddr = NULL; | ||
127 | |||
128 | macio_release_resource(mdev, 0); | ||
129 | |||
130 | pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(mdev), 0, 0); | ||
131 | ssleep(1); | ||
132 | |||
133 | macio_set_drvdata(mdev, NULL); | ||
134 | free_orinocodev(dev); | ||
135 | |||
136 | return 0; | ||
137 | } | ||
138 | |||
139 | static int airport_hard_reset(struct orinoco_private *priv) | ||
140 | { | ||
141 | /* It would be nice to power cycle the Airport for a real hard | ||
142 | * reset, but for some reason although it appears to | ||
143 | * re-initialize properly, it falls in a screaming heap | ||
144 | * shortly afterwards. */ | ||
145 | #if 0 | ||
146 | struct net_device *dev = priv->ndev; | ||
147 | struct airport *card = priv->card; | ||
148 | |||
149 | /* Vitally important. If we don't do this it seems we get an | ||
150 | * interrupt somewhere during the power cycle, since | ||
151 | * hw_unavailable is already set it doesn't get ACKed, we get | ||
152 | * into an interrupt loop and the PMU decides to turn us | ||
153 | * off. */ | ||
154 | disable_irq(dev->irq); | ||
155 | |||
156 | pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(card->mdev), 0, 0); | ||
157 | ssleep(1); | ||
158 | pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(card->mdev), 0, 1); | ||
159 | ssleep(1); | ||
160 | |||
161 | enable_irq(dev->irq); | ||
162 | ssleep(1); | ||
163 | #endif | ||
164 | |||
165 | return 0; | ||
166 | } | ||
167 | |||
168 | static int | ||
169 | airport_attach(struct macio_dev *mdev, const struct of_device_id *match) | ||
170 | { | ||
171 | struct orinoco_private *priv; | ||
172 | struct net_device *dev; | ||
173 | struct airport *card; | ||
174 | unsigned long phys_addr; | ||
175 | hermes_t *hw; | ||
176 | |||
177 | if (macio_resource_count(mdev) < 1 || macio_irq_count(mdev) < 1) { | ||
178 | printk(KERN_ERR PFX "Wrong interrupt/addresses in OF tree\n"); | ||
179 | return -ENODEV; | ||
180 | } | ||
181 | |||
182 | /* Allocate space for private device-specific data */ | ||
183 | dev = alloc_orinocodev(sizeof(*card), &mdev->ofdev.dev, | ||
184 | airport_hard_reset, NULL); | ||
185 | if (! dev) { | ||
186 | printk(KERN_ERR PFX "Cannot allocate network device\n"); | ||
187 | return -ENODEV; | ||
188 | } | ||
189 | priv = netdev_priv(dev); | ||
190 | card = priv->card; | ||
191 | |||
192 | hw = &priv->hw; | ||
193 | card->mdev = mdev; | ||
194 | |||
195 | if (macio_request_resource(mdev, 0, "airport")) { | ||
196 | printk(KERN_ERR PFX "can't request IO resource !\n"); | ||
197 | free_orinocodev(dev); | ||
198 | return -EBUSY; | ||
199 | } | ||
200 | |||
201 | SET_NETDEV_DEV(dev, &mdev->ofdev.dev); | ||
202 | |||
203 | macio_set_drvdata(mdev, dev); | ||
204 | |||
205 | /* Setup interrupts & base address */ | ||
206 | dev->irq = macio_irq(mdev, 0); | ||
207 | phys_addr = macio_resource_start(mdev, 0); /* Physical address */ | ||
208 | printk(KERN_DEBUG PFX "Physical address %lx\n", phys_addr); | ||
209 | dev->base_addr = phys_addr; | ||
210 | card->vaddr = ioremap(phys_addr, AIRPORT_IO_LEN); | ||
211 | if (!card->vaddr) { | ||
212 | printk(KERN_ERR PFX "ioremap() failed\n"); | ||
213 | goto failed; | ||
214 | } | ||
215 | |||
216 | hermes_struct_init(hw, card->vaddr, HERMES_16BIT_REGSPACING); | ||
217 | |||
218 | /* Power up card */ | ||
219 | pmac_call_feature(PMAC_FTR_AIRPORT_ENABLE, macio_get_of_node(mdev), 0, 1); | ||
220 | ssleep(1); | ||
221 | |||
222 | /* Reset it before we get the interrupt */ | ||
223 | hermes_init(hw); | ||
224 | |||
225 | if (request_irq(dev->irq, orinoco_interrupt, 0, dev->name, dev)) { | ||
226 | printk(KERN_ERR PFX "Couldn't get IRQ %d\n", dev->irq); | ||
227 | goto failed; | ||
228 | } | ||
229 | card->irq_requested = 1; | ||
230 | |||
231 | /* Tell the stack we exist */ | ||
232 | if (register_netdev(dev) != 0) { | ||
233 | printk(KERN_ERR PFX "register_netdev() failed\n"); | ||
234 | goto failed; | ||
235 | } | ||
236 | printk(KERN_DEBUG PFX "Card registered for interface %s\n", dev->name); | ||
237 | card->ndev_registered = 1; | ||
238 | return 0; | ||
239 | failed: | ||
240 | airport_detach(mdev); | ||
241 | return -ENODEV; | ||
242 | } /* airport_attach */ | ||
243 | |||
244 | |||
245 | static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION | ||
246 | " (Benjamin Herrenschmidt <benh@kernel.crashing.org>)"; | ||
247 | MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>"); | ||
248 | MODULE_DESCRIPTION("Driver for the Apple Airport wireless card."); | ||
249 | MODULE_LICENSE("Dual MPL/GPL"); | ||
250 | |||
251 | static struct of_device_id airport_match[] = | ||
252 | { | ||
253 | { | ||
254 | .name = "radio", | ||
255 | }, | ||
256 | {}, | ||
257 | }; | ||
258 | |||
259 | MODULE_DEVICE_TABLE (of, airport_match); | ||
260 | |||
261 | static struct macio_driver airport_driver = | ||
262 | { | ||
263 | .name = DRIVER_NAME, | ||
264 | .match_table = airport_match, | ||
265 | .probe = airport_attach, | ||
266 | .remove = airport_detach, | ||
267 | .suspend = airport_suspend, | ||
268 | .resume = airport_resume, | ||
269 | }; | ||
270 | |||
271 | static int __init | ||
272 | init_airport(void) | ||
273 | { | ||
274 | printk(KERN_DEBUG "%s\n", version); | ||
275 | |||
276 | return macio_register_driver(&airport_driver); | ||
277 | } | ||
278 | |||
279 | static void __exit | ||
280 | exit_airport(void) | ||
281 | { | ||
282 | return macio_unregister_driver(&airport_driver); | ||
283 | } | ||
284 | |||
285 | module_init(init_airport); | ||
286 | module_exit(exit_airport); | ||