2 * Copyright (c) 1998 - 2006 Søren Schmidt <sos@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
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.11 2007/12/17 09:24:40 hasso Exp $
32 #include <sys/param.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>
42 #include <sys/queue.h>
44 #include <sys/spinlock.h>
45 #include <sys/spinlock2.h>
46 #include <sys/systm.h>
47 #include <sys/taskqueue.h>
49 #include <machine/bus_dma.h>
51 #include <bus/pci/pcireg.h>
52 #include <bus/pci/pcivar.h>
58 /* local prototypes */
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_genahci_chipinit(device_t dev
);
79 static int ata_acard_chipinit(device_t dev
);
80 static int ata_acard_allocate(device_t dev
);
81 static int ata_acard_status(device_t dev
);
82 static void ata_acard_850_setmode(device_t dev
, int mode
);
83 static void ata_acard_86X_setmode(device_t dev
, int mode
);
84 static int ata_ali_chipinit(device_t dev
);
85 static int ata_ali_allocate(device_t dev
);
86 static int ata_ali_sata_allocate(device_t dev
);
87 static void ata_ali_reset(device_t dev
);
88 static void ata_ali_setmode(device_t dev
, int mode
);
89 static int ata_amd_chipinit(device_t dev
);
90 static int ata_ati_chipinit(device_t dev
);
91 static void ata_ati_setmode(device_t dev
, int mode
);
92 static int ata_cyrix_chipinit(device_t dev
);
93 static void ata_cyrix_setmode(device_t dev
, int mode
);
94 static int ata_cypress_chipinit(device_t dev
);
95 static void ata_cypress_setmode(device_t dev
, int mode
);
96 static int ata_highpoint_chipinit(device_t dev
);
97 static int ata_highpoint_allocate(device_t dev
);
98 static void ata_highpoint_setmode(device_t dev
, int mode
);
99 static int ata_highpoint_check_80pin(device_t dev
, int mode
);
100 static int ata_intel_chipinit(device_t dev
);
101 static int ata_intel_allocate(device_t dev
);
102 static void ata_intel_reset(device_t dev
);
103 static void ata_intel_old_setmode(device_t dev
, int mode
);
104 static void ata_intel_new_setmode(device_t dev
, int mode
);
105 static int ata_intel_31244_allocate(device_t dev
);
106 static int ata_intel_31244_status(device_t dev
);
107 static int ata_intel_31244_command(struct ata_request
*request
);
108 static void ata_intel_31244_reset(device_t dev
);
109 static int ata_ite_chipinit(device_t dev
);
110 static void ata_ite_setmode(device_t dev
, int mode
);
111 static int ata_jmicron_chipinit(device_t dev
);
112 static int ata_jmicron_allocate(device_t dev
);
113 static void ata_jmicron_reset(device_t dev
);
114 static void ata_jmicron_dmainit(device_t dev
);
115 static void ata_jmicron_setmode(device_t dev
, int mode
);
116 static int ata_marvell_pata_chipinit(device_t dev
);
117 static int ata_marvell_pata_allocate(device_t dev
);
118 static void ata_marvell_pata_setmode(device_t dev
, int mode
);
119 static int ata_marvell_edma_chipinit(device_t dev
);
120 static int ata_marvell_edma_allocate(device_t dev
);
121 static int ata_marvell_edma_status(device_t dev
);
122 static int ata_marvell_edma_begin_transaction(struct ata_request
*request
);
123 static int ata_marvell_edma_end_transaction(struct ata_request
*request
);
124 static void ata_marvell_edma_reset(device_t dev
);
125 static void ata_marvell_edma_dmasetprd(void *xsc
, bus_dma_segment_t
*segs
, int nsegs
, int error
);
126 static void ata_marvell_edma_dmainit(device_t dev
);
127 static int ata_national_chipinit(device_t dev
);
128 static void ata_national_setmode(device_t dev
, int mode
);
129 static int ata_netcell_chipinit(device_t dev
);
130 static int ata_netcell_allocate(device_t dev
);
131 static int ata_nvidia_chipinit(device_t dev
);
132 static int ata_nvidia_allocate(device_t dev
);
133 static int ata_nvidia_status(device_t dev
);
134 static void ata_nvidia_reset(device_t dev
);
135 static int ata_promise_chipinit(device_t dev
);
136 static int ata_promise_allocate(device_t dev
);
137 static int ata_promise_status(device_t dev
);
138 static int ata_promise_dmastart(device_t dev
);
139 static int ata_promise_dmastop(device_t dev
);
140 static void ata_promise_dmareset(device_t dev
);
141 static void ata_promise_dmainit(device_t dev
);
142 static void ata_promise_setmode(device_t dev
, int mode
);
143 static int ata_promise_tx2_allocate(device_t dev
);
144 static int ata_promise_tx2_status(device_t dev
);
145 static int ata_promise_mio_allocate(device_t dev
);
146 static void ata_promise_mio_intr(void *data
);
147 static int ata_promise_mio_status(device_t dev
);
148 static int ata_promise_mio_command(struct ata_request
*request
);
149 static void ata_promise_mio_reset(device_t dev
);
150 static void ata_promise_mio_dmainit(device_t dev
);
151 static void ata_promise_mio_setmode(device_t dev
, int mode
);
152 static void ata_promise_sx4_intr(void *data
);
153 static int ata_promise_sx4_command(struct ata_request
*request
);
154 static int ata_promise_apkt(u_int8_t
*bytep
, struct ata_request
*request
);
155 static void ata_promise_queue_hpkt(struct ata_pci_controller
*ctlr
, u_int32_t hpkt
);
156 static void ata_promise_next_hpkt(struct ata_pci_controller
*ctlr
);
157 static int ata_serverworks_chipinit(device_t dev
);
158 static int ata_serverworks_allocate(device_t dev
);
159 static void ata_serverworks_setmode(device_t dev
, int mode
);
160 static int ata_sii_chipinit(device_t dev
);
161 static int ata_cmd_allocate(device_t dev
);
162 static int ata_cmd_status(device_t dev
);
163 static void ata_cmd_setmode(device_t dev
, int mode
);
164 static int ata_sii_allocate(device_t dev
);
165 static int ata_sii_status(device_t dev
);
166 static void ata_sii_reset(device_t dev
);
167 static void ata_sii_setmode(device_t dev
, int mode
);
168 static int ata_siiprb_allocate(device_t dev
);
169 static int ata_siiprb_status(device_t dev
);
170 static int ata_siiprb_begin_transaction(struct ata_request
*request
);
171 static int ata_siiprb_end_transaction(struct ata_request
*request
);
172 static void ata_siiprb_reset(device_t dev
);
173 static void ata_siiprb_dmasetprd(void *xsc
, bus_dma_segment_t
*segs
, int nsegs
, int error
);
174 static void ata_siiprb_dmainit(device_t dev
);
175 static int ata_sis_chipinit(device_t dev
);
176 static int ata_sis_allocate(device_t dev
);
177 static void ata_sis_reset(device_t dev
);
178 static void ata_sis_setmode(device_t dev
, int mode
);
179 static int ata_via_chipinit(device_t dev
);
180 static int ata_via_allocate(device_t dev
);
181 static void ata_via_reset(device_t dev
);
182 static void ata_via_setmode(device_t dev
, int mode
);
183 static void ata_via_southbridge_fixup(device_t dev
);
184 static void ata_via_family_setmode(device_t dev
, int mode
);
185 static struct ata_chip_id
*ata_match_chip(device_t dev
, struct ata_chip_id
*index
);
186 static struct ata_chip_id
*ata_find_chip(device_t dev
, struct ata_chip_id
*index
, int slot
);
187 static int ata_setup_interrupt(device_t dev
);
188 static int ata_serialize(device_t dev
, int flags
);
189 static void ata_print_cable(device_t dev
, u_int8_t
*who
);
190 static int ata_atapi(device_t dev
);
191 static int ata_check_80pin(device_t dev
, int mode
);
192 static int ata_mode2idx(int mode
);
196 * generic ATA support functions
199 ata_generic_ident(device_t dev
)
201 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
203 device_set_desc(dev
, "GENERIC ATA controller");
204 ctlr
->chipinit
= ata_generic_chipinit
;
209 ata_generic_chipinit(device_t dev
)
211 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
213 if (ata_setup_interrupt(dev
))
215 ctlr
->setmode
= ata_generic_setmode
;
220 ata_generic_intr(void *data
)
222 struct ata_pci_controller
*ctlr
= data
;
223 struct ata_channel
*ch
;
226 for (unit
= 0; unit
< ctlr
->channels
; unit
++) {
227 if ((ch
= ctlr
->interrupt
[unit
].argument
))
228 ctlr
->interrupt
[unit
].function(ch
);
233 ata_generic_setmode(device_t dev
, int mode
)
235 struct ata_device
*atadev
= device_get_softc(dev
);
237 mode
= ata_limit_mode(dev
, mode
, ATA_UDMA2
);
238 mode
= ata_check_80pin(dev
, mode
);
239 if (!ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
))
245 * SATA support functions
248 ata_sata_phy_check_events(device_t dev
)
250 struct ata_channel
*ch
= device_get_softc(dev
);
251 u_int32_t error
= ATA_IDX_INL(ch
, ATA_SERROR
);
253 /* clear error bits/interrupt */
254 ATA_IDX_OUTL(ch
, ATA_SERROR
, error
);
256 /* do we have any events flagged ? */
258 struct ata_connect_task
*tp
;
259 u_int32_t status
= ATA_IDX_INL(ch
, ATA_SSTATUS
);
261 /* if we have a connection event deal with it */
262 if ((error
& ATA_SE_PHY_CHANGED
) &&
263 (tp
= (struct ata_connect_task
*)
264 kmalloc(sizeof(struct ata_connect_task
),
265 M_ATA
, M_INTWAIT
| M_ZERO
))) {
267 if (((status
& ATA_SS_CONWELL_MASK
) == ATA_SS_CONWELL_GEN1
) ||
268 ((status
& ATA_SS_CONWELL_MASK
) == ATA_SS_CONWELL_GEN2
)) {
270 device_printf(ch
->dev
, "CONNECT requested\n");
271 tp
->action
= ATA_C_ATTACH
;
275 device_printf(ch
->dev
, "DISCONNECT requested\n");
276 tp
->action
= ATA_C_DETACH
;
279 TASK_INIT(&tp
->task
, 0, ata_sata_phy_event
, tp
);
280 taskqueue_enqueue(taskqueue_thread
[mycpuid
], &tp
->task
);
286 ata_sata_phy_event(void *context
, int dummy
)
288 struct ata_connect_task
*tp
= (struct ata_connect_task
*)context
;
289 struct ata_channel
*ch
= device_get_softc(tp
->dev
);
294 if (tp
->action
== ATA_C_ATTACH
) {
296 device_printf(tp
->dev
, "CONNECTED\n");
298 ata_identify(tp
->dev
);
300 if (tp
->action
== ATA_C_DETACH
) {
301 if (!device_get_children(tp
->dev
, &children
, &nchildren
)) {
302 for (i
= 0; i
< nchildren
; i
++)
304 device_delete_child(tp
->dev
, children
[i
]);
305 kfree(children
, M_TEMP
);
307 spin_lock_wr(&ch
->state_mtx
);
308 ch
->state
= ATA_IDLE
;
309 spin_unlock_wr(&ch
->state_mtx
);
311 device_printf(tp
->dev
, "DISCONNECTED\n");
318 ata_sata_phy_reset(device_t dev
)
320 struct ata_channel
*ch
= device_get_softc(dev
);
323 if ((ATA_IDX_INL(ch
, ATA_SCONTROL
) & ATA_SC_DET_MASK
) == ATA_SC_DET_IDLE
)
324 return ata_sata_connect(ch
);
326 for (retry
= 0; retry
< 10; retry
++) {
327 for (loop
= 0; loop
< 10; loop
++) {
328 ATA_IDX_OUTL(ch
, ATA_SCONTROL
, ATA_SC_DET_RESET
);
330 if ((ATA_IDX_INL(ch
, ATA_SCONTROL
) &
331 ATA_SC_DET_MASK
) == ATA_SC_DET_RESET
)
335 for (loop
= 0; loop
< 10; loop
++) {
336 ATA_IDX_OUTL(ch
, ATA_SCONTROL
, ATA_SC_DET_IDLE
|
337 ATA_SC_IPM_DIS_PARTIAL
|
338 ATA_SC_IPM_DIS_SLUMBER
);
340 if ((ATA_IDX_INL(ch
, ATA_SCONTROL
) & ATA_SC_DET_MASK
) == 0)
341 return ata_sata_connect(ch
);
348 ata_sata_connect(struct ata_channel
*ch
)
353 /* wait up to 1 second for "connect well" */
354 for (timeout
= 0; timeout
< 100 ; timeout
++) {
355 status
= ATA_IDX_INL(ch
, ATA_SSTATUS
);
356 if ((status
& ATA_SS_CONWELL_MASK
) == ATA_SS_CONWELL_GEN1
||
357 (status
& ATA_SS_CONWELL_MASK
) == ATA_SS_CONWELL_GEN2
)
361 if (timeout
>= 100) {
363 device_printf(ch
->dev
, "SATA connect status=%08x\n", status
);
368 device_printf(ch
->dev
, "SATA connect time=%dms\n", timeout
* 10);
370 /* clear SATA error register */
371 ATA_IDX_OUTL(ch
, ATA_SERROR
, ATA_IDX_INL(ch
, ATA_SERROR
));
377 ata_sata_setmode(device_t dev
, int mode
)
379 struct ata_device
*atadev
= device_get_softc(dev
);
382 * if we detect that the device isn't a real SATA device we limit
383 * the transfer mode to UDMA5/ATA100.
384 * this works around the problems some devices has with the
385 * Marvell 88SX8030 SATA->PATA converters and UDMA6/ATA133.
387 if (atadev
->param
.satacapabilities
!= 0x0000 &&
388 atadev
->param
.satacapabilities
!= 0xffff) {
389 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
391 /* on some drives we need to set the transfer mode */
392 ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0,
393 ata_limit_mode(dev
, mode
, ATA_UDMA6
));
395 /* query SATA STATUS for the speed */
396 if (ch
->r_io
[ATA_SSTATUS
].res
&&
397 ((ATA_IDX_INL(ch
, ATA_SSTATUS
) & ATA_SS_CONWELL_MASK
) ==
398 ATA_SS_CONWELL_GEN2
))
399 atadev
->mode
= ATA_SA300
;
401 atadev
->mode
= ATA_SA150
;
404 mode
= ata_limit_mode(dev
, mode
, ATA_UDMA5
);
405 if (!ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
))
411 ata_request2fis_h2d(struct ata_request
*request
, u_int8_t
*fis
)
413 struct ata_device
*atadev
= device_get_softc(request
->dev
);
415 if (request
->flags
& ATA_R_ATAPI
) {
416 fis
[0] = 0x27; /* host to device */
417 fis
[1] = 0x80; /* command FIS (note PM goes here) */
418 fis
[2] = ATA_PACKET_CMD
;
419 if (request
->flags
& (ATA_R_READ
| ATA_R_WRITE
))
422 fis
[5] = request
->transfersize
;
423 fis
[6] = request
->transfersize
>> 8;
425 fis
[7] = ATA_D_LBA
| atadev
->unit
;
426 fis
[15] = ATA_A_4BIT
;
430 ata_modify_if_48bit(request
);
431 fis
[0] = 0x27; /* host to device */
432 fis
[1] = 0x80; /* command FIS (note PM goes here) */
433 fis
[2] = request
->u
.ata
.command
;
434 fis
[3] = request
->u
.ata
.feature
;
435 fis
[4] = request
->u
.ata
.lba
;
436 fis
[5] = request
->u
.ata
.lba
>> 8;
437 fis
[6] = request
->u
.ata
.lba
>> 16;
438 fis
[7] = ATA_D_LBA
| atadev
->unit
;
439 if (!(atadev
->flags
& ATA_D_48BIT_ACTIVE
))
440 fis
[7] |= (request
->u
.ata
.lba
>> 24 & 0x0f);
441 fis
[8] = request
->u
.ata
.lba
>> 24;
442 fis
[9] = request
->u
.ata
.lba
>> 32;
443 fis
[10] = request
->u
.ata
.lba
>> 40;
444 fis
[11] = request
->u
.ata
.feature
>> 8;
445 fis
[12] = request
->u
.ata
.count
;
446 fis
[13] = request
->u
.ata
.count
>> 8;
447 fis
[15] = ATA_A_4BIT
;
454 * AHCI v1.x compliant SATA chipset support functions
457 ata_ahci_chipinit(device_t dev
)
459 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
463 /* reset AHCI controller */
464 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_GHC
,
465 ATA_INL(ctlr
->r_res2
, ATA_AHCI_GHC
) | ATA_AHCI_GHC_HR
);
467 if (ATA_INL(ctlr
->r_res2
, ATA_AHCI_GHC
) & ATA_AHCI_GHC_HR
) {
468 bus_release_resource(dev
, ctlr
->r_type2
, ctlr
->r_rid2
, ctlr
->r_res2
);
469 device_printf(dev
, "AHCI controller reset failure\n");
473 /* enable AHCI mode */
474 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_GHC
,
475 ATA_INL(ctlr
->r_res2
, ATA_AHCI_GHC
) | ATA_AHCI_GHC_AE
);
477 /* get the number of HW channels */
479 MAX(flsl(ATA_INL(ctlr
->r_res2
, ATA_AHCI_PI
)),
480 (ATA_INL(ctlr
->r_res2
, ATA_AHCI_CAP
) & ATA_AHCI_NPMASK
) + 1);
482 /* disable interrupt sources and clear interrupts */
483 for (unit
= 0; unit
< ctlr
->channels
; unit
++) {
484 int offset
= unit
<< 7;
485 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_IE
+ offset
, 0);
486 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_IS
+ offset
, -1);
488 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_IS
, ATA_INL(ctlr
->r_res2
, ATA_AHCI_IS
));
490 /* enable AHCI interrupts */
491 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_GHC
,
492 ATA_INL(ctlr
->r_res2
, ATA_AHCI_GHC
) | ATA_AHCI_GHC_IE
);
494 ctlr
->reset
= ata_ahci_reset
;
495 ctlr
->dmainit
= ata_ahci_dmainit
;
496 ctlr
->allocate
= ata_ahci_allocate
;
497 ctlr
->setmode
= ata_sata_setmode
;
499 /* enable PCI interrupt */
500 pci_write_config(dev
, PCIR_COMMAND
,
501 pci_read_config(dev
, PCIR_COMMAND
, 2) & ~0x0400, 2);
503 /* announce we support the HW */
504 version
= ATA_INL(ctlr
->r_res2
, ATA_AHCI_VS
);
506 "AHCI Version %x%x.%x%x controller with %d ports detected\n",
507 (version
>> 24) & 0xff, (version
>> 16) & 0xff,
508 (version
>> 8) & 0xff, version
& 0xff,
509 (ATA_INL(ctlr
->r_res2
, ATA_AHCI_CAP
) & ATA_AHCI_NPMASK
) + 1);
514 ata_ahci_allocate(device_t dev
)
516 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
517 struct ata_channel
*ch
= device_get_softc(dev
);
519 int offset
= ch
->unit
<< 7;
521 /* set the SATA resources */
522 ch
->r_io
[ATA_SSTATUS
].res
= ctlr
->r_res2
;
523 ch
->r_io
[ATA_SSTATUS
].offset
= ATA_AHCI_P_SSTS
+ offset
;
524 ch
->r_io
[ATA_SERROR
].res
= ctlr
->r_res2
;
525 ch
->r_io
[ATA_SERROR
].offset
= ATA_AHCI_P_SERR
+ offset
;
526 ch
->r_io
[ATA_SCONTROL
].res
= ctlr
->r_res2
;
527 ch
->r_io
[ATA_SCONTROL
].offset
= ATA_AHCI_P_SCTL
+ offset
;
528 ch
->r_io
[ATA_SACTIVE
].res
= ctlr
->r_res2
;
529 ch
->r_io
[ATA_SACTIVE
].offset
= ATA_AHCI_P_SACT
+ offset
;
531 ch
->hw
.status
= ata_ahci_status
;
532 ch
->hw
.begin_transaction
= ata_ahci_begin_transaction
;
533 ch
->hw
.end_transaction
= ata_ahci_end_transaction
;
534 ch
->hw
.command
= NULL
; /* not used here */
536 /* setup work areas */
537 work
= ch
->dma
->work_bus
+ ATA_AHCI_CL_OFFSET
;
538 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_CLB
+ offset
, work
& 0xffffffff);
539 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_CLBU
+ offset
, work
>> 32);
541 work
= ch
->dma
->work_bus
+ ATA_AHCI_FB_OFFSET
;
542 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_FB
+ offset
, work
& 0xffffffff);
543 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_FBU
+ offset
, work
>> 32);
545 /* enable wanted port interrupts */
546 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_IE
+ offset
,
547 (ATA_AHCI_P_IX_CPD
| ATA_AHCI_P_IX_TFE
| ATA_AHCI_P_IX_HBF
|
548 ATA_AHCI_P_IX_HBD
| ATA_AHCI_P_IX_IF
| ATA_AHCI_P_IX_OF
|
549 ATA_AHCI_P_IX_PRC
| ATA_AHCI_P_IX_PC
| ATA_AHCI_P_IX_DP
|
550 ATA_AHCI_P_IX_UF
| ATA_AHCI_P_IX_SDB
| ATA_AHCI_P_IX_DS
|
551 ATA_AHCI_P_IX_PS
| ATA_AHCI_P_IX_DHR
));
553 /* start operations on this channel */
554 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
,
555 (ATA_AHCI_P_CMD_ACTIVE
| ATA_AHCI_P_CMD_FRE
|
556 ATA_AHCI_P_CMD_POD
| ATA_AHCI_P_CMD_SUD
| ATA_AHCI_P_CMD_ST
));
561 ata_ahci_status(device_t dev
)
563 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
564 struct ata_channel
*ch
= device_get_softc(dev
);
565 u_int32_t action
= ATA_INL(ctlr
->r_res2
, ATA_AHCI_IS
);
566 int offset
= ch
->unit
<< 7;
569 if (action
& (1 << ch
->unit
)) {
570 u_int32_t istatus
= ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_IS
+ offset
);
571 u_int32_t cstatus
= ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_CI
+ offset
);
573 /* clear interrupt(s) */
574 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_IS
, action
& (1 << ch
->unit
));
575 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_IS
+ offset
, istatus
);
577 /* do we have any PHY events ? */
578 /* XXX SOS check istatus phy bits */
579 ata_sata_phy_check_events(dev
);
581 /* do we have a potentially hanging engine to take care of? */
582 if ((istatus
& 0x78400050) && (cstatus
& (1 << tag
))) {
584 u_int32_t cmd
= ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
);
587 /* kill off all activity on this channel */
588 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
,
589 cmd
& ~(ATA_AHCI_P_CMD_FRE
| ATA_AHCI_P_CMD_ST
));
591 /* XXX SOS this is not entirely wrong */
594 if (timeout
++ > 500) {
595 device_printf(dev
, "stopping AHCI engine failed\n");
598 } while (ATA_INL(ctlr
->r_res2
,
599 ATA_AHCI_P_CMD
+ offset
) & ATA_AHCI_P_CMD_CR
);
601 /* start operations on this channel */
602 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
,
603 cmd
| (ATA_AHCI_P_CMD_FRE
| ATA_AHCI_P_CMD_ST
));
608 return (!(cstatus
& (1 << tag
)));
613 /* must be called with ATA channel locked and state_mtx held */
615 ata_ahci_begin_transaction(struct ata_request
*request
)
617 struct ata_pci_controller
*ctlr
=device_get_softc(GRANDPARENT(request
->dev
));
618 struct ata_channel
*ch
= device_get_softc(device_get_parent(request
->dev
));
619 struct ata_ahci_cmd_tab
*ctp
;
620 struct ata_ahci_cmd_list
*clp
;
621 int offset
= ch
->unit
<< 7;
622 int tag
= 0, entries
= 0;
625 /* get a piece of the workspace for this request */
626 ctp
= (struct ata_ahci_cmd_tab
*)
627 (ch
->dma
->work
+ ATA_AHCI_CT_OFFSET
+ (ATA_AHCI_CT_SIZE
* tag
));
629 /* setup the FIS for this request */
630 if (!(fis_size
= ata_ahci_setup_fis(ctp
, request
))) {
631 device_printf(request
->dev
, "setting up SATA FIS failed\n");
632 request
->result
= EIO
;
633 return ATA_OP_FINISHED
;
636 /* if request moves data setup and load SG list */
637 if (request
->flags
& (ATA_R_READ
| ATA_R_WRITE
)) {
638 if (ch
->dma
->load(ch
->dev
, request
->data
, request
->bytecount
,
639 request
->flags
& ATA_R_READ
,
640 ctp
->prd_tab
, &entries
)) {
641 device_printf(request
->dev
, "setting up DMA failed\n");
642 request
->result
= EIO
;
643 return ATA_OP_FINISHED
;
647 /* setup the command list entry */
648 clp
= (struct ata_ahci_cmd_list
*)
649 (ch
->dma
->work
+ ATA_AHCI_CL_OFFSET
+ (ATA_AHCI_CL_SIZE
* tag
));
651 clp
->prd_length
= entries
;
652 clp
->cmd_flags
= (request
->flags
& ATA_R_WRITE
? (1<<6) : 0) |
653 (request
->flags
& ATA_R_ATAPI
? ((1<<5) | (1<<7)) : 0) |
654 (fis_size
/ sizeof(u_int32_t
));
656 clp
->cmd_table_phys
= htole64(ch
->dma
->work_bus
+ ATA_AHCI_CT_OFFSET
+
657 (ATA_AHCI_CT_SIZE
* tag
));
659 /* clear eventual ACTIVE bit */
660 ATA_IDX_OUTL(ch
, ATA_SACTIVE
, ATA_IDX_INL(ch
, ATA_SACTIVE
) & (1 << tag
));
662 /* set command type bit */
663 if (request
->flags
& ATA_R_ATAPI
)
664 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
,
665 ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
) |
666 ATA_AHCI_P_CMD_ATAPI
);
668 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
,
669 ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
) &
670 ~ATA_AHCI_P_CMD_ATAPI
);
672 /* issue command to controller */
673 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_CI
+ offset
, (1 << tag
));
675 if (!(request
->flags
& ATA_R_ATAPI
)) {
676 /* device reset doesn't interrupt */
677 if (request
->u
.ata
.command
== ATA_DEVICE_RESET
) {
679 int timeout
= 1000000;
683 tf_data
= ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_TFD
+ (ch
->unit
<<7));
684 } while ((tf_data
& ATA_S_BUSY
) && timeout
--);
686 device_printf(ch
->dev
, "device_reset timeout=%dus\n",
687 (1000000-timeout
)*10);
688 request
->status
= tf_data
;
689 if (request
->status
& ATA_S_ERROR
)
690 request
->error
= tf_data
>> 8;
691 return ATA_OP_FINISHED
;
695 /* start the timeout */
696 callout_reset(&request
->callout
, request
->timeout
* hz
,
697 (timeout_t
*)ata_timeout
, request
);
698 return ATA_OP_CONTINUES
;
701 /* must be called with ATA channel locked and state_mtx held */
703 ata_ahci_end_transaction(struct ata_request
*request
)
705 struct ata_pci_controller
*ctlr
=device_get_softc(GRANDPARENT(request
->dev
));
706 struct ata_channel
*ch
= device_get_softc(device_get_parent(request
->dev
));
707 struct ata_ahci_cmd_list
*clp
;
709 int offset
= ch
->unit
<< 7;
712 /* kill the timeout */
713 callout_stop(&request
->callout
);
716 tf_data
= ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_TFD
+ offset
);
717 request
->status
= tf_data
;
719 /* if error status get details */
720 if (request
->status
& ATA_S_ERROR
)
721 request
->error
= tf_data
>> 8;
723 /* record how much data we actually moved */
724 clp
= (struct ata_ahci_cmd_list
*)
725 (ch
->dma
->work
+ ATA_AHCI_CL_OFFSET
+ (ATA_AHCI_CL_SIZE
* tag
));
726 request
->donecount
= clp
->bytecount
;
728 /* release SG list etc */
729 ch
->dma
->unload(ch
->dev
);
731 return ATA_OP_FINISHED
;
735 ata_ahci_reset(device_t dev
)
737 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
738 struct ata_channel
*ch
= device_get_softc(dev
);
739 u_int32_t cmd
, signature
;
740 int offset
= ch
->unit
<< 7;
743 if (!(ATA_INL(ctlr
->r_res2
, ATA_AHCI_PI
) & (1 << ch
->unit
))) {
744 device_printf(dev
, "port not implemented\n");
749 /* kill off all activity on this channel */
750 cmd
= ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
);
751 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
,
752 cmd
& ~(ATA_AHCI_P_CMD_FRE
| ATA_AHCI_P_CMD_ST
));
754 /* XXX SOS this is not entirely wrong */
758 if (timeout
++ > 500) {
759 device_printf(dev
, "stopping AHCI engine failed\n");
763 while (ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
) & ATA_AHCI_P_CMD_CR
);
765 /* issue Command List Override if supported */
766 if (ATA_INL(ctlr
->r_res2
, ATA_AHCI_CAP
) & ATA_AHCI_CAP_CLO
) {
767 cmd
= ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
);
768 cmd
|= ATA_AHCI_P_CMD_CLO
;
769 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
, cmd
);
773 if (timeout
++ > 500) {
774 device_printf(dev
, "executing CLO failed\n");
778 while (ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+offset
)&ATA_AHCI_P_CMD_CLO
);
781 /* reset PHY and decide what is present */
782 if (ata_sata_phy_reset(dev
)) {
784 /* clear any interrupts pending on this channel */
785 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_IS
+ offset
,
786 ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_IS
+ offset
));
788 /* clear SATA error register */
789 ATA_IDX_OUTL(ch
, ATA_SERROR
, ATA_IDX_INL(ch
, ATA_SERROR
));
791 /* start operations on this channel */
792 ATA_OUTL(ctlr
->r_res2
, ATA_AHCI_P_CMD
+ offset
,
793 (ATA_AHCI_P_CMD_ACTIVE
| ATA_AHCI_P_CMD_FRE
|
794 ATA_AHCI_P_CMD_POD
| ATA_AHCI_P_CMD_SUD
| ATA_AHCI_P_CMD_ST
));
796 signature
= ATA_INL(ctlr
->r_res2
, ATA_AHCI_P_SIG
+ offset
);
799 ch
->devices
= ATA_ATA_MASTER
;
802 ch
->devices
= ATA_PORTMULTIPLIER
;
803 device_printf(ch
->dev
, "Portmultipliers not supported yet\n");
807 ch
->devices
= ATA_ATAPI_MASTER
;
809 default: /* SOS XXX */
811 device_printf(ch
->dev
, "No signature, assuming disk device\n");
812 ch
->devices
= ATA_ATA_MASTER
;
816 device_printf(dev
, "ahci_reset devices=0x%b\n", ch
->devices
,
817 "\20\4ATAPI_SLAVE\3ATAPI_MASTER\2ATA_SLAVE\1ATA_MASTER");
821 ata_ahci_dmasetprd(void *xsc
, bus_dma_segment_t
*segs
, int nsegs
, int error
)
823 struct ata_dmasetprd_args
*args
= xsc
;
824 struct ata_ahci_dma_prd
*prd
= args
->dmatab
;
827 if (!(args
->error
= error
)) {
828 for (i
= 0; i
< nsegs
; i
++) {
829 prd
[i
].dba
= htole64(segs
[i
].ds_addr
);
830 prd
[i
].dbc
= htole32((segs
[i
].ds_len
- 1) & ATA_AHCI_PRD_MASK
);
837 ata_ahci_dmainit(device_t dev
)
839 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
840 struct ata_channel
*ch
= device_get_softc(dev
);
844 /* note start and stop are not used here */
845 ch
->dma
->setprd
= ata_ahci_dmasetprd
;
846 ch
->dma
->max_iosize
= 8192 * DEV_BSIZE
;
847 if (ATA_INL(ctlr
->r_res2
, ATA_AHCI_CAP
) & ATA_AHCI_CAP_64BIT
)
848 ch
->dma
->max_address
= BUS_SPACE_MAXADDR
;
853 ata_ahci_setup_fis(struct ata_ahci_cmd_tab
*ctp
, struct ata_request
*request
)
855 bzero(ctp
->cfis
, 64);
856 if (request
->flags
& ATA_R_ATAPI
) {
857 bzero(ctp
->acmd
, 32);
858 bcopy(request
->u
.atapi
.ccb
, ctp
->acmd
, 16);
860 return ata_request2fis_h2d(request
, &ctp
->cfis
[0]);
864 * Generic AHCI part support functions.
867 ata_genahci_ident(device_t dev
)
869 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
870 static struct ata_chip_id id
= {0, 0, 0, 0x00, ATA_SA300
, "AHCI"};
873 if(!(pci_read_config(dev
, PCIR_PROGIF
, 1) == PCIP_STORAGE_SATA_AHCI
)) {
877 ksprintf(buffer
, "GENERIC %s %s controller", id
.text
, ata_mode2str(id
.max_dma
));
878 device_set_desc_copy(dev
, buffer
);
880 ctlr
->chipinit
= ata_genahci_chipinit
;
885 ata_genahci_chipinit(device_t dev
)
887 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
889 if (ata_setup_interrupt(dev
))
892 /* Check if the chip has PCI BAR 5 as memory resource. */
893 ctlr
->r_type2
= SYS_RES_MEMORY
;
894 ctlr
->r_rid2
= PCIR_BAR(5); /* 0x24 */
895 if ((ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
896 &ctlr
->r_rid2
, RF_ACTIVE
))) {
897 return ata_ahci_chipinit(dev
);
903 * Acard chipset support functions
906 ata_acard_ident(device_t dev
)
908 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
909 struct ata_chip_id
*idx
;
910 static struct ata_chip_id ids
[] =
911 {{ ATA_ATP850R
, 0, ATPOLD
, 0x00, ATA_UDMA2
, "ATP850" },
912 { ATA_ATP860A
, 0, 0, 0x00, ATA_UDMA4
, "ATP860A" },
913 { ATA_ATP860R
, 0, 0, 0x00, ATA_UDMA4
, "ATP860R" },
914 { ATA_ATP865A
, 0, 0, 0x00, ATA_UDMA6
, "ATP865A" },
915 { ATA_ATP865R
, 0, 0, 0x00, ATA_UDMA6
, "ATP865R" },
916 { 0, 0, 0, 0, 0, 0}};
919 if (!(idx
= ata_match_chip(dev
, ids
)))
922 ksprintf(buffer
, "Acard %s %s controller",
923 idx
->text
, ata_mode2str(idx
->max_dma
));
924 device_set_desc_copy(dev
, buffer
);
926 ctlr
->chipinit
= ata_acard_chipinit
;
931 ata_acard_chipinit(device_t dev
)
933 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
935 if (ata_setup_interrupt(dev
))
938 ctlr
->allocate
= ata_acard_allocate
;
939 if (ctlr
->chip
->cfg1
== ATPOLD
) {
940 ctlr
->setmode
= ata_acard_850_setmode
;
941 ctlr
->locking
= ata_serialize
;
944 ctlr
->setmode
= ata_acard_86X_setmode
;
949 ata_acard_allocate(device_t dev
)
951 struct ata_channel
*ch
= device_get_softc(dev
);
953 /* setup the usual register normal pci style */
954 if (ata_pci_allocate(dev
))
957 ch
->hw
.status
= ata_acard_status
;
962 ata_acard_status(device_t dev
)
964 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
965 struct ata_channel
*ch
= device_get_softc(dev
);
967 if (ctlr
->chip
->cfg1
== ATPOLD
&&
968 ATA_LOCKING(ch
->dev
, ATA_LF_WHICH
) != ch
->unit
)
970 if (ch
->dma
&& (ch
->dma
->flags
& ATA_DMA_ACTIVE
)) {
971 int bmstat
= ATA_IDX_INB(ch
, ATA_BMSTAT_PORT
) & ATA_BMSTAT_MASK
;
973 if ((bmstat
& (ATA_BMSTAT_ACTIVE
| ATA_BMSTAT_INTERRUPT
)) !=
974 ATA_BMSTAT_INTERRUPT
)
976 ATA_IDX_OUTB(ch
, ATA_BMSTAT_PORT
, bmstat
& ~ATA_BMSTAT_ERROR
);
978 ATA_IDX_OUTB(ch
, ATA_BMCMD_PORT
,
979 ATA_IDX_INB(ch
, ATA_BMCMD_PORT
) & ~ATA_BMCMD_START_STOP
);
982 if (ATA_IDX_INB(ch
, ATA_ALTSTAT
) & ATA_S_BUSY
) {
984 if (ATA_IDX_INB(ch
, ATA_ALTSTAT
) & ATA_S_BUSY
)
991 ata_acard_850_setmode(device_t dev
, int mode
)
993 device_t gparent
= GRANDPARENT(dev
);
994 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
995 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
996 struct ata_device
*atadev
= device_get_softc(dev
);
997 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
1000 mode
= ata_limit_mode(dev
, mode
,
1001 ata_atapi(dev
) ? ATA_PIO_MAX
: ctlr
->chip
->max_dma
);
1003 /* XXX SOS missing WDMA0+1 + PIO modes */
1004 if (mode
>= ATA_WDMA2
) {
1005 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
1007 device_printf(dev
, "%ssetting %s on %s chip\n",
1008 (error
) ? "FAILURE " : "",
1009 ata_mode2str(mode
), ctlr
->chip
->text
);
1011 u_int8_t reg54
= pci_read_config(gparent
, 0x54, 1);
1013 reg54
&= ~(0x03 << (devno
<< 1));
1014 if (mode
>= ATA_UDMA0
)
1015 reg54
|= (((mode
& ATA_MODE_MASK
) + 1) << (devno
<< 1));
1016 pci_write_config(gparent
, 0x54, reg54
, 1);
1017 pci_write_config(gparent
, 0x4a, 0xa6, 1);
1018 pci_write_config(gparent
, 0x40 + (devno
<< 1), 0x0301, 2);
1019 atadev
->mode
= mode
;
1023 /* we could set PIO mode timings, but we assume the BIOS did that */
1027 ata_acard_86X_setmode(device_t dev
, int mode
)
1029 device_t gparent
= GRANDPARENT(dev
);
1030 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
1031 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
1032 struct ata_device
*atadev
= device_get_softc(dev
);
1033 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
1037 mode
= ata_limit_mode(dev
, mode
,
1038 ata_atapi(dev
) ? ATA_PIO_MAX
: ctlr
->chip
->max_dma
);
1040 mode
= ata_check_80pin(dev
, mode
);
1042 /* XXX SOS missing WDMA0+1 + PIO modes */
1043 if (mode
>= ATA_WDMA2
) {
1044 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
1046 device_printf(dev
, "%ssetting %s on %s chip\n",
1047 (error
) ? "FAILURE " : "",
1048 ata_mode2str(mode
), ctlr
->chip
->text
);
1050 u_int16_t reg44
= pci_read_config(gparent
, 0x44, 2);
1052 reg44
&= ~(0x000f << (devno
<< 2));
1053 if (mode
>= ATA_UDMA0
)
1054 reg44
|= (((mode
& ATA_MODE_MASK
) + 1) << (devno
<< 2));
1055 pci_write_config(gparent
, 0x44, reg44
, 2);
1056 pci_write_config(gparent
, 0x4a, 0xa6, 1);
1057 pci_write_config(gparent
, 0x40 + devno
, 0x31, 1);
1058 atadev
->mode
= mode
;
1062 /* we could set PIO mode timings, but we assume the BIOS did that */
1067 * Acer Labs Inc (ALI) chipset support functions
1070 ata_ali_ident(device_t dev
)
1072 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1073 struct ata_chip_id
*idx
;
1074 static struct ata_chip_id ids
[] =
1075 {{ ATA_ALI_5289
, 0x00, 2, ALISATA
, ATA_SA150
, "M5289" },
1076 { ATA_ALI_5288
, 0x00, 4, ALISATA
, ATA_SA300
, "M5288" },
1077 { ATA_ALI_5287
, 0x00, 4, ALISATA
, ATA_SA150
, "M5287" },
1078 { ATA_ALI_5281
, 0x00, 2, ALISATA
, ATA_SA150
, "M5281" },
1079 { ATA_ALI_5229
, 0xc5, 0, ALINEW
, ATA_UDMA6
, "M5229" },
1080 { ATA_ALI_5229
, 0xc4, 0, ALINEW
, ATA_UDMA5
, "M5229" },
1081 { ATA_ALI_5229
, 0xc2, 0, ALINEW
, ATA_UDMA4
, "M5229" },
1082 { ATA_ALI_5229
, 0x20, 0, ALIOLD
, ATA_UDMA2
, "M5229" },
1083 { ATA_ALI_5229
, 0x00, 0, ALIOLD
, ATA_WDMA2
, "M5229" },
1084 { 0, 0, 0, 0, 0, 0}};
1087 if (!(idx
= ata_match_chip(dev
, ids
)))
1090 ksprintf(buffer
, "AcerLabs %s %s controller",
1091 idx
->text
, ata_mode2str(idx
->max_dma
));
1092 device_set_desc_copy(dev
, buffer
);
1094 ctlr
->chipinit
= ata_ali_chipinit
;
1099 ata_ali_chipinit(device_t dev
)
1101 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1103 if (ata_setup_interrupt(dev
))
1106 switch (ctlr
->chip
->cfg2
) {
1108 ctlr
->channels
= ctlr
->chip
->cfg1
;
1109 ctlr
->allocate
= ata_ali_sata_allocate
;
1110 ctlr
->setmode
= ata_sata_setmode
;
1112 /* if we have a memory resource we can likely do AHCI */
1113 ctlr
->r_type2
= SYS_RES_MEMORY
;
1114 ctlr
->r_rid2
= PCIR_BAR(5);
1115 if ((ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
1116 &ctlr
->r_rid2
, RF_ACTIVE
)))
1117 return ata_ahci_chipinit(dev
);
1119 /* enable PCI interrupt */
1120 pci_write_config(dev
, PCIR_COMMAND
,
1121 pci_read_config(dev
, PCIR_COMMAND
, 2) & ~0x0400, 2);
1125 /* use device interrupt as byte count end */
1126 pci_write_config(dev
, 0x4a, pci_read_config(dev
, 0x4a, 1) | 0x20, 1);
1128 /* enable cable detection and UDMA support on newer chips */
1129 pci_write_config(dev
, 0x4b, pci_read_config(dev
, 0x4b, 1) | 0x09, 1);
1131 /* enable ATAPI UDMA mode */
1132 pci_write_config(dev
, 0x53, pci_read_config(dev
, 0x53, 1) | 0x01, 1);
1134 /* only chips with revision > 0xc4 can do 48bit DMA */
1135 if (ctlr
->chip
->chiprev
<= 0xc4)
1137 "using PIO transfers above 137GB as workaround for "
1138 "48bit DMA access bug, expect reduced performance\n");
1139 ctlr
->allocate
= ata_ali_allocate
;
1140 ctlr
->reset
= ata_ali_reset
;
1141 ctlr
->setmode
= ata_ali_setmode
;
1145 /* deactivate the ATAPI FIFO and enable ATAPI UDMA */
1146 pci_write_config(dev
, 0x53, pci_read_config(dev
, 0x53, 1) | 0x03, 1);
1147 ctlr
->setmode
= ata_ali_setmode
;
1154 ata_ali_allocate(device_t dev
)
1156 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
1157 struct ata_channel
*ch
= device_get_softc(dev
);
1159 /* setup the usual register normal pci style */
1160 if (ata_pci_allocate(dev
))
1163 /* older chips can't do 48bit DMA transfers */
1164 if (ctlr
->chip
->chiprev
<= 0xc4)
1165 ch
->flags
|= ATA_NO_48BIT_DMA
;
1171 ata_ali_sata_allocate(device_t dev
)
1173 device_t parent
= device_get_parent(dev
);
1174 struct ata_pci_controller
*ctlr
= device_get_softc(parent
);
1175 struct ata_channel
*ch
= device_get_softc(dev
);
1176 struct resource
*io
= NULL
, *ctlio
= NULL
;
1177 int unit01
= (ch
->unit
& 1), unit10
= (ch
->unit
& 2);
1180 rid
= PCIR_BAR(0) + (unit01
? 8 : 0);
1181 io
= bus_alloc_resource_any(parent
, SYS_RES_IOPORT
, &rid
, RF_ACTIVE
);
1185 rid
= PCIR_BAR(1) + (unit01
? 8 : 0);
1186 ctlio
= bus_alloc_resource_any(parent
, SYS_RES_IOPORT
, &rid
, RF_ACTIVE
);
1188 bus_release_resource(dev
, SYS_RES_IOPORT
, ATA_IOADDR_RID
, io
);
1192 for (i
= ATA_DATA
; i
<= ATA_COMMAND
; i
++) {
1193 ch
->r_io
[i
].res
= io
;
1194 ch
->r_io
[i
].offset
= i
+ (unit10
? 8 : 0);
1196 ch
->r_io
[ATA_CONTROL
].res
= ctlio
;
1197 ch
->r_io
[ATA_CONTROL
].offset
= 2 + (unit10
? 4 : 0);
1198 ch
->r_io
[ATA_IDX_ADDR
].res
= io
;
1199 ata_default_registers(dev
);
1201 for (i
= ATA_BMCMD_PORT
; i
<= ATA_BMDTP_PORT
; i
++) {
1202 ch
->r_io
[i
].res
= ctlr
->r_res1
;
1203 ch
->r_io
[i
].offset
= (i
- ATA_BMCMD_PORT
)+(ch
->unit
* ATA_BMIOSIZE
);
1206 ch
->flags
|= ATA_NO_SLAVE
;
1208 /* XXX SOS PHY handling awkward in ALI chip not supported yet */
1214 ata_ali_reset(device_t dev
)
1216 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
1217 struct ata_channel
*ch
= device_get_softc(dev
);
1221 ata_generic_reset(dev
);
1224 * workaround for datacorruption bug found on at least SUN Blade-100
1225 * find the ISA function on the southbridge and disable then enable
1226 * the ATA channel tristate buffer
1228 if (ctlr
->chip
->chiprev
== 0xc3 || ctlr
->chip
->chiprev
== 0xc2) {
1229 if (!device_get_children(GRANDPARENT(dev
), &children
, &nchildren
)) {
1230 for (i
= 0; i
< nchildren
; i
++) {
1231 if (pci_get_devid(children
[i
]) == ATA_ALI_1533
) {
1232 pci_write_config(children
[i
], 0x58,
1233 pci_read_config(children
[i
], 0x58, 1) &
1234 ~(0x04 << ch
->unit
), 1);
1235 pci_write_config(children
[i
], 0x58,
1236 pci_read_config(children
[i
], 0x58, 1) |
1237 (0x04 << ch
->unit
), 1);
1241 kfree(children
, M_TEMP
);
1247 ata_ali_setmode(device_t dev
, int mode
)
1249 device_t gparent
= GRANDPARENT(dev
);
1250 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
1251 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
1252 struct ata_device
*atadev
= device_get_softc(dev
);
1253 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
1256 mode
= ata_limit_mode(dev
, mode
, ctlr
->chip
->max_dma
);
1258 if (ctlr
->chip
->cfg2
& ALINEW
) {
1259 if (mode
> ATA_UDMA2
&&
1260 pci_read_config(gparent
, 0x4a, 1) & (1 << ch
->unit
)) {
1261 ata_print_cable(dev
, "controller");
1266 mode
= ata_check_80pin(dev
, mode
);
1268 if (ctlr
->chip
->cfg2
& ALIOLD
) {
1269 /* doesn't support ATAPI DMA on write */
1270 ch
->flags
|= ATA_ATAPI_DMA_RO
;
1271 if (ch
->devices
& ATA_ATAPI_MASTER
&& ch
->devices
& ATA_ATAPI_SLAVE
) {
1272 /* doesn't support ATAPI DMA on two ATAPI devices */
1273 device_printf(dev
, "two atapi devices on this channel, no DMA\n");
1274 mode
= ata_limit_mode(dev
, mode
, ATA_PIO_MAX
);
1278 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
1281 device_printf(dev
, "%ssetting %s on %s chip\n",
1282 (error
) ? "FAILURE " : "",
1283 ata_mode2str(mode
), ctlr
->chip
->text
);
1285 if (mode
>= ATA_UDMA0
) {
1286 u_int8_t udma
[] = {0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x0f, 0x0d};
1287 u_int32_t word54
= pci_read_config(gparent
, 0x54, 4);
1289 word54
&= ~(0x000f000f << (devno
<< 2));
1290 word54
|= (((udma
[mode
&ATA_MODE_MASK
]<<16)|0x05)<<(devno
<<2));
1291 pci_write_config(gparent
, 0x54, word54
, 4);
1292 pci_write_config(gparent
, 0x58 + (ch
->unit
<< 2),
1296 u_int32_t piotimings
[] =
1297 { 0x006d0003, 0x00580002, 0x00440001, 0x00330001,
1298 0x00310001, 0x00440001, 0x00330001, 0x00310001};
1300 pci_write_config(gparent
, 0x54, pci_read_config(gparent
, 0x54, 4) &
1301 ~(0x0008000f << (devno
<< 2)), 4);
1302 pci_write_config(gparent
, 0x58 + (ch
->unit
<< 2),
1303 piotimings
[ata_mode2idx(mode
)], 4);
1305 atadev
->mode
= mode
;
1311 * American Micro Devices (AMD) chipset support functions
1314 ata_amd_ident(device_t dev
)
1316 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1317 struct ata_chip_id
*idx
;
1318 static struct ata_chip_id ids
[] =
1319 {{ ATA_AMD756
, 0x00, AMDNVIDIA
, 0x00, ATA_UDMA4
, "756" },
1320 { ATA_AMD766
, 0x00, AMDNVIDIA
, AMDCABLE
|AMDBUG
, ATA_UDMA5
, "766" },
1321 { ATA_AMD768
, 0x00, AMDNVIDIA
, AMDCABLE
, ATA_UDMA5
, "768" },
1322 { ATA_AMD8111
, 0x00, AMDNVIDIA
, AMDCABLE
, ATA_UDMA6
, "8111" },
1323 { 0, 0, 0, 0, 0, 0}};
1326 if (!(idx
= ata_match_chip(dev
, ids
)))
1329 ksprintf(buffer
, "AMD %s %s controller",
1330 idx
->text
, ata_mode2str(idx
->max_dma
));
1331 device_set_desc_copy(dev
, buffer
);
1333 ctlr
->chipinit
= ata_amd_chipinit
;
1338 ata_amd_chipinit(device_t dev
)
1340 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1342 if (ata_setup_interrupt(dev
))
1345 /* disable/set prefetch, postwrite */
1346 if (ctlr
->chip
->cfg2
& AMDBUG
)
1347 pci_write_config(dev
, 0x41, pci_read_config(dev
, 0x41, 1) & 0x0f, 1);
1349 pci_write_config(dev
, 0x41, pci_read_config(dev
, 0x41, 1) | 0xf0, 1);
1351 ctlr
->setmode
= ata_via_family_setmode
;
1357 * ATI chipset support functions
1360 ata_ati_ident(device_t dev
)
1362 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1363 struct ata_chip_id
*idx
;
1364 static struct ata_chip_id ids
[] =
1365 {{ ATA_ATI_IXP200
, 0x00, 0, 0, ATA_UDMA5
, "IXP200" },
1366 { ATA_ATI_IXP300
, 0x00, 0, 0, ATA_UDMA6
, "IXP300" },
1367 { ATA_ATI_IXP400
, 0x00, 0, 0, ATA_UDMA6
, "IXP400" },
1368 { ATA_ATI_SB600
, 0x00, 0, 0, ATA_UDMA6
, "SB600" },
1369 { ATA_ATI_IXP300_S1
, 0x00, SIIMEMIO
, 0, ATA_SA150
, "IXP300" },
1370 { ATA_ATI_IXP400_S1
, 0x00, SIIMEMIO
, 0, ATA_SA150
, "IXP400" },
1371 { ATA_ATI_IXP400_S2
, 0x00, SIIMEMIO
, 0, ATA_SA150
, "IXP400" },
1372 { ATA_ATI_SB600_S1
, 0x00, ATIAHCI
, 0, ATA_SA300
, "SB600" },
1373 { ATA_ATI_SB600_S2
, 0x00, ATIAHCI
, 0, ATA_SA300
, "SB600" },
1374 { 0, 0, 0, 0, 0, 0}};
1377 if (!(idx
= ata_match_chip(dev
, ids
)))
1380 ksprintf(buffer
, "ATI %s %s controller",
1381 idx
->text
, ata_mode2str(idx
->max_dma
));
1382 device_set_desc_copy(dev
, buffer
);
1386 * The ATI SATA controllers are actually a SiI 3112 controller, except
1389 if (ctlr
->chip
->cfg1
& SIIMEMIO
)
1390 ctlr
->chipinit
= ata_sii_chipinit
;
1392 ctlr
->chipinit
= ata_ati_chipinit
;
1397 ata_ati_chipinit(device_t dev
)
1399 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1401 if (ata_setup_interrupt(dev
))
1404 /* The SB600 needs special treatment. */
1405 if (ctlr
->chip
->cfg1
& ATIAHCI
) {
1406 /* Check if the chip is configured as an AHCI part. */
1407 if ((pci_get_subclass(dev
) == PCIS_STORAGE_SATA
) &&
1408 (pci_read_config(dev
, PCIR_PROGIF
, 1) == PCIP_STORAGE_SATA_AHCI
)) {
1409 /* Check if the chip has PCI BAR 5 as memory resource. */
1410 ctlr
->r_type2
= SYS_RES_MEMORY
;
1411 ctlr
->r_rid2
= PCIR_BAR(5); /* 0x24 */
1412 if ((ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
1415 return ata_ahci_chipinit(dev
);
1420 ctlr
->setmode
= ata_ati_setmode
;
1425 ata_ati_setmode(device_t dev
, int mode
)
1427 device_t gparent
= GRANDPARENT(dev
);
1428 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
1429 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
1430 struct ata_device
*atadev
= device_get_softc(dev
);
1431 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
1432 int offset
= (devno
^ 0x01) << 3;
1434 u_int8_t piotimings
[] = { 0x5d, 0x47, 0x34, 0x22, 0x20, 0x34, 0x22, 0x20,
1435 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 };
1436 u_int8_t dmatimings
[] = { 0x77, 0x21, 0x20 };
1438 mode
= ata_limit_mode(dev
, mode
, ctlr
->chip
->max_dma
);
1440 mode
= ata_check_80pin(dev
, mode
);
1442 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
1445 device_printf(dev
, "%ssetting %s on %s chip\n",
1446 (error
) ? "FAILURE " : "",
1447 ata_mode2str(mode
), ctlr
->chip
->text
);
1449 if (mode
>= ATA_UDMA0
) {
1450 pci_write_config(gparent
, 0x56,
1451 (pci_read_config(gparent
, 0x56, 2) &
1452 ~(0xf << (devno
<< 2))) |
1453 ((mode
& ATA_MODE_MASK
) << (devno
<< 2)), 2);
1454 pci_write_config(gparent
, 0x54,
1455 pci_read_config(gparent
, 0x54, 1) |
1456 (0x01 << devno
), 1);
1457 pci_write_config(gparent
, 0x44,
1458 (pci_read_config(gparent
, 0x44, 4) &
1459 ~(0xff << offset
)) |
1460 (dmatimings
[2] << offset
), 4);
1462 else if (mode
>= ATA_WDMA0
) {
1463 pci_write_config(gparent
, 0x54,
1464 pci_read_config(gparent
, 0x54, 1) &
1465 ~(0x01 << devno
), 1);
1466 pci_write_config(gparent
, 0x44,
1467 (pci_read_config(gparent
, 0x44, 4) &
1468 ~(0xff << offset
)) |
1469 (dmatimings
[mode
& ATA_MODE_MASK
] << offset
), 4);
1472 pci_write_config(gparent
, 0x54,
1473 pci_read_config(gparent
, 0x54, 1) &
1474 ~(0x01 << devno
), 1);
1476 pci_write_config(gparent
, 0x4a,
1477 (pci_read_config(gparent
, 0x4a, 2) &
1478 ~(0xf << (devno
<< 2))) |
1479 (((mode
- ATA_PIO0
) & ATA_MODE_MASK
) << (devno
<<2)),2);
1480 pci_write_config(gparent
, 0x40,
1481 (pci_read_config(gparent
, 0x40, 4) &
1482 ~(0xff << offset
)) |
1483 (piotimings
[ata_mode2idx(mode
)] << offset
), 4);
1484 atadev
->mode
= mode
;
1489 * Cyrix chipset support functions
1492 ata_cyrix_ident(device_t dev
)
1494 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1496 if (pci_get_devid(dev
) == ATA_CYRIX_5530
) {
1497 device_set_desc(dev
, "Cyrix 5530 ATA33 controller");
1498 ctlr
->chipinit
= ata_cyrix_chipinit
;
1505 ata_cyrix_chipinit(device_t dev
)
1507 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1509 if (ata_setup_interrupt(dev
))
1513 ctlr
->setmode
= ata_cyrix_setmode
;
1515 ctlr
->setmode
= ata_generic_setmode
;
1520 ata_cyrix_setmode(device_t dev
, int mode
)
1522 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
1523 struct ata_device
*atadev
= device_get_softc(dev
);
1524 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
1525 u_int32_t piotiming
[] =
1526 { 0x00009172, 0x00012171, 0x00020080, 0x00032010, 0x00040010 };
1527 u_int32_t dmatiming
[] = { 0x00077771, 0x00012121, 0x00002020 };
1528 u_int32_t udmatiming
[] = { 0x00921250, 0x00911140, 0x00911030 };
1531 ch
->dma
->alignment
= 16;
1532 ch
->dma
->max_iosize
= 126 * DEV_BSIZE
;
1534 mode
= ata_limit_mode(dev
, mode
, ATA_UDMA2
);
1536 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
1539 device_printf(dev
, "%ssetting %s on Cyrix chip\n",
1540 (error
) ? "FAILURE " : "", ata_mode2str(mode
));
1542 if (mode
>= ATA_UDMA0
) {
1543 ATA_OUTL(ch
->r_io
[ATA_BMCMD_PORT
].res
,
1544 0x24 + (devno
<< 3), udmatiming
[mode
& ATA_MODE_MASK
]);
1546 else if (mode
>= ATA_WDMA0
) {
1547 ATA_OUTL(ch
->r_io
[ATA_BMCMD_PORT
].res
,
1548 0x24 + (devno
<< 3), dmatiming
[mode
& ATA_MODE_MASK
]);
1551 ATA_OUTL(ch
->r_io
[ATA_BMCMD_PORT
].res
,
1552 0x20 + (devno
<< 3), piotiming
[mode
& ATA_MODE_MASK
]);
1554 atadev
->mode
= mode
;
1560 * Cypress chipset support functions
1563 ata_cypress_ident(device_t dev
)
1565 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1568 * the Cypress chip is a mess, it contains two ATA functions, but
1569 * both channels are visible on the first one.
1570 * simply ignore the second function for now, as the right
1571 * solution (ignoring the second channel on the first function)
1572 * doesn't work with the crappy ATA interrupt setup on the alpha.
1574 if (pci_get_devid(dev
) == ATA_CYPRESS_82C693
&&
1575 pci_get_function(dev
) == 1 &&
1576 pci_get_subclass(dev
) == PCIS_STORAGE_IDE
) {
1577 device_set_desc(dev
, "Cypress 82C693 ATA controller");
1578 ctlr
->chipinit
= ata_cypress_chipinit
;
1585 ata_cypress_chipinit(device_t dev
)
1587 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1589 if (ata_setup_interrupt(dev
))
1592 ctlr
->setmode
= ata_cypress_setmode
;
1597 ata_cypress_setmode(device_t dev
, int mode
)
1599 device_t gparent
= GRANDPARENT(dev
);
1600 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
1601 struct ata_device
*atadev
= device_get_softc(dev
);
1604 mode
= ata_limit_mode(dev
, mode
, ATA_WDMA2
);
1606 /* XXX SOS missing WDMA0+1 + PIO modes */
1607 if (mode
== ATA_WDMA2
) {
1608 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
1610 device_printf(dev
, "%ssetting WDMA2 on Cypress chip\n",
1611 error
? "FAILURE " : "");
1613 pci_write_config(gparent
, ch
->unit
? 0x4e : 0x4c, 0x2020, 2);
1614 atadev
->mode
= mode
;
1618 /* we could set PIO mode timings, but we assume the BIOS did that */
1623 * HighPoint chipset support functions
1626 ata_highpoint_ident(device_t dev
)
1628 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1629 struct ata_chip_id
*idx
;
1630 static struct ata_chip_id ids
[] =
1631 {{ ATA_HPT374
, 0x07, HPT374
, 0x00, ATA_UDMA6
, "HPT374" },
1632 { ATA_HPT372
, 0x02, HPT372
, 0x00, ATA_UDMA6
, "HPT372N" },
1633 { ATA_HPT372
, 0x01, HPT372
, 0x00, ATA_UDMA6
, "HPT372" },
1634 { ATA_HPT371
, 0x01, HPT372
, 0x00, ATA_UDMA6
, "HPT371" },
1635 { ATA_HPT366
, 0x05, HPT372
, 0x00, ATA_UDMA6
, "HPT372" },
1636 { ATA_HPT366
, 0x03, HPT370
, 0x00, ATA_UDMA5
, "HPT370" },
1637 { ATA_HPT366
, 0x02, HPT366
, 0x00, ATA_UDMA4
, "HPT368" },
1638 { ATA_HPT366
, 0x00, HPT366
, HPTOLD
, ATA_UDMA4
, "HPT366" },
1639 { ATA_HPT302
, 0x01, HPT372
, 0x00, ATA_UDMA6
, "HPT302" },
1640 { 0, 0, 0, 0, 0, 0}};
1643 if (!(idx
= ata_match_chip(dev
, ids
)))
1646 strcpy(buffer
, "HighPoint ");
1647 strcat(buffer
, idx
->text
);
1648 if (idx
->cfg1
== HPT374
) {
1649 if (pci_get_function(dev
) == 0)
1650 strcat(buffer
, " (channel 0+1)");
1651 if (pci_get_function(dev
) == 1)
1652 strcat(buffer
, " (channel 2+3)");
1654 ksprintf(buffer
, "%s %s controller", buffer
, ata_mode2str(idx
->max_dma
));
1655 device_set_desc_copy(dev
, buffer
);
1657 ctlr
->chipinit
= ata_highpoint_chipinit
;
1662 ata_highpoint_chipinit(device_t dev
)
1664 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1666 if (ata_setup_interrupt(dev
))
1669 if (ctlr
->chip
->cfg2
== HPTOLD
) {
1670 /* disable interrupt prediction */
1671 pci_write_config(dev
, 0x51, (pci_read_config(dev
, 0x51, 1) & ~0x80), 1);
1674 /* disable interrupt prediction */
1675 pci_write_config(dev
, 0x51, (pci_read_config(dev
, 0x51, 1) & ~0x03), 1);
1676 pci_write_config(dev
, 0x55, (pci_read_config(dev
, 0x55, 1) & ~0x03), 1);
1678 /* enable interrupts */
1679 pci_write_config(dev
, 0x5a, (pci_read_config(dev
, 0x5a, 1) & ~0x10), 1);
1681 /* set clocks etc */
1682 if (ctlr
->chip
->cfg1
< HPT372
)
1683 pci_write_config(dev
, 0x5b, 0x22, 1);
1685 pci_write_config(dev
, 0x5b,
1686 (pci_read_config(dev
, 0x5b, 1) & 0x01) | 0x20, 1);
1688 ctlr
->allocate
= ata_highpoint_allocate
;
1689 ctlr
->setmode
= ata_highpoint_setmode
;
1694 ata_highpoint_allocate(device_t dev
)
1696 struct ata_channel
*ch
= device_get_softc(dev
);
1698 /* setup the usual register normal pci style */
1699 if (ata_pci_allocate(dev
))
1702 ch
->flags
|= ATA_ALWAYS_DMASTAT
;
1707 ata_highpoint_setmode(device_t dev
, int mode
)
1709 device_t gparent
= GRANDPARENT(dev
);
1710 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
1711 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
1712 struct ata_device
*atadev
= device_get_softc(dev
);
1713 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
1715 u_int32_t timings33
[][4] = {
1716 /* HPT366 HPT370 HPT372 HPT374 mode */
1717 { 0x40d0a7aa, 0x06914e57, 0x0d029d5e, 0x0ac1f48a }, /* PIO 0 */
1718 { 0x40d0a7a3, 0x06914e43, 0x0d029d26, 0x0ac1f465 }, /* PIO 1 */
1719 { 0x40d0a753, 0x06514e33, 0x0c829ca6, 0x0a81f454 }, /* PIO 2 */
1720 { 0x40c8a742, 0x06514e22, 0x0c829c84, 0x0a81f443 }, /* PIO 3 */
1721 { 0x40c8a731, 0x06514e21, 0x0c829c62, 0x0a81f442 }, /* PIO 4 */
1722 { 0x20c8a797, 0x26514e97, 0x2c82922e, 0x228082ea }, /* MWDMA 0 */
1723 { 0x20c8a732, 0x26514e33, 0x2c829266, 0x22808254 }, /* MWDMA 1 */
1724 { 0x20c8a731, 0x26514e21, 0x2c829262, 0x22808242 }, /* MWDMA 2 */
1725 { 0x10c8a731, 0x16514e31, 0x1c829c62, 0x121882ea }, /* UDMA 0 */
1726 { 0x10cba731, 0x164d4e31, 0x1c9a9c62, 0x12148254 }, /* UDMA 1 */
1727 { 0x10caa731, 0x16494e31, 0x1c929c62, 0x120c8242 }, /* UDMA 2 */
1728 { 0x10cfa731, 0x166d4e31, 0x1c8e9c62, 0x128c8242 }, /* UDMA 3 */
1729 { 0x10c9a731, 0x16454e31, 0x1c8a9c62, 0x12ac8242 }, /* UDMA 4 */
1730 { 0, 0x16454e31, 0x1c8a9c62, 0x12848242 }, /* UDMA 5 */
1731 { 0, 0, 0x1c869c62, 0x12808242 } /* UDMA 6 */
1734 mode
= ata_limit_mode(dev
, mode
, ctlr
->chip
->max_dma
);
1736 if (ctlr
->chip
->cfg1
== HPT366
&& ata_atapi(dev
))
1737 mode
= ata_limit_mode(dev
, mode
, ATA_PIO_MAX
);
1739 mode
= ata_highpoint_check_80pin(dev
, mode
);
1742 * most if not all HPT chips cant really handle that the device is
1743 * running at ATA_UDMA6/ATA133 speed, so we cheat at set the device to
1744 * a max of ATA_UDMA5/ATA100 to guard against suboptimal performance
1746 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0,
1747 ata_limit_mode(dev
, mode
, ATA_UDMA5
));
1749 device_printf(dev
, "%ssetting %s on HighPoint chip\n",
1750 (error
) ? "FAILURE " : "", ata_mode2str(mode
));
1752 pci_write_config(gparent
, 0x40 + (devno
<< 2),
1753 timings33
[ata_mode2idx(mode
)][ctlr
->chip
->cfg1
], 4);
1754 atadev
->mode
= mode
;
1758 ata_highpoint_check_80pin(device_t dev
, int mode
)
1760 device_t gparent
= GRANDPARENT(dev
);
1761 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
1762 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
1763 u_int8_t reg
, val
, res
;
1765 if (ctlr
->chip
->cfg1
== HPT374
&& pci_get_function(gparent
) == 1) {
1766 reg
= ch
->unit
? 0x57 : 0x53;
1767 val
= pci_read_config(gparent
, reg
, 1);
1768 pci_write_config(gparent
, reg
, val
| 0x80, 1);
1772 val
= pci_read_config(gparent
, reg
, 1);
1773 pci_write_config(gparent
, reg
, val
& 0xfe, 1);
1775 res
= pci_read_config(gparent
, 0x5a, 1) & (ch
->unit
? 0x1:0x2);
1776 pci_write_config(gparent
, reg
, val
, 1);
1778 if (mode
> ATA_UDMA2
&& res
) {
1779 ata_print_cable(dev
, "controller");
1787 * Intel chipset support functions
1790 ata_intel_ident(device_t dev
)
1792 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1793 struct ata_chip_id
*idx
;
1794 static struct ata_chip_id ids
[] =
1795 {{ ATA_I82371FB
, 0, 0, 0x00, ATA_WDMA2
, "PIIX" },
1796 { ATA_I82371SB
, 0, 0, 0x00, ATA_WDMA2
, "PIIX3" },
1797 { ATA_I82371AB
, 0, 0, 0x00, ATA_UDMA2
, "PIIX4" },
1798 { ATA_I82443MX
, 0, 0, 0x00, ATA_UDMA2
, "PIIX4" },
1799 { ATA_I82451NX
, 0, 0, 0x00, ATA_UDMA2
, "PIIX4" },
1800 { ATA_I82801AB
, 0, 0, 0x00, ATA_UDMA2
, "ICH0" },
1801 { ATA_I82801AA
, 0, 0, 0x00, ATA_UDMA4
, "ICH" },
1802 { ATA_I82372FB
, 0, 0, 0x00, ATA_UDMA4
, "ICH" },
1803 { ATA_I82801BA
, 0, 0, 0x00, ATA_UDMA5
, "ICH2" },
1804 { ATA_I82801BA_1
, 0, 0, 0x00, ATA_UDMA5
, "ICH2" },
1805 { ATA_I82801CA
, 0, 0, 0x00, ATA_UDMA5
, "ICH3" },
1806 { ATA_I82801CA_1
, 0, 0, 0x00, ATA_UDMA5
, "ICH3" },
1807 { ATA_I82801DB
, 0, 0, 0x00, ATA_UDMA5
, "ICH4" },
1808 { ATA_I82801DB_1
, 0, 0, 0x00, ATA_UDMA5
, "ICH4" },
1809 { ATA_I82801EB
, 0, 0, 0x00, ATA_UDMA5
, "ICH5" },
1810 { ATA_I82801EB_S1
, 0, 0, 0x00, ATA_SA150
, "ICH5" },
1811 { ATA_I82801EB_R1
, 0, 0, 0x00, ATA_SA150
, "ICH5" },
1812 { ATA_I6300ESB
, 0, 0, 0x00, ATA_UDMA5
, "6300ESB" },
1813 { ATA_I6300ESB_S1
, 0, 0, 0x00, ATA_SA150
, "6300ESB" },
1814 { ATA_I6300ESB_R1
, 0, 0, 0x00, ATA_SA150
, "6300ESB" },
1815 { ATA_I82801FB
, 0, 0, 0x00, ATA_UDMA5
, "ICH6" },
1816 { ATA_I82801FB_S1
, 0, AHCI
, 0x00, ATA_SA150
, "ICH6" },
1817 { ATA_I82801FB_R1
, 0, AHCI
, 0x00, ATA_SA150
, "ICH6" },
1818 { ATA_I82801FBM
, 0, AHCI
, 0x00, ATA_SA150
, "ICH6M" },
1819 { ATA_I82801GB
, 0, 0, 0x00, ATA_UDMA5
, "ICH7" },
1820 { ATA_I82801GB_S1
, 0, AHCI
, 0x00, ATA_SA300
, "ICH7" },
1821 { ATA_I82801GB_R1
, 0, AHCI
, 0x00, ATA_SA300
, "ICH7" },
1822 { ATA_I82801GB_AH
, 0, AHCI
, 0x00, ATA_SA300
, "ICH7" },
1823 { ATA_I82801GBM_S1
, 0, AHCI
, 0x00, ATA_SA300
, "ICH7M" },
1824 { ATA_I82801GBM_R1
, 0, AHCI
, 0x00, ATA_SA300
, "ICH7M" },
1825 { ATA_I82801GBM_AH
, 0, AHCI
, 0x00, ATA_SA300
, "ICH7M" },
1826 { ATA_I63XXESB2
, 0, 0, 0x00, ATA_UDMA5
, "63XXESB2" },
1827 { ATA_I63XXESB2_S1
, 0, AHCI
, 0x00, ATA_SA300
, "63XXESB2" },
1828 { ATA_I63XXESB2_S2
, 0, AHCI
, 0x00, ATA_SA300
, "63XXESB2" },
1829 { ATA_I63XXESB2_R1
, 0, AHCI
, 0x00, ATA_SA300
, "63XXESB2" },
1830 { ATA_I63XXESB2_R2
, 0, AHCI
, 0x00, ATA_SA300
, "63XXESB2" },
1831 { ATA_I82801HB_S1
, 0, AHCI
, 0x00, ATA_SA300
, "ICH8" },
1832 { ATA_I82801HB_S2
, 0, AHCI
, 0x00, ATA_SA300
, "ICH8" },
1833 { ATA_I82801HB_R1
, 0, AHCI
, 0x00, ATA_SA300
, "ICH8" },
1834 { ATA_I82801HB_AH4
, 0, AHCI
, 0x00, ATA_SA300
, "ICH8" },
1835 { ATA_I82801HB_AH6
, 0, AHCI
, 0x00, ATA_SA300
, "ICH8" },
1836 { ATA_I82801HBM_S1
, 0, 0, 0x00, ATA_SA300
, "ICH8M" },
1837 { ATA_I82801HBM_S2
, 0, AHCI
, 0x00, ATA_SA300
, "ICH8M" },
1838 { ATA_I82801HBM_S3
, 0, AHCI
, 0x00, ATA_SA300
, "ICH8M" },
1839 { ATA_I31244
, 0, 0, 0x00, ATA_SA150
, "31244" },
1840 { 0, 0, 0, 0, 0, 0}};
1843 if (!(idx
= ata_match_chip(dev
, ids
)))
1846 ksprintf(buffer
, "Intel %s %s controller",
1847 idx
->text
, ata_mode2str(idx
->max_dma
));
1848 device_set_desc_copy(dev
, buffer
);
1850 ctlr
->chipinit
= ata_intel_chipinit
;
1855 ata_intel_chipinit(device_t dev
)
1857 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
1859 if (ata_setup_interrupt(dev
))
1862 /* good old PIIX needs special treatment (not implemented) */
1863 if (ctlr
->chip
->chipid
== ATA_I82371FB
) {
1864 ctlr
->setmode
= ata_intel_old_setmode
;
1867 /* the intel 31244 needs special care if in DPA mode */
1868 else if (ctlr
->chip
->chipid
== ATA_I31244
) {
1869 if (pci_get_subclass(dev
) != PCIS_STORAGE_IDE
) {
1870 ctlr
->r_type2
= SYS_RES_MEMORY
;
1871 ctlr
->r_rid2
= PCIR_BAR(0);
1872 if (!(ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
1877 ctlr
->allocate
= ata_intel_31244_allocate
;
1878 ctlr
->reset
= ata_intel_31244_reset
;
1880 ctlr
->setmode
= ata_sata_setmode
;
1883 /* non SATA intel chips goes here */
1884 else if (ctlr
->chip
->max_dma
< ATA_SA150
) {
1885 ctlr
->allocate
= ata_intel_allocate
;
1886 ctlr
->setmode
= ata_intel_new_setmode
;
1889 /* SATA parts can be either compat or AHCI */
1891 /* force all ports active "the legacy way" */
1892 pci_write_config(dev
, 0x92, pci_read_config(dev
, 0x92, 2) | 0x0f,2);
1894 ctlr
->allocate
= ata_intel_allocate
;
1895 ctlr
->reset
= ata_intel_reset
;
1898 * if we have AHCI capability and BAR(5) as a memory resource
1899 * and AHCI or RAID mode enabled in BIOS we go for AHCI mode
1901 if ((ctlr
->chip
->cfg1
== AHCI
) &&
1902 (pci_read_config(dev
, 0x90, 1) & 0xc0)) {
1903 ctlr
->r_type2
= SYS_RES_MEMORY
;
1904 ctlr
->r_rid2
= PCIR_BAR(5);
1905 if ((ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
1908 return ata_ahci_chipinit(dev
);
1910 ctlr
->setmode
= ata_sata_setmode
;
1912 /* enable PCI interrupt */
1913 pci_write_config(dev
, PCIR_COMMAND
,
1914 pci_read_config(dev
, PCIR_COMMAND
, 2) & ~0x0400, 2);
1920 ata_intel_allocate(device_t dev
)
1922 struct ata_channel
*ch
= device_get_softc(dev
);
1924 /* setup the usual register normal pci style */
1925 if (ata_pci_allocate(dev
))
1928 ch
->flags
|= ATA_ALWAYS_DMASTAT
;
1933 ata_intel_reset(device_t dev
)
1935 device_t parent
= device_get_parent(dev
);
1936 struct ata_pci_controller
*ctlr
= device_get_softc(parent
);
1937 struct ata_channel
*ch
= device_get_softc(dev
);
1940 /* ICH6 & ICH7 in compat mode has 4 SATA ports as master/slave on 2 ch's */
1941 if (ctlr
->chip
->cfg1
) {
1942 mask
= (0x0005 << ch
->unit
);
1945 /* ICH5 in compat mode has SATA ports as master/slave on 1 channel */
1946 if (pci_read_config(parent
, 0x90, 1) & 0x04)
1949 mask
= (0x0001 << ch
->unit
);
1950 /* XXX SOS should be in intel_allocate if we grow it */
1951 ch
->flags
|= ATA_NO_SLAVE
;
1954 pci_write_config(parent
, 0x92, pci_read_config(parent
, 0x92, 2) & ~mask
, 2);
1956 pci_write_config(parent
, 0x92, pci_read_config(parent
, 0x92, 2) | mask
, 2);
1958 /* wait up to 1 sec for "connect well" */
1959 for (timeout
= 0; timeout
< 100 ; timeout
++) {
1960 if (((pci_read_config(parent
, 0x92, 2) & (mask
<< 4)) == (mask
<< 4)) &&
1961 (ATA_IDX_INB(ch
, ATA_STATUS
) != 0xff))
1965 ata_generic_reset(dev
);
1969 ata_intel_old_setmode(device_t dev
, int mode
)
1975 ata_intel_new_setmode(device_t dev
, int mode
)
1977 device_t gparent
= GRANDPARENT(dev
);
1978 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
1979 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
1980 struct ata_device
*atadev
= device_get_softc(dev
);
1981 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
1982 u_int32_t reg40
= pci_read_config(gparent
, 0x40, 4);
1983 u_int8_t reg44
= pci_read_config(gparent
, 0x44, 1);
1984 u_int8_t reg48
= pci_read_config(gparent
, 0x48, 1);
1985 u_int16_t reg4a
= pci_read_config(gparent
, 0x4a, 2);
1986 u_int16_t reg54
= pci_read_config(gparent
, 0x54, 2);
1987 u_int32_t mask40
= 0, new40
= 0;
1988 u_int8_t mask44
= 0, new44
= 0;
1990 u_int8_t timings
[] = { 0x00, 0x00, 0x10, 0x21, 0x23, 0x10, 0x21, 0x23,
1991 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23 };
1992 /* PIO0 PIO1 PIO2 PIO3 PIO4 WDMA0 WDMA1 WDMA2 */
1993 /* UDMA0 UDMA1 UDMA2 UDMA3 UDMA4 UDMA5 UDMA6 */
1995 mode
= ata_limit_mode(dev
, mode
, ctlr
->chip
->max_dma
);
1997 if ( mode
> ATA_UDMA2
&& !(reg54
& (0x10 << devno
))) {
1998 ata_print_cable(dev
, "controller");
2002 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
2005 device_printf(dev
, "%ssetting %s on %s chip\n",
2006 (error
) ? "FAILURE " : "",
2007 ata_mode2str(mode
), ctlr
->chip
->text
);
2012 * reg48: 1 bit per (primary drive 0, primary drive 1, secondary
2013 * drive 0, secondary drive 1)
2015 * 0 Disable Ultra DMA mode
2016 * 1 Enable Ultra DMA mode
2018 * reg4a: 4 bits per (primary drive 0, primary drive 1, secondary
2019 * drive 0, secondary drive 1).
2021 * 0001 UDMA mode 1, 3, 5
2022 * 0010 UDMA mode 2, 4, reserved
2024 * (top two bits for each drive reserved)
2028 "regs before 40=%08x 44=%02x 48=%02x 4a=%04x 54=%04x\n",
2029 reg40
, reg44
, reg48
,reg4a
, reg54
);
2031 reg48
&= ~(0x0001 << devno
);
2032 reg4a
&= ~(0x3 << (devno
<< 2));
2033 if (mode
>= ATA_UDMA0
) {
2034 reg48
|= 0x0001 << devno
;
2035 if (mode
> ATA_UDMA0
)
2036 reg4a
|= (1 + !(mode
& 0x01)) << (devno
<< 2);
2038 pci_write_config(gparent
, 0x48, reg48
, 2);
2039 pci_write_config(gparent
, 0x4a, reg4a
, 2);
2045 * 19:18 Secondary ATA signal mode
2046 * 17:16 Primary ATA signal mode
2047 * 00 = Normal (enabled)
2048 * 01 = Tri-state (disabled)
2049 * 10 = Drive Low (disabled)
2052 * 15 Secondary drive 1 - Base Clock
2053 * 14 Secondary drive 0 - Base Clock
2054 * 13 Primary drive 1 - Base Clock
2055 * 12 Primary drive 0 - Base Clock
2056 * 0 = Select 33 MHz clock
2057 * 1 = Select 100 Mhz clock
2060 * 10 Vendor specific (set by BIOS?)
2063 * 07 Secondary drive 1 - Cable Type
2064 * 06 Secondary drive 0 - Cable Type
2065 * 05 Primary drive 1 - Cable Type
2066 * 04 Primary drive 0 - Cable Type
2068 * 1 = 80 Conductor (or high speed cable)
2070 * 03 Secondary drive 1 - Select 33/66 clock
2071 * 02 Secondary drive 0 - Select 33/66 clock
2072 * 01 Primary drive 1 - Select 33/66 clock
2073 * 00 Primary drive 0 - Select 33/66 clock
2077 * It is unclear what this should be set to when operating
2080 * NOTE: UDMA2 = 33 MHz
2081 * UDMA3 = 40 MHz (?) - unsupported
2086 reg54
|= 0x0400; /* set vendor specific bit */
2087 reg54
&= ~((0x1 << devno
) | (0x1000 << devno
));
2089 if (mode
>= ATA_UDMA5
)
2090 reg54
|= (0x1000 << devno
);
2091 else if (mode
>= ATA_UDMA3
) /* XXX should this be ATA_UDMA3 or 4? */
2092 reg54
|= (0x1 << devno
);
2094 pci_write_config(gparent
, 0x54, reg54
, 2);
2097 * Reg40 (32 bits... well, actually two 16 bit registers)
2099 * Primary channel bits 15:00, Secondary channel bits 31:00. Note
2100 * that slave timings are handled in register 44.
2102 * 15 ATA Decode Enable (R/W) 1 = enable decoding of I/O ranges
2104 * 14 Slave ATA Timing Register Enable (R/W)
2106 * 13:12 IORDY Sample Mode
2109 * 10 PIO-3, PIO-4, MW-1, MW-2
2114 * 09:08 Recovery Mode
2115 * 00 PIO-0, PIO-2, SW-2
2120 * 07:04 Secondary Device Control Bits
2121 * 03:00 Primary Device Control Bits
2123 * bit 3 DMA Timing Enable
2125 * bit 2 Indicate Presence of ATA(1) or ATAPI(0) device
2127 * bit 1 Enable IORDY sample point capability for PIO
2128 * xfers. Always enabled for PIO4 and PIO3, enabled
2129 * for PIO2 if indicated by the device, and otherwise
2130 * probably should be 0.
2132 * bit 0 Fast Drive Timing Enable. Enables faster then PIO-0
2137 * Modify reg40 according to the table
2139 if (atadev
->unit
== ATA_MASTER
) {
2141 new40
= timings
[ata_mode2idx(mode
)] << 8;
2145 new44
= ((timings
[ata_mode2idx(mode
)] & 0x30) >> 2) |
2146 (timings
[ata_mode2idx(mode
)] & 0x03);
2150 * Slave ATA timing register enable
2156 * Device control bits 3:0 for master, 7:4 for slave.
2158 * bit3 DMA Timing enable.
2159 * bit2 Indicate presence of ATA(1) or ATAPI(0) device, set accordingly
2160 * bit1 Enable IORDY sample point capability for PIO xfers. Always
2161 * enabled for PIO4 and PIO3, enabled for PIO2 if indicated by
2162 * the device, and otherwise should be 0.
2163 * bit0 Fast Drive Timing Enable. Enable faster then PIO-0 timing modes.
2168 if (atadev
->unit
== ATA_MASTER
) {
2171 if (!ata_atapi(dev
))
2176 if (!ata_atapi(dev
))
2180 reg40 &= ~0x00ff00ff;
2181 reg40 |= 0x40774077;
2185 * Primary or Secondary controller
2193 pci_write_config(gparent
, 0x40, (reg40
& ~mask40
) | new40
, 4);
2194 pci_write_config(gparent
, 0x44, (reg44
& ~mask44
) | new44
, 1);
2197 reg40
= pci_read_config(gparent
, 0x40, 4);
2198 reg44
= pci_read_config(gparent
, 0x44, 1);
2199 reg48
= pci_read_config(gparent
, 0x48, 1);
2200 reg4a
= pci_read_config(gparent
, 0x4a, 2);
2201 reg54
= pci_read_config(gparent
, 0x54, 2);
2203 "regs after 40=%08x 44=%02x 48=%02x 4a=%04x 54=%04x\n",
2204 reg40
, reg44
, reg48
,reg4a
, reg54
);
2207 atadev
->mode
= mode
;
2211 ata_intel_31244_allocate(device_t dev
)
2213 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
2214 struct ata_channel
*ch
= device_get_softc(dev
);
2218 ch_offset
= 0x200 + ch
->unit
* 0x200;
2220 for (i
= ATA_DATA
; i
< ATA_MAX_RES
; i
++)
2221 ch
->r_io
[i
].res
= ctlr
->r_res2
;
2223 /* setup ATA registers */
2224 ch
->r_io
[ATA_DATA
].offset
= ch_offset
+ 0x00;
2225 ch
->r_io
[ATA_FEATURE
].offset
= ch_offset
+ 0x06;
2226 ch
->r_io
[ATA_COUNT
].offset
= ch_offset
+ 0x08;
2227 ch
->r_io
[ATA_SECTOR
].offset
= ch_offset
+ 0x0c;
2228 ch
->r_io
[ATA_CYL_LSB
].offset
= ch_offset
+ 0x10;
2229 ch
->r_io
[ATA_CYL_MSB
].offset
= ch_offset
+ 0x14;
2230 ch
->r_io
[ATA_DRIVE
].offset
= ch_offset
+ 0x18;
2231 ch
->r_io
[ATA_COMMAND
].offset
= ch_offset
+ 0x1d;
2232 ch
->r_io
[ATA_ERROR
].offset
= ch_offset
+ 0x04;
2233 ch
->r_io
[ATA_STATUS
].offset
= ch_offset
+ 0x1c;
2234 ch
->r_io
[ATA_ALTSTAT
].offset
= ch_offset
+ 0x28;
2235 ch
->r_io
[ATA_CONTROL
].offset
= ch_offset
+ 0x29;
2237 /* setup DMA registers */
2238 ch
->r_io
[ATA_SSTATUS
].offset
= ch_offset
+ 0x100;
2239 ch
->r_io
[ATA_SERROR
].offset
= ch_offset
+ 0x104;
2240 ch
->r_io
[ATA_SCONTROL
].offset
= ch_offset
+ 0x108;
2242 /* setup SATA registers */
2243 ch
->r_io
[ATA_BMCMD_PORT
].offset
= ch_offset
+ 0x70;
2244 ch
->r_io
[ATA_BMSTAT_PORT
].offset
= ch_offset
+ 0x72;
2245 ch
->r_io
[ATA_BMDTP_PORT
].offset
= ch_offset
+ 0x74;
2247 ch
->flags
|= ATA_NO_SLAVE
;
2249 ch
->hw
.status
= ata_intel_31244_status
;
2250 ch
->hw
.command
= ata_intel_31244_command
;
2252 /* enable PHY state change interrupt */
2253 ATA_OUTL(ctlr
->r_res2
, 0x4,
2254 ATA_INL(ctlr
->r_res2
, 0x04) | (0x01 << (ch
->unit
<< 3)));
2259 ata_intel_31244_status(device_t dev
)
2261 /* do we have any PHY events ? */
2262 ata_sata_phy_check_events(dev
);
2264 /* any drive action to take care of ? */
2265 return ata_pci_status(dev
);
2269 ata_intel_31244_command(struct ata_request
*request
)
2271 struct ata_channel
*ch
= device_get_softc(device_get_parent(request
->dev
));
2272 struct ata_device
*atadev
= device_get_softc(request
->dev
);
2275 if (!(atadev
->flags
& ATA_D_48BIT_ACTIVE
))
2276 return (ata_generic_command(request
));
2278 lba
= request
->u
.ata
.lba
;
2279 ATA_IDX_OUTB(ch
, ATA_DRIVE
, ATA_D_IBM
| ATA_D_LBA
| atadev
->unit
);
2280 /* enable interrupt */
2281 ATA_IDX_OUTB(ch
, ATA_CONTROL
, ATA_A_4BIT
);
2282 ATA_IDX_OUTW(ch
, ATA_FEATURE
, request
->u
.ata
.feature
);
2283 ATA_IDX_OUTW(ch
, ATA_COUNT
, request
->u
.ata
.count
);
2284 ATA_IDX_OUTW(ch
, ATA_SECTOR
, ((lba
>> 16) & 0xff00) | (lba
& 0x00ff));
2285 ATA_IDX_OUTW(ch
, ATA_CYL_LSB
, ((lba
>> 24) & 0xff00) |
2286 ((lba
>> 8) & 0x00ff));
2287 ATA_IDX_OUTW(ch
, ATA_CYL_MSB
, ((lba
>> 32) & 0xff00) |
2288 ((lba
>> 16) & 0x00ff));
2290 /* issue command to controller */
2291 ATA_IDX_OUTB(ch
, ATA_COMMAND
, request
->u
.ata
.command
);
2297 ata_intel_31244_reset(device_t dev
)
2299 if (ata_sata_phy_reset(dev
))
2300 ata_generic_reset(dev
);
2305 * Integrated Technology Express Inc. (ITE) chipset support functions
2308 ata_ite_ident(device_t dev
)
2310 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
2311 struct ata_chip_id
*idx
;
2312 static struct ata_chip_id ids
[] =
2313 {{ ATA_IT8212F
, 0x00, 0x00, 0x00, ATA_UDMA6
, "IT8212F" },
2314 { ATA_IT8211F
, 0x00, 0x00, 0x00, ATA_UDMA6
, "IT8211F" },
2315 { 0, 0, 0, 0, 0, 0}};
2318 if (!(idx
= ata_match_chip(dev
, ids
)))
2321 ksprintf(buffer
, "ITE %s %s controller",
2322 idx
->text
, ata_mode2str(idx
->max_dma
));
2323 device_set_desc_copy(dev
, buffer
);
2325 ctlr
->chipinit
= ata_ite_chipinit
;
2330 ata_ite_chipinit(device_t dev
)
2332 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
2334 if (ata_setup_interrupt(dev
))
2337 ctlr
->setmode
= ata_ite_setmode
;
2339 /* set PCI mode and 66Mhz reference clock */
2340 pci_write_config(dev
, 0x50, pci_read_config(dev
, 0x50, 1) & ~0x83, 1);
2342 /* set default active & recover timings */
2343 pci_write_config(dev
, 0x54, 0x31, 1);
2344 pci_write_config(dev
, 0x56, 0x31, 1);
2349 ata_ite_setmode(device_t dev
, int mode
)
2351 device_t gparent
= GRANDPARENT(dev
);
2352 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
2353 struct ata_device
*atadev
= device_get_softc(dev
);
2354 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
2357 /* correct the mode for what the HW supports */
2358 mode
= ata_limit_mode(dev
, mode
, ATA_UDMA6
);
2360 /* check the CBLID bits for 80 conductor cable detection */
2361 if (mode
> ATA_UDMA2
&& (pci_read_config(gparent
, 0x40, 2) &
2362 (ch
->unit
? (1<<3) : (1<<2)))) {
2363 ata_print_cable(dev
, "controller");
2367 /* set the wanted mode on the device */
2368 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
2371 device_printf(dev
, "%s setting %s on ITE8212F chip\n",
2372 (error
) ? "failed" : "success", ata_mode2str(mode
));
2374 /* if the device accepted the mode change, setup the HW accordingly */
2376 if (mode
>= ATA_UDMA0
) {
2377 u_int8_t udmatiming
[] =
2378 { 0x44, 0x42, 0x31, 0x21, 0x11, 0xa2, 0x91 };
2380 /* enable UDMA mode */
2381 pci_write_config(gparent
, 0x50,
2382 pci_read_config(gparent
, 0x50, 1) &
2383 ~(1 << (devno
+ 3)), 1);
2385 /* set UDMA timing */
2386 pci_write_config(gparent
,
2387 0x56 + (ch
->unit
<< 2) + ATA_DEV(atadev
->unit
),
2388 udmatiming
[mode
& ATA_MODE_MASK
], 1);
2391 u_int8_t chtiming
[] =
2392 { 0xaa, 0xa3, 0xa1, 0x33, 0x31, 0x88, 0x32, 0x31 };
2394 /* disable UDMA mode */
2395 pci_write_config(gparent
, 0x50,
2396 pci_read_config(gparent
, 0x50, 1) |
2397 (1 << (devno
+ 3)), 1);
2399 /* set active and recover timing (shared between master & slave) */
2400 if (pci_read_config(gparent
, 0x54 + (ch
->unit
<< 2), 1) <
2401 chtiming
[ata_mode2idx(mode
)])
2402 pci_write_config(gparent
, 0x54 + (ch
->unit
<< 2),
2403 chtiming
[ata_mode2idx(mode
)], 1);
2405 atadev
->mode
= mode
;
2411 * JMicron chipset support functions
2414 ata_jmicron_ident(device_t dev
)
2416 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
2417 struct ata_chip_id
*idx
;
2418 static struct ata_chip_id ids
[] =
2419 {{ ATA_JMB360
, 0, 1, 0, ATA_SA300
, "JMB360" },
2420 { ATA_JMB361
, 0, 1, 1, ATA_SA300
, "JMB361" },
2421 { ATA_JMB363
, 0, 2, 1, ATA_SA300
, "JMB363" },
2422 { ATA_JMB365
, 0, 1, 2, ATA_SA300
, "JMB365" },
2423 { ATA_JMB366
, 0, 2, 2, ATA_SA300
, "JMB366" },
2424 { ATA_JMB368
, 0, 0, 1, ATA_UDMA6
, "JMB368" },
2425 { 0, 0, 0, 0, 0, 0}};
2428 if (!(idx
= ata_match_chip(dev
, ids
)))
2431 if ((pci_read_config(dev
, 0xdf, 1) & 0x40) &&
2432 (pci_get_function(dev
) == (pci_read_config(dev
, 0x40, 1) & 0x02 >> 1)))
2433 ksnprintf(buffer
, sizeof(buffer
), "JMicron %s %s controller",
2434 idx
->text
, ata_mode2str(ATA_UDMA6
));
2436 ksnprintf(buffer
, sizeof(buffer
), "JMicron %s %s controller",
2437 idx
->text
, ata_mode2str(idx
->max_dma
));
2438 device_set_desc_copy(dev
, buffer
);
2440 ctlr
->chipinit
= ata_jmicron_chipinit
;
2445 ata_jmicron_chipinit(device_t dev
)
2447 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
2450 if (ata_setup_interrupt(dev
))
2453 /* do we have multiple PCI functions ? */
2454 if (pci_read_config(dev
, 0xdf, 1) & 0x40) {
2455 /* if we have a memory BAR(5) we are on the AHCI part */
2456 ctlr
->r_type2
= SYS_RES_MEMORY
;
2457 ctlr
->r_rid2
= PCIR_BAR(5);
2458 if ((ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
2459 &ctlr
->r_rid2
, RF_ACTIVE
)))
2460 return ata_ahci_chipinit(dev
);
2462 /* otherwise we are on the PATA part */
2463 ctlr
->allocate
= ata_pci_allocate
;
2464 ctlr
->reset
= ata_generic_reset
;
2465 ctlr
->dmainit
= ata_pci_dmainit
;
2466 ctlr
->setmode
= ata_jmicron_setmode
;
2467 ctlr
->channels
= ctlr
->chip
->cfg2
;
2470 /* set controller configuration to a combined setup we support */
2471 pci_write_config(dev
, 0x40, 0x80c0a131, 4);
2472 pci_write_config(dev
, 0x80, 0x01200000, 4);
2474 ctlr
->r_type2
= SYS_RES_MEMORY
;
2475 ctlr
->r_rid2
= PCIR_BAR(5);
2476 if ((ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
2477 &ctlr
->r_rid2
, RF_ACTIVE
))) {
2478 if ((error
= ata_ahci_chipinit(dev
)))
2482 ctlr
->allocate
= ata_jmicron_allocate
;
2483 ctlr
->reset
= ata_jmicron_reset
;
2484 ctlr
->dmainit
= ata_jmicron_dmainit
;
2485 ctlr
->setmode
= ata_jmicron_setmode
;
2487 /* set the number of HW channels */
2488 ctlr
->channels
= ctlr
->chip
->cfg1
+ ctlr
->chip
->cfg2
;
2494 ata_jmicron_allocate(device_t dev
)
2496 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
2497 struct ata_channel
*ch
= device_get_softc(dev
);
2500 if (ch
->unit
>= ctlr
->chip
->cfg1
) {
2501 ch
->unit
-= ctlr
->chip
->cfg1
;
2502 error
= ata_pci_allocate(dev
);
2503 ch
->unit
+= ctlr
->chip
->cfg1
;
2506 error
= ata_ahci_allocate(dev
);
2511 ata_jmicron_reset(device_t dev
)
2513 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
2514 struct ata_channel
*ch
= device_get_softc(dev
);
2516 if (ch
->unit
>= ctlr
->chip
->cfg1
)
2517 ata_generic_reset(dev
);
2519 ata_ahci_reset(dev
);
2523 ata_jmicron_dmainit(device_t dev
)
2525 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
2526 struct ata_channel
*ch
= device_get_softc(dev
);
2528 if (ch
->unit
>= ctlr
->chip
->cfg1
)
2529 ata_pci_dmainit(dev
);
2531 ata_ahci_dmainit(dev
);
2535 ata_jmicron_setmode(device_t dev
, int mode
)
2537 struct ata_pci_controller
*ctlr
= device_get_softc(GRANDPARENT(dev
));
2538 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
2540 if (pci_read_config(dev
, 0xdf, 1) & 0x40 || ch
->unit
>= ctlr
->chip
->cfg1
) {
2541 struct ata_device
*atadev
= device_get_softc(dev
);
2543 /* check for 80pin cable present */
2544 if (pci_read_config(dev
, 0x40, 1) & 0x08)
2545 mode
= ata_limit_mode(dev
, mode
, ATA_UDMA2
);
2547 mode
= ata_limit_mode(dev
, mode
, ATA_UDMA6
);
2549 if (!ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
))
2550 atadev
->mode
= mode
;
2553 ata_sata_setmode(dev
, mode
);
2558 * Marvell chipset support functions
2560 #define ATA_MV_HOST_BASE(ch) \
2561 ((ch->unit & 3) * 0x0100) + (ch->unit > 3 ? 0x30000 : 0x20000)
2562 #define ATA_MV_EDMA_BASE(ch) \
2563 ((ch->unit & 3) * 0x2000) + (ch->unit > 3 ? 0x30000 : 0x20000)
2565 struct ata_marvell_response
{
2567 u_int8_t edma_status
;
2568 u_int8_t dev_status
;
2569 u_int32_t timestamp
;
2572 struct ata_marvell_dma_prdentry
{
2580 ata_marvell_ident(device_t dev
)
2582 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
2583 struct ata_chip_id
*idx
;
2584 static struct ata_chip_id ids
[] =
2585 {{ ATA_M88SX5040
, 0, 4, MV50XX
, ATA_SA150
, "88SX5040" },
2586 { ATA_M88SX5041
, 0, 4, MV50XX
, ATA_SA150
, "88SX5041" },
2587 { ATA_M88SX5080
, 0, 8, MV50XX
, ATA_SA150
, "88SX5080" },
2588 { ATA_M88SX5081
, 0, 8, MV50XX
, ATA_SA150
, "88SX5081" },
2589 { ATA_M88SX6041
, 0, 4, MV60XX
, ATA_SA300
, "88SX6041" },
2590 { ATA_M88SX6081
, 0, 8, MV60XX
, ATA_SA300
, "88SX6081" },
2591 { ATA_M88SX6101
, 0, 1, MV61XX
, ATA_UDMA6
, "88SX6101" },
2592 { ATA_M88SX6145
, 0, 2, MV61XX
, ATA_UDMA6
, "88SX6145" },
2593 { 0, 0, 0, 0, 0, 0}};
2596 if (!(idx
= ata_match_chip(dev
, ids
)))
2599 ksprintf(buffer
, "Marvell %s %s controller",
2600 idx
->text
, ata_mode2str(idx
->max_dma
));
2601 device_set_desc_copy(dev
, buffer
);
2603 switch (ctlr
->chip
->cfg2
) {
2606 ctlr
->chipinit
= ata_marvell_edma_chipinit
;
2609 ctlr
->chipinit
= ata_marvell_pata_chipinit
;
2616 ata_marvell_pata_chipinit(device_t dev
)
2618 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
2620 if (ata_setup_interrupt(dev
))
2623 ctlr
->allocate
= ata_marvell_pata_allocate
;
2624 ctlr
->setmode
= ata_marvell_pata_setmode
;
2625 ctlr
->channels
= ctlr
->chip
->cfg1
;
2630 ata_marvell_pata_allocate(device_t dev
)
2632 struct ata_channel
*ch
= device_get_softc(dev
);
2634 /* setup the usual register normal pci style */
2635 if (ata_pci_allocate(dev
))
2638 /* dont use 32 bit PIO transfers */
2639 ch
->flags
|= ATA_USE_16BIT
;
2645 ata_marvell_pata_setmode(device_t dev
, int mode
)
2647 device_t gparent
= GRANDPARENT(dev
);
2648 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
2649 struct ata_device
*atadev
= device_get_softc(dev
);
2651 mode
= ata_limit_mode(dev
, mode
, ctlr
->chip
->max_dma
);
2652 mode
= ata_check_80pin(dev
, mode
);
2653 if (!ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
))
2654 atadev
->mode
= mode
;
2658 ata_marvell_edma_chipinit(device_t dev
)
2660 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
2662 if (ata_setup_interrupt(dev
))
2665 ctlr
->r_type1
= SYS_RES_MEMORY
;
2666 ctlr
->r_rid1
= PCIR_BAR(0);
2667 if (!(ctlr
->r_res1
= bus_alloc_resource_any(dev
, ctlr
->r_type1
,
2668 &ctlr
->r_rid1
, RF_ACTIVE
)))
2671 /* mask all host controller interrupts */
2672 ATA_OUTL(ctlr
->r_res1
, 0x01d64, 0x00000000);
2674 /* mask all PCI interrupts */
2675 ATA_OUTL(ctlr
->r_res1
, 0x01d5c, 0x00000000);
2677 ctlr
->allocate
= ata_marvell_edma_allocate
;
2678 ctlr
->reset
= ata_marvell_edma_reset
;
2679 ctlr
->dmainit
= ata_marvell_edma_dmainit
;
2680 ctlr
->setmode
= ata_sata_setmode
;
2681 ctlr
->channels
= ctlr
->chip
->cfg1
;
2683 /* clear host controller interrupts */
2684 ATA_OUTL(ctlr
->r_res1
, 0x20014, 0x00000000);
2685 if (ctlr
->chip
->cfg1
> 4)
2686 ATA_OUTL(ctlr
->r_res1
, 0x30014, 0x00000000);
2688 /* clear PCI interrupts */
2689 ATA_OUTL(ctlr
->r_res1
, 0x01d58, 0x00000000);
2691 /* unmask PCI interrupts we want */
2692 ATA_OUTL(ctlr
->r_res1
, 0x01d5c, 0x007fffff);
2694 /* unmask host controller interrupts we want */
2695 ATA_OUTL(ctlr
->r_res1
, 0x01d64, 0x000000ff/*HC0*/ | 0x0001fe00/*HC1*/ |
2696 /*(1<<19) | (1<<20) | (1<<21) |*/(1<<22) | (1<<24) | (0x7f << 25));
2698 /* enable PCI interrupt */
2699 pci_write_config(dev
, PCIR_COMMAND
,
2700 pci_read_config(dev
, PCIR_COMMAND
, 2) & ~0x0400, 2);
2705 ata_marvell_edma_allocate(device_t dev
)
2707 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
2708 struct ata_channel
*ch
= device_get_softc(dev
);
2709 u_int64_t work
= ch
->dma
->work_bus
;
2712 /* clear work area */
2713 bzero(ch
->dma
->work
, 1024+256);
2715 /* set legacy ATA resources */
2716 for (i
= ATA_DATA
; i
<= ATA_COMMAND
; i
++) {
2717 ch
->r_io
[i
].res
= ctlr
->r_res1
;
2718 ch
->r_io
[i
].offset
= 0x02100 + (i
<< 2) + ATA_MV_EDMA_BASE(ch
);
2720 ch
->r_io
[ATA_CONTROL
].res
= ctlr
->r_res1
;
2721 ch
->r_io
[ATA_CONTROL
].offset
= 0x02120 + ATA_MV_EDMA_BASE(ch
);
2722 ch
->r_io
[ATA_IDX_ADDR
].res
= ctlr
->r_res1
;
2723 ata_default_registers(dev
);
2725 /* set SATA resources */
2726 switch (ctlr
->chip
->cfg2
) {
2728 ch
->r_io
[ATA_SSTATUS
].res
= ctlr
->r_res1
;
2729 ch
->r_io
[ATA_SSTATUS
].offset
= 0x00100 + ATA_MV_HOST_BASE(ch
);
2730 ch
->r_io
[ATA_SERROR
].res
= ctlr
->r_res1
;
2731 ch
->r_io
[ATA_SERROR
].offset
= 0x00104 + ATA_MV_HOST_BASE(ch
);
2732 ch
->r_io
[ATA_SCONTROL
].res
= ctlr
->r_res1
;
2733 ch
->r_io
[ATA_SCONTROL
].offset
= 0x00108 + ATA_MV_HOST_BASE(ch
);
2736 ch
->r_io
[ATA_SSTATUS
].res
= ctlr
->r_res1
;
2737 ch
->r_io
[ATA_SSTATUS
].offset
= 0x02300 + ATA_MV_EDMA_BASE(ch
);
2738 ch
->r_io
[ATA_SERROR
].res
= ctlr
->r_res1
;
2739 ch
->r_io
[ATA_SERROR
].offset
= 0x02304 + ATA_MV_EDMA_BASE(ch
);
2740 ch
->r_io
[ATA_SCONTROL
].res
= ctlr
->r_res1
;
2741 ch
->r_io
[ATA_SCONTROL
].offset
= 0x02308 + ATA_MV_EDMA_BASE(ch
);
2742 ch
->r_io
[ATA_SACTIVE
].res
= ctlr
->r_res1
;
2743 ch
->r_io
[ATA_SACTIVE
].offset
= 0x02350 + ATA_MV_EDMA_BASE(ch
);
2747 ch
->flags
|= ATA_NO_SLAVE
;
2748 ch
->flags
|= ATA_USE_16BIT
; /* XXX SOS needed ? */
2749 ata_generic_hw(dev
);
2750 ch
->hw
.begin_transaction
= ata_marvell_edma_begin_transaction
;
2751 ch
->hw
.end_transaction
= ata_marvell_edma_end_transaction
;
2752 ch
->hw
.status
= ata_marvell_edma_status
;
2754 /* disable the EDMA machinery */
2755 ATA_OUTL(ctlr
->r_res1
, 0x02028 + ATA_MV_EDMA_BASE(ch
), 0x00000002);
2756 DELAY(100000); /* SOS should poll for disabled */
2758 /* set configuration to non-queued 128b read transfers stop on error */
2759 ATA_OUTL(ctlr
->r_res1
, 0x02000 + ATA_MV_EDMA_BASE(ch
), (1<<11) | (1<<13));
2761 /* request queue base high */
2762 ATA_OUTL(ctlr
->r_res1
, 0x02010 + ATA_MV_EDMA_BASE(ch
), work
>> 32);
2764 /* request queue in ptr */
2765 ATA_OUTL(ctlr
->r_res1
, 0x02014 + ATA_MV_EDMA_BASE(ch
), work
& 0xffffffff);
2767 /* request queue out ptr */
2768 ATA_OUTL(ctlr
->r_res1
, 0x02018 + ATA_MV_EDMA_BASE(ch
), 0x0);
2770 /* response queue base high */
2772 ATA_OUTL(ctlr
->r_res1
, 0x0201c + ATA_MV_EDMA_BASE(ch
), work
>> 32);
2774 /* response queue in ptr */
2775 ATA_OUTL(ctlr
->r_res1
, 0x02020 + ATA_MV_EDMA_BASE(ch
), 0x0);
2777 /* response queue out ptr */
2778 ATA_OUTL(ctlr
->r_res1
, 0x02024 + ATA_MV_EDMA_BASE(ch
), work
& 0xffffffff);
2780 /* clear SATA error register */
2781 ATA_IDX_OUTL(ch
, ATA_SERROR
, ATA_IDX_INL(ch
, ATA_SERROR
));
2783 /* clear any outstanding error interrupts */
2784 ATA_OUTL(ctlr
->r_res1
, 0x02008 + ATA_MV_EDMA_BASE(ch
), 0x0);
2786 /* unmask all error interrupts */
2787 ATA_OUTL(ctlr
->r_res1
, 0x0200c + ATA_MV_EDMA_BASE(ch
), ~0x0);
2789 /* enable EDMA machinery */
2790 ATA_OUTL(ctlr
->r_res1
, 0x02028 + ATA_MV_EDMA_BASE(ch
), 0x00000001);
2795 ata_marvell_edma_status(device_t dev
)
2797 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
2798 struct ata_channel
*ch
= device_get_softc(dev
);
2799 u_int32_t cause
= ATA_INL(ctlr
->r_res1
, 0x01d60);
2800 int shift
= (ch
->unit
<< 1) + (ch
->unit
> 3);
2802 if (cause
& (1 << shift
)) {
2804 /* clear interrupt(s) */
2805 ATA_OUTL(ctlr
->r_res1
, 0x02008 + ATA_MV_EDMA_BASE(ch
), 0x0);
2807 /* do we have any PHY events ? */
2808 ata_sata_phy_check_events(dev
);
2811 /* do we have any device action ? */
2812 return (cause
& (2 << shift
));
2815 /* must be called with ATA channel locked and state_mtx held */
2817 ata_marvell_edma_begin_transaction(struct ata_request
*request
)
2819 struct ata_pci_controller
*ctlr
=device_get_softc(GRANDPARENT(request
->dev
));
2820 struct ata_channel
*ch
= device_get_softc(device_get_parent(request
->dev
));
2826 int dummy
, error
, slot
;
2828 /* only DMA R/W goes through the EMDA machine */
2829 if (request
->u
.ata
.command
!= ATA_READ_DMA
&&
2830 request
->u
.ata
.command
!= ATA_WRITE_DMA
) {
2832 /* disable the EDMA machinery */
2833 if (ATA_INL(ctlr
->r_res1
, 0x02028 + ATA_MV_EDMA_BASE(ch
)) & 0x00000001)
2834 ATA_OUTL(ctlr
->r_res1
, 0x02028 + ATA_MV_EDMA_BASE(ch
), 0x00000002);
2835 return ata_begin_transaction(request
);
2838 /* check for 48 bit access and convert if needed */
2839 ata_modify_if_48bit(request
);
2841 /* check sanity, setup SG list and DMA engine */
2842 if ((error
= ch
->dma
->load(ch
->dev
, request
->data
, request
->bytecount
,
2843 request
->flags
& ATA_R_READ
, ch
->dma
->sg
,
2845 device_printf(request
->dev
, "setting up DMA failed\n");
2846 request
->result
= error
;
2847 return ATA_OP_FINISHED
;
2850 /* get next free request queue slot */
2851 req_in
= ATA_INL(ctlr
->r_res1
, 0x02014 + ATA_MV_EDMA_BASE(ch
));
2852 slot
= (((req_in
& ~0xfffffc00) >> 5) + 0) & 0x1f;
2853 bytep
= (u_int8_t
*)(ch
->dma
->work
);
2854 bytep
+= (slot
<< 5);
2855 wordp
= (u_int16_t
*)bytep
;
2856 quadp
= (u_int32_t
*)bytep
;
2858 /* fill in this request */
2859 quadp
[0] = (long)ch
->dma
->sg_bus
& 0xffffffff;
2860 quadp
[1] = (u_int64_t
)ch
->dma
->sg_bus
>> 32;
2861 wordp
[4] = (request
->flags
& ATA_R_READ
? 0x01 : 0x00) | (tag
<<1);
2864 bytep
[i
++] = (request
->u
.ata
.count
>> 8) & 0xff;
2865 bytep
[i
++] = 0x10 | ATA_COUNT
;
2866 bytep
[i
++] = request
->u
.ata
.count
& 0xff;
2867 bytep
[i
++] = 0x10 | ATA_COUNT
;
2869 bytep
[i
++] = (request
->u
.ata
.lba
>> 24) & 0xff;
2870 bytep
[i
++] = 0x10 | ATA_SECTOR
;
2871 bytep
[i
++] = request
->u
.ata
.lba
& 0xff;
2872 bytep
[i
++] = 0x10 | ATA_SECTOR
;
2874 bytep
[i
++] = (request
->u
.ata
.lba
>> 32) & 0xff;
2875 bytep
[i
++] = 0x10 | ATA_CYL_LSB
;
2876 bytep
[i
++] = (request
->u
.ata
.lba
>> 8) & 0xff;
2877 bytep
[i
++] = 0x10 | ATA_CYL_LSB
;
2879 bytep
[i
++] = (request
->u
.ata
.lba
>> 40) & 0xff;
2880 bytep
[i
++] = 0x10 | ATA_CYL_MSB
;
2881 bytep
[i
++] = (request
->u
.ata
.lba
>> 16) & 0xff;
2882 bytep
[i
++] = 0x10 | ATA_CYL_MSB
;
2884 bytep
[i
++] = ATA_D_LBA
| ATA_D_IBM
| ((request
->u
.ata
.lba
>> 24) & 0xf);
2885 bytep
[i
++] = 0x10 | ATA_DRIVE
;
2887 bytep
[i
++] = request
->u
.ata
.command
;
2888 bytep
[i
++] = 0x90 | ATA_COMMAND
;
2890 /* enable EDMA machinery if needed */
2891 if (!(ATA_INL(ctlr
->r_res1
, 0x02028 + ATA_MV_EDMA_BASE(ch
)) & 0x00000001)) {
2892 ATA_OUTL(ctlr
->r_res1
, 0x02028 + ATA_MV_EDMA_BASE(ch
), 0x00000001);
2893 while (!(ATA_INL(ctlr
->r_res1
,
2894 0x02028 + ATA_MV_EDMA_BASE(ch
)) & 0x00000001))
2898 /* tell EDMA it has a new request */
2899 slot
= (((req_in
& ~0xfffffc00) >> 5) + 1) & 0x1f;
2900 req_in
&= 0xfffffc00;
2901 req_in
+= (slot
<< 5);
2902 ATA_OUTL(ctlr
->r_res1
, 0x02014 + ATA_MV_EDMA_BASE(ch
), req_in
);
2904 return ATA_OP_CONTINUES
;
2907 /* must be called with ATA channel locked and state_mtx held */
2909 ata_marvell_edma_end_transaction(struct ata_request
*request
)
2911 struct ata_pci_controller
*ctlr
=device_get_softc(GRANDPARENT(request
->dev
));
2912 struct ata_channel
*ch
= device_get_softc(device_get_parent(request
->dev
));
2913 int offset
= (ch
->unit
> 3 ? 0x30014 : 0x20014);
2914 u_int32_t icr
= ATA_INL(ctlr
->r_res1
, offset
);
2917 /* EDMA interrupt */
2918 if ((icr
& (0x0001 << (ch
->unit
& 3)))) {
2919 struct ata_marvell_response
*response
;
2920 u_int32_t rsp_in
, rsp_out
;
2924 callout_stop(&request
->callout
);
2926 /* get response ptr's */
2927 rsp_in
= ATA_INL(ctlr
->r_res1
, 0x02020 + ATA_MV_EDMA_BASE(ch
));
2928 rsp_out
= ATA_INL(ctlr
->r_res1
, 0x02024 + ATA_MV_EDMA_BASE(ch
));
2929 slot
= (((rsp_in
& ~0xffffff00) >> 3)) & 0x1f;
2930 rsp_out
&= 0xffffff00;
2931 rsp_out
+= (slot
<< 3);
2932 response
= (struct ata_marvell_response
*)
2933 (ch
->dma
->work
+ 1024 + (slot
<< 3));
2935 /* record status for this request */
2936 request
->status
= response
->dev_status
;
2940 ATA_OUTL(ctlr
->r_res1
, 0x02024 + ATA_MV_EDMA_BASE(ch
), rsp_out
);
2942 /* update progress */
2943 if (!(request
->status
& ATA_S_ERROR
) &&
2944 !(request
->flags
& ATA_R_TIMEOUT
))
2945 request
->donecount
= request
->bytecount
;
2947 /* unload SG list */
2948 ch
->dma
->unload(ch
->dev
);
2950 res
= ATA_OP_FINISHED
;
2953 /* legacy ATA interrupt */
2955 res
= ata_end_transaction(request
);
2959 ATA_OUTL(ctlr
->r_res1
, offset
, ~(icr
& (0x0101 << (ch
->unit
& 3))));
2964 ata_marvell_edma_reset(device_t dev
)
2966 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
2967 struct ata_channel
*ch
= device_get_softc(dev
);
2969 /* disable the EDMA machinery */
2970 ATA_OUTL(ctlr
->r_res1
, 0x02028 + ATA_MV_EDMA_BASE(ch
), 0x00000002);
2971 while ((ATA_INL(ctlr
->r_res1
, 0x02028 + ATA_MV_EDMA_BASE(ch
)) & 0x00000001))
2974 /* clear SATA error register */
2975 ATA_IDX_OUTL(ch
, ATA_SERROR
, ATA_IDX_INL(ch
, ATA_SERROR
));
2977 /* clear any outstanding error interrupts */
2978 ATA_OUTL(ctlr
->r_res1
, 0x02008 + ATA_MV_EDMA_BASE(ch
), 0x0);
2980 /* unmask all error interrupts */
2981 ATA_OUTL(ctlr
->r_res1
, 0x0200c + ATA_MV_EDMA_BASE(ch
), ~0x0);
2983 /* enable channel and test for devices */
2984 if (ata_sata_phy_reset(dev
))
2985 ata_generic_reset(dev
);
2987 /* enable EDMA machinery */
2988 ATA_OUTL(ctlr
->r_res1
, 0x02028 + ATA_MV_EDMA_BASE(ch
), 0x00000001);
2992 ata_marvell_edma_dmasetprd(void *xsc
, bus_dma_segment_t
*segs
, int nsegs
,
2995 struct ata_dmasetprd_args
*args
= xsc
;
2996 struct ata_marvell_dma_prdentry
*prd
= args
->dmatab
;
2999 if ((args
->error
= error
))
3002 for (i
= 0; i
< nsegs
; i
++) {
3003 prd
[i
].addrlo
= htole32(segs
[i
].ds_addr
);
3004 prd
[i
].count
= htole32(segs
[i
].ds_len
);
3005 prd
[i
].addrhi
= htole32((u_int64_t
)segs
[i
].ds_addr
>> 32);
3007 prd
[i
- 1].count
|= htole32(ATA_DMA_EOT
);
3011 ata_marvell_edma_dmainit(device_t dev
)
3013 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
3014 struct ata_channel
*ch
= device_get_softc(dev
);
3018 /* note start and stop are not used here */
3019 ch
->dma
->setprd
= ata_marvell_edma_dmasetprd
;
3021 if (ATA_INL(ctlr
->r_res1
, 0x00d00) & 0x00000004)
3022 ch
->dma
->max_address
= BUS_SPACE_MAXADDR
;
3028 * National chipset support functions
3031 ata_national_ident(device_t dev
)
3033 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
3035 /* this chip is a clone of the Cyrix chip, bugs and all */
3036 if (pci_get_devid(dev
) == ATA_SC1100
) {
3037 device_set_desc(dev
, "National Geode SC1100 ATA33 controller");
3038 ctlr
->chipinit
= ata_national_chipinit
;
3045 ata_national_chipinit(device_t dev
)
3047 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
3049 if (ata_setup_interrupt(dev
))
3052 ctlr
->setmode
= ata_national_setmode
;
3057 ata_national_setmode(device_t dev
, int mode
)
3059 device_t gparent
= GRANDPARENT(dev
);
3060 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
3061 struct ata_device
*atadev
= device_get_softc(dev
);
3062 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
3063 u_int32_t piotiming
[] =
3064 { 0x9172d132, 0x21717121, 0x00803020, 0x20102010, 0x00100010,
3065 0x00803020, 0x20102010, 0x00100010,
3066 0x00100010, 0x00100010, 0x00100010 };
3067 u_int32_t dmatiming
[] = { 0x80077771, 0x80012121, 0x80002020 };
3068 u_int32_t udmatiming
[] = { 0x80921250, 0x80911140, 0x80911030 };
3071 ch
->dma
->alignment
= 16;
3072 ch
->dma
->max_iosize
= 126 * DEV_BSIZE
;
3074 mode
= ata_limit_mode(dev
, mode
, ATA_UDMA2
);
3076 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
3079 device_printf(dev
, "%s setting %s on National chip\n",
3080 (error
) ? "failed" : "success", ata_mode2str(mode
));
3082 if (mode
>= ATA_UDMA0
) {
3083 pci_write_config(gparent
, 0x44 + (devno
<< 3),
3084 udmatiming
[mode
& ATA_MODE_MASK
], 4);
3086 else if (mode
>= ATA_WDMA0
) {
3087 pci_write_config(gparent
, 0x44 + (devno
<< 3),
3088 dmatiming
[mode
& ATA_MODE_MASK
], 4);
3091 pci_write_config(gparent
, 0x44 + (devno
<< 3),
3092 pci_read_config(gparent
, 0x44 + (devno
<< 3), 4) |
3095 pci_write_config(gparent
, 0x40 + (devno
<< 3),
3096 piotiming
[ata_mode2idx(mode
)], 4);
3097 atadev
->mode
= mode
;
3102 * NetCell chipset support functions
3105 ata_netcell_ident(device_t dev
)
3107 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
3109 if (pci_get_devid(dev
) == ATA_NETCELL_SR
) {
3110 device_set_desc(dev
, "Netcell SyncRAID SR3000/5000 RAID Controller");
3111 ctlr
->chipinit
= ata_netcell_chipinit
;
3118 ata_netcell_chipinit(device_t dev
)
3120 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
3122 if (ata_generic_chipinit(dev
))
3125 ctlr
->allocate
= ata_netcell_allocate
;
3130 ata_netcell_allocate(device_t dev
)
3132 struct ata_channel
*ch
= device_get_softc(dev
);
3134 /* setup the usual register normal pci style */
3135 if (ata_pci_allocate(dev
))
3138 /* the NetCell only supports 16 bit PIO transfers */
3139 ch
->flags
|= ATA_USE_16BIT
;
3146 * nVidia chipset support functions
3149 ata_nvidia_ident(device_t dev
)
3151 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
3152 struct ata_chip_id
*idx
;
3153 static struct ata_chip_id ids
[] =
3154 {{ ATA_NFORCE1
, 0, AMDNVIDIA
, NVIDIA
, ATA_UDMA5
, "nForce" },
3155 { ATA_NFORCE2
, 0, AMDNVIDIA
, NVIDIA
, ATA_UDMA6
, "nForce2" },
3156 { ATA_NFORCE2_PRO
, 0, AMDNVIDIA
, NVIDIA
, ATA_UDMA6
, "nForce2 Pro" },
3157 { ATA_NFORCE2_PRO_S1
, 0, 0, 0, ATA_SA150
, "nForce2 Pro" },
3158 { ATA_NFORCE3
, 0, AMDNVIDIA
, NVIDIA
, ATA_UDMA6
, "nForce3" },
3159 { ATA_NFORCE3_PRO
, 0, AMDNVIDIA
, NVIDIA
, ATA_UDMA6
, "nForce3 Pro" },
3160 { ATA_NFORCE3_PRO_S1
, 0, 0, 0, ATA_SA150
, "nForce3 Pro" },
3161 { ATA_NFORCE3_PRO_S2
, 0, 0, 0, ATA_SA150
, "nForce3 Pro" },
3162 { ATA_NFORCE_MCP04
, 0, AMDNVIDIA
, NVIDIA
, ATA_UDMA6
, "nForce MCP" },
3163 { ATA_NFORCE_MCP04_S1
, 0, 0, NV4
, ATA_SA150
, "nForce MCP" },
3164 { ATA_NFORCE_MCP04_S2
, 0, 0, NV4
, ATA_SA150
, "nForce MCP" },
3165 { ATA_NFORCE_CK804
, 0, AMDNVIDIA
, NVIDIA
, ATA_UDMA6
, "nForce CK804" },
3166 { ATA_NFORCE_CK804_S1
, 0, 0, NV4
, ATA_SA300
, "nForce CK804" },
3167 { ATA_NFORCE_CK804_S2
, 0, 0, NV4
, ATA_SA300
, "nForce CK804" },
3168 { ATA_NFORCE_MCP51
, 0, AMDNVIDIA
, NVIDIA
, ATA_UDMA6
, "nForce MCP51" },
3169 { ATA_NFORCE_MCP51_S1
, 0, 0, NV4
|NVQ
, ATA_SA300
, "nForce MCP51" },
3170 { ATA_NFORCE_MCP51_S2
, 0, 0, NV4
|NVQ
, ATA_SA300
, "nForce MCP51" },
3171 { ATA_NFORCE_MCP55
, 0, AMDNVIDIA
, NVIDIA
, ATA_UDMA6
, "nForce MCP55" },
3172 { ATA_NFORCE_MCP55_S1
, 0, 0, NV4
|NVQ
, ATA_SA300
, "nForce MCP55" },
3173 { ATA_NFORCE_MCP55_S2
, 0, 0, NV4
|NVQ
, ATA_SA300
, "nForce MCP55" },
3174 { 0, 0, 0, 0, 0, 0}} ;
3177 if (!(idx
= ata_match_chip(dev
, ids
)))
3180 ksprintf(buffer
, "nVidia %s %s controller",
3181 idx
->text
, ata_mode2str(idx
->max_dma
));
3182 device_set_desc_copy(dev
, buffer
);
3184 ctlr
->chipinit
= ata_nvidia_chipinit
;
3189 ata_nvidia_chipinit(device_t dev
)
3191 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
3193 if (ata_setup_interrupt(dev
))
3196 if (ctlr
->chip
->max_dma
>= ATA_SA150
) {
3197 if (pci_read_config(dev
, PCIR_BAR(5), 1) & 1)
3198 ctlr
->r_type2
= SYS_RES_IOPORT
;
3200 ctlr
->r_type2
= SYS_RES_MEMORY
;
3201 ctlr
->r_rid2
= PCIR_BAR(5);
3202 if ((ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
3203 &ctlr
->r_rid2
, RF_ACTIVE
))) {
3204 int offset
= ctlr
->chip
->cfg2
& NV4
? 0x0440 : 0x0010;
3206 ctlr
->allocate
= ata_nvidia_allocate
;
3207 ctlr
->reset
= ata_nvidia_reset
;
3209 /* enable control access */
3210 pci_write_config(dev
, 0x50, pci_read_config(dev
, 0x50, 1) | 0x04,1);
3212 if (ctlr
->chip
->cfg2
& NVQ
) {
3213 /* clear interrupt status */
3214 ATA_OUTL(ctlr
->r_res2
, offset
, 0x00ff00ff);
3216 /* enable device and PHY state change interrupts */
3217 ATA_OUTL(ctlr
->r_res2
, offset
+ 4, 0x000d000d);
3219 /* disable NCQ support */
3220 ATA_OUTL(ctlr
->r_res2
, 0x0400,
3221 ATA_INL(ctlr
->r_res2
, 0x0400) & 0xfffffff9);
3224 /* clear interrupt status */
3225 ATA_OUTB(ctlr
->r_res2
, offset
, 0xff);
3227 /* enable device and PHY state change interrupts */
3228 ATA_OUTB(ctlr
->r_res2
, offset
+ 1, 0xdd);
3231 /* enable PCI interrupt */
3232 pci_write_config(dev
, PCIR_COMMAND
,
3233 pci_read_config(dev
, PCIR_COMMAND
, 2) & ~0x0400,2);
3236 ctlr
->setmode
= ata_sata_setmode
;
3239 /* disable prefetch, postwrite */
3240 pci_write_config(dev
, 0x51, pci_read_config(dev
, 0x51, 1) & 0x0f, 1);
3241 ctlr
->setmode
= ata_via_family_setmode
;
3247 ata_nvidia_allocate(device_t dev
)
3249 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
3250 struct ata_channel
*ch
= device_get_softc(dev
);
3252 /* setup the usual register normal pci style */
3253 if (ata_pci_allocate(dev
))
3256 ch
->r_io
[ATA_SSTATUS
].res
= ctlr
->r_res2
;
3257 ch
->r_io
[ATA_SSTATUS
].offset
= (ch
->unit
<< 6);
3258 ch
->r_io
[ATA_SERROR
].res
= ctlr
->r_res2
;
3259 ch
->r_io
[ATA_SERROR
].offset
= 0x04 + (ch
->unit
<< 6);
3260 ch
->r_io
[ATA_SCONTROL
].res
= ctlr
->r_res2
;
3261 ch
->r_io
[ATA_SCONTROL
].offset
= 0x08 + (ch
->unit
<< 6);
3263 ch
->hw
.status
= ata_nvidia_status
;
3264 ch
->flags
|= ATA_NO_SLAVE
;
3270 ata_nvidia_status(device_t dev
)
3272 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
3273 struct ata_channel
*ch
= device_get_softc(dev
);
3274 int offset
= ctlr
->chip
->cfg2
& NV4
? 0x0440 : 0x0010;
3275 int shift
= ch
->unit
<< (ctlr
->chip
->cfg2
& NVQ
? 4 : 2);
3276 u_int32_t istatus
= ATA_INL(ctlr
->r_res2
, offset
);
3278 /* do we have any PHY events ? */
3279 if (istatus
& (0x0c << shift
))
3280 ata_sata_phy_check_events(dev
);
3282 /* clear interrupt(s) */
3283 ATA_OUTB(ctlr
->r_res2
, offset
,
3284 (0x0f << shift
) | (ctlr
->chip
->cfg2
& NVQ
? 0x00f000f0 : 0));
3286 /* do we have any device action ? */
3287 return (istatus
& (0x01 << shift
));
3291 ata_nvidia_reset(device_t dev
)
3293 if (ata_sata_phy_reset(dev
))
3294 ata_generic_reset(dev
);
3299 * Promise chipset support functions
3301 #define ATA_PDC_APKT_OFFSET 0x00000010
3302 #define ATA_PDC_HPKT_OFFSET 0x00000040
3303 #define ATA_PDC_ASG_OFFSET 0x00000080
3304 #define ATA_PDC_LSG_OFFSET 0x000000c0
3305 #define ATA_PDC_HSG_OFFSET 0x00000100
3306 #define ATA_PDC_CHN_OFFSET 0x00000400
3307 #define ATA_PDC_BUF_BASE 0x00400000
3308 #define ATA_PDC_BUF_OFFSET 0x00100000
3309 #define ATA_PDC_MAX_HPKT 8
3310 #define ATA_PDC_WRITE_REG 0x00
3311 #define ATA_PDC_WRITE_CTL 0x0e
3312 #define ATA_PDC_WRITE_END 0x08
3313 #define ATA_PDC_WAIT_NBUSY 0x10
3314 #define ATA_PDC_WAIT_READY 0x18
3315 #define ATA_PDC_1B 0x20
3316 #define ATA_PDC_2B 0x40
3318 struct host_packet
{
3320 TAILQ_ENTRY(host_packet
) chain
;
3323 struct ata_promise_sx4
{
3324 struct spinlock mtx
;
3325 TAILQ_HEAD(, host_packet
) queue
;
3330 ata_promise_ident(device_t dev
)
3332 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
3333 struct ata_chip_id
*idx
;
3334 static struct ata_chip_id ids
[] =
3335 {{ ATA_PDC20246
, 0, PROLD
, 0x00, ATA_UDMA2
, "PDC20246" },
3336 { ATA_PDC20262
, 0, PRNEW
, 0x00, ATA_UDMA4
, "PDC20262" },
3337 { ATA_PDC20263
, 0, PRNEW
, 0x00, ATA_UDMA4
, "PDC20263" },
3338 { ATA_PDC20265
, 0, PRNEW
, 0x00, ATA_UDMA5
, "PDC20265" },
3339 { ATA_PDC20267
, 0, PRNEW
, 0x00, ATA_UDMA5
, "PDC20267" },
3340 { ATA_PDC20268
, 0, PRTX
, PRTX4
, ATA_UDMA5
, "PDC20268" },
3341 { ATA_PDC20269
, 0, PRTX
, 0x00, ATA_UDMA6
, "PDC20269" },
3342 { ATA_PDC20270
, 0, PRTX
, PRTX4
, ATA_UDMA5
, "PDC20270" },
3343 { ATA_PDC20271
, 0, PRTX
, 0x00, ATA_UDMA6
, "PDC20271" },
3344 { ATA_PDC20275
, 0, PRTX
, 0x00, ATA_UDMA6
, "PDC20275" },
3345 { ATA_PDC20276
, 0, PRTX
, PRSX6K
, ATA_UDMA6
, "PDC20276" },
3346 { ATA_PDC20277
, 0, PRTX
, 0x00, ATA_UDMA6
, "PDC20277" },
3347 { ATA_PDC20318
, 0, PRMIO
, PRSATA
, ATA_SA150
, "PDC20318" },
3348 { ATA_PDC20319
, 0, PRMIO
, PRSATA
, ATA_SA150
, "PDC20319" },
3349 { ATA_PDC20371
, 0, PRMIO
, PRCMBO
, ATA_SA150
, "PDC20371" },
3350 { ATA_PDC20375
, 0, PRMIO
, PRCMBO
, ATA_SA150
, "PDC20375" },
3351 { ATA_PDC20376
, 0, PRMIO
, PRCMBO
, ATA_SA150
, "PDC20376" },
3352 { ATA_PDC20377
, 0, PRMIO
, PRCMBO
, ATA_SA150
, "PDC20377" },
3353 { ATA_PDC20378
, 0, PRMIO
, PRCMBO
, ATA_SA150
, "PDC20378" },
3354 { ATA_PDC20379
, 0, PRMIO
, PRCMBO
, ATA_SA150
, "PDC20379" },
3355 { ATA_PDC20571
, 0, PRMIO
, PRCMBO2
, ATA_SA150
, "PDC20571" },
3356 { ATA_PDC20575
, 0, PRMIO
, PRCMBO2
, ATA_SA150
, "PDC20575" },
3357 { ATA_PDC20579
, 0, PRMIO
, PRCMBO2
, ATA_SA150
, "PDC20579" },
3358 { ATA_PDC20771
, 0, PRMIO
, PRCMBO2
, ATA_SA300
, "PDC20771" },
3359 { ATA_PDC40775
, 0, PRMIO
, PRCMBO2
, ATA_SA300
, "PDC40775" },
3360 { ATA_PDC20617
, 0, PRMIO
, PRPATA
, ATA_UDMA6
, "PDC20617" },
3361 { ATA_PDC20618
, 0, PRMIO
, PRPATA
, ATA_UDMA6
, "PDC20618" },
3362 { ATA_PDC20619
, 0, PRMIO
, PRPATA
, ATA_UDMA6
, "PDC20619" },
3363 { ATA_PDC20620
, 0, PRMIO
, PRPATA
, ATA_UDMA6
, "PDC20620" },
3364 { ATA_PDC20621
, 0, PRMIO
, PRSX4X
, ATA_UDMA5
, "PDC20621" },
3365 { ATA_PDC20622
, 0, PRMIO
, PRSX4X
, ATA_SA150
, "PDC20622" },
3366 { ATA_PDC40518
, 0, PRMIO
, PRSATA2
, ATA_SA150
, "PDC40518" },
3367 { ATA_PDC40519
, 0, PRMIO
, PRSATA2
, ATA_SA150
, "PDC40519" },
3368 { ATA_PDC40718
, 0, PRMIO
, PRSATA2
, ATA_SA300
, "PDC40718" },
3369 { ATA_PDC40719
, 0, PRMIO
, PRSATA2
, ATA_SA300
, "PDC40719" },
3370 { ATA_PDC40779
, 0, PRMIO
, PRSATA2
, ATA_SA300
, "PDC40779" },
3371 { 0, 0, 0, 0, 0, 0}};
3373 uintptr_t devid
= 0;
3375 if (!(idx
= ata_match_chip(dev
, ids
)))
3378 /* if we are on a SuperTrak SX6000 dont attach */
3379 if ((idx
->cfg2
& PRSX6K
) && pci_get_class(GRANDPARENT(dev
))==PCIC_BRIDGE
&&
3380 !BUS_READ_IVAR(device_get_parent(GRANDPARENT(dev
)),
3381 GRANDPARENT(dev
), PCI_IVAR_DEVID
, &devid
) &&
3382 devid
== ATA_I960RM
)
3385 strcpy(buffer
, "Promise ");
3386 strcat(buffer
, idx
->text
);
3388 /* if we are on a FastTrak TX4, adjust the interrupt resource */
3389 if ((idx
->cfg2
& PRTX4
) && pci_get_class(GRANDPARENT(dev
))==PCIC_BRIDGE
&&
3390 !BUS_READ_IVAR(device_get_parent(GRANDPARENT(dev
)),
3391 GRANDPARENT(dev
), PCI_IVAR_DEVID
, &devid
) &&
3392 ((devid
== ATA_DEC_21150
) || (devid
== ATA_DEC_21150_1
))) {
3393 static long start
= 0, end
= 0;
3395 if (pci_get_slot(dev
) == 1) {
3396 bus_get_resource(dev
, SYS_RES_IRQ
, 0, &start
, &end
);
3397 strcat(buffer
, " (channel 0+1)");
3399 else if (pci_get_slot(dev
) == 2 && start
&& end
) {
3400 bus_set_resource(dev
, SYS_RES_IRQ
, 0, start
, end
);
3401 strcat(buffer
, " (channel 2+3)");
3407 ksprintf(buffer
, "%s %s controller", buffer
, ata_mode2str(idx
->max_dma
));
3408 device_set_desc_copy(dev
, buffer
);
3410 ctlr
->chipinit
= ata_promise_chipinit
;
3415 ata_promise_chipinit(device_t dev
)
3417 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
3418 int fake_reg
, stat_reg
;
3420 if (ata_setup_interrupt(dev
))
3423 switch (ctlr
->chip
->cfg1
) {
3426 ATA_OUTB(ctlr
->r_res1
, 0x11, ATA_INB(ctlr
->r_res1
, 0x11) | 0x0a);
3428 ctlr
->dmainit
= ata_promise_dmainit
;
3432 /* enable burst mode */
3433 ATA_OUTB(ctlr
->r_res1
, 0x1f, ATA_INB(ctlr
->r_res1
, 0x1f) | 0x01);
3434 ctlr
->allocate
= ata_promise_allocate
;
3435 ctlr
->setmode
= ata_promise_setmode
;
3439 ctlr
->allocate
= ata_promise_tx2_allocate
;
3440 ctlr
->setmode
= ata_promise_setmode
;
3444 ctlr
->r_type1
= SYS_RES_MEMORY
;
3445 ctlr
->r_rid1
= PCIR_BAR(4);
3446 if (!(ctlr
->r_res1
= bus_alloc_resource_any(dev
, ctlr
->r_type1
,
3447 &ctlr
->r_rid1
, RF_ACTIVE
)))
3450 ctlr
->r_type2
= SYS_RES_MEMORY
;
3451 ctlr
->r_rid2
= PCIR_BAR(3);
3452 if (!(ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
3453 &ctlr
->r_rid2
, RF_ACTIVE
)))
3456 if (ctlr
->chip
->cfg2
== PRSX4X
) {
3457 struct ata_promise_sx4
*hpkt
;
3458 u_int32_t dimm
= ATA_INL(ctlr
->r_res2
, 0x000c0080);
3460 if (bus_teardown_intr(dev
, ctlr
->r_irq
, ctlr
->handle
) ||
3461 bus_setup_intr(dev
, ctlr
->r_irq
, ATA_INTR_FLAGS
,
3462 ata_promise_sx4_intr
, ctlr
, &ctlr
->handle
, NULL
)) {
3463 device_printf(dev
, "unable to setup interrupt\n");
3467 /* print info about cache memory */
3468 device_printf(dev
, "DIMM size %dMB @ 0x%08x%s\n",
3469 (((dimm
>> 16) & 0xff)-((dimm
>> 24) & 0xff)+1) << 4,
3470 ((dimm
>> 24) & 0xff),
3471 ATA_INL(ctlr
->r_res2
, 0x000c0088) & (1<<16) ?
3472 " ECC enabled" : "" );
3474 /* adjust cache memory parameters */
3475 ATA_OUTL(ctlr
->r_res2
, 0x000c000c,
3476 (ATA_INL(ctlr
->r_res2
, 0x000c000c) & 0xffff0000));
3478 /* setup host packet controls */
3479 hpkt
= kmalloc(sizeof(struct ata_promise_sx4
),
3480 M_TEMP
, M_INTWAIT
| M_ZERO
);
3481 spin_init(&hpkt
->mtx
);
3482 TAILQ_INIT(&hpkt
->queue
);
3484 device_set_ivars(dev
, hpkt
);
3485 ctlr
->allocate
= ata_promise_mio_allocate
;
3486 ctlr
->reset
= ata_promise_mio_reset
;
3487 ctlr
->dmainit
= ata_promise_mio_dmainit
;
3488 ctlr
->setmode
= ata_promise_setmode
;
3493 /* mio type controllers need an interrupt intercept */
3494 if (bus_teardown_intr(dev
, ctlr
->r_irq
, ctlr
->handle
) ||
3495 bus_setup_intr(dev
, ctlr
->r_irq
, ATA_INTR_FLAGS
,
3496 ata_promise_mio_intr
, ctlr
, &ctlr
->handle
, NULL
)) {
3497 device_printf(dev
, "unable to setup interrupt\n");
3501 switch (ctlr
->chip
->cfg2
) {
3503 ctlr
->channels
= ((ATA_INL(ctlr
->r_res2
, 0x48) & 0x01) > 0) +
3504 ((ATA_INL(ctlr
->r_res2
, 0x48) & 0x02) > 0) + 2;
3528 /* prime fake interrupt register */
3529 ATA_OUTL(ctlr
->r_res2
, fake_reg
, 0xffffffff);
3531 /* clear SATA status */
3532 ATA_OUTL(ctlr
->r_res2
, stat_reg
, 0x000000ff);
3534 ctlr
->allocate
= ata_promise_mio_allocate
;
3535 ctlr
->reset
= ata_promise_mio_reset
;
3536 ctlr
->dmainit
= ata_promise_mio_dmainit
;
3537 ctlr
->setmode
= ata_promise_mio_setmode
;
3544 bus_release_resource(dev
, ctlr
->r_type2
, ctlr
->r_rid2
, ctlr
->r_res2
);
3546 bus_release_resource(dev
, ctlr
->r_type1
, ctlr
->r_rid1
, ctlr
->r_res1
);
3551 ata_promise_allocate(device_t dev
)
3553 struct ata_channel
*ch
= device_get_softc(dev
);
3555 if (ata_pci_allocate(dev
))
3558 ch
->hw
.status
= ata_promise_status
;
3563 ata_promise_status(device_t dev
)
3565 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
3566 struct ata_channel
*ch
= device_get_softc(dev
);
3568 if (ATA_INL(ctlr
->r_res1
, 0x1c) & (ch
->unit
? 0x00004000 : 0x00000400)) {
3569 return ata_pci_status(dev
);
3575 ata_promise_dmastart(device_t dev
)
3577 struct ata_pci_controller
*ctlr
= device_get_softc(GRANDPARENT(dev
));
3578 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
3579 struct ata_device
*atadev
= device_get_softc(dev
);
3581 if (atadev
->flags
& ATA_D_48BIT_ACTIVE
) {
3582 ATA_OUTB(ctlr
->r_res1
, 0x11,
3583 ATA_INB(ctlr
->r_res1
, 0x11) | (ch
->unit
? 0x08 : 0x02));
3584 ATA_OUTL(ctlr
->r_res1
, ch
->unit
? 0x24 : 0x20,
3585 ((ch
->dma
->flags
& ATA_DMA_READ
) ? 0x05000000 : 0x06000000) |
3586 (ch
->dma
->cur_iosize
>> 1));
3588 ATA_IDX_OUTB(ch
, ATA_BMSTAT_PORT
, (ATA_IDX_INB(ch
, ATA_BMSTAT_PORT
) |
3589 (ATA_BMSTAT_INTERRUPT
| ATA_BMSTAT_ERROR
)));
3590 ATA_IDX_OUTL(ch
, ATA_BMDTP_PORT
, ch
->dma
->sg_bus
);
3591 ATA_IDX_OUTB(ch
, ATA_BMCMD_PORT
,
3592 ((ch
->dma
->flags
& ATA_DMA_READ
) ? ATA_BMCMD_WRITE_READ
: 0) |
3593 ATA_BMCMD_START_STOP
);
3594 ch
->flags
|= ATA_DMA_ACTIVE
;
3599 ata_promise_dmastop(device_t dev
)
3601 struct ata_pci_controller
*ctlr
= device_get_softc(GRANDPARENT(dev
));
3602 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
3603 struct ata_device
*atadev
= device_get_softc(dev
);
3606 if (atadev
->flags
& ATA_D_48BIT_ACTIVE
) {
3607 ATA_OUTB(ctlr
->r_res1
, 0x11,
3608 ATA_INB(ctlr
->r_res1
, 0x11) & ~(ch
->unit
? 0x08 : 0x02));
3609 ATA_OUTL(ctlr
->r_res1
, ch
->unit
? 0x24 : 0x20, 0);
3611 error
= ATA_IDX_INB(ch
, ATA_BMSTAT_PORT
);
3612 ATA_IDX_OUTB(ch
, ATA_BMCMD_PORT
,
3613 ATA_IDX_INB(ch
, ATA_BMCMD_PORT
) & ~ATA_BMCMD_START_STOP
);
3614 ATA_IDX_OUTB(ch
, ATA_BMSTAT_PORT
, ATA_BMSTAT_INTERRUPT
| ATA_BMSTAT_ERROR
);
3615 ch
->flags
&= ~ATA_DMA_ACTIVE
;
3620 ata_promise_dmareset(device_t dev
)
3622 struct ata_channel
*ch
= device_get_softc(dev
);
3624 ATA_IDX_OUTB(ch
, ATA_BMCMD_PORT
,
3625 ATA_IDX_INB(ch
, ATA_BMCMD_PORT
) & ~ATA_BMCMD_START_STOP
);
3626 ATA_IDX_OUTB(ch
, ATA_BMSTAT_PORT
, ATA_BMSTAT_INTERRUPT
| ATA_BMSTAT_ERROR
);
3627 ch
->flags
&= ~ATA_DMA_ACTIVE
;
3631 ata_promise_dmainit(device_t dev
)
3633 struct ata_channel
*ch
= device_get_softc(dev
);
3637 ch
->dma
->start
= ata_promise_dmastart
;
3638 ch
->dma
->stop
= ata_promise_dmastop
;
3639 ch
->dma
->reset
= ata_promise_dmareset
;
3644 ata_promise_setmode(device_t dev
, int mode
)
3646 device_t gparent
= GRANDPARENT(dev
);
3647 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
3648 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
3649 struct ata_device
*atadev
= device_get_softc(dev
);
3650 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
3652 u_int32_t timings
[][2] = {
3653 /* PROLD PRNEW mode */
3654 { 0x004ff329, 0x004fff2f }, /* PIO 0 */
3655 { 0x004fec25, 0x004ff82a }, /* PIO 1 */
3656 { 0x004fe823, 0x004ff026 }, /* PIO 2 */
3657 { 0x004fe622, 0x004fec24 }, /* PIO 3 */
3658 { 0x004fe421, 0x004fe822 }, /* PIO 4 */
3659 { 0x004567f3, 0x004acef6 }, /* MWDMA 0 */
3660 { 0x004467f3, 0x0048cef6 }, /* MWDMA 1 */
3661 { 0x004367f3, 0x0046cef6 }, /* MWDMA 2 */
3662 { 0x004367f3, 0x0046cef6 }, /* UDMA 0 */
3663 { 0x004247f3, 0x00448ef6 }, /* UDMA 1 */
3664 { 0x004127f3, 0x00436ef6 }, /* UDMA 2 */
3665 { 0, 0x00424ef6 }, /* UDMA 3 */
3666 { 0, 0x004127f3 }, /* UDMA 4 */
3667 { 0, 0x004127f3 } /* UDMA 5 */
3670 mode
= ata_limit_mode(dev
, mode
, ctlr
->chip
->max_dma
);
3672 switch (ctlr
->chip
->cfg1
) {
3675 if (mode
> ATA_UDMA2
&& (pci_read_config(gparent
, 0x50, 2) &
3676 (ch
->unit
? 1 << 11 : 1 << 10))) {
3677 ata_print_cable(dev
, "controller");
3680 if (ata_atapi(dev
) && mode
> ATA_PIO_MAX
)
3681 mode
= ata_limit_mode(dev
, mode
, ATA_PIO_MAX
);
3685 ATA_IDX_OUTB(ch
, ATA_BMDEVSPEC_0
, 0x0b);
3686 if (mode
> ATA_UDMA2
&&
3687 ATA_IDX_INB(ch
, ATA_BMDEVSPEC_1
) & 0x04) {
3688 ata_print_cable(dev
, "controller");
3694 if (mode
> ATA_UDMA2
&&
3695 (ATA_INL(ctlr
->r_res2
,
3696 (ctlr
->chip
->cfg2
& PRSX4X
? 0x000c0260 : 0x0260) +
3697 (ch
->unit
<< 7)) & 0x01000000)) {
3698 ata_print_cable(dev
, "controller");
3704 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
3707 device_printf(dev
, "%ssetting %s on %s chip\n",
3708 (error
) ? "FAILURE " : "",
3709 ata_mode2str(mode
), ctlr
->chip
->text
);
3711 if (ctlr
->chip
->cfg1
< PRTX
)
3712 pci_write_config(gparent
, 0x60 + (devno
<< 2),
3713 timings
[ata_mode2idx(mode
)][ctlr
->chip
->cfg1
], 4);
3714 atadev
->mode
= mode
;
3720 ata_promise_tx2_allocate(device_t dev
)
3722 struct ata_channel
*ch
= device_get_softc(dev
);
3724 if (ata_pci_allocate(dev
))
3727 ch
->hw
.status
= ata_promise_tx2_status
;
3732 ata_promise_tx2_status(device_t dev
)
3734 struct ata_channel
*ch
= device_get_softc(dev
);
3736 ATA_IDX_OUTB(ch
, ATA_BMDEVSPEC_0
, 0x0b);
3737 if (ATA_IDX_INB(ch
, ATA_BMDEVSPEC_1
) & 0x20) {
3738 return ata_pci_status(dev
);
3744 ata_promise_mio_allocate(device_t dev
)
3746 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
3747 struct ata_channel
*ch
= device_get_softc(dev
);
3748 int offset
= (ctlr
->chip
->cfg2
& PRSX4X
) ? 0x000c0000 : 0;
3751 for (i
= ATA_DATA
; i
<= ATA_COMMAND
; i
++) {
3752 ch
->r_io
[i
].res
= ctlr
->r_res2
;
3753 ch
->r_io
[i
].offset
= offset
+ 0x0200 + (i
<< 2) + (ch
->unit
<< 7);
3755 ch
->r_io
[ATA_CONTROL
].res
= ctlr
->r_res2
;
3756 ch
->r_io
[ATA_CONTROL
].offset
= offset
+ 0x0238 + (ch
->unit
<< 7);
3757 ch
->r_io
[ATA_IDX_ADDR
].res
= ctlr
->r_res2
;
3758 ata_default_registers(dev
);
3759 if ((ctlr
->chip
->cfg2
& (PRSATA
| PRSATA2
)) ||
3760 ((ctlr
->chip
->cfg2
& (PRCMBO
| PRCMBO2
)) && ch
->unit
< 2)) {
3761 ch
->r_io
[ATA_SSTATUS
].res
= ctlr
->r_res2
;
3762 ch
->r_io
[ATA_SSTATUS
].offset
= 0x400 + (ch
->unit
<< 8);
3763 ch
->r_io
[ATA_SERROR
].res
= ctlr
->r_res2
;
3764 ch
->r_io
[ATA_SERROR
].offset
= 0x404 + (ch
->unit
<< 8);
3765 ch
->r_io
[ATA_SCONTROL
].res
= ctlr
->r_res2
;
3766 ch
->r_io
[ATA_SCONTROL
].offset
= 0x408 + (ch
->unit
<< 8);
3767 ch
->flags
|= ATA_NO_SLAVE
;
3769 ch
->flags
|= ATA_USE_16BIT
;
3771 ata_generic_hw(dev
);
3772 if (ctlr
->chip
->cfg2
& PRSX4X
) {
3773 ch
->hw
.command
= ata_promise_sx4_command
;
3776 ch
->hw
.command
= ata_promise_mio_command
;
3777 ch
->hw
.status
= ata_promise_mio_status
;
3783 ata_promise_mio_intr(void *data
)
3785 struct ata_pci_controller
*ctlr
= data
;
3786 struct ata_channel
*ch
;
3790 switch (ctlr
->chip
->cfg2
) {
3804 * since reading interrupt status register on early "mio" chips
3805 * clears the status bits we cannot read it for each channel later on
3806 * in the generic interrupt routine.
3807 * store the bits in an unused register in the chip so we can read
3808 * it from there safely to get around this "feature".
3810 vector
= ATA_INL(ctlr
->r_res2
, 0x040);
3811 ATA_OUTL(ctlr
->r_res2
, 0x040, vector
);
3812 ATA_OUTL(ctlr
->r_res2
, fake_reg
, vector
);
3814 for (unit
= 0; unit
< ctlr
->channels
; unit
++) {
3815 if ((ch
= ctlr
->interrupt
[unit
].argument
))
3816 ctlr
->interrupt
[unit
].function(ch
);
3819 ATA_OUTL(ctlr
->r_res2
, fake_reg
, 0xffffffff);
3823 ata_promise_mio_status(device_t dev
)
3825 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
3826 struct ata_channel
*ch
= device_get_softc(dev
);
3827 struct ata_connect_task
*tp
;
3828 u_int32_t fake_reg
, stat_reg
, vector
, status
;
3830 switch (ctlr
->chip
->cfg2
) {
3845 /* read and acknowledge interrupt */
3846 vector
= ATA_INL(ctlr
->r_res2
, fake_reg
);
3848 /* read and clear interface status */
3849 status
= ATA_INL(ctlr
->r_res2
, stat_reg
);
3850 ATA_OUTL(ctlr
->r_res2
, stat_reg
, status
& (0x00000011 << ch
->unit
));
3852 /* check for and handle disconnect events */
3853 if ((status
& (0x00000001 << ch
->unit
)) &&
3854 (tp
= (struct ata_connect_task
*)
3855 kmalloc(sizeof(struct ata_connect_task
),
3856 M_ATA
, M_INTWAIT
| M_ZERO
))) {
3859 device_printf(ch
->dev
, "DISCONNECT requested\n");
3860 tp
->action
= ATA_C_DETACH
;
3862 TASK_INIT(&tp
->task
, 0, ata_sata_phy_event
, tp
);
3863 taskqueue_enqueue(taskqueue_thread
[mycpuid
], &tp
->task
);
3866 /* check for and handle connect events */
3867 if ((status
& (0x00000010 << ch
->unit
)) &&
3868 (tp
= (struct ata_connect_task
*)
3869 kmalloc(sizeof(struct ata_connect_task
),
3870 M_ATA
, M_INTWAIT
| M_ZERO
))) {
3873 device_printf(ch
->dev
, "CONNECT requested\n");
3874 tp
->action
= ATA_C_ATTACH
;
3876 TASK_INIT(&tp
->task
, 0, ata_sata_phy_event
, tp
);
3877 taskqueue_enqueue(taskqueue_thread
[mycpuid
], &tp
->task
);
3880 /* do we have any device action ? */
3881 return (vector
& (1 << (ch
->unit
+ 1)));
3885 ata_promise_mio_command(struct ata_request
*request
)
3887 struct ata_pci_controller
*ctlr
=device_get_softc(GRANDPARENT(request
->dev
));
3888 struct ata_channel
*ch
= device_get_softc(device_get_parent(request
->dev
));
3889 u_int32_t
*wordp
= (u_int32_t
*)ch
->dma
->work
;
3891 ATA_OUTL(ctlr
->r_res2
, (ch
->unit
+ 1) << 2, 0x00000001);
3893 /* XXX SOS add ATAPI commands support later */
3894 switch (request
->u
.ata
.command
) {
3896 return ata_generic_command(request
);
3899 case ATA_READ_DMA48
:
3900 wordp
[0] = htole32(0x04 | ((ch
->unit
+ 1) << 16) | (0x00 << 24));
3904 case ATA_WRITE_DMA48
:
3905 wordp
[0] = htole32(0x00 | ((ch
->unit
+ 1) << 16) | (0x00 << 24));
3908 wordp
[1] = htole32(ch
->dma
->sg_bus
);
3910 ata_promise_apkt((u_int8_t
*)wordp
, request
);
3912 ATA_OUTL(ctlr
->r_res2
, 0x0240 + (ch
->unit
<< 7), ch
->dma
->work_bus
);
3917 ata_promise_mio_reset(device_t dev
)
3919 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
3920 struct ata_channel
*ch
= device_get_softc(dev
);
3921 struct ata_promise_sx4
*hpktp
;
3923 switch (ctlr
->chip
->cfg2
) {
3926 /* softreset channel ATA module */
3927 hpktp
= device_get_ivars(ctlr
->dev
);
3928 ATA_OUTL(ctlr
->r_res2
, 0xc0260 + (ch
->unit
<< 7), ch
->unit
+ 1);
3930 ATA_OUTL(ctlr
->r_res2
, 0xc0260 + (ch
->unit
<< 7),
3931 (ATA_INL(ctlr
->r_res2
, 0xc0260 + (ch
->unit
<< 7)) &
3932 ~0x00003f9f) | (ch
->unit
+ 1));
3934 /* softreset HOST module */ /* XXX SOS what about other outstandings */
3935 spin_lock_wr(&hpktp
->mtx
);
3936 ATA_OUTL(ctlr
->r_res2
, 0xc012c,
3937 (ATA_INL(ctlr
->r_res2
, 0xc012c) & ~0x00000f9f) | (1 << 11));
3939 ATA_OUTL(ctlr
->r_res2
, 0xc012c,
3940 (ATA_INL(ctlr
->r_res2
, 0xc012c) & ~0x00000f9f));
3942 spin_unlock_wr(&hpktp
->mtx
);
3943 ata_generic_reset(dev
);
3949 if ((ctlr
->chip
->cfg2
== PRSATA
) ||
3950 ((ctlr
->chip
->cfg2
== PRCMBO
) && (ch
->unit
< 2))) {
3952 /* mask plug/unplug intr */
3953 ATA_OUTL(ctlr
->r_res2
, 0x06c, (0x00110000 << ch
->unit
));
3956 /* softreset channels ATA module */
3957 ATA_OUTL(ctlr
->r_res2
, 0x0260 + (ch
->unit
<< 7), (1 << 11));
3959 ATA_OUTL(ctlr
->r_res2
, 0x0260 + (ch
->unit
<< 7),
3960 (ATA_INL(ctlr
->r_res2
, 0x0260 + (ch
->unit
<< 7)) &
3961 ~0x00003f9f) | (ch
->unit
+ 1));
3963 if ((ctlr
->chip
->cfg2
== PRSATA
) ||
3964 ((ctlr
->chip
->cfg2
== PRCMBO
) && (ch
->unit
< 2))) {
3966 if (ata_sata_phy_reset(dev
))
3967 ata_generic_reset(dev
);
3969 /* reset and enable plug/unplug intr */
3970 ATA_OUTL(ctlr
->r_res2
, 0x06c, (0x00000011 << ch
->unit
));
3973 ata_generic_reset(dev
);
3978 if ((ctlr
->chip
->cfg2
== PRSATA2
) ||
3979 ((ctlr
->chip
->cfg2
== PRCMBO2
) && (ch
->unit
< 2))) {
3980 /* set portmultiplier port */
3981 ATA_OUTL(ctlr
->r_res2
, 0x4e8 + (ch
->unit
<< 8), 0x0f);
3983 /* mask plug/unplug intr */
3984 ATA_OUTL(ctlr
->r_res2
, 0x060, (0x00110000 << ch
->unit
));
3987 /* softreset channels ATA module */
3988 ATA_OUTL(ctlr
->r_res2
, 0x0260 + (ch
->unit
<< 7), (1 << 11));
3990 ATA_OUTL(ctlr
->r_res2
, 0x0260 + (ch
->unit
<< 7),
3991 (ATA_INL(ctlr
->r_res2
, 0x0260 + (ch
->unit
<< 7)) &
3992 ~0x00003f9f) | (ch
->unit
+ 1));
3994 if ((ctlr
->chip
->cfg2
== PRSATA2
) ||
3995 ((ctlr
->chip
->cfg2
== PRCMBO2
) && (ch
->unit
< 2))) {
3997 /* set PHY mode to "improved" */
3998 ATA_OUTL(ctlr
->r_res2
, 0x414 + (ch
->unit
<< 8),
3999 (ATA_INL(ctlr
->r_res2
, 0x414 + (ch
->unit
<< 8)) &
4000 ~0x00000003) | 0x00000001);
4002 if (ata_sata_phy_reset(dev
))
4003 ata_generic_reset(dev
);
4005 /* reset and enable plug/unplug intr */
4006 ATA_OUTL(ctlr
->r_res2
, 0x060, (0x00000011 << ch
->unit
));
4008 /* set portmultiplier port */
4009 ATA_OUTL(ctlr
->r_res2
, 0x4e8 + (ch
->unit
<< 8), 0x00);
4012 ata_generic_reset(dev
);
4019 ata_promise_mio_dmainit(device_t dev
)
4021 /* note start and stop are not used here */
4026 ata_promise_mio_setmode(device_t dev
, int mode
)
4028 device_t gparent
= GRANDPARENT(dev
);
4029 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
4030 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
4032 if ( (ctlr
->chip
->cfg2
== PRSATA
) ||
4033 ((ctlr
->chip
->cfg2
== PRCMBO
) && (ch
->unit
< 2)) ||
4034 (ctlr
->chip
->cfg2
== PRSATA2
) ||
4035 ((ctlr
->chip
->cfg2
== PRCMBO2
) && (ch
->unit
< 2)))
4036 ata_sata_setmode(dev
, mode
);
4038 ata_promise_setmode(dev
, mode
);
4042 ata_promise_sx4_intr(void *data
)
4044 struct ata_pci_controller
*ctlr
= data
;
4045 struct ata_channel
*ch
;
4046 u_int32_t vector
= ATA_INL(ctlr
->r_res2
, 0x000c0480);
4049 for (unit
= 0; unit
< ctlr
->channels
; unit
++) {
4050 if (vector
& (1 << (unit
+ 1)))
4051 if ((ch
= ctlr
->interrupt
[unit
].argument
))
4052 ctlr
->interrupt
[unit
].function(ch
);
4053 if (vector
& (1 << (unit
+ 5)))
4054 if ((ch
= ctlr
->interrupt
[unit
].argument
))
4055 ata_promise_queue_hpkt(ctlr
,
4056 htole32((ch
->unit
* ATA_PDC_CHN_OFFSET
) +
4057 ATA_PDC_HPKT_OFFSET
));
4058 if (vector
& (1 << (unit
+ 9))) {
4059 ata_promise_next_hpkt(ctlr
);
4060 if ((ch
= ctlr
->interrupt
[unit
].argument
))
4061 ctlr
->interrupt
[unit
].function(ch
);
4063 if (vector
& (1 << (unit
+ 13))) {
4064 ata_promise_next_hpkt(ctlr
);
4065 if ((ch
= ctlr
->interrupt
[unit
].argument
))
4066 ATA_OUTL(ctlr
->r_res2
, 0x000c0240 + (ch
->unit
<< 7),
4067 htole32((ch
->unit
* ATA_PDC_CHN_OFFSET
) +
4068 ATA_PDC_APKT_OFFSET
));
4074 ata_promise_sx4_command(struct ata_request
*request
)
4076 device_t gparent
= GRANDPARENT(request
->dev
);
4077 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
4078 struct ata_channel
*ch
= device_get_softc(device_get_parent(request
->dev
));
4079 struct ata_dma_prdentry
*prd
= ch
->dma
->sg
;
4080 caddr_t window
= rman_get_virtual(ctlr
->r_res1
);
4082 int i
, idx
, length
= 0;
4084 /* XXX SOS add ATAPI commands support later */
4085 switch (request
->u
.ata
.command
) {
4090 case ATA_ATA_IDENTIFY
:
4094 case ATA_READ_MUL48
:
4098 case ATA_WRITE_MUL48
:
4099 ATA_OUTL(ctlr
->r_res2
, 0x000c0400 + ((ch
->unit
+ 1) << 2), 0x00000001);
4100 return ata_generic_command(request
);
4102 case ATA_SETFEATURES
:
4103 case ATA_FLUSHCACHE
:
4104 case ATA_FLUSHCACHE48
:
4107 wordp
= (u_int32_t
*)
4108 (window
+ (ch
->unit
* ATA_PDC_CHN_OFFSET
) + ATA_PDC_APKT_OFFSET
);
4109 wordp
[0] = htole32(0x08 | ((ch
->unit
+ 1)<<16) | (0x00 << 24));
4112 ata_promise_apkt((u_int8_t
*)wordp
, request
);
4113 ATA_OUTL(ctlr
->r_res2
, 0x000c0484, 0x00000001);
4114 ATA_OUTL(ctlr
->r_res2
, 0x000c0400 + ((ch
->unit
+ 1) << 2), 0x00000001);
4115 ATA_OUTL(ctlr
->r_res2
, 0x000c0240 + (ch
->unit
<< 7),
4116 htole32((ch
->unit
* ATA_PDC_CHN_OFFSET
)+ATA_PDC_APKT_OFFSET
));
4120 case ATA_READ_DMA48
:
4122 case ATA_WRITE_DMA48
:
4123 wordp
= (u_int32_t
*)
4124 (window
+ (ch
->unit
* ATA_PDC_CHN_OFFSET
) + ATA_PDC_HSG_OFFSET
);
4127 wordp
[idx
++] = prd
[i
].addr
;
4128 wordp
[idx
++] = prd
[i
].count
;
4129 length
+= (prd
[i
].count
& ~ATA_DMA_EOT
);
4130 } while (!(prd
[i
++].count
& ATA_DMA_EOT
));
4132 wordp
= (u_int32_t
*)
4133 (window
+ (ch
->unit
* ATA_PDC_CHN_OFFSET
) + ATA_PDC_LSG_OFFSET
);
4134 wordp
[0] = htole32((ch
->unit
* ATA_PDC_BUF_OFFSET
) + ATA_PDC_BUF_BASE
);
4135 wordp
[1] = htole32(request
->bytecount
| ATA_DMA_EOT
);
4137 wordp
= (u_int32_t
*)
4138 (window
+ (ch
->unit
* ATA_PDC_CHN_OFFSET
) + ATA_PDC_ASG_OFFSET
);
4139 wordp
[0] = htole32((ch
->unit
* ATA_PDC_BUF_OFFSET
) + ATA_PDC_BUF_BASE
);
4140 wordp
[1] = htole32(request
->bytecount
| ATA_DMA_EOT
);
4142 wordp
= (u_int32_t
*)
4143 (window
+ (ch
->unit
* ATA_PDC_CHN_OFFSET
) + ATA_PDC_HPKT_OFFSET
);
4144 if (request
->flags
& ATA_R_READ
)
4145 wordp
[0] = htole32(0x14 | ((ch
->unit
+9)<<16) | ((ch
->unit
+5)<<24));
4146 if (request
->flags
& ATA_R_WRITE
)
4147 wordp
[0] = htole32(0x00 | ((ch
->unit
+13)<<16) | (0x00<<24));
4148 wordp
[1] = htole32((ch
->unit
* ATA_PDC_CHN_OFFSET
)+ATA_PDC_HSG_OFFSET
);
4149 wordp
[2] = htole32((ch
->unit
* ATA_PDC_CHN_OFFSET
)+ATA_PDC_LSG_OFFSET
);
4152 wordp
= (u_int32_t
*)
4153 (window
+ (ch
->unit
* ATA_PDC_CHN_OFFSET
) + ATA_PDC_APKT_OFFSET
);
4154 if (request
->flags
& ATA_R_READ
)
4155 wordp
[0] = htole32(0x04 | ((ch
->unit
+5)<<16) | (0x00<<24));
4156 if (request
->flags
& ATA_R_WRITE
)
4157 wordp
[0] = htole32(0x10 | ((ch
->unit
+1)<<16) | ((ch
->unit
+13)<<24));
4158 wordp
[1] = htole32((ch
->unit
* ATA_PDC_CHN_OFFSET
)+ATA_PDC_ASG_OFFSET
);
4160 ata_promise_apkt((u_int8_t
*)wordp
, request
);
4161 ATA_OUTL(ctlr
->r_res2
, 0x000c0484, 0x00000001);
4163 if (request
->flags
& ATA_R_READ
) {
4164 ATA_OUTL(ctlr
->r_res2
, 0x000c0400 + ((ch
->unit
+5)<<2), 0x00000001);
4165 ATA_OUTL(ctlr
->r_res2
, 0x000c0400 + ((ch
->unit
+9)<<2), 0x00000001);
4166 ATA_OUTL(ctlr
->r_res2
, 0x000c0240 + (ch
->unit
<< 7),
4167 htole32((ch
->unit
* ATA_PDC_CHN_OFFSET
) + ATA_PDC_APKT_OFFSET
));
4169 if (request
->flags
& ATA_R_WRITE
) {
4170 ATA_OUTL(ctlr
->r_res2
, 0x000c0400 + ((ch
->unit
+1)<<2), 0x00000001);
4171 ATA_OUTL(ctlr
->r_res2
, 0x000c0400 + ((ch
->unit
+13)<<2), 0x00000001);
4172 ata_promise_queue_hpkt(ctlr
,
4173 htole32((ch
->unit
* ATA_PDC_CHN_OFFSET
) + ATA_PDC_HPKT_OFFSET
));
4180 ata_promise_apkt(u_int8_t
*bytep
, struct ata_request
*request
)
4182 struct ata_device
*atadev
= device_get_softc(request
->dev
);
4185 bytep
[i
++] = ATA_PDC_1B
| ATA_PDC_WRITE_REG
| ATA_PDC_WAIT_NBUSY
|ATA_DRIVE
;
4186 bytep
[i
++] = ATA_D_IBM
| ATA_D_LBA
| atadev
->unit
;
4187 bytep
[i
++] = ATA_PDC_1B
| ATA_PDC_WRITE_CTL
;
4188 bytep
[i
++] = ATA_A_4BIT
;
4190 if (atadev
->flags
& ATA_D_48BIT_ACTIVE
) {
4191 bytep
[i
++] = ATA_PDC_2B
| ATA_PDC_WRITE_REG
| ATA_FEATURE
;
4192 bytep
[i
++] = request
->u
.ata
.feature
>> 8;
4193 bytep
[i
++] = request
->u
.ata
.feature
;
4194 bytep
[i
++] = ATA_PDC_2B
| ATA_PDC_WRITE_REG
| ATA_COUNT
;
4195 bytep
[i
++] = request
->u
.ata
.count
>> 8;
4196 bytep
[i
++] = request
->u
.ata
.count
;
4197 bytep
[i
++] = ATA_PDC_2B
| ATA_PDC_WRITE_REG
| ATA_SECTOR
;
4198 bytep
[i
++] = request
->u
.ata
.lba
>> 24;
4199 bytep
[i
++] = request
->u
.ata
.lba
;
4200 bytep
[i
++] = ATA_PDC_2B
| ATA_PDC_WRITE_REG
| ATA_CYL_LSB
;
4201 bytep
[i
++] = request
->u
.ata
.lba
>> 32;
4202 bytep
[i
++] = request
->u
.ata
.lba
>> 8;
4203 bytep
[i
++] = ATA_PDC_2B
| ATA_PDC_WRITE_REG
| ATA_CYL_MSB
;
4204 bytep
[i
++] = request
->u
.ata
.lba
>> 40;
4205 bytep
[i
++] = request
->u
.ata
.lba
>> 16;
4206 bytep
[i
++] = ATA_PDC_1B
| ATA_PDC_WRITE_REG
| ATA_DRIVE
;
4207 bytep
[i
++] = ATA_D_LBA
| atadev
->unit
;
4210 bytep
[i
++] = ATA_PDC_1B
| ATA_PDC_WRITE_REG
| ATA_FEATURE
;
4211 bytep
[i
++] = request
->u
.ata
.feature
;
4212 bytep
[i
++] = ATA_PDC_1B
| ATA_PDC_WRITE_REG
| ATA_COUNT
;
4213 bytep
[i
++] = request
->u
.ata
.count
;
4214 bytep
[i
++] = ATA_PDC_1B
| ATA_PDC_WRITE_REG
| ATA_SECTOR
;
4215 bytep
[i
++] = request
->u
.ata
.lba
;
4216 bytep
[i
++] = ATA_PDC_1B
| ATA_PDC_WRITE_REG
| ATA_CYL_LSB
;
4217 bytep
[i
++] = request
->u
.ata
.lba
>> 8;
4218 bytep
[i
++] = ATA_PDC_1B
| ATA_PDC_WRITE_REG
| ATA_CYL_MSB
;
4219 bytep
[i
++] = request
->u
.ata
.lba
>> 16;
4220 bytep
[i
++] = ATA_PDC_1B
| ATA_PDC_WRITE_REG
| ATA_DRIVE
;
4221 bytep
[i
++] = (atadev
->flags
& ATA_D_USE_CHS
? 0 : ATA_D_LBA
) |
4222 ATA_D_IBM
| atadev
->unit
| ((request
->u
.ata
.lba
>> 24)&0xf);
4224 bytep
[i
++] = ATA_PDC_1B
| ATA_PDC_WRITE_END
| ATA_COMMAND
;
4225 bytep
[i
++] = request
->u
.ata
.command
;
4230 ata_promise_queue_hpkt(struct ata_pci_controller
*ctlr
, u_int32_t hpkt
)
4232 struct ata_promise_sx4
*hpktp
= device_get_ivars(ctlr
->dev
);
4234 spin_lock_wr(&hpktp
->mtx
);
4236 struct host_packet
*hp
=
4237 kmalloc(sizeof(struct host_packet
), M_TEMP
, M_INTWAIT
| M_ZERO
);
4239 TAILQ_INSERT_TAIL(&hpktp
->queue
, hp
, chain
);
4243 ATA_OUTL(ctlr
->r_res2
, 0x000c0100, hpkt
);
4245 spin_unlock_wr(&hpktp
->mtx
);
4249 ata_promise_next_hpkt(struct ata_pci_controller
*ctlr
)
4251 struct ata_promise_sx4
*hpktp
= device_get_ivars(ctlr
->dev
);
4252 struct host_packet
*hp
;
4254 spin_lock_wr(&hpktp
->mtx
);
4255 if ((hp
= TAILQ_FIRST(&hpktp
->queue
))) {
4256 TAILQ_REMOVE(&hpktp
->queue
, hp
, chain
);
4257 ATA_OUTL(ctlr
->r_res2
, 0x000c0100, hp
->addr
);
4262 spin_unlock_wr(&hpktp
->mtx
);
4267 * ServerWorks chipset support functions
4270 ata_serverworks_ident(device_t dev
)
4272 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
4273 struct ata_chip_id
*idx
;
4274 static struct ata_chip_id ids
[] =
4275 {{ ATA_ROSB4
, 0x00, SWKS33
, 0, ATA_UDMA2
, "ROSB4" },
4276 { ATA_CSB5
, 0x92, SWKS100
, 0, ATA_UDMA5
, "CSB5" },
4277 { ATA_CSB5
, 0x00, SWKS66
, 0, ATA_UDMA4
, "CSB5" },
4278 { ATA_CSB6
, 0x00, SWKS100
, 0, ATA_UDMA5
, "CSB6" },
4279 { ATA_CSB6_1
, 0x00, SWKS66
, 0, ATA_UDMA4
, "CSB6" },
4280 { ATA_HT1000
, 0x00, SWKS100
, 0, ATA_UDMA5
, "HT1000" },
4281 { ATA_HT1000_S1
, 0x00, SWKS100
, 4, ATA_SA150
, "HT1000" },
4282 { ATA_HT1000_S2
, 0x00, SWKSMIO
, 4, ATA_SA150
, "HT1000" },
4283 { ATA_K2
, 0x00, SWKSMIO
, 4, ATA_SA150
, "K2" },
4284 { ATA_FRODO4
, 0x00, SWKSMIO
, 4, ATA_SA150
, "Frodo4" },
4285 { ATA_FRODO8
, 0x00, SWKSMIO
, 8, ATA_SA150
, "Frodo8" },
4286 { 0, 0, 0, 0, 0, 0}};
4289 if (!(idx
= ata_match_chip(dev
, ids
)))
4292 ksprintf(buffer
, "ServerWorks %s %s controller",
4293 idx
->text
, ata_mode2str(idx
->max_dma
));
4294 device_set_desc_copy(dev
, buffer
);
4296 ctlr
->chipinit
= ata_serverworks_chipinit
;
4301 ata_serverworks_chipinit(device_t dev
)
4303 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
4305 if (ata_setup_interrupt(dev
))
4308 if (ctlr
->chip
->cfg1
== SWKSMIO
) {
4309 ctlr
->r_type2
= SYS_RES_MEMORY
;
4310 ctlr
->r_rid2
= PCIR_BAR(5);
4311 if (!(ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
4312 &ctlr
->r_rid2
, RF_ACTIVE
)))
4315 ctlr
->channels
= ctlr
->chip
->cfg2
;
4316 ctlr
->allocate
= ata_serverworks_allocate
;
4317 ctlr
->setmode
= ata_sata_setmode
;
4320 else if (ctlr
->chip
->cfg1
== SWKS33
) {
4324 /* locate the ISA part in the southbridge and enable UDMA33 */
4325 if (!device_get_children(device_get_parent(dev
), &children
,&nchildren
)){
4326 for (i
= 0; i
< nchildren
; i
++) {
4327 if (pci_get_devid(children
[i
]) == ATA_ROSB4_ISA
) {
4328 pci_write_config(children
[i
], 0x64,
4329 (pci_read_config(children
[i
], 0x64, 4) &
4330 ~0x00002000) | 0x00004000, 4);
4334 kfree(children
, M_TEMP
);
4338 pci_write_config(dev
, 0x5a,
4339 (pci_read_config(dev
, 0x5a, 1) & ~0x40) |
4340 (ctlr
->chip
->cfg1
== SWKS100
) ? 0x03 : 0x02, 1);
4342 ctlr
->setmode
= ata_serverworks_setmode
;
4347 ata_serverworks_allocate(device_t dev
)
4349 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
4350 struct ata_channel
*ch
= device_get_softc(dev
);
4354 ch_offset
= ch
->unit
* 0x100;
4356 for (i
= ATA_DATA
; i
< ATA_MAX_RES
; i
++)
4357 ch
->r_io
[i
].res
= ctlr
->r_res2
;
4359 /* setup ATA registers */
4360 ch
->r_io
[ATA_DATA
].offset
= ch_offset
+ 0x00;
4361 ch
->r_io
[ATA_FEATURE
].offset
= ch_offset
+ 0x04;
4362 ch
->r_io
[ATA_COUNT
].offset
= ch_offset
+ 0x08;
4363 ch
->r_io
[ATA_SECTOR
].offset
= ch_offset
+ 0x0c;
4364 ch
->r_io
[ATA_CYL_LSB
].offset
= ch_offset
+ 0x10;
4365 ch
->r_io
[ATA_CYL_MSB
].offset
= ch_offset
+ 0x14;
4366 ch
->r_io
[ATA_DRIVE
].offset
= ch_offset
+ 0x18;
4367 ch
->r_io
[ATA_COMMAND
].offset
= ch_offset
+ 0x1c;
4368 ch
->r_io
[ATA_CONTROL
].offset
= ch_offset
+ 0x20;
4369 ata_default_registers(dev
);
4371 /* setup DMA registers */
4372 ch
->r_io
[ATA_BMCMD_PORT
].offset
= ch_offset
+ 0x30;
4373 ch
->r_io
[ATA_BMSTAT_PORT
].offset
= ch_offset
+ 0x32;
4374 ch
->r_io
[ATA_BMDTP_PORT
].offset
= ch_offset
+ 0x34;
4376 /* setup SATA registers */
4377 ch
->r_io
[ATA_SSTATUS
].offset
= ch_offset
+ 0x40;
4378 ch
->r_io
[ATA_SERROR
].offset
= ch_offset
+ 0x44;
4379 ch
->r_io
[ATA_SCONTROL
].offset
= ch_offset
+ 0x48;
4381 ch
->flags
|= ATA_NO_SLAVE
;
4387 ata_serverworks_setmode(device_t dev
, int mode
)
4389 device_t gparent
= GRANDPARENT(dev
);
4390 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
4391 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
4392 struct ata_device
*atadev
= device_get_softc(dev
);
4393 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
4394 int offset
= (devno
^ 0x01) << 3;
4396 u_int8_t piotimings
[] = { 0x5d, 0x47, 0x34, 0x22, 0x20, 0x34, 0x22, 0x20,
4397 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 };
4398 u_int8_t dmatimings
[] = { 0x77, 0x21, 0x20 };
4400 mode
= ata_limit_mode(dev
, mode
, ctlr
->chip
->max_dma
);
4402 mode
= ata_check_80pin(dev
, mode
);
4404 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
4407 device_printf(dev
, "%ssetting %s on %s chip\n",
4408 (error
) ? "FAILURE " : "",
4409 ata_mode2str(mode
), ctlr
->chip
->text
);
4411 if (mode
>= ATA_UDMA0
) {
4412 pci_write_config(gparent
, 0x56,
4413 (pci_read_config(gparent
, 0x56, 2) &
4414 ~(0xf << (devno
<< 2))) |
4415 ((mode
& ATA_MODE_MASK
) << (devno
<< 2)), 2);
4416 pci_write_config(gparent
, 0x54,
4417 pci_read_config(gparent
, 0x54, 1) |
4418 (0x01 << devno
), 1);
4419 pci_write_config(gparent
, 0x44,
4420 (pci_read_config(gparent
, 0x44, 4) &
4421 ~(0xff << offset
)) |
4422 (dmatimings
[2] << offset
), 4);
4424 else if (mode
>= ATA_WDMA0
) {
4425 pci_write_config(gparent
, 0x54,
4426 pci_read_config(gparent
, 0x54, 1) &
4427 ~(0x01 << devno
), 1);
4428 pci_write_config(gparent
, 0x44,
4429 (pci_read_config(gparent
, 0x44, 4) &
4430 ~(0xff << offset
)) |
4431 (dmatimings
[mode
& ATA_MODE_MASK
] << offset
), 4);
4434 pci_write_config(gparent
, 0x54,
4435 pci_read_config(gparent
, 0x54, 1) &
4436 ~(0x01 << devno
), 1);
4438 pci_write_config(gparent
, 0x40,
4439 (pci_read_config(gparent
, 0x40, 4) &
4440 ~(0xff << offset
)) |
4441 (piotimings
[ata_mode2idx(mode
)] << offset
), 4);
4442 atadev
->mode
= mode
;
4448 * Silicon Image Inc. (SiI) (former CMD) chipset support functions
4451 ata_sii_ident(device_t dev
)
4453 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
4454 struct ata_chip_id
*idx
;
4455 static struct ata_chip_id ids
[] =
4456 {{ ATA_SII3114
, 0x00, SIIMEMIO
, SII4CH
, ATA_SA150
, "SiI 3114" },
4457 { ATA_SII3512
, 0x02, SIIMEMIO
, 0, ATA_SA150
, "SiI 3512" },
4458 { ATA_SII3112
, 0x02, SIIMEMIO
, 0, ATA_SA150
, "SiI 3112" },
4459 { ATA_SII3112_1
, 0x02, SIIMEMIO
, 0, ATA_SA150
, "SiI 3112" },
4460 { ATA_SII3512
, 0x00, SIIMEMIO
, SIIBUG
, ATA_SA150
, "SiI 3512" },
4461 { ATA_SII3112
, 0x00, SIIMEMIO
, SIIBUG
, ATA_SA150
, "SiI 3112" },
4462 { ATA_SII3112_1
, 0x00, SIIMEMIO
, SIIBUG
, ATA_SA150
, "SiI 3112" },
4463 { ATA_SII3124
, 0x00, SIIPRBIO
, SII4CH
, ATA_SA300
, "SiI 3124" },
4464 { ATA_SII3132
, 0x00, SIIPRBIO
, 0, ATA_SA300
, "SiI 3132" },
4465 { ATA_SII0680
, 0x00, SIIMEMIO
, SIISETCLK
, ATA_UDMA6
, "SiI 0680" },
4466 { ATA_CMD649
, 0x00, 0, SIIINTR
, ATA_UDMA5
, "CMD 649" },
4467 { ATA_CMD648
, 0x00, 0, SIIINTR
, ATA_UDMA4
, "CMD 648" },
4468 { ATA_CMD646
, 0x07, 0, 0, ATA_UDMA2
, "CMD 646U2" },
4469 { ATA_CMD646
, 0x00, 0, 0, ATA_WDMA2
, "CMD 646" },
4470 { 0, 0, 0, 0, 0, 0}};
4473 if (!(idx
= ata_match_chip(dev
, ids
)))
4476 ksprintf(buffer
, "%s %s controller", idx
->text
, ata_mode2str(idx
->max_dma
));
4477 device_set_desc_copy(dev
, buffer
);
4479 ctlr
->chipinit
= ata_sii_chipinit
;
4484 ata_sii_chipinit(device_t dev
)
4486 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
4488 if (ata_setup_interrupt(dev
))
4491 switch (ctlr
->chip
->cfg1
) {
4493 ctlr
->r_type1
= SYS_RES_MEMORY
;
4494 ctlr
->r_rid1
= PCIR_BAR(0);
4495 if (!(ctlr
->r_res1
= bus_alloc_resource_any(dev
, ctlr
->r_type1
,
4496 &ctlr
->r_rid1
, RF_ACTIVE
)))
4499 ctlr
->r_rid2
= PCIR_BAR(2);
4500 ctlr
->r_type2
= SYS_RES_MEMORY
;
4501 if (!(ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
4502 &ctlr
->r_rid2
, RF_ACTIVE
))){
4503 bus_release_resource(dev
, ctlr
->r_type1
, ctlr
->r_rid1
,ctlr
->r_res1
);
4506 ctlr
->allocate
= ata_siiprb_allocate
;
4507 ctlr
->reset
= ata_siiprb_reset
;
4508 ctlr
->dmainit
= ata_siiprb_dmainit
;
4509 ctlr
->setmode
= ata_sata_setmode
;
4510 ctlr
->channels
= (ctlr
->chip
->cfg2
== SII4CH
) ? 4 : 2;
4512 /* reset controller */
4513 ATA_OUTL(ctlr
->r_res1
, 0x0040, 0x80000000);
4515 ATA_OUTL(ctlr
->r_res1
, 0x0040, 0x0000000f);
4517 /* enable PCI interrupt */
4518 pci_write_config(dev
, PCIR_COMMAND
,
4519 pci_read_config(dev
, PCIR_COMMAND
, 2) & ~0x0400, 2);
4523 ctlr
->r_type2
= SYS_RES_MEMORY
;
4524 ctlr
->r_rid2
= PCIR_BAR(5);
4525 if (!(ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
4526 &ctlr
->r_rid2
, RF_ACTIVE
)))
4529 if (ctlr
->chip
->cfg2
& SIISETCLK
) {
4530 if ((pci_read_config(dev
, 0x8a, 1) & 0x30) != 0x10)
4531 pci_write_config(dev
, 0x8a,
4532 (pci_read_config(dev
, 0x8a, 1) & 0xcf)|0x10,1);
4533 if ((pci_read_config(dev
, 0x8a, 1) & 0x30) != 0x10)
4534 device_printf(dev
, "%s could not set ATA133 clock\n",
4538 /* if we have 4 channels enable the second set */
4539 if (ctlr
->chip
->cfg2
& SII4CH
) {
4540 ATA_OUTL(ctlr
->r_res2
, 0x0200, 0x00000002);
4544 /* dont block interrupts from any channel */
4545 pci_write_config(dev
, 0x48,
4546 (pci_read_config(dev
, 0x48, 4) & ~0x03c00000), 4);
4548 /* enable PCI interrupt as BIOS might not */
4549 pci_write_config(dev
, 0x8a, (pci_read_config(dev
, 0x8a, 1) & 0x3f), 1);
4551 ctlr
->allocate
= ata_sii_allocate
;
4552 if (ctlr
->chip
->max_dma
>= ATA_SA150
) {
4553 ctlr
->reset
= ata_sii_reset
;
4554 ctlr
->setmode
= ata_sata_setmode
;
4557 ctlr
->setmode
= ata_sii_setmode
;
4561 if ((pci_read_config(dev
, 0x51, 1) & 0x08) != 0x08) {
4562 device_printf(dev
, "HW has secondary channel disabled\n");
4566 /* enable interrupt as BIOS might not */
4567 pci_write_config(dev
, 0x71, 0x01, 1);
4569 ctlr
->allocate
= ata_cmd_allocate
;
4570 ctlr
->setmode
= ata_cmd_setmode
;
4577 ata_cmd_allocate(device_t dev
)
4579 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
4580 struct ata_channel
*ch
= device_get_softc(dev
);
4582 /* setup the usual register normal pci style */
4583 if (ata_pci_allocate(dev
))
4586 if (ctlr
->chip
->cfg2
& SIIINTR
)
4587 ch
->hw
.status
= ata_cmd_status
;
4593 ata_cmd_status(device_t dev
)
4595 struct ata_channel
*ch
= device_get_softc(dev
);
4598 if (((reg71
= pci_read_config(device_get_parent(ch
->dev
), 0x71, 1)) &
4599 (ch
->unit
? 0x08 : 0x04))) {
4600 pci_write_config(device_get_parent(ch
->dev
), 0x71,
4601 reg71
& ~(ch
->unit
? 0x04 : 0x08), 1);
4602 return ata_pci_status(dev
);
4608 ata_cmd_setmode(device_t dev
, int mode
)
4610 device_t gparent
= GRANDPARENT(dev
);
4611 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
4612 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
4613 struct ata_device
*atadev
= device_get_softc(dev
);
4614 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
4617 mode
= ata_limit_mode(dev
, mode
, ctlr
->chip
->max_dma
);
4619 mode
= ata_check_80pin(dev
, mode
);
4621 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
4624 device_printf(dev
, "%ssetting %s on %s chip\n",
4625 (error
) ? "FAILURE " : "",
4626 ata_mode2str(mode
), ctlr
->chip
->text
);
4628 int treg
= 0x54 + ((devno
< 3) ? (devno
<< 1) : 7);
4629 int ureg
= ch
->unit
? 0x7b : 0x73;
4631 if (mode
>= ATA_UDMA0
) {
4632 int udmatimings
[][2] = { { 0x31, 0xc2 }, { 0x21, 0x82 },
4633 { 0x11, 0x42 }, { 0x25, 0x8a },
4634 { 0x15, 0x4a }, { 0x05, 0x0a } };
4636 u_int8_t umode
= pci_read_config(gparent
, ureg
, 1);
4638 umode
&= ~(atadev
->unit
== ATA_MASTER
? 0x35 : 0xca);
4639 umode
|= udmatimings
[mode
& ATA_MODE_MASK
][ATA_DEV(atadev
->unit
)];
4640 pci_write_config(gparent
, ureg
, umode
, 1);
4642 else if (mode
>= ATA_WDMA0
) {
4643 int dmatimings
[] = { 0x87, 0x32, 0x3f };
4645 pci_write_config(gparent
, treg
, dmatimings
[mode
& ATA_MODE_MASK
],1);
4646 pci_write_config(gparent
, ureg
,
4647 pci_read_config(gparent
, ureg
, 1) &
4648 ~(atadev
->unit
== ATA_MASTER
? 0x35 : 0xca), 1);
4651 int piotimings
[] = { 0xa9, 0x57, 0x44, 0x32, 0x3f };
4652 pci_write_config(gparent
, treg
,
4653 piotimings
[(mode
& ATA_MODE_MASK
) - ATA_PIO0
], 1);
4654 pci_write_config(gparent
, ureg
,
4655 pci_read_config(gparent
, ureg
, 1) &
4656 ~(atadev
->unit
== ATA_MASTER
? 0x35 : 0xca), 1);
4658 atadev
->mode
= mode
;
4663 ata_sii_allocate(device_t dev
)
4665 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
4666 struct ata_channel
*ch
= device_get_softc(dev
);
4667 int unit01
= (ch
->unit
& 1), unit10
= (ch
->unit
& 2);
4670 for (i
= ATA_DATA
; i
<= ATA_COMMAND
; i
++) {
4671 ch
->r_io
[i
].res
= ctlr
->r_res2
;
4672 ch
->r_io
[i
].offset
= 0x80 + i
+ (unit01
<< 6) + (unit10
<< 8);
4674 ch
->r_io
[ATA_CONTROL
].res
= ctlr
->r_res2
;
4675 ch
->r_io
[ATA_CONTROL
].offset
= 0x8a + (unit01
<< 6) + (unit10
<< 8);
4676 ch
->r_io
[ATA_IDX_ADDR
].res
= ctlr
->r_res2
;
4677 ata_default_registers(dev
);
4679 ch
->r_io
[ATA_BMCMD_PORT
].res
= ctlr
->r_res2
;
4680 ch
->r_io
[ATA_BMCMD_PORT
].offset
= 0x00 + (unit01
<< 3) + (unit10
<< 8);
4681 ch
->r_io
[ATA_BMSTAT_PORT
].res
= ctlr
->r_res2
;
4682 ch
->r_io
[ATA_BMSTAT_PORT
].offset
= 0x02 + (unit01
<< 3) + (unit10
<< 8);
4683 ch
->r_io
[ATA_BMDTP_PORT
].res
= ctlr
->r_res2
;
4684 ch
->r_io
[ATA_BMDTP_PORT
].offset
= 0x04 + (unit01
<< 3) + (unit10
<< 8);
4686 if (ctlr
->chip
->max_dma
>= ATA_SA150
) {
4687 ch
->r_io
[ATA_SSTATUS
].res
= ctlr
->r_res2
;
4688 ch
->r_io
[ATA_SSTATUS
].offset
= 0x104 + (unit01
<< 7) + (unit10
<< 8);
4689 ch
->r_io
[ATA_SERROR
].res
= ctlr
->r_res2
;
4690 ch
->r_io
[ATA_SERROR
].offset
= 0x108 + (unit01
<< 7) + (unit10
<< 8);
4691 ch
->r_io
[ATA_SCONTROL
].res
= ctlr
->r_res2
;
4692 ch
->r_io
[ATA_SCONTROL
].offset
= 0x100 + (unit01
<< 7) + (unit10
<< 8);
4693 ch
->flags
|= ATA_NO_SLAVE
;
4695 /* enable PHY state change interrupt */
4696 ATA_OUTL(ctlr
->r_res2
, 0x148 + (unit01
<< 7) + (unit10
<< 8),(1 << 16));
4699 if ((ctlr
->chip
->cfg2
& SIIBUG
) && ch
->dma
) {
4700 /* work around errata in early chips */
4701 ch
->dma
->boundary
= 16 * DEV_BSIZE
;
4702 ch
->dma
->segsize
= 15 * DEV_BSIZE
;
4706 ch
->hw
.status
= ata_sii_status
;
4711 ata_sii_status(device_t dev
)
4713 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
4714 struct ata_channel
*ch
= device_get_softc(dev
);
4715 int offset0
= ((ch
->unit
& 1) << 3) + ((ch
->unit
& 2) << 8);
4716 int offset1
= ((ch
->unit
& 1) << 6) + ((ch
->unit
& 2) << 8);
4718 /* do we have any PHY events ? */
4719 if (ctlr
->chip
->max_dma
>= ATA_SA150
&&
4720 (ATA_INL(ctlr
->r_res2
, 0x10 + offset0
) & 0x00000010))
4721 ata_sata_phy_check_events(dev
);
4723 if (ATA_INL(ctlr
->r_res2
, 0xa0 + offset1
) & 0x00000800)
4724 return ata_pci_status(dev
);
4730 ata_sii_reset(device_t dev
)
4732 if (ata_sata_phy_reset(dev
))
4733 ata_generic_reset(dev
);
4737 ata_sii_setmode(device_t dev
, int mode
)
4739 device_t gparent
= GRANDPARENT(dev
);
4740 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
4741 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
4742 struct ata_device
*atadev
= device_get_softc(dev
);
4743 int rego
= (ch
->unit
<< 4) + (ATA_DEV(atadev
->unit
) << 1);
4744 int mreg
= ch
->unit
? 0x84 : 0x80;
4745 int mask
= 0x03 << (ATA_DEV(atadev
->unit
) << 2);
4746 int mval
= pci_read_config(gparent
, mreg
, 1) & ~mask
;
4749 mode
= ata_limit_mode(dev
, mode
, ctlr
->chip
->max_dma
);
4751 if (ctlr
->chip
->cfg2
& SIISETCLK
) {
4752 if (mode
> ATA_UDMA2
&& (pci_read_config(gparent
, 0x79, 1) &
4753 (ch
->unit
? 0x02 : 0x01))) {
4754 ata_print_cable(dev
, "controller");
4759 mode
= ata_check_80pin(dev
, mode
);
4761 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
4764 device_printf(dev
, "%ssetting %s on %s chip\n",
4765 (error
) ? "FAILURE " : "",
4766 ata_mode2str(mode
), ctlr
->chip
->text
);
4770 if (mode
>= ATA_UDMA0
) {
4771 u_int8_t udmatimings
[] = { 0xf, 0xb, 0x7, 0x5, 0x3, 0x2, 0x1 };
4772 u_int8_t ureg
= 0xac + rego
;
4774 pci_write_config(gparent
, mreg
,
4775 mval
| (0x03 << (ATA_DEV(atadev
->unit
) << 2)), 1);
4776 pci_write_config(gparent
, ureg
,
4777 (pci_read_config(gparent
, ureg
, 1) & ~0x3f) |
4778 udmatimings
[mode
& ATA_MODE_MASK
], 1);
4781 else if (mode
>= ATA_WDMA0
) {
4782 u_int8_t dreg
= 0xa8 + rego
;
4783 u_int16_t dmatimings
[] = { 0x2208, 0x10c2, 0x10c1 };
4785 pci_write_config(gparent
, mreg
,
4786 mval
| (0x02 << (ATA_DEV(atadev
->unit
) << 2)), 1);
4787 pci_write_config(gparent
, dreg
, dmatimings
[mode
& ATA_MODE_MASK
], 2);
4791 u_int8_t preg
= 0xa4 + rego
;
4792 u_int16_t piotimings
[] = { 0x328a, 0x2283, 0x1104, 0x10c3, 0x10c1 };
4794 pci_write_config(gparent
, mreg
,
4795 mval
| (0x01 << (ATA_DEV(atadev
->unit
) << 2)), 1);
4796 pci_write_config(gparent
, preg
, piotimings
[mode
& ATA_MODE_MASK
], 2);
4798 atadev
->mode
= mode
;
4801 struct ata_siiprb_dma_prdentry
{
4807 struct ata_siiprb_ata_command
{
4808 u_int32_t reserved0
;
4809 struct ata_siiprb_dma_prdentry prd
[126];
4812 struct ata_siiprb_atapi_command
{
4814 struct ata_siiprb_dma_prdentry prd
[125];
4817 struct ata_siiprb_command
{
4819 u_int16_t protocol_override
;
4820 u_int32_t transfer_count
;
4823 struct ata_siiprb_ata_command ata
;
4824 struct ata_siiprb_atapi_command atapi
;
4829 ata_siiprb_allocate(device_t dev
)
4831 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
4832 struct ata_channel
*ch
= device_get_softc(dev
);
4833 int offset
= ch
->unit
* 0x2000;
4835 /* set the SATA resources */
4836 ch
->r_io
[ATA_SSTATUS
].res
= ctlr
->r_res2
;
4837 ch
->r_io
[ATA_SSTATUS
].offset
= 0x1f04 + offset
;
4838 ch
->r_io
[ATA_SERROR
].res
= ctlr
->r_res2
;
4839 ch
->r_io
[ATA_SERROR
].offset
= 0x1f08 + offset
;
4840 ch
->r_io
[ATA_SCONTROL
].res
= ctlr
->r_res2
;
4841 ch
->r_io
[ATA_SCONTROL
].offset
= 0x1f00 + offset
;
4842 ch
->r_io
[ATA_SACTIVE
].res
= ctlr
->r_res2
;
4843 ch
->r_io
[ATA_SACTIVE
].offset
= 0x1f0c + offset
;
4845 ch
->hw
.begin_transaction
= ata_siiprb_begin_transaction
;
4846 ch
->hw
.end_transaction
= ata_siiprb_end_transaction
;
4847 ch
->hw
.status
= ata_siiprb_status
;
4848 ch
->hw
.command
= NULL
; /* not used here */
4853 ata_siiprb_status(device_t dev
)
4855 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
4856 struct ata_channel
*ch
= device_get_softc(dev
);
4857 int offset
= ch
->unit
* 0x2000;
4859 if ((ATA_INL(ctlr
->r_res1
, 0x0044) & (1 << ch
->unit
))) {
4860 u_int32_t istatus
= ATA_INL(ctlr
->r_res2
, 0x1008 + offset
);
4862 /* do we have any PHY events ? */
4863 ata_sata_phy_check_events(dev
);
4865 /* clear interrupt(s) */
4866 ATA_OUTL(ctlr
->r_res2
, 0x1008 + offset
, istatus
);
4868 /* do we have any device action ? */
4869 return (istatus
& 0x00000001);
4875 ata_siiprb_begin_transaction(struct ata_request
*request
)
4877 struct ata_pci_controller
*ctlr
=device_get_softc(GRANDPARENT(request
->dev
));
4878 struct ata_channel
*ch
= device_get_softc(device_get_parent(request
->dev
));
4879 struct ata_siiprb_command
*prb
;
4880 int offset
= ch
->unit
* 0x2000;
4884 /* check for 48 bit access and convert if needed */
4885 ata_modify_if_48bit(request
);
4887 /* get a piece of the workspace for this request */
4888 prb
= (struct ata_siiprb_command
*)
4889 (ch
->dma
->work
+ (sizeof(struct ata_siiprb_command
) * tag
));
4891 /* set basic prd options ata/atapi etc etc */
4892 bzero(prb
, sizeof(struct ata_siiprb_command
));
4894 /* setup the FIS for this request */
4895 if (!ata_request2fis_h2d(request
, &prb
->fis
[0])) {
4896 device_printf(request
->dev
, "setting up SATA FIS failed\n");
4897 request
->result
= EIO
;
4898 return ATA_OP_FINISHED
;
4901 /* if request moves data setup and load SG list */
4902 if (request
->flags
& (ATA_R_READ
| ATA_R_WRITE
)) {
4903 struct ata_siiprb_dma_prdentry
*prd
;
4905 if (request
->flags
& ATA_R_ATAPI
)
4906 prd
= &prb
->u
.atapi
.prd
[0];
4908 prd
= &prb
->u
.ata
.prd
[0];
4909 if (ch
->dma
->load(ch
->dev
, request
->data
, request
->bytecount
,
4910 request
->flags
& ATA_R_READ
, prd
, &dummy
)) {
4911 device_printf(request
->dev
, "setting up DMA failed\n");
4912 request
->result
= EIO
;
4913 return ATA_OP_FINISHED
;
4917 /* activate the prb */
4918 prb_bus
= ch
->dma
->work_bus
+ (sizeof(struct ata_siiprb_command
) * tag
);
4919 ATA_OUTL(ctlr
->r_res2
,
4920 0x1c00 + offset
+ (tag
* sizeof(u_int64_t
)), prb_bus
);
4921 ATA_OUTL(ctlr
->r_res2
,
4922 0x1c04 + offset
+ (tag
* sizeof(u_int64_t
)), prb_bus
>>32);
4924 /* start the timeout */
4925 callout_reset(&request
->callout
, request
->timeout
* hz
,
4926 (timeout_t
*)ata_timeout
, request
);
4927 return ATA_OP_CONTINUES
;
4931 ata_siiprb_end_transaction(struct ata_request
*request
)
4933 struct ata_pci_controller
*ctlr
=device_get_softc(GRANDPARENT(request
->dev
));
4934 struct ata_channel
*ch
= device_get_softc(device_get_parent(request
->dev
));
4935 struct ata_siiprb_command
*prb
;
4936 int offset
= ch
->unit
* 0x2000;
4939 /* kill the timeout */
4940 callout_stop(&request
->callout
);
4942 prb
= (struct ata_siiprb_command
*)
4943 ((u_int8_t
*)rman_get_virtual(ctlr
->r_res2
) + (tag
<< 7) + offset
);
4945 /* if error status get details */
4946 request
->status
= prb
->fis
[2];
4947 if (request
->status
& ATA_S_ERROR
)
4948 request
->error
= prb
->fis
[3];
4950 /* update progress */
4951 if (!(request
->status
& ATA_S_ERROR
) && !(request
->flags
& ATA_R_TIMEOUT
)) {
4952 if (request
->flags
& ATA_R_READ
)
4953 request
->donecount
= prb
->transfer_count
;
4955 request
->donecount
= request
->bytecount
;
4958 /* any controller errors flagged ? */
4959 if ((error
= ATA_INL(ctlr
->r_res2
, 0x1024 + offset
))) {
4960 kprintf("ata_siiprb_end_transaction %s error=%08x\n",
4961 ata_cmd2str(request
), error
);
4964 /* release SG list etc */
4965 ch
->dma
->unload(ch
->dev
);
4967 return ATA_OP_FINISHED
;
4971 ata_siiprb_reset(device_t dev
)
4973 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
4974 struct ata_channel
*ch
= device_get_softc(dev
);
4975 int offset
= ch
->unit
* 0x2000;
4976 struct ata_siiprb_command
*prb
;
4978 u_int32_t status
, signature
;
4979 int timeout
, tag
= 0;
4981 /* reset channel HW */
4982 ATA_OUTL(ctlr
->r_res2
, 0x1000 + offset
, 0x00000001);
4984 ATA_OUTL(ctlr
->r_res2
, 0x1004 + offset
, 0x00000001);
4987 /* poll for channel ready */
4988 for (timeout
= 0; timeout
< 1000; timeout
++) {
4989 if ((status
= ATA_INL(ctlr
->r_res2
, 0x1000 + offset
)) & 0x00040000)
4993 if (timeout
>= 1000) {
4994 device_printf(ch
->dev
, "channel HW reset timeout reset failure\n");
4999 device_printf(ch
->dev
, "channel HW reset time=%dms\n", timeout
* 1);
5002 if (!ata_sata_phy_reset(dev
)) {
5004 device_printf(ch
->dev
, "phy reset found no device\n");
5009 /* get a piece of the workspace for a soft reset request */
5010 prb
= (struct ata_siiprb_command
*)
5011 (ch
->dma
->work
+ (sizeof(struct ata_siiprb_command
) * tag
));
5012 bzero(prb
, sizeof(struct ata_siiprb_command
));
5013 prb
->control
= htole16(0x0080);
5015 /* activate the soft reset prb */
5016 prb_bus
= ch
->dma
->work_bus
+ (sizeof(struct ata_siiprb_command
) * tag
);
5017 ATA_OUTL(ctlr
->r_res2
,
5018 0x1c00 + offset
+ (tag
* sizeof(u_int64_t
)), prb_bus
);
5019 ATA_OUTL(ctlr
->r_res2
,
5020 0x1c04 + offset
+ (tag
* sizeof(u_int64_t
)), prb_bus
>>32);
5022 /* poll for channel ready */
5023 for (timeout
= 0; timeout
< 1000; timeout
++) {
5025 if ((status
= ATA_INL(ctlr
->r_res2
, 0x1008 + offset
)) & 0x00010000)
5028 if (timeout
>= 1000) {
5029 device_printf(ch
->dev
, "reset timeout - no device found\n");
5034 device_printf(ch
->dev
, "soft reset exec time=%dms status=%08x\n",
5037 /* find out whats there */
5038 prb
= (struct ata_siiprb_command
*)
5039 ((u_int8_t
*)rman_get_virtual(ctlr
->r_res2
) + (tag
<< 7) + offset
);
5041 prb
->fis
[12]|(prb
->fis
[4]<<8)|(prb
->fis
[5]<<16)|(prb
->fis
[6]<<24);
5043 device_printf(ch
->dev
, "signature=%08x\n", signature
);
5044 switch (signature
) {
5046 ch
->devices
= ATA_ATAPI_MASTER
;
5047 device_printf(ch
->dev
, "SATA ATAPI devices not supported yet\n");
5051 ch
->devices
= ATA_PORTMULTIPLIER
;
5052 device_printf(ch
->dev
, "Portmultipliers not supported yet\n");
5056 ch
->devices
= ATA_ATA_MASTER
;
5063 /* clear interrupt(s) */
5064 ATA_OUTL(ctlr
->r_res2
, 0x1008 + offset
, 0x000008ff);
5066 /* require explicit interrupt ack */
5067 ATA_OUTL(ctlr
->r_res2
, 0x1000 + offset
, 0x00000008);
5070 ATA_OUTL(ctlr
->r_res2
, 0x1004 + offset
, 0x00000400);
5072 /* enable interrupts wanted */
5073 ATA_OUTL(ctlr
->r_res2
, 0x1010 + offset
, 0x000000ff);
5077 ata_siiprb_dmasetprd(void *xsc
, bus_dma_segment_t
*segs
, int nsegs
, int error
)
5079 struct ata_dmasetprd_args
*args
= xsc
;
5080 struct ata_siiprb_dma_prdentry
*prd
= args
->dmatab
;
5083 if ((args
->error
= error
))
5086 for (i
= 0; i
< nsegs
; i
++) {
5087 prd
[i
].addr
= htole64(segs
[i
].ds_addr
);
5088 prd
[i
].count
= htole32(segs
[i
].ds_len
);
5090 prd
[i
- 1].control
= htole32(ATA_DMA_EOT
);
5094 ata_siiprb_dmainit(device_t dev
)
5096 struct ata_channel
*ch
= device_get_softc(dev
);
5100 /* note start and stop are not used here */
5101 ch
->dma
->setprd
= ata_siiprb_dmasetprd
;
5102 ch
->dma
->max_address
= BUS_SPACE_MAXADDR
;
5108 * Silicon Integrated Systems Corp. (SiS) chipset support functions
5111 ata_sis_ident(device_t dev
)
5113 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
5114 struct ata_chip_id
*idx
;
5115 static struct ata_chip_id ids
[] =
5116 {{ ATA_SIS182
, 0x00, SISSATA
, 0, ATA_SA150
, "182" }, /* south */
5117 { ATA_SIS181
, 0x00, SISSATA
, 0, ATA_SA150
, "181" }, /* south */
5118 { ATA_SIS180
, 0x00, SISSATA
, 0, ATA_SA150
, "180" }, /* south */
5119 { ATA_SIS965
, 0x00, SIS133NEW
, 0, ATA_UDMA6
, "965" }, /* south */
5120 { ATA_SIS964
, 0x00, SIS133NEW
, 0, ATA_UDMA6
, "964" }, /* south */
5121 { ATA_SIS963
, 0x00, SIS133NEW
, 0, ATA_UDMA6
, "963" }, /* south */
5122 { ATA_SIS962
, 0x00, SIS133NEW
, 0, ATA_UDMA6
, "962" }, /* south */
5124 { ATA_SIS745
, 0x00, SIS100NEW
, 0, ATA_UDMA5
, "745" }, /* 1chip */
5125 { ATA_SIS735
, 0x00, SIS100NEW
, 0, ATA_UDMA5
, "735" }, /* 1chip */
5126 { ATA_SIS733
, 0x00, SIS100NEW
, 0, ATA_UDMA5
, "733" }, /* 1chip */
5127 { ATA_SIS730
, 0x00, SIS100OLD
, 0, ATA_UDMA5
, "730" }, /* 1chip */
5129 { ATA_SIS635
, 0x00, SIS100NEW
, 0, ATA_UDMA5
, "635" }, /* 1chip */
5130 { ATA_SIS633
, 0x00, SIS100NEW
, 0, ATA_UDMA5
, "633" }, /* unknown */
5131 { ATA_SIS630
, 0x30, SIS100OLD
, 0, ATA_UDMA5
, "630S"}, /* 1chip */
5132 { ATA_SIS630
, 0x00, SIS66
, 0, ATA_UDMA4
, "630" }, /* 1chip */
5133 { ATA_SIS620
, 0x00, SIS66
, 0, ATA_UDMA4
, "620" }, /* 1chip */
5135 { ATA_SIS550
, 0x00, SIS66
, 0, ATA_UDMA5
, "550" },
5136 { ATA_SIS540
, 0x00, SIS66
, 0, ATA_UDMA4
, "540" },
5137 { ATA_SIS530
, 0x00, SIS66
, 0, ATA_UDMA4
, "530" },
5139 { ATA_SIS5513
, 0xc2, SIS33
, 1, ATA_UDMA2
, "5513" },
5140 { ATA_SIS5513
, 0x00, SIS33
, 1, ATA_WDMA2
, "5513" },
5141 { 0, 0, 0, 0, 0, 0 }};
5145 if (!(idx
= ata_find_chip(dev
, ids
, -pci_get_slot(dev
))))
5148 if (idx
->cfg2
&& !found
) {
5149 u_int8_t reg57
= pci_read_config(dev
, 0x57, 1);
5151 pci_write_config(dev
, 0x57, (reg57
& 0x7f), 1);
5152 if (pci_read_config(dev
, PCIR_DEVVENDOR
, 4) == ATA_SIS5518
) {
5154 idx
->cfg1
= SIS133NEW
;
5155 idx
->max_dma
= ATA_UDMA6
;
5156 ksprintf(buffer
, "SiS 962/963 %s controller",
5157 ata_mode2str(idx
->max_dma
));
5159 pci_write_config(dev
, 0x57, reg57
, 1);
5161 if (idx
->cfg2
&& !found
) {
5162 u_int8_t reg4a
= pci_read_config(dev
, 0x4a, 1);
5164 pci_write_config(dev
, 0x4a, (reg4a
| 0x10), 1);
5165 if (pci_read_config(dev
, PCIR_DEVVENDOR
, 4) == ATA_SIS5517
) {
5166 struct ata_chip_id id
[] =
5167 {{ ATA_SISSOUTH
, 0x10, 0, 0, 0, "" }, { 0, 0, 0, 0, 0, 0 }};
5170 if (ata_find_chip(dev
, id
, pci_get_slot(dev
))) {
5171 idx
->cfg1
= SIS133OLD
;
5172 idx
->max_dma
= ATA_UDMA6
;
5175 idx
->cfg1
= SIS100NEW
;
5176 idx
->max_dma
= ATA_UDMA5
;
5178 ksprintf(buffer
, "SiS 961 %s controller",ata_mode2str(idx
->max_dma
));
5180 pci_write_config(dev
, 0x4a, reg4a
, 1);
5183 ksprintf(buffer
,"SiS %s %s controller",
5184 idx
->text
, ata_mode2str(idx
->max_dma
));
5186 device_set_desc_copy(dev
, buffer
);
5188 ctlr
->chipinit
= ata_sis_chipinit
;
5193 ata_sis_chipinit(device_t dev
)
5195 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
5197 if (ata_setup_interrupt(dev
))
5200 switch (ctlr
->chip
->cfg1
) {
5205 pci_write_config(dev
, 0x52, pci_read_config(dev
, 0x52, 1) & ~0x04, 1);
5209 pci_write_config(dev
, 0x49, pci_read_config(dev
, 0x49, 1) & ~0x01, 1);
5212 pci_write_config(dev
, 0x50, pci_read_config(dev
, 0x50, 2) | 0x0008, 2);
5213 pci_write_config(dev
, 0x52, pci_read_config(dev
, 0x52, 2) | 0x0008, 2);
5216 ctlr
->r_type2
= SYS_RES_IOPORT
;
5217 ctlr
->r_rid2
= PCIR_BAR(5);
5218 if ((ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
5219 &ctlr
->r_rid2
, RF_ACTIVE
))) {
5220 ctlr
->allocate
= ata_sis_allocate
;
5221 ctlr
->reset
= ata_sis_reset
;
5223 /* enable PCI interrupt */
5224 pci_write_config(dev
, PCIR_COMMAND
,
5225 pci_read_config(dev
, PCIR_COMMAND
, 2) & ~0x0400,2);
5227 ctlr
->setmode
= ata_sata_setmode
;
5232 ctlr
->setmode
= ata_sis_setmode
;
5237 ata_sis_allocate(device_t dev
)
5239 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
5240 struct ata_channel
*ch
= device_get_softc(dev
);
5241 int offset
= ch
->unit
<< ((ctlr
->chip
->chipid
== ATA_SIS182
) ? 5 : 6);
5243 /* setup the usual register normal pci style */
5244 if (ata_pci_allocate(dev
))
5247 ch
->r_io
[ATA_SSTATUS
].res
= ctlr
->r_res2
;
5248 ch
->r_io
[ATA_SSTATUS
].offset
= 0x00 + offset
;
5249 ch
->r_io
[ATA_SERROR
].res
= ctlr
->r_res2
;
5250 ch
->r_io
[ATA_SERROR
].offset
= 0x04 + offset
;
5251 ch
->r_io
[ATA_SCONTROL
].res
= ctlr
->r_res2
;
5252 ch
->r_io
[ATA_SCONTROL
].offset
= 0x08 + offset
;
5253 ch
->flags
|= ATA_NO_SLAVE
;
5255 /* XXX SOS PHY hotplug handling missing in SiS chip ?? */
5256 /* XXX SOS unknown how to enable PHY state change interrupt */
5261 ata_sis_reset(device_t dev
)
5263 if (ata_sata_phy_reset(dev
))
5264 ata_generic_reset(dev
);
5268 ata_sis_setmode(device_t dev
, int mode
)
5270 device_t gparent
= GRANDPARENT(dev
);
5271 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
5272 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
5273 struct ata_device
*atadev
= device_get_softc(dev
);
5274 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
5277 mode
= ata_limit_mode(dev
, mode
, ctlr
->chip
->max_dma
);
5279 if (ctlr
->chip
->cfg1
== SIS133NEW
) {
5280 if (mode
> ATA_UDMA2
&&
5281 pci_read_config(gparent
, ch
->unit
? 0x52 : 0x50,2) & 0x8000) {
5282 ata_print_cable(dev
, "controller");
5287 if (mode
> ATA_UDMA2
&&
5288 pci_read_config(gparent
, 0x48, 1)&(ch
->unit
? 0x20 : 0x10)) {
5289 ata_print_cable(dev
, "controller");
5294 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
5297 device_printf(dev
, "%ssetting %s on %s chip\n",
5298 (error
) ? "FAILURE " : "",
5299 ata_mode2str(mode
), ctlr
->chip
->text
);
5301 switch (ctlr
->chip
->cfg1
) {
5303 u_int32_t timings
[] =
5304 { 0x28269008, 0x0c266008, 0x04263008, 0x0c0a3008, 0x05093008,
5305 0x22196008, 0x0c0a3008, 0x05093008, 0x050939fc, 0x050936ac,
5306 0x0509347c, 0x0509325c, 0x0509323c, 0x0509322c, 0x0509321c};
5309 reg
= (pci_read_config(gparent
, 0x57, 1)&0x40?0x70:0x40)+(devno
<<2);
5310 pci_write_config(gparent
, reg
, timings
[ata_mode2idx(mode
)], 4);
5314 u_int16_t timings
[] =
5315 { 0x00cb, 0x0067, 0x0044, 0x0033, 0x0031, 0x0044, 0x0033, 0x0031,
5316 0x8f31, 0x8a31, 0x8731, 0x8531, 0x8331, 0x8231, 0x8131 };
5318 u_int16_t reg
= 0x40 + (devno
<< 1);
5320 pci_write_config(gparent
, reg
, timings
[ata_mode2idx(mode
)], 2);
5324 u_int16_t timings
[] =
5325 { 0x00cb, 0x0067, 0x0044, 0x0033, 0x0031, 0x0044, 0x0033,
5326 0x0031, 0x8b31, 0x8731, 0x8531, 0x8431, 0x8231, 0x8131 };
5327 u_int16_t reg
= 0x40 + (devno
<< 1);
5329 pci_write_config(gparent
, reg
, timings
[ata_mode2idx(mode
)], 2);
5335 u_int16_t timings
[] =
5336 { 0x0c0b, 0x0607, 0x0404, 0x0303, 0x0301, 0x0404, 0x0303,
5337 0x0301, 0xf301, 0xd301, 0xb301, 0xa301, 0x9301, 0x8301 };
5338 u_int16_t reg
= 0x40 + (devno
<< 1);
5340 pci_write_config(gparent
, reg
, timings
[ata_mode2idx(mode
)], 2);
5344 atadev
->mode
= mode
;
5349 /* VIA Technologies Inc. chipset support functions */
5351 ata_via_ident(device_t dev
)
5353 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
5354 struct ata_chip_id
*idx
;
5355 static struct ata_chip_id ids
[] =
5356 {{ ATA_VIA82C586
, 0x02, VIA33
, 0x00, ATA_UDMA2
, "82C586B" },
5357 { ATA_VIA82C586
, 0x00, VIA33
, 0x00, ATA_WDMA2
, "82C586" },
5358 { ATA_VIA82C596
, 0x12, VIA66
, VIACLK
, ATA_UDMA4
, "82C596B" },
5359 { ATA_VIA82C596
, 0x00, VIA33
, 0x00, ATA_UDMA2
, "82C596" },
5360 { ATA_VIA82C686
, 0x40, VIA100
, VIABUG
, ATA_UDMA5
, "82C686B"},
5361 { ATA_VIA82C686
, 0x10, VIA66
, VIACLK
, ATA_UDMA4
, "82C686A" },
5362 { ATA_VIA82C686
, 0x00, VIA33
, 0x00, ATA_UDMA2
, "82C686" },
5363 { ATA_VIA8231
, 0x00, VIA100
, VIABUG
, ATA_UDMA5
, "8231" },
5364 { ATA_VIA8233
, 0x00, VIA100
, 0x00, ATA_UDMA5
, "8233" },
5365 { ATA_VIA8233C
, 0x00, VIA100
, 0x00, ATA_UDMA5
, "8233C" },
5366 { ATA_VIA8233A
, 0x00, VIA133
, 0x00, ATA_UDMA6
, "8233A" },
5367 { ATA_VIA8235
, 0x00, VIA133
, 0x00, ATA_UDMA6
, "8235" },
5368 { ATA_VIA8237
, 0x00, VIA133
, 0x00, ATA_UDMA6
, "8237" },
5369 { ATA_VIA8237A
, 0x00, VIA133
, 0x00, ATA_UDMA6
, "8237A" },
5370 { ATA_VIA8251
, 0x00, VIA133
, 0x00, ATA_UDMA6
, "8251" },
5371 { 0, 0, 0, 0, 0, 0 }};
5372 static struct ata_chip_id new_ids
[] =
5373 {{ ATA_VIA6410
, 0x00, 0, 0x00, ATA_UDMA6
, "6410" },
5374 { ATA_VIA6420
, 0x00, 7, 0x00, ATA_SA150
, "6420" },
5375 { ATA_VIA6421
, 0x00, 6, VIABAR
, ATA_SA150
, "6421" },
5376 { ATA_VIA8237A
, 0x00, 7, 0x00, ATA_SA150
, "8237A" },
5377 { ATA_VIA8251
, 0x00, 0, VIAAHCI
, ATA_SA300
, "8251" },
5378 { 0, 0, 0, 0, 0, 0 }};
5381 if (pci_get_devid(dev
) == ATA_VIA82C571
) {
5382 if (!(idx
= ata_find_chip(dev
, ids
, -99)))
5386 if (!(idx
= ata_match_chip(dev
, new_ids
)))
5390 ksprintf(buffer
, "VIA %s %s controller",
5391 idx
->text
, ata_mode2str(idx
->max_dma
));
5392 device_set_desc_copy(dev
, buffer
);
5394 ctlr
->chipinit
= ata_via_chipinit
;
5399 ata_via_chipinit(device_t dev
)
5401 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
5403 if (ata_setup_interrupt(dev
))
5406 if (ctlr
->chip
->max_dma
>= ATA_SA150
) {
5407 if (ctlr
->chip
->cfg2
== VIAAHCI
) {
5408 ctlr
->r_type2
= SYS_RES_MEMORY
;
5409 ctlr
->r_rid2
= PCIR_BAR(5);
5410 if ((ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
5413 return ata_ahci_chipinit(dev
);
5416 ctlr
->r_type2
= SYS_RES_IOPORT
;
5417 ctlr
->r_rid2
= PCIR_BAR(5);
5418 if ((ctlr
->r_res2
= bus_alloc_resource_any(dev
, ctlr
->r_type2
,
5419 &ctlr
->r_rid2
, RF_ACTIVE
))) {
5420 ctlr
->allocate
= ata_via_allocate
;
5421 ctlr
->reset
= ata_via_reset
;
5423 /* enable PCI interrupt */
5424 pci_write_config(dev
, PCIR_COMMAND
,
5425 pci_read_config(dev
, PCIR_COMMAND
, 2) & ~0x0400,2);
5428 if (ctlr
->chip
->cfg2
& VIABAR
) {
5430 ctlr
->setmode
= ata_via_setmode
;
5433 ctlr
->setmode
= ata_sata_setmode
;
5437 /* prepare for ATA-66 on the 82C686a and 82C596b */
5438 if (ctlr
->chip
->cfg2
& VIACLK
)
5439 pci_write_config(dev
, 0x50, 0x030b030b, 4);
5441 /* the southbridge might need the data corruption fix */
5442 if (ctlr
->chip
->cfg2
& VIABUG
)
5443 ata_via_southbridge_fixup(dev
);
5445 /* set fifo configuration half'n'half */
5446 pci_write_config(dev
, 0x43,
5447 (pci_read_config(dev
, 0x43, 1) & 0x90) | 0x2a, 1);
5449 /* set status register read retry */
5450 pci_write_config(dev
, 0x44, pci_read_config(dev
, 0x44, 1) | 0x08, 1);
5452 /* set DMA read & end-of-sector fifo flush */
5453 pci_write_config(dev
, 0x46,
5454 (pci_read_config(dev
, 0x46, 1) & 0x0c) | 0xf0, 1);
5456 /* set sector size */
5457 pci_write_config(dev
, 0x60, DEV_BSIZE
, 2);
5458 pci_write_config(dev
, 0x68, DEV_BSIZE
, 2);
5460 ctlr
->setmode
= ata_via_family_setmode
;
5465 ata_via_allocate(device_t dev
)
5467 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
5468 struct ata_channel
*ch
= device_get_softc(dev
);
5470 /* newer SATA chips has resources in one BAR for each channel */
5471 if (ctlr
->chip
->cfg2
& VIABAR
) {
5472 struct resource
*r_io
;
5475 rid
= PCIR_BAR(ch
->unit
);
5476 if (!(r_io
= bus_alloc_resource_any(device_get_parent(dev
),
5481 for (i
= ATA_DATA
; i
<= ATA_COMMAND
; i
++) {
5482 ch
->r_io
[i
].res
= r_io
;
5483 ch
->r_io
[i
].offset
= i
;
5485 ch
->r_io
[ATA_CONTROL
].res
= r_io
;
5486 ch
->r_io
[ATA_CONTROL
].offset
= 2 + ATA_IOSIZE
;
5487 ch
->r_io
[ATA_IDX_ADDR
].res
= r_io
;
5488 ata_default_registers(dev
);
5489 for (i
= ATA_BMCMD_PORT
; i
<= ATA_BMDTP_PORT
; i
++) {
5490 ch
->r_io
[i
].res
= ctlr
->r_res1
;
5491 ch
->r_io
[i
].offset
= (i
- ATA_BMCMD_PORT
)+(ch
->unit
* ATA_BMIOSIZE
);
5498 /* setup the usual register normal pci style */
5499 if (ata_pci_allocate(dev
))
5503 ch
->r_io
[ATA_SSTATUS
].res
= ctlr
->r_res2
;
5504 ch
->r_io
[ATA_SSTATUS
].offset
= (ch
->unit
<< ctlr
->chip
->cfg1
);
5505 ch
->r_io
[ATA_SERROR
].res
= ctlr
->r_res2
;
5506 ch
->r_io
[ATA_SERROR
].offset
= 0x04 + (ch
->unit
<< ctlr
->chip
->cfg1
);
5507 ch
->r_io
[ATA_SCONTROL
].res
= ctlr
->r_res2
;
5508 ch
->r_io
[ATA_SCONTROL
].offset
= 0x08 + (ch
->unit
<< ctlr
->chip
->cfg1
);
5509 ch
->flags
|= ATA_NO_SLAVE
;
5511 /* XXX SOS PHY hotplug handling missing in VIA chip ?? */
5512 /* XXX SOS unknown how to enable PHY state change interrupt */
5517 ata_via_reset(device_t dev
)
5519 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
5520 struct ata_channel
*ch
= device_get_softc(dev
);
5522 if ((ctlr
->chip
->cfg2
& VIABAR
) && (ch
->unit
> 1))
5523 ata_generic_reset(dev
);
5525 if (ata_sata_phy_reset(dev
))
5526 ata_generic_reset(dev
);
5530 ata_via_setmode(device_t dev
, int mode
)
5532 device_t gparent
= GRANDPARENT(dev
);
5533 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
5534 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
5535 struct ata_device
*atadev
= device_get_softc(dev
);
5538 if ((ctlr
->chip
->cfg2
& VIABAR
) && (ch
->unit
> 1)) {
5539 u_int8_t pio_timings
[] = { 0xa8, 0x65, 0x65, 0x32, 0x20,
5541 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 };
5542 u_int8_t dma_timings
[] = { 0xee, 0xe8, 0xe6, 0xe4, 0xe2, 0xe1, 0xe0 };
5544 mode
= ata_check_80pin(dev
, ata_limit_mode(dev
, mode
, ATA_UDMA6
));
5545 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
5547 device_printf(dev
, "%ssetting %s on %s chip\n",
5548 (error
) ? "FAILURE " : "", ata_mode2str(mode
),
5551 pci_write_config(gparent
, 0xab, pio_timings
[ata_mode2idx(mode
)], 1);
5552 if (mode
>= ATA_UDMA0
)
5553 pci_write_config(gparent
, 0xb3,
5554 dma_timings
[mode
& ATA_MODE_MASK
], 1);
5555 atadev
->mode
= mode
;
5559 ata_sata_setmode(dev
, mode
);
5563 ata_via_southbridge_fixup(device_t dev
)
5568 if (device_get_children(device_get_parent(dev
), &children
, &nchildren
))
5571 for (i
= 0; i
< nchildren
; i
++) {
5572 if (pci_get_devid(children
[i
]) == ATA_VIA8363
||
5573 pci_get_devid(children
[i
]) == ATA_VIA8371
||
5574 pci_get_devid(children
[i
]) == ATA_VIA8662
||
5575 pci_get_devid(children
[i
]) == ATA_VIA8361
) {
5576 u_int8_t reg76
= pci_read_config(children
[i
], 0x76, 1);
5578 if ((reg76
& 0xf0) != 0xd0) {
5580 "Correcting VIA config for southbridge data corruption bug\n");
5581 pci_write_config(children
[i
], 0x75, 0x80, 1);
5582 pci_write_config(children
[i
], 0x76, (reg76
& 0x0f) | 0xd0, 1);
5587 kfree(children
, M_TEMP
);
5591 /* common code for VIA, AMD & nVidia */
5593 ata_via_family_setmode(device_t dev
, int mode
)
5595 device_t gparent
= GRANDPARENT(dev
);
5596 struct ata_pci_controller
*ctlr
= device_get_softc(gparent
);
5597 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
5598 struct ata_device
*atadev
= device_get_softc(dev
);
5599 u_int8_t timings
[] = { 0xa8, 0x65, 0x42, 0x22, 0x20, 0x42, 0x22, 0x20,
5600 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 };
5602 { 0xc2, 0xc1, 0xc0, 0x00, 0x00, 0x00, 0x00 }, /* VIA ATA33 */
5603 { 0xee, 0xec, 0xea, 0xe9, 0xe8, 0x00, 0x00 }, /* VIA ATA66 */
5604 { 0xf7, 0xf6, 0xf4, 0xf2, 0xf1, 0xf0, 0x00 }, /* VIA ATA100 */
5605 { 0xf7, 0xf7, 0xf6, 0xf4, 0xf2, 0xf1, 0xf0 }, /* VIA ATA133 */
5606 { 0xc2, 0xc1, 0xc0, 0xc4, 0xc5, 0xc6, 0xc7 }}; /* AMD/nVIDIA */
5607 int devno
= (ch
->unit
<< 1) + ATA_DEV(atadev
->unit
);
5608 int reg
= 0x53 - devno
;
5611 mode
= ata_limit_mode(dev
, mode
, ctlr
->chip
->max_dma
);
5613 if (ctlr
->chip
->cfg2
& AMDCABLE
) {
5614 if (mode
> ATA_UDMA2
&&
5615 !(pci_read_config(gparent
, 0x42, 1) & (1 << devno
))) {
5616 ata_print_cable(dev
, "controller");
5621 mode
= ata_check_80pin(dev
, mode
);
5623 if (ctlr
->chip
->cfg2
& NVIDIA
)
5626 if (ctlr
->chip
->cfg1
!= VIA133
)
5627 pci_write_config(gparent
, reg
- 0x08, timings
[ata_mode2idx(mode
)], 1);
5629 error
= ata_controlcmd(dev
, ATA_SETFEATURES
, ATA_SF_SETXFER
, 0, mode
);
5632 device_printf(dev
, "%ssetting %s on %s chip\n",
5633 (error
) ? "FAILURE " : "", ata_mode2str(mode
),
5636 if (mode
>= ATA_UDMA0
)
5637 pci_write_config(gparent
, reg
,
5638 modes
[ctlr
->chip
->cfg1
][mode
& ATA_MODE_MASK
], 1);
5640 pci_write_config(gparent
, reg
, 0x8b, 1);
5641 atadev
->mode
= mode
;
5646 /* misc functions */
5647 static struct ata_chip_id
*
5648 ata_match_chip(device_t dev
, struct ata_chip_id
*index
)
5650 while (index
->chipid
!= 0) {
5651 if (pci_get_devid(dev
) == index
->chipid
&&
5652 pci_get_revid(dev
) >= index
->chiprev
)
5659 static struct ata_chip_id
*
5660 ata_find_chip(device_t dev
, struct ata_chip_id
*index
, int slot
)
5665 if (device_get_children(device_get_parent(dev
), &children
, &nchildren
))
5668 while (index
->chipid
!= 0) {
5669 for (i
= 0; i
< nchildren
; i
++) {
5670 if (((slot
>= 0 && pci_get_slot(children
[i
]) == slot
) ||
5671 (slot
< 0 && pci_get_slot(children
[i
]) <= -slot
)) &&
5672 pci_get_devid(children
[i
]) == index
->chipid
&&
5673 pci_get_revid(children
[i
]) >= index
->chiprev
) {
5674 kfree(children
, M_TEMP
);
5680 kfree(children
, M_TEMP
);
5685 ata_setup_interrupt(device_t dev
)
5687 struct ata_pci_controller
*ctlr
= device_get_softc(dev
);
5688 int rid
= ATA_IRQ_RID
;
5690 if (!ata_legacy(dev
)) {
5691 if (!(ctlr
->r_irq
= bus_alloc_resource_any(dev
, SYS_RES_IRQ
, &rid
,
5692 RF_SHAREABLE
| RF_ACTIVE
))) {
5693 device_printf(dev
, "unable to map interrupt\n");
5696 if ((bus_setup_intr(dev
, ctlr
->r_irq
, ATA_INTR_FLAGS
,
5697 ata_generic_intr
, ctlr
, &ctlr
->handle
, NULL
))) {
5698 device_printf(dev
, "unable to setup interrupt\n");
5705 struct ata_serialize
{
5706 struct spinlock locked_mtx
;
5712 ata_serialize(device_t dev
, int flags
)
5714 struct ata_pci_controller
*ctlr
= device_get_softc(device_get_parent(dev
));
5715 struct ata_channel
*ch
= device_get_softc(dev
);
5716 struct ata_serialize
*serial
;
5717 static int inited
= 0;
5721 serial
= kmalloc(sizeof(struct ata_serialize
),
5722 M_TEMP
, M_INTWAIT
| M_ZERO
);
5723 spin_init(&serial
->locked_mtx
);
5724 serial
->locked_ch
= -1;
5725 serial
->restart_ch
= -1;
5726 device_set_ivars(ctlr
->dev
, serial
);
5730 serial
= device_get_ivars(ctlr
->dev
);
5732 spin_lock_wr(&serial
->locked_mtx
);
5735 if (serial
->locked_ch
== -1)
5736 serial
->locked_ch
= ch
->unit
;
5737 if (serial
->locked_ch
!= ch
->unit
)
5738 serial
->restart_ch
= ch
->unit
;
5742 if (serial
->locked_ch
== ch
->unit
) {
5743 serial
->locked_ch
= -1;
5744 if (serial
->restart_ch
!= -1) {
5745 if ((ch
= ctlr
->interrupt
[serial
->restart_ch
].argument
)) {
5746 serial
->restart_ch
= -1;
5747 spin_unlock_wr(&serial
->locked_mtx
);
5758 res
= serial
->locked_ch
;
5759 spin_unlock_wr(&serial
->locked_mtx
);
5764 ata_print_cable(device_t dev
, u_int8_t
*who
)
5767 "DMA limited to UDMA33, %s found non-ATA66 cable\n", who
);
5771 ata_atapi(device_t dev
)
5773 struct ata_channel
*ch
= device_get_softc(device_get_parent(dev
));
5774 struct ata_device
*atadev
= device_get_softc(dev
);
5776 return ((atadev
->unit
== ATA_MASTER
&& ch
->devices
& ATA_ATAPI_MASTER
) ||
5777 (atadev
->unit
== ATA_SLAVE
&& ch
->devices
& ATA_ATAPI_SLAVE
));
5781 ata_check_80pin(device_t dev
, int mode
)
5783 struct ata_device
*atadev
= device_get_softc(dev
);
5785 if (mode
> ATA_UDMA2
&& !(atadev
->param
.hwres
& ATA_CABLE_ID
)) {
5786 ata_print_cable(dev
, "device");
5793 ata_mode2idx(int mode
)
5795 if ((mode
& ATA_DMA_MASK
) == ATA_UDMA0
)
5796 return (mode
& ATA_MODE_MASK
) + 8;
5797 if ((mode
& ATA_DMA_MASK
) == ATA_WDMA0
)
5798 return (mode
& ATA_MODE_MASK
) + 5;
5799 return (mode
& ATA_MODE_MASK
) - ATA_PIO0
;