esp_pcmcia.c revision 1.18 
1/*	$NetBSD: esp_pcmcia.c,v 1.18 2004/08/10 07:04:19 mycroft Exp $	*/
2
3/*-
4 * Copyright (c) 2000, 2004 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Charles M. Hannum.
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. All advertising materials mentioning features or use of this software
19 *    must display the following acknowledgement:
20 *        This product includes software developed by the NetBSD
21 *        Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 *    contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38
39#include <sys/cdefs.h>
40__KERNEL_RCSID(0, "$NetBSD: esp_pcmcia.c,v 1.18 2004/08/10 07:04:19 mycroft Exp $");
41
42#include <sys/param.h>
43#include <sys/systm.h>
44#include <sys/device.h>
45#include <sys/buf.h>
46
47#include <machine/bus.h>
48#include <machine/intr.h>
49
50#include <dev/scsipi/scsi_all.h>
51#include <dev/scsipi/scsipi_all.h>
52#include <dev/scsipi/scsiconf.h>
53
54#include <dev/pcmcia/pcmciareg.h>
55#include <dev/pcmcia/pcmciavar.h>
56#include <dev/pcmcia/pcmciadevs.h>
57
58#include <dev/ic/ncr53c9xreg.h>
59#include <dev/ic/ncr53c9xvar.h>
60
61struct esp_pcmcia_softc {
62	struct ncr53c9x_softc	sc_ncr53c9x;	/* glue to MI code */
63
64	int		sc_active;		/* Pseudo-DMA state vars */
65	int		sc_tc;
66	int		sc_datain;
67	size_t		sc_dmasize;
68	size_t		sc_dmatrans;
69	char		**sc_dmaaddr;
70	size_t		*sc_pdmalen;
71
72	/* PCMCIA-specific goo. */
73	struct pcmcia_function *sc_pf;		/* our PCMCIA function */
74	void *sc_ih;				/* interrupt handler */
75#ifdef ESP_PCMCIA_POLL
76	struct callout sc_poll_ch;
77#endif
78	bus_space_tag_t	sc_iot;
79	bus_space_handle_t sc_ioh;
80
81	int sc_state;
82#define	ESP_PCMCIA_ATTACH1	1
83#define	ESP_PCMCIA_ATTACH2	2
84#define ESP_PCMCIA_ATTACHED	3
85};
86
87int	esp_pcmcia_match __P((struct device *, struct cfdata *, void *));
88int	esp_pcmcia_validate_config __P((struct pcmcia_config_entry *));
89void	esp_pcmcia_attach __P((struct device *, struct device *, void *));
90void	esp_pcmcia_init __P((struct esp_pcmcia_softc *));
91int	esp_pcmcia_detach __P((struct device *, int));
92int	esp_pcmcia_enable __P((struct device *, int));
93
94CFATTACH_DECL(esp_pcmcia, sizeof(struct esp_pcmcia_softc),
95    esp_pcmcia_match, esp_pcmcia_attach, esp_pcmcia_detach, NULL);
96
97/*
98 * Functions and the switch for the MI code.
99 */
100#ifdef ESP_PCMCIA_POLL
101void	esp_pcmcia_poll __P((void *));
102#endif
103u_char	esp_pcmcia_read_reg __P((struct ncr53c9x_softc *, int));
104void	esp_pcmcia_write_reg __P((struct ncr53c9x_softc *, int, u_char));
105int	esp_pcmcia_dma_isintr __P((struct ncr53c9x_softc *));
106void	esp_pcmcia_dma_reset __P((struct ncr53c9x_softc *));
107int	esp_pcmcia_dma_intr __P((struct ncr53c9x_softc *));
108int	esp_pcmcia_dma_setup __P((struct ncr53c9x_softc *, caddr_t *,
109	    size_t *, int, size_t *));
110void	esp_pcmcia_dma_go __P((struct ncr53c9x_softc *));
111void	esp_pcmcia_dma_stop __P((struct ncr53c9x_softc *));
112int	esp_pcmcia_dma_isactive __P((struct ncr53c9x_softc *));
113
114static const struct esp_pcmcia_product *
115    esp_pcmcia_lookup __P((struct pcmcia_attach_args *));
116
117struct ncr53c9x_glue esp_pcmcia_glue = {
118	esp_pcmcia_read_reg,
119	esp_pcmcia_write_reg,
120	esp_pcmcia_dma_isintr,
121	esp_pcmcia_dma_reset,
122	esp_pcmcia_dma_intr,
123	esp_pcmcia_dma_setup,
124	esp_pcmcia_dma_go,
125	esp_pcmcia_dma_stop,
126	esp_pcmcia_dma_isactive,
127	NULL,			/* gl_clear_latched_intr */
128};
129
130const struct esp_pcmcia_product {
131	const char	*epp_name;		/* product name */
132	u_int32_t	epp_vendor;		/* vendor ID */
133	u_int32_t	epp_product;		/* product ID */
134	const char	*epp_cisinfo[4];	/* CIS information */
135} esp_pcmcia_products[] = {
136	{ "",	PCMCIA_VENDOR_PANASONIC,
137	  PCMCIA_PRODUCT_PANASONIC_KXLC002,	PCMCIA_CIS_PANASONIC_KXLC002 },
138
139	{ "",	PCMCIA_VENDOR_RATOC,
140	  PCMCIA_PRODUCT_RATOC_REX_9530,	PCMCIA_CIS_RATOC_REX_9530 },
141
142	{ NULL }
143};
144
145static const struct esp_pcmcia_product *
146esp_pcmcia_lookup(pa)
147	struct pcmcia_attach_args *pa;
148{
149	const struct esp_pcmcia_product *epp;
150
151	for (epp = esp_pcmcia_products; epp->epp_name != NULL; epp++) {
152		/* match by CIS information */
153		if (pa->card->cis1_info[0] != NULL &&
154		    epp->epp_cisinfo[0] != NULL &&
155		    strcmp(pa->card->cis1_info[0], epp->epp_cisinfo[0]) == 0 &&
156		    pa->card->cis1_info[1] != NULL &&
157		    epp->epp_cisinfo[1] != NULL &&
158		    strcmp(pa->card->cis1_info[1], epp->epp_cisinfo[1]) == 0)
159			return (epp);
160
161		/* match by vendor/product id */
162		if (pa->manufacturer != PCMCIA_VENDOR_INVALID &&
163		    pa->manufacturer == epp->epp_vendor &&
164		    pa->product != PCMCIA_PRODUCT_INVALID &&
165		    pa->product == epp->epp_product)
166			return (epp);
167	}
168
169	return (NULL);
170}
171
172int
173esp_pcmcia_match(parent, match, aux)
174	struct device *parent;
175	struct cfdata *match;
176	void *aux;
177{
178	struct pcmcia_attach_args *pa = aux;
179
180	if (esp_pcmcia_lookup(pa) != NULL)
181		return (1);
182	return (0);
183}
184
185int
186esp_pcmcia_validate_config(cfe)
187	struct pcmcia_config_entry *cfe;
188{
189	if (cfe->iftype != PCMCIA_IFTYPE_IO ||
190	    cfe->num_memspace != 0 ||
191	    cfe->num_iospace != 1)
192		return (EINVAL);
193	return (0);
194}
195
196void
197esp_pcmcia_attach(parent, self, aux)
198	struct device *parent, *self;
199	void *aux;
200{
201	struct esp_pcmcia_softc *esc = (void *)self;
202	struct ncr53c9x_softc *sc = &esc->sc_ncr53c9x;
203	struct pcmcia_attach_args *pa = aux;
204	struct pcmcia_config_entry *cfe;
205	struct pcmcia_function *pf = pa->pf;
206	int error;
207
208	aprint_normal("\n");
209	esc->sc_pf = pf;
210
211	error = pcmcia_function_configure(pf, esp_pcmcia_validate_config);
212	if (error) {
213		aprint_error("%s: configure failed, error=%d\n", self->dv_xname,
214		    error);
215		return;
216	}
217
218	cfe = pf->cfe;
219	esc->sc_iot = cfe->iospace[0].handle.iot;
220	esc->sc_ioh = cfe->iospace[0].handle.ioh;
221	esp_pcmcia_init(esc);
222
223	error = esp_pcmcia_enable(self, 1);
224	if (error) {
225		aprint_error("%s: enable failed, error=%d\n", self->dv_xname,
226		    error);
227		goto fail;
228	}
229
230	sc->sc_adapter.adapt_minphys = minphys;
231	sc->sc_adapter.adapt_request = ncr53c9x_scsipi_request;
232	sc->sc_adapter.adapt_enable = esp_pcmcia_enable;
233
234	esc->sc_state = ESP_PCMCIA_ATTACH1;
235	ncr53c9x_attach(sc);
236	if (esc->sc_state == ESP_PCMCIA_ATTACH1)
237		esp_pcmcia_enable(self, 0);
238	esc->sc_state = ESP_PCMCIA_ATTACHED;
239	return;
240
241fail:
242	pcmcia_function_unconfigure(pf);
243}
244
245void
246esp_pcmcia_init(esc)
247	struct esp_pcmcia_softc *esc;
248{
249	struct ncr53c9x_softc *sc = &esc->sc_ncr53c9x;
250
251	/* id 7, clock 40M, parity ON, sync OFF, fast ON, slow ON */
252
253	sc->sc_glue = &esp_pcmcia_glue;
254
255#ifdef ESP_PCMCIA_POLL
256	callout_init(&esc->sc_poll_ch);
257#endif
258
259	sc->sc_rev = NCR_VARIANT_ESP406;
260	sc->sc_id = 7;
261	sc->sc_freq = 40;
262	/* try -PARENB -SLOW */
263	sc->sc_cfg1 = sc->sc_id | NCRCFG1_PARENB | NCRCFG1_SLOW;
264	/* try +FE */
265	sc->sc_cfg2 = NCRCFG2_SCSI2;
266	/* try -IDM -FSCSI -FCLK */
267	sc->sc_cfg3 = NCRESPCFG3_CDB | NCRESPCFG3_FCLK | NCRESPCFG3_IDM |
268	    NCRESPCFG3_FSCSI;
269	sc->sc_cfg4 = NCRCFG4_ACTNEG;
270	/* try +INTP */
271	sc->sc_cfg5 = NCRCFG5_CRS1 | NCRCFG5_AADDR | NCRCFG5_PTRINC;
272	sc->sc_minsync = 0;
273	sc->sc_maxxfer = 64 * 1024;
274}
275
276int
277esp_pcmcia_detach(self, flags)
278	struct device *self;
279	int flags;
280{
281	struct esp_pcmcia_softc *sc = (void *)self;
282	int error;
283
284	if (sc->sc_state != ESP_PCMCIA_ATTACHED)
285		return (0);
286
287	error = ncr53c9x_detach(&sc->sc_ncr53c9x, flags);
288	if (error)
289		return (error);
290
291	pcmcia_function_unconfigure(sc->sc_pf);
292
293	return (0);
294}
295
296int
297esp_pcmcia_enable(arg, onoff)
298	struct device *arg;
299	int onoff;
300{
301	struct esp_pcmcia_softc *sc = (void *)arg;
302
303	if (onoff) {
304		/*
305		 * If attach is in progress, we already have the device
306		 * powered up.
307		 */
308		if (sc->sc_state == ESP_PCMCIA_ATTACH1) {
309			sc->sc_state = ESP_PCMCIA_ATTACH2;
310		} else {
311#ifdef ESP_PCMCIA_POLL
312			callout_reset(&sc->sc_poll_ch, 1, esp_pcmcia_poll, sc);
313#else
314			/* Establish the interrupt handler. */
315			sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_BIO,
316			    ncr53c9x_intr, &sc->sc_ncr53c9x);
317			if (sc->sc_ih == NULL) {
318				printf("%s: couldn't establish interrupt handler\n",
319				    sc->sc_ncr53c9x.sc_dev.dv_xname);
320				return (EIO);
321			}
322#endif
323
324			if (pcmcia_function_enable(sc->sc_pf)) {
325				printf("%s: couldn't enable PCMCIA function\n",
326				    sc->sc_ncr53c9x.sc_dev.dv_xname);
327				pcmcia_intr_disestablish(sc->sc_pf,
328				    sc->sc_ih);
329				return (EIO);
330			}
331
332			/* Initialize only chip.  */
333			ncr53c9x_init(&sc->sc_ncr53c9x, 0);
334		}
335	} else {
336		pcmcia_function_disable(sc->sc_pf);
337#ifdef ESP_PCMCIA_POLL
338		callout_stop(&sc->sc_poll_ch);
339#else
340		pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
341		sc->sc_ih = 0;
342#endif
343	}
344
345	return (0);
346}
347
348#ifdef ESP_PCMCIA_POLL
349void
350esp_pcmcia_poll(arg)
351	void *arg;
352{
353	struct esp_pcmcia_softc *esc = arg;
354
355	(void) ncr53c9x_intr(&esc->sc_ncr53c9x);
356	callout_reset(&esc->sc_poll_ch, 1, esp_pcmcia_poll, esc);
357}
358#endif
359
360/*
361 * Glue functions.
362 */
363u_char
364esp_pcmcia_read_reg(sc, reg)
365	struct ncr53c9x_softc *sc;
366	int reg;
367{
368	struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
369	u_char v;
370
371	v = bus_space_read_1(esc->sc_iot, esc->sc_ioh, reg);
372	return v;
373}
374
375void
376esp_pcmcia_write_reg(sc, reg, val)
377	struct ncr53c9x_softc *sc;
378	int reg;
379	u_char val;
380{
381	struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
382	u_char v = val;
383
384	if (reg == NCR_CMD && v == (NCRCMD_TRANS|NCRCMD_DMA))
385		v = NCRCMD_TRANS;
386	bus_space_write_1(esc->sc_iot, esc->sc_ioh, reg, v);
387}
388
389int
390esp_pcmcia_dma_isintr(sc)
391	struct ncr53c9x_softc *sc;
392{
393
394	return NCR_READ_REG(sc, NCR_STAT) & NCRSTAT_INT;
395}
396
397void
398esp_pcmcia_dma_reset(sc)
399	struct ncr53c9x_softc *sc;
400{
401	struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
402
403	esc->sc_active = 0;
404	esc->sc_tc = 0;
405}
406
407int
408esp_pcmcia_dma_intr(sc)
409	struct ncr53c9x_softc *sc;
410{
411	struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
412	u_char	*p;
413	u_int	espphase, espstat, espintr;
414	int	cnt;
415
416	if (esc->sc_active == 0) {
417		printf("%s: dma_intr--inactive DMA\n", sc->sc_dev.dv_xname);
418		return -1;
419	}
420
421	if ((sc->sc_espintr & NCRINTR_BS) == 0) {
422		esc->sc_active = 0;
423		return 0;
424	}
425
426	cnt = *esc->sc_pdmalen;
427	if (*esc->sc_pdmalen == 0) {
428		printf("%s: data interrupt, but no count left\n",
429		    sc->sc_dev.dv_xname);
430	}
431
432	p = *esc->sc_dmaaddr;
433	espphase = sc->sc_phase;
434	espstat = (u_int) sc->sc_espstat;
435	espintr = (u_int) sc->sc_espintr;
436	do {
437		if (esc->sc_datain) {
438			*p++ = NCR_READ_REG(sc, NCR_FIFO);
439			cnt--;
440			if (espphase == DATA_IN_PHASE)
441				NCR_WRITE_REG(sc, NCR_CMD, NCRCMD_TRANS);
442			else
443				esc->sc_active = 0;
444		} else {
445			if (espphase == DATA_OUT_PHASE ||
446			    espphase == MESSAGE_OUT_PHASE) {
447				NCR_WRITE_REG(sc, NCR_FIFO, *p++);
448				cnt--;
449				NCR_WRITE_REG(sc, NCR_CMD, NCRCMD_TRANS);
450			} else
451				esc->sc_active = 0;
452		}
453
454		if (esc->sc_active) {
455			while (!(NCR_READ_REG(sc, NCR_STAT) & NCRSTAT_INT));
456			espstat = NCR_READ_REG(sc, NCR_STAT);
457			espintr = NCR_READ_REG(sc, NCR_INTR);
458			espphase = (espintr & NCRINTR_DIS)
459				    ? /* Disconnected */ BUSFREE_PHASE
460				    : espstat & PHASE_MASK;
461		}
462	} while (esc->sc_active && espintr);
463	sc->sc_phase = espphase;
464	sc->sc_espstat = (u_char) espstat;
465	sc->sc_espintr = (u_char) espintr;
466	*esc->sc_dmaaddr = p;
467	*esc->sc_pdmalen = cnt;
468
469	if (*esc->sc_pdmalen == 0)
470		esc->sc_tc = NCRSTAT_TC;
471	sc->sc_espstat |= esc->sc_tc;
472	return 0;
473}
474
475int
476esp_pcmcia_dma_setup(sc, addr, len, datain, dmasize)
477	struct ncr53c9x_softc *sc;
478	caddr_t *addr;
479	size_t *len;
480	int datain;
481	size_t *dmasize;
482{
483	struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
484
485	esc->sc_dmaaddr = addr;
486	esc->sc_pdmalen = len;
487	esc->sc_datain = datain;
488	esc->sc_dmasize = *dmasize;
489	esc->sc_tc = 0;
490
491	return 0;
492}
493
494void
495esp_pcmcia_dma_go(sc)
496	struct ncr53c9x_softc *sc;
497{
498	struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
499
500	esc->sc_active = 1;
501}
502
503void
504esp_pcmcia_dma_stop(sc)
505	struct ncr53c9x_softc *sc;
506{
507}
508
509int
510esp_pcmcia_dma_isactive(sc)
511	struct ncr53c9x_softc *sc;
512{
513	struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
514
515	return (esc->sc_active);
516}
517