Commit | Line | Data |
---|---|---|
553d6d5f MB |
1 | /* |
2 | * This file is subject to the terms and conditions of the GNU General Public | |
3 | * License. See the file "COPYING" in the main directory of this archive | |
4 | * for more details. | |
5 | * | |
6 | * Copyright (C) 2008 Maxime Bizon <mbizon@freebox.fr> | |
7 | */ | |
8 | ||
9 | #include <linux/kernel.h> | |
10 | #include <linux/module.h> | |
11 | #include <linux/ioport.h> | |
12 | #include <linux/timer.h> | |
13 | #include <linux/platform_device.h> | |
5a0e3ad6 | 14 | #include <linux/slab.h> |
553d6d5f MB |
15 | #include <linux/delay.h> |
16 | #include <linux/pci.h> | |
17 | #include <linux/gpio.h> | |
18 | ||
19 | #include <bcm63xx_regs.h> | |
20 | #include <bcm63xx_io.h> | |
21 | #include "bcm63xx_pcmcia.h" | |
22 | ||
23 | #define PFX "bcm63xx_pcmcia: " | |
24 | ||
25 | #ifdef CONFIG_CARDBUS | |
26 | /* if cardbus is used, platform device needs reference to actual pci | |
27 | * device */ | |
28 | static struct pci_dev *bcm63xx_cb_dev; | |
29 | #endif | |
30 | ||
31 | /* | |
32 | * read/write helper for pcmcia regs | |
33 | */ | |
34 | static inline u32 pcmcia_readl(struct bcm63xx_pcmcia_socket *skt, u32 off) | |
35 | { | |
36 | return bcm_readl(skt->base + off); | |
37 | } | |
38 | ||
39 | static inline void pcmcia_writel(struct bcm63xx_pcmcia_socket *skt, | |
40 | u32 val, u32 off) | |
41 | { | |
42 | bcm_writel(val, skt->base + off); | |
43 | } | |
44 | ||
45 | /* | |
46 | * This callback should (re-)initialise the socket, turn on status | |
47 | * interrupts and PCMCIA bus, and wait for power to stabilise so that | |
48 | * the card status signals report correctly. | |
49 | * | |
50 | * Hardware cannot do that. | |
51 | */ | |
52 | static int bcm63xx_pcmcia_sock_init(struct pcmcia_socket *sock) | |
53 | { | |
54 | return 0; | |
55 | } | |
56 | ||
57 | /* | |
58 | * This callback should remove power on the socket, disable IRQs from | |
59 | * the card, turn off status interrupts, and disable the PCMCIA bus. | |
60 | * | |
61 | * Hardware cannot do that. | |
62 | */ | |
63 | static int bcm63xx_pcmcia_suspend(struct pcmcia_socket *sock) | |
64 | { | |
65 | return 0; | |
66 | } | |
67 | ||
68 | /* | |
69 | * Implements the set_socket() operation for the in-kernel PCMCIA | |
70 | * service (formerly SS_SetSocket in Card Services). We more or | |
71 | * less punt all of this work and let the kernel handle the details | |
72 | * of power configuration, reset, &c. We also record the value of | |
73 | * `state' in order to regurgitate it to the PCMCIA core later. | |
74 | */ | |
75 | static int bcm63xx_pcmcia_set_socket(struct pcmcia_socket *sock, | |
76 | socket_state_t *state) | |
77 | { | |
78 | struct bcm63xx_pcmcia_socket *skt; | |
79 | unsigned long flags; | |
80 | u32 val; | |
81 | ||
82 | skt = sock->driver_data; | |
83 | ||
84 | spin_lock_irqsave(&skt->lock, flags); | |
85 | ||
86 | /* note: hardware cannot control socket power, so we will | |
87 | * always report SS_POWERON */ | |
88 | ||
89 | /* apply socket reset */ | |
90 | val = pcmcia_readl(skt, PCMCIA_C1_REG); | |
91 | if (state->flags & SS_RESET) | |
92 | val |= PCMCIA_C1_RESET_MASK; | |
93 | else | |
94 | val &= ~PCMCIA_C1_RESET_MASK; | |
95 | ||
96 | /* reverse reset logic for cardbus card */ | |
97 | if (skt->card_detected && (skt->card_type & CARD_CARDBUS)) | |
98 | val ^= PCMCIA_C1_RESET_MASK; | |
99 | ||
100 | pcmcia_writel(skt, val, PCMCIA_C1_REG); | |
101 | ||
102 | /* keep requested state for event reporting */ | |
103 | skt->requested_state = *state; | |
104 | ||
105 | spin_unlock_irqrestore(&skt->lock, flags); | |
106 | ||
107 | return 0; | |
108 | } | |
109 | ||
110 | /* | |
111 | * identity cardtype from VS[12] input, CD[12] input while only VS2 is | |
112 | * floating, and CD[12] input while only VS1 is floating | |
113 | */ | |
114 | enum { | |
115 | IN_VS1 = (1 << 0), | |
116 | IN_VS2 = (1 << 1), | |
117 | IN_CD1_VS2H = (1 << 2), | |
118 | IN_CD2_VS2H = (1 << 3), | |
119 | IN_CD1_VS1H = (1 << 4), | |
120 | IN_CD2_VS1H = (1 << 5), | |
121 | }; | |
122 | ||
123 | static const u8 vscd_to_cardtype[] = { | |
124 | ||
125 | /* VS1 float, VS2 float */ | |
126 | [IN_VS1 | IN_VS2] = (CARD_PCCARD | CARD_5V), | |
127 | ||
128 | /* VS1 grounded, VS2 float */ | |
129 | [IN_VS2] = (CARD_PCCARD | CARD_5V | CARD_3V), | |
130 | ||
131 | /* VS1 grounded, VS2 grounded */ | |
132 | [0] = (CARD_PCCARD | CARD_5V | CARD_3V | CARD_XV), | |
133 | ||
134 | /* VS1 tied to CD1, VS2 float */ | |
135 | [IN_VS1 | IN_VS2 | IN_CD1_VS1H] = (CARD_CARDBUS | CARD_3V), | |
136 | ||
137 | /* VS1 grounded, VS2 tied to CD2 */ | |
138 | [IN_VS2 | IN_CD2_VS2H] = (CARD_CARDBUS | CARD_3V | CARD_XV), | |
139 | ||
140 | /* VS1 tied to CD2, VS2 grounded */ | |
141 | [IN_VS1 | IN_CD2_VS1H] = (CARD_CARDBUS | CARD_3V | CARD_XV | CARD_YV), | |
142 | ||
143 | /* VS1 float, VS2 grounded */ | |
144 | [IN_VS1] = (CARD_PCCARD | CARD_XV), | |
145 | ||
146 | /* VS1 float, VS2 tied to CD2 */ | |
147 | [IN_VS1 | IN_VS2 | IN_CD2_VS2H] = (CARD_CARDBUS | CARD_3V), | |
148 | ||
149 | /* VS1 float, VS2 tied to CD1 */ | |
150 | [IN_VS1 | IN_VS2 | IN_CD1_VS2H] = (CARD_CARDBUS | CARD_XV | CARD_YV), | |
151 | ||
152 | /* VS1 tied to CD2, VS2 float */ | |
153 | [IN_VS1 | IN_VS2 | IN_CD2_VS1H] = (CARD_CARDBUS | CARD_YV), | |
154 | ||
155 | /* VS2 grounded, VS1 is tied to CD1, CD2 is grounded */ | |
156 | [IN_VS1 | IN_CD1_VS1H] = 0, /* ignore cardbay */ | |
157 | }; | |
158 | ||
159 | /* | |
160 | * poll hardware to check card insertion status | |
161 | */ | |
162 | static unsigned int __get_socket_status(struct bcm63xx_pcmcia_socket *skt) | |
163 | { | |
164 | unsigned int stat; | |
165 | u32 val; | |
166 | ||
167 | stat = 0; | |
168 | ||
169 | /* check CD for card presence */ | |
170 | val = pcmcia_readl(skt, PCMCIA_C1_REG); | |
171 | ||
172 | if (!(val & PCMCIA_C1_CD1_MASK) && !(val & PCMCIA_C1_CD2_MASK)) | |
173 | stat |= SS_DETECT; | |
174 | ||
175 | /* if new insertion, detect cardtype */ | |
176 | if ((stat & SS_DETECT) && !skt->card_detected) { | |
177 | unsigned int stat = 0; | |
178 | ||
179 | /* float VS1, float VS2 */ | |
180 | val |= PCMCIA_C1_VS1OE_MASK; | |
181 | val |= PCMCIA_C1_VS2OE_MASK; | |
182 | pcmcia_writel(skt, val, PCMCIA_C1_REG); | |
183 | ||
184 | /* wait for output to stabilize and read VS[12] */ | |
185 | udelay(10); | |
186 | val = pcmcia_readl(skt, PCMCIA_C1_REG); | |
187 | stat |= (val & PCMCIA_C1_VS1_MASK) ? IN_VS1 : 0; | |
188 | stat |= (val & PCMCIA_C1_VS2_MASK) ? IN_VS2 : 0; | |
189 | ||
190 | /* drive VS1 low, float VS2 */ | |
191 | val &= ~PCMCIA_C1_VS1OE_MASK; | |
192 | val |= PCMCIA_C1_VS2OE_MASK; | |
193 | pcmcia_writel(skt, val, PCMCIA_C1_REG); | |
194 | ||
195 | /* wait for output to stabilize and read CD[12] */ | |
196 | udelay(10); | |
197 | val = pcmcia_readl(skt, PCMCIA_C1_REG); | |
198 | stat |= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS2H : 0; | |
199 | stat |= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS2H : 0; | |
200 | ||
201 | /* float VS1, drive VS2 low */ | |
202 | val |= PCMCIA_C1_VS1OE_MASK; | |
203 | val &= ~PCMCIA_C1_VS2OE_MASK; | |
204 | pcmcia_writel(skt, val, PCMCIA_C1_REG); | |
205 | ||
206 | /* wait for output to stabilize and read CD[12] */ | |
207 | udelay(10); | |
208 | val = pcmcia_readl(skt, PCMCIA_C1_REG); | |
209 | stat |= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS1H : 0; | |
210 | stat |= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS1H : 0; | |
211 | ||
212 | /* guess cardtype from all this */ | |
213 | skt->card_type = vscd_to_cardtype[stat]; | |
214 | if (!skt->card_type) | |
215 | dev_err(&skt->socket.dev, "unsupported card type\n"); | |
216 | ||
217 | /* drive both VS pin to 0 again */ | |
218 | val &= ~(PCMCIA_C1_VS1OE_MASK | PCMCIA_C1_VS2OE_MASK); | |
219 | ||
220 | /* enable correct logic */ | |
221 | val &= ~(PCMCIA_C1_EN_PCMCIA_MASK | PCMCIA_C1_EN_CARDBUS_MASK); | |
222 | if (skt->card_type & CARD_PCCARD) | |
223 | val |= PCMCIA_C1_EN_PCMCIA_MASK; | |
224 | else | |
225 | val |= PCMCIA_C1_EN_CARDBUS_MASK; | |
226 | ||
227 | pcmcia_writel(skt, val, PCMCIA_C1_REG); | |
228 | } | |
229 | skt->card_detected = (stat & SS_DETECT) ? 1 : 0; | |
230 | ||
231 | /* report card type/voltage */ | |
232 | if (skt->card_type & CARD_CARDBUS) | |
233 | stat |= SS_CARDBUS; | |
234 | if (skt->card_type & CARD_3V) | |
235 | stat |= SS_3VCARD; | |
236 | if (skt->card_type & CARD_XV) | |
237 | stat |= SS_XVCARD; | |
238 | stat |= SS_POWERON; | |
239 | ||
240 | if (gpio_get_value(skt->pd->ready_gpio)) | |
241 | stat |= SS_READY; | |
242 | ||
243 | return stat; | |
244 | } | |
245 | ||
246 | /* | |
247 | * core request to get current socket status | |
248 | */ | |
249 | static int bcm63xx_pcmcia_get_status(struct pcmcia_socket *sock, | |
250 | unsigned int *status) | |
251 | { | |
252 | struct bcm63xx_pcmcia_socket *skt; | |
253 | ||
254 | skt = sock->driver_data; | |
255 | ||
256 | spin_lock_bh(&skt->lock); | |
257 | *status = __get_socket_status(skt); | |
258 | spin_unlock_bh(&skt->lock); | |
259 | ||
260 | return 0; | |
261 | } | |
262 | ||
263 | /* | |
264 | * socket polling timer callback | |
265 | */ | |
266 | static void bcm63xx_pcmcia_poll(unsigned long data) | |
267 | { | |
268 | struct bcm63xx_pcmcia_socket *skt; | |
269 | unsigned int stat, events; | |
270 | ||
271 | skt = (struct bcm63xx_pcmcia_socket *)data; | |
272 | ||
273 | spin_lock_bh(&skt->lock); | |
274 | ||
275 | stat = __get_socket_status(skt); | |
276 | ||
277 | /* keep only changed bits, and mask with required one from the | |
278 | * core */ | |
279 | events = (stat ^ skt->old_status) & skt->requested_state.csc_mask; | |
280 | skt->old_status = stat; | |
281 | spin_unlock_bh(&skt->lock); | |
282 | ||
283 | if (events) | |
284 | pcmcia_parse_events(&skt->socket, events); | |
285 | ||
286 | mod_timer(&skt->timer, | |
287 | jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE)); | |
288 | } | |
289 | ||
290 | static int bcm63xx_pcmcia_set_io_map(struct pcmcia_socket *sock, | |
291 | struct pccard_io_map *map) | |
292 | { | |
293 | /* this doesn't seem to be called by pcmcia layer if static | |
294 | * mapping is used */ | |
295 | return 0; | |
296 | } | |
297 | ||
298 | static int bcm63xx_pcmcia_set_mem_map(struct pcmcia_socket *sock, | |
299 | struct pccard_mem_map *map) | |
300 | { | |
301 | struct bcm63xx_pcmcia_socket *skt; | |
302 | struct resource *res; | |
303 | ||
304 | skt = sock->driver_data; | |
305 | if (map->flags & MAP_ATTRIB) | |
306 | res = skt->attr_res; | |
307 | else | |
308 | res = skt->common_res; | |
309 | ||
310 | map->static_start = res->start + map->card_start; | |
311 | return 0; | |
312 | } | |
313 | ||
314 | static struct pccard_operations bcm63xx_pcmcia_operations = { | |
315 | .init = bcm63xx_pcmcia_sock_init, | |
316 | .suspend = bcm63xx_pcmcia_suspend, | |
317 | .get_status = bcm63xx_pcmcia_get_status, | |
318 | .set_socket = bcm63xx_pcmcia_set_socket, | |
319 | .set_io_map = bcm63xx_pcmcia_set_io_map, | |
320 | .set_mem_map = bcm63xx_pcmcia_set_mem_map, | |
321 | }; | |
322 | ||
323 | /* | |
324 | * register pcmcia socket to core | |
325 | */ | |
34cdf25a | 326 | static int bcm63xx_drv_pcmcia_probe(struct platform_device *pdev) |
553d6d5f MB |
327 | { |
328 | struct bcm63xx_pcmcia_socket *skt; | |
329 | struct pcmcia_socket *sock; | |
330 | struct resource *res, *irq_res; | |
331 | unsigned int regmem_size = 0, iomem_size = 0; | |
332 | u32 val; | |
333 | int ret; | |
334 | ||
335 | skt = kzalloc(sizeof(*skt), GFP_KERNEL); | |
336 | if (!skt) | |
337 | return -ENOMEM; | |
338 | spin_lock_init(&skt->lock); | |
339 | sock = &skt->socket; | |
340 | sock->driver_data = skt; | |
341 | ||
342 | /* make sure we have all resources we need */ | |
343 | skt->common_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); | |
344 | skt->attr_res = platform_get_resource(pdev, IORESOURCE_MEM, 2); | |
345 | irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); | |
346 | skt->pd = pdev->dev.platform_data; | |
347 | if (!skt->common_res || !skt->attr_res || !irq_res || !skt->pd) { | |
348 | ret = -EINVAL; | |
349 | goto err; | |
350 | } | |
351 | ||
352 | /* remap pcmcia registers */ | |
353 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
354 | regmem_size = resource_size(res); | |
355 | if (!request_mem_region(res->start, regmem_size, "bcm63xx_pcmcia")) { | |
356 | ret = -EINVAL; | |
357 | goto err; | |
358 | } | |
359 | skt->reg_res = res; | |
360 | ||
361 | skt->base = ioremap(res->start, regmem_size); | |
362 | if (!skt->base) { | |
363 | ret = -ENOMEM; | |
364 | goto err; | |
365 | } | |
366 | ||
367 | /* remap io registers */ | |
368 | res = platform_get_resource(pdev, IORESOURCE_MEM, 3); | |
369 | iomem_size = resource_size(res); | |
370 | skt->io_base = ioremap(res->start, iomem_size); | |
371 | if (!skt->io_base) { | |
372 | ret = -ENOMEM; | |
373 | goto err; | |
374 | } | |
375 | ||
376 | /* resources are static */ | |
377 | sock->resource_ops = &pccard_static_ops; | |
378 | sock->ops = &bcm63xx_pcmcia_operations; | |
379 | sock->owner = THIS_MODULE; | |
380 | sock->dev.parent = &pdev->dev; | |
381 | sock->features = SS_CAP_STATIC_MAP | SS_CAP_PCCARD; | |
382 | sock->io_offset = (unsigned long)skt->io_base; | |
383 | sock->pci_irq = irq_res->start; | |
384 | ||
385 | #ifdef CONFIG_CARDBUS | |
386 | sock->cb_dev = bcm63xx_cb_dev; | |
387 | if (bcm63xx_cb_dev) | |
388 | sock->features |= SS_CAP_CARDBUS; | |
389 | #endif | |
390 | ||
391 | /* assume common & attribute memory have the same size */ | |
392 | sock->map_size = resource_size(skt->common_res); | |
393 | ||
394 | /* initialize polling timer */ | |
395 | setup_timer(&skt->timer, bcm63xx_pcmcia_poll, (unsigned long)skt); | |
396 | ||
397 | /* initialize pcmcia control register, drive VS[12] to 0, | |
398 | * leave CB IDSEL to the old value since it is set by the PCI | |
399 | * layer */ | |
400 | val = pcmcia_readl(skt, PCMCIA_C1_REG); | |
401 | val &= PCMCIA_C1_CBIDSEL_MASK; | |
402 | val |= PCMCIA_C1_EN_PCMCIA_GPIO_MASK; | |
403 | pcmcia_writel(skt, val, PCMCIA_C1_REG); | |
404 | ||
405 | /* | |
406 | * Hardware has only one set of timings registers, not one for | |
407 | * each memory access type, so we configure them for the | |
408 | * slowest one: attribute memory. | |
409 | */ | |
410 | val = PCMCIA_C2_DATA16_MASK; | |
411 | val |= 10 << PCMCIA_C2_RWCOUNT_SHIFT; | |
412 | val |= 6 << PCMCIA_C2_INACTIVE_SHIFT; | |
413 | val |= 3 << PCMCIA_C2_SETUP_SHIFT; | |
414 | val |= 3 << PCMCIA_C2_HOLD_SHIFT; | |
415 | pcmcia_writel(skt, val, PCMCIA_C2_REG); | |
416 | ||
417 | ret = pcmcia_register_socket(sock); | |
418 | if (ret) | |
419 | goto err; | |
420 | ||
421 | /* start polling socket */ | |
422 | mod_timer(&skt->timer, | |
423 | jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE)); | |
424 | ||
425 | platform_set_drvdata(pdev, skt); | |
426 | return 0; | |
427 | ||
428 | err: | |
429 | if (skt->io_base) | |
430 | iounmap(skt->io_base); | |
431 | if (skt->base) | |
432 | iounmap(skt->base); | |
433 | if (skt->reg_res) | |
434 | release_mem_region(skt->reg_res->start, regmem_size); | |
435 | kfree(skt); | |
436 | return ret; | |
437 | } | |
438 | ||
e765a02c | 439 | static int bcm63xx_drv_pcmcia_remove(struct platform_device *pdev) |
553d6d5f MB |
440 | { |
441 | struct bcm63xx_pcmcia_socket *skt; | |
442 | struct resource *res; | |
443 | ||
444 | skt = platform_get_drvdata(pdev); | |
445 | del_timer_sync(&skt->timer); | |
446 | iounmap(skt->base); | |
447 | iounmap(skt->io_base); | |
448 | res = skt->reg_res; | |
449 | release_mem_region(res->start, resource_size(res)); | |
450 | kfree(skt); | |
451 | return 0; | |
452 | } | |
453 | ||
454 | struct platform_driver bcm63xx_pcmcia_driver = { | |
455 | .probe = bcm63xx_drv_pcmcia_probe, | |
96364e3a | 456 | .remove = bcm63xx_drv_pcmcia_remove, |
553d6d5f MB |
457 | .driver = { |
458 | .name = "bcm63xx_pcmcia", | |
459 | .owner = THIS_MODULE, | |
460 | }, | |
461 | }; | |
462 | ||
463 | #ifdef CONFIG_CARDBUS | |
34cdf25a | 464 | static int bcm63xx_cb_probe(struct pci_dev *dev, |
553d6d5f MB |
465 | const struct pci_device_id *id) |
466 | { | |
467 | /* keep pci device */ | |
468 | bcm63xx_cb_dev = dev; | |
469 | return platform_driver_register(&bcm63xx_pcmcia_driver); | |
470 | } | |
471 | ||
e765a02c | 472 | static void bcm63xx_cb_exit(struct pci_dev *dev) |
553d6d5f MB |
473 | { |
474 | platform_driver_unregister(&bcm63xx_pcmcia_driver); | |
475 | bcm63xx_cb_dev = NULL; | |
476 | } | |
477 | ||
0178a7a5 | 478 | static const struct pci_device_id bcm63xx_cb_table[] = { |
553d6d5f MB |
479 | { |
480 | .vendor = PCI_VENDOR_ID_BROADCOM, | |
481 | .device = BCM6348_CPU_ID, | |
482 | .subvendor = PCI_VENDOR_ID_BROADCOM, | |
483 | .subdevice = PCI_ANY_ID, | |
484 | .class = PCI_CLASS_BRIDGE_CARDBUS << 8, | |
485 | .class_mask = ~0, | |
486 | }, | |
487 | ||
488 | { | |
489 | .vendor = PCI_VENDOR_ID_BROADCOM, | |
490 | .device = BCM6358_CPU_ID, | |
491 | .subvendor = PCI_VENDOR_ID_BROADCOM, | |
492 | .subdevice = PCI_ANY_ID, | |
493 | .class = PCI_CLASS_BRIDGE_CARDBUS << 8, | |
494 | .class_mask = ~0, | |
495 | }, | |
496 | ||
497 | { }, | |
498 | }; | |
499 | ||
500 | MODULE_DEVICE_TABLE(pci, bcm63xx_cb_table); | |
501 | ||
502 | static struct pci_driver bcm63xx_cardbus_driver = { | |
503 | .name = "bcm63xx_cardbus", | |
504 | .id_table = bcm63xx_cb_table, | |
505 | .probe = bcm63xx_cb_probe, | |
96364e3a | 506 | .remove = bcm63xx_cb_exit, |
553d6d5f MB |
507 | }; |
508 | #endif | |
509 | ||
510 | /* | |
511 | * if cardbus support is enabled, register our platform device after | |
512 | * our fake cardbus bridge has been registered | |
513 | */ | |
514 | static int __init bcm63xx_pcmcia_init(void) | |
515 | { | |
516 | #ifdef CONFIG_CARDBUS | |
517 | return pci_register_driver(&bcm63xx_cardbus_driver); | |
518 | #else | |
519 | return platform_driver_register(&bcm63xx_pcmcia_driver); | |
520 | #endif | |
521 | } | |
522 | ||
523 | static void __exit bcm63xx_pcmcia_exit(void) | |
524 | { | |
525 | #ifdef CONFIG_CARDBUS | |
526 | return pci_unregister_driver(&bcm63xx_cardbus_driver); | |
527 | #else | |
528 | platform_driver_unregister(&bcm63xx_pcmcia_driver); | |
529 | #endif | |
530 | } | |
531 | ||
532 | module_init(bcm63xx_pcmcia_init); | |
533 | module_exit(bcm63xx_pcmcia_exit); | |
534 | ||
535 | MODULE_LICENSE("GPL"); | |
536 | MODULE_AUTHOR("Maxime Bizon <mbizon@freebox.fr>"); | |
537 | MODULE_DESCRIPTION("Linux PCMCIA Card Services: bcm63xx Socket Controller"); |