1 /* $NetBSD: esp_pcmcia.c,v 1.39 2016/07/07 06:55:42 msaitoh 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 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: esp_pcmcia.c,v 1.39 2016/07/07 06:55:42 msaitoh Exp $");
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/device.h>
38 #include <sys/buf.h>
39
40 #include <sys/bus.h>
41 #include <sys/intr.h>
42
43 #include <dev/scsipi/scsi_all.h>
44 #include <dev/scsipi/scsipi_all.h>
45 #include <dev/scsipi/scsiconf.h>
46
47 #include <dev/pcmcia/pcmciareg.h>
48 #include <dev/pcmcia/pcmciavar.h>
49 #include <dev/pcmcia/pcmciadevs.h>
50
51 #include <dev/ic/ncr53c9xreg.h>
52 #include <dev/ic/ncr53c9xvar.h>
53
54 struct esp_pcmcia_softc {
55 struct ncr53c9x_softc sc_ncr53c9x; /* glue to MI code */
56
57 int sc_active; /* Pseudo-DMA state vars */
58 int sc_tc;
59 int sc_datain;
60 size_t sc_dmasize;
61 size_t sc_dmatrans;
62 uint8_t **sc_dmaaddr;
63 size_t *sc_pdmalen;
64
65 /* PCMCIA-specific goo. */
66 struct pcmcia_function *sc_pf; /* our PCMCIA function */
67 void *sc_ih; /* interrupt handler */
68 #ifdef ESP_PCMCIA_POLL
69 struct callout sc_poll_ch;
70 #endif
71 bus_space_tag_t sc_iot;
72 bus_space_handle_t sc_ioh;
73
74 int sc_state;
75 #define ESP_PCMCIA_ATTACHED 3
76 };
77
78 int esp_pcmcia_match(device_t, cfdata_t, void *);
79 int esp_pcmcia_validate_config(struct pcmcia_config_entry *);
80 void esp_pcmcia_attach(device_t, device_t, void *);
81 void esp_pcmcia_init(struct esp_pcmcia_softc *);
82 int esp_pcmcia_detach(device_t, int);
83 int esp_pcmcia_enable(device_t, int);
84
85 CFATTACH_DECL_NEW(esp_pcmcia, sizeof(struct esp_pcmcia_softc),
86 esp_pcmcia_match, esp_pcmcia_attach, esp_pcmcia_detach, NULL);
87
88 /*
89 * Functions and the switch for the MI code.
90 */
91 #ifdef ESP_PCMCIA_POLL
92 void esp_pcmcia_poll(void *);
93 #endif
94 uint8_t esp_pcmcia_read_reg(struct ncr53c9x_softc *, int);
95 void esp_pcmcia_write_reg(struct ncr53c9x_softc *, int, uint8_t);
96 int esp_pcmcia_dma_isintr(struct ncr53c9x_softc *);
97 void esp_pcmcia_dma_reset(struct ncr53c9x_softc *);
98 int esp_pcmcia_dma_intr(struct ncr53c9x_softc *);
99 int esp_pcmcia_dma_setup(struct ncr53c9x_softc *, uint8_t **,
100 size_t *, int, size_t *);
101 void esp_pcmcia_dma_go(struct ncr53c9x_softc *);
102 void esp_pcmcia_dma_stop(struct ncr53c9x_softc *);
103 int esp_pcmcia_dma_isactive(struct ncr53c9x_softc *);
104
105 const struct ncr53c9x_glue esp_pcmcia_glue = {
106 esp_pcmcia_read_reg,
107 esp_pcmcia_write_reg,
108 esp_pcmcia_dma_isintr,
109 esp_pcmcia_dma_reset,
110 esp_pcmcia_dma_intr,
111 esp_pcmcia_dma_setup,
112 esp_pcmcia_dma_go,
113 esp_pcmcia_dma_stop,
114 esp_pcmcia_dma_isactive,
115 NULL, /* gl_clear_latched_intr */
116 };
117
118 const struct pcmcia_product esp_pcmcia_products[] = {
119 { PCMCIA_VENDOR_PANASONIC, PCMCIA_PRODUCT_PANASONIC_KXLC002,
120 PCMCIA_CIS_PANASONIC_KXLC002 },
121
122 { PCMCIA_VENDOR_RATOC, PCMCIA_PRODUCT_RATOC_REX_9530,
123 PCMCIA_CIS_RATOC_REX_9530 },
124 };
125 const size_t esp_pcmcia_nproducts = __arraycount(esp_pcmcia_products);
126
127 int
esp_pcmcia_match(device_t parent,cfdata_t cf,void * aux)128 esp_pcmcia_match(device_t parent, cfdata_t cf, void *aux)
129 {
130 struct pcmcia_attach_args *pa = aux;
131
132 if (pcmcia_product_lookup(pa, esp_pcmcia_products, esp_pcmcia_nproducts,
133 sizeof(esp_pcmcia_products[0]), NULL))
134 return 1;
135 return 0;
136 }
137
138 int
esp_pcmcia_validate_config(struct pcmcia_config_entry * cfe)139 esp_pcmcia_validate_config(struct pcmcia_config_entry *cfe)
140 {
141
142 if (cfe->iftype != PCMCIA_IFTYPE_IO ||
143 cfe->num_memspace != 0 ||
144 cfe->num_iospace != 1)
145 return EINVAL;
146 return 0;
147 }
148
149 void
esp_pcmcia_attach(device_t parent,device_t self,void * aux)150 esp_pcmcia_attach(device_t parent, device_t self, void *aux)
151 {
152 struct esp_pcmcia_softc *esc = device_private(self);
153 struct ncr53c9x_softc *sc = &esc->sc_ncr53c9x;
154 struct pcmcia_attach_args *pa = aux;
155 struct pcmcia_config_entry *cfe;
156 struct pcmcia_function *pf = pa->pf;
157 int error;
158
159 sc->sc_dev = self;
160
161 esc->sc_pf = pf;
162
163 error = pcmcia_function_configure(pf, esp_pcmcia_validate_config);
164 if (error) {
165 aprint_error_dev(self, "configure failed, error=%d\n", error);
166 return;
167 }
168
169 cfe = pf->cfe;
170 esc->sc_iot = cfe->iospace[0].handle.iot;
171 esc->sc_ioh = cfe->iospace[0].handle.ioh;
172 esp_pcmcia_init(esc);
173
174 aprint_normal("%s", device_xname(self));
175
176 sc->sc_adapter.adapt_minphys = minphys;
177 sc->sc_adapter.adapt_request = ncr53c9x_scsipi_request;
178 sc->sc_adapter.adapt_enable = esp_pcmcia_enable;
179
180 ncr53c9x_attach(sc);
181 esc->sc_state = ESP_PCMCIA_ATTACHED;
182 }
183
184 void
esp_pcmcia_init(struct esp_pcmcia_softc * esc)185 esp_pcmcia_init(struct esp_pcmcia_softc *esc)
186 {
187 struct ncr53c9x_softc *sc = &esc->sc_ncr53c9x;
188
189 /* id 7, clock 40M, parity ON, sync OFF, fast ON, slow ON */
190
191 sc->sc_glue = &esp_pcmcia_glue;
192
193 #ifdef ESP_PCMCIA_POLL
194 callout_init(&esc->sc_poll_ch, 0);
195 #endif
196
197 sc->sc_rev = NCR_VARIANT_ESP406;
198 sc->sc_id = 7;
199 sc->sc_freq = 40;
200 /* try -PARENB -SLOW */
201 sc->sc_cfg1 = sc->sc_id | NCRCFG1_PARENB | NCRCFG1_SLOW;
202 /* try +FE */
203 sc->sc_cfg2 = NCRCFG2_SCSI2;
204 /* try -IDM -FSCSI -FCLK */
205 sc->sc_cfg3 = NCRESPCFG3_CDB | NCRESPCFG3_FCLK | NCRESPCFG3_IDM |
206 NCRESPCFG3_FSCSI;
207 sc->sc_cfg4 = NCRCFG4_ACTNEG;
208 /* try +INTP */
209 sc->sc_cfg5 = NCRCFG5_CRS1 | NCRCFG5_AADDR | NCRCFG5_PTRINC;
210 sc->sc_minsync = 0;
211 sc->sc_maxxfer = 64 * 1024;
212 }
213
214 int
esp_pcmcia_detach(device_t self,int flags)215 esp_pcmcia_detach(device_t self, int flags)
216 {
217 struct esp_pcmcia_softc *sc = device_private(self);
218 int error;
219
220 if (sc->sc_state != ESP_PCMCIA_ATTACHED)
221 return 0;
222
223 error = ncr53c9x_detach(&sc->sc_ncr53c9x, flags);
224 if (error)
225 return error;
226
227 pcmcia_function_unconfigure(sc->sc_pf);
228
229 return 0;
230 }
231
232 int
esp_pcmcia_enable(device_t self,int onoff)233 esp_pcmcia_enable(device_t self, int onoff)
234 {
235 struct esp_pcmcia_softc *sc = device_private(self);
236 int error;
237
238 if (onoff) {
239 #ifdef ESP_PCMCIA_POLL
240 callout_reset(&sc->sc_poll_ch, 1, esp_pcmcia_poll, sc);
241 #else
242 /* Establish the interrupt handler. */
243 sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_BIO,
244 ncr53c9x_intr, &sc->sc_ncr53c9x);
245 if (!sc->sc_ih)
246 return EIO;
247 #endif
248
249 error = pcmcia_function_enable(sc->sc_pf);
250 if (error) {
251 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
252 sc->sc_ih = 0;
253 return error;
254 }
255
256 /* Initialize only chip. */
257 ncr53c9x_init(&sc->sc_ncr53c9x, 0);
258 } else {
259 pcmcia_function_disable(sc->sc_pf);
260 #ifdef ESP_PCMCIA_POLL
261 callout_stop(&sc->sc_poll_ch);
262 #else
263 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
264 sc->sc_ih = 0;
265 #endif
266 }
267
268 return 0;
269 }
270
271 #ifdef ESP_PCMCIA_POLL
272 void
esp_pcmcia_poll(void * arg)273 esp_pcmcia_poll(void *arg)
274 {
275 struct esp_pcmcia_softc *esc = arg;
276
277 (void)ncr53c9x_intr(&esc->sc_ncr53c9x);
278 callout_reset(&esc->sc_poll_ch, 1, esp_pcmcia_poll, esc);
279 }
280 #endif
281
282 /*
283 * Glue functions.
284 */
285 uint8_t
esp_pcmcia_read_reg(struct ncr53c9x_softc * sc,int reg)286 esp_pcmcia_read_reg(struct ncr53c9x_softc *sc, int reg)
287 {
288 struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
289
290 return bus_space_read_1(esc->sc_iot, esc->sc_ioh, reg);
291 }
292
293 void
esp_pcmcia_write_reg(struct ncr53c9x_softc * sc,int reg,uint8_t val)294 esp_pcmcia_write_reg(struct ncr53c9x_softc *sc, int reg, uint8_t val)
295 {
296 struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
297 uint8_t v = val;
298
299 if (reg == NCR_CMD && v == (NCRCMD_TRANS|NCRCMD_DMA))
300 v = NCRCMD_TRANS;
301 bus_space_write_1(esc->sc_iot, esc->sc_ioh, reg, v);
302 }
303
304 int
esp_pcmcia_dma_isintr(struct ncr53c9x_softc * sc)305 esp_pcmcia_dma_isintr(struct ncr53c9x_softc *sc)
306 {
307
308 return NCR_READ_REG(sc, NCR_STAT) & NCRSTAT_INT;
309 }
310
311 void
esp_pcmcia_dma_reset(struct ncr53c9x_softc * sc)312 esp_pcmcia_dma_reset(struct ncr53c9x_softc *sc)
313 {
314 struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
315
316 esc->sc_active = 0;
317 esc->sc_tc = 0;
318 }
319
320 int
esp_pcmcia_dma_intr(struct ncr53c9x_softc * sc)321 esp_pcmcia_dma_intr(struct ncr53c9x_softc *sc)
322 {
323 struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
324 uint8_t *p;
325 u_int espphase, espstat, espintr;
326 int cnt;
327
328 if (esc->sc_active == 0) {
329 printf("%s: dma_intr--inactive DMA\n",
330 device_xname(sc->sc_dev));
331 return -1;
332 }
333
334 if ((sc->sc_espintr & NCRINTR_BS) == 0) {
335 esc->sc_active = 0;
336 return 0;
337 }
338
339 cnt = *esc->sc_pdmalen;
340 if (*esc->sc_pdmalen == 0) {
341 printf("%s: data interrupt, but no count left\n",
342 device_xname(sc->sc_dev));
343 }
344
345 p = *esc->sc_dmaaddr;
346 espphase = sc->sc_phase;
347 espstat = (u_int)sc->sc_espstat;
348 espintr = (u_int)sc->sc_espintr;
349 do {
350 if (esc->sc_datain) {
351 *p++ = NCR_READ_REG(sc, NCR_FIFO);
352 cnt--;
353 if (espphase == DATA_IN_PHASE)
354 NCR_WRITE_REG(sc, NCR_CMD, NCRCMD_TRANS);
355 else
356 esc->sc_active = 0;
357 } else {
358 if (espphase == DATA_OUT_PHASE ||
359 espphase == MESSAGE_OUT_PHASE) {
360 NCR_WRITE_REG(sc, NCR_FIFO, *p++);
361 cnt--;
362 NCR_WRITE_REG(sc, NCR_CMD, NCRCMD_TRANS);
363 } else
364 esc->sc_active = 0;
365 }
366
367 if (esc->sc_active) {
368 while ((NCR_READ_REG(sc, NCR_STAT) & NCRSTAT_INT) == 0)
369 ;
370 espstat = NCR_READ_REG(sc, NCR_STAT);
371 espintr = NCR_READ_REG(sc, NCR_INTR);
372 espphase = (espintr & NCRINTR_DIS)
373 ? /* Disconnected */ BUSFREE_PHASE
374 : espstat & PHASE_MASK;
375 }
376 } while (esc->sc_active && espintr);
377 sc->sc_phase = espphase;
378 sc->sc_espstat = (uint8_t)espstat;
379 sc->sc_espintr = (uint8_t)espintr;
380 *esc->sc_dmaaddr = p;
381 *esc->sc_pdmalen = cnt;
382
383 if (*esc->sc_pdmalen == 0)
384 esc->sc_tc = NCRSTAT_TC;
385 sc->sc_espstat |= esc->sc_tc;
386 return 0;
387 }
388
389 int
esp_pcmcia_dma_setup(struct ncr53c9x_softc * sc,uint8_t ** addr,size_t * len,int datain,size_t * dmasize)390 esp_pcmcia_dma_setup(struct ncr53c9x_softc *sc, uint8_t **addr, size_t *len,
391 int datain, size_t *dmasize)
392 {
393 struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
394
395 esc->sc_dmaaddr = addr;
396 esc->sc_pdmalen = len;
397 esc->sc_datain = datain;
398 esc->sc_dmasize = *dmasize;
399 esc->sc_tc = 0;
400
401 return 0;
402 }
403
404 void
esp_pcmcia_dma_go(struct ncr53c9x_softc * sc)405 esp_pcmcia_dma_go(struct ncr53c9x_softc *sc)
406 {
407 struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
408
409 esc->sc_active = 1;
410 }
411
412 void
esp_pcmcia_dma_stop(struct ncr53c9x_softc * sc)413 esp_pcmcia_dma_stop(struct ncr53c9x_softc *sc)
414 {
415 }
416
417 int
esp_pcmcia_dma_isactive(struct ncr53c9x_softc * sc)418 esp_pcmcia_dma_isactive(struct ncr53c9x_softc *sc)
419 {
420 struct esp_pcmcia_softc *esc = (struct esp_pcmcia_softc *)sc;
421
422 return esc->sc_active;
423 }
424