1 /* $OpenBSD: ts102.c,v 1.14 2005/01/27 17:03:23 millert Exp $ */
2 /* $NetBSD: ts102.c,v 1.22 2023/12/20 05:33:18 thorpej Exp $ */
3 /*
4 * Copyright (c) 2003, 2004, Miodrag Vallat.
5 * Copyright (c) 2005, Michael Lorenz.
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 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
20 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
24 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
25 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 /*
30 * Driver for the PCMCIA controller found in Tadpole SPARCbook 3 series
31 * notebooks.
32 *
33 * Based on the information provided in the SPARCbook 3 Technical Reference
34 * Manual (s3gxtrmb.pdf), chapter 7. A few ramblings against this document
35 * and/or the chip itself are scattered across this file.
36 *
37 * Implementation notes:
38 *
39 * - The TS102 exports its PCMCIA windows as SBus memory ranges: 64MB for
40 * the common memory window, and 16MB for the attribute and I/O windows.
41 *
42 * Mapping the whole windows would consume 192MB of address space, which
43 * is much more that what the iospace can offer.
44 *
45 * A best-effort solution would be to map the windows on demand. However,
46 * due to the wap mapdev() works, the va used for the mappings would be
47 * lost after unmapping (although using an extent to register iospace memory
48 * usage would fix this). So, instead, we will do a fixed mapping of a subset
49 * of each window upon attach - this is similar to what the stp4020 driver
50 * does.
51 *
52 * Endianness farce:
53 *
54 * - The documentation pretends that the endianness settings only affect the
55 * common memory window. Gee, thanks a lot. What about other windows, then?
56 * As a result, this driver runs with endianness conversions turned off.
57 *
58 * - One of the little-endian SBus and big-endian PCMCIA flags has the reverse
59 * meaning, actually. To achieve a ``no endianness conversion'' status,
60 * one has to be set and the other unset. It does not matter which one,
61 * though.
62 */
63
64 #include <sys/cdefs.h>
65
66 #include <sys/param.h>
67 #include <sys/systm.h>
68 #include <sys/errno.h>
69 #include <sys/extent.h>
70 #include <sys/proc.h>
71 #include <sys/kernel.h>
72 #include <sys/kthread.h>
73 #include <sys/device.h>
74
75 #include <dev/pcmcia/pcmciareg.h>
76 #include <dev/pcmcia/pcmciavar.h>
77 #include <dev/pcmcia/pcmciachip.h>
78
79 #include <sys/bus.h>
80 #include <machine/intr.h>
81 #include <machine/autoconf.h>
82
83 #include <dev/sbus/sbusvar.h>
84 #include <sparc/dev/ts102reg.h>
85
86 #include "tctrl.h"
87
88 #if NTCTRL > 0
89 #include <machine/tctrl.h>
90 #include <sparc/dev/tctrlvar.h>
91 #endif
92
93 #define TS102_NUM_SLOTS 2
94
95 /*
96 * Memory ranges
97 */
98 #define TS102_RANGE_COMMON 0
99 #define TS102_RANGE_ATTR 1
100 #define TS102_RANGE_IO 2
101
102 #define TS102_RANGE_CNT 3
103 #define TS102_NUM_RANGES (TS102_RANGE_CNT * TS102_NUM_SLOTS)
104
105 #define TS102_ARBITRARY_MAP_SIZE (1 * 1024 * 1024)
106
107 struct tslot_softc;
108
109 #ifdef TSLOT_DEBUG
110 #define TSPRINTF printf
111 #else
112 #define TSPRINTF while (0) printf
113 #endif
114
115 /*
116 * Per-slot data
117 */
118 struct tslot_data {
119 struct tslot_softc *td_parent;
120 device_t td_pcmcia;
121
122 volatile uint8_t *td_regs;
123 bus_addr_t td_space[TS102_RANGE_CNT];
124 bus_space_tag_t td_pcmciat; /* for accessing cards */
125
126 /* Interrupt handler */
127 int (*td_intr)(void *);
128 void *td_intrarg;
129 void *td_softint;
130
131 /* Socket status */
132 int td_slot;
133 int td_status;
134 #define TS_CARD 0x0001
135 };
136
137 struct tslot_softc {
138 device_t sc_dev;
139
140 bus_space_tag_t sc_bustag; /* socket control io */
141 bus_space_handle_t sc_regh; /* space */
142
143 pcmcia_chipset_tag_t sc_pct;
144
145 lwp_t *sc_thread; /* event thread */
146 uint32_t sc_events; /* sockets with pending events */
147
148 /* bits 0 and 1 are set according to card presence in slot 0 and 1 */
149 uint32_t sc_active;
150
151 struct tslot_data sc_slot[TS102_NUM_SLOTS];
152 };
153
154 static void tslot_attach(device_t, device_t, void *);
155 static void tslot_event_thread(void *);
156 static int tslot_intr(void *);
157 static void tslot_intr_disestablish(pcmcia_chipset_handle_t, void *);
158 static void *tslot_intr_establish(pcmcia_chipset_handle_t,
159 struct pcmcia_function *, int, int (*)(void *), void *);
160
161 const char *tslot_intr_string(pcmcia_chipset_handle_t, void *);
162 static int tslot_io_alloc(pcmcia_chipset_handle_t, bus_addr_t, bus_size_t,
163 bus_size_t, struct pcmcia_io_handle *);
164 static void tslot_io_free(pcmcia_chipset_handle_t, struct pcmcia_io_handle *);
165 static int tslot_io_map(pcmcia_chipset_handle_t, int, bus_addr_t, bus_size_t,
166 struct pcmcia_io_handle *, int *);
167 static void tslot_io_unmap(pcmcia_chipset_handle_t, int);
168 static int tslot_match(device_t, struct cfdata *, void *);
169 static int tslot_mem_alloc(pcmcia_chipset_handle_t, bus_size_t,
170 struct pcmcia_mem_handle *);
171 static void tslot_mem_free(pcmcia_chipset_handle_t, struct pcmcia_mem_handle *);
172 static int tslot_mem_map(pcmcia_chipset_handle_t, int, bus_addr_t, bus_size_t,
173 struct pcmcia_mem_handle *, bus_size_t *, int *);
174 static void tslot_mem_unmap(pcmcia_chipset_handle_t, int);
175 static int tslot_print(void *, const char *);
176 static void tslot_queue_event(struct tslot_softc *, int);
177 static void tslot_reset(struct tslot_data *, uint32_t);
178 static void tslot_slot_disable(pcmcia_chipset_handle_t);
179 static void tslot_slot_enable(pcmcia_chipset_handle_t);
180 static void tslot_slot_intr(struct tslot_data *, int);
181 static void tslot_slot_settype(pcmcia_chipset_handle_t, int);
182 static void tslot_update_lcd(struct tslot_softc *, int, int);
183 static void tslot_intr_dispatch(void *arg);
184 void tslot_delay(struct tslot_softc *sc, unsigned int ms);
185
186 CFATTACH_DECL_NEW(tslot, sizeof(struct tslot_softc),
187 tslot_match, tslot_attach, NULL, NULL);
188
189 extern struct cfdriver tslot_cd;
190
191 /*
192 * PCMCIA chipset methods
193 */
194 struct pcmcia_chip_functions tslot_functions = {
195 tslot_mem_alloc,
196 tslot_mem_free,
197 tslot_mem_map,
198 tslot_mem_unmap,
199
200 tslot_io_alloc,
201 tslot_io_free,
202 tslot_io_map,
203 tslot_io_unmap,
204
205 tslot_intr_establish,
206 tslot_intr_disestablish,
207
208 tslot_slot_enable,
209 tslot_slot_disable,
210 tslot_slot_settype
211 };
212
213 static uint16_t ts102_read_2(bus_space_tag_t,
214 bus_space_handle_t,
215 bus_size_t);
216 static uint32_t ts102_read_4(bus_space_tag_t,
217 bus_space_handle_t,
218 bus_size_t);
219 static uint64_t ts102_read_8(bus_space_tag_t,
220 bus_space_handle_t,
221 bus_size_t);
222 static void ts102_write_2(bus_space_tag_t,
223 bus_space_handle_t,
224 bus_size_t,
225 uint16_t);
226 static void ts102_write_4(bus_space_tag_t,
227 bus_space_handle_t,
228 bus_size_t,
229 uint32_t);
230 static void ts102_write_8(bus_space_tag_t,
231 bus_space_handle_t,
232 bus_size_t,
233 uint64_t);
234
235 static uint16_t
ts102_read_2(bus_space_tag_t space,bus_space_handle_t handle,bus_size_t offset)236 ts102_read_2(bus_space_tag_t space, bus_space_handle_t handle,
237 bus_size_t offset)
238 {
239 return (le16toh(*(volatile uint16_t *)(handle +
240 offset)));
241 }
242
243 static uint32_t
ts102_read_4(bus_space_tag_t space,bus_space_handle_t handle,bus_size_t offset)244 ts102_read_4(bus_space_tag_t space, bus_space_handle_t handle,
245 bus_size_t offset)
246 {
247 return (le32toh(*(volatile uint32_t *)(handle +
248 offset)));
249 }
250
251 static uint64_t
ts102_read_8(bus_space_tag_t space,bus_space_handle_t handle,bus_size_t offset)252 ts102_read_8(bus_space_tag_t space, bus_space_handle_t handle,
253 bus_size_t offset)
254 {
255 return (le64toh(*(volatile uint64_t *)(handle +
256 offset)));
257 }
258
259 static void
ts102_write_2(bus_space_tag_t space,bus_space_handle_t handle,bus_size_t offset,uint16_t value)260 ts102_write_2(bus_space_tag_t space, bus_space_handle_t handle,
261 bus_size_t offset, uint16_t value)
262 {
263 (*(volatile uint16_t *)(handle + offset)) =
264 htole16(value);
265 }
266
267 static void
ts102_write_4(bus_space_tag_t space,bus_space_handle_t handle,bus_size_t offset,uint32_t value)268 ts102_write_4(bus_space_tag_t space, bus_space_handle_t handle,
269 bus_size_t offset, uint32_t value)
270 {
271 (*(volatile uint32_t *)(handle + offset)) =
272 htole32(value);
273 }
274
275 static void
ts102_write_8(bus_space_tag_t space,bus_space_handle_t handle,bus_size_t offset,uint64_t value)276 ts102_write_8(bus_space_tag_t space, bus_space_handle_t handle,
277 bus_size_t offset, uint64_t value)
278 {
279 (*(volatile uint64_t *)(handle + offset)) =
280 htole64(value);
281 }
282
283
284 #define TSLOT_READ(slot, offset) \
285 *(volatile uint16_t *)((slot)->td_regs + (offset))
286 #define TSLOT_WRITE(slot, offset, value) \
287 *(volatile uint16_t *)((slot)->td_regs + (offset)) = (value)
288
289 /*
290 * Attachment and initialization
291 */
292
293 static int
tslot_match(device_t parent,struct cfdata * vcf,void * aux)294 tslot_match(device_t parent, struct cfdata *vcf, void *aux)
295 {
296 struct sbus_attach_args *sa = aux;
297
298 return (strcmp("ts102", sa->sa_name) == 0);
299 }
300
301 static void
tslot_attach(device_t parent,device_t self,void * args)302 tslot_attach(device_t parent, device_t self, void *args)
303 {
304 struct sbus_attach_args *sa = args;
305 struct tslot_softc *sc = device_private(self);
306 struct tslot_data *td;
307 volatile uint8_t *regs;
308 int node, slot, rnum, base, size;
309 uint32_t ranges[30];
310 void *rptr = ranges;
311 bus_space_handle_t hrang = 0;
312 bus_space_tag_t tag;
313
314 sc->sc_dev = self;
315 node = sa->sa_node;
316 sc->sc_bustag=sa->sa_bustag;
317 if (sbus_bus_map(sa->sa_bustag,
318 sa->sa_slot,
319 sa->sa_offset,
320 sa->sa_size,
321 0, &sc->sc_regh) != 0) {
322 printf("%s: cannot map registers\n", device_xname(self));
323 return;
324 }
325 regs = (uint8_t *)bus_space_vaddr(sa->sa_bustag, sc->sc_regh);
326
327 tag = bus_space_tag_alloc(sa->sa_bustag, sc);
328 if (tag == NULL) {
329 printf("%s: attach: out of memory\n", device_xname(self));
330 return;
331 }
332 tag->sparc_read_2 = ts102_read_2;
333 tag->sparc_read_4 = ts102_read_4;
334 tag->sparc_read_8 = ts102_read_8;
335 tag->sparc_write_2 = ts102_write_2;
336 tag->sparc_write_4 = ts102_write_4;
337 tag->sparc_write_8 = ts102_write_8;
338
339 bus_intr_establish(sa->sa_bustag, sa->sa_intr[0].oi_pri,
340 IPL_NONE, tslot_intr, sc);
341
342 printf(": %d slots\n", TS102_NUM_SLOTS);
343
344 size = sizeof(ranges);
345 if (prom_getprop(node, "ranges", 4, &size, &rptr) != 0) {
346 printf("couldn't read ranges\n");
347 return;
348 }
349
350 /*
351 * Setup asynchronous event handler
352 */
353 sc->sc_events = 0;
354
355 TSPRINTF("starting event thread...\n");
356 if (kthread_create(PRI_NONE, 0, NULL, tslot_event_thread, sc,
357 &sc->sc_thread, "%s", device_xname(self)) != 0) {
358 panic("%s: unable to create event kthread",
359 device_xname(self));
360 }
361
362 sc->sc_pct = (pcmcia_chipset_tag_t)&tslot_functions;
363 sc->sc_active = 0;
364
365 /*
366 * Setup slots
367 */
368 TSPRINTF("mapping resources...\n");
369 for (slot = 0; slot < TS102_NUM_SLOTS; slot++) {
370 td = &sc->sc_slot[slot];
371 TSPRINTF("slot %d, ",slot);
372 for (rnum = 0; rnum < TS102_RANGE_CNT; rnum++) {
373 base = (slot * TS102_RANGE_CNT + rnum) * 5;
374 TSPRINTF("%d: %08x %08x ",rnum,ranges[base + 3],
375 ranges[base + 4]);
376 if(sbus_bus_map(sc->sc_bustag,
377 sa->sa_slot,
378 ranges[base+3],
379 TS102_ARBITRARY_MAP_SIZE,
380 0, &hrang) != 0) {
381 printf("%s: cannot map registers\n",
382 device_xname(self));
383 return;
384 }
385 TSPRINTF("%08x: %08x ",(uint32_t)ranges[base + 3],
386 (uint32_t)hrang);
387 td->td_space[rnum] = hrang;
388 }
389 td->td_parent = sc;
390 td->td_pcmciat = tag;
391 td->td_softint = NULL;
392 td->td_regs = regs + slot * (TS102_REG_CARD_B_INT -
393 TS102_REG_CARD_A_INT);
394 td->td_slot = slot;
395
396 TSPRINTF("resetting slot %d %d\n", slot, (int)td->td_regs);
397 tslot_reset(td, TS102_ARBITRARY_MAP_SIZE);
398 }
399 }
400
401 static void
tslot_reset(struct tslot_data * td,uint32_t iosize)402 tslot_reset(struct tslot_data *td, uint32_t iosize)
403 {
404 struct pcmciabus_attach_args paa;
405 int ctl, status;
406
407 paa.paa_busname = "pcmcia";
408 paa.pct = (pcmcia_chipset_tag_t)td->td_parent->sc_pct;
409 paa.pch = (pcmcia_chipset_handle_t)td;
410
411 td->td_pcmcia = config_found(td->td_parent->sc_dev, &paa, tslot_print,
412 CFARGS_NONE);
413
414 if (td->td_pcmcia == NULL) {
415 /*
416 * If no pcmcia attachment, power down the slot.
417 */
418 tslot_slot_disable((pcmcia_chipset_handle_t)td);
419 return;
420 }
421
422 /*
423 * Initialize the slot
424 */
425
426 ctl = TSLOT_READ(td, TS102_REG_CARD_A_CTL);
427
428 /* force low addresses */
429 ctl &= ~(TS102_CARD_CTL_AA_MASK | TS102_CARD_CTL_IA_MASK);
430
431 /* Put SBus and PCMCIA in their respective endian mode */
432 ctl |= TS102_CARD_CTL_SBLE; /* this is not what it looks like! */
433 ctl &= ~TS102_CARD_CTL_PCMBE; /* default */
434
435 /* disable read ahead and address increment */
436 ctl &= ~TS102_CARD_CTL_RAHD;
437 ctl |= TS102_CARD_CTL_INCDIS;
438
439 /* power on */
440 ctl &= ~TS102_CARD_CTL_PWRD;
441 TSLOT_WRITE(td, TS102_REG_CARD_A_CTL, ctl);
442 TSPRINTF("ctl: %x\n", ctl);
443
444 /*
445 * Enable interrupt upon insertion/removal
446 */
447
448 TSLOT_WRITE(td, TS102_REG_CARD_A_INT,
449 TS102_CARD_INT_MASK_CARDDETECT_STATUS);
450
451 status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
452 if (status & TS102_CARD_STS_PRES) {
453 td->td_status = TS_CARD;
454 pcmcia_card_attach(td->td_pcmcia);
455 } else
456 td->td_status = 0;
457 }
458
459 /* XXX there ought to be a common function for this... */
460 static int
tslot_print(void * aux,const char * description)461 tslot_print(void *aux, const char *description)
462 {
463 struct pcmciabus_attach_args *paa = aux;
464 struct tslot_data *td = (struct tslot_data *)paa->pch;
465
466 printf(" socket %d", td->td_slot);
467 return (UNCONF);
468 }
469
470 /*
471 * PCMCIA Helpers
472 */
473
474 static int
tslot_io_alloc(pcmcia_chipset_handle_t pch,bus_addr_t start,bus_size_t size,bus_size_t align,struct pcmcia_io_handle * pih)475 tslot_io_alloc(pcmcia_chipset_handle_t pch, bus_addr_t start, bus_size_t size,
476 bus_size_t align, struct pcmcia_io_handle *pih)
477 {
478 struct tslot_data *td = (struct tslot_data *)pch;
479
480 #ifdef TSLOT_DEBUG
481 printf("[io alloc %x]", (uint32_t)size);
482 #endif
483
484 pih->iot = td->td_pcmciat;
485 pih->ioh = td->td_space[TS102_RANGE_IO];
486 pih->addr = start;
487 pih->size = size;
488 pih->flags = 0;
489
490 return (0);
491 }
492
493 static void
tslot_io_free(pcmcia_chipset_handle_t pch,struct pcmcia_io_handle * pih)494 tslot_io_free(pcmcia_chipset_handle_t pch, struct pcmcia_io_handle *pih)
495 {
496 #ifdef TSLOT_DEBUG
497 printf("[io free]");
498 #endif
499 }
500
501 static int
tslot_io_map(pcmcia_chipset_handle_t pch,int width,bus_addr_t offset,bus_size_t size,struct pcmcia_io_handle * pih,int * windowp)502 tslot_io_map(pcmcia_chipset_handle_t pch, int width, bus_addr_t offset,
503 bus_size_t size, struct pcmcia_io_handle *pih, int *windowp)
504 {
505 struct tslot_data *td = (struct tslot_data *)pch;
506
507 #ifdef TSLOT_DEBUG
508 printf("[io map %x/%x", (uint32_t)offset, (uint32_t)size);
509 #endif
510
511 pih->iot = td->td_pcmciat;
512 if (bus_space_subregion(pih->iot, td->td_space[TS102_RANGE_IO],
513 offset, size, &pih->ioh) != 0)
514 printf("io_map failed, offset %x\n", (uint32_t)offset);
515 *windowp = 0; /* TS102_RANGE_IO */
516
517 #ifdef TSLOT_DEBUG
518 printf("->%x/%x]", (uint32_t)pih->ioh, (uint32_t)size);
519 {
520 int addr, line;
521 for( addr = offset; addr < (offset + size); addr += 16) {
522 printf("%04x:", addr);
523 for(line = addr; line < (addr + 16); line += 2) {
524 printf(" %04x", bus_space_read_2(pih->iot,
525 pih->ioh, line));
526 }
527 printf("\n");
528 }
529 }
530 #endif
531
532 return (0);
533 }
534
535 static void
tslot_io_unmap(pcmcia_chipset_handle_t pch,int win)536 tslot_io_unmap(pcmcia_chipset_handle_t pch, int win)
537 {
538 #ifdef TSLOT_DEBUG
539 struct tslot_data *td = (struct tslot_data *)pch;
540
541 printf("[io unmap]");
542 {
543 int addr, line, offset = 0, size = 0x80;
544 for (addr = offset; addr < (offset + size); addr += 16) {
545 printf("%04x:", addr);
546 for (line = addr; line < (addr + 16); line += 2){
547 printf(" %04x", bus_space_read_2(td->td_pcmciat,
548 td->td_space[2], line));
549 }
550 printf("\n");
551 }
552 }
553 #endif
554 }
555
556 static int
tslot_mem_alloc(pcmcia_chipset_handle_t pch,bus_size_t size,struct pcmcia_mem_handle * pmh)557 tslot_mem_alloc(pcmcia_chipset_handle_t pch, bus_size_t size,
558 struct pcmcia_mem_handle *pmh)
559 {
560 struct tslot_data *td = (struct tslot_data *)pch;
561
562 #ifdef TSLOT_DEBUG
563 printf("[mem alloc %x]", (uint32_t)size);
564 #endif
565 pmh->memt = td->td_pcmciat;
566 pmh->size = size;
567 pmh->addr = 0;
568 pmh->mhandle = 0;
569 pmh->realsize = size; /* nothing so far! */
570
571 return (0);
572 }
573
574 static void
tslot_mem_free(pcmcia_chipset_handle_t pch,struct pcmcia_mem_handle * pmh)575 tslot_mem_free(pcmcia_chipset_handle_t pch, struct pcmcia_mem_handle *pmh)
576 {
577 #ifdef TSLOT_DEBUG
578 printf("[mem free]");
579 #endif
580 }
581
582 static int
tslot_mem_map(pcmcia_chipset_handle_t pch,int kind,bus_addr_t addr,bus_size_t size,struct pcmcia_mem_handle * pmh,bus_size_t * offsetp,int * windowp)583 tslot_mem_map(pcmcia_chipset_handle_t pch, int kind, bus_addr_t addr,
584 bus_size_t size, struct pcmcia_mem_handle *pmh, bus_size_t *offsetp,
585 int *windowp)
586 {
587 struct tslot_data *td = (struct tslot_data *)pch;
588 int slot;
589
590 slot = kind & PCMCIA_MEM_ATTR ? TS102_RANGE_ATTR : TS102_RANGE_COMMON;
591 #ifdef TSLOT_DEBUG
592 printf("[mem map %d %x/%x", slot, (uint32_t)addr, (uint32_t)size);
593 #endif
594
595 pmh->memt = td->td_parent->sc_bustag;
596 if (bus_space_subregion(pmh->memt, td->td_space[slot],
597 addr, size, &pmh->memh) != 0)
598 printf("mem_map failed, offset %x\n", (uint32_t)addr);
599 pmh->realsize = TS102_ARBITRARY_MAP_SIZE - addr;
600 pmh->size = size;
601 *offsetp = 0;
602 *windowp = 0;
603
604 #ifdef TSLOT_DEBUG
605 printf("->%x/%x]", (uint32_t)pmh->memh, (uint32_t)size);
606 #endif
607
608 return (0);
609 }
610
611 static void
tslot_mem_unmap(pcmcia_chipset_handle_t pch,int win)612 tslot_mem_unmap(pcmcia_chipset_handle_t pch, int win)
613 {
614 #ifdef TSLOT_DEBUG
615 printf("[mem unmap %d]", win);
616 #endif
617 }
618
619 static void
tslot_slot_disable(pcmcia_chipset_handle_t pch)620 tslot_slot_disable(pcmcia_chipset_handle_t pch)
621 {
622 struct tslot_data *td = (struct tslot_data *)pch;
623 int status;
624
625 #ifdef TSLOT_DEBUG
626 printf("%s: disable slot %d\n",
627 device_xname(td->td_parent->sc_dev), td->td_slot);
628 #endif
629
630 status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
631
632 status &= ~TS102_CARD_STS_ACEN;
633
634 /*
635 * Disable interrupts, except for insertion.
636 */
637 TSLOT_WRITE(td, TS102_REG_CARD_A_INT,
638 TS102_CARD_INT_MASK_CARDDETECT_STATUS);
639
640 /*
641 * Power down the socket and disable access
642 */
643 status &= ~TS102_CARD_STS_ACEN;
644 status &= ~(TS102_CARD_STS_VPP1_MASK | TS102_CARD_STS_VPP2_MASK);
645 status |= TS102_CARD_STS_VCCEN;
646 TSLOT_WRITE(td, TS102_REG_CARD_A_STS, status);
647
648 /*
649 * wait 300ms until power fails (Tpf).
650 */
651 tslot_delay(td->td_parent, 300);
652 }
653
654 static void
tslot_slot_enable(pcmcia_chipset_handle_t pch)655 tslot_slot_enable(pcmcia_chipset_handle_t pch)
656 {
657 struct tslot_data *td = (struct tslot_data *)pch;
658 int status, intr, i;
659
660 #ifdef TSLOT_DEBUG
661 printf("%s: enable slot %d\n",
662 device_xname(td->td_parent->sc_dev), td->td_slot);
663 #endif
664
665 /* Power down the socket to reset it */
666 status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
667 TSPRINTF("status: %x\n", status);
668
669 status &= ~TS102_CARD_STS_ACEN;
670 status &= ~(TS102_CARD_STS_VPP1_MASK | TS102_CARD_STS_VPP2_MASK);
671 status |= TS102_CARD_STS_VCCEN;
672 TSLOT_WRITE(td, TS102_REG_CARD_A_STS, status);
673
674 /*
675 * wait 300ms until power fails (Tpf). Then, wait 100ms since we
676 * are changing Vcc (Toff).
677 */
678 tslot_delay(td->td_parent, 300 + 100);
679
680 /*
681 * Power on the card if not already done, and enable card access
682 */
683 status |= TS102_CARD_STS_ACEN;
684 status |= TS102_CARD_STS_VPP1_VCC;
685 status &= ~TS102_CARD_STS_VCCEN;
686 TSLOT_WRITE(td, TS102_REG_CARD_A_STS, status);
687
688 /*
689 * wait 100ms until power raise (Tpr) and 20ms to become
690 * stable (Tsu(Vcc)).
691 */
692 tslot_delay(td->td_parent, 100 + 20);
693
694 /*
695 * hold RESET at least 20us.
696 */
697 intr = TSLOT_READ(td, TS102_REG_CARD_A_INT);
698 delay(20);
699 TSLOT_WRITE(td, TS102_REG_CARD_A_INT,
700 intr & ~TS102_CARD_INT_SOFT_RESET);
701
702 /* wait 20ms as per pc card standard (r2.01) section 4.3.6 */
703 tslot_delay(td->td_parent, 20);
704
705 /* We need level-triggered interrupts for PC Card hardware */
706 TSLOT_WRITE(td, TS102_REG_CARD_A_STS,
707 TSLOT_READ(td, TS102_REG_CARD_A_STS) | TS102_CARD_STS_LVL);
708
709 /*
710 * Wait until the card is unbusy. If it is still busy after 3 seconds,
711 * give up. We could enable card interrupts and wait for the interrupt
712 * to happen when BUSY is released, but the interrupt could also be
713 * triggered by the card itself if it's an I/O card, so better poll
714 * here.
715 */
716 for (i = 30000; i != 0; i--) {
717 status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
718 /* If the card has been removed, abort */
719 if ((status & TS102_CARD_STS_PRES) == 0) {
720 tslot_slot_disable(pch);
721 return;
722 }
723 if (status & TS102_CARD_STS_RDY)
724 break;
725 else
726 delay(100);
727 }
728
729 if (i == 0) {
730 printf("%s: slot %d still busy after 3 seconds, status 0x%x\n",
731 device_xname(td->td_parent->sc_dev), td->td_slot,
732 TSLOT_READ(td, TS102_REG_CARD_A_STS));
733 return;
734 }
735 }
736 static void
tslot_event_thread(void * v)737 tslot_event_thread(void *v)
738 {
739 struct tslot_softc *sc = v;
740 struct tslot_data *td;
741 int s, status;
742 unsigned int socket;
743
744 #if NTCTRL > 0
745 int i;
746
747 /*
748 * First-time setup of our LCD symbol. When a card is present at boot
749 * time we won't detect a change here and therefore the LCD symbol won't
750 * light up.
751 */
752 for (i = 0; i < TS102_NUM_SLOTS; i++) {
753 td = &sc->sc_slot[i];
754 status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
755 tslot_update_lcd(sc, i, status & TS102_CARD_STS_PRES);
756 }
757 #endif
758
759 for (;;) {
760 s = splhigh();
761
762 if ((socket = ffs(sc->sc_events)) == 0) {
763 splx(s);
764 tsleep(&sc->sc_events, PWAIT, "tslot_event", hz * 30);
765 continue;
766 }
767 socket--;
768 sc->sc_events &= ~(1 << socket);
769 splx(s);
770
771 if (socket >= TS102_NUM_SLOTS) {
772 #ifdef DEBUG
773 printf("%s: invalid slot number %d\n",
774 device_xname(sc->sc_dev), socket);
775 #endif
776 continue;
777 }
778
779 td = &sc->sc_slot[socket];
780 status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
781
782 if (status & TS102_CARD_STS_PRES) {
783 /* Card insertion */
784 if ((td->td_status & TS_CARD) == 0) {
785 td->td_status |= TS_CARD;
786 tslot_update_lcd(sc, socket, 1);
787 pcmcia_card_attach(td->td_pcmcia);
788 }
789 } else {
790 /* Card removal */
791 if ((td->td_status & TS_CARD) != 0) {
792 tslot_update_lcd(sc, socket, 0);
793 td->td_status &= ~TS_CARD;
794 pcmcia_card_detach(td->td_pcmcia,
795 DETACH_FORCE);
796 }
797 }
798 }
799 }
800
801 /*
802 * Interrupt handling
803 */
804
805 static int
tslot_intr(void * v)806 tslot_intr(void *v)
807 {
808 struct tslot_softc *sc = v;
809 struct tslot_data *td;
810 int intregs[TS102_NUM_SLOTS], *intreg;
811 int i, s, rc = 0;
812
813 s = splhigh();
814
815 /*
816 * Scan slots, and acknowledge the interrupt if necessary first
817 */
818 for (i = 0; i < TS102_NUM_SLOTS; i++) {
819 td = &sc->sc_slot[i];
820 intreg = &intregs[i];
821 *intreg = TSLOT_READ(td, TS102_REG_CARD_A_INT);
822
823 /*
824 * Acknowledge all interrupt situations at once, even if they
825 * did not occur.
826 */
827 if ((*intreg & (TS102_CARD_INT_STATUS_IRQ |
828 TS102_CARD_INT_STATUS_WP_STATUS_CHANGED |
829 TS102_CARD_INT_STATUS_BATTERY_STATUS_CHANGED |
830 TS102_CARD_INT_STATUS_CARDDETECT_STATUS_CHANGED)) != 0) {
831 rc = 1;
832 TSLOT_WRITE(td, TS102_REG_CARD_A_INT, *intreg |
833 TS102_CARD_INT_RQST_IRQ |
834 TS102_CARD_INT_RQST_WP_STATUS_CHANGED |
835 TS102_CARD_INT_RQST_BATTERY_STATUS_CHANGED |
836 TS102_CARD_INT_RQST_CARDDETECT_STATUS_CHANGED);
837 }
838 }
839
840 #ifdef TSLOT_DEBUG
841 printf("tslot_intr: %x %x\n", intregs[0], intregs[1]);
842 #endif
843
844 /*
845 * Invoke the interrupt handler for each slot
846 */
847 for (i = 0; i < TS102_NUM_SLOTS; i++) {
848 td = &sc->sc_slot[i];
849 intreg = &intregs[i];
850
851 if ((*intreg & (TS102_CARD_INT_STATUS_IRQ |
852 TS102_CARD_INT_STATUS_WP_STATUS_CHANGED |
853 TS102_CARD_INT_STATUS_BATTERY_STATUS_CHANGED |
854 TS102_CARD_INT_STATUS_CARDDETECT_STATUS_CHANGED)) != 0)
855 tslot_slot_intr(td, *intreg);
856 }
857 splx(s);
858
859 return (rc);
860 }
861
862 static void
tslot_queue_event(struct tslot_softc * sc,int slot)863 tslot_queue_event(struct tslot_softc *sc, int slot)
864 {
865 int s;
866
867 s = splhigh();
868 sc->sc_events |= (1 << slot);
869 splx(s);
870 wakeup(&sc->sc_events);
871 }
872
873 static void
tslot_slot_intr(struct tslot_data * td,int intreg)874 tslot_slot_intr(struct tslot_data *td, int intreg)
875 {
876 struct tslot_softc *sc = td->td_parent;
877 int status, sockstat;
878 uint32_t ireg;
879
880 status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
881 #ifdef TSLOT_DEBUG
882 printf("%s: interrupt on socket %d ir %x sts %x\n",
883 device_xname(sc->sc_dev), td->td_slot, intreg, status);
884 #else
885 __USE(status);
886 #endif
887
888 sockstat = td->td_status;
889
890 /*
891 * The TS102 queues interrupt request, and may trigger an interrupt
892 * for a condition the driver does not want to receive anymore (for
893 * example, after a card gets removed).
894 * Thus, only proceed if the driver is currently allowing a particular
895 * condition.
896 */
897
898 if ((intreg & TS102_CARD_INT_STATUS_CARDDETECT_STATUS_CHANGED) != 0 &&
899 (intreg & TS102_CARD_INT_MASK_CARDDETECT_STATUS) != 0) {
900 tslot_queue_event(sc, td->td_slot);
901 #ifdef TSLOT_DEBUG
902 printf("%s: slot %d status changed from %d to %d\n",
903 device_xname(sc->sc_dev), td->td_slot, sockstat,
904 td->td_status);
905 #endif
906 /*
907 * Ignore extra interrupt bits, they are part of the change.
908 */
909 return;
910 }
911
912 if ((intreg & TS102_CARD_INT_STATUS_IRQ) != 0 &&
913 (intreg & TS102_CARD_INT_MASK_IRQ) != 0) {
914 /* ignore interrupts if we have a pending state change */
915 if (sc->sc_events & (1 << td->td_slot))
916 {
917 TSPRINTF("ev: %d\n", sc->sc_events);
918 return;
919 }
920 if ((sockstat & TS_CARD) == 0) {
921 printf("%s: spurious interrupt on slot %d isr %x\n",
922 device_xname(sc->sc_dev), td->td_slot, intreg);
923 return;
924 }
925
926 if (td->td_intr != NULL) {
927
928 if (td->td_softint != NULL)
929 sparc_softintr_schedule(td->td_softint);
930 /*
931 * Disable this sbus interrupt, until the soft-int
932 * handler had a chance to run
933 */
934 ireg = TSLOT_READ(td, TS102_REG_CARD_A_INT);
935 TSLOT_WRITE(td, TS102_REG_CARD_A_INT, ireg &
936 ~TS102_CARD_INT_MASK_IRQ);
937 }
938 }
939 }
940
941 static void
tslot_intr_disestablish(pcmcia_chipset_handle_t pch,void * ih)942 tslot_intr_disestablish(pcmcia_chipset_handle_t pch, void *ih)
943 {
944 struct tslot_data *td = (struct tslot_data *)pch;
945
946 td->td_intr = NULL;
947 td->td_intrarg = NULL;
948 if (td->td_softint) {
949 sparc_softintr_disestablish(td->td_softint);
950 td->td_softint = NULL;
951 }
952 }
953
954 const char *
tslot_intr_string(pcmcia_chipset_handle_t pch,void * ih)955 tslot_intr_string(pcmcia_chipset_handle_t pch, void *ih)
956 {
957 if (ih == NULL)
958 return ("couldn't establish interrupt");
959 else
960 return (""); /* nothing for now */
961 }
962
963 static void *
tslot_intr_establish(pcmcia_chipset_handle_t pch,struct pcmcia_function * pf,int ipl,int (* handler)(void *),void * arg)964 tslot_intr_establish(pcmcia_chipset_handle_t pch, struct pcmcia_function *pf,
965 int ipl, int (*handler)(void *), void *arg)
966 {
967 struct tslot_data *td = (struct tslot_data *)pch;
968
969 td->td_intr = handler;
970 td->td_intrarg = arg;
971 td->td_softint = sparc_softintr_establish(ipl, tslot_intr_dispatch, td);
972
973 return (td);
974 }
975
976 /*
977 * Softinterrupt called to invoke the real driver interrupt handler.
978 */
979 static void
tslot_intr_dispatch(void * arg)980 tslot_intr_dispatch(void *arg)
981 {
982 struct tslot_data *td = arg;
983 int s;
984 uint32_t ireg;
985
986 /* invoke driver handler */
987 td->td_intr(td->td_intrarg);
988
989 /* enable SBUS interrupts for pcmcia interrupts again */
990 s = splhigh();
991 ireg = TSLOT_READ(td, TS102_REG_CARD_A_INT);
992 TSLOT_WRITE(td, TS102_REG_CARD_A_INT, ireg | TS102_CARD_INT_MASK_IRQ);
993 splx(s);
994 }
995
996 static void
tslot_slot_settype(pcmcia_chipset_handle_t pch,int type)997 tslot_slot_settype(pcmcia_chipset_handle_t pch, int type)
998 {
999 struct tslot_data *td = (struct tslot_data *)pch;
1000 uint32_t reg;
1001
1002 /*
1003 * Enable the card interrupts if this is an I/O card.
1004 * Note that the TS102_CARD_STS_IO bit in the status register will
1005 * never get set, despite what the documentation says!
1006 */
1007 TSPRINTF("tslot_slot_settype(%d)\n",type);
1008 if (type == PCMCIA_IFTYPE_IO) {
1009 TSLOT_WRITE(td, TS102_REG_CARD_A_STS,
1010 TSLOT_READ(td, TS102_REG_CARD_A_STS) | TS102_CARD_STS_IO);
1011 TSLOT_WRITE(td, TS102_REG_CARD_A_INT,
1012 TS102_CARD_INT_MASK_CARDDETECT_STATUS |
1013 TS102_CARD_INT_MASK_IRQ);
1014 reg=TSLOT_READ(td, TS102_REG_CARD_A_STS);
1015 TSPRINTF("status: %x\n", reg);
1016 }
1017 }
1018
1019 static void
tslot_update_lcd(struct tslot_softc * sc,int socket,int status)1020 tslot_update_lcd(struct tslot_softc *sc, int socket, int status)
1021 {
1022 #if NTCTRL > 0
1023 int was = (sc->sc_active != 0), is;
1024 int mask = 1 << socket;
1025
1026 if (status > 0) {
1027 sc->sc_active |= mask;
1028 } else {
1029 sc->sc_active &= (mask ^ 3);
1030 }
1031 is = (sc->sc_active != 0);
1032 if (was != is) {
1033 tadpole_set_lcd(is, 0x40);
1034 }
1035 #endif
1036 }
1037
1038 /*
1039 * Delay and possibly yield CPU.
1040 * XXX - assumes a context
1041 */
1042 void
tslot_delay(struct tslot_softc * sc,unsigned int ms)1043 tslot_delay(struct tslot_softc *sc, unsigned int ms)
1044 {
1045 unsigned int ticks = mstohz(ms);
1046
1047 if (cold || ticks == 0) {
1048 delay(ms);
1049 return;
1050 }
1051
1052 #ifdef DIAGNOSTIC
1053 if (ticks > 60*hz)
1054 panic("tslot: preposterous delay: %u", ticks);
1055 #endif
1056 tsleep(sc, 0, "tslotdel", ticks);
1057 }
1058