ata-cbus.c revision 144397 
1/*-
2 * Copyright (c) 2002 - 2005 S�ren Schmidt <sos@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer,
10 *    without modification, immediately at the beginning of the file.
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 OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: head/sys/dev/ata/ata-cbus.c 144397 2005-03-31 15:05:40Z sos $");
31
32#include "opt_ata.h"
33#include <sys/param.h>
34#include <sys/systm.h>
35#include <sys/kernel.h>
36#include <sys/ata.h>
37#include <sys/bus.h>
38#include <sys/malloc.h>
39#include <sys/module.h>
40#include <sys/conf.h>
41#include <sys/sema.h>
42#include <sys/taskqueue.h>
43#include <vm/uma.h>
44#include <machine/resource.h>
45#include <machine/bus.h>
46#include <sys/rman.h>
47#include <isa/isavar.h>
48#include <dev/ata/ata-all.h>
49#include <ata_if.h>
50
51/* local vars */
52struct ata_cbus_controller {
53    struct resource *io;
54    struct resource *altio;
55    struct resource *bankio;
56    struct resource *irq;
57    void *ih;
58    struct mtx bank_mtx;
59    int locked_bank;
60    int restart_bank;
61    int hardware_bank;
62    struct {
63	void (*function)(void *);
64	void *argument;
65    } interrupt[2];
66};
67
68/* local prototypes */
69static void ata_cbus_intr(void *);
70static int ata_cbuschannel_banking(device_t dev, int flags);
71
72static int
73ata_cbus_probe(device_t dev)
74{
75    struct resource *io;
76    int rid;
77    u_long tmp;
78
79    /* dont probe PnP devices */
80    if (isa_get_vendorid(dev))
81	return (ENXIO);
82
83    /* allocate the ioport range */
84    rid = ATA_IOADDR_RID;
85    io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0,
86			    ATA_PC98_IOSIZE, RF_ACTIVE);
87    if (!io)
88	return ENOMEM;
89
90    /* calculate & set the altport range */
91    rid = ATA_PC98_ALTADDR_RID;
92    if (bus_get_resource(dev, SYS_RES_IOPORT, rid, &tmp, &tmp)) {
93	bus_set_resource(dev, SYS_RES_IOPORT, rid,
94			 rman_get_start(io)+ATA_PC98_ALTOFFSET, ATA_ALTIOSIZE);
95    }
96
97    /* calculate & set the bank range */
98    rid = ATA_PC98_BANKADDR_RID;
99    if (bus_get_resource(dev, SYS_RES_IOPORT, rid, &tmp, &tmp)) {
100	bus_set_resource(dev, SYS_RES_IOPORT, rid,
101			 ATA_PC98_BANK, ATA_PC98_BANKIOSIZE);
102    }
103
104    bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, io);
105    return 0;
106}
107
108static int
109ata_cbus_attach(device_t dev)
110{
111    struct ata_cbus_controller *ctlr = device_get_softc(dev);
112    int rid;
113
114    /* allocate resources */
115    rid = ATA_IOADDR_RID;
116    ctlr->io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0,
117				  ATA_PC98_IOSIZE, RF_ACTIVE);
118    if (!ctlr->io)
119       return ENOMEM;
120
121    rid = ATA_PC98_ALTADDR_RID;
122    ctlr->altio =
123	bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
124			   rman_get_start(ctlr->io) + ATA_PC98_ALTOFFSET, ~0,
125			   ATA_ALTIOSIZE, RF_ACTIVE);
126    if (!ctlr->altio) {
127	bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, ctlr->io);
128	return ENOMEM;
129    }
130
131    rid = ATA_PC98_BANKADDR_RID;
132    ctlr->bankio = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
133				      ATA_PC98_BANK, ~0,
134				      ATA_PC98_BANKIOSIZE, RF_ACTIVE);
135    if (!ctlr->bankio) {
136	bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, ctlr->io);
137	bus_release_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, ctlr->altio);
138	return ENOMEM;
139    }
140
141    rid = ATA_IRQ_RID;
142    if (!(ctlr->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
143					     RF_ACTIVE | RF_SHAREABLE))) {
144	device_printf(dev, "unable to alloc interrupt\n");
145	bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, ctlr->io);
146	bus_release_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, ctlr->altio);
147	bus_release_resource(dev, SYS_RES_IOPORT,
148			     ATA_PC98_BANKADDR_RID, ctlr->bankio);
149	return ENXIO;
150    }
151
152    if ((bus_setup_intr(dev, ctlr->irq, ATA_INTR_FLAGS,
153			ata_cbus_intr, ctlr, &ctlr->ih))) {
154	device_printf(dev, "unable to setup interrupt\n");
155	bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, ctlr->io);
156	bus_release_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, ctlr->altio);
157	bus_release_resource(dev, SYS_RES_IOPORT,
158			     ATA_PC98_BANKADDR_RID, ctlr->bankio);
159	bus_release_resource(dev, SYS_RES_IOPORT, ATA_IRQ_RID, ctlr->irq);
160	return ENXIO;
161    }
162
163    mtx_init(&ctlr->bank_mtx, "ATA cbus bank lock", NULL, MTX_DEF);
164    ctlr->hardware_bank = -1;
165    ctlr->locked_bank = -1;
166    ctlr->restart_bank = -1;
167
168    if (!device_add_child(dev, "ata", 0))
169	return ENOMEM;
170    if (!device_add_child(dev, "ata", 1))
171	return ENOMEM;
172
173    return bus_generic_attach(dev);
174}
175
176static struct resource *
177ata_cbus_alloc_resource(device_t dev, device_t child, int type, int *rid,
178			u_long start, u_long end, u_long count, u_int flags)
179{
180    struct ata_cbus_controller *ctlr = device_get_softc(dev);
181
182    if (type == SYS_RES_IOPORT) {
183	switch (*rid) {
184	case ATA_IOADDR_RID:
185	    return ctlr->io;
186	case ATA_ALTADDR_RID:
187	    return ctlr->altio;
188	}
189    }
190    if (type == SYS_RES_IRQ)
191	return ctlr->irq;
192    return 0;
193}
194
195static int
196ata_cbus_setup_intr(device_t dev, device_t child, struct resource *irq,
197	       int flags, driver_intr_t *intr, void *arg,
198	       void **cookiep)
199{
200    struct ata_cbus_controller *controller = device_get_softc(dev);
201    int unit = ((struct ata_channel *)device_get_softc(child))->unit;
202
203    controller->interrupt[unit].function = intr;
204    controller->interrupt[unit].argument = arg;
205    *cookiep = controller;
206
207    return 0;
208}
209
210static int
211ata_cbus_print_child(device_t dev, device_t child)
212{
213    struct ata_channel *ch = device_get_softc(child);
214    int retval = 0;
215
216    retval += bus_print_child_header(dev, child);
217    retval += printf(" at bank %d", ch->unit);
218    retval += bus_print_child_footer(dev, child);
219    return retval;
220}
221
222static void
223ata_cbus_intr(void *data)
224{
225    struct ata_cbus_controller *ctlr = data;
226    struct ata_channel *ch;
227    int unit;
228
229    for (unit = 0; unit < 2; unit++) {
230	if (!(ch = ctlr->interrupt[unit].argument))
231	    continue;
232	if (ata_cbuschannel_banking(ch->dev, ATA_LF_WHICH) == unit)
233	    ctlr->interrupt[unit].function(ch);
234    }
235}
236
237static device_method_t ata_cbus_methods[] = {
238    /* device interface */
239    DEVMETHOD(device_probe,             ata_cbus_probe),
240    DEVMETHOD(device_attach,            ata_cbus_attach),
241//  DEVMETHOD(device_detach,            ata_cbus_detach),
242
243    /* bus methods */
244    DEVMETHOD(bus_alloc_resource,       ata_cbus_alloc_resource),
245    DEVMETHOD(bus_setup_intr,           ata_cbus_setup_intr),
246    DEVMETHOD(bus_print_child,          ata_cbus_print_child),
247
248    { 0, 0 }
249};
250
251static driver_t ata_cbus_driver = {
252    "atacbus",
253    ata_cbus_methods,
254    sizeof(struct ata_cbus_controller),
255};
256
257static devclass_t ata_cbus_devclass;
258
259DRIVER_MODULE(atacbus, isa, ata_cbus_driver, ata_cbus_devclass, 0, 0);
260
261static int
262ata_cbuschannel_probe(device_t dev)
263{
264    struct ata_cbus_controller *ctlr = device_get_softc(device_get_parent(dev));
265    struct ata_channel *ch = device_get_softc(dev);
266    device_t *children;
267    int count, i;
268
269    /* find channel number on this controller */
270    device_get_children(device_get_parent(dev), &children, &count);
271    for (i = 0; i < count; i++) {
272	if (children[i] == dev)
273	    ch->unit = i;
274    }
275    free(children, M_TEMP);
276
277    /* setup the resource vectors */
278    for (i = ATA_DATA; i <= ATA_STATUS; i ++) {
279	ch->r_io[i].res = ctlr->io;
280	ch->r_io[i].offset = i << 1;
281    }
282    ch->r_io[ATA_ALTSTAT].res = ctlr->altio;
283    ch->r_io[ATA_ALTSTAT].offset = 0;
284
285    /* initialize softc for this channel */
286    ch->flags |= ATA_USE_16BIT;
287    ata_generic_hw(ch);
288    return ata_probe(dev);
289}
290
291static int
292ata_cbuschannel_banking(device_t dev, int flags)
293{
294    struct ata_cbus_controller *ctlr = device_get_softc(device_get_parent(dev));
295    struct ata_channel *ch = device_get_softc(dev);
296    int res;
297
298    mtx_lock(&ctlr->bank_mtx);
299    switch (flags) {
300    case ATA_LF_LOCK:
301	if (ctlr->locked_bank == -1)
302	    ctlr->locked_bank = ch->unit;
303	if (ctlr->locked_bank == ch->unit) {
304	    ctlr->hardware_bank = ch->unit;
305	    ATA_OUTB(ctlr->bankio, 0, ch->unit);
306	}
307	else
308	    ctlr->restart_bank = ch->unit;
309	break;
310
311    case ATA_LF_UNLOCK:
312	if (ctlr->locked_bank == ch->unit) {
313	    ctlr->locked_bank = -1;
314	    if (ctlr->restart_bank != -1) {
315		if ((ch = ctlr->interrupt[ctlr->restart_bank].argument)) {
316		    ctlr->restart_bank = -1;
317		    mtx_unlock(&ctlr->bank_mtx);
318		    ata_start(ch->dev);
319		    return -1;
320		}
321	    }
322	}
323	break;
324
325    case ATA_LF_WHICH:
326	break;
327    }
328    res = ctlr->locked_bank;
329    mtx_unlock(&ctlr->bank_mtx);
330    return res;
331}
332
333static device_method_t ata_cbuschannel_methods[] = {
334    /* device interface */
335    DEVMETHOD(device_probe,     ata_cbuschannel_probe),
336    DEVMETHOD(device_attach,    ata_attach),
337    DEVMETHOD(device_detach,    ata_detach),
338    DEVMETHOD(device_suspend,   ata_suspend),
339    DEVMETHOD(device_resume,    ata_resume),
340
341    /* ATA methods */
342    DEVMETHOD(ata_locking,      ata_cbuschannel_banking),
343
344    { 0, 0 }
345};
346
347static driver_t ata_cbuschannel_driver = {
348    "ata",
349    ata_cbuschannel_methods,
350    sizeof(struct ata_channel),
351};
352
353DRIVER_MODULE(ata, atacbus, ata_cbuschannel_driver, ata_devclass, 0, 0);
354MODULE_DEPEND(ata, ata, 1, 1, 1);
355