21f701933d31e0e413de49043c3f84fcf20e08b4
[barrelfish] / usr / drivers / omap44xx / sdma / main.c
1 /*
2  * Copyright (c) 2014, ETH Zurich.
3  * All rights reserved.
4  *
5  * This file is distributed under the terms in the attached LICENSE file.
6  * If you do not find this file, copies can be found by writing to:
7  * ETH Zurich D-INFK, CAB F.78, Universitaetstr 6, CH-8092 Zurich.
8  */
9
10 #include <stdio.h>
11 #include <stdlib.h>
12
13 #include <barrelfish/barrelfish.h>
14 #include <barrelfish/waitset.h>
15 #include <barrelfish/inthandler.h>
16 #include <driverkit/driverkit.h>
17
18 #include <thc/thc.h>
19
20 #include <arch/arm/omap44xx/device_registers.h>
21 #include <maps/omap44xx_map.h>
22
23 #include "sdma.h"
24 #include "omap_sdma.h"
25
26 // Channel State. Filled by the interrupt callback, read by the request task.
27 static struct {
28     awe_t *request;
29     errval_t err;
30 } channel_state[OMAP44XX_SDMA_NUM_CHANNEL];
31
32 /**
33  * \brief Interrupt callback which will be called when a channel interrupt
34  * occurs.
35  *
36  * \param channel   Channel which triggered the interrupt
37  * \param err       State of the channel, SYS_ERR_OK if transfer completed
38  */
39 static void sdma_irq_handler(omap_sdma_channel_t channel, errval_t err)
40 {
41     channel_state[channel].err = err;
42     THCSchedule(channel_state[channel].request);
43 }
44
45 /**
46  * \brief Execute a transfer on the SDMA engine. Blocks until the transfer is
47  * completed or an error occurred.
48  *
49  * \param conf   Pointer to valid & initialized channel configuration
50  */
51 static errval_t run_omap_sdma_transfer(struct omap_sdma_channel_conf *conf)
52 {
53     errval_t err;
54     omap_sdma_channel_t channel;
55
56     err = omap_sdma_allocate_channel(&channel);
57     if (err_is_fail(err)) return err;
58
59     // configure and enable allocated channel
60     omap_sdma_set_channel_conf(channel, conf);
61     omap_sdma_enable_channel(channel, true);
62
63     // this task will be rescheduled by the IRQ handler
64     THCSuspend(&channel_state[channel].request);
65
66     // read status flag set by IRQ handler
67     err = channel_state[channel].err;
68
69     omap_sdma_free_channel(channel);
70
71     return err;
72 }
73
74 /**
75  * \brief Converts the pixel size of the Flounder interface description to the
76  * element size needed for the hardware.
77  *
78  */
79 static omap44xx_sdma_data_type_t extract_data_type(omap_sdma_data_type_t pixel_size)
80 {
81     omap44xx_sdma_data_type_t data_type;
82
83     switch(pixel_size) {
84     case omap_sdma_DATA_TYPE_8BIT:
85         data_type = omap44xx_sdma_DATA_TYPE_8BIT;
86         break;
87     case omap_sdma_DATA_TYPE_16BIT:
88         data_type = omap44xx_sdma_DATA_TYPE_16BIT;
89         break;
90     case omap_sdma_DATA_TYPE_32BIT:
91     default:
92         data_type = omap44xx_sdma_DATA_TYPE_32BIT;
93         break;
94     }
95
96     return data_type;
97 }
98
99 /**
100  * \brief Initializes a configuration struct for the given parameters. It is
101  * the callers responsibility ensure that the start address and count values
102  * are valid.
103  */
104 static void init_channel_conf(struct omap_sdma_channel_conf *conf,
105                 lpaddr_t dst_start, lpaddr_t src_start,
106                 int32_t dst_x_modify, int32_t dst_y_modify,
107                 int32_t src_x_modify, int32_t src_y_modify,
108                 omap_sdma_count_2d_t count,
109                 omap44xx_sdma_color_mode_t color_mode, uint32_t color)
110 {
111     assert(conf);
112
113     omap44xx_sdma_data_type_t data_type = extract_data_type(count.pixel_size);
114
115     // OMAP4460 TRM: SDMA 16.4.5
116     int32_t es = 1 << (data_type);
117     int32_t src_element_index = (src_x_modify - 1) * es + 1;
118     int32_t src_frame_index   = (src_y_modify - 1) * es + 1;
119
120     int32_t dst_element_index = (dst_x_modify - 1) * es + 1;
121     int32_t dst_frame_index   = (dst_y_modify - 1) * es + 1;
122
123     *conf = (struct omap_sdma_channel_conf) {
124         // low priority for software-synchronized transfers
125         .read_priority  = omap44xx_sdma_PORT_PRIORITY_LOW,
126         .write_priority = omap44xx_sdma_PORT_PRIORITY_LOW,
127
128         // normal copy/transparent copy/constant fill
129         .color_mode = color_mode,
130         .color = color,
131
132         // wait for last write to complete
133         .write_mode = omap44xx_sdma_WRITE_MODE_LAST_NON_POSTED,
134
135         // channel linking is not used
136         .enable_link = false,
137         .next_channel = 0,
138
139         // always use double indexing mode, packed & burst transfer
140         .src_conf = {
141             .start_address      = src_start,
142             .addr_mode          = omap44xx_sdma_ADDR_MODE_DOUBLE_IDX,
143             .element_index      = src_element_index,
144             .frame_index        = src_frame_index,
145             .packed_transfer    = omap44xx_sdma_SRC_PACKED_ENABLE,
146             .burst_mode         = omap44xx_sdma_BURST_EN_64BYTE,
147         },
148
149         .dst_conf = {
150             .start_address      = dst_start,
151             .addr_mode          = omap44xx_sdma_ADDR_MODE_DOUBLE_IDX,
152             .element_index      = dst_element_index,
153             .frame_index        = dst_frame_index,
154             .packed_transfer    = omap44xx_sdma_DST_PACKED_ENABLE,
155             .burst_mode         = omap44xx_sdma_BURST_EN_64BYTE,
156         },
157
158         // conversion of omap_count_2d
159         .transfer_size = {
160             .element_number = count.x_count,
161             .frame_number   = count.y_count,
162             .data_type      = data_type,
163         },
164     };
165 }
166
167 /**
168  * \brief Splits the physical frame size into two factors, as the SDMA engine
169  * needs the memory region to be specified in EN * FN.
170  *
171  * \param bits      Size of the frame as a power of two.
172  * \param retcount  Pointer to count struct which will be filled with frame size
173  */
174 static void init_count_1d(uint8_t bits, omap_sdma_count_2d_t *retcount)
175 {
176     assert(retcount);
177
178     // split frame size: 2^b = 2^(b/2) * 2^(b - b/2)
179     uint8_t x_bits = MIN(bits, OMAP44XX_SDMA_MAX_EN_BITS);
180     uint8_t y_bits = bits - x_bits;
181
182     // fill count struct
183     retcount->pixel_size = omap_sdma_DATA_TYPE_8BIT;
184     retcount->x_count = 1 << x_bits;
185     retcount->y_count = 1 << y_bits;
186 }
187
188 /**
189  * \brief Performs a 32bit integer multiplication and checks for overflow.
190  */
191 inline static bool i32_mull_overflow(int32_t y, int32_t x, int32_t* prod) {
192     int64_t i64prod=(int64_t)x*y;
193     if (i64prod > INT32_MAX || i64prod < INT32_MIN) return true;
194     *prod = i64prod & 0xffffffff;
195     return false;
196 }
197
198 /**
199  * \brief Calculates the start address for a given frame capability in a
200  * two-dimensional transfer.
201  *
202  * \param cap       frame capability in which the transfer should happen
203  * \param addr      addr_2d struct containing start offset and modifiers
204  * \param count     count_2d struct specifing size of the transfer
205  * \param retaddr   filled with the physical start address of the transfer
206  *
207  * This function also does some sanity checks, to ensure that the hardware will
208  * not access any values outside the frame boundaries.
209  */
210 static errval_t frame_address_2d(struct capref cap, omap_sdma_addr_2d_t *addr,
211                 omap_sdma_count_2d_t *count, lpaddr_t *retaddr)
212 {
213     assert(addr);
214     assert(count);
215     assert(retaddr);
216
217     errval_t err;
218     struct frame_identity id;
219
220     err = invoke_frame_identify(cap, &id);
221     if (err_is_fail(err)) return err_push(err, OMAP_SDMA_ERR_CAP_LOOKUP);
222
223     lpaddr_t frame_start = id.base;
224     int32_t frame_size = id.bytes;
225
226     // image size cannot exceed hardware limits
227     if (count->x_count > OMAP44XX_SDMA_MAX_EN ||
228         count->y_count > OMAP44XX_SDMA_MAX_FN
229     ) {
230         return OMAP_SDMA_ERR_HARDWARE_LIMIT_SIZE;
231     }
232
233     // pixel size in bytes
234     int32_t pixel_size = 1 << extract_data_type(count->pixel_size);
235     // image size in pixels
236     int32_t x_cnt = count->x_count;
237     int32_t y_cnt = count->y_count;
238
239     // {x,y} modifiers and their accumulated value
240     // (all value in bytes, not pixels!)
241     int32_t x_mod, y_mod,
242             x_mod_sum, y_mod_sum;
243
244     // x_mod = addr->x_modify * pixel_size
245     // y_mod = addr->y_modify * pixel_size
246     // x_mod_sum = (x_cnt-1) * x_mod;
247     // y_mod_sum = (y_cnt-1) * y_mod;
248
249     // check for integer overflow
250     if (
251         (addr->x_modify > INT16_MAX || addr->x_modify < INT16_MIN) ||
252         i32_mull_overflow(addr->x_modify, pixel_size, &x_mod) ||
253         i32_mull_overflow(addr->y_modify, pixel_size, &y_mod) ||
254         i32_mull_overflow(x_cnt-1, x_mod, &x_mod_sum) ||
255         i32_mull_overflow(y_cnt-1, y_mod, &y_mod_sum)
256     ) {
257         return OMAP_SDMA_ERR_HARDWARE_LIMIT_ADDR;
258     }
259
260     // first access performed by the device (start offset)
261     int32_t first_access = (addr->y_start * y_cnt + addr->x_start) * pixel_size;
262     // last access performed by the device
263     int32_t last_access  = first_access + (y_cnt * x_mod_sum) + y_mod_sum;
264
265     int32_t lowest_access, highest_access;
266
267     if (x_mod >= 0 && y_mod >= 0) {
268         // monotonic access
269         // first access is smallest, last access is largest
270         lowest_access  = first_access;
271         highest_access = last_access;
272     } else if (x_mod < 0 && y_mod < 0) {
273         // monotonic access
274         // last access is smallest, first access is largest
275         lowest_access  = last_access;
276         highest_access = first_access;
277     } else {
278         // non-monotonic access
279         if (x_mod > 0) {
280             // x_mod > 0, y_mod < 0
281             if (x_mod_sum + y_mod < 0) {
282                 lowest_access  = last_access  - x_mod_sum;
283                 highest_access = first_access + x_mod_sum;
284             } else {
285                 lowest_access  = first_access;
286                 highest_access = last_access;
287             }
288         } else {
289             // x_mod < 0, y_mod > 0
290             if (x_mod_sum + y_mod > 0) {
291                 lowest_access  = first_access + x_mod_sum;
292                 highest_access = last_access  - x_mod_sum;
293             } else {
294                 lowest_access  = last_access;
295                 highest_access = first_access;
296             }
297         }
298     }
299
300     // all accesses have to be within frame boundaries
301     if (lowest_access < 0 || highest_access >= frame_size) {
302         return OMAP_SDMA_ERR_OUT_OF_BOUNDS;
303     }
304
305     *retaddr = frame_start + first_access;
306
307     return SYS_ERR_OK;
308 }
309
310 /**
311  * \brief Stub to perform simple frame-to-frame memory copy
312  * \see   Flounder definition in if/omap_sdma.if
313  */
314 errval_t mem_copy(struct capref dst_cap, struct capref src_cap)
315 {
316     errval_t err;
317     omap_sdma_count_2d_t count;
318     struct frame_identity src_id, dst_id;
319
320     // get frame sizes
321     err = invoke_frame_identify(src_cap, &src_id);
322     if (err_is_fail(err)) return err_push(err, OMAP_SDMA_ERR_CAP_LOOKUP);
323
324     err = invoke_frame_identify(dst_cap, &dst_id);
325     if (err_is_fail(err)) return err_push(err, OMAP_SDMA_ERR_CAP_LOOKUP);
326
327     // infer element/frame number for smaller frame
328     init_count_1d(MIN(log2ceil(dst_id.bytes), log2ceil(dst_id.bytes)), &count);
329
330     // configure and initiate transfer
331     struct omap_sdma_channel_conf conf;
332     init_channel_conf(&conf, dst_id.base, src_id.base, 1, 1, 1, 1, count,
333                          omap44xx_sdma_DISABLE_COLOR_MODE, 0);
334     err = run_omap_sdma_transfer(&conf);
335
336     return err;
337 }
338
339 /**
340  * \brief Stub to fill a memory frame with a constant value
341  * \see   Flounder definition in if/omap_sdma.if
342  */
343 errval_t mem_fill(struct capref dst_cap, uint8_t color)
344 {
345     errval_t err;
346     omap_sdma_count_2d_t count;
347     struct frame_identity dst_id;
348
349     // get frame size and infer element/frame number
350     err = invoke_frame_identify(dst_cap, &dst_id);
351     if (err_is_fail(err)) return err_push(err, OMAP_SDMA_ERR_CAP_LOOKUP);
352     init_count_1d(log2ceil(dst_id.bytes), &count);
353
354     // configure and initiate transfer
355     struct omap_sdma_channel_conf conf;
356     init_channel_conf(&conf, dst_id.base, 0, 1, 1, 1, 1, count,
357                          omap44xx_sdma_CONSTANT_FILL, color);
358     err = run_omap_sdma_transfer(&conf);
359
360     return err;
361 }
362
363 /**
364  * \brief Stub to perform a two-dimensional memory copy
365  * \see   Flounder definition in if/omap_sdma.if
366  */
367 errval_t mem_copy_2d(omap_sdma_addr_2d_t dst, omap_sdma_addr_2d_t src,
368                 omap_sdma_count_2d_t count, bool transparent, uint32_t color)
369 {
370     errval_t err;
371     lpaddr_t src_start, dst_start;
372
373     // check boundaries and calculate start address for source/dest frames
374     err = frame_address_2d(dst.cap, &dst, &count, &dst_start);
375     if (err_is_fail(err)) return err;
376
377     err = frame_address_2d(src.cap, &src, &count, &src_start);
378     if (err_is_fail(err)) return err;
379
380     // use transparent copy mode if requested
381     omap44xx_sdma_color_mode_t color_mode = (transparent) ?
382                                                 omap44xx_sdma_TRANSPARENT_COPY :
383                                                 omap44xx_sdma_DISABLE_COLOR_MODE;
384
385     struct omap_sdma_channel_conf conf;
386     init_channel_conf(&conf, dst_start, src_start,
387                          dst.x_modify, dst.y_modify,
388                          src.x_modify, src.y_modify,
389                          count, color_mode, color);
390
391     err = run_omap_sdma_transfer(&conf);
392     return err;
393 }
394
395 /**
396  * \brief Stub to fill parts of a frame using two-dimensional indeces
397  * \see   Flounder definition in if/omap_sdma.if
398  */
399 errval_t mem_fill_2d(omap_sdma_addr_2d_t dst, omap_sdma_count_2d_t count, uint32_t color)
400 {
401     errval_t err;
402     lpaddr_t  dst_start;
403
404     err = frame_address_2d(dst.cap, &dst, &count, &dst_start);
405     if (err_is_fail(err)) return err;
406
407     struct omap_sdma_channel_conf conf;
408     init_channel_conf(&conf, dst_start, 0,
409                          dst.x_modify, dst.y_modify, 0, 0,
410                          count, omap44xx_sdma_CONSTANT_FILL, color);
411
412     err = run_omap_sdma_transfer(&conf);
413     return err;
414 }
415
416 int main(int argc, char **argv)
417 {
418     errval_t err;
419     lvaddr_t dev_base;
420
421     err = map_device_register( OMAP44XX_MAP_L4_CFG_SDMA, 
422                                OMAP44XX_MAP_L4_CFG_SDMA_SIZE, 
423                                &dev_base);
424     if (err_is_fail(err)) {
425         USER_PANIC_ERR(err, "unable to map SDMA registers");
426     }
427
428     omap_sdma_init((mackerel_addr_t)dev_base, sdma_irq_handler);
429     start_service();
430
431     return 0;
432 }