source: mainline/uspace/drv/bus/isa/i8237.c@ ed54cbf

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since ed54cbf was ed54cbf, checked in by Jan Vesely <jano.vesely@…>, 13 years ago

isa: Add and use helper functions. Add comments.
  • Property mode set to 100644
File size: 13.9 KB
Line 
1/*
2 * Copyright (c) 2011 Jan Vesely
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup isa
30 * @{
31 */
32
33/** @file
34 * @brief DMA controller management
35 */
36
37#include <assert.h>
38#include <bool.h>
39#include <errno.h>
40#include <fibril_synch.h>
41#include <ddi.h>
42#include <libarch/ddi.h>
43#include <ddf/log.h>
44#include "i8237.h"
45
46/** DMA Slave controller I/O Address. */
47#define DMA_CONTROLLER_FIRST_BASE ((void *) 0x00)
48
49/** DMA Master controller I/O Address. */
50#define DMA_CONTROLLER_SECOND_BASE ((void *) 0xc0)
51
52/** Shared DMA page address register I/O address. */
53#define DMA_CONTROLLER_PAGE_BASE ((void *) 0x81)
54
55#define DMA_STATUS_REQ(x) (1 << (((x) % 4) + 4))
56#define DMA_STATUS_COMPLETE(x) (1 << ((x) % 4))
57
58/** http://wiki.osdev.org/DMA: The only bit that works is COND (bit 2) */
59#define DMA_COMMAND_COND (1 << 2) /**< Disables DMA controller */
60
61#define DMA_SINGLE_MASK_CHAN_SEL_MASK 0x03
62#define DMA_SINGLE_MASK_CHAN_SEL_SHIFT 0
63
64#define DMA_SINGLE_MASK_CHAN_TO_REG(x) \
65 (((x) & DMA_SINGLE_MASK_CHAN_SEL_MASK) << DMA_SINGLE_MASK_CHAN_SEL_SHIFT)
66
67#define DMA_SINGLE_MASK_MASKED_FLAG (1 << 2)
68
69#define DMA_MODE_CHAN_SELECT_MASK 0x03
70#define DMA_MODE_CHAN_SELECT_SHIFT 0
71
72#define DMA_MODE_CHAN_TO_REG(x) \
73 (((x) & DMA_MODE_CHAN_SELECT_MASK) << DMA_MODE_CHAN_SELECT_SHIFT)
74
75#define DMA_MODE_CHAN_TRA_MASK 0x03
76#define DMA_MODE_CHAN_TRA_SHIFT 2
77#define DMA_MODE_CHAN_TRA_SELF_TEST 0
78#define DMA_MODE_CHAN_TRA_WRITE 0x01
79#define DMA_MODE_CHAN_TRA_READ 0x02
80
81#define DMA_MODE_CHAN_AUTO_FLAG (1 << 4)
82#define DMA_MODE_CHAN_DOWN_FLAG (1 << 5)
83
84#define DMA_MODE_CHAN_MODE_MASK 0x03
85#define DMA_MODE_CHAN_MODE_SHIFT 6
86#define DMA_MODE_CHAN_MODE_DEMAND 0
87#define DMA_MODE_CHAN_MODE_SINGLE 1
88#define DMA_MODE_CHAN_MODE_BLOCK 2
89#define DMA_MODE_CHAN_MODE_CASCADE 3
90
91#define DMA_MULTI_MASK_CHAN(x) (1 << ((x) % 4))
92
93typedef struct {
94 uint8_t channel_start0;
95 uint8_t channel_count0;
96 uint8_t channel_start1;
97 uint8_t channel_count1;
98 uint8_t channel_start2;
99 uint8_t channel_count2;
100 uint8_t channel_start3;
101 uint8_t channel_count3;
102
103 uint8_t command_status;
104
105 /** Memory to memory transfers, NOT implemented on PCs */
106 uint8_t request;
107 uint8_t single_mask;
108 uint8_t mode;
109 uint8_t flip_flop;
110
111 /*
112 * Master reset sets Flip-Flop low, clears status,
113 * sets all mask bits on.
114 *
115 * Intermediate is not implemented on PCs.
116 *
117 */
118 uint8_t master_reset;
119 uint8_t mask_reset;
120 uint8_t multi_mask;
121} dma_controller_regs_first_t;
122
123typedef struct {
124 uint8_t channel_start4;
125 uint8_t reserved0;
126 uint8_t channel_count4;
127 uint8_t reserved1;
128 uint8_t channel_start5;
129 uint8_t reserved2;
130 uint8_t channel_count5;
131 uint8_t reserved3;
132 uint8_t channel_start6;
133 uint8_t reserved4;
134 uint8_t channel_count6;
135 uint8_t reserved5;
136 uint8_t channel_start7;
137 uint8_t reserved6;
138 uint8_t channel_count7;
139
140 uint8_t command_status;
141 uint8_t reserved8;
142 uint8_t request;
143 uint8_t reserved9;
144 uint8_t single_mask;
145 uint8_t reserveda;
146 uint8_t mode;
147 uint8_t reservedb;
148 uint8_t flip_flop;
149 uint8_t reservedc;
150 uint8_t master_reset;
151 uint8_t reservedd;
152 uint8_t multi_mask;
153} dma_controller_regs_second_t;
154
155typedef struct {
156 uint8_t channel2;
157 uint8_t channel3;
158 uint8_t channel1;
159 uint8_t reserved0;
160 uint8_t reserved1;
161 uint8_t reserved2;
162 uint8_t channel0;
163 uint8_t reserved3;
164 uint8_t channel6;
165 uint8_t channel7;
166 uint8_t channel5;
167 uint8_t reserved4;
168 uint8_t reserved5;
169 uint8_t reserved6;
170 uint8_t channel4;
171} dma_page_regs_t;
172
173/** Addresses needed to setup a DMA channel. */
174typedef struct {
175 ioport8_t *offset_reg_address;
176 ioport8_t *size_reg_address;
177 ioport8_t *page_reg_address;
178 ioport8_t *single_mask_address;
179 ioport8_t *mode_address;
180 ioport8_t *flip_flop_address;
181} dma_channel_t;
182
183typedef struct {
184 dma_channel_t channels[8];
185 dma_page_regs_t *page_table;
186 dma_controller_regs_first_t *first;
187 dma_controller_regs_second_t *second;
188 bool initialized;
189} dma_controller_t;
190
191static fibril_mutex_t guard = FIBRIL_MUTEX_INITIALIZER(guard);
192
193/** Standard i8237 DMA controller.
194 *
195 * http://zet.aluzina.org/index.php/8237_DMA_controller#DMA_Channel_Registers
196 *
197 */
198static dma_controller_t controller_8237 = {
199 .channels = {
200 /* The first chip 8-bit */
201 { /* Channel 0 - Unusable*/
202 .offset_reg_address = (uint8_t *) 0x00,
203 .size_reg_address = (uint8_t *) 0x01,
204 .page_reg_address = (uint8_t *) 0x87,
205 .single_mask_address = (uint8_t *) 0x0a,
206 .mode_address = (uint8_t *) 0x0b,
207 .flip_flop_address = (uint8_t *) 0x0c,
208 },
209 { /* Channel 1 */
210 .offset_reg_address = (uint8_t *) 0x02,
211 .size_reg_address = (uint8_t *) 0x03,
212 .page_reg_address = (uint8_t *) 0x83,
213 .single_mask_address = (uint8_t *) 0x0a,
214 .mode_address = (uint8_t *) 0x0b,
215 .flip_flop_address = (uint8_t *) 0x0c,
216 },
217 { /* Channel 2 */
218 .offset_reg_address = (uint8_t *) 0x04,
219 .size_reg_address = (uint8_t *) 0x05,
220 .page_reg_address = (uint8_t *) 0x81,
221 .single_mask_address = (uint8_t *) 0x0a,
222 .mode_address = (uint8_t *) 0x0b,
223 .flip_flop_address = (uint8_t *) 0x0c,
224 },
225 { /* Channel 3 */
226 .offset_reg_address = (uint8_t *) 0x06,
227 .size_reg_address = (uint8_t *) 0x07,
228 .page_reg_address = (uint8_t *) 0x82,
229 .single_mask_address = (uint8_t *) 0x0a,
230 .mode_address = (uint8_t *) 0x0b,
231 .flip_flop_address = (uint8_t *) 0x0c,
232 },
233
234 /* The second chip 16-bit */
235 { /* Channel 4 - Unusable */
236 .offset_reg_address = (uint8_t *) 0xc0,
237 .size_reg_address = (uint8_t *) 0xc2,
238 .page_reg_address = (uint8_t *) 0x8f,
239 .single_mask_address = (uint8_t *) 0xd4,
240 .mode_address = (uint8_t *) 0xd6,
241 .flip_flop_address = (uint8_t *) 0xd8,
242 },
243 { /* Channel 5 */
244 .offset_reg_address = (uint8_t *) 0xc4,
245 .size_reg_address = (uint8_t *) 0xc6,
246 .page_reg_address = (uint8_t *) 0x8b,
247 .single_mask_address = (uint8_t *) 0xd4,
248 .mode_address = (uint8_t *) 0xd6,
249 .flip_flop_address = (uint8_t *) 0xd8,
250 },
251 { /* Channel 6 */
252 .offset_reg_address = (uint8_t *) 0xc8,
253 .size_reg_address = (uint8_t *) 0xca,
254 .page_reg_address = (uint8_t *) 0x89,
255 .single_mask_address = (uint8_t *) 0xd4,
256 .mode_address = (uint8_t *) 0xd6,
257 .flip_flop_address = (uint8_t *) 0xd8,
258 },
259 { /* Channel 7 */
260 .offset_reg_address = (uint8_t *) 0xcc,
261 .size_reg_address = (uint8_t *) 0xce,
262 .page_reg_address = (uint8_t *) 0x8a,
263 .single_mask_address = (uint8_t *) 0xd4,
264 .mode_address = (uint8_t *) 0xd6,
265 .flip_flop_address = (uint8_t *) 0xd8,
266 },
267 },
268
269 .page_table = NULL,
270 .first = NULL,
271 .second = NULL,
272 .initialized = false,
273};
274
275/** Initialize I/O access to DMA controller I/O ports.
276 *
277 * @param controller DMA Controller structure to initialize.
278 *
279 * @return Error code.
280 */
281static inline int dma_controller_init(dma_controller_t *controller)
282{
283 assert(controller);
284 int ret = pio_enable(DMA_CONTROLLER_PAGE_BASE, sizeof(dma_page_regs_t),
285 (void **) &controller->page_table);
286 if (ret != EOK)
287 return EIO;
288
289 ret = pio_enable(DMA_CONTROLLER_FIRST_BASE,
290 sizeof(dma_controller_regs_first_t), (void **) &controller->first);
291 if (ret != EOK)
292 return EIO;
293
294 ret = pio_enable(DMA_CONTROLLER_SECOND_BASE,
295 sizeof(dma_controller_regs_second_t), (void **) &controller->second);
296 if (ret != EOK)
297 return EIO;
298
299 controller->initialized = true;
300
301 /* Reset the controller */
302 pio_write_8(&controller->second->master_reset, 0xff);
303 pio_write_8(&controller->first->master_reset, 0xff);
304
305 return EOK;
306}
307
308/** Helper function. Channels 4,5,6, and 7 are 8 bit DMA.
309 * @pram channel DMA channel.
310 * @reutrn True, if channel is 4,5,6, or 7, false otherwise.
311 */
312static inline bool is_dma16(unsigned channel)
313{
314 return (channel >= 4) && (channel < 8);
315}
316
317/** Helper function. Channels 0,1,2, and 3 are 8 bit DMA.
318 * @pram channel DMA channel.
319 * @reutrn True, if channel is 0,1,2, or 3, false otherwise.
320 */
321static inline bool is_dma8(unsigned channel)
322{
323 return (channel < 4);
324}
325
326/** Setup DMA channel to specified place and mode.
327 *
328 * @param channel DMA Channel 1, 2, 3 for 8 bit transfers,
329 * 5, 6, 7 for 16 bit.
330 * @param pa Physical address of the buffer. Must be < 16 MB
331 * for 16 bit and < 1 MB for 8 bit transfers.
332 * @param size DMA buffer size, limited to 64 KB.
333 * @param mode Mode of the DMA channel:
334 * - Read or Write
335 * - Allow automatic reset
336 * - Use address decrement instead of increment
337 * - Use SINGLE/BLOCK/ON DEMAND transfer mode
338 *
339 * @return Error code.
340 */
341int dma_channel_setup(unsigned int channel, uint32_t pa, uint16_t size,
342 uint8_t mode)
343{
344 if (!is_dma8(channel) && !is_dma16(channel))
345 return ENOENT;
346
347 if ((channel == 0) || (channel == 4))
348 return ENOTSUP;
349
350 /* DMA is limited to 24bit addresses. */
351 if (pa >= (1 << 24))
352 return EINVAL;
353
354 /* 8 bit channels use only 4 bits from the page register. */
355 if (is_dma8(channel) && (pa >= (1 << 20)))
356 return EINVAL;
357
358 /* Buffers cannot cross 64K page boundaries */
359 if ((pa & 0xffff0000) != ((pa + size) & 0xffff0000))
360 return EINVAL;
361
362 fibril_mutex_lock(&guard);
363
364 if (!controller_8237.initialized)
365 dma_controller_init(&controller_8237);
366
367 if (!controller_8237.initialized) {
368 fibril_mutex_unlock(&guard);
369 return EIO;
370 }
371
372 ddf_msg(LVL_DEBUG, "Unspoiled address: %p and size: %zu.", pa, size);
373
374 /* 16 bit transfers are a bit special */
375 if (is_dma16(channel)) {
376 /* Size must be aligned to 16 bits */
377 if ((size & 1) != 0) {
378 fibril_mutex_unlock(&guard);
379 return EINVAL;
380 }
381 /* Size is in 2byte words */
382 size >>= 1;
383 /* Address is fun: lower 16 bits need to be shifted by 1 */
384 pa = ((pa & 0xffff) >> 1) | (pa & 0xff0000);
385 }
386
387 const dma_channel_t dma_channel = controller_8237.channels[channel];
388
389 ddf_msg(LVL_DEBUG, "Setting channel %u, to address %p(%zu), mode %hhx.",
390 channel, pa, size, mode);
391
392 /* Mask DMA request */
393 uint8_t value = DMA_SINGLE_MASK_CHAN_TO_REG(channel) |
394 DMA_SINGLE_MASK_MASKED_FLAG;
395 pio_write_8(dma_channel.single_mask_address, value);
396
397 /* Set mode */
398 value = DMA_MODE_CHAN_TO_REG(channel) | mode;
399 ddf_msg(LVL_DEBUG2, "Writing mode byte: %p:%hhx.",
400 dma_channel.mode_address, value);
401 pio_write_8(dma_channel.mode_address, value);
402
403 /* Set address - reset flip-flop */
404 pio_write_8(dma_channel.flip_flop_address, 0);
405
406 /* Low byte */
407 value = pa & 0xff;
408 ddf_msg(LVL_DEBUG2, "Writing address low byte: %p:%hhx.",
409 dma_channel.offset_reg_address, value);
410 pio_write_8(dma_channel.offset_reg_address, value);
411
412 /* High byte */
413 value = (pa >> 8) & 0xff;
414 ddf_msg(LVL_DEBUG2, "Writing address high byte: %p:%hhx.",
415 dma_channel.offset_reg_address, value);
416 pio_write_8(dma_channel.offset_reg_address, value);
417
418 /* Page address - third byte */
419 value = (pa >> 16) & 0xff;
420 ddf_msg(LVL_DEBUG2, "Writing address page byte: %p:%hhx.",
421 dma_channel.page_reg_address, value);
422 pio_write_8(dma_channel.page_reg_address, value);
423
424 /* Set size - reset flip-flop */
425 pio_write_8(dma_channel.flip_flop_address, 0);
426
427 /* Low byte */
428 value = (size - 1) & 0xff;
429 ddf_msg(LVL_DEBUG2, "Writing size low byte: %p:%hhx.",
430 dma_channel.size_reg_address, value);
431 pio_write_8(dma_channel.size_reg_address, value);
432
433 /* High byte */
434 value = ((size - 1) >> 8) & 0xff;
435 ddf_msg(LVL_DEBUG2, "Writing size high byte: %p:%hhx.",
436 dma_channel.size_reg_address, value);
437 pio_write_8(dma_channel.size_reg_address, value);
438
439 /* Unmask DMA request */
440 value = DMA_SINGLE_MASK_CHAN_TO_REG(channel);
441 pio_write_8(dma_channel.single_mask_address, value);
442
443 fibril_mutex_unlock(&guard);
444
445 return EOK;
446}
447
448/** Query remaining buffer size.
449 *
450 * @param channel DMA Channel 1, 2, 3 for 8 bit transfers,
451 * 5, 6, 7 for 16 bit.
452 * @param size Place to store number of bytes pending in the assigned buffer.
453 *
454 * @return Error code.
455 */
456int dma_channel_remain(unsigned channel, uint16_t *size)
457{
458 assert(size);
459 if (!is_dma8(channel) && !is_dma16(channel))
460 return ENOENT;
461
462 if ((channel == 0) || (channel == 4))
463 return ENOTSUP;
464
465 fibril_mutex_lock(&guard);
466 if (!controller_8237.initialized) {
467 fibril_mutex_unlock(&guard);
468 return EIO;
469 }
470
471 const dma_channel_t dma_channel = controller_8237.channels[channel];
472 /* Get size - reset flip-flop */
473 pio_write_8(dma_channel.flip_flop_address, 0);
474
475 /* Low byte */
476 const uint8_t value_low = pio_read_8(dma_channel.size_reg_address);
477 ddf_msg(LVL_DEBUG2, "Read size low byte: %p:%zx.",
478 dma_channel.size_reg_address, value_low);
479
480 /* High byte */
481 const uint8_t value_high = pio_read_8(dma_channel.size_reg_address);
482 ddf_msg(LVL_DEBUG2, "Read size high byte: %p:%zx.",
483 dma_channel.size_reg_address, value_high);
484 fibril_mutex_unlock(&guard);
485
486 const int remain = (value_high << 8 | value_low) + 1;
487 /* 16 bit DMA size is in words */
488 *size = is_dma16(channel) ? remain << 1 : remain;
489 return EOK;
490}
491/**
492 * @}
493 */
Note: See TracBrowser for help on using the repository browser.