Home | History | Annotate | Line # | Download | only in cardbus
cardslot.c revision 1.35.6.2 
      1 /*	$NetBSD: cardslot.c,v 1.35.6.2 2007/11/06 14:27:15 joerg Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1999 and 2000
      5  *       HAYAKAWA Koichi.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *	This product includes software developed by HAYAKAWA Koichi.
     18  * 4. 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  *
     22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     24  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     25  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
     26  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
     27  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
     28  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     30  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
     31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     32  * POSSIBILITY OF SUCH DAMAGE.
     33  */
     34 
     35 #include <sys/cdefs.h>
     36 __KERNEL_RCSID(0, "$NetBSD: cardslot.c,v 1.35.6.2 2007/11/06 14:27:15 joerg Exp $");
     37 
     38 #include "opt_cardslot.h"
     39 
     40 #include <sys/param.h>
     41 #include <sys/systm.h>
     42 #include <sys/device.h>
     43 #include <sys/malloc.h>
     44 #include <sys/kernel.h>
     45 #include <sys/syslog.h>
     46 #include <sys/kthread.h>
     47 
     48 #include <sys/bus.h>
     49 
     50 #include <dev/cardbus/cardslotvar.h>
     51 #include <dev/cardbus/cardbusvar.h>
     52 #include <dev/pcmcia/pcmciavar.h>
     53 #include <dev/pcmcia/pcmciachip.h>
     54 #include <dev/ic/i82365var.h>
     55 
     56 #include "locators.h"
     57 
     58 #if defined CARDSLOT_DEBUG
     59 #define STATIC
     60 #define DPRINTF(a) printf a
     61 #else
     62 #define STATIC static
     63 #define DPRINTF(a)
     64 #endif
     65 
     66 
     67 
     68 STATIC void cardslotattach(struct device *, struct device *, void *);
     69 
     70 STATIC int cardslotmatch(struct device *, struct cfdata *, void *);
     71 static void cardslot_event_thread(void *arg);
     72 
     73 STATIC int cardslot_cb_print(void *aux, const char *pcic);
     74 static int cardslot_16_print(void *, const char *);
     75 static int cardslot_16_submatch(struct device *, struct cfdata *,
     76 				     const int *, void *);
     77 
     78 CFATTACH_DECL(cardslot, sizeof(struct cardslot_softc),
     79     cardslotmatch, cardslotattach, NULL, NULL);
     80 
     81 STATIC int
     82 cardslotmatch(struct device *parent, struct cfdata *cf,
     83     void *aux)
     84 {
     85 	struct cardslot_attach_args *caa = aux;
     86 
     87 	if (caa->caa_cb_attach == NULL && caa->caa_16_attach == NULL) {
     88 		/* Neither CardBus nor 16-bit PCMCIA are defined. */
     89 		return 0;
     90 	}
     91 
     92 	return 1;
     93 }
     94 
     95 
     96 
     97 STATIC void
     98 cardslotattach(struct device *parent, struct device *self,
     99     void *aux)
    100 {
    101 	struct cardslot_softc *sc = device_private(self);
    102 	struct cardslot_attach_args *caa = aux;
    103 
    104 	struct cbslot_attach_args *cba = caa->caa_cb_attach;
    105 	struct pcmciabus_attach_args *pa = caa->caa_16_attach;
    106 
    107 	struct cardbus_softc *csc = NULL;
    108 	struct pcmcia_softc *psc = NULL;
    109 
    110 	sc->sc_slot = device_unit(&sc->sc_dev);
    111 	sc->sc_cb_softc = NULL;
    112 	sc->sc_16_softc = NULL;
    113 	SIMPLEQ_INIT(&sc->sc_events);
    114 	sc->sc_th_enable = 0;
    115 
    116 	printf(" slot %d flags %x\n", sc->sc_slot,
    117 	       device_cfdata(&sc->sc_dev)->cf_flags);
    118 
    119 	DPRINTF(("%s attaching CardBus bus...\n", sc->sc_dev.dv_xname));
    120 	if (cba != NULL) {
    121 		csc = (void *)config_found_ia(self, "cbbus", cba,
    122 					      cardslot_cb_print);
    123 		if (csc) {
    124 			/* cardbus found */
    125 			DPRINTF(("%s: found cardbus on %s\n", __func__,
    126 				 sc->sc_dev.dv_xname));
    127 			sc->sc_cb_softc = csc;
    128 		}
    129 	}
    130 
    131 	if (pa != NULL) {
    132 		psc = (void *)config_found_sm_loc(self, "pcmciabus", NULL, pa,
    133 			cardslot_16_print, cardslot_16_submatch);
    134 		if (psc) {
    135 			/* pcmcia 16-bit bus found */
    136 			DPRINTF(("%s: found 16-bit pcmcia bus\n", __func__));
    137 			sc->sc_16_softc = psc;
    138 			/*
    139 			 * XXX:
    140 			 * dirty.  This code should be removed to achieve MI.
    141 			 */
    142 			caa->caa_ph->pcmcia = (struct device *)psc;
    143 		}
    144 	}
    145 
    146 	if (csc != NULL || psc != NULL) {
    147 		config_pending_incr();
    148 		if (kthread_create(PRI_NONE, 0, NULL, cardslot_event_thread,
    149 		    sc, &sc->sc_event_thread, "%s", sc->sc_dev.dv_xname)) {
    150 			printf("%s: unable to create thread for slot %d\n",
    151 			    sc->sc_dev.dv_xname, sc->sc_slot);
    152 			panic("cardslotattach");
    153 		}
    154 		sc->sc_th_enable = 1;
    155 	}
    156 
    157 	if (csc && (csc->sc_cf->cardbus_ctrl)(csc->sc_cc, CARDBUS_CD)) {
    158 		DPRINTF(("%s: CardBus card found\n", __func__));
    159 		/* attach deferred */
    160 		cardslot_event_throw(sc, CARDSLOT_EVENT_INSERTION_CB);
    161 	}
    162 
    163 	if (psc && (psc->pct->card_detect)(psc->pch)) {
    164 		DPRINTF(("%s: 16-bit card found\n", __func__));
    165 		/* attach deferred */
    166 		cardslot_event_throw(sc, CARDSLOT_EVENT_INSERTION_16);
    167 	}
    168 
    169 	if (!pnp_device_register(self, NULL, NULL))
    170 		aprint_error_dev(self, "couldn't establish power handler\n");
    171 }
    172 
    173 
    174 
    175 STATIC int
    176 cardslot_cb_print(void *aux, const char *pnp)
    177 {
    178 	struct cbslot_attach_args *cba = aux;
    179 
    180 	if (pnp != NULL) {
    181 		aprint_normal("cardbus at %s subordinate bus %d",
    182 		    pnp, cba->cba_bus);
    183 	}
    184 
    185 	return UNCONF;
    186 }
    187 
    188 
    189 static int
    190 cardslot_16_submatch(struct device *parent, struct cfdata *cf,
    191     const int *ldesc, void *aux)
    192 {
    193 
    194 	if (cf->cf_loc[PCMCIABUSCF_CONTROLLER] != PCMCIABUSCF_CONTROLLER_DEFAULT
    195 	    && cf->cf_loc[PCMCIABUSCF_CONTROLLER] != 0) {
    196 		return 0;
    197 	}
    198 
    199 	if ((cf->cf_loc[PCMCIABUSCF_CONTROLLER] == PCMCIABUSCF_CONTROLLER_DEFAULT)) {
    200 		return (config_match(parent, cf, aux));
    201 	}
    202 
    203 	return 0;
    204 }
    205 
    206 
    207 
    208 static int
    209 cardslot_16_print(void *arg, const char *pnp)
    210 {
    211 
    212 	if (pnp != NULL) {
    213 		aprint_normal("pcmciabus at %s", pnp);
    214 	}
    215 
    216 	return UNCONF;
    217 }
    218 
    219 
    220 /*
    221  * void cardslot_event_throw(struct cardslot_softc *sc, int ev)
    222  *
    223  *   This function throws an event to the event handler.  If the state
    224  *   of a slot is changed, it should be noticed using this function.
    225  */
    226 void
    227 cardslot_event_throw(struct cardslot_softc *sc, int ev)
    228 {
    229 	struct cardslot_event *ce;
    230 
    231 	DPRINTF(("cardslot_event_throw: an event %s comes\n",
    232 	    ev == CARDSLOT_EVENT_INSERTION_CB ? "CardBus Card inserted" :
    233 	    ev == CARDSLOT_EVENT_INSERTION_16 ? "16-bit Card inserted" :
    234 	    ev == CARDSLOT_EVENT_REMOVAL_CB ? "CardBus Card removed" :
    235 	    ev == CARDSLOT_EVENT_REMOVAL_16 ? "16-bit Card removed" : "???"));
    236 
    237 	if (NULL == (ce = (struct cardslot_event *)malloc(sizeof (struct cardslot_event), M_TEMP, M_NOWAIT))) {
    238 		panic("cardslot_enevt");
    239 	}
    240 
    241 	ce->ce_type = ev;
    242 
    243 	{
    244 		int s = spltty();
    245 		SIMPLEQ_INSERT_TAIL(&sc->sc_events, ce, ce_q);
    246 		splx(s);
    247 	}
    248 
    249 	wakeup(&sc->sc_events);
    250 
    251 	return;
    252 }
    253 
    254 
    255 /*
    256  * static void cardslot_event_thread(void *arg)
    257  *
    258  *   This function is the main routine handing cardslot events such as
    259  *   insertions and removals.
    260  *
    261  */
    262 static void
    263 cardslot_event_thread(arg)
    264 	void *arg;
    265 {
    266 	struct cardslot_softc *sc = arg;
    267 	struct cardslot_event *ce;
    268 	int s, first = 1;
    269 	static int antonym_ev[4] = {
    270 		CARDSLOT_EVENT_REMOVAL_16, CARDSLOT_EVENT_INSERTION_16,
    271 		CARDSLOT_EVENT_REMOVAL_CB, CARDSLOT_EVENT_INSERTION_CB
    272 	};
    273 
    274 	while (sc->sc_th_enable) {
    275 		s = spltty();
    276 		if ((ce = SIMPLEQ_FIRST(&sc->sc_events)) == NULL) {
    277 			splx(s);
    278 			if (first) {
    279 				first = 0;
    280 				config_pending_decr();
    281 			}
    282 			(void) tsleep(&sc->sc_events, PWAIT, "cardslotev", 0);
    283 			continue;
    284 		}
    285 		SIMPLEQ_REMOVE_HEAD(&sc->sc_events, ce_q);
    286 		splx(s);
    287 
    288 		if (IS_CARDSLOT_INSERT_REMOVE_EV(ce->ce_type)) {
    289 			/* Chattering suppression */
    290 			s = spltty();
    291 			while (1) {
    292 				struct cardslot_event *ce1, *ce2;
    293 
    294 				if ((ce1 = SIMPLEQ_FIRST(&sc->sc_events)) == NULL) {
    295 					break;
    296 				}
    297 				if (ce1->ce_type != antonym_ev[ce->ce_type]) {
    298 					break;
    299 				}
    300 				if ((ce2 = SIMPLEQ_NEXT(ce1, ce_q)) == NULL) {
    301 					break;
    302 				}
    303 				if (ce2->ce_type == ce->ce_type) {
    304 					SIMPLEQ_REMOVE_HEAD(&sc->sc_events,
    305 					    ce_q);
    306 					free(ce1, M_TEMP);
    307 					SIMPLEQ_REMOVE_HEAD(&sc->sc_events,
    308 					    ce_q);
    309 					free(ce2, M_TEMP);
    310 				}
    311 			}
    312 			splx(s);
    313 		}
    314 
    315 		switch (ce->ce_type) {
    316 		case CARDSLOT_EVENT_INSERTION_CB:
    317 			if ((CARDSLOT_CARDTYPE(sc->sc_status) == CARDSLOT_STATUS_CARD_CB)
    318 			    || (CARDSLOT_CARDTYPE(sc->sc_status) == CARDSLOT_STATUS_CARD_16)) {
    319 				if (CARDSLOT_WORK(sc->sc_status) == CARDSLOT_STATUS_WORKING) {
    320 					/*
    321 					 * A card has already been
    322 					 * inserted and works.
    323 					 */
    324 					break;
    325 				}
    326 			}
    327 
    328 			if (sc->sc_cb_softc) {
    329 				CARDSLOT_SET_CARDTYPE(sc->sc_status,
    330 				    CARDSLOT_STATUS_CARD_CB);
    331 				if (cardbus_attach_card(sc->sc_cb_softc) > 0) {
    332 					/* at least one function works */
    333 					CARDSLOT_SET_WORK(sc->sc_status, CARDSLOT_STATUS_WORKING);
    334 				} else {
    335 					/*
    336 					 * no functions work or this
    337 					 * card is not known
    338 					 */
    339 					CARDSLOT_SET_WORK(sc->sc_status,
    340 					    CARDSLOT_STATUS_NOTWORK);
    341 				}
    342 			} else {
    343 				panic("no cardbus on %s", sc->sc_dev.dv_xname);
    344 			}
    345 
    346 			break;
    347 
    348 		case CARDSLOT_EVENT_INSERTION_16:
    349 			if ((CARDSLOT_CARDTYPE(sc->sc_status) == CARDSLOT_STATUS_CARD_CB)
    350 			    || (CARDSLOT_CARDTYPE(sc->sc_status) == CARDSLOT_STATUS_CARD_16)) {
    351 				if (CARDSLOT_WORK(sc->sc_status) == CARDSLOT_STATUS_WORKING) {
    352 					/*
    353 					 * A card has already been
    354 					 * inserted and work.
    355 					 */
    356 					break;
    357 				}
    358 			}
    359 			if (sc->sc_16_softc) {
    360 				CARDSLOT_SET_CARDTYPE(sc->sc_status, CARDSLOT_STATUS_CARD_16);
    361 				if (pcmcia_card_attach((struct device *)sc->sc_16_softc)) {
    362 					/* Do not attach */
    363 					CARDSLOT_SET_WORK(sc->sc_status,
    364 					    CARDSLOT_STATUS_NOTWORK);
    365 				} else {
    366 					/* working */
    367 					CARDSLOT_SET_WORK(sc->sc_status,
    368 					    CARDSLOT_STATUS_WORKING);
    369 				}
    370 			} else {
    371 				panic("no 16-bit pcmcia on %s", sc->sc_dev.dv_xname);
    372 			}
    373 
    374 			break;
    375 
    376 		case CARDSLOT_EVENT_REMOVAL_CB:
    377 			if (CARDSLOT_CARDTYPE(sc->sc_status) == CARDSLOT_STATUS_CARD_CB) {
    378 				/* CardBus card has not been inserted. */
    379 				if (CARDSLOT_WORK(sc->sc_status) == CARDSLOT_STATUS_WORKING) {
    380 					cardbus_detach_card(sc->sc_cb_softc);
    381 					CARDSLOT_SET_WORK(sc->sc_status,
    382 					    CARDSLOT_STATUS_NOTWORK);
    383 					CARDSLOT_SET_WORK(sc->sc_status,
    384 					    CARDSLOT_STATUS_CARD_NONE);
    385 				}
    386 				CARDSLOT_SET_CARDTYPE(sc->sc_status,
    387 				    CARDSLOT_STATUS_CARD_NONE);
    388 			} else if (CARDSLOT_CARDTYPE(sc->sc_status) != CARDSLOT_STATUS_CARD_16) {
    389 				/* Unknown card... */
    390 				CARDSLOT_SET_CARDTYPE(sc->sc_status,
    391 				    CARDSLOT_STATUS_CARD_NONE);
    392 			}
    393 			CARDSLOT_SET_WORK(sc->sc_status,
    394 			    CARDSLOT_STATUS_NOTWORK);
    395 			break;
    396 
    397 		case CARDSLOT_EVENT_REMOVAL_16:
    398 			DPRINTF(("%s: removal event\n", sc->sc_dev.dv_xname));
    399 			if (CARDSLOT_CARDTYPE(sc->sc_status) != CARDSLOT_STATUS_CARD_16) {
    400 				/* 16-bit card has not been inserted. */
    401 				break;
    402 			}
    403 			if ((sc->sc_16_softc != NULL)
    404 			    && (CARDSLOT_WORK(sc->sc_status) == CARDSLOT_STATUS_WORKING)) {
    405 				struct pcmcia_softc *psc = sc->sc_16_softc;
    406 
    407 				pcmcia_card_deactivate((struct device *)psc);
    408 				pcmcia_chip_socket_disable(psc->pct, psc->pch);
    409 				pcmcia_card_detach((struct device *)psc, DETACH_FORCE);
    410 			}
    411 			CARDSLOT_SET_CARDTYPE(sc->sc_status, CARDSLOT_STATUS_CARD_NONE);
    412 			CARDSLOT_SET_WORK(sc->sc_status, CARDSLOT_STATUS_NOTWORK);
    413 			break;
    414 
    415 		default:
    416 			panic("cardslot_event_thread: unknown event %d", ce->ce_type);
    417 		}
    418 		free(ce, M_TEMP);
    419 	}
    420 
    421 	sc->sc_event_thread = NULL;
    422 
    423 	/* In case the parent device is waiting for us to exit. */
    424 	wakeup(sc);
    425 
    426 	kthread_exit(0);
    427 }
    428