2 * IPWireless 3G PCMCIA Network Driver
5 * by Stephen Blackheath <stephen@blacksapphire.com>,
6 * Ben Martel <benm@symmetric.co.nz>
8 * Copyrighted as follows:
9 * Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
11 * Various driver changes and rewrites, port to new kernels
12 * Copyright (C) 2006-2007 Jiri Kosina
14 * Misc code cleanups and updates
15 * Copyright (C) 2007 David Sterba
23 #include <linux/delay.h>
24 #include <linux/init.h>
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/sched.h>
29 #include <linux/slab.h>
31 #include <pcmcia/cisreg.h>
32 #include <pcmcia/device_id.h>
33 #include <pcmcia/ss.h>
34 #include <pcmcia/ds.h>
35 #include <pcmcia/cs.h>
37 static struct pcmcia_device_id ipw_ids
[] = {
38 PCMCIA_DEVICE_MANF_CARD(0x02f2, 0x0100),
39 PCMCIA_DEVICE_MANF_CARD(0x02f2, 0x0200),
42 MODULE_DEVICE_TABLE(pcmcia
, ipw_ids
);
44 static void ipwireless_detach(struct pcmcia_device
*link
);
49 /* Debug mode: more verbose, print sent/recv bytes */
51 int ipwireless_loopback
;
52 int ipwireless_out_queue
= 1;
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]");
60 MODULE_PARM_DESC(out_queue
, "debug: set size of outgoing queue [1]");
62 /* Executes in process context. */
63 static void signalled_reboot_work(struct work_struct
*work_reboot
)
65 struct ipw_dev
*ipw
= container_of(work_reboot
, struct ipw_dev
,
67 struct pcmcia_device
*link
= ipw
->link
;
68 int ret
= pccard_reset_card(link
->socket
);
70 if (ret
!= CS_SUCCESS
)
71 cs_error(link
, ResetCard
, ret
);
74 static void signalled_reboot_callback(void *callback_data
)
76 struct ipw_dev
*ipw
= (struct ipw_dev
*) callback_data
;
78 /* Delegate to process context. */
79 schedule_work(&ipw
->work_reboot
);
82 static int config_ipwireless(struct ipw_dev
*ipw
)
84 struct pcmcia_device
*link
= ipw
->link
;
88 unsigned short buf
[64];
90 unsigned short cor_value
;
91 win_req_t request_attr_memory
;
92 win_req_t request_common_memory
;
93 memreq_t memreq_attr_memory
;
94 memreq_t memreq_common_memory
;
99 tuple
.TupleData
= (cisdata_t
*) buf
;
100 tuple
.TupleDataMax
= sizeof(buf
);
101 tuple
.TupleOffset
= 0;
103 tuple
.DesiredTuple
= RETURN_FIRST_TUPLE
;
105 ret
= pcmcia_get_first_tuple(link
, &tuple
);
108 ret
= pcmcia_get_tuple_data(link
, &tuple
);
110 if (ret
!= CS_SUCCESS
) {
111 cs_error(link
, GetTupleData
, ret
);
114 ret
= pcmcia_get_next_tuple(link
, &tuple
);
117 tuple
.DesiredTuple
= CISTPL_CFTABLE_ENTRY
;
119 ret
= pcmcia_get_first_tuple(link
, &tuple
);
121 if (ret
!= CS_SUCCESS
) {
122 cs_error(link
, GetFirstTuple
, ret
);
126 ret
= pcmcia_get_tuple_data(link
, &tuple
);
128 if (ret
!= CS_SUCCESS
) {
129 cs_error(link
, GetTupleData
, ret
);
133 ret
= pcmcia_parse_tuple(link
, &tuple
, &parse
);
135 if (ret
!= CS_SUCCESS
) {
136 cs_error(link
, ParseTuple
, ret
);
140 link
->io
.Attributes1
= IO_DATA_PATH_WIDTH_AUTO
;
141 link
->io
.BasePort1
= parse
.cftable_entry
.io
.win
[0].base
;
142 link
->io
.NumPorts1
= parse
.cftable_entry
.io
.win
[0].len
;
143 link
->io
.IOAddrLines
= 16;
145 link
->irq
.IRQInfo1
= parse
.cftable_entry
.irq
.IRQInfo1
;
147 /* 0x40 causes it to generate level mode interrupts. */
148 /* 0x04 enables IREQ pin. */
149 cor_value
= parse
.cftable_entry
.index
| 0x44;
150 link
->conf
.ConfigIndex
= cor_value
;
152 /* IRQ and I/O settings */
153 tuple
.DesiredTuple
= CISTPL_CONFIG
;
155 ret
= pcmcia_get_first_tuple(link
, &tuple
);
157 if (ret
!= CS_SUCCESS
) {
158 cs_error(link
, GetFirstTuple
, ret
);
162 ret
= pcmcia_get_tuple_data(link
, &tuple
);
164 if (ret
!= CS_SUCCESS
) {
165 cs_error(link
, GetTupleData
, ret
);
169 ret
= pcmcia_parse_tuple(link
, &tuple
, &parse
);
171 if (ret
!= CS_SUCCESS
) {
172 cs_error(link
, GetTupleData
, ret
);
175 link
->conf
.Attributes
= CONF_ENABLE_IRQ
;
176 link
->conf
.ConfigBase
= parse
.config
.base
;
177 link
->conf
.Present
= parse
.config
.rmask
[0];
178 link
->conf
.IntType
= INT_MEMORY_AND_IO
;
180 link
->irq
.Attributes
= IRQ_TYPE_DYNAMIC_SHARING
| IRQ_HANDLE_PRESENT
;
181 link
->irq
.Handler
= ipwireless_interrupt
;
182 link
->irq
.Instance
= ipw
->hardware
;
184 ret
= pcmcia_request_io(link
, &link
->io
);
186 if (ret
!= CS_SUCCESS
) {
187 cs_error(link
, RequestIO
, ret
);
191 /* memory settings */
193 tuple
.DesiredTuple
= CISTPL_CFTABLE_ENTRY
;
195 ret
= pcmcia_get_first_tuple(link
, &tuple
);
197 if (ret
!= CS_SUCCESS
) {
198 cs_error(link
, GetFirstTuple
, ret
);
202 ret
= pcmcia_get_tuple_data(link
, &tuple
);
204 if (ret
!= CS_SUCCESS
) {
205 cs_error(link
, GetTupleData
, ret
);
209 ret
= pcmcia_parse_tuple(link
, &tuple
, &parse
);
211 if (ret
!= CS_SUCCESS
) {
212 cs_error(link
, ParseTuple
, ret
);
216 if (parse
.cftable_entry
.mem
.nwin
> 0) {
217 request_common_memory
.Attributes
=
218 WIN_DATA_WIDTH_16
| WIN_MEMORY_TYPE_CM
| WIN_ENABLE
;
219 request_common_memory
.Base
=
220 parse
.cftable_entry
.mem
.win
[0].host_addr
;
221 request_common_memory
.Size
= parse
.cftable_entry
.mem
.win
[0].len
;
222 if (request_common_memory
.Size
< 0x1000)
223 request_common_memory
.Size
= 0x1000;
224 request_common_memory
.AccessSpeed
= 0;
226 ret
= pcmcia_request_window(&link
, &request_common_memory
,
227 &ipw
->handle_common_memory
);
229 if (ret
!= CS_SUCCESS
) {
230 cs_error(link
, RequestWindow
, ret
);
234 memreq_common_memory
.CardOffset
=
235 parse
.cftable_entry
.mem
.win
[0].card_addr
;
236 memreq_common_memory
.Page
= 0;
238 ret
= pcmcia_map_mem_page(ipw
->handle_common_memory
,
239 &memreq_common_memory
);
241 if (ret
!= CS_SUCCESS
) {
242 cs_error(link
, MapMemPage
, ret
);
247 parse
.cftable_entry
.mem
.win
[0].len
== 0x100;
249 ipw
->common_memory
= ioremap(request_common_memory
.Base
,
250 request_common_memory
.Size
);
252 request_attr_memory
.Attributes
=
253 WIN_DATA_WIDTH_16
| WIN_MEMORY_TYPE_AM
| WIN_ENABLE
;
254 request_attr_memory
.Base
= 0;
255 request_attr_memory
.Size
= 0; /* this used to be 0x1000 */
256 request_attr_memory
.AccessSpeed
= 0;
258 ret
= pcmcia_request_window(&link
, &request_attr_memory
,
259 &ipw
->handle_attr_memory
);
261 if (ret
!= CS_SUCCESS
) {
262 cs_error(link
, RequestWindow
, ret
);
266 memreq_attr_memory
.CardOffset
= 0;
267 memreq_attr_memory
.Page
= 0;
269 ret
= pcmcia_map_mem_page(ipw
->handle_attr_memory
,
270 &memreq_attr_memory
);
272 if (ret
!= CS_SUCCESS
) {
273 cs_error(link
, MapMemPage
, ret
);
277 ipw
->attr_memory
= ioremap(request_attr_memory
.Base
,
278 request_attr_memory
.Size
);
281 INIT_WORK(&ipw
->work_reboot
, signalled_reboot_work
);
283 ipwireless_init_hardware_v1(ipw
->hardware
, link
->io
.BasePort1
,
284 ipw
->attr_memory
, ipw
->common_memory
,
285 ipw
->is_v2_card
, signalled_reboot_callback
,
288 ret
= pcmcia_request_irq(link
, &link
->irq
);
290 if (ret
!= CS_SUCCESS
) {
291 cs_error(link
, RequestIRQ
, ret
);
295 /* Look up current Vcc */
297 ret
= pcmcia_get_configuration_info(link
, &conf
);
299 if (ret
!= CS_SUCCESS
) {
300 cs_error(link
, GetConfigurationInfo
, ret
);
304 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
": Card type %s\n",
305 ipw
->is_v2_card
? "V2/V3" : "V1");
306 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
307 ": I/O ports 0x%04x-0x%04x, irq %d\n",
308 (unsigned int) link
->io
.BasePort1
,
309 (unsigned int) (link
->io
.BasePort1
+
310 link
->io
.NumPorts1
- 1),
311 (unsigned int) link
->irq
.AssignedIRQ
);
312 if (ipw
->attr_memory
&& ipw
->common_memory
)
313 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
314 ": attr memory 0x%08lx-0x%08lx, common memory 0x%08lx-0x%08lx\n",
315 request_attr_memory
.Base
,
316 request_attr_memory
.Base
317 + request_attr_memory
.Size
- 1,
318 request_common_memory
.Base
,
319 request_common_memory
.Base
320 + request_common_memory
.Size
- 1);
322 ipw
->network
= ipwireless_network_create(ipw
->hardware
);
326 ipw
->tty
= ipwireless_tty_create(ipw
->hardware
, ipw
->network
,
331 ipwireless_init_hardware_v2_v3(ipw
->hardware
);
334 * Do the RequestConfiguration last, because it enables interrupts.
335 * Then we don't get any interrupts before we're ready for them.
337 ret
= pcmcia_request_configuration(link
, &link
->conf
);
339 if (ret
!= CS_SUCCESS
) {
340 cs_error(link
, RequestConfiguration
, ret
);
344 link
->dev_node
= &ipw
->nodes
[0];
349 pcmcia_disable_device(link
);
351 if (ipw
->attr_memory
) {
352 iounmap(ipw
->attr_memory
);
353 pcmcia_release_window(ipw
->handle_attr_memory
);
354 pcmcia_disable_device(link
);
357 if (ipw
->common_memory
) {
358 iounmap(ipw
->common_memory
);
359 pcmcia_release_window(ipw
->handle_common_memory
);
362 pcmcia_disable_device(link
);
367 static void release_ipwireless(struct ipw_dev
*ipw
)
369 struct pcmcia_device
*link
= ipw
->link
;
371 pcmcia_disable_device(link
);
373 if (ipw
->common_memory
)
374 iounmap(ipw
->common_memory
);
375 if (ipw
->attr_memory
)
376 iounmap(ipw
->attr_memory
);
377 if (ipw
->common_memory
)
378 pcmcia_release_window(ipw
->handle_common_memory
);
379 if (ipw
->attr_memory
)
380 pcmcia_release_window(ipw
->handle_attr_memory
);
381 pcmcia_disable_device(link
);
385 * ipwireless_attach() creates an "instance" of the driver, allocating
386 * local data structures for one device (one interface). The device
387 * is registered with Card Services.
389 * The pcmcia_device structure is initialized, but we don't actually
390 * configure the card at this point -- we wait until we receive a
391 * card insertion event.
393 static int ipwireless_attach(struct pcmcia_device
*link
)
398 ipw
= kzalloc(sizeof(struct ipw_dev
), GFP_KERNEL
);
404 link
->irq
.Instance
= ipw
;
406 /* Link this device into our device list. */
407 link
->dev_node
= &ipw
->nodes
[0];
409 ipw
->hardware
= ipwireless_hardware_create();
410 if (!ipw
->hardware
) {
414 /* RegisterClient will call config_ipwireless */
416 ret
= config_ipwireless(ipw
);
419 cs_error(link
, RegisterClient
, ret
);
420 ipwireless_detach(link
);
428 * This deletes a driver "instance". The device is de-registered with
429 * Card Services. If it has been released, all local data structures
430 * are freed. Otherwise, the structures will be freed when the device
433 static void ipwireless_detach(struct pcmcia_device
*link
)
435 struct ipw_dev
*ipw
= link
->priv
;
437 release_ipwireless(ipw
);
439 /* Break the link with Card Services */
441 pcmcia_disable_device(link
);
443 if (ipw
->tty
!= NULL
)
444 ipwireless_tty_free(ipw
->tty
);
445 if (ipw
->network
!= NULL
)
446 ipwireless_network_free(ipw
->network
);
447 if (ipw
->hardware
!= NULL
)
448 ipwireless_hardware_free(ipw
->hardware
);
452 static struct pcmcia_driver me
= {
453 .owner
= THIS_MODULE
,
454 .probe
= ipwireless_attach
,
455 .remove
= ipwireless_detach
,
456 .drv
= { .name
= IPWIRELESS_PCCARD_NAME
},
461 * Module insertion : initialisation of the module.
462 * Register the card with cardmgr...
464 static int __init
init_ipwireless(void)
468 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
" "
469 IPWIRELESS_PCMCIA_VERSION
" by " IPWIRELESS_PCMCIA_AUTHOR
"\n");
471 ret
= ipwireless_tty_init();
475 ret
= pcmcia_register_driver(&me
);
477 ipwireless_tty_release();
485 static void __exit
exit_ipwireless(void)
487 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
" "
488 IPWIRELESS_PCMCIA_VERSION
" removed\n");
490 pcmcia_unregister_driver(&me
);
491 ipwireless_tty_release();
494 module_init(init_ipwireless
);
495 module_exit(exit_ipwireless
);
497 MODULE_AUTHOR(IPWIRELESS_PCMCIA_AUTHOR
);
498 MODULE_DESCRIPTION(IPWIRELESS_PCCARD_NAME
" " IPWIRELESS_PCMCIA_VERSION
);
499 MODULE_LICENSE("GPL");