Commit | Line | Data |
---|---|---|
e3b3d0f5 | 1 | // SPDX-License-Identifier: GPL-2.0 |
099dc4fb DS |
2 | /* |
3 | * IPWireless 3G PCMCIA Network Driver | |
4 | * | |
5 | * Original code | |
6 | * by Stephen Blackheath <stephen@blacksapphire.com>, | |
7 | * Ben Martel <benm@symmetric.co.nz> | |
8 | * | |
9 | * Copyrighted as follows: | |
10 | * Copyright (C) 2004 by Symmetric Systems Ltd (NZ) | |
11 | * | |
12 | * Various driver changes and rewrites, port to new kernels | |
13 | * Copyright (C) 2006-2007 Jiri Kosina | |
14 | * | |
15 | * Misc code cleanups and updates | |
16 | * Copyright (C) 2007 David Sterba | |
17 | */ | |
18 | ||
19 | #include "hardware.h" | |
20 | #include "network.h" | |
21 | #include "main.h" | |
22 | #include "tty.h" | |
23 | ||
24 | #include <linux/delay.h> | |
25 | #include <linux/init.h> | |
26 | #include <linux/io.h> | |
27 | #include <linux/kernel.h> | |
28 | #include <linux/module.h> | |
29 | #include <linux/sched.h> | |
30 | #include <linux/slab.h> | |
31 | ||
099dc4fb DS |
32 | #include <pcmcia/cisreg.h> |
33 | #include <pcmcia/device_id.h> | |
34 | #include <pcmcia/ss.h> | |
35 | #include <pcmcia/ds.h> | |
099dc4fb | 36 | |
25f8f54f | 37 | static const struct pcmcia_device_id ipw_ids[] = { |
099dc4fb DS |
38 | PCMCIA_DEVICE_MANF_CARD(0x02f2, 0x0100), |
39 | PCMCIA_DEVICE_MANF_CARD(0x02f2, 0x0200), | |
40 | PCMCIA_DEVICE_NULL | |
41 | }; | |
42 | MODULE_DEVICE_TABLE(pcmcia, ipw_ids); | |
43 | ||
44 | static void ipwireless_detach(struct pcmcia_device *link); | |
45 | ||
46 | /* | |
47 | * Module params | |
48 | */ | |
49 | /* Debug mode: more verbose, print sent/recv bytes */ | |
50 | int ipwireless_debug; | |
51 | int ipwireless_loopback; | |
bee9c7c0 | 52 | int ipwireless_out_queue = 10; |
099dc4fb DS |
53 | |
54 | module_param_named(debug, ipwireless_debug, int, 0); | |
55 | module_param_named(loopback, ipwireless_loopback, int, 0); | |
56 | module_param_named(out_queue, ipwireless_out_queue, int, 0); | |
57 | MODULE_PARM_DESC(debug, "switch on debug messages [0]"); | |
58 | MODULE_PARM_DESC(loopback, | |
59 | "debug: enable ras_raw channel [0]"); | |
bee9c7c0 | 60 | MODULE_PARM_DESC(out_queue, "debug: set size of outgoing PPP queue [10]"); |
099dc4fb DS |
61 | |
62 | /* Executes in process context. */ | |
63 | static void signalled_reboot_work(struct work_struct *work_reboot) | |
64 | { | |
65 | struct ipw_dev *ipw = container_of(work_reboot, struct ipw_dev, | |
66 | work_reboot); | |
67 | struct pcmcia_device *link = ipw->link; | |
cbf624f0 | 68 | pcmcia_reset_card(link->socket); |
099dc4fb DS |
69 | } |
70 | ||
71 | static void signalled_reboot_callback(void *callback_data) | |
72 | { | |
73 | struct ipw_dev *ipw = (struct ipw_dev *) callback_data; | |
74 | ||
75 | /* Delegate to process context. */ | |
76 | schedule_work(&ipw->work_reboot); | |
77 | } | |
78 | ||
00990e7c | 79 | static int ipwireless_probe(struct pcmcia_device *p_dev, void *priv_data) |
aaa8cfda | 80 | { |
af757923 | 81 | struct ipw_dev *ipw = priv_data; |
af757923 DB |
82 | int ret; |
83 | ||
00990e7c | 84 | p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH; |
90abdc3b | 85 | p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO; |
aaa8cfda | 86 | |
aaa8cfda DB |
87 | /* 0x40 causes it to generate level mode interrupts. */ |
88 | /* 0x04 enables IREQ pin. */ | |
00990e7c | 89 | p_dev->config_index |= 0x44; |
90abdc3b DB |
90 | p_dev->io_lines = 16; |
91 | ret = pcmcia_request_io(p_dev); | |
af757923 DB |
92 | if (ret) |
93 | return ret; | |
aaa8cfda | 94 | |
d5bb2923 JL |
95 | if (!request_region(p_dev->resource[0]->start, |
96 | resource_size(p_dev->resource[0]), | |
97 | IPWIRELESS_PCCARD_NAME)) { | |
98 | ret = -EBUSY; | |
99 | goto exit; | |
100 | } | |
099dc4fb | 101 | |
cdb13808 | 102 | p_dev->resource[2]->flags |= |
af757923 | 103 | WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_CM | WIN_ENABLE; |
099dc4fb | 104 | |
cdb13808 | 105 | ret = pcmcia_request_window(p_dev, p_dev->resource[2], 0); |
cbf624f0 | 106 | if (ret != 0) |
af757923 | 107 | goto exit1; |
099dc4fb | 108 | |
00990e7c | 109 | ret = pcmcia_map_mem_page(p_dev, p_dev->resource[2], p_dev->card_addr); |
cbf624f0 | 110 | if (ret != 0) |
d5bb2923 | 111 | goto exit1; |
099dc4fb | 112 | |
00990e7c | 113 | ipw->is_v2_card = resource_size(p_dev->resource[2]) == 0x100; |
099dc4fb | 114 | |
d5bb2923 | 115 | ipw->common_memory = ioremap(p_dev->resource[2]->start, |
cdb13808 | 116 | resource_size(p_dev->resource[2])); |
1bbb1c31 KL |
117 | if (!ipw->common_memory) { |
118 | ret = -ENOMEM; | |
119 | goto exit1; | |
120 | } | |
d5bb2923 JL |
121 | if (!request_mem_region(p_dev->resource[2]->start, |
122 | resource_size(p_dev->resource[2]), | |
123 | IPWIRELESS_PCCARD_NAME)) { | |
124 | ret = -EBUSY; | |
125 | goto exit2; | |
126 | } | |
af757923 | 127 | |
cdb13808 DB |
128 | p_dev->resource[3]->flags |= WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_AM | |
129 | WIN_ENABLE; | |
130 | p_dev->resource[3]->end = 0; /* this used to be 0x1000 */ | |
131 | ret = pcmcia_request_window(p_dev, p_dev->resource[3], 0); | |
cbf624f0 | 132 | if (ret != 0) |
d5bb2923 | 133 | goto exit3; |
099dc4fb | 134 | |
cdb13808 | 135 | ret = pcmcia_map_mem_page(p_dev, p_dev->resource[3], 0); |
cbf624f0 | 136 | if (ret != 0) |
af757923 | 137 | goto exit3; |
099dc4fb | 138 | |
cdb13808 DB |
139 | ipw->attr_memory = ioremap(p_dev->resource[3]->start, |
140 | resource_size(p_dev->resource[3])); | |
1bbb1c31 KL |
141 | if (!ipw->attr_memory) { |
142 | ret = -ENOMEM; | |
143 | goto exit3; | |
144 | } | |
d5bb2923 JL |
145 | if (!request_mem_region(p_dev->resource[3]->start, |
146 | resource_size(p_dev->resource[3]), | |
147 | IPWIRELESS_PCCARD_NAME)) { | |
148 | ret = -EBUSY; | |
149 | goto exit4; | |
150 | } | |
099dc4fb | 151 | |
af757923 | 152 | return 0; |
099dc4fb | 153 | |
d5bb2923 JL |
154 | exit4: |
155 | iounmap(ipw->attr_memory); | |
af757923 | 156 | exit3: |
d5bb2923 JL |
157 | release_mem_region(p_dev->resource[2]->start, |
158 | resource_size(p_dev->resource[2])); | |
af757923 | 159 | exit2: |
d5bb2923 | 160 | iounmap(ipw->common_memory); |
af757923 | 161 | exit1: |
d5bb2923 JL |
162 | release_region(p_dev->resource[0]->start, |
163 | resource_size(p_dev->resource[0])); | |
164 | exit: | |
af757923 | 165 | pcmcia_disable_device(p_dev); |
d5bb2923 | 166 | return ret; |
af757923 | 167 | } |
099dc4fb | 168 | |
af757923 DB |
169 | static int config_ipwireless(struct ipw_dev *ipw) |
170 | { | |
171 | struct pcmcia_device *link = ipw->link; | |
172 | int ret = 0; | |
099dc4fb | 173 | |
af757923 | 174 | ipw->is_v2_card = 0; |
00990e7c DB |
175 | link->config_flags |= CONF_AUTO_SET_IO | CONF_AUTO_SET_IOMEM | |
176 | CONF_ENABLE_IRQ; | |
099dc4fb | 177 | |
af757923 | 178 | ret = pcmcia_loop_config(link, ipwireless_probe, ipw); |
cbf624f0 | 179 | if (ret != 0) |
af757923 | 180 | return ret; |
099dc4fb | 181 | |
099dc4fb DS |
182 | INIT_WORK(&ipw->work_reboot, signalled_reboot_work); |
183 | ||
9a017a91 | 184 | ipwireless_init_hardware_v1(ipw->hardware, link->resource[0]->start, |
099dc4fb DS |
185 | ipw->attr_memory, ipw->common_memory, |
186 | ipw->is_v2_card, signalled_reboot_callback, | |
187 | ipw); | |
188 | ||
eb14120f | 189 | ret = pcmcia_request_irq(link, ipwireless_interrupt); |
cbf624f0 | 190 | if (ret != 0) |
af757923 | 191 | goto exit; |
099dc4fb | 192 | |
099dc4fb DS |
193 | printk(KERN_INFO IPWIRELESS_PCCARD_NAME ": Card type %s\n", |
194 | ipw->is_v2_card ? "V2/V3" : "V1"); | |
195 | printk(KERN_INFO IPWIRELESS_PCCARD_NAME | |
9a017a91 | 196 | ": I/O ports %pR, irq %d\n", link->resource[0], |
eb14120f | 197 | (unsigned int) link->irq); |
099dc4fb DS |
198 | if (ipw->attr_memory && ipw->common_memory) |
199 | printk(KERN_INFO IPWIRELESS_PCCARD_NAME | |
cdb13808 DB |
200 | ": attr memory %pR, common memory %pR\n", |
201 | link->resource[3], | |
202 | link->resource[2]); | |
099dc4fb DS |
203 | |
204 | ipw->network = ipwireless_network_create(ipw->hardware); | |
205 | if (!ipw->network) | |
af757923 | 206 | goto exit; |
099dc4fb | 207 | |
b498ada6 | 208 | ipw->tty = ipwireless_tty_create(ipw->hardware, ipw->network); |
099dc4fb | 209 | if (!ipw->tty) |
af757923 | 210 | goto exit; |
099dc4fb DS |
211 | |
212 | ipwireless_init_hardware_v2_v3(ipw->hardware); | |
213 | ||
214 | /* | |
215 | * Do the RequestConfiguration last, because it enables interrupts. | |
216 | * Then we don't get any interrupts before we're ready for them. | |
217 | */ | |
1ac71e5a | 218 | ret = pcmcia_enable_device(link); |
cbf624f0 | 219 | if (ret != 0) |
af757923 | 220 | goto exit; |
099dc4fb | 221 | |
099dc4fb DS |
222 | return 0; |
223 | ||
af757923 | 224 | exit: |
099dc4fb | 225 | if (ipw->common_memory) { |
cdb13808 DB |
226 | release_mem_region(link->resource[2]->start, |
227 | resource_size(link->resource[2])); | |
099dc4fb | 228 | iounmap(ipw->common_memory); |
099dc4fb | 229 | } |
cdb13808 DB |
230 | if (ipw->attr_memory) { |
231 | release_mem_region(link->resource[3]->start, | |
232 | resource_size(link->resource[3])); | |
233 | iounmap(ipw->attr_memory); | |
234 | } | |
099dc4fb | 235 | pcmcia_disable_device(link); |
099dc4fb DS |
236 | return -1; |
237 | } | |
238 | ||
239 | static void release_ipwireless(struct ipw_dev *ipw) | |
240 | { | |
d5bb2923 JL |
241 | release_region(ipw->link->resource[0]->start, |
242 | resource_size(ipw->link->resource[0])); | |
09e491e9 | 243 | if (ipw->common_memory) { |
cdb13808 DB |
244 | release_mem_region(ipw->link->resource[2]->start, |
245 | resource_size(ipw->link->resource[2])); | |
099dc4fb | 246 | iounmap(ipw->common_memory); |
09e491e9 DS |
247 | } |
248 | if (ipw->attr_memory) { | |
cdb13808 DB |
249 | release_mem_region(ipw->link->resource[3]->start, |
250 | resource_size(ipw->link->resource[3])); | |
099dc4fb | 251 | iounmap(ipw->attr_memory); |
09e491e9 | 252 | } |
09e491e9 | 253 | pcmcia_disable_device(ipw->link); |
099dc4fb DS |
254 | } |
255 | ||
256 | /* | |
257 | * ipwireless_attach() creates an "instance" of the driver, allocating | |
258 | * local data structures for one device (one interface). The device | |
259 | * is registered with Card Services. | |
260 | * | |
261 | * The pcmcia_device structure is initialized, but we don't actually | |
262 | * configure the card at this point -- we wait until we receive a | |
263 | * card insertion event. | |
264 | */ | |
265 | static int ipwireless_attach(struct pcmcia_device *link) | |
266 | { | |
267 | struct ipw_dev *ipw; | |
268 | int ret; | |
269 | ||
270 | ipw = kzalloc(sizeof(struct ipw_dev), GFP_KERNEL); | |
271 | if (!ipw) | |
272 | return -ENOMEM; | |
273 | ||
274 | ipw->link = link; | |
275 | link->priv = ipw; | |
099dc4fb | 276 | |
099dc4fb DS |
277 | ipw->hardware = ipwireless_hardware_create(); |
278 | if (!ipw->hardware) { | |
279 | kfree(ipw); | |
280 | return -ENOMEM; | |
281 | } | |
282 | /* RegisterClient will call config_ipwireless */ | |
283 | ||
284 | ret = config_ipwireless(ipw); | |
285 | ||
286 | if (ret != 0) { | |
099dc4fb DS |
287 | ipwireless_detach(link); |
288 | return ret; | |
289 | } | |
290 | ||
291 | return 0; | |
292 | } | |
293 | ||
294 | /* | |
295 | * This deletes a driver "instance". The device is de-registered with | |
296 | * Card Services. If it has been released, all local data structures | |
297 | * are freed. Otherwise, the structures will be freed when the device | |
298 | * is released. | |
299 | */ | |
300 | static void ipwireless_detach(struct pcmcia_device *link) | |
301 | { | |
302 | struct ipw_dev *ipw = link->priv; | |
303 | ||
304 | release_ipwireless(ipw); | |
305 | ||
099dc4fb DS |
306 | if (ipw->tty != NULL) |
307 | ipwireless_tty_free(ipw->tty); | |
308 | if (ipw->network != NULL) | |
309 | ipwireless_network_free(ipw->network); | |
310 | if (ipw->hardware != NULL) | |
311 | ipwireless_hardware_free(ipw->hardware); | |
312 | kfree(ipw); | |
313 | } | |
314 | ||
315 | static struct pcmcia_driver me = { | |
316 | .owner = THIS_MODULE, | |
317 | .probe = ipwireless_attach, | |
318 | .remove = ipwireless_detach, | |
2e9b981a | 319 | .name = IPWIRELESS_PCCARD_NAME, |
099dc4fb DS |
320 | .id_table = ipw_ids |
321 | }; | |
322 | ||
323 | /* | |
324 | * Module insertion : initialisation of the module. | |
325 | * Register the card with cardmgr... | |
326 | */ | |
327 | static int __init init_ipwireless(void) | |
328 | { | |
329 | int ret; | |
330 | ||
099dc4fb DS |
331 | ret = ipwireless_tty_init(); |
332 | if (ret != 0) | |
333 | return ret; | |
334 | ||
335 | ret = pcmcia_register_driver(&me); | |
336 | if (ret != 0) | |
337 | ipwireless_tty_release(); | |
338 | ||
339 | return ret; | |
340 | } | |
341 | ||
342 | /* | |
343 | * Module removal | |
344 | */ | |
345 | static void __exit exit_ipwireless(void) | |
346 | { | |
099dc4fb DS |
347 | pcmcia_unregister_driver(&me); |
348 | ipwireless_tty_release(); | |
349 | } | |
350 | ||
351 | module_init(init_ipwireless); | |
352 | module_exit(exit_ipwireless); | |
353 | ||
354 | MODULE_AUTHOR(IPWIRELESS_PCMCIA_AUTHOR); | |
355 | MODULE_DESCRIPTION(IPWIRELESS_PCCARD_NAME " " IPWIRELESS_PCMCIA_VERSION); | |
356 | MODULE_LICENSE("GPL"); |