Synchronize various changes from FreeBSD. This is not exhaustive but gets
[dragonfly.git] / sys / dev / disk / nata / ata-chipset.c
1 /*-
2  * Copyright (c) 1998 - 2006 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  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/dev/ata/ata-chipset.c,v 1.196 2007/04/08 19:18:51 sos Exp $
27  * $DragonFly: src/sys/dev/disk/nata/ata-chipset.c,v 1.13 2008/03/24 06:41:56 dillon Exp $
28  */
29
30 #include "opt_ata.h"
31
32 #include <sys/param.h>
33 #include <sys/bus.h>
34 #include <sys/bus_dma.h>
35 #include <sys/bus_resource.h>
36 #include <sys/callout.h>
37 #include <sys/endian.h>
38 #include <sys/libkern.h>
39 #include <sys/lock.h>           /* for {get,rel}_mplock() */
40 #include <sys/malloc.h>
41 #include <sys/nata.h>
42 #include <sys/queue.h>
43 #include <sys/rman.h>
44 #include <sys/spinlock.h>
45 #include <sys/spinlock2.h>
46 #include <sys/systm.h>
47 #include <sys/taskqueue.h>
48
49 #include <machine/bus_dma.h>
50
51 #include <bus/pci/pcireg.h>
52 #include <bus/pci/pcivar.h>
53
54 #include "ata-all.h"
55 #include "ata-pci.h"
56 #include "ata_if.h"
57
58 /* local prototypes */
59 /* ata-chipset.c */
60 static int ata_generic_chipinit(device_t dev);
61 static void ata_generic_intr(void *data);
62 static void ata_generic_setmode(device_t dev, int mode);
63 static void ata_sata_phy_check_events(device_t dev);
64 static void ata_sata_phy_event(void *context, int dummy);
65 static int ata_sata_phy_reset(device_t dev);
66 static int ata_sata_connect(struct ata_channel *ch);
67 static void ata_sata_setmode(device_t dev, int mode);
68 static int ata_request2fis_h2d(struct ata_request *request, u_int8_t *fis);
69 static int ata_ahci_chipinit(device_t dev);
70 static int ata_ahci_allocate(device_t dev);
71 static int ata_ahci_status(device_t dev);
72 static int ata_ahci_begin_transaction(struct ata_request *request);
73 static int ata_ahci_end_transaction(struct ata_request *request);
74 static void ata_ahci_reset(device_t dev);
75 static void ata_ahci_dmasetprd(void *xsc, bus_dma_segment_t *segs, int nsegs, int error);
76 static void ata_ahci_dmainit(device_t dev);
77 static int ata_ahci_setup_fis(struct ata_ahci_cmd_tab *ctp, struct ata_request *request);
78 static int ata_acard_chipinit(device_t dev);
79 static int ata_acard_allocate(device_t dev);
80 static int ata_acard_status(device_t dev);
81 static void ata_acard_850_setmode(device_t dev, int mode);
82 static void ata_acard_86X_setmode(device_t dev, int mode);
83 static int ata_ali_chipinit(device_t dev);
84 static int ata_ali_allocate(device_t dev);
85 static int ata_ali_sata_allocate(device_t dev);
86 static void ata_ali_reset(device_t dev);
87 static void ata_ali_setmode(device_t dev, int mode);
88 static int ata_amd_chipinit(device_t dev);
89 static int ata_ati_chipinit(device_t dev);
90 static void ata_ati_setmode(device_t dev, int mode);
91 static int ata_cyrix_chipinit(device_t dev);
92 static void ata_cyrix_setmode(device_t dev, int mode);
93 static int ata_cypress_chipinit(device_t dev);
94 static void ata_cypress_setmode(device_t dev, int mode);
95 static int ata_highpoint_chipinit(device_t dev);
96 static int ata_highpoint_allocate(device_t dev);
97 static void ata_highpoint_setmode(device_t dev, int mode);
98 static int ata_highpoint_check_80pin(device_t dev, int mode);
99 static int ata_intel_chipinit(device_t dev);
100 static int ata_intel_allocate(device_t dev);
101 static void ata_intel_reset(device_t dev);
102 static void ata_intel_old_setmode(device_t dev, int mode);
103 static void ata_intel_new_setmode(device_t dev, int mode);
104 static int ata_intel_31244_allocate(device_t dev);
105 static int ata_intel_31244_status(device_t dev);
106 static int ata_intel_31244_command(struct ata_request *request);
107 static void ata_intel_31244_reset(device_t dev);
108 static int ata_ite_chipinit(device_t dev);
109 static void ata_ite_setmode(device_t dev, int mode);
110 static int ata_jmicron_chipinit(device_t dev);
111 static int ata_jmicron_allocate(device_t dev);
112 static void ata_jmicron_reset(device_t dev);
113 static void ata_jmicron_dmainit(device_t dev);
114 static void ata_jmicron_setmode(device_t dev, int mode);
115 static int ata_marvell_pata_chipinit(device_t dev);
116 static int ata_marvell_pata_allocate(device_t dev);
117 static void ata_marvell_pata_setmode(device_t dev, int mode);
118 static int ata_marvell_edma_chipinit(device_t dev);
119 static int ata_marvell_edma_allocate(device_t dev);
120 static int ata_marvell_edma_status(device_t dev);
121 static int ata_marvell_edma_begin_transaction(struct ata_request *request);
122 static int ata_marvell_edma_end_transaction(struct ata_request *request);
123 static void ata_marvell_edma_reset(device_t dev);
124 static void ata_marvell_edma_dmasetprd(void *xsc, bus_dma_segment_t *segs, int nsegs, int error);
125 static void ata_marvell_edma_dmainit(device_t dev);
126 static int ata_national_chipinit(device_t dev);
127 static void ata_national_setmode(device_t dev, int mode);
128 static int ata_netcell_chipinit(device_t dev);
129 static int ata_netcell_allocate(device_t dev);
130 static int ata_nvidia_chipinit(device_t dev);
131 static int ata_nvidia_allocate(device_t dev);
132 static int ata_nvidia_status(device_t dev);
133 static void ata_nvidia_reset(device_t dev);
134 static int ata_promise_chipinit(device_t dev);
135 static int ata_promise_allocate(device_t dev);
136 static int ata_promise_status(device_t dev);
137 static int ata_promise_dmastart(device_t dev);
138 static int ata_promise_dmastop(device_t dev);
139 static void ata_promise_dmareset(device_t dev);
140 static void ata_promise_dmainit(device_t dev);
141 static void ata_promise_setmode(device_t dev, int mode);
142 static int ata_promise_tx2_allocate(device_t dev);
143 static int ata_promise_tx2_status(device_t dev);
144 static int ata_promise_mio_allocate(device_t dev);
145 static void ata_promise_mio_intr(void *data);
146 static int ata_promise_mio_status(device_t dev);
147 static int ata_promise_mio_command(struct ata_request *request);
148 static void ata_promise_mio_reset(device_t dev);
149 static void ata_promise_mio_dmainit(device_t dev);
150 static void ata_promise_mio_setmode(device_t dev, int mode);
151 static void ata_promise_sx4_intr(void *data);
152 static int ata_promise_sx4_command(struct ata_request *request);
153 static int ata_promise_apkt(u_int8_t *bytep, struct ata_request *request);
154 static void ata_promise_queue_hpkt(struct ata_pci_controller *ctlr, u_int32_t hpkt);
155 static void ata_promise_next_hpkt(struct ata_pci_controller *ctlr);
156 static int ata_serverworks_chipinit(device_t dev);
157 static int ata_serverworks_allocate(device_t dev);
158 static void ata_serverworks_setmode(device_t dev, int mode);
159 static int ata_sii_chipinit(device_t dev);
160 static int ata_cmd_allocate(device_t dev);
161 static int ata_cmd_status(device_t dev);
162 static void ata_cmd_setmode(device_t dev, int mode);
163 static int ata_sii_allocate(device_t dev);
164 static int ata_sii_status(device_t dev);
165 static void ata_sii_reset(device_t dev);
166 static void ata_sii_setmode(device_t dev, int mode);
167 static int ata_siiprb_allocate(device_t dev);
168 static int ata_siiprb_status(device_t dev);
169 static int ata_siiprb_begin_transaction(struct ata_request *request);
170 static int ata_siiprb_end_transaction(struct ata_request *request);
171 static void ata_siiprb_reset(device_t dev);
172 static void ata_siiprb_dmasetprd(void *xsc, bus_dma_segment_t *segs, int nsegs, int error);
173 static void ata_siiprb_dmainit(device_t dev);
174 static int ata_sis_chipinit(device_t dev);
175 static int ata_sis_allocate(device_t dev);
176 static void ata_sis_reset(device_t dev);
177 static void ata_sis_setmode(device_t dev, int mode);
178 static int ata_via_chipinit(device_t dev);
179 static int ata_via_allocate(device_t dev);
180 static void ata_via_reset(device_t dev);
181 static void ata_via_setmode(device_t dev, int mode);
182 static void ata_via_southbridge_fixup(device_t dev);
183 static void ata_via_family_setmode(device_t dev, int mode);
184 static struct ata_chip_id *ata_match_chip(device_t dev, struct ata_chip_id *index);
185 static struct ata_chip_id *ata_find_chip(device_t dev, struct ata_chip_id *index, int slot);
186 static int ata_setup_interrupt(device_t dev);
187 static int ata_serialize(device_t dev, int flags);
188 static void ata_print_cable(device_t dev, u_int8_t *who);
189 static int ata_atapi(device_t dev);
190 static int ata_check_80pin(device_t dev, int mode);
191 static int ata_mode2idx(int mode);
192
193
194 /*
195  * generic ATA support functions
196  */
197 int
198 ata_generic_ident(device_t dev)
199 {
200     struct ata_pci_controller *ctlr = device_get_softc(dev);
201     char buffer[64];
202
203     ksnprintf(buffer, sizeof(buffer),
204               "%s ATA controller", ata_pcivendor2str(dev));
205     device_set_desc_copy(dev, buffer);
206     ctlr->chipinit = ata_generic_chipinit;
207     return 0;
208 }
209
210 static int
211 ata_generic_chipinit(device_t dev)
212 {
213     struct ata_pci_controller *ctlr = device_get_softc(dev);
214
215     if (ata_setup_interrupt(dev))
216         return ENXIO;
217     ctlr->setmode = ata_generic_setmode;
218     return 0;
219 }
220
221 static void
222 ata_generic_intr(void *data)
223 {
224     struct ata_pci_controller *ctlr = data;
225     struct ata_channel *ch;
226     int unit;
227
228     for (unit = 0; unit < ctlr->channels; unit++) {
229         if ((ch = ctlr->interrupt[unit].argument))
230             ctlr->interrupt[unit].function(ch);
231     }
232 }
233
234 static void
235 ata_generic_setmode(device_t dev, int mode)
236 {
237     struct ata_device *atadev = device_get_softc(dev);
238
239     mode = ata_limit_mode(dev, mode, ATA_UDMA2);
240     mode = ata_check_80pin(dev, mode);
241     if (!ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode))
242         atadev->mode = mode;
243 }
244
245
246 /*
247  * SATA support functions
248  */
249 static void
250 ata_sata_phy_check_events(device_t dev)
251 {
252     struct ata_channel *ch = device_get_softc(dev);
253     u_int32_t error = ATA_IDX_INL(ch, ATA_SERROR);
254
255     /* clear error bits/interrupt */
256     ATA_IDX_OUTL(ch, ATA_SERROR, error);
257
258     /* do we have any events flagged ? */
259     if (error) {
260         struct ata_connect_task *tp;
261         u_int32_t status = ATA_IDX_INL(ch, ATA_SSTATUS);
262
263         /* if we have a connection event deal with it */
264         if ((error & ATA_SE_PHY_CHANGED) &&
265             (tp = (struct ata_connect_task *)
266                   kmalloc(sizeof(struct ata_connect_task),
267                          M_ATA, M_INTWAIT | M_ZERO))) {
268
269             if (((status & ATA_SS_CONWELL_MASK) == ATA_SS_CONWELL_GEN1) ||
270                 ((status & ATA_SS_CONWELL_MASK) == ATA_SS_CONWELL_GEN2)) {
271                 if (bootverbose)
272                     device_printf(ch->dev, "CONNECT requested\n");
273                 tp->action = ATA_C_ATTACH;
274             }
275             else {
276                 if (bootverbose)
277                     device_printf(ch->dev, "DISCONNECT requested\n");
278                 tp->action = ATA_C_DETACH;
279             }
280             tp->dev = ch->dev;
281             TASK_INIT(&tp->task, 0, ata_sata_phy_event, tp);
282             taskqueue_enqueue(taskqueue_thread[mycpuid], &tp->task);
283         }
284     }
285 }
286
287 static void
288 ata_sata_phy_event(void *context, int dummy)
289 {
290     struct ata_connect_task *tp = (struct ata_connect_task *)context;
291     struct ata_channel *ch = device_get_softc(tp->dev);
292     device_t *children;
293     int nchildren, i;
294
295     get_mplock();
296     if (tp->action == ATA_C_ATTACH) {
297         if (bootverbose)
298             device_printf(tp->dev, "CONNECTED\n");
299         ATA_RESET(tp->dev);
300         ata_identify(tp->dev);
301     }
302     if (tp->action == ATA_C_DETACH) {
303         if (!device_get_children(tp->dev, &children, &nchildren)) {
304             for (i = 0; i < nchildren; i++)
305                 if (children[i])
306                     device_delete_child(tp->dev, children[i]);
307             kfree(children, M_TEMP);
308         }    
309         spin_lock_wr(&ch->state_mtx);
310         ch->state = ATA_IDLE;
311         spin_unlock_wr(&ch->state_mtx);
312         if (bootverbose)
313             device_printf(tp->dev, "DISCONNECTED\n");
314     }
315     rel_mplock();
316     kfree(tp, M_ATA);
317 }
318
319 static int
320 ata_sata_phy_reset(device_t dev)
321 {
322     struct ata_channel *ch = device_get_softc(dev);
323     int loop, retry;
324
325     if ((ATA_IDX_INL(ch, ATA_SCONTROL) & ATA_SC_DET_MASK) == ATA_SC_DET_IDLE)
326         return ata_sata_connect(ch);
327
328     for (retry = 0; retry < 10; retry++) {
329         for (loop = 0; loop < 10; loop++) {
330             ATA_IDX_OUTL(ch, ATA_SCONTROL, ATA_SC_DET_RESET);
331             ata_udelay(100);
332             if ((ATA_IDX_INL(ch, ATA_SCONTROL) &
333                 ATA_SC_DET_MASK) == ATA_SC_DET_RESET)
334                 break;
335         }
336         ata_udelay(5000);
337         for (loop = 0; loop < 10; loop++) {
338             ATA_IDX_OUTL(ch, ATA_SCONTROL, ATA_SC_DET_IDLE |
339                                            ATA_SC_IPM_DIS_PARTIAL |
340                                            ATA_SC_IPM_DIS_SLUMBER);
341             ata_udelay(100);
342             if ((ATA_IDX_INL(ch, ATA_SCONTROL) & ATA_SC_DET_MASK) == 0)
343                 return ata_sata_connect(ch);
344         }
345     }
346     return 0;
347 }
348
349 static int
350 ata_sata_connect(struct ata_channel *ch)
351 {
352     u_int32_t status;
353     int timeout;
354
355     /* wait up to 1 second for "connect well" */
356     for (timeout = 0; timeout < 100 ; timeout++) {
357         status = ATA_IDX_INL(ch, ATA_SSTATUS);
358         if ((status & ATA_SS_CONWELL_MASK) == ATA_SS_CONWELL_GEN1 ||
359             (status & ATA_SS_CONWELL_MASK) == ATA_SS_CONWELL_GEN2)
360             break;
361         ata_udelay(10000);
362     }
363     if (timeout >= 100) {
364         if (bootverbose)
365             device_printf(ch->dev, "SATA connect status=%08x\n", status);
366         return 0;
367     }
368
369     if (bootverbose)
370         device_printf(ch->dev, "SATA connect time=%dms\n", timeout * 10);
371
372     /* clear SATA error register */
373     ATA_IDX_OUTL(ch, ATA_SERROR, ATA_IDX_INL(ch, ATA_SERROR));
374
375     return 1;
376 }
377
378 static void
379 ata_sata_setmode(device_t dev, int mode)
380 {
381     struct ata_device *atadev = device_get_softc(dev);
382
383     /*
384      * if we detect that the device isn't a real SATA device we limit 
385      * the transfer mode to UDMA5/ATA100.
386      * this works around the problems some devices has with the 
387      * Marvell 88SX8030 SATA->PATA converters and UDMA6/ATA133.
388      */
389     if (atadev->param.satacapabilities != 0x0000 &&
390         atadev->param.satacapabilities != 0xffff) {
391         struct ata_channel *ch = device_get_softc(device_get_parent(dev));
392
393         /* on some drives we need to set the transfer mode */
394         ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0,
395                        ata_limit_mode(dev, mode, ATA_UDMA6));
396
397         /* query SATA STATUS for the speed */
398         if (ch->r_io[ATA_SSTATUS].res && 
399            ((ATA_IDX_INL(ch, ATA_SSTATUS) & ATA_SS_CONWELL_MASK) ==
400             ATA_SS_CONWELL_GEN2))
401             atadev->mode = ATA_SA300;
402         else 
403             atadev->mode = ATA_SA150;
404     }
405     else {
406         mode = ata_limit_mode(dev, mode, ATA_UDMA5);
407         if (!ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode))
408             atadev->mode = mode;
409     }
410 }
411
412 static int
413 ata_request2fis_h2d(struct ata_request *request, u_int8_t *fis)
414 {
415     struct ata_device *atadev = device_get_softc(request->dev);
416
417     if (request->flags & ATA_R_ATAPI) {
418         fis[0] = 0x27;  /* host to device */
419         fis[1] = 0x80;  /* command FIS (note PM goes here) */
420         fis[2] = ATA_PACKET_CMD;
421         if (request->flags & (ATA_R_READ | ATA_R_WRITE))
422             fis[3] = ATA_F_DMA;
423         else {
424             fis[5] = request->transfersize;
425             fis[6] = request->transfersize >> 8;
426         }
427         fis[7] = ATA_D_LBA | atadev->unit;
428         fis[15] = ATA_A_4BIT;
429         return 20;
430     }
431     else {
432         ata_modify_if_48bit(request);
433         fis[0] = 0x27;  /* host to device */
434         fis[1] = 0x80;  /* command FIS (note PM goes here) */
435         fis[2] = request->u.ata.command;
436         fis[3] = request->u.ata.feature;
437         fis[4] = request->u.ata.lba;
438         fis[5] = request->u.ata.lba >> 8;
439         fis[6] = request->u.ata.lba >> 16;
440         fis[7] = ATA_D_LBA | atadev->unit;
441         if (!(atadev->flags & ATA_D_48BIT_ACTIVE))
442             fis[7] |= (request->u.ata.lba >> 24 & 0x0f);
443         fis[8] = request->u.ata.lba >> 24;
444         fis[9] = request->u.ata.lba >> 32; 
445         fis[10] = request->u.ata.lba >> 40; 
446         fis[11] = request->u.ata.feature >> 8;
447         fis[12] = request->u.ata.count;
448         fis[13] = request->u.ata.count >> 8;
449         fis[15] = ATA_A_4BIT;
450         return 20;
451     }
452     return 0;
453 }
454
455 /*
456  * AHCI v1.x compliant SATA chipset support functions
457  */
458 int
459 ata_ahci_ident(device_t dev)
460 {
461     struct ata_pci_controller *ctlr = device_get_softc(dev);
462     static struct ata_chip_id id = {0, 0, 0, 0x00, ATA_SA300, "AHCI"};
463     char buffer[64];
464
465     if (pci_read_config(dev, PCIR_PROGIF, 1) != PCIP_STORAGE_SATA_AHCI_1_0)
466         return ENXIO;
467
468     if (bootverbose)
469         ksnprintf(buffer, sizeof(buffer), "%s (ID=%08x) AHCI controller",
470                   ata_pcivendor2str(dev), pci_get_devid(dev));
471     else
472         ksnprintf(buffer, sizeof(buffer), "%s AHCI controller",
473                   ata_pcivendor2str(dev));
474     device_set_desc_copy(dev, buffer);
475     ctlr->chip = &id;
476     ctlr->chipinit = ata_ahci_chipinit;
477     return 0;
478 }
479
480
481 /*
482  * AHCI v1.x compliant SATA chipset support functions
483  */
484 int
485 ata_ahci_chipinit(device_t dev)
486 {
487     struct ata_pci_controller *ctlr = device_get_softc(dev);
488     u_int32_t version;
489     int unit;
490
491     /* enable AHCI mode */
492     ATA_OUTL(ctlr->r_res2, ATA_AHCI_GHC, ATA_AHCI_GHC_AE);
493
494     /* reset AHCI controller */
495     ATA_OUTL(ctlr->r_res2, ATA_AHCI_GHC, ATA_AHCI_GHC_HR);
496     DELAY(1000000);
497     if (ATA_INL(ctlr->r_res2, ATA_AHCI_GHC) & ATA_AHCI_GHC_HR) {
498         bus_release_resource(dev, ctlr->r_type2, ctlr->r_rid2, ctlr->r_res2);
499         device_printf(dev, "AHCI controller reset failure\n");
500         return ENXIO;
501     }
502
503     /* reenable AHCI mode */
504     ATA_OUTL(ctlr->r_res2, ATA_AHCI_GHC, ATA_AHCI_GHC_AE);
505
506     /* get the number of HW channels */
507     ctlr->channels =
508         MAX(flsl(ATA_INL(ctlr->r_res2, ATA_AHCI_PI)), 
509             (ATA_INL(ctlr->r_res2, ATA_AHCI_CAP) & ATA_AHCI_NPMASK) + 1);
510
511     /* disable interrupt sources and clear interrupts */
512     for (unit = 0; unit < ctlr->channels; unit++) {
513         int offset = unit << 7;
514         ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_IE + offset, 0);
515         ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_IS + offset, -1);
516     }
517     ATA_OUTL(ctlr->r_res2, ATA_AHCI_IS, ATA_INL(ctlr->r_res2, ATA_AHCI_IS));
518
519     /* enable AHCI interrupts */
520     ATA_OUTL(ctlr->r_res2, ATA_AHCI_GHC,
521              ATA_INL(ctlr->r_res2, ATA_AHCI_GHC) | ATA_AHCI_GHC_IE);
522
523     ctlr->reset = ata_ahci_reset;
524     ctlr->dmainit = ata_ahci_dmainit;
525     ctlr->allocate = ata_ahci_allocate;
526     ctlr->setmode = ata_sata_setmode;
527
528     /* enable PCI interrupt */
529     pci_write_config(dev, PCIR_COMMAND,
530                      pci_read_config(dev, PCIR_COMMAND, 2) & ~0x0400, 2);
531
532     /* announce we support the HW */
533     version = ATA_INL(ctlr->r_res2, ATA_AHCI_VS);
534     device_printf(dev,
535                   "AHCI Version %x%x.%x%x controller with %d ports detected\n",
536                   (version >> 24) & 0xff, (version >> 16) & 0xff,
537                   (version >> 8) & 0xff, version & 0xff,
538                   (ATA_INL(ctlr->r_res2, ATA_AHCI_CAP) & ATA_AHCI_NPMASK) + 1);
539     return 0;
540 }
541
542 static int
543 ata_ahci_allocate(device_t dev)
544 {
545     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
546     struct ata_channel *ch = device_get_softc(dev);
547     u_int64_t work;
548     int offset = ch->unit << 7;
549
550     /* set the SATA resources */
551     ch->r_io[ATA_SSTATUS].res = ctlr->r_res2;
552     ch->r_io[ATA_SSTATUS].offset = ATA_AHCI_P_SSTS + offset;
553     ch->r_io[ATA_SERROR].res = ctlr->r_res2;
554     ch->r_io[ATA_SERROR].offset = ATA_AHCI_P_SERR + offset;
555     ch->r_io[ATA_SCONTROL].res = ctlr->r_res2;
556     ch->r_io[ATA_SCONTROL].offset = ATA_AHCI_P_SCTL + offset;
557     ch->r_io[ATA_SACTIVE].res = ctlr->r_res2;
558     ch->r_io[ATA_SACTIVE].offset = ATA_AHCI_P_SACT + offset;
559
560     ch->hw.status = ata_ahci_status;
561     ch->hw.begin_transaction = ata_ahci_begin_transaction;
562     ch->hw.end_transaction = ata_ahci_end_transaction;
563     ch->hw.command = NULL;      /* not used here */
564
565     /* setup work areas */
566     work = ch->dma->work_bus + ATA_AHCI_CL_OFFSET;
567     ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CLB + offset, work & 0xffffffff);
568     ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CLBU + offset, work >> 32);
569
570     work = ch->dma->work_bus + ATA_AHCI_FB_OFFSET;
571     ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_FB + offset, work & 0xffffffff); 
572     ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_FBU + offset, work >> 32);
573
574     /* enable wanted port interrupts */
575     ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_IE + offset,
576              (ATA_AHCI_P_IX_CPD | ATA_AHCI_P_IX_TFE | ATA_AHCI_P_IX_HBF |
577               ATA_AHCI_P_IX_HBD | ATA_AHCI_P_IX_IF | ATA_AHCI_P_IX_OF |
578               ATA_AHCI_P_IX_PRC | ATA_AHCI_P_IX_PC | ATA_AHCI_P_IX_DP |
579               ATA_AHCI_P_IX_UF | ATA_AHCI_P_IX_SDB | ATA_AHCI_P_IX_DS |
580               ATA_AHCI_P_IX_PS | ATA_AHCI_P_IX_DHR));
581
582     /* start operations on this channel */
583     ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CMD + offset,
584              (ATA_AHCI_P_CMD_ACTIVE | ATA_AHCI_P_CMD_FRE |
585               ATA_AHCI_P_CMD_POD | ATA_AHCI_P_CMD_SUD | ATA_AHCI_P_CMD_ST));
586     return 0;
587 }
588
589 static int
590 ata_ahci_status(device_t dev)
591 {
592     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
593     struct ata_channel *ch = device_get_softc(dev);
594     u_int32_t action = ATA_INL(ctlr->r_res2, ATA_AHCI_IS);
595     int offset = ch->unit << 7;
596     int tag = 0;
597
598     if (action & (1 << ch->unit)) {
599         u_int32_t istatus = ATA_INL(ctlr->r_res2, ATA_AHCI_P_IS + offset);
600         u_int32_t cstatus = ATA_INL(ctlr->r_res2, ATA_AHCI_P_CI + offset);
601
602         /* clear interrupt(s) */
603         ATA_OUTL(ctlr->r_res2, ATA_AHCI_IS, action & (1 << ch->unit));
604         ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_IS + offset, istatus);
605
606         /* do we have any PHY events ? */
607         /* XXX SOS check istatus phy bits */
608         ata_sata_phy_check_events(dev);
609
610         /* do we have a potentially hanging engine to take care of? */
611         if ((istatus & 0x78400050) && (cstatus & (1 << tag))) {
612  
613             u_int32_t cmd = ATA_INL(ctlr->r_res2, ATA_AHCI_P_CMD + offset);
614             int timeout = 0;
615  
616             /* kill off all activity on this channel */
617             ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CMD + offset,
618                      cmd & ~(ATA_AHCI_P_CMD_FRE | ATA_AHCI_P_CMD_ST));
619  
620             /* XXX SOS this is not entirely wrong */
621             do {
622                 DELAY(1000);
623                 if (timeout++ > 500) {
624                     device_printf(dev, "stopping AHCI engine failed\n");
625                     break;
626                 }
627             } while (ATA_INL(ctlr->r_res2,
628                              ATA_AHCI_P_CMD + offset) & ATA_AHCI_P_CMD_CR);
629  
630             /* start operations on this channel */
631             ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CMD + offset,
632                      cmd | (ATA_AHCI_P_CMD_FRE | ATA_AHCI_P_CMD_ST));
633  
634             return 1;
635         }
636         else
637             return (!(cstatus & (1 << tag)));
638     }
639     return 0;
640 }
641
642 /* must be called with ATA channel locked and state_mtx held */
643 static int
644 ata_ahci_begin_transaction(struct ata_request *request)
645 {
646     struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
647     struct ata_channel *ch = device_get_softc(device_get_parent(request->dev));
648     struct ata_ahci_cmd_tab *ctp;
649     struct ata_ahci_cmd_list *clp;
650     int offset = ch->unit << 7;
651     int tag = 0, entries = 0;
652     int fis_size;
653
654     /* get a piece of the workspace for this request */
655     ctp = (struct ata_ahci_cmd_tab *)
656           (ch->dma->work + ATA_AHCI_CT_OFFSET + (ATA_AHCI_CT_SIZE * tag));
657
658     /* setup the FIS for this request */
659     if (!(fis_size = ata_ahci_setup_fis(ctp, request))) {
660         device_printf(request->dev, "setting up SATA FIS failed\n");
661         request->result = EIO;
662         return ATA_OP_FINISHED;
663     }
664
665     /* if request moves data setup and load SG list */
666     if (request->flags & (ATA_R_READ | ATA_R_WRITE)) {
667         if (ch->dma->load(ch->dev, request->data, request->bytecount,
668                           request->flags & ATA_R_READ,
669                           ctp->prd_tab, &entries)) {
670             device_printf(request->dev, "setting up DMA failed\n");
671             request->result = EIO;
672             return ATA_OP_FINISHED;
673         }
674     }
675
676     /* setup the command list entry */
677     clp = (struct ata_ahci_cmd_list *)
678           (ch->dma->work + ATA_AHCI_CL_OFFSET + (ATA_AHCI_CL_SIZE * tag));
679
680     clp->prd_length = entries;
681     clp->cmd_flags = (request->flags & ATA_R_WRITE ? (1<<6) : 0) |
682                      (request->flags & ATA_R_ATAPI ? ((1<<5) | (1<<7)) : 0) |
683                      (fis_size / sizeof(u_int32_t));
684     clp->bytecount = 0;
685     clp->cmd_table_phys = htole64(ch->dma->work_bus + ATA_AHCI_CT_OFFSET +
686                                   (ATA_AHCI_CT_SIZE * tag));
687
688     /* clear eventual ACTIVE bit */
689     ATA_IDX_OUTL(ch, ATA_SACTIVE, ATA_IDX_INL(ch, ATA_SACTIVE) & (1 << tag));
690
691     /* set command type bit */
692     if (request->flags & ATA_R_ATAPI)
693         ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CMD + offset,
694                  ATA_INL(ctlr->r_res2, ATA_AHCI_P_CMD + offset) |
695                  ATA_AHCI_P_CMD_ATAPI);
696     else
697         ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CMD + offset,
698                  ATA_INL(ctlr->r_res2, ATA_AHCI_P_CMD + offset) &
699                  ~ATA_AHCI_P_CMD_ATAPI);
700
701     /* issue command to controller */
702     ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CI + offset, (1 << tag));
703
704     if (!(request->flags & ATA_R_ATAPI)) {
705         /* device reset doesn't interrupt */
706         if (request->u.ata.command == ATA_DEVICE_RESET) {
707             u_int32_t tf_data;
708             int timeout = 1000000;
709
710             do {
711                 DELAY(10);
712                 tf_data = ATA_INL(ctlr->r_res2, ATA_AHCI_P_TFD + (ch->unit<<7));
713             } while ((tf_data & ATA_S_BUSY) && timeout--);
714             if (bootverbose)
715                 device_printf(ch->dev, "device_reset timeout=%dus\n",
716                               (1000000-timeout)*10);
717             request->status = tf_data;
718             if (request->status & ATA_S_ERROR)
719                 request->error = tf_data >> 8;
720             return ATA_OP_FINISHED;
721         }
722     }
723
724     /* start the timeout */
725     callout_reset(&request->callout, request->timeout * hz,
726                   (timeout_t*)ata_timeout, request);
727     return ATA_OP_CONTINUES;
728 }
729
730 /* must be called with ATA channel locked and state_mtx held */
731 static int
732 ata_ahci_end_transaction(struct ata_request *request)
733 {
734     struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
735     struct ata_channel *ch = device_get_softc(device_get_parent(request->dev));
736     struct ata_ahci_cmd_list *clp;
737     u_int32_t tf_data;
738     int offset = ch->unit << 7;
739     int tag = 0;
740
741     /* kill the timeout */
742     callout_stop(&request->callout);
743
744     /* get status */
745     tf_data = ATA_INL(ctlr->r_res2, ATA_AHCI_P_TFD + offset);
746     request->status = tf_data;
747
748     /* if error status get details */
749     if (request->status & ATA_S_ERROR)  
750         request->error = tf_data >> 8;
751
752     /* record how much data we actually moved */
753     clp = (struct ata_ahci_cmd_list *)
754           (ch->dma->work + ATA_AHCI_CL_OFFSET + (ATA_AHCI_CL_SIZE * tag));
755     request->donecount = clp->bytecount;
756
757     /* release SG list etc */
758     ch->dma->unload(ch->dev);
759
760     return ATA_OP_FINISHED;
761 }
762
763 static void
764 ata_ahci_reset(device_t dev)
765 {
766     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
767     struct ata_channel *ch = device_get_softc(dev);
768     u_int32_t cmd, signature;
769     int offset = ch->unit << 7;
770     int timeout;
771
772     if (!(ATA_INL(ctlr->r_res2, ATA_AHCI_PI) & (1 << ch->unit))) {
773         device_printf(dev, "port not implemented\n");
774         return;
775     }
776     ch->devices = 0;
777
778     /* kill off all activity on this channel */
779     cmd = ATA_INL(ctlr->r_res2, ATA_AHCI_P_CMD + offset);
780     ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CMD + offset,
781              cmd & ~(ATA_AHCI_P_CMD_FRE | ATA_AHCI_P_CMD_ST));
782
783     /* XXX SOS this is not entirely wrong */
784     timeout = 0;
785     do {
786         DELAY(1000);
787         if (timeout++ > 500) {
788             device_printf(dev, "stopping AHCI engine failed\n");
789             break;
790         }
791     }
792     while (ATA_INL(ctlr->r_res2, ATA_AHCI_P_CMD + offset) & ATA_AHCI_P_CMD_CR);
793
794     /* issue Command List Override if supported */ 
795     if (ATA_INL(ctlr->r_res2, ATA_AHCI_CAP) & ATA_AHCI_CAP_CLO) {
796         cmd = ATA_INL(ctlr->r_res2, ATA_AHCI_P_CMD + offset);
797         cmd |= ATA_AHCI_P_CMD_CLO;
798         ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CMD + offset, cmd);
799         timeout = 0;
800         do {
801             DELAY(1000);
802             if (timeout++ > 500) {
803                 device_printf(dev, "executing CLO failed\n");
804                 break;
805             }
806         }
807         while (ATA_INL(ctlr->r_res2, ATA_AHCI_P_CMD+offset)&ATA_AHCI_P_CMD_CLO);
808     }
809
810     /* reset PHY and decide what is present */
811     if (ata_sata_phy_reset(dev)) {
812
813         /* clear any interrupts pending on this channel */
814         ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_IS + offset,
815                  ATA_INL(ctlr->r_res2, ATA_AHCI_P_IS + offset));
816
817         /* clear SATA error register */
818         ATA_IDX_OUTL(ch, ATA_SERROR, ATA_IDX_INL(ch, ATA_SERROR));
819
820         /* start operations on this channel */
821         ATA_OUTL(ctlr->r_res2, ATA_AHCI_P_CMD + offset,
822                  (ATA_AHCI_P_CMD_ACTIVE | ATA_AHCI_P_CMD_FRE |
823                   ATA_AHCI_P_CMD_POD | ATA_AHCI_P_CMD_SUD | ATA_AHCI_P_CMD_ST));
824
825         signature = ATA_INL(ctlr->r_res2, ATA_AHCI_P_SIG + offset);
826         switch (signature) {
827         case 0x00000101:
828             ch->devices = ATA_ATA_MASTER;
829             break;
830         case 0x96690101:
831             ch->devices = ATA_PORTMULTIPLIER;
832             device_printf(ch->dev, "Portmultipliers not supported yet\n");
833             ch->devices = 0;
834             break;
835         case 0xeb140101:
836             ch->devices = ATA_ATAPI_MASTER;
837             break;
838         default: /* SOS XXX */
839             if (bootverbose)
840                 device_printf(ch->dev, "No signature, assuming disk device\n");
841             ch->devices = ATA_ATA_MASTER;
842         }
843     }
844     if (bootverbose)
845         device_printf(dev, "ahci_reset devices=0x%b\n", ch->devices,
846                       "\20\4ATAPI_SLAVE\3ATAPI_MASTER\2ATA_SLAVE\1ATA_MASTER");
847 }
848
849 static void
850 ata_ahci_dmasetprd(void *xsc, bus_dma_segment_t *segs, int nsegs, int error)
851 {    
852     struct ata_dmasetprd_args *args = xsc;
853     struct ata_ahci_dma_prd *prd = args->dmatab;
854     int i;
855
856     if (!(args->error = error)) {
857         for (i = 0; i < nsegs; i++) {
858             prd[i].dba = htole64(segs[i].ds_addr);
859             prd[i].dbc = htole32((segs[i].ds_len - 1) & ATA_AHCI_PRD_MASK);
860         }
861     }
862     args->nsegs = nsegs;
863 }
864
865 static void
866 ata_ahci_dmainit(device_t dev)
867 {
868     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
869     struct ata_channel *ch = device_get_softc(dev);
870
871     ata_dmainit(dev);
872     if (ch->dma) {
873         /* note start and stop are not used here */
874         ch->dma->setprd = ata_ahci_dmasetprd;
875         ch->dma->max_iosize = 8192 * DEV_BSIZE;
876         if (ATA_INL(ctlr->r_res2, ATA_AHCI_CAP) & ATA_AHCI_CAP_64BIT)
877             ch->dma->max_address = BUS_SPACE_MAXADDR;
878     }
879 }
880
881 static int
882 ata_ahci_setup_fis(struct ata_ahci_cmd_tab *ctp, struct ata_request *request)
883 {
884     bzero(ctp->cfis, 64);
885     if (request->flags & ATA_R_ATAPI) {
886         bzero(ctp->acmd, 32);
887         bcopy(request->u.atapi.ccb, ctp->acmd, 16);
888     }
889     return ata_request2fis_h2d(request, &ctp->cfis[0]);
890 }
891
892 /*
893  * Acard chipset support functions
894  */
895 int
896 ata_acard_ident(device_t dev)
897 {
898     struct ata_pci_controller *ctlr = device_get_softc(dev);
899     struct ata_chip_id *idx;
900     static struct ata_chip_id ids[] =
901     {{ ATA_ATP850R, 0, ATPOLD, 0x00, ATA_UDMA2, "ATP850" },
902      { ATA_ATP860A, 0, 0,      0x00, ATA_UDMA4, "ATP860A" },
903      { ATA_ATP860R, 0, 0,      0x00, ATA_UDMA4, "ATP860R" },
904      { ATA_ATP865A, 0, 0,      0x00, ATA_UDMA6, "ATP865A" },
905      { ATA_ATP865R, 0, 0,      0x00, ATA_UDMA6, "ATP865R" },
906      { 0, 0, 0, 0, 0, 0}};
907     char buffer[64]; 
908
909     if (!(idx = ata_match_chip(dev, ids)))
910         return ENXIO;
911
912     ksprintf(buffer, "Acard %s %s controller",
913             idx->text, ata_mode2str(idx->max_dma));
914     device_set_desc_copy(dev, buffer);
915     ctlr->chip = idx;
916     ctlr->chipinit = ata_acard_chipinit;
917     return 0;
918 }
919
920 static int
921 ata_acard_chipinit(device_t dev)
922 {
923     struct ata_pci_controller *ctlr = device_get_softc(dev);
924
925     if (ata_setup_interrupt(dev))
926         return ENXIO;
927
928     ctlr->allocate = ata_acard_allocate;
929     if (ctlr->chip->cfg1 == ATPOLD) {
930         ctlr->setmode = ata_acard_850_setmode;
931         ctlr->locking = ata_serialize;
932     }
933     else
934         ctlr->setmode = ata_acard_86X_setmode;
935     return 0;
936 }
937
938 static int
939 ata_acard_allocate(device_t dev)
940 {
941     struct ata_channel *ch = device_get_softc(dev);
942
943     /* setup the usual register normal pci style */
944     if (ata_pci_allocate(dev))
945         return ENXIO;
946
947     ch->hw.status = ata_acard_status;
948     return 0;
949 }
950
951 static int
952 ata_acard_status(device_t dev)
953 {
954     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
955     struct ata_channel *ch = device_get_softc(dev);
956
957     if (ctlr->chip->cfg1 == ATPOLD &&
958         ATA_LOCKING(ch->dev, ATA_LF_WHICH) != ch->unit)
959             return 0;
960     if (ch->dma && (ch->dma->flags & ATA_DMA_ACTIVE)) {
961         int bmstat = ATA_IDX_INB(ch, ATA_BMSTAT_PORT) & ATA_BMSTAT_MASK;
962
963         if ((bmstat & (ATA_BMSTAT_ACTIVE | ATA_BMSTAT_INTERRUPT)) !=
964             ATA_BMSTAT_INTERRUPT)
965             return 0;
966         ATA_IDX_OUTB(ch, ATA_BMSTAT_PORT, bmstat & ~ATA_BMSTAT_ERROR);
967         DELAY(1);
968         ATA_IDX_OUTB(ch, ATA_BMCMD_PORT,
969                      ATA_IDX_INB(ch, ATA_BMCMD_PORT) & ~ATA_BMCMD_START_STOP);
970         DELAY(1);
971     }
972     if (ATA_IDX_INB(ch, ATA_ALTSTAT) & ATA_S_BUSY) {
973         DELAY(100);
974         if (ATA_IDX_INB(ch, ATA_ALTSTAT) & ATA_S_BUSY)
975             return 0;
976     }
977     return 1;
978 }
979
980 static void
981 ata_acard_850_setmode(device_t dev, int mode)
982 {
983     device_t gparent = GRANDPARENT(dev);
984     struct ata_pci_controller *ctlr = device_get_softc(gparent);
985     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
986     struct ata_device *atadev = device_get_softc(dev);
987     int devno = (ch->unit << 1) + ATA_DEV(atadev->unit);
988     int error;
989
990     mode = ata_limit_mode(dev, mode,
991                           ata_atapi(dev) ? ATA_PIO_MAX : ctlr->chip->max_dma);
992
993     /* XXX SOS missing WDMA0+1 + PIO modes */
994     if (mode >= ATA_WDMA2) {
995         error = ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode);
996         if (bootverbose)
997             device_printf(dev, "%ssetting %s on %s chip\n",
998                           (error) ? "FAILURE " : "",
999                           ata_mode2str(mode), ctlr->chip->text);
1000         if (!error) {
1001             u_int8_t reg54 = pci_read_config(gparent, 0x54, 1);
1002             
1003             reg54 &= ~(0x03 << (devno << 1));
1004             if (mode >= ATA_UDMA0)
1005                 reg54 |= (((mode & ATA_MODE_MASK) + 1) << (devno << 1));
1006             pci_write_config(gparent, 0x54, reg54, 1);
1007             pci_write_config(gparent, 0x4a, 0xa6, 1);
1008             pci_write_config(gparent, 0x40 + (devno << 1), 0x0301, 2);
1009             atadev->mode = mode;
1010             return;
1011         }
1012     }
1013     /* we could set PIO mode timings, but we assume the BIOS did that */
1014 }
1015
1016 static void
1017 ata_acard_86X_setmode(device_t dev, int mode)
1018 {
1019     device_t gparent = GRANDPARENT(dev);
1020     struct ata_pci_controller *ctlr = device_get_softc(gparent);
1021     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
1022     struct ata_device *atadev = device_get_softc(dev);
1023     int devno = (ch->unit << 1) + ATA_DEV(atadev->unit);
1024     int error;
1025
1026
1027     mode = ata_limit_mode(dev, mode,
1028                           ata_atapi(dev) ? ATA_PIO_MAX : ctlr->chip->max_dma);
1029
1030     mode = ata_check_80pin(dev, mode);
1031
1032     /* XXX SOS missing WDMA0+1 + PIO modes */
1033     if (mode >= ATA_WDMA2) {
1034         error = ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode);
1035         if (bootverbose)
1036             device_printf(dev, "%ssetting %s on %s chip\n",
1037                           (error) ? "FAILURE " : "",
1038                           ata_mode2str(mode), ctlr->chip->text);
1039         if (!error) {
1040             u_int16_t reg44 = pci_read_config(gparent, 0x44, 2);
1041             
1042             reg44 &= ~(0x000f << (devno << 2));
1043             if (mode >= ATA_UDMA0)
1044                 reg44 |= (((mode & ATA_MODE_MASK) + 1) << (devno << 2));
1045             pci_write_config(gparent, 0x44, reg44, 2);
1046             pci_write_config(gparent, 0x4a, 0xa6, 1);
1047             pci_write_config(gparent, 0x40 + devno, 0x31, 1);
1048             atadev->mode = mode;
1049             return;
1050         }
1051     }
1052     /* we could set PIO mode timings, but we assume the BIOS did that */
1053 }
1054
1055
1056 /*
1057  * Acer Labs Inc (ALI) chipset support functions
1058  */
1059 int
1060 ata_ali_ident(device_t dev)
1061 {
1062     struct ata_pci_controller *ctlr = device_get_softc(dev);
1063     struct ata_chip_id *idx;
1064     static struct ata_chip_id ids[] =
1065     {{ ATA_ALI_5289, 0x00, 2, ALISATA, ATA_SA150, "M5289" },
1066      { ATA_ALI_5288, 0x00, 4, ALISATA, ATA_SA300, "M5288" },
1067      { ATA_ALI_5287, 0x00, 4, ALISATA, ATA_SA150, "M5287" },
1068      { ATA_ALI_5281, 0x00, 2, ALISATA, ATA_SA150, "M5281" },
1069      { ATA_ALI_5229, 0xc5, 0, ALINEW,  ATA_UDMA6, "M5229" },
1070      { ATA_ALI_5229, 0xc4, 0, ALINEW,  ATA_UDMA5, "M5229" },
1071      { ATA_ALI_5229, 0xc2, 0, ALINEW,  ATA_UDMA4, "M5229" },
1072      { ATA_ALI_5229, 0x20, 0, ALIOLD,  ATA_UDMA2, "M5229" },
1073      { ATA_ALI_5229, 0x00, 0, ALIOLD,  ATA_WDMA2, "M5229" },
1074      { 0, 0, 0, 0, 0, 0}};
1075     char buffer[64]; 
1076
1077     if (!(idx = ata_match_chip(dev, ids)))
1078         return ENXIO;
1079
1080     ksprintf(buffer, "AcerLabs %s %s controller",
1081             idx->text, ata_mode2str(idx->max_dma));
1082     device_set_desc_copy(dev, buffer);
1083     ctlr->chip = idx;
1084     ctlr->chipinit = ata_ali_chipinit;
1085     return 0;
1086 }
1087
1088 static int
1089 ata_ali_chipinit(device_t dev)
1090 {
1091     struct ata_pci_controller *ctlr = device_get_softc(dev);
1092
1093     if (ata_setup_interrupt(dev))
1094         return ENXIO;
1095
1096     switch (ctlr->chip->cfg2) {
1097     case ALISATA:
1098         ctlr->channels = ctlr->chip->cfg1;
1099         ctlr->allocate = ata_ali_sata_allocate;
1100         ctlr->setmode = ata_sata_setmode;
1101
1102         /* if we have a memory resource we can likely do AHCI */
1103         ctlr->r_type2 = SYS_RES_MEMORY;
1104         ctlr->r_rid2 = PCIR_BAR(5);
1105         if ((ctlr->r_res2 = bus_alloc_resource_any(dev, ctlr->r_type2,
1106                                                    &ctlr->r_rid2, RF_ACTIVE)))
1107             return ata_ahci_chipinit(dev);
1108
1109         /* enable PCI interrupt */
1110         pci_write_config(dev, PCIR_COMMAND,
1111                          pci_read_config(dev, PCIR_COMMAND, 2) & ~0x0400, 2);
1112         break;
1113
1114     case ALINEW:
1115         /* use device interrupt as byte count end */
1116         pci_write_config(dev, 0x4a, pci_read_config(dev, 0x4a, 1) | 0x20, 1);
1117
1118         /* enable cable detection and UDMA support on newer chips */
1119         pci_write_config(dev, 0x4b, pci_read_config(dev, 0x4b, 1) | 0x09, 1);
1120
1121         /* enable ATAPI UDMA mode */
1122         pci_write_config(dev, 0x53, pci_read_config(dev, 0x53, 1) | 0x01, 1);
1123
1124         /* only chips with revision > 0xc4 can do 48bit DMA */
1125         if (ctlr->chip->chiprev <= 0xc4)
1126             device_printf(dev,
1127                           "using PIO transfers above 137GB as workaround for "
1128                           "48bit DMA access bug, expect reduced performance\n");
1129         ctlr->allocate = ata_ali_allocate;
1130         ctlr->reset = ata_ali_reset;
1131         ctlr->setmode = ata_ali_setmode;
1132         break;
1133
1134     case ALIOLD:
1135         /* deactivate the ATAPI FIFO and enable ATAPI UDMA */
1136         pci_write_config(dev, 0x53, pci_read_config(dev, 0x53, 1) | 0x03, 1);
1137         ctlr->setmode = ata_ali_setmode;
1138         break;
1139     }
1140     return 0;
1141 }
1142
1143 static int
1144 ata_ali_allocate(device_t dev)
1145 {
1146     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
1147     struct ata_channel *ch = device_get_softc(dev);
1148
1149     /* setup the usual register normal pci style */
1150     if (ata_pci_allocate(dev))
1151         return ENXIO;
1152
1153     /* older chips can't do 48bit DMA transfers */
1154     if (ctlr->chip->chiprev <= 0xc4)
1155         ch->flags |= ATA_NO_48BIT_DMA;
1156
1157     return 0;
1158 }
1159
1160 static int
1161 ata_ali_sata_allocate(device_t dev)
1162 {
1163     device_t parent = device_get_parent(dev);
1164     struct ata_pci_controller *ctlr = device_get_softc(parent);
1165     struct ata_channel *ch = device_get_softc(dev);
1166     struct resource *io = NULL, *ctlio = NULL;
1167     int unit01 = (ch->unit & 1), unit10 = (ch->unit & 2);
1168     int i, rid;
1169                 
1170     rid = PCIR_BAR(0) + (unit01 ? 8 : 0);
1171     io = bus_alloc_resource_any(parent, SYS_RES_IOPORT, &rid, RF_ACTIVE);
1172     if (!io)
1173         return ENXIO;
1174
1175     rid = PCIR_BAR(1) + (unit01 ? 8 : 0);
1176     ctlio = bus_alloc_resource_any(parent, SYS_RES_IOPORT, &rid, RF_ACTIVE);
1177     if (!ctlio) {
1178         bus_release_resource(dev, SYS_RES_IOPORT, ATA_IOADDR_RID, io);
1179         return ENXIO;
1180     }
1181                 
1182     for (i = ATA_DATA; i <= ATA_COMMAND; i ++) {
1183         ch->r_io[i].res = io;
1184         ch->r_io[i].offset = i + (unit10 ? 8 : 0);
1185     }
1186     ch->r_io[ATA_CONTROL].res = ctlio;
1187     ch->r_io[ATA_CONTROL].offset = 2 + (unit10 ? 4 : 0);
1188     ch->r_io[ATA_IDX_ADDR].res = io;
1189     ata_default_registers(dev);
1190     if (ctlr->r_res1) {
1191         for (i = ATA_BMCMD_PORT; i <= ATA_BMDTP_PORT; i++) {
1192             ch->r_io[i].res = ctlr->r_res1;
1193             ch->r_io[i].offset = (i - ATA_BMCMD_PORT)+(ch->unit * ATA_BMIOSIZE);
1194         }
1195     }
1196     ch->flags |= ATA_NO_SLAVE;
1197
1198     /* XXX SOS PHY handling awkward in ALI chip not supported yet */
1199     ata_pci_hw(dev);
1200     return 0;
1201 }
1202
1203 static void
1204 ata_ali_reset(device_t dev)
1205 {
1206     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
1207     struct ata_channel *ch = device_get_softc(dev);
1208     device_t *children;
1209     int nchildren, i;
1210
1211     ata_generic_reset(dev);
1212
1213     /*
1214      * workaround for datacorruption bug found on at least SUN Blade-100
1215      * find the ISA function on the southbridge and disable then enable
1216      * the ATA channel tristate buffer
1217      */
1218     if (ctlr->chip->chiprev == 0xc3 || ctlr->chip->chiprev == 0xc2) {
1219         if (!device_get_children(GRANDPARENT(dev), &children, &nchildren)) {
1220             for (i = 0; i < nchildren; i++) {
1221                 if (pci_get_devid(children[i]) == ATA_ALI_1533) {
1222                     pci_write_config(children[i], 0x58, 
1223                                      pci_read_config(children[i], 0x58, 1) &
1224                                      ~(0x04 << ch->unit), 1);
1225                     pci_write_config(children[i], 0x58, 
1226                                      pci_read_config(children[i], 0x58, 1) |
1227                                      (0x04 << ch->unit), 1);
1228                     break;
1229                 }
1230             }
1231             kfree(children, M_TEMP);
1232         }
1233     }
1234 }
1235
1236 static void
1237 ata_ali_setmode(device_t dev, int mode)
1238 {
1239     device_t gparent = GRANDPARENT(dev);
1240     struct ata_pci_controller *ctlr = device_get_softc(gparent);
1241     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
1242     struct ata_device *atadev = device_get_softc(dev);
1243     int devno = (ch->unit << 1) + ATA_DEV(atadev->unit);
1244     int error;
1245
1246     mode = ata_limit_mode(dev, mode, ctlr->chip->max_dma);
1247
1248     if (ctlr->chip->cfg2 & ALINEW) {
1249         if (mode > ATA_UDMA2 &&
1250             pci_read_config(gparent, 0x4a, 1) & (1 << ch->unit)) {
1251             ata_print_cable(dev, "controller");
1252             mode = ATA_UDMA2;
1253         }
1254     }
1255     else
1256         mode = ata_check_80pin(dev, mode);
1257
1258     if (ctlr->chip->cfg2 & ALIOLD) {
1259         /* doesn't support ATAPI DMA on write */
1260         ch->flags |= ATA_ATAPI_DMA_RO;
1261         if (ch->devices & ATA_ATAPI_MASTER && ch->devices & ATA_ATAPI_SLAVE) {
1262             /* doesn't support ATAPI DMA on two ATAPI devices */
1263             device_printf(dev, "two atapi devices on this channel, no DMA\n");
1264             mode = ata_limit_mode(dev, mode, ATA_PIO_MAX);
1265         }
1266     }
1267
1268     error = ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode);
1269
1270     if (bootverbose)
1271         device_printf(dev, "%ssetting %s on %s chip\n",
1272                    (error) ? "FAILURE " : "", 
1273                    ata_mode2str(mode), ctlr->chip->text);
1274     if (!error) {
1275         if (mode >= ATA_UDMA0) {
1276             u_int8_t udma[] = {0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x0f, 0x0d};
1277             u_int32_t word54 = pci_read_config(gparent, 0x54, 4);
1278
1279             word54 &= ~(0x000f000f << (devno << 2));
1280             word54 |= (((udma[mode&ATA_MODE_MASK]<<16)|0x05)<<(devno<<2));
1281             pci_write_config(gparent, 0x54, word54, 4);
1282             pci_write_config(gparent, 0x58 + (ch->unit << 2),
1283                              0x00310001, 4);
1284         }
1285         else {
1286             u_int32_t piotimings[] =
1287                 { 0x006d0003, 0x00580002, 0x00440001, 0x00330001,
1288                   0x00310001, 0x00440001, 0x00330001, 0x00310001};
1289
1290             pci_write_config(gparent, 0x54, pci_read_config(gparent, 0x54, 4) &
1291                                             ~(0x0008000f << (devno << 2)), 4);
1292             pci_write_config(gparent, 0x58 + (ch->unit << 2),
1293                              piotimings[ata_mode2idx(mode)], 4);
1294         }
1295         atadev->mode = mode;
1296     }
1297 }
1298
1299
1300 /*
1301  * American Micro Devices (AMD) chipset support functions
1302  */
1303 int
1304 ata_amd_ident(device_t dev)
1305 {
1306     struct ata_pci_controller *ctlr = device_get_softc(dev);
1307     struct ata_chip_id *idx;
1308     static struct ata_chip_id ids[] =
1309     {{ ATA_AMD756,  0x00, AMDNVIDIA, 0x00,            ATA_UDMA4, "756" },
1310      { ATA_AMD766,  0x00, AMDNVIDIA, AMDCABLE|AMDBUG, ATA_UDMA5, "766" },
1311      { ATA_AMD768,  0x00, AMDNVIDIA, AMDCABLE,        ATA_UDMA5, "768" },
1312      { ATA_AMD8111, 0x00, AMDNVIDIA, AMDCABLE,        ATA_UDMA6, "8111" },
1313      { 0, 0, 0, 0, 0, 0}};
1314     char buffer[64]; 
1315
1316     if (!(idx = ata_match_chip(dev, ids)))
1317         return ENXIO;
1318
1319     ksprintf(buffer, "AMD %s %s controller",
1320             idx->text, ata_mode2str(idx->max_dma));
1321     device_set_desc_copy(dev, buffer);
1322     ctlr->chip = idx;
1323     ctlr->chipinit = ata_amd_chipinit;
1324     return 0;
1325 }
1326
1327 static int
1328 ata_amd_chipinit(device_t dev)
1329 {
1330     struct ata_pci_controller *ctlr = device_get_softc(dev);
1331
1332     if (ata_setup_interrupt(dev))
1333         return ENXIO;
1334
1335     /* disable/set prefetch, postwrite */
1336     if (ctlr->chip->cfg2 & AMDBUG)
1337         pci_write_config(dev, 0x41, pci_read_config(dev, 0x41, 1) & 0x0f, 1);
1338     else
1339         pci_write_config(dev, 0x41, pci_read_config(dev, 0x41, 1) | 0xf0, 1);
1340
1341     ctlr->setmode = ata_via_family_setmode;
1342     return 0;
1343 }
1344
1345
1346 /*
1347  * ATI chipset support functions
1348  */
1349 int
1350 ata_ati_ident(device_t dev)
1351 {
1352     struct ata_pci_controller *ctlr = device_get_softc(dev);
1353     struct ata_chip_id *idx;
1354     static struct ata_chip_id ids[] =
1355     {{ ATA_ATI_IXP200,    0x00, 0,        0, ATA_UDMA5, "IXP200" },
1356      { ATA_ATI_IXP300,    0x00, 0,        0, ATA_UDMA6, "IXP300" },
1357      { ATA_ATI_IXP400,    0x00, 0,        0, ATA_UDMA6, "IXP400" },
1358      { ATA_ATI_SB600,     0x00, 0,        0, ATA_UDMA6, "SB600"  },
1359      { ATA_ATI_IXP300_S1, 0x00, SIIMEMIO, 0, ATA_SA150, "IXP300" },
1360      { ATA_ATI_IXP400_S1, 0x00, SIIMEMIO, 0, ATA_SA150, "IXP400" },
1361      { ATA_ATI_IXP400_S2, 0x00, SIIMEMIO, 0, ATA_SA150, "IXP400" },
1362      { ATA_ATI_SB600_S1,  0x00, ATIAHCI,     0, ATA_SA300, "SB600"  },
1363      { ATA_ATI_SB600_S2,  0x00, ATIAHCI,     0, ATA_SA300, "SB600"  },
1364      { 0, 0, 0, 0, 0, 0}};
1365     char buffer[64];
1366
1367     if (!(idx = ata_match_chip(dev, ids)))
1368         return ENXIO;
1369
1370     ksprintf(buffer, "ATI %s %s controller",
1371             idx->text, ata_mode2str(idx->max_dma));
1372     device_set_desc_copy(dev, buffer);
1373     ctlr->chip = idx;
1374
1375     /*
1376      * The ATI SATA controllers are actually a SiI 3112 controller, except
1377      * for the SB600.
1378      */
1379     if (ctlr->chip->cfg1 & SIIMEMIO)
1380         ctlr->chipinit = ata_sii_chipinit;
1381     else
1382         ctlr->chipinit = ata_ati_chipinit;
1383     return 0;
1384 }
1385
1386 static int
1387 ata_ati_chipinit(device_t dev)
1388 {
1389     struct ata_pci_controller *ctlr = device_get_softc(dev);
1390
1391     if (ata_setup_interrupt(dev))
1392         return ENXIO;
1393
1394     /* The SB600 needs special treatment. */
1395     if (ctlr->chip->cfg1 & ATIAHCI) {
1396         /* Check if the chip is configured as an AHCI part. */
1397         if ((pci_get_subclass(dev) == PCIS_STORAGE_SATA) &&
1398             (pci_read_config(dev, PCIR_PROGIF, 1) == PCIP_STORAGE_SATA_AHCI_1_0)) {
1399             /* Check if the chip has PCI BAR 5 as memory resource. */
1400             ctlr->r_type2 = SYS_RES_MEMORY;
1401             ctlr->r_rid2 = PCIR_BAR(5); /* 0x24 */
1402             if ((ctlr->r_res2 = bus_alloc_resource_any(dev, ctlr->r_type2,
1403                                                        &ctlr->r_rid2,
1404                                                        RF_ACTIVE))) {
1405                 return ata_ahci_chipinit(dev);
1406             }
1407         }
1408     }
1409
1410     ctlr->setmode = ata_ati_setmode;
1411     return 0;
1412 }
1413
1414 static void
1415 ata_ati_setmode(device_t dev, int mode)
1416 {
1417     device_t gparent = GRANDPARENT(dev);
1418     struct ata_pci_controller *ctlr = device_get_softc(gparent);
1419     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
1420     struct ata_device *atadev = device_get_softc(dev);
1421     int devno = (ch->unit << 1) + ATA_DEV(atadev->unit);
1422     int offset = (devno ^ 0x01) << 3;
1423     int error;
1424     u_int8_t piotimings[] = { 0x5d, 0x47, 0x34, 0x22, 0x20, 0x34, 0x22, 0x20,
1425                               0x20, 0x20, 0x20, 0x20, 0x20, 0x20 };
1426     u_int8_t dmatimings[] = { 0x77, 0x21, 0x20 };
1427
1428     mode = ata_limit_mode(dev, mode, ctlr->chip->max_dma);
1429
1430     mode = ata_check_80pin(dev, mode);
1431
1432     error = ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode);
1433
1434     if (bootverbose)
1435         device_printf(dev, "%ssetting %s on %s chip\n",
1436                       (error) ? "FAILURE " : "",
1437                       ata_mode2str(mode), ctlr->chip->text);
1438     if (!error) {
1439         if (mode >= ATA_UDMA0) {
1440             pci_write_config(gparent, 0x56, 
1441                              (pci_read_config(gparent, 0x56, 2) &
1442                               ~(0xf << (devno << 2))) |
1443                              ((mode & ATA_MODE_MASK) << (devno << 2)), 2);
1444             pci_write_config(gparent, 0x54,
1445                              pci_read_config(gparent, 0x54, 1) |
1446                              (0x01 << devno), 1);
1447             pci_write_config(gparent, 0x44, 
1448                              (pci_read_config(gparent, 0x44, 4) &
1449                               ~(0xff << offset)) |
1450                              (dmatimings[2] << offset), 4);
1451         }
1452         else if (mode >= ATA_WDMA0) {
1453             pci_write_config(gparent, 0x54,
1454                              pci_read_config(gparent, 0x54, 1) &
1455                               ~(0x01 << devno), 1);
1456             pci_write_config(gparent, 0x44, 
1457                              (pci_read_config(gparent, 0x44, 4) &
1458                               ~(0xff << offset)) |
1459                              (dmatimings[mode & ATA_MODE_MASK] << offset), 4);
1460         }
1461         else
1462             pci_write_config(gparent, 0x54,
1463                              pci_read_config(gparent, 0x54, 1) &
1464                              ~(0x01 << devno), 1);
1465
1466         pci_write_config(gparent, 0x4a,
1467                          (pci_read_config(gparent, 0x4a, 2) &
1468                           ~(0xf << (devno << 2))) |
1469                          (((mode - ATA_PIO0) & ATA_MODE_MASK) << (devno<<2)),2);
1470         pci_write_config(gparent, 0x40, 
1471                          (pci_read_config(gparent, 0x40, 4) &
1472                           ~(0xff << offset)) |
1473                          (piotimings[ata_mode2idx(mode)] << offset), 4);
1474         atadev->mode = mode;
1475     }
1476 }
1477
1478 /*
1479  * Cyrix chipset support functions
1480  */
1481 int
1482 ata_cyrix_ident(device_t dev)
1483 {
1484     struct ata_pci_controller *ctlr = device_get_softc(dev);
1485
1486     if (pci_get_devid(dev) == ATA_CYRIX_5530) {
1487         device_set_desc(dev, "Cyrix 5530 ATA33 controller");
1488         ctlr->chipinit = ata_cyrix_chipinit;
1489         return 0;
1490     }
1491     return ENXIO;
1492 }
1493
1494 static int
1495 ata_cyrix_chipinit(device_t dev)
1496 {
1497     struct ata_pci_controller *ctlr = device_get_softc(dev);
1498
1499     if (ata_setup_interrupt(dev))
1500         return ENXIO;
1501
1502     if (ctlr->r_res1)
1503         ctlr->setmode = ata_cyrix_setmode;
1504     else
1505         ctlr->setmode = ata_generic_setmode;
1506     return 0;
1507 }
1508
1509 static void
1510 ata_cyrix_setmode(device_t dev, int mode)
1511 {
1512     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
1513     struct ata_device *atadev = device_get_softc(dev);
1514     int devno = (ch->unit << 1) + ATA_DEV(atadev->unit);
1515     u_int32_t piotiming[] = 
1516         { 0x00009172, 0x00012171, 0x00020080, 0x00032010, 0x00040010 };
1517     u_int32_t dmatiming[] = { 0x00077771, 0x00012121, 0x00002020 };
1518     u_int32_t udmatiming[] = { 0x00921250, 0x00911140, 0x00911030 };
1519     int error;
1520
1521     ch->dma->alignment = 16;
1522     ch->dma->max_iosize = 126 * DEV_BSIZE;
1523
1524     mode = ata_limit_mode(dev, mode, ATA_UDMA2);
1525
1526     error = ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode);
1527
1528     if (bootverbose)
1529         device_printf(dev, "%ssetting %s on Cyrix chip\n",
1530                       (error) ? "FAILURE " : "", ata_mode2str(mode));
1531     if (!error) {
1532         if (mode >= ATA_UDMA0) {
1533             ATA_OUTL(ch->r_io[ATA_BMCMD_PORT].res,
1534                      0x24 + (devno << 3), udmatiming[mode & ATA_MODE_MASK]);
1535         }
1536         else if (mode >= ATA_WDMA0) {
1537             ATA_OUTL(ch->r_io[ATA_BMCMD_PORT].res,
1538                      0x24 + (devno << 3), dmatiming[mode & ATA_MODE_MASK]);
1539         }
1540         else {
1541             ATA_OUTL(ch->r_io[ATA_BMCMD_PORT].res,
1542                      0x20 + (devno << 3), piotiming[mode & ATA_MODE_MASK]);
1543         }
1544         atadev->mode = mode;
1545     }
1546 }
1547
1548
1549 /*
1550  * Cypress chipset support functions
1551  */
1552 int
1553 ata_cypress_ident(device_t dev)
1554 {
1555     struct ata_pci_controller *ctlr = device_get_softc(dev);
1556
1557     /*
1558      * the Cypress chip is a mess, it contains two ATA functions, but
1559      * both channels are visible on the first one.
1560      * simply ignore the second function for now, as the right
1561      * solution (ignoring the second channel on the first function)
1562      * doesn't work with the crappy ATA interrupt setup on the alpha.
1563      */
1564     if (pci_get_devid(dev) == ATA_CYPRESS_82C693 &&
1565         pci_get_function(dev) == 1 &&
1566         pci_get_subclass(dev) == PCIS_STORAGE_IDE) {
1567         device_set_desc(dev, "Cypress 82C693 ATA controller");
1568         ctlr->chipinit = ata_cypress_chipinit;
1569         return 0;
1570     }
1571     return ENXIO;
1572 }
1573
1574 static int
1575 ata_cypress_chipinit(device_t dev)
1576 {
1577     struct ata_pci_controller *ctlr = device_get_softc(dev);
1578
1579     if (ata_setup_interrupt(dev))
1580         return ENXIO;
1581
1582     ctlr->setmode = ata_cypress_setmode;
1583     return 0;
1584 }
1585
1586 static void
1587 ata_cypress_setmode(device_t dev, int mode)
1588 {
1589     device_t gparent = GRANDPARENT(dev);
1590     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
1591     struct ata_device *atadev = device_get_softc(dev);
1592     int error;
1593
1594     mode = ata_limit_mode(dev, mode, ATA_WDMA2);
1595
1596     /* XXX SOS missing WDMA0+1 + PIO modes */
1597     if (mode == ATA_WDMA2) { 
1598         error = ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode);
1599         if (bootverbose)
1600             device_printf(dev, "%ssetting WDMA2 on Cypress chip\n",
1601                           error ? "FAILURE " : "");
1602         if (!error) {
1603             pci_write_config(gparent, ch->unit ? 0x4e : 0x4c, 0x2020, 2);
1604             atadev->mode = mode;
1605             return;
1606         }
1607     }
1608     /* we could set PIO mode timings, but we assume the BIOS did that */
1609 }
1610
1611
1612 /*
1613  * HighPoint chipset support functions
1614  */
1615 int
1616 ata_highpoint_ident(device_t dev)
1617 {
1618     struct ata_pci_controller *ctlr = device_get_softc(dev);
1619     struct ata_chip_id *idx;
1620     static struct ata_chip_id ids[] =
1621     {{ ATA_HPT374, 0x07, HPT374, 0x00,   ATA_UDMA6, "HPT374" },
1622      { ATA_HPT372, 0x02, HPT372, 0x00,   ATA_UDMA6, "HPT372N" },
1623      { ATA_HPT372, 0x01, HPT372, 0x00,   ATA_UDMA6, "HPT372" },
1624      { ATA_HPT371, 0x01, HPT372, 0x00,   ATA_UDMA6, "HPT371" },
1625      { ATA_HPT366, 0x05, HPT372, 0x00,   ATA_UDMA6, "HPT372" },
1626      { ATA_HPT366, 0x03, HPT370, 0x00,   ATA_UDMA5, "HPT370" },
1627      { ATA_HPT366, 0x02, HPT366, 0x00,   ATA_UDMA4, "HPT368" },
1628      { ATA_HPT366, 0x00, HPT366, HPTOLD, ATA_UDMA4, "HPT366" },
1629      { ATA_HPT302, 0x01, HPT372, 0x00,   ATA_UDMA6, "HPT302" },
1630      { 0, 0, 0, 0, 0, 0}};
1631     char buffer[64];
1632
1633     if (!(idx = ata_match_chip(dev, ids)))
1634         return ENXIO;
1635
1636     strcpy(buffer, "HighPoint ");
1637     strcat(buffer, idx->text);
1638     if (idx->cfg1 == HPT374) {
1639         if (pci_get_function(dev) == 0)
1640             strcat(buffer, " (channel 0+1)");
1641         if (pci_get_function(dev) == 1)
1642             strcat(buffer, " (channel 2+3)");
1643     }
1644     ksprintf(buffer, "%s %s controller", buffer, ata_mode2str(idx->max_dma));
1645     device_set_desc_copy(dev, buffer);
1646     ctlr->chip = idx;
1647     ctlr->chipinit = ata_highpoint_chipinit;
1648     return 0;
1649 }
1650
1651 static int
1652 ata_highpoint_chipinit(device_t dev)
1653 {
1654     struct ata_pci_controller *ctlr = device_get_softc(dev);
1655
1656     if (ata_setup_interrupt(dev))
1657         return ENXIO;
1658
1659     if (ctlr->chip->cfg2 == HPTOLD) {
1660         /* disable interrupt prediction */
1661         pci_write_config(dev, 0x51, (pci_read_config(dev, 0x51, 1) & ~0x80), 1);
1662     }
1663     else {
1664         /* disable interrupt prediction */
1665         pci_write_config(dev, 0x51, (pci_read_config(dev, 0x51, 1) & ~0x03), 1);
1666         pci_write_config(dev, 0x55, (pci_read_config(dev, 0x55, 1) & ~0x03), 1);
1667
1668         /* enable interrupts */
1669         pci_write_config(dev, 0x5a, (pci_read_config(dev, 0x5a, 1) & ~0x10), 1);
1670
1671         /* set clocks etc */
1672         if (ctlr->chip->cfg1 < HPT372)
1673             pci_write_config(dev, 0x5b, 0x22, 1);
1674         else
1675             pci_write_config(dev, 0x5b,
1676                              (pci_read_config(dev, 0x5b, 1) & 0x01) | 0x20, 1);
1677     }
1678     ctlr->allocate = ata_highpoint_allocate;
1679     ctlr->setmode = ata_highpoint_setmode;
1680     return 0;
1681 }
1682
1683 static int
1684 ata_highpoint_allocate(device_t dev)
1685 {
1686     struct ata_channel *ch = device_get_softc(dev);
1687
1688     /* setup the usual register normal pci style */
1689     if (ata_pci_allocate(dev))
1690         return ENXIO;
1691
1692     ch->flags |= ATA_ALWAYS_DMASTAT;
1693     return 0;
1694 }
1695
1696 static void
1697 ata_highpoint_setmode(device_t dev, int mode)
1698 {
1699     device_t gparent = GRANDPARENT(dev);
1700     struct ata_pci_controller *ctlr = device_get_softc(gparent);
1701     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
1702     struct ata_device *atadev = device_get_softc(dev);
1703     int devno = (ch->unit << 1) + ATA_DEV(atadev->unit);
1704     int error;
1705     u_int32_t timings33[][4] = {
1706     /*    HPT366      HPT370      HPT372      HPT374               mode */
1707         { 0x40d0a7aa, 0x06914e57, 0x0d029d5e, 0x0ac1f48a },     /* PIO 0 */
1708         { 0x40d0a7a3, 0x06914e43, 0x0d029d26, 0x0ac1f465 },     /* PIO 1 */
1709         { 0x40d0a753, 0x06514e33, 0x0c829ca6, 0x0a81f454 },     /* PIO 2 */
1710         { 0x40c8a742, 0x06514e22, 0x0c829c84, 0x0a81f443 },     /* PIO 3 */
1711         { 0x40c8a731, 0x06514e21, 0x0c829c62, 0x0a81f442 },     /* PIO 4 */
1712         { 0x20c8a797, 0x26514e97, 0x2c82922e, 0x228082ea },     /* MWDMA 0 */
1713         { 0x20c8a732, 0x26514e33, 0x2c829266, 0x22808254 },     /* MWDMA 1 */
1714         { 0x20c8a731, 0x26514e21, 0x2c829262, 0x22808242 },     /* MWDMA 2 */
1715         { 0x10c8a731, 0x16514e31, 0x1c829c62, 0x121882ea },     /* UDMA 0 */
1716         { 0x10cba731, 0x164d4e31, 0x1c9a9c62, 0x12148254 },     /* UDMA 1 */
1717         { 0x10caa731, 0x16494e31, 0x1c929c62, 0x120c8242 },     /* UDMA 2 */
1718         { 0x10cfa731, 0x166d4e31, 0x1c8e9c62, 0x128c8242 },     /* UDMA 3 */
1719         { 0x10c9a731, 0x16454e31, 0x1c8a9c62, 0x12ac8242 },     /* UDMA 4 */
1720         { 0,          0x16454e31, 0x1c8a9c62, 0x12848242 },     /* UDMA 5 */
1721         { 0,          0,          0x1c869c62, 0x12808242 }      /* UDMA 6 */
1722     };
1723
1724     mode = ata_limit_mode(dev, mode, ctlr->chip->max_dma);
1725
1726     if (ctlr->chip->cfg1 == HPT366 && ata_atapi(dev))
1727         mode = ata_limit_mode(dev, mode, ATA_PIO_MAX);
1728
1729     mode = ata_highpoint_check_80pin(dev, mode);
1730
1731     /*
1732      * most if not all HPT chips cant really handle that the device is
1733      * running at ATA_UDMA6/ATA133 speed, so we cheat at set the device to
1734      * a max of ATA_UDMA5/ATA100 to guard against suboptimal performance
1735      */
1736     error = ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0,
1737                            ata_limit_mode(dev, mode, ATA_UDMA5));
1738     if (bootverbose)
1739         device_printf(dev, "%ssetting %s on HighPoint chip\n",
1740                       (error) ? "FAILURE " : "", ata_mode2str(mode));
1741     if (!error)
1742         pci_write_config(gparent, 0x40 + (devno << 2),
1743                          timings33[ata_mode2idx(mode)][ctlr->chip->cfg1], 4);
1744     atadev->mode = mode;
1745 }
1746
1747 static int
1748 ata_highpoint_check_80pin(device_t dev, int mode)
1749 {
1750     device_t gparent = GRANDPARENT(dev);
1751     struct ata_pci_controller *ctlr = device_get_softc(gparent);
1752     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
1753     u_int8_t reg, val, res;
1754
1755     if (ctlr->chip->cfg1 == HPT374 && pci_get_function(gparent) == 1) {
1756         reg = ch->unit ? 0x57 : 0x53;
1757         val = pci_read_config(gparent, reg, 1);
1758         pci_write_config(gparent, reg, val | 0x80, 1);
1759     }
1760     else {
1761         reg = 0x5b;
1762         val = pci_read_config(gparent, reg, 1);
1763         pci_write_config(gparent, reg, val & 0xfe, 1);
1764     }
1765     res = pci_read_config(gparent, 0x5a, 1) & (ch->unit ? 0x1:0x2);
1766     pci_write_config(gparent, reg, val, 1);
1767
1768     if (mode > ATA_UDMA2 && res) {
1769         ata_print_cable(dev, "controller");
1770         mode = ATA_UDMA2;
1771     }
1772     return mode;
1773 }
1774
1775
1776 /*
1777  * Intel chipset support functions
1778  */
1779 int
1780 ata_intel_ident(device_t dev)
1781 {
1782     struct ata_pci_controller *ctlr = device_get_softc(dev);
1783     struct ata_chip_id *idx;
1784     static struct ata_chip_id ids[] =
1785     {{ ATA_I82371FB,    0,    0, 0x00, ATA_WDMA2, "PIIX" },
1786      { ATA_I82371SB,    0,    0, 0x00, ATA_WDMA2, "PIIX3" },
1787      { ATA_I82371AB,    0,    0, 0x00, ATA_UDMA2, "PIIX4" },
1788      { ATA_I82443MX,    0,    0, 0x00, ATA_UDMA2, "PIIX4" },
1789      { ATA_I82451NX,    0,    0, 0x00, ATA_UDMA2, "PIIX4" },
1790      { ATA_I82801AB,    0,    0, 0x00, ATA_UDMA2, "ICH0" },
1791      { ATA_I82801AA,    0,    0, 0x00, ATA_UDMA4, "ICH" },
1792      { ATA_I82372FB,    0,    0, 0x00, ATA_UDMA4, "ICH" },
1793      { ATA_I82801BA,    0,    0, 0x00, ATA_UDMA5, "ICH2" },
1794      { ATA_I82801BA_1,  0,    0, 0x00, ATA_UDMA5, "ICH2" },
1795      { ATA_I82801CA,    0,    0, 0x00, ATA_UDMA5, "ICH3" },
1796      { ATA_I82801CA_1,  0,    0, 0x00, ATA_UDMA5, "ICH3" },
1797      { ATA_I82801DB,    0,    0, 0x00, ATA_UDMA5, "ICH4" },
1798      { ATA_I82801DB_1,  0,    0, 0x00, ATA_UDMA5, "ICH4" },
1799      { ATA_I82801EB,    0,    0, 0x00, ATA_UDMA5, "ICH5" },
1800      { ATA_I82801EB_S1, 0,    0, 0x00, ATA_SA150, "ICH5" },
1801      { ATA_I82801EB_R1, 0,    0, 0x00, ATA_SA150, "ICH5" },
1802      { ATA_I6300ESB,    0,    0, 0x00, ATA_UDMA5, "6300ESB" },
1803      { ATA_I6300ESB_S1, 0,    0, 0x00, ATA_SA150, "6300ESB" },
1804      { ATA_I6300ESB_R1, 0,    0, 0x00, ATA_SA150, "6300ESB" },
1805      { ATA_I82801FB,    0,    0, 0x00, ATA_UDMA5, "ICH6" },
1806      { ATA_I82801FB_S1, 0, AHCI, 0x00, ATA_SA150, "ICH6" },
1807      { ATA_I82801FB_R1, 0, AHCI, 0x00, ATA_SA150, "ICH6" },
1808      { ATA_I82801FBM,   0, AHCI, 0x00, ATA_SA150, "ICH6M" },
1809      { ATA_I82801GB,    0,    0, 0x00, ATA_UDMA5, "ICH7" },
1810      { ATA_I82801GB_S1, 0, AHCI, 0x00, ATA_SA300, "ICH7" },
1811      { ATA_I82801GB_R1, 0, AHCI, 0x00, ATA_SA300, "ICH7" },
1812      { ATA_I82801GB_AH, 0, AHCI, 0x00, ATA_SA300, "ICH7" },
1813      { ATA_I82801GBM_S1, 0, AHCI, 0x00, ATA_SA300, "ICH7M" },
1814      { ATA_I82801GBM_R1, 0, AHCI, 0x00, ATA_SA300, "ICH7M" },
1815      { ATA_I82801GBM_AH, 0, AHCI, 0x00, ATA_SA300, "ICH7M" },
1816      { ATA_I63XXESB2,    0,    0, 0x00, ATA_UDMA5, "63XXESB2" },
1817      { ATA_I63XXESB2_S1, 0, AHCI, 0x00, ATA_SA300, "63XXESB2" },
1818      { ATA_I63XXESB2_S2, 0, AHCI, 0x00, ATA_SA300, "63XXESB2" },
1819      { ATA_I63XXESB2_R1, 0, AHCI, 0x00, ATA_SA300, "63XXESB2" },
1820      { ATA_I63XXESB2_R2, 0, AHCI, 0x00, ATA_SA300, "63XXESB2" },
1821      { ATA_I82801HB_S1,  0, AHCI, 0x00, ATA_SA300, "ICH8" },
1822      { ATA_I82801HB_S2,  0, AHCI, 0x00, ATA_SA300, "ICH8" },
1823      { ATA_I82801HB_R1,  0, AHCI, 0x00, ATA_SA300, "ICH8" },
1824      { ATA_I82801HB_AH4, 0, AHCI, 0x00, ATA_SA300, "ICH8" },
1825      { ATA_I82801HB_AH6, 0, AHCI, 0x00, ATA_SA300, "ICH8" },
1826      { ATA_I82801HBM_S1, 0,    0, 0x00, ATA_SA300, "ICH8M" },
1827      { ATA_I82801HBM_S2, 0, AHCI, 0x00, ATA_SA300, "ICH8M" },
1828      { ATA_I82801HBM_S3, 0, AHCI, 0x00, ATA_SA300, "ICH8M" },
1829      { ATA_I82801IB_S1,  0, AHCI, 0x00, ATA_SA300, "ICH9" },
1830      { ATA_I82801IB_S2,  0, AHCI, 0x00, ATA_SA300, "ICH9" },
1831      { ATA_I82801IB_AH2, 0, AHCI, 0x00, ATA_SA300, "ICH9" },
1832      { ATA_I82801IB_AH4, 0, AHCI, 0x00, ATA_SA300, "ICH9" },
1833      { ATA_I82801IB_AH6, 0, AHCI, 0x00, ATA_SA300, "ICH9" },
1834      { ATA_I31244,      0,    0, 0x00, ATA_SA150, "31244" },
1835      { 0, 0, 0, 0, 0, 0}};
1836     char buffer[64]; 
1837
1838     if (!(idx = ata_match_chip(dev, ids)))
1839         return ENXIO;
1840
1841     ksprintf(buffer, "Intel %s %s controller",
1842             idx->text, ata_mode2str(idx->max_dma));
1843     device_set_desc_copy(dev, buffer);
1844     ctlr->chip = idx;
1845     ctlr->chipinit = ata_intel_chipinit;
1846     return 0;
1847 }
1848
1849 static int
1850 ata_intel_chipinit(device_t dev)
1851 {
1852     struct ata_pci_controller *ctlr = device_get_softc(dev);
1853
1854     if (ata_setup_interrupt(dev))
1855         return ENXIO;
1856
1857     /* good old PIIX needs special treatment (not implemented) */
1858     if (ctlr->chip->chipid == ATA_I82371FB) {
1859         ctlr->setmode = ata_intel_old_setmode;
1860     }
1861
1862     /* the intel 31244 needs special care if in DPA mode */
1863     else if (ctlr->chip->chipid == ATA_I31244) {
1864         if (pci_get_subclass(dev) != PCIS_STORAGE_IDE) {
1865             ctlr->r_type2 = SYS_RES_MEMORY;
1866             ctlr->r_rid2 = PCIR_BAR(0);
1867             if (!(ctlr->r_res2 = bus_alloc_resource_any(dev, ctlr->r_type2,
1868                                                         &ctlr->r_rid2,
1869                                                         RF_ACTIVE)))
1870                 return ENXIO;
1871             ctlr->channels = 4;
1872             ctlr->allocate = ata_intel_31244_allocate;
1873             ctlr->reset = ata_intel_31244_reset;
1874         }
1875         ctlr->setmode = ata_sata_setmode;
1876     }
1877
1878     /* non SATA intel chips goes here */
1879     else if (ctlr->chip->max_dma < ATA_SA150) {
1880         ctlr->allocate = ata_intel_allocate;
1881         ctlr->setmode = ata_intel_new_setmode;
1882     }
1883
1884     /* SATA parts can be either compat or AHCI */
1885     else {
1886         /* force all ports active "the legacy way" */
1887         pci_write_config(dev, 0x92, pci_read_config(dev, 0x92, 2) | 0x0f,2);
1888
1889         ctlr->allocate = ata_intel_allocate;
1890         ctlr->reset = ata_intel_reset;
1891
1892         /* 
1893          * if we have AHCI capability and BAR(5) as a memory resource
1894          * and AHCI or RAID mode enabled in BIOS we go for AHCI mode
1895          */ 
1896         if ((ctlr->chip->cfg1 == AHCI) &&
1897             (pci_read_config(dev, 0x90, 1) & 0xc0)) {
1898             ctlr->r_type2 = SYS_RES_MEMORY;
1899             ctlr->r_rid2 = PCIR_BAR(5);
1900             if ((ctlr->r_res2 = bus_alloc_resource_any(dev, ctlr->r_type2,
1901                                                        &ctlr->r_rid2,
1902                                                        RF_ACTIVE)))
1903                 return ata_ahci_chipinit(dev);
1904         }
1905         ctlr->setmode = ata_sata_setmode;
1906
1907         /* enable PCI interrupt */
1908         pci_write_config(dev, PCIR_COMMAND,
1909                          pci_read_config(dev, PCIR_COMMAND, 2) & ~0x0400, 2);
1910     }
1911     return 0;
1912 }
1913
1914 static int
1915 ata_intel_allocate(device_t dev)
1916 {
1917     struct ata_channel *ch = device_get_softc(dev);
1918
1919     /* setup the usual register normal pci style */
1920     if (ata_pci_allocate(dev))
1921         return ENXIO;
1922
1923     ch->flags |= ATA_ALWAYS_DMASTAT;
1924     return 0;
1925 }
1926
1927 static void
1928 ata_intel_reset(device_t dev)
1929 {
1930     device_t parent = device_get_parent(dev);
1931     struct ata_pci_controller *ctlr = device_get_softc(parent);
1932     struct ata_channel *ch = device_get_softc(dev);
1933     int mask, timeout;
1934
1935     /* ICH6 & ICH7 in compat mode has 4 SATA ports as master/slave on 2 ch's */
1936     if (ctlr->chip->cfg1) {
1937         mask = (0x0005 << ch->unit);
1938     }
1939     else {
1940         /* ICH5 in compat mode has SATA ports as master/slave on 1 channel */
1941         if (pci_read_config(parent, 0x90, 1) & 0x04)
1942             mask = 0x0003;
1943         else {
1944             mask = (0x0001 << ch->unit);
1945             /* XXX SOS should be in intel_allocate if we grow it */
1946             ch->flags |= ATA_NO_SLAVE;
1947         }
1948     }
1949     pci_write_config(parent, 0x92, pci_read_config(parent, 0x92, 2) & ~mask, 2);
1950     DELAY(10);
1951     pci_write_config(parent, 0x92, pci_read_config(parent, 0x92, 2) | mask, 2);
1952
1953     /* wait up to 1 sec for "connect well" */
1954     for (timeout = 0; timeout < 100 ; timeout++) {
1955         if (((pci_read_config(parent, 0x92, 2) & (mask << 4)) == (mask << 4)) &&
1956             (ATA_IDX_INB(ch, ATA_STATUS) != 0xff))
1957             break;
1958         ata_udelay(10000);
1959     }
1960     ata_generic_reset(dev);
1961 }
1962
1963 static void
1964 ata_intel_old_setmode(device_t dev, int mode)
1965 {
1966     /* NOT YET */
1967 }
1968
1969 static void
1970 ata_intel_new_setmode(device_t dev, int mode)
1971 {
1972     device_t gparent = GRANDPARENT(dev);
1973     struct ata_pci_controller *ctlr = device_get_softc(gparent);
1974     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
1975     struct ata_device *atadev = device_get_softc(dev);
1976     int devno = (ch->unit << 1) + ATA_DEV(atadev->unit);
1977     u_int32_t reg40 = pci_read_config(gparent, 0x40, 4);
1978     u_int8_t reg44 = pci_read_config(gparent, 0x44, 1);
1979     u_int8_t reg48 = pci_read_config(gparent, 0x48, 1);
1980     u_int16_t reg4a = pci_read_config(gparent, 0x4a, 2);
1981     u_int16_t reg54 = pci_read_config(gparent, 0x54, 2);
1982     u_int32_t mask40 = 0, new40 = 0;
1983     u_int8_t mask44 = 0, new44 = 0;
1984     int error;
1985     u_int8_t timings[] = { 0x00, 0x00, 0x10, 0x21, 0x23, 0x10, 0x21, 0x23,
1986                            0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23 };
1987                         /* PIO0  PIO1  PIO2  PIO3  PIO4  WDMA0 WDMA1 WDMA2 */
1988                         /* UDMA0 UDMA1 UDMA2 UDMA3 UDMA4 UDMA5 UDMA6 */
1989
1990     mode = ata_limit_mode(dev, mode, ctlr->chip->max_dma);
1991
1992     if ( mode > ATA_UDMA2 && !(reg54 & (0x10 << devno))) {
1993         ata_print_cable(dev, "controller");
1994         mode = ATA_UDMA2;
1995     }
1996
1997     error = ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode);
1998
1999     if (bootverbose)
2000         device_printf(dev, "%ssetting %s on %s chip\n",
2001                       (error) ? "FAILURE " : "",
2002                       ata_mode2str(mode), ctlr->chip->text);
2003     if (error)
2004         return;
2005
2006     /*
2007      * reg48: 1 bit per (primary drive 0, primary drive 1, secondary
2008      *                   drive 0, secondary drive 1)
2009      *
2010      *          0 Disable Ultra DMA mode
2011      *          1 Enable Ultra DMA mode
2012      *
2013      * reg4a: 4 bits per (primary drive 0, primary drive 1, secondary
2014      *                    drive 0, secondary drive 1).
2015      *          0000 UDMA mode 0
2016      *          0001 UDMA mode 1, 3, 5
2017      *          0010 UDMA mode 2, 4, reserved
2018      *          0011 reserved
2019      *          (top two bits for each drive reserved)
2020      */
2021 #if 0
2022     device_printf(dev,
2023                   "regs before 40=%08x 44=%02x 48=%02x 4a=%04x 54=%04x\n",
2024                   reg40, reg44, reg48 ,reg4a, reg54);
2025 #endif
2026     reg48 &= ~(0x0001 << devno);
2027     reg4a &= ~(0x3 << (devno << 2));
2028     if (mode >= ATA_UDMA0) {
2029         reg48 |= 0x0001 << devno;
2030         if (mode > ATA_UDMA0) 
2031             reg4a |= (1 + !(mode & 0x01)) << (devno << 2);
2032     }
2033     pci_write_config(gparent, 0x48, reg48, 2);
2034     pci_write_config(gparent, 0x4a, reg4a, 2);
2035
2036     /*
2037      * reg54:
2038      *
2039      *  32:20   reserved
2040      *  19:18   Secondary ATA signal mode
2041      *  17:16   Primary ATA signal mode
2042      *          00 = Normal (enabled)
2043      *          01 = Tri-state (disabled)
2044      *          10 = Drive Low (disabled)
2045      *          11 = Reserved
2046      *
2047      *  15      Secondary drive 1       - Base Clock
2048      *  14      Secondary drive 0       - Base Clock
2049      *  13      Primary drive 1         - Base Clock
2050      *  12      Primary drive 0         - Base Clock
2051      *          0 = Select 33 MHz clock
2052      *          1 = Select 100 Mhz clock
2053      *
2054      *  11      Reserved
2055      *  10      Vendor specific (set by BIOS?)
2056      *  09:08   Reserved
2057      *
2058      *  07      Secondary drive 1       - Cable Type
2059      *  06      Secondary drive 0       - Cable Type
2060      *  05      Primary drive 1         - Cable Type
2061      *  04      Primary drive 0         - Cable Type
2062      *          0 = 40 Conductor
2063      *          1 = 80 Conductor (or high speed cable)
2064      *
2065      *  03      Secondary drive 1       - Select 33/66 clock
2066      *  02      Secondary drive 0       - Select 33/66 clock
2067      *  01      Primary drive 1         - Select 33/66 clock
2068      *  00      Primary drive 0         - Select 33/66 clock
2069      *          0 = Select 33 MHz
2070      *          1 = Select 66 MHz
2071      *
2072      *          It is unclear what this should be set to when operating
2073      *          in 100MHz mode.
2074      *
2075      * NOTE: UDMA2 = 33 MHz
2076      *       UDMA3 = 40 MHz (?) - unsupported
2077      *       UDMA4 = 66 MHz
2078      *       UDMA5 = 100 MHz
2079      *       UDMA6 = 133 Mhz
2080      */
2081     reg54 |= 0x0400;    /* set vendor specific bit */
2082     reg54 &= ~((0x1 << devno) | (0x1000 << devno));
2083
2084     if (mode >= ATA_UDMA5)
2085         reg54 |= (0x1000 << devno);
2086     else if (mode >= ATA_UDMA3) /* XXX should this be ATA_UDMA3 or 4? */
2087         reg54 |= (0x1 << devno);
2088
2089     pci_write_config(gparent, 0x54, reg54, 2);
2090
2091     /*
2092      * Reg40 (32 bits... well, actually two 16 bit registers)
2093      *
2094      * Primary channel bits 15:00, Secondary channel bits 31:00.  Note
2095      * that slave timings are handled in register 44.
2096      *
2097      * 15       ATA Decode Enable (R/W) 1 = enable decoding of I/O ranges
2098      *
2099      * 14       Slave ATA Timing Register Enable (R/W)
2100      *
2101      * 13:12    IORDY Sample Mode
2102      *          00      PIO-0
2103      *          01      PIO-2, SW-2
2104      *          10      PIO-3, PIO-4, MW-1, MW-2
2105      *          11      Reserved
2106      *
2107      * 11:10    Reserved
2108      *
2109      * 09:08    Recovery Mode
2110      *          00      PIO-0, PIO-2, SW-2
2111      *          01      PIO-3, MW-1
2112      *          10      Reserved
2113      *          11      PIO-4, MW-2
2114      *
2115      * 07:04    Secondary Device Control Bits
2116      * 03:00    Primary Device Control Bits
2117      *
2118      *          bit 3   DMA Timing Enable
2119      *
2120      *          bit 2   Indicate Presence of ATA(1) or ATAPI(0) device
2121      *
2122      *          bit 1   Enable IORDY sample point capability for PIO
2123      *                  xfers.  Always enabled for PIO4 and PIO3, enabled
2124      *                  for PIO2 if indicated by the device, and otherwise
2125      *                  probably should be 0.
2126      *
2127      *          bit 0   Fast Drive Timing Enable.  Enables faster then PIO-0
2128      *                  timing modes.
2129      */
2130
2131     /*
2132      * Modify reg40 according to the table
2133      */
2134     if (atadev->unit == ATA_MASTER) {
2135         mask40 = 0x3300;
2136         new40 = timings[ata_mode2idx(mode)] << 8;
2137     }
2138     else {
2139         mask44 = 0x0f;
2140         new44 = ((timings[ata_mode2idx(mode)] & 0x30) >> 2) |
2141                 (timings[ata_mode2idx(mode)] & 0x03);
2142     }
2143
2144     /*
2145      * Slave ATA timing register enable
2146      */
2147     mask40 |= 0x4000;
2148     new40  |= 0x4000;
2149
2150     /*
2151      * Device control bits 3:0 for master, 7:4 for slave.
2152      *
2153      * bit3 DMA Timing enable.
2154      * bit2 Indicate presence of ATA(1) or ATAPI(0) device, set accordingly
2155      * bit1 Enable IORDY sample point capability for PIO xfers.  Always
2156      *      enabled for PIO4 and PIO3, enabled for PIO2 if indicated by
2157      *      the device, and otherwise should be 0.
2158      * bit0 Fast Drive Timing Enable.  Enable faster then PIO-0 timing modes.
2159      *
2160      * Set to: 0 x 1 1
2161      */
2162
2163     if (atadev->unit == ATA_MASTER) {
2164         mask40 |= 0x0F;
2165         new40 |= 0x03;
2166         if (!ata_atapi(dev))
2167             new40 |= 0x04;
2168     } else {
2169         mask40 |= 0xF0;
2170         new40 |= 0x30;
2171         if (!ata_atapi(dev))
2172             new40 |= 0x40;
2173     }
2174     /*
2175     reg40 &= ~0x00ff00ff;
2176     reg40 |= 0x40774077;
2177     */
2178
2179     /*
2180      * Primary or Secondary controller
2181      */
2182     if (ch->unit) {
2183         mask40 <<= 16;
2184         new40 <<= 16;
2185         mask44 <<= 4;
2186         new44 <<= 4;
2187     }
2188     pci_write_config(gparent, 0x40, (reg40 & ~mask40) | new40, 4);
2189     pci_write_config(gparent, 0x44, (reg44 & ~mask44) | new44, 1);
2190
2191 #if 0
2192     reg40 = pci_read_config(gparent, 0x40, 4);
2193     reg44 = pci_read_config(gparent, 0x44, 1);
2194     reg48 = pci_read_config(gparent, 0x48, 1);
2195     reg4a = pci_read_config(gparent, 0x4a, 2);
2196     reg54 = pci_read_config(gparent, 0x54, 2);
2197     device_printf(dev,
2198                   "regs after 40=%08x 44=%02x 48=%02x 4a=%04x 54=%04x\n",
2199                   reg40, reg44, reg48 ,reg4a, reg54);
2200 #endif
2201
2202     atadev->mode = mode;
2203 }
2204
2205 static int
2206 ata_intel_31244_allocate(device_t dev)
2207 {
2208     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
2209     struct ata_channel *ch = device_get_softc(dev);
2210     int i;
2211     int ch_offset;
2212
2213     ch_offset = 0x200 + ch->unit * 0x200;
2214
2215     for (i = ATA_DATA; i < ATA_MAX_RES; i++)
2216         ch->r_io[i].res = ctlr->r_res2;
2217
2218     /* setup ATA registers */
2219     ch->r_io[ATA_DATA].offset = ch_offset + 0x00;
2220     ch->r_io[ATA_FEATURE].offset = ch_offset + 0x06;
2221     ch->r_io[ATA_COUNT].offset = ch_offset + 0x08;
2222     ch->r_io[ATA_SECTOR].offset = ch_offset + 0x0c;
2223     ch->r_io[ATA_CYL_LSB].offset = ch_offset + 0x10;
2224     ch->r_io[ATA_CYL_MSB].offset = ch_offset + 0x14;
2225     ch->r_io[ATA_DRIVE].offset = ch_offset + 0x18;
2226     ch->r_io[ATA_COMMAND].offset = ch_offset + 0x1d;
2227     ch->r_io[ATA_ERROR].offset = ch_offset + 0x04;
2228     ch->r_io[ATA_STATUS].offset = ch_offset + 0x1c;
2229     ch->r_io[ATA_ALTSTAT].offset = ch_offset + 0x28;
2230     ch->r_io[ATA_CONTROL].offset = ch_offset + 0x29;
2231
2232     /* setup DMA registers */
2233     ch->r_io[ATA_SSTATUS].offset = ch_offset + 0x100;
2234     ch->r_io[ATA_SERROR].offset = ch_offset + 0x104;
2235     ch->r_io[ATA_SCONTROL].offset = ch_offset + 0x108;
2236
2237     /* setup SATA registers */
2238     ch->r_io[ATA_BMCMD_PORT].offset = ch_offset + 0x70;
2239     ch->r_io[ATA_BMSTAT_PORT].offset = ch_offset + 0x72;
2240     ch->r_io[ATA_BMDTP_PORT].offset = ch_offset + 0x74;
2241
2242     ch->flags |= ATA_NO_SLAVE;
2243     ata_pci_hw(dev);
2244     ch->hw.status = ata_intel_31244_status;
2245     ch->hw.command = ata_intel_31244_command;
2246
2247     /* enable PHY state change interrupt */
2248     ATA_OUTL(ctlr->r_res2, 0x4,
2249              ATA_INL(ctlr->r_res2, 0x04) | (0x01 << (ch->unit << 3)));
2250     return 0;
2251 }
2252
2253 static int
2254 ata_intel_31244_status(device_t dev)
2255 {
2256     /* do we have any PHY events ? */
2257     ata_sata_phy_check_events(dev);
2258
2259     /* any drive action to take care of ? */
2260     return ata_pci_status(dev);
2261 }
2262
2263 static int
2264 ata_intel_31244_command(struct ata_request *request)
2265 {
2266     struct ata_channel *ch = device_get_softc(device_get_parent(request->dev));
2267     struct ata_device *atadev = device_get_softc(request->dev);
2268     u_int64_t lba;
2269
2270     if (!(atadev->flags & ATA_D_48BIT_ACTIVE))
2271             return (ata_generic_command(request));
2272
2273     lba = request->u.ata.lba;
2274     ATA_IDX_OUTB(ch, ATA_DRIVE, ATA_D_IBM | ATA_D_LBA | atadev->unit);
2275     /* enable interrupt */
2276     ATA_IDX_OUTB(ch, ATA_CONTROL, ATA_A_4BIT);
2277     ATA_IDX_OUTW(ch, ATA_FEATURE, request->u.ata.feature);
2278     ATA_IDX_OUTW(ch, ATA_COUNT, request->u.ata.count);
2279     ATA_IDX_OUTW(ch, ATA_SECTOR, ((lba >> 16) & 0xff00) | (lba & 0x00ff));
2280     ATA_IDX_OUTW(ch, ATA_CYL_LSB, ((lba >> 24) & 0xff00) |
2281                                   ((lba >> 8) & 0x00ff));
2282     ATA_IDX_OUTW(ch, ATA_CYL_MSB, ((lba >> 32) & 0xff00) | 
2283                                   ((lba >> 16) & 0x00ff));
2284
2285     /* issue command to controller */
2286     ATA_IDX_OUTB(ch, ATA_COMMAND, request->u.ata.command);
2287
2288     return 0;
2289 }
2290
2291 static void
2292 ata_intel_31244_reset(device_t dev)
2293 {
2294     if (ata_sata_phy_reset(dev))
2295         ata_generic_reset(dev);
2296 }
2297
2298
2299 /*
2300  * Integrated Technology Express Inc. (ITE) chipset support functions
2301  */
2302 int
2303 ata_ite_ident(device_t dev)
2304 {
2305     struct ata_pci_controller *ctlr = device_get_softc(dev);
2306     struct ata_chip_id *idx;
2307     static struct ata_chip_id ids[] =
2308     {{ ATA_IT8212F, 0x00, 0x00, 0x00, ATA_UDMA6, "IT8212F" },
2309      { ATA_IT8211F, 0x00, 0x00, 0x00, ATA_UDMA6, "IT8211F" },
2310      { 0, 0, 0, 0, 0, 0}};
2311     char buffer[64]; 
2312
2313     if (!(idx = ata_match_chip(dev, ids)))
2314         return ENXIO;
2315
2316     ksprintf(buffer, "ITE %s %s controller",
2317             idx->text, ata_mode2str(idx->max_dma));
2318     device_set_desc_copy(dev, buffer);
2319     ctlr->chip = idx;
2320     ctlr->chipinit = ata_ite_chipinit;
2321     return 0;
2322 }
2323
2324 static int
2325 ata_ite_chipinit(device_t dev)
2326 {
2327     struct ata_pci_controller *ctlr = device_get_softc(dev);
2328
2329     if (ata_setup_interrupt(dev))
2330         return ENXIO;
2331
2332     ctlr->setmode = ata_ite_setmode;
2333
2334     /* set PCI mode and 66Mhz reference clock */
2335     pci_write_config(dev, 0x50, pci_read_config(dev, 0x50, 1) & ~0x83, 1);
2336
2337     /* set default active & recover timings */
2338     pci_write_config(dev, 0x54, 0x31, 1);
2339     pci_write_config(dev, 0x56, 0x31, 1);
2340     return 0;
2341 }
2342  
2343 static void
2344 ata_ite_setmode(device_t dev, int mode)
2345 {
2346     device_t gparent = GRANDPARENT(dev);
2347     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
2348     struct ata_device *atadev = device_get_softc(dev);
2349     int devno = (ch->unit << 1) + ATA_DEV(atadev->unit);
2350     int error;
2351
2352     /* correct the mode for what the HW supports */
2353     mode = ata_limit_mode(dev, mode, ATA_UDMA6);
2354
2355     /* check the CBLID bits for 80 conductor cable detection */
2356     if (mode > ATA_UDMA2 && (pci_read_config(gparent, 0x40, 2) &
2357                              (ch->unit ? (1<<3) : (1<<2)))) {
2358         ata_print_cable(dev, "controller");
2359         mode = ATA_UDMA2;
2360     }
2361
2362     /* set the wanted mode on the device */
2363     error = ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode);
2364
2365     if (bootverbose)
2366         device_printf(dev, "%s setting %s on ITE8212F chip\n",
2367                       (error) ? "failed" : "success", ata_mode2str(mode));
2368
2369     /* if the device accepted the mode change, setup the HW accordingly */
2370     if (!error) {
2371         if (mode >= ATA_UDMA0) {
2372             u_int8_t udmatiming[] =
2373                 { 0x44, 0x42, 0x31, 0x21, 0x11, 0xa2, 0x91 };
2374
2375             /* enable UDMA mode */
2376             pci_write_config(gparent, 0x50,
2377                              pci_read_config(gparent, 0x50, 1) &
2378                              ~(1 << (devno + 3)), 1);
2379
2380             /* set UDMA timing */
2381             pci_write_config(gparent,
2382                              0x56 + (ch->unit << 2) + ATA_DEV(atadev->unit),
2383                              udmatiming[mode & ATA_MODE_MASK], 1);
2384         }
2385         else {
2386             u_int8_t chtiming[] =
2387                 { 0xaa, 0xa3, 0xa1, 0x33, 0x31, 0x88, 0x32, 0x31 };
2388
2389             /* disable UDMA mode */
2390             pci_write_config(gparent, 0x50,
2391                              pci_read_config(gparent, 0x50, 1) |
2392                              (1 << (devno + 3)), 1);
2393
2394             /* set active and recover timing (shared between master & slave) */
2395             if (pci_read_config(gparent, 0x54 + (ch->unit << 2), 1) <
2396                 chtiming[ata_mode2idx(mode)])
2397                 pci_write_config(gparent, 0x54 + (ch->unit << 2),
2398                                  chtiming[ata_mode2idx(mode)], 1);
2399         }
2400         atadev->mode = mode;
2401     }
2402 }
2403
2404
2405 /*
2406  * JMicron chipset support functions
2407  */
2408 int
2409 ata_jmicron_ident(device_t dev)
2410 {
2411     struct ata_pci_controller *ctlr = device_get_softc(dev);
2412     struct ata_chip_id *idx;
2413     static struct ata_chip_id ids[] =
2414     {{ ATA_JMB360, 0, 1, 0, ATA_SA300, "JMB360" },
2415      { ATA_JMB361, 0, 1, 1, ATA_SA300, "JMB361" },
2416      { ATA_JMB363, 0, 2, 1, ATA_SA300, "JMB363" },
2417      { ATA_JMB365, 0, 1, 2, ATA_SA300, "JMB365" },
2418      { ATA_JMB366, 0, 2, 2, ATA_SA300, "JMB366" },
2419      { ATA_JMB368, 0, 0, 1, ATA_UDMA6, "JMB368" },
2420      { 0, 0, 0, 0, 0, 0}};
2421     char buffer[64];
2422
2423     if (!(idx = ata_match_chip(dev, ids)))
2424         return ENXIO;
2425
2426     if ((pci_read_config(dev, 0xdf, 1) & 0x40) &&
2427         (pci_get_function(dev) == (pci_read_config(dev, 0x40, 1) & 0x02 >> 1)))
2428         ksnprintf(buffer, sizeof(buffer), "JMicron %s %s controller",
2429                 idx->text, ata_mode2str(ATA_UDMA6));
2430     else
2431         ksnprintf(buffer, sizeof(buffer), "JMicron %s %s controller",
2432                 idx->text, ata_mode2str(idx->max_dma));
2433     device_set_desc_copy(dev, buffer);
2434     ctlr->chip = idx;
2435     ctlr->chipinit = ata_jmicron_chipinit;
2436     return 0;
2437 }
2438
2439 static int
2440 ata_jmicron_chipinit(device_t dev)
2441 {
2442     struct ata_pci_controller *ctlr = device_get_softc(dev);
2443     int error;
2444
2445     if (ata_setup_interrupt(dev))
2446         return ENXIO;
2447
2448     /* do we have multiple PCI functions ? */
2449     if (pci_read_config(dev, 0xdf, 1) & 0x40) {
2450         /* if we have a memory BAR(5) we are on the AHCI part */
2451         ctlr->r_type2 = SYS_RES_MEMORY;
2452         ctlr->r_rid2 = PCIR_BAR(5);
2453         if ((ctlr->r_res2 = bus_alloc_resource_any(dev, ctlr->r_type2,
2454                                                    &ctlr->r_rid2, RF_ACTIVE)))
2455             return ata_ahci_chipinit(dev);
2456
2457         /* otherwise we are on the PATA part */
2458         ctlr->allocate = ata_pci_allocate;
2459         ctlr->reset = ata_generic_reset;
2460         ctlr->dmainit = ata_pci_dmainit;
2461         ctlr->setmode = ata_jmicron_setmode;
2462         ctlr->channels = ctlr->chip->cfg2;
2463     }
2464     else {
2465         /* set controller configuration to a combined setup we support */
2466         pci_write_config(dev, 0x40, 0x80c0a131, 4);
2467         pci_write_config(dev, 0x80, 0x01200000, 4);
2468
2469         ctlr->r_type2 = SYS_RES_MEMORY;
2470         ctlr->r_rid2 = PCIR_BAR(5);
2471         if ((ctlr->r_res2 = bus_alloc_resource_any(dev, ctlr->r_type2,
2472                                                    &ctlr->r_rid2, RF_ACTIVE))) {
2473             if ((error = ata_ahci_chipinit(dev)))
2474                 return error;
2475         }
2476
2477         ctlr->allocate = ata_jmicron_allocate;
2478         ctlr->reset = ata_jmicron_reset;
2479         ctlr->dmainit = ata_jmicron_dmainit;
2480         ctlr->setmode = ata_jmicron_setmode;
2481
2482         /* set the number of HW channels */ 
2483         ctlr->channels = ctlr->chip->cfg1 + ctlr->chip->cfg2;
2484     }
2485     return 0;
2486 }
2487
2488 static int
2489 ata_jmicron_allocate(device_t dev)
2490 {
2491     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
2492     struct ata_channel *ch = device_get_softc(dev);
2493     int error;
2494
2495     if (ch->unit >= ctlr->chip->cfg1) {
2496         ch->unit -= ctlr->chip->cfg1;
2497         error = ata_pci_allocate(dev);
2498         ch->unit += ctlr->chip->cfg1;
2499     }
2500     else
2501         error = ata_ahci_allocate(dev);
2502     return error;
2503 }
2504
2505 static void
2506 ata_jmicron_reset(device_t dev)
2507 {
2508     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
2509     struct ata_channel *ch = device_get_softc(dev);
2510
2511     if (ch->unit >= ctlr->chip->cfg1)
2512         ata_generic_reset(dev);
2513     else
2514         ata_ahci_reset(dev);
2515 }
2516
2517 static void
2518 ata_jmicron_dmainit(device_t dev)
2519 {
2520     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
2521     struct ata_channel *ch = device_get_softc(dev);
2522
2523     if (ch->unit >= ctlr->chip->cfg1)
2524         ata_pci_dmainit(dev);
2525     else
2526         ata_ahci_dmainit(dev);
2527 }
2528
2529 static void
2530 ata_jmicron_setmode(device_t dev, int mode)
2531 {
2532     struct ata_pci_controller *ctlr = device_get_softc(GRANDPARENT(dev));
2533     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
2534
2535     if (pci_read_config(dev, 0xdf, 1) & 0x40 || ch->unit >= ctlr->chip->cfg1) {
2536         struct ata_device *atadev = device_get_softc(dev);
2537
2538         /* check for 80pin cable present */
2539         if (pci_read_config(dev, 0x40, 1) & 0x08)
2540             mode = ata_limit_mode(dev, mode, ATA_UDMA2);
2541         else
2542             mode = ata_limit_mode(dev, mode, ATA_UDMA6);
2543
2544         if (!ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode))
2545             atadev->mode = mode;
2546     }
2547     else
2548         ata_sata_setmode(dev, mode);
2549 }
2550
2551
2552 /*
2553  * Marvell chipset support functions
2554  */
2555 #define ATA_MV_HOST_BASE(ch) \
2556         ((ch->unit & 3) * 0x0100) + (ch->unit > 3 ? 0x30000 : 0x20000)
2557 #define ATA_MV_EDMA_BASE(ch) \
2558         ((ch->unit & 3) * 0x2000) + (ch->unit > 3 ? 0x30000 : 0x20000)
2559
2560 struct ata_marvell_response {
2561     u_int16_t   tag;
2562     u_int8_t    edma_status;
2563     u_int8_t    dev_status;
2564     u_int32_t   timestamp;
2565 };
2566
2567 struct ata_marvell_dma_prdentry {
2568     u_int32_t addrlo;
2569     u_int32_t count;
2570     u_int32_t addrhi;
2571     u_int32_t reserved;
2572 };  
2573
2574 int
2575 ata_marvell_ident(device_t dev)
2576 {
2577     struct ata_pci_controller *ctlr = device_get_softc(dev);
2578     struct ata_chip_id *idx;
2579     static struct ata_chip_id ids[] =
2580     {{ ATA_M88SX5040, 0, 4, MV50XX, ATA_SA150, "88SX5040" },
2581      { ATA_M88SX5041, 0, 4, MV50XX, ATA_SA150, "88SX5041" },
2582      { ATA_M88SX5080, 0, 8, MV50XX, ATA_SA150, "88SX5080" },
2583      { ATA_M88SX5081, 0, 8, MV50XX, ATA_SA150, "88SX5081" },
2584      { ATA_M88SX6041, 0, 4, MV60XX, ATA_SA300, "88SX6041" },
2585      { ATA_M88SX6081, 0, 8, MV60XX, ATA_SA300, "88SX6081" },
2586      { ATA_M88SX6101, 0, 1, MV61XX, ATA_UDMA6, "88SX6101" },
2587      { ATA_M88SX6145, 0, 2, MV61XX, ATA_UDMA6, "88SX6145" },
2588      { 0, 0, 0, 0, 0, 0}};
2589     char buffer[64];
2590
2591     if (!(idx = ata_match_chip(dev, ids)))
2592         return ENXIO;
2593
2594     ksprintf(buffer, "Marvell %s %s controller",
2595             idx->text, ata_mode2str(idx->max_dma));
2596     device_set_desc_copy(dev, buffer);
2597     ctlr->chip = idx;
2598     switch (ctlr->chip->cfg2) {
2599     case MV50XX:
2600     case MV60XX:
2601         ctlr->chipinit = ata_marvell_edma_chipinit;
2602         break;
2603     case MV61XX:
2604         ctlr->chipinit = ata_marvell_pata_chipinit;
2605         break;
2606     }
2607     return 0;
2608 }
2609
2610 static int
2611 ata_marvell_pata_chipinit(device_t dev)
2612 {
2613     struct ata_pci_controller *ctlr = device_get_softc(dev);
2614
2615     if (ata_setup_interrupt(dev))
2616         return ENXIO;
2617
2618     ctlr->allocate = ata_marvell_pata_allocate;
2619     ctlr->setmode = ata_marvell_pata_setmode;
2620     ctlr->channels = ctlr->chip->cfg1;
2621     return 0;
2622 }
2623
2624 static int
2625 ata_marvell_pata_allocate(device_t dev)
2626 {
2627     struct ata_channel *ch = device_get_softc(dev);
2628  
2629     /* setup the usual register normal pci style */
2630     if (ata_pci_allocate(dev))
2631         return ENXIO;
2632  
2633     /* dont use 32 bit PIO transfers */
2634     ch->flags |= ATA_USE_16BIT;
2635
2636     return 0;
2637 }
2638
2639 static void
2640 ata_marvell_pata_setmode(device_t dev, int mode)
2641 {
2642     device_t gparent = GRANDPARENT(dev);
2643     struct ata_pci_controller *ctlr = device_get_softc(gparent);
2644     struct ata_device *atadev = device_get_softc(dev);
2645
2646     mode = ata_limit_mode(dev, mode, ctlr->chip->max_dma);
2647     mode = ata_check_80pin(dev, mode);
2648     if (!ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode))
2649         atadev->mode = mode;
2650 }
2651
2652 static int
2653 ata_marvell_edma_chipinit(device_t dev)
2654 {
2655     struct ata_pci_controller *ctlr = device_get_softc(dev);
2656
2657     if (ata_setup_interrupt(dev))
2658         return ENXIO;
2659
2660     ctlr->r_type1 = SYS_RES_MEMORY;
2661     ctlr->r_rid1 = PCIR_BAR(0);
2662     if (!(ctlr->r_res1 = bus_alloc_resource_any(dev, ctlr->r_type1,
2663                                                 &ctlr->r_rid1, RF_ACTIVE)))
2664         return ENXIO;
2665
2666     /* mask all host controller interrupts */
2667     ATA_OUTL(ctlr->r_res1, 0x01d64, 0x00000000);
2668
2669     /* mask all PCI interrupts */
2670     ATA_OUTL(ctlr->r_res1, 0x01d5c, 0x00000000);
2671
2672     ctlr->allocate = ata_marvell_edma_allocate;
2673     ctlr->reset = ata_marvell_edma_reset;
2674     ctlr->dmainit = ata_marvell_edma_dmainit;
2675     ctlr->setmode = ata_sata_setmode;
2676     ctlr->channels = ctlr->chip->cfg1;
2677
2678     /* clear host controller interrupts */
2679     ATA_OUTL(ctlr->r_res1, 0x20014, 0x00000000);
2680     if (ctlr->chip->cfg1 > 4)
2681         ATA_OUTL(ctlr->r_res1, 0x30014, 0x00000000);
2682
2683     /* clear PCI interrupts */
2684     ATA_OUTL(ctlr->r_res1, 0x01d58, 0x00000000);
2685
2686     /* unmask PCI interrupts we want */
2687     ATA_OUTL(ctlr->r_res1, 0x01d5c, 0x007fffff);
2688
2689     /* unmask host controller interrupts we want */
2690     ATA_OUTL(ctlr->r_res1, 0x01d64, 0x000000ff/*HC0*/ | 0x0001fe00/*HC1*/ |
2691              /*(1<<19) | (1<<20) | (1<<21) |*/(1<<22) | (1<<24) | (0x7f << 25));
2692
2693     /* enable PCI interrupt */
2694     pci_write_config(dev, PCIR_COMMAND,
2695                      pci_read_config(dev, PCIR_COMMAND, 2) & ~0x0400, 2);
2696     return 0;
2697 }
2698
2699 static int
2700 ata_marvell_edma_allocate(device_t dev)
2701 {
2702     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
2703     struct ata_channel *ch = device_get_softc(dev);
2704     u_int64_t work = ch->dma->work_bus;
2705     int i;
2706
2707     /* clear work area */
2708     bzero(ch->dma->work, 1024+256);
2709
2710     /* set legacy ATA resources */
2711     for (i = ATA_DATA; i <= ATA_COMMAND; i++) {
2712         ch->r_io[i].res = ctlr->r_res1;
2713         ch->r_io[i].offset = 0x02100 + (i << 2) + ATA_MV_EDMA_BASE(ch);
2714     }
2715     ch->r_io[ATA_CONTROL].res = ctlr->r_res1;
2716     ch->r_io[ATA_CONTROL].offset = 0x02120 + ATA_MV_EDMA_BASE(ch);
2717     ch->r_io[ATA_IDX_ADDR].res = ctlr->r_res1;
2718     ata_default_registers(dev);
2719
2720     /* set SATA resources */
2721     switch (ctlr->chip->cfg2) {
2722     case MV50XX:
2723         ch->r_io[ATA_SSTATUS].res = ctlr->r_res1;
2724         ch->r_io[ATA_SSTATUS].offset =  0x00100 + ATA_MV_HOST_BASE(ch);
2725         ch->r_io[ATA_SERROR].res = ctlr->r_res1;
2726         ch->r_io[ATA_SERROR].offset = 0x00104 + ATA_MV_HOST_BASE(ch);
2727         ch->r_io[ATA_SCONTROL].res = ctlr->r_res1;
2728         ch->r_io[ATA_SCONTROL].offset = 0x00108 + ATA_MV_HOST_BASE(ch);
2729         break;
2730     case MV60XX:
2731         ch->r_io[ATA_SSTATUS].res = ctlr->r_res1;
2732         ch->r_io[ATA_SSTATUS].offset =  0x02300 + ATA_MV_EDMA_BASE(ch);
2733         ch->r_io[ATA_SERROR].res = ctlr->r_res1;
2734         ch->r_io[ATA_SERROR].offset = 0x02304 + ATA_MV_EDMA_BASE(ch);
2735         ch->r_io[ATA_SCONTROL].res = ctlr->r_res1;
2736         ch->r_io[ATA_SCONTROL].offset = 0x02308 + ATA_MV_EDMA_BASE(ch);
2737         ch->r_io[ATA_SACTIVE].res = ctlr->r_res1;
2738         ch->r_io[ATA_SACTIVE].offset = 0x02350 + ATA_MV_EDMA_BASE(ch);
2739         break;
2740     }
2741
2742     ch->flags |= ATA_NO_SLAVE;
2743     ch->flags |= ATA_USE_16BIT; /* XXX SOS needed ? */
2744     ata_generic_hw(dev);
2745     ch->hw.begin_transaction = ata_marvell_edma_begin_transaction;
2746     ch->hw.end_transaction = ata_marvell_edma_end_transaction;
2747     ch->hw.status = ata_marvell_edma_status;
2748
2749     /* disable the EDMA machinery */
2750     ATA_OUTL(ctlr->r_res1, 0x02028 + ATA_MV_EDMA_BASE(ch), 0x00000002);
2751     DELAY(100000);       /* SOS should poll for disabled */
2752
2753     /* set configuration to non-queued 128b read transfers stop on error */
2754     ATA_OUTL(ctlr->r_res1, 0x02000 + ATA_MV_EDMA_BASE(ch), (1<<11) | (1<<13));
2755
2756     /* request queue base high */
2757     ATA_OUTL(ctlr->r_res1, 0x02010 + ATA_MV_EDMA_BASE(ch), work >> 32);
2758
2759     /* request queue in ptr */
2760     ATA_OUTL(ctlr->r_res1, 0x02014 + ATA_MV_EDMA_BASE(ch), work & 0xffffffff);
2761
2762     /* request queue out ptr */
2763     ATA_OUTL(ctlr->r_res1, 0x02018 + ATA_MV_EDMA_BASE(ch), 0x0);
2764
2765     /* response queue base high */
2766     work += 1024;
2767     ATA_OUTL(ctlr->r_res1, 0x0201c + ATA_MV_EDMA_BASE(ch), work >> 32);
2768
2769     /* response queue in ptr */
2770     ATA_OUTL(ctlr->r_res1, 0x02020 + ATA_MV_EDMA_BASE(ch), 0x0);
2771
2772     /* response queue out ptr */
2773     ATA_OUTL(ctlr->r_res1, 0x02024 + ATA_MV_EDMA_BASE(ch), work & 0xffffffff);
2774
2775     /* clear SATA error register */
2776     ATA_IDX_OUTL(ch, ATA_SERROR, ATA_IDX_INL(ch, ATA_SERROR));
2777
2778     /* clear any outstanding error interrupts */
2779     ATA_OUTL(ctlr->r_res1, 0x02008 + ATA_MV_EDMA_BASE(ch), 0x0);
2780
2781     /* unmask all error interrupts */
2782     ATA_OUTL(ctlr->r_res1, 0x0200c + ATA_MV_EDMA_BASE(ch), ~0x0);
2783     
2784     /* enable EDMA machinery */
2785     ATA_OUTL(ctlr->r_res1, 0x02028 + ATA_MV_EDMA_BASE(ch), 0x00000001);
2786     return 0;
2787 }
2788
2789 static int
2790 ata_marvell_edma_status(device_t dev)
2791 {
2792     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
2793     struct ata_channel *ch = device_get_softc(dev);
2794     u_int32_t cause = ATA_INL(ctlr->r_res1, 0x01d60);
2795     int shift = (ch->unit << 1) + (ch->unit > 3);
2796
2797     if (cause & (1 << shift)) {
2798
2799         /* clear interrupt(s) */
2800         ATA_OUTL(ctlr->r_res1, 0x02008 + ATA_MV_EDMA_BASE(ch), 0x0);
2801
2802         /* do we have any PHY events ? */
2803         ata_sata_phy_check_events(dev);
2804     }
2805
2806     /* do we have any device action ? */
2807     return (cause & (2 << shift));
2808 }
2809
2810 /* must be called with ATA channel locked and state_mtx held */
2811 static int
2812 ata_marvell_edma_begin_transaction(struct ata_request *request)
2813 {
2814     struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
2815     struct ata_channel *ch = device_get_softc(device_get_parent(request->dev));
2816     u_int32_t req_in;
2817     u_int8_t *bytep;
2818     u_int16_t *wordp;
2819     u_int32_t *quadp;
2820     int i, tag = 0x07;
2821     int dummy, error, slot;
2822
2823     /* only DMA R/W goes through the EMDA machine */
2824     if (request->u.ata.command != ATA_READ_DMA &&
2825         request->u.ata.command != ATA_WRITE_DMA) {
2826
2827         /* disable the EDMA machinery */
2828         if (ATA_INL(ctlr->r_res1, 0x02028 + ATA_MV_EDMA_BASE(ch)) & 0x00000001)
2829             ATA_OUTL(ctlr->r_res1, 0x02028 + ATA_MV_EDMA_BASE(ch), 0x00000002);
2830         return ata_begin_transaction(request);
2831     }
2832
2833     /* check for 48 bit access and convert if needed */
2834     ata_modify_if_48bit(request);
2835
2836     /* check sanity, setup SG list and DMA engine */
2837     if ((error = ch->dma->load(ch->dev, request->data, request->bytecount,
2838                                request->flags & ATA_R_READ, ch->dma->sg,
2839                                &dummy))) {
2840         device_printf(request->dev, "setting up DMA failed\n");
2841         request->result = error;
2842         return ATA_OP_FINISHED;
2843     }
2844
2845     /* get next free request queue slot */
2846     req_in = ATA_INL(ctlr->r_res1, 0x02014 + ATA_MV_EDMA_BASE(ch));
2847     slot = (((req_in & ~0xfffffc00) >> 5) + 0) & 0x1f;
2848     bytep = (u_int8_t *)(ch->dma->work);
2849     bytep += (slot << 5);
2850     wordp = (u_int16_t *)bytep;
2851     quadp = (u_int32_t *)bytep;
2852
2853     /* fill in this request */
2854     quadp[0] = (long)ch->dma->sg_bus & 0xffffffff;
2855     quadp[1] = (u_int64_t)ch->dma->sg_bus >> 32;
2856     wordp[4] = (request->flags & ATA_R_READ ? 0x01 : 0x00) | (tag<<1);
2857
2858     i = 10;
2859     bytep[i++] = (request->u.ata.count >> 8) & 0xff;
2860     bytep[i++] = 0x10 | ATA_COUNT;
2861     bytep[i++] = request->u.ata.count & 0xff;
2862     bytep[i++] = 0x10 | ATA_COUNT;
2863
2864     bytep[i++] = (request->u.ata.lba >> 24) & 0xff;
2865     bytep[i++] = 0x10 | ATA_SECTOR;
2866     bytep[i++] = request->u.ata.lba & 0xff;
2867     bytep[i++] = 0x10 | ATA_SECTOR;
2868
2869     bytep[i++] = (request->u.ata.lba >> 32) & 0xff;
2870     bytep[i++] = 0x10 | ATA_CYL_LSB;
2871     bytep[i++] = (request->u.ata.lba >> 8) & 0xff;
2872     bytep[i++] = 0x10 | ATA_CYL_LSB;
2873
2874     bytep[i++] = (request->u.ata.lba >> 40) & 0xff;
2875     bytep[i++] = 0x10 | ATA_CYL_MSB;
2876     bytep[i++] = (request->u.ata.lba >> 16) & 0xff;
2877     bytep[i++] = 0x10 | ATA_CYL_MSB;
2878
2879     bytep[i++] = ATA_D_LBA | ATA_D_IBM | ((request->u.ata.lba >> 24) & 0xf);
2880     bytep[i++] = 0x10 | ATA_DRIVE;
2881
2882     bytep[i++] = request->u.ata.command;
2883     bytep[i++] = 0x90 | ATA_COMMAND;
2884
2885     /* enable EDMA machinery if needed */
2886     if (!(ATA_INL(ctlr->r_res1, 0x02028 + ATA_MV_EDMA_BASE(ch)) & 0x00000001)) {
2887         ATA_OUTL(ctlr->r_res1, 0x02028 + ATA_MV_EDMA_BASE(ch), 0x00000001);
2888         while (!(ATA_INL(ctlr->r_res1,
2889                          0x02028 + ATA_MV_EDMA_BASE(ch)) & 0x00000001))
2890             DELAY(10);
2891     }
2892
2893     /* tell EDMA it has a new request */
2894     slot = (((req_in & ~0xfffffc00) >> 5) + 1) & 0x1f;
2895     req_in &= 0xfffffc00;
2896     req_in += (slot << 5);
2897     ATA_OUTL(ctlr->r_res1, 0x02014 + ATA_MV_EDMA_BASE(ch), req_in);
2898    
2899     return ATA_OP_CONTINUES;
2900 }
2901
2902 /* must be called with ATA channel locked and state_mtx held */
2903 static int
2904 ata_marvell_edma_end_transaction(struct ata_request *request)
2905 {
2906     struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
2907     struct ata_channel *ch = device_get_softc(device_get_parent(request->dev));
2908     int offset = (ch->unit > 3 ? 0x30014 : 0x20014);
2909     u_int32_t icr = ATA_INL(ctlr->r_res1, offset);
2910     int res;
2911
2912     /* EDMA interrupt */
2913     if ((icr & (0x0001 << (ch->unit & 3)))) {
2914         struct ata_marvell_response *response;
2915         u_int32_t rsp_in, rsp_out;
2916         int slot;
2917
2918         /* stop timeout */
2919         callout_stop(&request->callout);
2920
2921         /* get response ptr's */
2922         rsp_in = ATA_INL(ctlr->r_res1, 0x02020 + ATA_MV_EDMA_BASE(ch));
2923         rsp_out = ATA_INL(ctlr->r_res1, 0x02024 + ATA_MV_EDMA_BASE(ch));
2924         slot = (((rsp_in & ~0xffffff00) >> 3)) & 0x1f;
2925         rsp_out &= 0xffffff00;
2926         rsp_out += (slot << 3);
2927         response = (struct ata_marvell_response *)
2928                    (ch->dma->work + 1024 + (slot << 3));
2929
2930         /* record status for this request */
2931         request->status = response->dev_status;
2932         request->error = 0; 
2933
2934         /* ack response */
2935         ATA_OUTL(ctlr->r_res1, 0x02024 + ATA_MV_EDMA_BASE(ch), rsp_out);
2936
2937         /* update progress */
2938         if (!(request->status & ATA_S_ERROR) &&
2939             !(request->flags & ATA_R_TIMEOUT))
2940             request->donecount = request->bytecount;
2941
2942         /* unload SG list */
2943         ch->dma->unload(ch->dev);
2944
2945         res = ATA_OP_FINISHED;
2946     }
2947
2948     /* legacy ATA interrupt */
2949     else {
2950         res = ata_end_transaction(request);
2951     }
2952
2953     /* ack interrupt */
2954     ATA_OUTL(ctlr->r_res1, offset, ~(icr & (0x0101 << (ch->unit & 3))));
2955     return res;
2956 }
2957
2958 static void
2959 ata_marvell_edma_reset(device_t dev)
2960 {
2961     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
2962     struct ata_channel *ch = device_get_softc(dev);
2963
2964     /* disable the EDMA machinery */
2965     ATA_OUTL(ctlr->r_res1, 0x02028 + ATA_MV_EDMA_BASE(ch), 0x00000002);
2966     while ((ATA_INL(ctlr->r_res1, 0x02028 + ATA_MV_EDMA_BASE(ch)) & 0x00000001))
2967         DELAY(10);
2968
2969     /* clear SATA error register */
2970     ATA_IDX_OUTL(ch, ATA_SERROR, ATA_IDX_INL(ch, ATA_SERROR));
2971
2972     /* clear any outstanding error interrupts */
2973     ATA_OUTL(ctlr->r_res1, 0x02008 + ATA_MV_EDMA_BASE(ch), 0x0);
2974
2975     /* unmask all error interrupts */
2976     ATA_OUTL(ctlr->r_res1, 0x0200c + ATA_MV_EDMA_BASE(ch), ~0x0);
2977
2978     /* enable channel and test for devices */
2979     if (ata_sata_phy_reset(dev))
2980         ata_generic_reset(dev);
2981
2982     /* enable EDMA machinery */
2983     ATA_OUTL(ctlr->r_res1, 0x02028 + ATA_MV_EDMA_BASE(ch), 0x00000001);
2984 }
2985
2986 static void
2987 ata_marvell_edma_dmasetprd(void *xsc, bus_dma_segment_t *segs, int nsegs,
2988                            int error)
2989 {
2990     struct ata_dmasetprd_args *args = xsc;
2991     struct ata_marvell_dma_prdentry *prd = args->dmatab;
2992     int i;
2993
2994     if ((args->error = error))
2995         return;
2996
2997     for (i = 0; i < nsegs; i++) {
2998         prd[i].addrlo = htole32(segs[i].ds_addr);
2999         prd[i].count = htole32(segs[i].ds_len);
3000         prd[i].addrhi = htole32((u_int64_t)segs[i].ds_addr >> 32);
3001     }
3002     prd[i - 1].count |= htole32(ATA_DMA_EOT);
3003 }
3004
3005 static void
3006 ata_marvell_edma_dmainit(device_t dev)
3007 {
3008     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
3009     struct ata_channel *ch = device_get_softc(dev);
3010
3011     ata_dmainit(dev);
3012     if (ch->dma) {
3013         /* note start and stop are not used here */
3014         ch->dma->setprd = ata_marvell_edma_dmasetprd;
3015
3016         if (ATA_INL(ctlr->r_res1, 0x00d00) & 0x00000004)
3017             ch->dma->max_address = BUS_SPACE_MAXADDR;
3018
3019         /* chip does not reliably do 64K DMA transfers */
3020         ch->dma->max_iosize = 126 * DEV_BSIZE;
3021     }
3022 }
3023
3024
3025 /*
3026  * National chipset support functions
3027  */
3028 int
3029 ata_national_ident(device_t dev)
3030 {
3031     struct ata_pci_controller *ctlr = device_get_softc(dev);
3032
3033     /* this chip is a clone of the Cyrix chip, bugs and all */
3034     if (pci_get_devid(dev) == ATA_SC1100) {
3035         device_set_desc(dev, "National Geode SC1100 ATA33 controller");
3036         ctlr->chipinit = ata_national_chipinit;
3037         return 0;
3038     }
3039     return ENXIO;
3040 }
3041     
3042 static int
3043 ata_national_chipinit(device_t dev)
3044 {
3045     struct ata_pci_controller *ctlr = device_get_softc(dev);
3046     
3047     if (ata_setup_interrupt(dev))
3048         return ENXIO;
3049                     
3050     ctlr->setmode = ata_national_setmode;
3051     return 0;
3052 }
3053
3054 static void
3055 ata_national_setmode(device_t dev, int mode)
3056 {
3057     device_t gparent = GRANDPARENT(dev);
3058     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
3059     struct ata_device *atadev = device_get_softc(dev);
3060     int devno = (ch->unit << 1) + ATA_DEV(atadev->unit);
3061     u_int32_t piotiming[] =
3062         { 0x9172d132, 0x21717121, 0x00803020, 0x20102010, 0x00100010,
3063           0x00803020, 0x20102010, 0x00100010,
3064           0x00100010, 0x00100010, 0x00100010 };
3065     u_int32_t dmatiming[] = { 0x80077771, 0x80012121, 0x80002020 };
3066     u_int32_t udmatiming[] = { 0x80921250, 0x80911140, 0x80911030 };
3067     int error;
3068
3069     ch->dma->alignment = 16;
3070     ch->dma->max_iosize = 126 * DEV_BSIZE;
3071
3072     mode = ata_limit_mode(dev, mode, ATA_UDMA2);
3073
3074     error = ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode);
3075
3076     if (bootverbose)
3077         device_printf(dev, "%s setting %s on National chip\n",
3078                       (error) ? "failed" : "success", ata_mode2str(mode));
3079     if (!error) {
3080         if (mode >= ATA_UDMA0) {
3081             pci_write_config(gparent, 0x44 + (devno << 3),
3082                              udmatiming[mode & ATA_MODE_MASK], 4);
3083         }
3084         else if (mode >= ATA_WDMA0) {
3085             pci_write_config(gparent, 0x44 + (devno << 3),
3086                              dmatiming[mode & ATA_MODE_MASK], 4);
3087         }
3088         else {
3089             pci_write_config(gparent, 0x44 + (devno << 3),
3090                              pci_read_config(gparent, 0x44 + (devno << 3), 4) |
3091                              0x80000000, 4);
3092         }
3093         pci_write_config(gparent, 0x40 + (devno << 3),
3094                          piotiming[ata_mode2idx(mode)], 4);
3095         atadev->mode = mode;
3096     }
3097 }
3098
3099 /*
3100  * NetCell chipset support functions
3101  */
3102 int
3103 ata_netcell_ident(device_t dev)
3104 {
3105     struct ata_pci_controller *ctlr = device_get_softc(dev);
3106
3107     if (pci_get_devid(dev) == ATA_NETCELL_SR) {
3108         device_set_desc(dev, "Netcell SyncRAID SR3000/5000 RAID Controller");
3109         ctlr->chipinit = ata_netcell_chipinit;
3110         return 0;
3111     }
3112     return ENXIO;
3113 }
3114
3115 static int
3116 ata_netcell_chipinit(device_t dev)
3117 {
3118     struct ata_pci_controller *ctlr = device_get_softc(dev);
3119
3120     if (ata_generic_chipinit(dev))
3121         return ENXIO;
3122
3123     ctlr->allocate = ata_netcell_allocate;
3124     return 0;
3125 }
3126
3127 static int
3128 ata_netcell_allocate(device_t dev)
3129 {
3130     struct ata_channel *ch = device_get_softc(dev);
3131  
3132     /* setup the usual register normal pci style */
3133     if (ata_pci_allocate(dev))
3134         return ENXIO;
3135  
3136     /* the NetCell only supports 16 bit PIO transfers */
3137     ch->flags |= ATA_USE_16BIT;
3138
3139     return 0;
3140 }
3141
3142
3143 /*
3144  * nVidia chipset support functions
3145  */
3146 int
3147 ata_nvidia_ident(device_t dev)
3148 {
3149     struct ata_pci_controller *ctlr = device_get_softc(dev);
3150     struct ata_chip_id *idx;
3151     static struct ata_chip_id ids[] =
3152     {{ ATA_NFORCE1,         0, AMDNVIDIA, NVIDIA,  ATA_UDMA5, "nForce" },
3153      { ATA_NFORCE2,         0, AMDNVIDIA, NVIDIA,  ATA_UDMA6, "nForce2" },
3154      { ATA_NFORCE2_PRO,     0, AMDNVIDIA, NVIDIA,  ATA_UDMA6, "nForce2 Pro" },
3155      { ATA_NFORCE2_PRO_S1,  0, 0,         0,       ATA_SA150, "nForce2 Pro" },
3156      { ATA_NFORCE3,         0, AMDNVIDIA, NVIDIA,  ATA_UDMA6, "nForce3" },
3157      { ATA_NFORCE3_PRO,     0, AMDNVIDIA, NVIDIA,  ATA_UDMA6, "nForce3 Pro" },
3158      { ATA_NFORCE3_PRO_S1,  0, 0,         0,       ATA_SA150, "nForce3 Pro" },
3159      { ATA_NFORCE3_PRO_S2,  0, 0,         0,       ATA_SA150, "nForce3 Pro" },
3160      { ATA_NFORCE_MCP04,    0, AMDNVIDIA, NVIDIA,  ATA_UDMA6, "nForce MCP" },
3161      { ATA_NFORCE_MCP04_S1, 0, 0,         NV4,     ATA_SA150, "nForce MCP" },
3162      { ATA_NFORCE_MCP04_S2, 0, 0,         NV4,     ATA_SA150, "nForce MCP" },
3163      { ATA_NFORCE_CK804,    0, AMDNVIDIA, NVIDIA,  ATA_UDMA6, "nForce CK804" },
3164      { ATA_NFORCE_CK804_S1, 0, 0,         NV4,     ATA_SA300, "nForce CK804" },
3165      { ATA_NFORCE_CK804_S2, 0, 0,         NV4,     ATA_SA300, "nForce CK804" },
3166      { ATA_NFORCE_MCP51,    0, AMDNVIDIA, NVIDIA,  ATA_UDMA6, "nForce MCP51" },
3167      { ATA_NFORCE_MCP51_S1, 0, 0,         NV4|NVQ, ATA_SA300, "nForce MCP51" },
3168      { ATA_NFORCE_MCP51_S2, 0, 0,         NV4|NVQ, ATA_SA300, "nForce MCP51" },
3169      { ATA_NFORCE_MCP55,    0, AMDNVIDIA, NVIDIA,  ATA_UDMA6, "nForce MCP55" },
3170      { ATA_NFORCE_MCP55_S1, 0, 0,         NV4|NVQ, ATA_SA300, "nForce MCP55" },
3171      { ATA_NFORCE_MCP55_S2, 0, 0,         NV4|NVQ, ATA_SA300, "nForce MCP55" },
3172      { 0, 0, 0, 0, 0, 0}} ;
3173     char buffer[64] ;
3174
3175     if (!(idx = ata_match_chip(dev, ids)))
3176         return ENXIO;
3177
3178     ksprintf(buffer, "nVidia %s %s controller",
3179             idx->text, ata_mode2str(idx->max_dma));
3180     device_set_desc_copy(dev, buffer);
3181     ctlr->chip = idx;
3182     ctlr->chipinit = ata_nvidia_chipinit;
3183     return 0;
3184 }
3185
3186 static int
3187 ata_nvidia_chipinit(device_t dev)
3188 {
3189     struct ata_pci_controller *ctlr = device_get_softc(dev);
3190
3191     if (ata_setup_interrupt(dev))
3192         return ENXIO;
3193
3194     if (ctlr->chip->max_dma >= ATA_SA150) {
3195         if (pci_read_config(dev, PCIR_BAR(5), 1) & 1)
3196             ctlr->r_type2 = SYS_RES_IOPORT;
3197         else
3198             ctlr->r_type2 = SYS_RES_MEMORY;
3199         ctlr->r_rid2 = PCIR_BAR(5);
3200         if ((ctlr->r_res2 = bus_alloc_resource_any(dev, ctlr->r_type2,
3201                                                    &ctlr->r_rid2, RF_ACTIVE))) {
3202             int offset = ctlr->chip->cfg2 & NV4 ? 0x0440 : 0x0010;
3203
3204             ctlr->allocate = ata_nvidia_allocate;
3205             ctlr->reset = ata_nvidia_reset;
3206
3207             /* enable control access */
3208             pci_write_config(dev, 0x50, pci_read_config(dev, 0x50, 1) | 0x04,1);
3209
3210             if (ctlr->chip->cfg2 & NVQ) {
3211                 /* clear interrupt status */
3212                 ATA_OUTL(ctlr->r_res2, offset, 0x00ff00ff);
3213
3214                 /* enable device and PHY state change interrupts */
3215                 ATA_OUTL(ctlr->r_res2, offset + 4, 0x000d000d);
3216
3217                 /* disable NCQ support */
3218                 ATA_OUTL(ctlr->r_res2, 0x0400,
3219                          ATA_INL(ctlr->r_res2, 0x0400) & 0xfffffff9);
3220             } 
3221             else {
3222                 /* clear interrupt status */
3223                 ATA_OUTB(ctlr->r_res2, offset, 0xff);
3224
3225                 /* enable device and PHY state change interrupts */
3226                 ATA_OUTB(ctlr->r_res2, offset + 1, 0xdd);
3227             }
3228
3229             /* enable PCI interrupt */
3230             pci_write_config(dev, PCIR_COMMAND,
3231                              pci_read_config(dev, PCIR_COMMAND, 2) & ~0x0400,2);
3232
3233         }
3234         ctlr->setmode = ata_sata_setmode;
3235     }
3236     else {
3237         /* disable prefetch, postwrite */
3238         pci_write_config(dev, 0x51, pci_read_config(dev, 0x51, 1) & 0x0f, 1);
3239         ctlr->setmode = ata_via_family_setmode;
3240     }
3241     return 0;
3242 }
3243
3244 static int
3245 ata_nvidia_allocate(device_t dev)
3246 {
3247     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
3248     struct ata_channel *ch = device_get_softc(dev);
3249
3250     /* setup the usual register normal pci style */
3251     if (ata_pci_allocate(dev))
3252         return ENXIO;
3253
3254     ch->r_io[ATA_SSTATUS].res = ctlr->r_res2;
3255     ch->r_io[ATA_SSTATUS].offset = (ch->unit << 6);
3256     ch->r_io[ATA_SERROR].res = ctlr->r_res2;
3257     ch->r_io[ATA_SERROR].offset = 0x04 + (ch->unit << 6);
3258     ch->r_io[ATA_SCONTROL].res = ctlr->r_res2;
3259     ch->r_io[ATA_SCONTROL].offset = 0x08 + (ch->unit << 6);
3260
3261     ch->hw.status = ata_nvidia_status;
3262     ch->flags |= ATA_NO_SLAVE;
3263
3264     return 0;
3265 }
3266
3267 static int 
3268 ata_nvidia_status(device_t dev)
3269 {
3270     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
3271     struct ata_channel *ch = device_get_softc(dev);
3272     int offset = ctlr->chip->cfg2 & NV4 ? 0x0440 : 0x0010;
3273     int shift = ch->unit << (ctlr->chip->cfg2 & NVQ ? 4 : 2);
3274     u_int32_t istatus = ATA_INL(ctlr->r_res2, offset);
3275
3276     /* do we have any PHY events ? */
3277     if (istatus & (0x0c << shift))
3278         ata_sata_phy_check_events(dev);
3279
3280     /* clear interrupt(s) */
3281     ATA_OUTB(ctlr->r_res2, offset,
3282              (0x0f << shift) | (ctlr->chip->cfg2 & NVQ ? 0x00f000f0 : 0));
3283
3284     /* do we have any device action ? */
3285     return (istatus & (0x01 << shift));
3286 }
3287
3288 static void
3289 ata_nvidia_reset(device_t dev)
3290 {
3291     if (ata_sata_phy_reset(dev))
3292         ata_generic_reset(dev);
3293 }
3294
3295
3296 /*
3297  * Promise chipset support functions
3298  */
3299 #define ATA_PDC_APKT_OFFSET     0x00000010 
3300 #define ATA_PDC_HPKT_OFFSET     0x00000040
3301 #define ATA_PDC_ASG_OFFSET      0x00000080
3302 #define ATA_PDC_LSG_OFFSET      0x000000c0
3303 #define ATA_PDC_HSG_OFFSET      0x00000100
3304 #define ATA_PDC_CHN_OFFSET      0x00000400
3305 #define ATA_PDC_BUF_BASE        0x00400000
3306 #define ATA_PDC_BUF_OFFSET      0x00100000
3307 #define ATA_PDC_MAX_HPKT        8
3308 #define ATA_PDC_WRITE_REG       0x00
3309 #define ATA_PDC_WRITE_CTL       0x0e
3310 #define ATA_PDC_WRITE_END       0x08
3311 #define ATA_PDC_WAIT_NBUSY      0x10
3312 #define ATA_PDC_WAIT_READY      0x18
3313 #define ATA_PDC_1B              0x20
3314 #define ATA_PDC_2B              0x40
3315
3316 struct host_packet {
3317     u_int32_t                   addr;
3318     TAILQ_ENTRY(host_packet)    chain;
3319 };
3320
3321 struct ata_promise_sx4 {
3322     struct spinlock             mtx;
3323     TAILQ_HEAD(, host_packet)   queue;
3324     int                         busy;
3325 };
3326
3327 int
3328 ata_promise_ident(device_t dev)
3329 {
3330     struct ata_pci_controller *ctlr = device_get_softc(dev);
3331     struct ata_chip_id *idx;
3332     static struct ata_chip_id ids[] =
3333     {{ ATA_PDC20246,  0, PROLD, 0x00,    ATA_UDMA2, "PDC20246" },
3334      { ATA_PDC20262,  0, PRNEW, 0x00,    ATA_UDMA4, "PDC20262" },
3335      { ATA_PDC20263,  0, PRNEW, 0x00,    ATA_UDMA4, "PDC20263" },
3336      { ATA_PDC20265,  0, PRNEW, 0x00,    ATA_UDMA5, "PDC20265" },
3337      { ATA_PDC20267,  0, PRNEW, 0x00,    ATA_UDMA5, "PDC20267" },
3338      { ATA_PDC20268,  0, PRTX,  PRTX4,   ATA_UDMA5, "PDC20268" },
3339      { ATA_PDC20269,  0, PRTX,  0x00,    ATA_UDMA6, "PDC20269" },
3340      { ATA_PDC20270,  0, PRTX,  PRTX4,   ATA_UDMA5, "PDC20270" },
3341      { ATA_PDC20271,  0, PRTX,  0x00,    ATA_UDMA6, "PDC20271" },
3342      { ATA_PDC20275,  0, PRTX,  0x00,    ATA_UDMA6, "PDC20275" },
3343      { ATA_PDC20276,  0, PRTX,  PRSX6K,  ATA_UDMA6, "PDC20276" },
3344      { ATA_PDC20277,  0, PRTX,  0x00,    ATA_UDMA6, "PDC20277" },
3345      { ATA_PDC20318,  0, PRMIO, PRSATA,  ATA_SA150, "PDC20318" },
3346      { ATA_PDC20319,  0, PRMIO, PRSATA,  ATA_SA150, "PDC20319" },
3347      { ATA_PDC20371,  0, PRMIO, PRCMBO,  ATA_SA150, "PDC20371" },
3348      { ATA_PDC20375,  0, PRMIO, PRCMBO,  ATA_SA150, "PDC20375" },
3349      { ATA_PDC20376,  0, PRMIO, PRCMBO,  ATA_SA150, "PDC20376" },
3350      { ATA_PDC20377,  0, PRMIO, PRCMBO,  ATA_SA150, "PDC20377" },
3351      { ATA_PDC20378,  0, PRMIO, PRCMBO,  ATA_SA150, "PDC20378" },
3352      { ATA_PDC20379,  0, PRMIO, PRCMBO,  ATA_SA150, "PDC20379" },
3353      { ATA_PDC20571,  0, PRMIO, PRCMBO2, ATA_SA150, "PDC20571" },
3354      { ATA_PDC20575,  0, PRMIO, PRCMBO2, ATA_SA150, "PDC20575" },
3355      { ATA_PDC20579,  0, PRMIO, PRCMBO2, ATA_SA150, "PDC20579" },
3356      { ATA_PDC20771,  0, PRMIO, PRCMBO2, ATA_SA300, "PDC20771" },
3357      { ATA_PDC40775,  0, PRMIO, PRCMBO2, ATA_SA300, "PDC40775" },
3358      { ATA_PDC20617,  0, PRMIO, PRPATA,  ATA_UDMA6, "PDC20617" },
3359      { ATA_PDC20618,  0, PRMIO, PRPATA,  ATA_UDMA6, "PDC20618" },
3360      { ATA_PDC20619,  0, PRMIO, PRPATA,  ATA_UDMA6, "PDC20619" },
3361      { ATA_PDC20620,  0, PRMIO, PRPATA,  ATA_UDMA6, "PDC20620" },
3362      { ATA_PDC20621,  0, PRMIO, PRSX4X,  ATA_UDMA5, "PDC20621" },
3363      { ATA_PDC20622,  0, PRMIO, PRSX4X,  ATA_SA150, "PDC20622" },
3364      { ATA_PDC40518,  0, PRMIO, PRSATA2, ATA_SA150, "PDC40518" },
3365      { ATA_PDC40519,  0, PRMIO, PRSATA2, ATA_SA150, "PDC40519" },
3366      { ATA_PDC40718,  0, PRMIO, PRSATA2, ATA_SA300, "PDC40718" },
3367      { ATA_PDC40719,  0, PRMIO, PRSATA2, ATA_SA300, "PDC40719" },
3368      { ATA_PDC40779,  0, PRMIO, PRSATA2, ATA_SA300, "PDC40779" },
3369      { 0, 0, 0, 0, 0, 0}};
3370     char buffer[64];
3371     uintptr_t devid = 0;
3372
3373     if (!(idx = ata_match_chip(dev, ids)))
3374         return ENXIO;
3375
3376     /* if we are on a SuperTrak SX6000 dont attach */
3377     if ((idx->cfg2 & PRSX6K) && pci_get_class(GRANDPARENT(dev))==PCIC_BRIDGE &&
3378         !BUS_READ_IVAR(device_get_parent(GRANDPARENT(dev)),
3379                        GRANDPARENT(dev), PCI_IVAR_DEVID, &devid) &&
3380         devid == ATA_I960RM) 
3381         return ENXIO;
3382
3383     strcpy(buffer, "Promise ");
3384     strcat(buffer, idx->text);
3385
3386     /* if we are on a FastTrak TX4, adjust the interrupt resource */
3387     if ((idx->cfg2 & PRTX4) && pci_get_class(GRANDPARENT(dev))==PCIC_BRIDGE &&
3388         !BUS_READ_IVAR(device_get_parent(GRANDPARENT(dev)),
3389                        GRANDPARENT(dev), PCI_IVAR_DEVID, &devid) &&
3390         ((devid == ATA_DEC_21150) || (devid == ATA_DEC_21150_1))) {
3391         static long start = 0, end = 0;
3392
3393         if (pci_get_slot(dev) == 1) {
3394             bus_get_resource(dev, SYS_RES_IRQ, 0, &start, &end);
3395             strcat(buffer, " (channel 0+1)");
3396         }
3397         else if (pci_get_slot(dev) == 2 && start && end) {
3398             bus_set_resource(dev, SYS_RES_IRQ, 0, start, end);
3399             strcat(buffer, " (channel 2+3)");
3400         }
3401         else {
3402             start = end = 0;
3403         }
3404     }
3405     ksprintf(buffer, "%s %s controller", buffer, ata_mode2str(idx->max_dma));
3406     device_set_desc_copy(dev, buffer);
3407     ctlr->chip = idx;
3408     ctlr->chipinit = ata_promise_chipinit;
3409     return 0;
3410 }
3411
3412 static int
3413 ata_promise_chipinit(device_t dev)
3414 {
3415     struct ata_pci_controller *ctlr = device_get_softc(dev);
3416     int fake_reg, stat_reg;
3417
3418     if (ata_setup_interrupt(dev))
3419         return ENXIO;
3420
3421     switch  (ctlr->chip->cfg1) {
3422     case PRNEW:
3423         /* setup clocks */
3424         ATA_OUTB(ctlr->r_res1, 0x11, ATA_INB(ctlr->r_res1, 0x11) | 0x0a);
3425
3426         ctlr->dmainit = ata_promise_dmainit;
3427         /* FALLTHROUGH */
3428
3429     case PROLD:
3430         /* enable burst mode */
3431         ATA_OUTB(ctlr->r_res1, 0x1f, ATA_INB(ctlr->r_res1, 0x1f) | 0x01);
3432         ctlr->allocate = ata_promise_allocate;
3433         ctlr->setmode = ata_promise_setmode;
3434         return 0;
3435
3436     case PRTX:
3437         ctlr->allocate = ata_promise_tx2_allocate;
3438         ctlr->setmode = ata_promise_setmode;
3439         return 0;
3440
3441     case PRMIO:
3442         ctlr->r_type1 = SYS_RES_MEMORY;
3443         ctlr->r_rid1 = PCIR_BAR(4);
3444         if (!(ctlr->r_res1 = bus_alloc_resource_any(dev, ctlr->r_type1,
3445                                                     &ctlr->r_rid1, RF_ACTIVE)))
3446             goto failnfree;
3447
3448         ctlr->r_type2 = SYS_RES_MEMORY;
3449         ctlr->r_rid2 = PCIR_BAR(3);
3450         if (!(ctlr->r_res2 = bus_alloc_resource_any(dev, ctlr->r_type2,
3451                                                     &ctlr->r_rid2, RF_ACTIVE)))
3452             goto failnfree;
3453
3454         if (ctlr->chip->cfg2 == PRSX4X) {
3455             struct ata_promise_sx4 *hpkt;
3456             u_int32_t dimm = ATA_INL(ctlr->r_res2, 0x000c0080);
3457
3458             if (bus_teardown_intr(dev, ctlr->r_irq, ctlr->handle) ||
3459                 bus_setup_intr(dev, ctlr->r_irq, ATA_INTR_FLAGS,
3460                                ata_promise_sx4_intr, ctlr, &ctlr->handle, NULL)) {
3461                 device_printf(dev, "unable to setup interrupt\n");
3462                 goto failnfree;
3463             }
3464
3465             /* print info about cache memory */
3466             device_printf(dev, "DIMM size %dMB @ 0x%08x%s\n",
3467                           (((dimm >> 16) & 0xff)-((dimm >> 24) & 0xff)+1) << 4,
3468                           ((dimm >> 24) & 0xff),
3469                           ATA_INL(ctlr->r_res2, 0x000c0088) & (1<<16) ?
3470                           " ECC enabled" : "" );
3471
3472             /* adjust cache memory parameters */
3473             ATA_OUTL(ctlr->r_res2, 0x000c000c, 
3474                      (ATA_INL(ctlr->r_res2, 0x000c000c) & 0xffff0000));
3475
3476             /* setup host packet controls */
3477             hpkt = kmalloc(sizeof(struct ata_promise_sx4),
3478                           M_TEMP, M_INTWAIT | M_ZERO);
3479             spin_init(&hpkt->mtx);
3480             TAILQ_INIT(&hpkt->queue);
3481             hpkt->busy = 0;
3482             device_set_ivars(dev, hpkt);
3483             ctlr->allocate = ata_promise_mio_allocate;
3484             ctlr->reset = ata_promise_mio_reset;
3485             ctlr->dmainit = ata_promise_mio_dmainit;
3486             ctlr->setmode = ata_promise_setmode;
3487             ctlr->channels = 4;
3488             return 0;
3489         }
3490
3491         /* mio type controllers need an interrupt intercept */
3492         if (bus_teardown_intr(dev, ctlr->r_irq, ctlr->handle) ||
3493                 bus_setup_intr(dev, ctlr->r_irq, ATA_INTR_FLAGS,
3494                                ata_promise_mio_intr, ctlr, &ctlr->handle, NULL)) {
3495                 device_printf(dev, "unable to setup interrupt\n");
3496                 goto failnfree;
3497         }
3498
3499         switch (ctlr->chip->cfg2) {
3500         case PRPATA:
3501             ctlr->channels = ((ATA_INL(ctlr->r_res2, 0x48) & 0x01) > 0) +
3502                              ((ATA_INL(ctlr->r_res2, 0x48) & 0x02) > 0) + 2;
3503             goto sata150;
3504         case PRCMBO:
3505             ctlr->channels = 3;
3506             goto sata150;
3507         case PRSATA:
3508             ctlr->channels = 4;
3509 sata150:
3510             fake_reg = 0x60;
3511             stat_reg = 0x6c;
3512             break;
3513
3514         case PRCMBO2: 
3515             ctlr->channels = 3;
3516             goto sataii;
3517         case PRSATA2:
3518         default:
3519             ctlr->channels = 4;
3520 sataii:
3521             fake_reg = 0x54;
3522             stat_reg = 0x60;
3523             break;
3524         }
3525
3526         /* prime fake interrupt register */
3527         ATA_OUTL(ctlr->r_res2, fake_reg, 0xffffffff);
3528
3529         /* clear SATA status */
3530         ATA_OUTL(ctlr->r_res2, stat_reg, 0x000000ff);
3531
3532         ctlr->allocate = ata_promise_mio_allocate;
3533         ctlr->reset = ata_promise_mio_reset;
3534         ctlr->dmainit = ata_promise_mio_dmainit;
3535         ctlr->setmode = ata_promise_mio_setmode;
3536
3537         return 0;
3538     }
3539
3540 failnfree:
3541     if (ctlr->r_res2)
3542         bus_release_resource(dev, ctlr->r_type2, ctlr->r_rid2, ctlr->r_res2);
3543     if (ctlr->r_res1)
3544         bus_release_resource(dev, ctlr->r_type1, ctlr->r_rid1, ctlr->r_res1);
3545     return ENXIO;
3546 }
3547
3548 static int
3549 ata_promise_allocate(device_t dev)
3550 {
3551     struct ata_channel *ch = device_get_softc(dev);
3552
3553     if (ata_pci_allocate(dev))
3554         return ENXIO;
3555
3556     ch->hw.status = ata_promise_status;
3557     return 0;
3558 }
3559
3560 static int
3561 ata_promise_status(device_t dev)
3562 {
3563     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
3564     struct ata_channel *ch = device_get_softc(dev);
3565
3566     if (ATA_INL(ctlr->r_res1, 0x1c) & (ch->unit ? 0x00004000 : 0x00000400)) {
3567         return ata_pci_status(dev);
3568     }
3569     return 0;
3570 }
3571
3572 static int
3573 ata_promise_dmastart(device_t dev)
3574 {
3575     struct ata_pci_controller *ctlr = device_get_softc(GRANDPARENT(dev));
3576     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
3577     struct ata_device *atadev  = device_get_softc(dev);
3578
3579     if (atadev->flags & ATA_D_48BIT_ACTIVE) {
3580         ATA_OUTB(ctlr->r_res1, 0x11,
3581                  ATA_INB(ctlr->r_res1, 0x11) | (ch->unit ? 0x08 : 0x02));
3582         ATA_OUTL(ctlr->r_res1, ch->unit ? 0x24 : 0x20,
3583                  ((ch->dma->flags & ATA_DMA_READ) ? 0x05000000 : 0x06000000) |
3584                  (ch->dma->cur_iosize >> 1));
3585     }
3586     ATA_IDX_OUTB(ch, ATA_BMSTAT_PORT, (ATA_IDX_INB(ch, ATA_BMSTAT_PORT) |
3587                  (ATA_BMSTAT_INTERRUPT | ATA_BMSTAT_ERROR)));
3588     ATA_IDX_OUTL(ch, ATA_BMDTP_PORT, ch->dma->sg_bus);
3589     ATA_IDX_OUTB(ch, ATA_BMCMD_PORT,
3590                  ((ch->dma->flags & ATA_DMA_READ) ? ATA_BMCMD_WRITE_READ : 0) |
3591                  ATA_BMCMD_START_STOP);
3592     ch->flags |= ATA_DMA_ACTIVE;
3593     return 0;
3594 }
3595
3596 static int
3597 ata_promise_dmastop(device_t dev)
3598 {
3599     struct ata_pci_controller *ctlr = device_get_softc(GRANDPARENT(dev));
3600     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
3601     struct ata_device *atadev  = device_get_softc(dev);
3602     int error;
3603
3604     if (atadev->flags & ATA_D_48BIT_ACTIVE) {
3605         ATA_OUTB(ctlr->r_res1, 0x11,
3606                  ATA_INB(ctlr->r_res1, 0x11) & ~(ch->unit ? 0x08 : 0x02));
3607         ATA_OUTL(ctlr->r_res1, ch->unit ? 0x24 : 0x20, 0);
3608     }
3609     error = ATA_IDX_INB(ch, ATA_BMSTAT_PORT);
3610     ATA_IDX_OUTB(ch, ATA_BMCMD_PORT,
3611                  ATA_IDX_INB(ch, ATA_BMCMD_PORT) & ~ATA_BMCMD_START_STOP);
3612     ATA_IDX_OUTB(ch, ATA_BMSTAT_PORT, ATA_BMSTAT_INTERRUPT | ATA_BMSTAT_ERROR); 
3613     ch->flags &= ~ATA_DMA_ACTIVE;
3614     return error;
3615 }
3616
3617 static void
3618 ata_promise_dmareset(device_t dev)
3619 {
3620     struct ata_channel *ch = device_get_softc(dev);
3621
3622     ATA_IDX_OUTB(ch, ATA_BMCMD_PORT,
3623                  ATA_IDX_INB(ch, ATA_BMCMD_PORT) & ~ATA_BMCMD_START_STOP);
3624     ATA_IDX_OUTB(ch, ATA_BMSTAT_PORT, ATA_BMSTAT_INTERRUPT | ATA_BMSTAT_ERROR); 
3625     ch->flags &= ~ATA_DMA_ACTIVE;
3626 }
3627
3628 static void
3629 ata_promise_dmainit(device_t dev)
3630 {
3631     struct ata_channel *ch = device_get_softc(dev);
3632
3633     ata_dmainit(dev);
3634     if (ch->dma) {
3635         ch->dma->start = ata_promise_dmastart;
3636         ch->dma->stop = ata_promise_dmastop;
3637         ch->dma->reset = ata_promise_dmareset;
3638     }
3639 }
3640
3641 static void
3642 ata_promise_setmode(device_t dev, int mode)
3643 {
3644     device_t gparent = GRANDPARENT(dev);
3645     struct ata_pci_controller *ctlr = device_get_softc(gparent);
3646     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
3647     struct ata_device *atadev = device_get_softc(dev);
3648     int devno = (ch->unit << 1) + ATA_DEV(atadev->unit);
3649     int error;
3650     u_int32_t timings[][2] = {
3651     /*    PROLD       PRNEW                mode */
3652         { 0x004ff329, 0x004fff2f },     /* PIO 0 */
3653         { 0x004fec25, 0x004ff82a },     /* PIO 1 */
3654         { 0x004fe823, 0x004ff026 },     /* PIO 2 */
3655         { 0x004fe622, 0x004fec24 },     /* PIO 3 */
3656         { 0x004fe421, 0x004fe822 },     /* PIO 4 */
3657         { 0x004567f3, 0x004acef6 },     /* MWDMA 0 */
3658         { 0x004467f3, 0x0048cef6 },     /* MWDMA 1 */
3659         { 0x004367f3, 0x0046cef6 },     /* MWDMA 2 */
3660         { 0x004367f3, 0x0046cef6 },     /* UDMA 0 */
3661         { 0x004247f3, 0x00448ef6 },     /* UDMA 1 */
3662         { 0x004127f3, 0x00436ef6 },     /* UDMA 2 */
3663         { 0,          0x00424ef6 },     /* UDMA 3 */
3664         { 0,          0x004127f3 },     /* UDMA 4 */
3665         { 0,          0x004127f3 }      /* UDMA 5 */
3666     };
3667
3668     mode = ata_limit_mode(dev, mode, ctlr->chip->max_dma);
3669
3670     switch (ctlr->chip->cfg1) {
3671     case PROLD:
3672     case PRNEW:
3673         if (mode > ATA_UDMA2 && (pci_read_config(gparent, 0x50, 2) &
3674                                  (ch->unit ? 1 << 11 : 1 << 10))) {
3675             ata_print_cable(dev, "controller");
3676             mode = ATA_UDMA2;
3677         }
3678         if (ata_atapi(dev) && mode > ATA_PIO_MAX)
3679             mode = ata_limit_mode(dev, mode, ATA_PIO_MAX);
3680         break;
3681
3682     case PRTX:
3683         ATA_IDX_OUTB(ch, ATA_BMDEVSPEC_0, 0x0b);
3684         if (mode > ATA_UDMA2 &&
3685             ATA_IDX_INB(ch, ATA_BMDEVSPEC_1) & 0x04) {
3686             ata_print_cable(dev, "controller");
3687             mode = ATA_UDMA2;
3688         }
3689         break;
3690    
3691     case PRMIO:
3692         if (mode > ATA_UDMA2 &&
3693             (ATA_INL(ctlr->r_res2,
3694                      (ctlr->chip->cfg2 & PRSX4X ? 0x000c0260 : 0x0260) +
3695                      (ch->unit << 7)) & 0x01000000)) {
3696             ata_print_cable(dev, "controller");
3697             mode = ATA_UDMA2;
3698         }
3699         break;
3700     }
3701
3702     error = ata_controlcmd(dev, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode);
3703
3704     if (bootverbose)
3705         device_printf(dev, "%ssetting %s on %s chip\n",
3706                      (error) ? "FAILURE " : "",
3707                      ata_mode2str(mode), ctlr->chip->text);
3708     if (!error) {
3709         if (ctlr->chip->cfg1 < PRTX)
3710             pci_write_config(gparent, 0x60 + (devno << 2),
3711                              timings[ata_mode2idx(mode)][ctlr->chip->cfg1], 4);
3712         atadev->mode = mode;
3713     }
3714     return;
3715 }
3716
3717 static int
3718 ata_promise_tx2_allocate(device_t dev)
3719 {
3720     struct ata_channel *ch = device_get_softc(dev);
3721
3722     if (ata_pci_allocate(dev))
3723         return ENXIO;
3724
3725     ch->hw.status = ata_promise_tx2_status;
3726     return 0;
3727 }
3728
3729 static int
3730 ata_promise_tx2_status(device_t dev)
3731 {
3732     struct ata_channel *ch = device_get_softc(dev);
3733
3734     ATA_IDX_OUTB(ch, ATA_BMDEVSPEC_0, 0x0b);
3735     if (ATA_IDX_INB(ch, ATA_BMDEVSPEC_1) & 0x20) {
3736         return ata_pci_status(dev);
3737     }
3738     return 0;
3739 }
3740
3741 static int
3742 ata_promise_mio_allocate(device_t dev)
3743 {
3744     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
3745     struct ata_channel *ch = device_get_softc(dev);
3746     int offset = (ctlr->chip->cfg2 & PRSX4X) ? 0x000c0000 : 0;
3747     int i;
3748  
3749     for (i = ATA_DATA; i <= ATA_COMMAND; i++) {
3750         ch->r_io[i].res = ctlr->r_res2;
3751         ch->r_io[i].offset = offset + 0x0200 + (i << 2) + (ch->unit << 7); 
3752     }
3753     ch->r_io[ATA_CONTROL].res = ctlr->r_res2;
3754     ch->r_io[ATA_CONTROL].offset = offset + 0x0238 + (ch->unit << 7);
3755     ch->r_io[ATA_IDX_ADDR].res = ctlr->r_res2;
3756     ata_default_registers(dev);
3757     if ((ctlr->chip->cfg2 & (PRSATA | PRSATA2)) ||
3758         ((ctlr->chip->cfg2 & (PRCMBO | PRCMBO2)) && ch->unit < 2)) {
3759         ch->r_io[ATA_SSTATUS].res = ctlr->r_res2;
3760         ch->r_io[ATA_SSTATUS].offset = 0x400 + (ch->unit << 8);
3761         ch->r_io[ATA_SERROR].res = ctlr->r_res2;
3762         ch->r_io[ATA_SERROR].offset = 0x404 + (ch->unit << 8);
3763         ch->r_io[ATA_SCONTROL].res = ctlr->r_res2;
3764         ch->r_io[ATA_SCONTROL].offset = 0x408 + (ch->unit << 8);
3765         ch->flags |= ATA_NO_SLAVE;
3766     }
3767     ch->flags |= ATA_USE_16BIT;
3768
3769     ata_generic_hw(dev);
3770     if (ctlr->chip->cfg2 & PRSX4X) {
3771         ch->hw.command = ata_promise_sx4_command;
3772     }
3773     else {
3774         ch->hw.command = ata_promise_mio_command;
3775         ch->hw.status = ata_promise_mio_status;
3776      }
3777     return 0;
3778 }
3779
3780 static void
3781 ata_promise_mio_intr(void *data)
3782 {
3783     struct ata_pci_controller *ctlr = data;
3784     struct ata_channel *ch;
3785     u_int32_t vector;
3786     int unit, fake_reg;
3787
3788     switch (ctlr->chip->cfg2) {
3789     case PRPATA:
3790     case PRCMBO:
3791     case PRSATA:
3792         fake_reg = 0x60;
3793         break;
3794     case PRCMBO2: 
3795     case PRSATA2:
3796     default:
3797         fake_reg = 0x54;
3798         break;
3799     }
3800
3801     /*
3802      * since reading interrupt status register on early "mio" chips
3803      * clears the status bits we cannot read it for each channel later on
3804      * in the generic interrupt routine.
3805      * store the bits in an unused register in the chip so we can read
3806      * it from there safely to get around this "feature".
3807      */
3808     vector = ATA_INL(ctlr->r_res2, 0x040);
3809     ATA_OUTL(ctlr->r_res2, 0x040, vector);
3810     ATA_OUTL(ctlr->r_res2, fake_reg, vector);
3811
3812     for (unit = 0; unit < ctlr->channels; unit++) {
3813         if ((ch = ctlr->interrupt[unit].argument))
3814             ctlr->interrupt[unit].function(ch);
3815     }
3816
3817     ATA_OUTL(ctlr->r_res2, fake_reg, 0xffffffff);
3818 }
3819
3820 static int
3821 ata_promise_mio_status(device_t dev)
3822 {
3823     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
3824     struct ata_channel *ch = device_get_softc(dev);
3825     struct ata_connect_task *tp;
3826     u_int32_t fake_reg, stat_reg, vector, status;
3827
3828     switch (ctlr->chip->cfg2) {
3829     case PRPATA:
3830     case PRCMBO:
3831     case PRSATA:
3832         fake_reg = 0x60;
3833         stat_reg = 0x6c;
3834         break;
3835     case PRCMBO2: 
3836     case PRSATA2:
3837     default:
3838         fake_reg = 0x54;
3839         stat_reg = 0x60;
3840         break;
3841     }
3842
3843     /* read and acknowledge interrupt */
3844     vector = ATA_INL(ctlr->r_res2, fake_reg);
3845
3846     /* read and clear interface status */
3847     status = ATA_INL(ctlr->r_res2, stat_reg);
3848     ATA_OUTL(ctlr->r_res2, stat_reg, status & (0x00000011 << ch->unit));
3849
3850     /* check for and handle disconnect events */
3851     if ((status & (0x00000001 << ch->unit)) &&
3852         (tp = (struct ata_connect_task *)
3853               kmalloc(sizeof(struct ata_connect_task),
3854                      M_ATA, M_INTWAIT | M_ZERO))) {
3855
3856         if (bootverbose)
3857             device_printf(ch->dev, "DISCONNECT requested\n");
3858         tp->action = ATA_C_DETACH;
3859         tp->dev = ch->dev;
3860         TASK_INIT(&tp->task, 0, ata_sata_phy_event, tp);
3861         taskqueue_enqueue(taskqueue_thread[mycpuid], &tp->task);
3862     }
3863
3864     /* check for and handle connect events */
3865     if ((status & (0x00000010 << ch->unit)) &&
3866         (tp = (struct ata_connect_task *)
3867               kmalloc(sizeof(struct ata_connect_task),
3868                      M_ATA, M_INTWAIT | M_ZERO))) {
3869
3870         if (bootverbose)
3871             device_printf(ch->dev, "CONNECT requested\n");
3872         tp->action = ATA_C_ATTACH;
3873         tp->dev = ch->dev;
3874         TASK_INIT(&tp->task, 0, ata_sata_phy_event, tp);
3875         taskqueue_enqueue(taskqueue_thread[mycpuid], &tp->task);
3876     }
3877
3878     /* do we have any device action ? */
3879     return (vector & (1 << (ch->unit + 1)));
3880 }
3881
3882 static int
3883 ata_promise_mio_command(struct ata_request *request)
3884 {
3885     struct ata_pci_controller *ctlr=device_get_softc(GRANDPARENT(request->dev));
3886     struct ata_channel *ch = device_get_softc(device_get_parent(request->dev));
3887     u_int32_t *wordp = (u_int32_t *)ch->dma->work;
3888
3889     ATA_OUTL(ctlr->r_res2, (ch->unit + 1) << 2, 0x00000001);
3890
3891     /* XXX SOS add ATAPI commands support later */
3892     switch (request->u.ata.command) {
3893     default:
3894         return ata_generic_command(request);
3895
3896     case ATA_READ_DMA:
3897     case ATA_READ_DMA48:
3898         wordp[0] = htole32(0x04 | ((ch->unit + 1) << 16) | (0x00 << 24));
3899         break;
3900
3901     case ATA_WRITE_DMA:
3902     case ATA_WRITE_DMA48:
3903         wordp[0] = htole32(0x00 | ((ch->unit + 1) << 16) | (0x00 << 24));
3904         break;
3905     }
3906     wordp[1] = htole32(ch->dma->sg_bus);
3907     wordp[2] = 0;
3908     ata_promise_apkt((u_int8_t*)wordp, request);
3909
3910     ATA_OUTL(ctlr->r_res2, 0x0240 + (ch->unit << 7), ch->dma->work_bus);
3911     return 0;
3912 }
3913
3914 static void
3915 ata_promise_mio_reset(device_t dev)
3916 {
3917     struct ata_pci_controller *ctlr = device_get_softc(device_get_parent(dev));
3918     struct ata_channel *ch = device_get_softc(dev);
3919     struct ata_promise_sx4 *hpktp;
3920
3921     switch (ctlr->chip->cfg2) {
3922     case PRSX4X:
3923
3924         /* softreset channel ATA module */
3925         hpktp = device_get_ivars(ctlr->dev);
3926         ATA_OUTL(ctlr->r_res2, 0xc0260 + (ch->unit << 7), ch->unit + 1);
3927         ata_udelay(1000);
3928         ATA_OUTL(ctlr->r_res2, 0xc0260 + (ch->unit << 7),
3929                  (ATA_INL(ctlr->r_res2, 0xc0260 + (ch->unit << 7)) &
3930                   ~0x00003f9f) | (ch->unit + 1));
3931
3932         /* softreset HOST module */ /* XXX SOS what about other outstandings */
3933         spin_lock_wr(&hpktp->mtx);
3934         ATA_OUTL(ctlr->r_res2, 0xc012c,
3935                  (ATA_INL(ctlr->r_res2, 0xc012c) & ~0x00000f9f) | (1 << 11));
3936         DELAY(10);
3937         ATA_OUTL(ctlr->r_res2, 0xc012c,
3938                  (ATA_INL(ctlr->r_res2, 0xc012c) & ~0x00000f9f));
3939         hpktp->busy = 0;
3940         spin_unlock_wr(&hpktp->mtx);
3941         ata_generic_reset(dev);
3942         break;
3943
3944     case PRPATA:
3945     case PRCMBO:
3946     case PRSATA:
3947         if ((ctlr->chip->cfg2 == PRSATA) ||
3948             ((ctlr->chip->cfg2 == PRCMBO) && (ch->unit < 2))) {
3949
3950             /* mask plug/unplug intr */
3951             ATA_OUTL(ctlr->r_res2, 0x06c, (0x00110000 << ch->unit));
3952         }
3953
3954         /* softreset channels ATA module */
3955         ATA_OUTL(ctlr->r_res2, 0x0260 + (ch->unit << 7), (1 << 11));
3956         ata_udelay(10000);
3957         ATA_OUTL(ctlr->r_res2, 0x0260 + (ch->unit << 7),
3958                  (ATA_INL(ctlr->r_res2, 0x0260 + (ch->unit << 7)) &
3959                   ~0x00003f9f) | (ch->unit + 1));
3960
3961         if ((ctlr->chip->cfg2 == PRSATA) ||
3962             ((ctlr->chip->cfg2 == PRCMBO) && (ch->unit < 2))) {
3963
3964             if (ata_sata_phy_reset(dev))
3965                 ata_generic_reset(dev);
3966
3967             /* reset and enable plug/unplug intr */
3968             ATA_OUTL(ctlr->r_res2, 0x06c, (0x00000011 << ch->unit));
3969         }
3970         else
3971             ata_generic_reset(dev);
3972         break;
3973
3974     case PRCMBO2:
3975     case PRSATA2:
3976         if ((ctlr->chip->cfg2 == PRSATA2) ||
3977             ((ctlr->chip->cfg2 == PRCMBO2) && (ch->unit < 2))) {
3978             /* set portmultiplier port */
3979             ATA_OUTL(ctlr->r_res2, 0x4e8 + (ch->unit << 8), 0x0f);
3980
3981             /* mask plug/unplug intr */
3982             ATA_OUTL(ctlr->r_res2, 0x060, (0x00110000 << ch->unit));
3983         }
3984
3985         /* softreset channels ATA module */
3986         ATA_OUTL(ctlr->r_res2, 0x0260 + (ch->unit << 7), (1 << 11));
3987         ata_udelay(10000);
3988         ATA_OUTL(ctlr->r_res2, 0x0260 + (ch->unit << 7),
3989                  (ATA_INL(ctlr->r_res2, 0x0260 + (ch->unit << 7)) &
3990                   ~0x00003f9f) | (ch->unit + 1));
3991
3992         if ((ctlr->chip->cfg2 == PRSATA2) ||
3993             ((ctlr->chip->cfg2 == PRCMBO2) && (ch->unit < 2))) {
3994
3995             /* set PHY mode to "improved" */
3996             ATA_OUTL(ctlr->r_res2, 0x414 + (ch->unit << 8),
3997                      (ATA_INL(ctlr->r_res2, 0x414 + (ch->unit << 8)) &
3998                      ~0x00000003) | 0x00000001);
3999
4000             if (ata_sata_phy_reset(dev))
4001                 ata_generic_reset(dev);
4002
4003             /* reset and enable plug/unplug intr */
4004             ATA_OUTL(ctlr->r_res2, 0x060, (0x00000011 << ch->unit));
4005
4006             /* set portmultiplier port */
4007             ATA_OUTL(ctlr->r_res2, 0x4e8 + (ch->unit << 8), 0x00);
4008         }
4009         else
4010             ata_generic_reset(dev);
4011         break;
4012
4013     }
4014 }
4015
4016 static void
4017 ata_promise_mio_dmainit(device_t dev)
4018 {
4019     /* note start and stop are not used here */
4020     ata_dmainit(dev);
4021 }
4022
4023 static void
4024 ata_promise_mio_setmode(device_t dev, int mode)
4025 {
4026     device_t gparent = GRANDPARENT(dev);
4027     struct ata_pci_controller *ctlr = device_get_softc(gparent);
4028     struct ata_channel *ch = device_get_softc(device_get_parent(dev));
4029
4030     if ( (ctlr->chip->cfg2 == PRSATA) ||
4031         ((ctlr->chip->cfg2 == PRCMBO) && (ch->unit < 2)) ||
4032         (ctlr->chip->cfg2 == PRSATA2) ||
4033         ((ctlr->chip->cfg2 == PRCMBO2) && (ch->unit < 2)))
4034         ata_sata_setmode(dev, mode);
4035     else
4036         ata_promise_setmode(dev, mode);
4037 }
4038
4039 static void
4040 ata_promise_sx4_intr(void *data)
4041 {
4042     struct ata_pci_controller *ctlr = data;
4043     struct ata_channel *ch;
4044     u_int32_t vector = ATA_INL(ctlr->r_res2, 0x000c0480);
4045     int unit;
4046
4047     for (unit = 0; unit < ctlr->channels; unit++) {
4048         if (vector & (1 << (unit + 1)))
4049             if ((ch = ctlr->interrupt[unit].argument))
4050                 ctlr->interrupt[unit].function(ch);
4051         if (vector & (1 << (unit + 5)))
4052             if ((ch = ctlr->interrupt[unit].argument))
4053                 ata_promise_queue_hpkt(ctlr,
4054                                        htole32((ch->unit * ATA_PDC_CHN_OFFSET) +
4055                                                ATA_PDC_HPKT_OFFSET));
4056         if (vector & (1 << (unit + 9))) {
4057             ata_promise_next_hpkt(ctlr);
4058             if ((ch = ctlr->interrupt[unit].argument))
4059                 ctlr->interrupt[unit].function(ch);
4060         }
4061         if (vector & (1 << (unit + 13))) {
4062             ata_promise_next_hpkt(ctlr);
4063             if ((ch = ctlr->interrupt[unit].argument))
4064                 ATA_OUTL(ctlr->r_res2, 0x000c0240 + (ch->unit << 7),
4065                          htole32((ch->unit * ATA_PDC_CHN_OFFSET) +
4066                          ATA_PDC_APKT_OFFSET));
4067         }
4068     }
4069 }
4070
4071 static int
4072 ata_promise_sx4_command(struct ata_request *request)
4073 {
4074     device_t gparent = GRANDPARENT(request->dev);
4075     struct ata_pci_controller *ctlr = device_get_softc(gparent);
4076     struct ata_channel *ch = device_get_softc(device_get_parent(request->dev));
4077     struct ata_dma_prdentry *prd = ch->dma->sg;
4078     caddr_t window = rman_get_virtual(ctlr->r_res1);
4079     u_int32_t *wordp;
4080     int i, idx, length = 0;
4081
4082     /* XXX SOS add ATAPI commands support later */
4083     switch (request->u.ata.command) {    
4084
4085     default:
4086         return -1;
4087
4088     case ATA_ATA_IDENTIFY:
4089     case ATA_READ:
4090     case ATA_READ48:
4091     case ATA_READ_MUL:
4092     case ATA_READ_MUL48:
4093     case ATA_WRITE:
4094     case ATA_WRITE48:
4095     case ATA_WRITE_MUL:
4096     case ATA_WRITE_MUL48:
4097         ATA_OUTL(ctlr->r_res2, 0x000c0400 + ((ch->unit + 1) << 2), 0x00000001);
4098         return ata_generic_command(request);
4099
4100     case ATA_SETFEATURES:
4101     case ATA_FLUSHCACHE:
4102     case ATA_FLUSHCACHE48:
4103     case ATA_SLEEP:
4104     case ATA_SET_MULTI:
4105         wordp = (u_int32_t *)
4106             (window + (ch->unit * ATA_PDC_CHN_OFFSET) + ATA_PDC_APKT_OFFSET);
4107         wordp[0] = htole32(0x08 | ((ch->unit + 1)<<16) | (0x00 << 24));
4108         wordp[1] = 0;
4109         wordp[2] = 0;
4110         ata_promise_apkt((u_int8_t *)wordp, request);
4111         ATA_OUTL(ctlr->r_res2, 0x000c0484, 0x00000001);
4112         ATA_OUTL(ctlr->r_res2, 0x000c0400 + ((ch->unit + 1) << 2), 0x00000001);
4113         ATA_OUTL(ctlr->r_res2, 0x000c0240 + (ch->unit << 7),
4114                  htole32((ch->unit * ATA_PDC_CHN_OFFSET)+ATA_PDC_APKT_OFFSET));
4115         return 0;
4116
4117     case ATA_READ_DMA:
4118     case ATA_READ_DMA48:
4119     case ATA_WRITE_DMA:
4120     case ATA_WRITE_DMA48:
4121         wordp = (u_int32_t *)
4122             (window + (ch->unit * ATA_PDC_CHN_OFFSET) + ATA_PDC_HSG_OFFSET);
4123         i = idx = 0;
4124         do {
4125             wordp[idx++] = prd[i].addr;
4126             wordp[idx++] = prd[i].count;
4127             length += (prd[i].count & ~ATA_DMA_EOT);
4128         } while (!(prd[i++].count & ATA_DMA_EOT));
4129
4130         wordp = (u_int32_t *)
4131             (window + (ch->unit * ATA_PDC_CHN_OFFSET) + ATA_PDC_LSG_OFFSET);
4132         wordp[0] = htole32((ch->unit * ATA_PDC_BUF_OFFSET) + ATA_PDC_BUF_BASE);
4133         wordp[1] = htole32(request->bytecount | ATA_DMA_EOT);
4134
4135         wordp = (u_int32_t *)
4136             (window + (ch->unit * ATA_PDC_CHN_OFFSET) + ATA_PDC_ASG_OFFSET);
4137         wordp[0] = htole32((ch->unit * ATA_PDC_BUF_OFFSET) + ATA_PDC_BUF_BASE);
4138         wordp[1] = htole32(request->bytecount | ATA_DMA_EOT);
4139
4140         wordp = (u_int32_t *)
4141             (window + (ch->unit * ATA_PDC_CHN_OFFSET) + ATA_PDC_HPKT_OFFSET);
4142         if (request->flags & ATA_R_READ)
4143             wordp[0] = htole32(0x14 | ((ch->unit+9)<<16) | ((ch->unit+5)<<24));
4144         if (request->flags & ATA_R_WRITE)
4145             wordp[0] = htole32(0x00 | ((ch->unit+13)<<16) | (0x00<<24));
4146         wordp[1] = htole32((ch->unit * ATA_PDC_CHN_OFFSET)+ATA_PDC_HSG_OFFSET);
4147         wordp[2] = htole32((ch->unit * ATA_PDC_CHN_OFFSET)+ATA_PDC_LSG_OFFSET);
4148         wordp[3] = 0;
4149
4150         wordp = (u_int32_t *)
4151             (window + (ch->unit * ATA_PDC_CHN_OFFSET) + ATA_PDC_APKT_OFFSET);
4152         if (request->flags & ATA_R_READ)
4153             wordp[0] = htole32(0x04 | ((ch->unit+5)<<16) | (0x00<<24));
4154         if (request->flags & ATA_R_WRITE)
4155             wordp[0] = htole32(0x10 | ((ch->unit+1)<<16) | ((ch->unit+13)<<24));
4156         wordp[1] = htole32((ch->unit * ATA_PDC_CHN_OFFSET)+ATA_PDC_ASG_OFFSET);
4157         wordp[2] = 0;
4158         ata_promise_apkt((u_int8_t *)wordp, request);
4159         ATA_OUTL(ctlr->r_res2, 0x000c0484, 0x00000001);
4160
4161         if (request->flags & ATA_R_READ) {
4162             ATA_OUTL(ctlr->r_res2, 0x000c0400 + ((ch->unit+5)<<2), 0x00000001);
4163             ATA_OUTL(ctlr->r_res2, 0x000c0400 + ((ch->unit+9)<<2), 0x00000001);
4164             ATA_OUTL(ctlr->r_res2, 0x000c0240 + (ch->unit << 7),
4165                 htole32((ch->unit * ATA_PDC_CHN_OFFSET) + ATA_PDC_APKT_OFFSET));
4166         }
4167         if (request->flags & ATA_R_WRITE) {
4168             ATA_OUTL(ctlr->r_res2, 0x000c0400 + ((ch->unit+1)<<2), 0x00000001);
4169             ATA_OUTL(ctlr->r_res2, 0x000c0400 + ((ch->unit+13)<<2), 0x00000001);
4170             ata_promise_queue_hpkt(ctlr,
4171                 htole32((ch->unit * ATA_PDC_CHN_OFFSET) + ATA_PDC_HPKT_OFFSET));
4172         }
4173         return 0;
4174     }
4175 }
4176
4177 static int
4178 ata_promise_apkt(u_int8_t *bytep, struct ata_request *request)
4179
4180     struct ata_device *atadev = device_get_softc(request->dev);
4181     int i = 12;
4182
4183     bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_PDC_WAIT_NBUSY|ATA_DRIVE;
4184     bytep[i++] = ATA_D_IBM | ATA_D_LBA | atadev->unit;
4185     bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_CTL;
4186     bytep[i++] = ATA_A_4BIT;
4187
4188     if (atadev->flags & ATA_D_48BIT_ACTIVE) {
4189         bytep[i++] = ATA_PDC_2B | ATA_PDC_WRITE_REG | ATA_FEATURE;
4190         bytep[i++] = request->u.ata.feature >> 8;
4191         bytep[i++] = request->u.ata.feature;
4192         bytep[i++] = ATA_PDC_2B | ATA_PDC_WRITE_REG | ATA_COUNT;
4193         bytep[i++] = request->u.ata.count >> 8;
4194         bytep[i++] = request->u.ata.count;
4195         bytep[i++] = ATA_PDC_2B | ATA_PDC_WRITE_REG | ATA_SECTOR;
4196         bytep[i++] = request->u.ata.lba >> 24;
4197         bytep[i++] = request->u.ata.lba;
4198         bytep[i++] = ATA_PDC_2B | ATA_PDC_WRITE_REG | ATA_CYL_LSB;
4199         bytep[i++] = request->u.ata.lba >> 32;
4200         bytep[i++] = request->u.ata.lba >> 8;
4201         bytep[i++] = ATA_PDC_2B | ATA_PDC_WRITE_REG | ATA_CYL_MSB;
4202         bytep[i++] = request->u.ata.lba >> 40;
4203         bytep[i++] = request->u.ata.lba >> 16;
4204         bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_DRIVE;
4205         bytep[i++] = ATA_D_LBA | atadev->unit;
4206     }
4207     else {
4208         bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_FEATURE;
4209         bytep[i++] = request->u.ata.feature;
4210         bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_COUNT;
4211         bytep[i++] = request->u.ata.count;
4212         bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_SECTOR;
4213         bytep[i++] = request->u.ata.lba;
4214         bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_CYL_LSB;
4215         bytep[i++] = request->u.ata.lba >> 8;
4216         bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_CYL_MSB;
4217         bytep[i++] = request->u.ata.lba >> 16;
4218         bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_REG | ATA_DRIVE;
4219         bytep[i++] = (atadev->flags & ATA_D_USE_CHS ? 0 : ATA_D_LBA) |
4220                    ATA_D_IBM | atadev->unit | ((request->u.ata.lba >> 24)&0xf);
4221     }
4222     bytep[i++] = ATA_PDC_1B | ATA_PDC_WRITE_END | ATA_COMMAND;
4223     bytep[i++] = request->u.ata.command;
4224     return i;
4225 }
4226
4227 static void
4228 ata_promise_queue_hpkt(struct ata_pci_controller *ctlr, u_int32_t hpkt)
4229 {
4230     struct ata_promise_sx4 *hpktp = device_get_ivars(ctlr->dev);
4231
4232     spin_lock_wr(&hpktp->mtx);
4233     if (hpktp->busy) {