Home | History | Annotate | Line # | Download | only in dev
mediabay.c revision 1.22.66.1
      1 /*	$NetBSD: mediabay.c,v 1.22.66.1 2021/04/03 22:28:29 thorpej Exp $	*/
      2 
      3 /*-
      4  * Copyright (C) 1999 Tsubai Masanari.  All rights reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  * 3. The name of the author may not be used to endorse or promote products
     15  *    derived from this software without specific prior written permission.
     16  *
     17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27  */
     28 
     29 #include <sys/cdefs.h>
     30 __KERNEL_RCSID(0, "$NetBSD: mediabay.c,v 1.22.66.1 2021/04/03 22:28:29 thorpej Exp $");
     31 
     32 #include <sys/param.h>
     33 #include <sys/device.h>
     34 #include <sys/kernel.h>
     35 #include <sys/kthread.h>
     36 #include <sys/systm.h>
     37 
     38 #include <dev/ofw/openfirm.h>
     39 
     40 #include <machine/autoconf.h>
     41 #include <machine/pio.h>
     42 
     43 enum mediabay_controller {
     44 	MB_CONTROLLER_KEYLARGO,
     45 	MB_CONTROLLER_OTHER
     46 };
     47 
     48 struct mediabay_softc {
     49 	device_t sc_dev;
     50 	bus_space_tag_t sc_tag;
     51 	int sc_node;
     52 	u_int *sc_addr;
     53 	u_int *sc_fcr;
     54 	u_int sc_baseaddr;
     55 	device_t sc_content;
     56 	lwp_t *sc_kthread;
     57 	enum mediabay_controller sc_type;
     58 };
     59 
     60 static const char *mediabay_keylargo[] = {
     61 	"keylargo-media-bay",
     62 	NULL
     63 };
     64 
     65 void mediabay_attach(device_t, device_t, void *);
     66 int mediabay_match(device_t, cfdata_t, void *);
     67 int mediabay_print(void *, const char *);
     68 void mediabay_attach_content(struct mediabay_softc *);
     69 int mediabay_intr(void *);
     70 void mediabay_kthread(void *);
     71 
     72 CFATTACH_DECL_NEW(mediabay, sizeof(struct mediabay_softc),
     73     mediabay_match, mediabay_attach, NULL, NULL);
     74 
     75 #ifdef MEDIABAY_DEBUG
     76 # define DPRINTF printf
     77 #else
     78 # define DPRINTF while (0) printf
     79 #endif
     80 
     81 #define FCR_MEDIABAY_RESET	0x00000002
     82 #define FCR_MEDIABAY_IDE_ENABLE	0x00000008
     83 #define FCR_MEDIABAY_FD_ENABLE	0x00000010
     84 #define FCR_MEDIABAY_ENABLE	0x00000080
     85 #define FCR_MEDIABAY_CD_POWER	0x00800000
     86 
     87 #define MBCR_MEDIABAY0_ENABLE		0x00000100
     88 #define MBCR_MEDIABAY0_RESET		0x00000200
     89 #define MBCR_MEDIABAY0_POWER		0x00000400
     90 #define MBCR_MEDIABAY0_IDE_ENABLE	0x00001000
     91 #define MBCR_MEDIABAY0_DEVMASK		0x00007800
     92 
     93 #define FCR1_EIDE0_ENABLE	0x00800000
     94 #define FCR1_EIDE0_RESET	0x01000000
     95 
     96 #define MEDIABAY_ID(sc, x)				\
     97 	((sc)->sc_type == MB_CONTROLLER_KEYLARGO ?	\
     98 	 (((x) >> 4) & 0xf) :				\
     99 	 (((x) >> 12) & 0xf))
    100 #define MEDIABAY_ID_FD		0
    101 #define MEDIABAY_ID_CD		3
    102 #define MEDIABAY_ID_NONE	7
    103 
    104 int
    105 mediabay_match(device_t parent, cfdata_t cf, void *aux)
    106 {
    107 	struct confargs *ca = aux;
    108 
    109 	if (strcmp(ca->ca_name, "media-bay") == 0)
    110 		return 1;
    111 
    112 	return 0;
    113 }
    114 
    115 /*
    116  * Attach all the sub-devices we can find
    117  */
    118 void
    119 mediabay_attach(device_t parent, device_t self, void *aux)
    120 {
    121 	struct mediabay_softc *sc = device_private(self);
    122 	struct confargs *ca = aux;
    123 	int irq, itype;
    124 
    125 	sc->sc_dev = self;
    126 	ca->ca_reg[0] += ca->ca_baseaddr;
    127 
    128 	sc->sc_addr = mapiodev(ca->ca_reg[0], PAGE_SIZE, false);
    129 	sc->sc_node = ca->ca_node;
    130 	sc->sc_baseaddr = ca->ca_baseaddr;
    131 	sc->sc_tag = ca->ca_tag;
    132 	irq = ca->ca_intr[0];
    133 	itype = IST_EDGE;
    134 
    135 	if (of_compatible(ca->ca_node, mediabay_keylargo)) {
    136 		sc->sc_type = MB_CONTROLLER_KEYLARGO;
    137 		sc->sc_fcr = sc->sc_addr + 2;
    138 	} else {
    139 		sc->sc_type = MB_CONTROLLER_OTHER;
    140 		sc->sc_fcr = sc->sc_addr + 1;
    141 	}
    142 
    143 	if (ca->ca_nintr == 8 && ca->ca_intr[1] != 0)
    144 		itype = IST_LEVEL;
    145 
    146 	printf(" irq %d %s\n", irq, intr_typename(itype));
    147 
    148 	intr_establish_xname(irq, itype, IPL_BIO, mediabay_intr, sc,
    149 	    device_xname(self));
    150 
    151 	sc->sc_content = NULL;
    152 
    153 	if (MEDIABAY_ID(sc, in32rb(sc->sc_addr)) != MEDIABAY_ID_NONE)
    154 		mediabay_attach_content(sc);
    155 
    156 	kthread_create(PRI_NONE, 0, NULL, mediabay_kthread, sc,
    157 	    &sc->sc_kthread, "media-bay");
    158 }
    159 
    160 void
    161 mediabay_attach_content(struct mediabay_softc *sc)
    162 {
    163 	int child;
    164 	u_int fcr = 0;
    165 	device_t content;
    166 	struct confargs ca;
    167 	u_int reg[20], intr[5];
    168 	char name[32];
    169 
    170 	if (sc->sc_type != MB_CONTROLLER_KEYLARGO) {
    171 		fcr = in32rb(sc->sc_fcr);
    172 
    173 		/*
    174 		 * if the mediabay isn't powered up we need to wait a few seconds
    175 		 * before probing devices
    176 		 */
    177 		if ((fcr & (FCR_MEDIABAY_ENABLE | FCR_MEDIABAY_IDE_ENABLE
    178 		    | FCR_MEDIABAY_CD_POWER)) != (FCR_MEDIABAY_ENABLE
    179 		    | FCR_MEDIABAY_IDE_ENABLE | FCR_MEDIABAY_CD_POWER)) {
    180 			fcr |= FCR_MEDIABAY_ENABLE | FCR_MEDIABAY_RESET;
    181 			out32rb(sc->sc_fcr, fcr);
    182 			delay(50000);
    183 
    184 			fcr &= ~FCR_MEDIABAY_RESET;
    185 			out32rb(sc->sc_fcr, fcr);
    186 			delay(50000);
    187 
    188 			fcr |= FCR_MEDIABAY_IDE_ENABLE | FCR_MEDIABAY_CD_POWER;
    189 			out32rb(sc->sc_fcr, fcr);
    190 			delay(50000);
    191 			printf("%s: powering up...\n", device_xname(sc->sc_dev));
    192 			delay(2000000);
    193 		}
    194 	} else {
    195 		printf("%s: powering up keylargo-media-bay..", device_xname(sc->sc_dev));
    196 
    197 		out32rb(sc->sc_addr, in32rb(sc->sc_addr) & ~MBCR_MEDIABAY0_RESET);
    198 		out32rb(sc->sc_addr, in32rb(sc->sc_addr) & ~MBCR_MEDIABAY0_POWER);
    199 		delay(50000);
    200 
    201 		out32rb(sc->sc_addr, in32rb(sc->sc_addr) & ~MBCR_MEDIABAY0_ENABLE);
    202 		delay(50000);
    203 
    204 		out32rb(sc->sc_addr,
    205 		    in32rb(sc->sc_addr) | MBCR_MEDIABAY0_IDE_ENABLE);
    206 		delay(50000);
    207 
    208 		out32rb(sc->sc_addr, in32rb(sc->sc_addr) | MBCR_MEDIABAY0_RESET);
    209 		delay(50000);
    210 
    211 		out32rb(sc->sc_fcr, in32rb(sc->sc_fcr) | FCR1_EIDE0_RESET);
    212 		out32rb(sc->sc_fcr, in32rb(sc->sc_fcr) | FCR1_EIDE0_ENABLE);
    213 		delay(50000);
    214 
    215 		out32rb(sc->sc_addr, in32rb(sc->sc_addr) | MBCR_MEDIABAY0_ENABLE);
    216 		__asm volatile ("eieio");
    217 		delay(50000);
    218 
    219 		out32rb(sc->sc_addr, in32rb(sc->sc_addr) & ~0xf);
    220 		__asm volatile ("eieio");
    221 		delay(50000);
    222 
    223 		tsleep(sc, PRI_NONE, "mediabay", hz*1);
    224 
    225 		printf(" done.\n");
    226 	}
    227 
    228 	for (child = OF_child(sc->sc_node); child; child = OF_peer(child)) {
    229 		memset(name, 0, sizeof(name));
    230 		if (OF_getprop(child, "name", name, sizeof(name)) == -1)
    231 			continue;
    232 		ca.ca_name = name;
    233 		ca.ca_node = child;
    234 		ca.ca_baseaddr = sc->sc_baseaddr;
    235 		ca.ca_tag = sc->sc_tag;
    236 
    237 		ca.ca_nreg  = OF_getprop(child, "reg", reg, sizeof(reg));
    238 		ca.ca_nintr = OF_getprop(child, "AAPL,interrupts", intr,
    239 				sizeof(intr));
    240 		if (ca.ca_nintr == -1)
    241 			ca.ca_nintr = OF_getprop(child, "interrupts", intr,
    242 					sizeof(intr));
    243 		ca.ca_reg = reg;
    244 		ca.ca_intr = intr;
    245 
    246 		content = config_found(sc->sc_dev, &ca, mediabay_print);
    247 		if (content) {
    248 			sc->sc_content = content;
    249 			return;
    250 		}
    251 	}
    252 
    253 	if (sc->sc_type != MB_CONTROLLER_KEYLARGO) {
    254 		/* No devices found.  Disable media-bay. */
    255 		fcr &= ~(FCR_MEDIABAY_ENABLE | FCR_MEDIABAY_IDE_ENABLE |
    256 			 FCR_MEDIABAY_CD_POWER | FCR_MEDIABAY_FD_ENABLE);
    257 		out32rb(sc->sc_fcr, fcr);
    258 	}
    259 }
    260 
    261 int
    262 mediabay_print(void *aux, const char *mediabay)
    263 {
    264 	struct confargs *ca = aux;
    265 
    266 	if (mediabay == NULL && ca->ca_nreg > 0)
    267 		aprint_normal(" offset 0x%x", ca->ca_reg[0]);
    268 
    269 	return QUIET;
    270 }
    271 
    272 int
    273 mediabay_intr(void *v)
    274 {
    275 	struct mediabay_softc *sc = v;
    276 
    277 	wakeup(&sc->sc_kthread);
    278 
    279 	return 1;
    280 }
    281 
    282 void
    283 mediabay_kthread(void *v)
    284 {
    285 	struct mediabay_softc *sc = v;
    286 	u_int x, fcr;
    287 
    288 	for (;;) {
    289 		tsleep(&sc->sc_kthread, PRIBIO, "mbayev", 0);
    290 
    291 		/* sleep 0.25 sec */
    292 		tsleep(mediabay_kthread, PRIBIO, "mbayev", hz/4);
    293 
    294 		DPRINTF("%s: ", device_xname(sc->sc_dev));
    295 		x = in32rb(sc->sc_addr);
    296 
    297 		switch (MEDIABAY_ID(sc, x)) {
    298 		case MEDIABAY_ID_NONE:
    299 			DPRINTF("removed\n");
    300 			if (sc->sc_content != NULL) {
    301 				config_detach(sc->sc_content, DETACH_FORCE);
    302 				DPRINTF("%s: detach done\n",
    303 					device_xname(sc->sc_dev));
    304 				sc->sc_content = NULL;
    305 
    306 				if (sc->sc_type != MB_CONTROLLER_KEYLARGO) {
    307 					/* disable media-bay */
    308 					fcr = in32rb(sc->sc_fcr);
    309 					fcr &= ~(FCR_MEDIABAY_ENABLE |
    310 						 FCR_MEDIABAY_IDE_ENABLE |
    311 						 FCR_MEDIABAY_CD_POWER |
    312 						 FCR_MEDIABAY_FD_ENABLE);
    313 					out32rb(sc->sc_fcr, fcr);
    314 				}
    315 			}
    316 			break;
    317 		case MEDIABAY_ID_FD:
    318 			DPRINTF("FD inserted\n");
    319 			break;
    320 		case MEDIABAY_ID_CD:
    321 			DPRINTF("CD inserted\n");
    322 
    323 			if (sc->sc_content == NULL)
    324 				mediabay_attach_content(sc);
    325 			break;
    326 		default:
    327 			printf("unknown event (0x%x)\n", x);
    328 		}
    329 	}
    330 }
    331 
    332 /* PBG3: 0x7025X0c0 */
    333 /* 3400: 0x7070X080 */
    334 /* 2400: 0x0070X0a8 */
    335