889ab4d435589f3fb7903bd917c45405583f1aa1
[dragonfly.git] / sys / bus / pccard / pccard.c
1 /*
2  *      pccard.c - Interface code for PC-CARD controllers.
3  *
4  *      June 1995, Andrew McRae (andrew@mega.com.au)
5  *-------------------------------------------------------------------------
6  *
7  * Copyright (c) 2001 M. Warner Losh.  All rights reserved.
8  * Copyright (c) 1995 Andrew McRae.  All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. The name of the author may not be used to endorse or promote products
19  *    derived from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  *
32  * $FreeBSD: src/sys/pccard/pccard.c,v 1.106.2.15 2003/02/26 18:42:00 imp Exp $
33  * $DragonFly: src/sys/bus/pccard/pccard.c,v 1.7 2003/08/07 21:16:46 dillon Exp $
34  */
35
36 #include <sys/param.h>
37 #include <sys/types.h>
38 #include <sys/systm.h>
39 #include <sys/kernel.h>
40 #include <sys/malloc.h>
41 #include <sys/sysctl.h>
42 #include <sys/conf.h>
43 #include <sys/uio.h>
44 #include <sys/poll.h>
45 #include <sys/bus.h>
46 #include <sys/proc.h>
47 #include <machine/bus.h>
48
49 #include "cardinfo.h"
50 #include "driver.h"
51 #include "slot.h"
52 #include "pccard_nbk.h"
53
54 #include <machine/md_var.h>
55
56 static int              allocate_driver(struct slot *, struct dev_desc *);
57 static void             inserted(void *);
58 static void             disable_slot(struct slot *);
59 static void             disable_slot_to(struct slot *);
60 static void             power_off_slot(void *);
61
62 /*
63  *      The driver interface for read/write uses a block
64  *      of memory in the ISA I/O memory space allocated via
65  *      an ioctl setting.
66  *
67  *      Now that we have different bus attachments, we should really
68  *      use a better algorythm to allocate memory.
69  */
70 static unsigned long pccard_mem;        /* Physical memory */
71 static unsigned char *pccard_kmem;      /* Kernel virtual address */
72 static struct resource *pccard_mem_res;
73 static int pccard_mem_rid;
74
75 static  d_open_t        crdopen;
76 static  d_close_t       crdclose;
77 static  d_read_t        crdread;
78 static  d_write_t       crdwrite;
79 static  d_ioctl_t       crdioctl;
80 static  d_poll_t        crdpoll;
81
82 #define CDEV_MAJOR 50
83 static struct cdevsw crd_cdevsw = {
84         /* name */      "crd",
85         /* maj */       CDEV_MAJOR,
86         /* flags */     0,
87         /* port */      NULL,
88         /* autoq */     0,
89
90         /* open */      crdopen,
91         /* close */     crdclose,
92         /* read */      crdread,
93         /* write */     crdwrite,
94         /* ioctl */     crdioctl,
95         /* poll */      crdpoll,
96         /* mmap */      nommap,
97         /* strategy */  nostrategy,
98         /* dump */      nodump,
99         /* psize */     nopsize
100 };
101
102 /*
103  *      Power off the slot.
104  *      (doing it immediately makes the removal of some cards unstable)
105  */
106 static void
107 power_off_slot(void *arg)
108 {
109         struct slot *slt = (struct slot *)arg;
110         int s;
111
112         /*
113          * The following will generate an interrupt.  So, to hold off
114          * the interrupt unitl after disable runs so that we can get rid
115          * rid of the interrupt before it becomes unsafe to touch the
116          * device.
117          *
118          * XXX In current, the spl stuff is a nop.
119          */
120         s = splhigh();
121         /* Power off the slot. */
122         slt->pwr_off_pending = 0;
123         slt->ctrl->disable(slt);
124         splx(s);
125 }
126
127 /*
128  *      disable_slot - Disables the slot by removing
129  *      the power and unmapping the I/O
130  */
131 static void
132 disable_slot(struct slot *slt)
133 {
134         device_t pccarddev;
135         device_t *kids;
136         int nkids;
137         int i;
138         int ret;
139
140         /*
141          * Note that a race condition is possible here; if a
142          * driver is accessing the device and it is removed, then
143          * all bets are off...
144          */
145         pccarddev = slt->dev;
146         device_get_children(pccarddev, &kids, &nkids);
147         for (i = 0; i < nkids; i++) {
148                 if ((ret = device_delete_child(pccarddev, kids[i])) != 0)
149                         printf("pccard: delete of %s failed: %d\n",
150                                 device_get_nameunit(kids[i]), ret);
151         }
152         free(kids, M_TEMP);
153
154         /* Power off the slot 1/2 second after removal of the card */
155         slt->poff_ch = timeout(power_off_slot, (caddr_t)slt, hz / 2);
156         slt->pwr_off_pending = 1;
157 }
158
159 static void
160 disable_slot_to(struct slot *slt)
161 {
162         disable_slot(slt);
163         if (slt->state == empty)
164                 printf("pccard: card removed, slot %d\n", slt->slotnum);
165         else
166                 printf("pccard: card deactivated, slot %d\n", slt->slotnum);
167         pccard_remove_beep();
168         selwakeup(&slt->selp);
169 }
170
171 /*
172  *      pccard_init_slot - Initialize the slot controller and attach various
173  * things to it.  We also make the device for it.  We create the device that
174  * will be exported to devfs.
175  */
176 struct slot *
177 pccard_init_slot(device_t dev, struct slot_ctrl *ctrl)
178 {
179         int             slotno;
180         struct slot     *slt;
181
182         slt = PCCARD_DEVICE2SOFTC(dev);
183         slotno = device_get_unit(dev);
184         slt->dev = dev;
185         slt->d = make_dev(&crd_cdevsw, slotno, 0, 0, 0600, "card%d", slotno);
186         slt->d->si_drv1 = slt;
187         slt->ctrl = ctrl;
188         slt->slotnum = slotno;
189         callout_handle_init(&slt->insert_ch);
190         callout_handle_init(&slt->poff_ch);
191
192         return (slt);
193 }
194
195 /*
196  *      allocate_driver - Create a new device entry for this
197  *      slot, and attach a driver to it.
198  */
199 static int
200 allocate_driver(struct slot *slt, struct dev_desc *desc)
201 {
202         struct pccard_devinfo *devi;
203         device_t pccarddev;
204         int err, irq = 0;
205         device_t child;
206         device_t *devs;
207         int count;
208
209         pccarddev = slt->dev;
210         err = device_get_children(pccarddev, &devs, &count);
211         if (err != 0)
212                 return (err);
213         free(devs, M_TEMP);
214         if (count) {
215                 device_printf(pccarddev,
216                     "Can not attach more than one child.\n");
217                 return (EIO);
218         }
219         irq = ffs(desc->irqmask) - 1;
220         MALLOC(devi, struct pccard_devinfo *, sizeof(*devi), M_DEVBUF,
221             M_WAITOK | M_ZERO);
222         strcpy(devi->name, desc->name);
223         /*
224          *      Create an entry for the device under this slot.
225          */
226         devi->running = 1;
227         devi->slt = slt;
228         bcopy(desc->misc, devi->misc, sizeof(desc->misc));
229         strcpy(devi->manufstr, desc->manufstr);
230         strcpy(devi->versstr, desc->versstr);
231         devi->manufacturer = desc->manufacturer;
232         devi->product = desc->product;
233         devi->prodext = desc->prodext;
234         resource_list_init(&devi->resources);
235         child = device_add_child(pccarddev, devi->name, desc->unit);
236         if (child == NULL) {
237                 if (desc->unit != -1)
238                         device_printf(pccarddev,
239                             "Unit %d failed for %s, try a different unit\n",
240                             desc->unit, devi->name);
241                 else
242                         device_printf(pccarddev,
243                             "No units available for %s.  Impossible?\n",
244                             devi->name);
245                 return (EIO);
246         }
247         device_set_flags(child, desc->flags);
248         device_set_ivars(child, devi);
249         if (bootverbose) {
250                 device_printf(pccarddev, "Assigning %s:",
251                     device_get_nameunit(child));
252                 if (desc->iobase)
253                         printf(" io 0x%x-0x%x",
254                             desc->iobase, desc->iobase + desc->iosize - 1);
255                 if (irq)
256                         printf(" irq %d", irq);
257                 if (desc->mem)
258                         printf(" mem 0x%lx-0x%lx", desc->mem,
259                             desc->mem + desc->memsize - 1);
260                 printf(" flags 0x%x\n", desc->flags);
261         }
262         err = bus_set_resource(child, SYS_RES_IOPORT, 0, desc->iobase,
263             desc->iosize);
264         if (err)
265                 goto err;
266         if (irq)
267                 err = bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1);
268         if (err)
269                 goto err;
270         if (desc->memsize) {
271                 err = bus_set_resource(child, SYS_RES_MEMORY, 0, desc->mem,
272                     desc->memsize);
273                 if (err)
274                         goto err;
275         }
276         err = device_probe_and_attach(child);
277         /*
278          * XXX We unwisely assume that the detach code won't run while the
279          * XXX the attach code is attaching.  Someone should put some
280          * XXX interlock code.  This can happen if probe/attach takes a while
281          * XXX and the user ejects the card, which causes the detach
282          * XXX function to be called.
283          */
284         strncpy(desc->name, device_get_nameunit(child), sizeof(desc->name));
285         desc->name[sizeof(desc->name) - 1] = '\0';
286 err:
287         if (err)
288                 device_delete_child(pccarddev, child);
289         return (err);
290 }
291
292 /*
293  *      card insert routine - Called from a timeout to debounce
294  *      insertion events.
295  */
296 static void
297 inserted(void *arg)
298 {
299         struct slot *slt = arg;
300
301         slt->state = filled;
302         /*
303          * Disable any pending timeouts for this slot, and explicitly
304          * power it off right now.  Then, re-enable the power using
305          * the (possibly new) power settings.
306          */
307         untimeout(power_off_slot, (caddr_t)slt, slt->poff_ch);
308         power_off_slot(slt);
309
310         /*
311          *      Enable 5V to the card so that the CIS can be read.  Well,
312          * enable the most natural voltage so that the CIS can be read.
313          */
314         slt->pwr.vcc = -1;
315         slt->pwr.vpp = -1;
316         slt->ctrl->power(slt);
317
318         printf("pccard: card inserted, slot %d\n", slt->slotnum);
319         pccard_insert_beep();
320         slt->ctrl->reset(slt);
321 }
322
323 /*
324  *      Card event callback. Called at splhigh to prevent
325  *      device interrupts from interceding.
326  */
327 void
328 pccard_event(struct slot *slt, enum card_event event)
329 {
330         if (slt->insert_seq) {
331                 slt->insert_seq = 0;
332                 untimeout(inserted, (void *)slt, slt->insert_ch);
333         }
334
335         switch(event) {
336         case card_removed:
337         case card_deactivated:
338                 if (slt->state == filled || slt->state == inactive) {
339                         if (event == card_removed)
340                                 slt->state = empty;
341                         else
342                                 slt->state = inactive;
343                         disable_slot_to(slt);
344                 }
345                 break;
346         case card_inserted:
347                 slt->insert_seq = 1;
348                 slt->insert_ch = timeout(inserted, (void *)slt, hz/4);
349                 break;
350         }
351 }
352
353 /*
354  *      Device driver interface.
355  */
356 static  int
357 crdopen(dev_t dev, int oflags, int devtype, d_thread_t *td)
358 {
359         struct slot *slt = PCCARD_DEV2SOFTC(dev);
360
361         if (slt == NULL)
362                 return (ENXIO);
363         if (slt->rwmem == 0)
364                 slt->rwmem = MDF_ATTR;
365         return (0);
366 }
367
368 /*
369  *      Close doesn't de-allocate any resources, since
370  *      slots may be assigned to drivers already.
371  */
372 static  int
373 crdclose(dev_t dev, int fflag, int devtype, d_thread_t *td)
374 {
375         return (0);
376 }
377
378 /*
379  *      read interface. Map memory at lseek offset,
380  *      then transfer to user space.
381  */
382 static  int
383 crdread(dev_t dev, struct uio *uio, int ioflag)
384 {
385         struct slot *slt = PCCARD_DEV2SOFTC(dev);
386         struct mem_desc *mp, oldmap;
387         unsigned char *p;
388         unsigned int offs;
389         int error = 0, win, count;
390
391         if (slt == 0 || slt->state != filled)
392                 return (ENXIO);
393         if (pccard_mem == 0)
394                 return (ENOMEM);
395         for (win = slt->ctrl->maxmem - 1; win >= 0; win--)
396                 if ((slt->mem[win].flags & MDF_ACTIVE) == 0)
397                         break;
398         if (win < 0)
399                 return (EBUSY);
400         mp = &slt->mem[win];
401         oldmap = *mp;
402         mp->flags = slt->rwmem | MDF_ACTIVE;
403         while (uio->uio_resid && error == 0) {
404                 mp->card = uio->uio_offset;
405                 mp->size = PCCARD_MEMSIZE;
406                 mp->start = (caddr_t)(void *)(uintptr_t)pccard_mem;
407                 if ((error = slt->ctrl->mapmem(slt, win)) != 0)
408                         break;
409                 offs = (unsigned int)uio->uio_offset & (PCCARD_MEMSIZE - 1);
410                 p = pccard_kmem + offs;
411                 count = MIN(PCCARD_MEMSIZE - offs, uio->uio_resid);
412                 error = uiomove(p, count, uio);
413         }
414         /*
415          *      Restore original map.
416          */
417         *mp = oldmap;
418         slt->ctrl->mapmem(slt, win);
419
420         return (error);
421 }
422
423 /*
424  *      crdwrite - Write data to card memory.
425  *      Handles wrap around so that only one memory
426  *      window is used.
427  */
428 static  int
429 crdwrite(dev_t dev, struct uio *uio, int ioflag)
430 {
431         struct slot *slt = PCCARD_DEV2SOFTC(dev);
432         struct mem_desc *mp, oldmap;
433         unsigned char *p;
434         unsigned int offs;
435         int error = 0, win, count;
436
437         if (slt == 0 || slt->state != filled)
438                 return (ENXIO);
439         if (pccard_mem == 0)
440                 return (ENOMEM);
441         for (win = slt->ctrl->maxmem - 1; win >= 0; win--)
442                 if ((slt->mem[win].flags & MDF_ACTIVE) == 0)
443                         break;
444         if (win < 0)
445                 return (EBUSY);
446         mp = &slt->mem[win];
447         oldmap = *mp;
448         mp->flags = slt->rwmem | MDF_ACTIVE;
449         while (uio->uio_resid && error == 0) {
450                 mp->card = uio->uio_offset;
451                 mp->size = PCCARD_MEMSIZE;
452                 mp->start = (caddr_t)(void *)(uintptr_t)pccard_mem;
453                 if ((error = slt->ctrl->mapmem(slt, win)) != 0)
454                         break;
455                 offs = (unsigned int)uio->uio_offset & (PCCARD_MEMSIZE - 1);
456                 p = pccard_kmem + offs;
457                 count = MIN(PCCARD_MEMSIZE - offs, uio->uio_resid);
458                 error = uiomove(p, count, uio);
459         }
460         /*
461          *      Restore original map.
462          */
463         *mp = oldmap;
464         slt->ctrl->mapmem(slt, win);
465
466         return (error);
467 }
468
469 /*
470  *      ioctl calls - allows setting/getting of memory and I/O
471  *      descriptors, and assignment of drivers.
472  */
473 static  int
474 crdioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, d_thread_t *td)
475 {
476         u_int32_t       addr;
477         int             err;
478         struct io_desc  *ip;
479         struct mem_desc *mp;
480         device_t        pccarddev;
481         int             pwval;
482         int             s;
483         struct slot     *slt = PCCARD_DEV2SOFTC(dev);
484
485         if (slt == 0 && cmd != PIOCRWMEM)
486                 return (ENXIO);
487
488         KKASSERT(td->td_proc != NULL);
489
490         switch(cmd) {
491         default:
492                 if (slt->ctrl->ioctl)
493                         return (slt->ctrl->ioctl(slt, cmd, data));
494                 return (ENOTTY);
495         /*
496          * Get slot state.
497          */
498         case PIOCGSTATE:
499                 s = splhigh();
500                 ((struct slotstate *)data)->state = slt->state;
501                 ((struct slotstate *)data)->laststate = slt->laststate;
502                 slt->laststate = slt->state;
503                 splx(s);
504                 ((struct slotstate *)data)->maxmem = slt->ctrl->maxmem;
505                 ((struct slotstate *)data)->maxio = slt->ctrl->maxio;
506                 ((struct slotstate *)data)->irqs = 0;
507                 break;
508         /*
509          * Get memory context.
510          */
511         case PIOCGMEM:
512                 s = ((struct mem_desc *)data)->window;
513                 if (s < 0 || s >= slt->ctrl->maxmem)
514                         return (EINVAL);
515                 mp = &slt->mem[s];
516                 ((struct mem_desc *)data)->flags = mp->flags;
517                 ((struct mem_desc *)data)->start = mp->start;
518                 ((struct mem_desc *)data)->size = mp->size;
519                 ((struct mem_desc *)data)->card = mp->card;
520                 break;
521         /*
522          * Set memory context. If context already active, then unmap it.
523          * It is hard to see how the parameters can be checked.
524          * At the very least, we only allow root to set the context.
525          */
526         case PIOCSMEM:
527                 if (suser(td))
528                         return (EPERM);
529                 if (slt->state != filled)
530                         return (ENXIO);
531                 s = ((struct mem_desc *)data)->window;
532                 if (s < 0 || s >= slt->ctrl->maxmem)
533                         return (EINVAL);
534                 slt->mem[s] = *((struct mem_desc *)data);
535                 return (slt->ctrl->mapmem(slt, s));
536         /*
537          * Get I/O port context.
538          */
539         case PIOCGIO:
540                 s = ((struct io_desc *)data)->window;
541                 if (s < 0 || s >= slt->ctrl->maxio)
542                         return (EINVAL);
543                 ip = &slt->io[s];
544                 ((struct io_desc *)data)->flags = ip->flags;
545                 ((struct io_desc *)data)->start = ip->start;
546                 ((struct io_desc *)data)->size = ip->size;
547                 break;
548         /*
549          * Set I/O port context.
550          */
551         case PIOCSIO:
552                 if (suser(td))
553                         return (EPERM);
554                 if (slt->state != filled)
555                         return (ENXIO);
556                 s = ((struct io_desc *)data)->window;
557                 if (s < 0 || s >= slt->ctrl->maxio)
558                         return (EINVAL);
559                 slt->io[s] = *((struct io_desc *)data);
560                 /* XXX Don't actually map */
561                 return (0);
562                 break;
563         /*
564          * Set memory window flags for read/write interface.
565          */
566         case PIOCRWFLAG:
567                 slt->rwmem = *(int *)data;
568                 break;
569         /*
570          * Set the memory window to be used for the read/write interface.
571          */
572         case PIOCRWMEM:
573                 if (*(unsigned long *)data == 0) {
574                         *(unsigned long *)data = pccard_mem;
575                         break;
576                 }
577                 if (suser(td))
578                         return (EPERM);
579                 /*
580                  * Validate the memory by checking it against the I/O
581                  * memory range. It must also start on an aligned block size.
582                  */
583                 if (*(unsigned long *)data & (PCCARD_MEMSIZE-1))
584                         return (EINVAL);
585                 pccarddev = PCCARD_DEV2SOFTC(dev)->dev;
586                 pccard_mem_rid = 0;
587                 addr = *(unsigned long *)data;
588                 if (pccard_mem_res)
589                         bus_release_resource(pccarddev, SYS_RES_MEMORY,
590                             pccard_mem_rid, pccard_mem_res);
591                 pccard_mem_res = bus_alloc_resource(pccarddev, SYS_RES_MEMORY,
592                     &pccard_mem_rid, addr, addr, PCCARD_MEMSIZE,
593                     RF_ACTIVE | rman_make_alignment_flags(PCCARD_MEMSIZE));
594                 if (pccard_mem_res == NULL)
595                         return (EINVAL);
596                 pccard_mem = rman_get_start(pccard_mem_res);
597                 pccard_kmem = rman_get_virtual(pccard_mem_res);
598                 break;
599         /*
600          * Set power values.
601          */
602         case PIOCSPOW:
603                 slt->pwr = *(struct power *)data;
604                 return (slt->ctrl->power(slt));
605         /*
606          * Allocate a driver to this slot.
607          */
608         case PIOCSDRV:
609                 if (suser(td))
610                         return (EPERM);
611                 err = allocate_driver(slt, (struct dev_desc *)data);
612                 if (!err)
613                         pccard_success_beep();
614                 else
615                         pccard_failure_beep();
616                 return (err);
617         /*
618          * Virtual removal/insertion
619          */
620         case PIOCSVIR:
621                 pwval = *(int *)data;
622                 if (!pwval) {
623                         if (slt->state != filled)
624                                 return (EINVAL);
625                         pccard_event(slt, card_deactivated);
626                 } else {
627                         if (slt->state != empty && slt->state != inactive)
628                                 return (EINVAL);
629                         pccard_event(slt, card_inserted);
630                 }
631                 break;
632         case PIOCSBEEP:
633                 if (pccard_beep_select(*(int *)data)) {
634                         return (EINVAL);
635                 }
636                 break;
637         }
638         return (0);
639 }
640
641 /*
642  *      poll - Poll on exceptions will return true
643  *      when a change in card status occurs.
644  */
645 static  int
646 crdpoll(dev_t dev, int events, d_thread_t *td)
647 {
648         int     revents = 0;
649         int     s;
650         struct slot *slt = PCCARD_DEV2SOFTC(dev);
651
652         if (events & (POLLIN | POLLRDNORM))
653                 revents |= events & (POLLIN | POLLRDNORM);
654
655         if (events & (POLLOUT | POLLWRNORM))
656                 revents |= events & (POLLIN | POLLRDNORM);
657
658         s = splhigh();
659         /*
660          *      select for exception - card event.
661          */
662         if (events & POLLRDBAND)
663                 if (slt == 0 || slt->laststate != slt->state)
664                         revents |= POLLRDBAND;
665
666         if (revents == 0)
667                 selrecord(td, &slt->selp);
668
669         splx(s);
670         return (revents);
671 }
672
673 /*
674  *      APM hooks for suspending and resuming.
675  */
676 int
677 pccard_suspend(device_t dev)
678 {
679         struct slot *slt = PCCARD_DEVICE2SOFTC(dev);
680
681         /* This code stolen from pccard_event:card_removed */
682         if (slt->state == filled) {
683                 int s = splhigh();              /* nop on current */
684                 disable_slot(slt);
685                 slt->laststate = suspend;       /* for pccardd */
686                 slt->state = empty;
687                 splx(s);
688                 printf("pccard: card disabled, slot %d\n", slt->slotnum);
689         }
690         /*
691          * Disable any pending timeouts for this slot since we're
692          * powering it down/disabling now.
693          */
694         untimeout(power_off_slot, (caddr_t)slt, slt->poff_ch);
695         slt->ctrl->disable(slt);
696         return (0);
697 }
698
699 int
700 pccard_resume(device_t dev)
701 {
702         struct slot *slt = PCCARD_DEVICE2SOFTC(dev);
703
704         slt->ctrl->resume(slt);
705         return (0);
706 }