Modules/UDI - Heaps of fixes and features
[tpg/acess2.git] / KernelLand / Modules / Interfaces / UDI / udi_lib / physio / pio.c
1 /**
2  * \file udi_lib/physio/pio.c
3  * \author John Hodge (thePowersGang)
4  */
5 #define DEBUG   1
6 #include <udi.h>
7 #include <udi_physio.h>
8 #include <acess.h>
9 #include <udi_internal.h>
10
11 typedef void    _udi_pio_do_io_op_t(uint32_t child_ID, udi_ubit32_t regset_idx, udi_ubit32_t ofs, size_t len,
12         void *data, bool isOutput);
13
14 // === STRUCTURES ===
15 struct udi_pio_handle_s
16 {
17         tUDI_DriverInstance     *Inst;
18         udi_index_t     RegionIdx;
19
20         _udi_pio_do_io_op_t     *IOFunc;
21         udi_ubit32_t    ChildID;
22         udi_index_t     RegSet;
23         
24         udi_ubit32_t    Offset;
25         udi_ubit32_t    Length;
26         
27         size_t  nTransOps;
28         udi_pio_trans_t *TransOps;
29         
30         udi_ubit16_t    PIOAttributes;
31         udi_ubit32_t    Pace;
32         udi_index_t     Domain;
33
34         // TODO: Cached labels
35 //      size_t  Labels[];
36 };
37
38 // === IMPORTS ===
39 extern _udi_pio_do_io_op_t      pci_pio_do_io;
40
41 // === EXPORTS ===
42 EXPORT(udi_pio_map);
43 EXPORT(udi_pio_unmap);
44 EXPORT(udi_pio_atmic_sizes);
45 EXPORT(udi_pio_abort_sequence);
46 EXPORT(udi_pio_trans);
47 EXPORT(udi_pio_probe);
48
49 // === CODE ===
50 void udi_pio_map(udi_pio_map_call_t *callback, udi_cb_t *gcb,
51         udi_ubit32_t regset_idx, udi_ubit32_t base_offset, udi_ubit32_t length,
52         udi_pio_trans_t *trans_list, udi_ubit16_t list_length,
53         udi_ubit16_t pio_attributes, udi_ubit32_t pace, udi_index_t serialization_domain)
54 {
55         LOG("gcb=%p,regset_idx=%i,base_offset=0x%x,length=0x%x,trans_list=%p,list_length=%i,...",
56                 gcb, regset_idx, base_offset, length, trans_list, list_length);
57         char bus_type[16] = {0};
58         udi_instance_attr_type_t        type;
59         type = udi_instance_attr_get_internal(gcb, "bus_type", 0, bus_type, sizeof(bus_type), NULL);
60         if(type != UDI_ATTR_STRING) {
61                 Log_Warning("UDI", "No/invalid bus_type attribute");
62                 callback(gcb, UDI_NULL_PIO_HANDLE);
63                 return ;
64         }
65
66
67         _udi_pio_do_io_op_t     *io_op;
68         if( strcmp(bus_type, "pci") == 0 ) {
69                 // Ask PCI binding
70                 io_op = pci_pio_do_io;
71         }
72         else {
73                 // Oops, unknown
74                 Log_Warning("UDI", "Unknown bus type %s", bus_type);
75                 callback(gcb, UDI_NULL_PIO_HANDLE);
76                 return ;
77         }
78
79         udi_pio_handle_t ret = malloc( sizeof(struct udi_pio_handle_s) );
80         ret->Inst = UDI_int_ChannelGetInstance(gcb, false, &ret->RegionIdx);
81         ret->ChildID = ret->Inst->ParentChildBinding->ChildID;
82         ret->RegSet = regset_idx;
83         ret->IOFunc = io_op;
84         ret->Offset = base_offset;
85         ret->Length = length;
86         ret->TransOps = trans_list;
87         // TODO: Pre-scan to get labels
88         ret->nTransOps = list_length;
89         ret->PIOAttributes = pio_attributes;
90         ret->Pace = pace;
91         // TODO: Validate serialization_domain
92         ret->Domain = serialization_domain;
93         
94         callback(gcb, ret);
95 }
96
97 void udi_pio_unmap(udi_pio_handle_t pio_handle)
98 {
99         UNIMPLEMENTED();
100 }
101
102 udi_ubit32_t udi_pio_atmic_sizes(udi_pio_handle_t pio_handle)
103 {
104         UNIMPLEMENTED();
105         return 0;
106 }
107
108 void udi_pio_abort_sequence(udi_pio_handle_t pio_handle, udi_size_t scratch_requirement)
109 {
110         UNIMPLEMENTED();
111 }
112
113 size_t _get_label(udi_pio_handle_t pio_handle, udi_index_t label)
114 {
115         udi_pio_trans_t *ops = pio_handle->TransOps;
116         size_t  ip = 0;
117         if( label == 0 )
118                 return 0;
119         for( ; ip < pio_handle->nTransOps; ip ++ ) {
120                 if( ops[ip].pio_op == UDI_PIO_LABEL && ops[ip].operand == label )
121                         return ip;
122         }
123         return 0;
124 }
125
126 typedef union
127 {
128         udi_ubit32_t    words[32/4];;
129 } _trans_value_t;
130
131 void _zero_upper(int sizelog2, _trans_value_t *val)
132 {
133         switch(sizelog2)
134         {
135         case UDI_PIO_1BYTE:
136                 val->words[0] &= 0x00FF;
137         case UDI_PIO_2BYTE:
138                 val->words[0] &= 0xFFFF;
139         case UDI_PIO_4BYTE:
140                 val->words[1] = 0;
141         case UDI_PIO_8BYTE:
142                 val->words[2] = 0;
143                 val->words[3] = 0;
144         case UDI_PIO_16BYTE:
145                 val->words[4] = 0;
146                 val->words[5] = 0;
147                 val->words[6] = 0;
148                 val->words[7] = 0;
149         case UDI_PIO_32BYTE:
150                 break;
151         }
152 }
153
154 int _compare_zero(_trans_value_t *val, int sizelog2)
155 {
156          int    is_z=1;
157          int    is_n=0;
158         switch(sizelog2)
159         {
160         case UDI_PIO_32BYTE:
161                 is_z = is_z && (val->words[7] == 0);
162                 is_z = is_z && (val->words[6] == 0);
163                 is_z = is_z && (val->words[5] == 0);
164                 is_z = is_z && (val->words[4] == 0);
165         case UDI_PIO_16BYTE:
166                 is_z = is_z && (val->words[3] == 0);
167                 is_z = is_z && (val->words[2] == 0);
168         case UDI_PIO_8BYTE:
169                 is_z = is_z && (val->words[1] == 0);
170         case UDI_PIO_4BYTE:
171                 is_z = is_z && (val->words[0] == 0);
172                 is_n = (val->words[ (1<<sizelog2)/4-1 ] >> 31) != 0;
173                 break;
174         case UDI_PIO_2BYTE:
175                 is_z = (val->words[0] & 0xFFFF) == 0;
176                 is_n = (val->words[0] >> 15) != 0;
177                 break;
178         case UDI_PIO_1BYTE:
179                 is_z = (val->words[0] & 0xFFFF) == 0;
180                 is_n = (val->words[0] >> 7) != 0;
181                 break;
182         }
183         
184         return is_z | (is_n << 1);
185 }
186
187 static inline void _operation_shift_left(int sizelog2, _trans_value_t *dstval, int count)
188 {
189         const int nwords = (1<<sizelog2)/4;
190         ASSERTC(count, <=, 32);
191         if( sizelog2 <= UDI_PIO_4BYTE ) {
192                 dstval->words[0] <<= count;
193         }
194         else if( count == 0 ) {
195                 // nop
196         }
197         else if( count == 32 ) {
198                 for(int i = nwords - 1; i --; )
199                         dstval->words[i+1] = dstval->words[i];
200                 dstval->words[0] = 0;
201         }
202         else {
203                 for( int i = nwords - 1; i --; )
204                         dstval->words[i+1] = (dstval->words[i+1] << count)
205                                 | (dstval->words[i] >> (32 - count));
206                 dstval->words[0] = dstval->words[0] << count;
207         }
208         _zero_upper(sizelog2, dstval);
209 }
210 static inline void _operation_shift_right(int sizelog2, _trans_value_t *dstval, int count)
211 {
212         const int nwords = (1<<sizelog2)/4;
213         ASSERTC(count, <=, 32);
214         if( sizelog2 <= UDI_PIO_4BYTE ) {
215                 dstval->words[0] >>= count;
216         }
217         else if( count == 0 ) {
218                 // nop
219         }
220         else if( count == 32 ) {
221                 for(int i = 0; i < nwords-1; i++ )
222                         dstval->words[i] = dstval->words[i+1];
223                 dstval->words[nwords-1] = 0;
224         }
225         else {
226                 for(int i = 0; i < nwords-1; i++ )
227                         dstval->words[i] = (dstval->words[i] >> count)
228                                 | (dstval->words[i+1] << (32 - count));
229                 dstval->words[nwords-1] = dstval->words[nwords-1] >> count;
230         }
231         _zero_upper(sizelog2, dstval);
232 }
233 static inline void _operation_and(int sizelog2, _trans_value_t *dstval, const _trans_value_t *srcval)
234 {
235         for( int i = 0; i < ((1 <<sizelog2)+3)/4; i ++ )
236                 dstval->words[i] &= srcval->words[i];
237         _zero_upper(sizelog2, dstval);
238 }
239 static inline void _operation_or(int sizelog2, _trans_value_t *dstval, const _trans_value_t *srcval)
240 {
241         for( int i = 0; i < ((1 <<sizelog2)+3)/4; i ++ )
242                 dstval->words[i] |= srcval->words[i];
243         _zero_upper(sizelog2, dstval);
244 }
245 static inline void _operation_xor(int sizelog2, _trans_value_t *dstval, const _trans_value_t *srcval)
246 {
247         for( int i = 0; i < ((1 <<sizelog2)+3)/4; i ++ )
248                 dstval->words[i] ^= srcval->words[i];
249         _zero_upper(sizelog2, dstval);
250 }
251 static inline void _operation_add(int sizelog2, _trans_value_t *dstval, const _trans_value_t *srcval)
252 {
253          int    c = 0;
254         for( int i = 0; i < ((1 <<sizelog2)+3)/4; i ++ ) {
255                  int    new_c = (dstval->words[i] + srcval->words[i]) < srcval->words[i];
256                 dstval->words[i] += srcval->words[i] + c;
257                 c = new_c;
258         }
259         _zero_upper(sizelog2, dstval);
260 }
261 static inline void _operation_sub(int sizelog2, _trans_value_t *dstval, const _trans_value_t *srcval)
262 {
263         if( sizelog2 <= UDI_PIO_4BYTE ) {
264                 // Single word doesn't need the borrow logic
265                 // - including it would cause bugs
266                 dstval->words[0] -= srcval->words[0];
267         }
268         else {
269                  int    b = 0;
270                 for( int i = ((1 <<sizelog2)+3)/4; i --; ) {
271                          int    new_b = (dstval->words[i] < srcval->words[i] + b);
272                         dstval->words[i] -= srcval->words[i] + b;
273                         b = new_b;
274                 }
275         }
276         _zero_upper(sizelog2, dstval);
277 }
278
279 #if DEBUG
280 static const char *caMEM_MODES[] = {"DIRECT","SCRATCH","BUF","MEM"};
281 #endif
282 static inline int _read_mem(udi_cb_t *gcb, udi_buf_t *buf, void *mem_ptr,
283         udi_ubit8_t op, int sizelog2,
284         const _trans_value_t *reg, _trans_value_t *val)
285 {
286         udi_ubit32_t    ofs = reg->words[0];
287         udi_size_t      size = 1 << sizelog2;
288         switch(op)
289         {
290         case UDI_PIO_DIRECT:
291                 memcpy(val, reg, size);
292                 _zero_upper(sizelog2, val);
293                 break;
294         case UDI_PIO_SCRATCH:
295                 ASSERTCR( (ofs & (size-1)), ==, 0, 1);
296                 memcpy(val, gcb->scratch + ofs, size);
297                 //LOG("scr %p+%i => %i %x,...", gcb->scratch, ofs, size, val->words[0]);
298                 break;
299         case UDI_PIO_BUF:
300                 udi_buf_read(buf, ofs, size, val);
301                 //LOG("buf %p+%i => %i %x,...", buf, ofs, size, val->words[0]);
302                 break;
303         case UDI_PIO_MEM:
304                 ASSERTCR( (ofs & (size-1)), ==, 0, 1 );
305                 memcpy(val, mem_ptr + ofs, size);
306                 //LOG("mem %p+%i => %i %x,...", mem_ptr, ofs, size, val->words[0]);
307                 break;
308         }
309         return 0;
310 }
311
312 static inline int _write_mem(udi_cb_t *gcb, udi_buf_t *buf, void *mem_ptr,
313         udi_ubit8_t op, int sizelog2,
314         _trans_value_t *reg, const _trans_value_t *val)
315 {
316         udi_ubit32_t    ofs = reg->words[0];
317         udi_size_t      size = 1 << sizelog2;
318         switch(op)
319         {
320         case UDI_PIO_DIRECT:
321                 memcpy(reg, val, size);
322                 _zero_upper(sizelog2, reg);
323                 break;
324         case UDI_PIO_SCRATCH:
325                 ASSERTCR( (ofs & (size-1)), ==, 0, 1);
326                 LOG("scr %p+%i = %i %x,...", gcb->scratch, ofs, size, val->words[0]);
327                 memcpy(gcb->scratch + ofs, val, size);
328                 break;
329         case UDI_PIO_BUF:
330                 LOG("buf %p+%i = %i %x,...", buf, ofs, size, val->words[0]);
331                 udi_buf_write(NULL,NULL, val, size, buf, ofs, size, UDI_NULL_BUF_PATH);
332                 break;
333         case UDI_PIO_MEM:
334                 ASSERTCR( (ofs & (size-1)), ==, 0, 1);
335                 LOG("mem %p+%i = %i %x,...", mem_ptr, ofs, size, val->words[0]);
336                 memcpy(mem_ptr + ofs, val, size);
337                 break;
338         }
339         return 0;
340 }
341
342 void udi_pio_trans(udi_pio_trans_call_t *callback, udi_cb_t *gcb,
343         udi_pio_handle_t pio_handle, udi_index_t start_label,
344         udi_buf_t *buf, void *mem_ptr)
345 {
346         LOG("pio_handle=%p,start_label=%i,buf=%p,mem_ptr=%p",
347                 pio_handle, start_label, buf, mem_ptr);
348         _trans_value_t  registers[8];
349         _trans_value_t  tmpval;
350
351         ASSERT(pio_handle);
352         
353         udi_ubit16_t    ret_status = 0;
354         
355         udi_pio_trans_t *ops = pio_handle->TransOps;
356         size_t  ip = _get_label(pio_handle, start_label);
357         
358         while( ip < pio_handle->nTransOps )
359         {
360                 udi_ubit8_t     pio_op = ops[ip].pio_op;
361                 udi_ubit8_t     tran_size = ops[ip].tran_size;
362                 udi_ubit16_t    operand = ops[ip].operand;
363                 LOG("%2i: %02x %i 0x%04x", ip, pio_op, tran_size, operand);
364                 ASSERTC(tran_size, <=, UDI_PIO_32BYTE);
365                 ip ++;
366                 if( !(pio_op & 0x80) )
367                 {
368                         // Class A
369                         _trans_value_t  *reg = &registers[pio_op&7];
370                         switch(pio_op & 0x60)
371                         {
372                         case UDI_PIO_IN:
373                                 pio_handle->IOFunc(pio_handle->ChildID, pio_handle->RegSet,
374                                         operand, tran_size, &tmpval, false);
375                                 _write_mem(gcb, buf, mem_ptr, (pio_op&0x18), tran_size, reg, &tmpval);
376                                 break;
377                         case UDI_PIO_OUT:
378                                 _read_mem(gcb, buf, mem_ptr, (pio_op&0x18), tran_size, reg, &tmpval);
379                                 pio_handle->IOFunc(pio_handle->ChildID, pio_handle->RegSet,
380                                         operand, tran_size, &tmpval, true);
381                                 break;
382                         case UDI_PIO_LOAD:
383                                 _read_mem(gcb, buf, mem_ptr, (pio_op&0x18), tran_size, reg, &registers[operand]);
384                                 _zero_upper(tran_size, &registers[operand]);
385                                 break;
386                         case UDI_PIO_STORE:
387                                 _write_mem(gcb, buf, mem_ptr, (pio_op&0x18), tran_size, reg, &registers[operand]);
388                                 break;
389                         }
390                 }
391                 else if( pio_op < 0xF0 )
392                 {
393                          int    reg_num = pio_op & 7;
394                         _trans_value_t  *reg = &registers[reg_num];
395                         // Class B
396                         switch(pio_op & 0xF8)
397                         {
398                         case UDI_PIO_LOAD_IMM:
399                                 ASSERTC(ip + (1<<tran_size)/2-1, <=, pio_handle->nTransOps);
400                                 if( tran_size == UDI_PIO_1BYTE ) {
401                                         Log_Error("UDI", "udi_pio_trans - %p [%i] LOAD_IMM with 1 byte",
402                                                 ops, ip-1);
403                                         goto error;
404                                 }
405                                 switch(tran_size)
406                                 {
407                                 case UDI_PIO_32BYTE:
408                                         reg->words[7] = (ops[ip+14].operand << 16) | ops[ip+13].operand;
409                                         reg->words[6] = (ops[ip+12].operand << 16) | ops[ip+11].operand;
410                                         reg->words[5] = (ops[ip+10].operand << 16) | ops[ip+ 9].operand;
411                                         reg->words[4] = (ops[ip+ 8].operand << 16) | ops[ip+ 7].operand;
412                                 case UDI_PIO_16BYTE:
413                                         reg->words[3] = (ops[ip+ 6].operand << 16) | ops[ip+ 5].operand;
414                                         reg->words[2] = (ops[ip+ 4].operand << 16) | ops[ip+ 3].operand;
415                                 case UDI_PIO_8BYTE:
416                                         reg->words[1] = (ops[ip+ 2].operand << 16) | ops[ip+ 1].operand;
417                                 case UDI_PIO_4BYTE:
418                                         reg->words[0] = (ops[ip+ 0].operand << 16) | operand;
419                                 case UDI_PIO_2BYTE:
420                                 case UDI_PIO_1BYTE:
421                                         reg->words[0] = operand;
422                                         break;
423                                 }
424                                 _zero_upper(tran_size, reg);
425                                 ip += (1<<tran_size)/2-1;
426                                 break;
427                         case UDI_PIO_CSKIP: {
428                                 int cnd = _compare_zero(reg, tran_size);
429                                 switch(operand)
430                                 {
431                                 case UDI_PIO_NZ:
432                                         LOG("CSKIP NZ R%i", reg_num);
433                                         if( !(cnd & 1) )
434                                                 ip ++;
435                                         break;
436                                 case UDI_PIO_Z:
437                                         LOG("CSKIP Z R%i", reg_num);
438                                         if( cnd & 1 )
439                                                 ip ++;
440                                         break;
441                                 case UDI_PIO_NNEG:
442                                         LOG("CSKIP NNEG R%i", reg_num);
443                                         if( !(cnd & 2) )
444                                                 ip ++;
445                                 case UDI_PIO_NEG:
446                                         LOG("CSKIP NEG R%i", reg_num);
447                                         if( cnd & 2 )
448                                                 ip ++;
449                                         break;
450                                 }
451                                 break; }
452                         case UDI_PIO_IN_IND:
453                                 pio_handle->IOFunc(pio_handle->ChildID, pio_handle->RegSet,
454                                         registers[operand].words[0], tran_size, reg, false);
455                                 _zero_upper(tran_size, reg);
456                                 break;
457                         case UDI_PIO_OUT_IND:
458                                 pio_handle->IOFunc(pio_handle->ChildID, pio_handle->RegSet,
459                                         registers[operand].words[0], tran_size, reg, true);
460                                 break;
461                         case UDI_PIO_SHIFT_LEFT:
462                                 _operation_shift_left(tran_size, reg, operand);
463                                 break;
464                         case UDI_PIO_SHIFT_RIGHT:
465                                 _operation_shift_right(tran_size, reg, operand);
466                                 break;
467                         case UDI_PIO_AND:
468                                 _operation_and(tran_size, reg, &registers[operand]);
469                                 break;
470                         case UDI_PIO_AND_IMM:
471                                 tmpval.words[0] = operand;
472                                 _zero_upper(UDI_PIO_2BYTE, &tmpval);
473                                 _operation_and(tran_size, reg, &tmpval);
474                                 break;
475                         case UDI_PIO_OR:
476                                 _operation_or(tran_size, reg, &registers[operand]);
477                                 break;
478                         case UDI_PIO_OR_IMM:
479                                 tmpval.words[0] = operand;
480                                 _zero_upper(UDI_PIO_4BYTE, &tmpval);
481                                 _operation_or(tran_size, reg, &tmpval);
482                                 break;
483                         case UDI_PIO_XOR:
484                                 _operation_xor(tran_size, reg, &registers[operand]);
485                                 break;
486                         case UDI_PIO_ADD:
487                                 _operation_add(tran_size, reg, &registers[operand]);
488                                 break;
489                         case UDI_PIO_ADD_IMM:
490                                 tmpval.words[0] = operand;
491                                 if( operand & (1 <<16) ) {
492                                         tmpval.words[0] |= 0xFFFF0000;
493                                         memset(&tmpval.words[1], 0xFF, 4*(8-1));
494                                 }
495                                 else {
496                                         _zero_upper(UDI_PIO_4BYTE, &tmpval);
497                                 }
498                                 _operation_add(tran_size, reg, &tmpval);
499                                 break;
500                         case UDI_PIO_SUB:
501                                 _operation_sub(tran_size, reg, &registers[operand]);
502                                 break;
503                         default:
504                                 Log_Error("UDI", "udi_pio_trans - Class B %x unhandled!",
505                                         pio_op & 0xF8);
506                                 goto error;
507                         }
508                 }
509                 else
510                 {
511                         // Class C
512                         switch(pio_op)
513                         {
514                         case UDI_PIO_BRANCH:
515                                 ip = _get_label(pio_handle, operand);
516                                 break;
517                         case UDI_PIO_LABEL:
518                                 // nop
519                                 break;
520                         case UDI_PIO_REP_IN_IND:
521                         case UDI_PIO_REP_OUT_IND: {
522                                 bool dir_is_out = (pio_op == UDI_PIO_REP_OUT_IND);
523                                 udi_ubit8_t     mode    = operand & 0x18;
524                                 udi_ubit32_t    cnt     = registers[(operand>>13) & 7].words[0];
525                                  int    pio_stride      =           (operand>>10) & 3;
526                                 udi_ubit32_t    pio_ofs = registers[(operand>>7) & 7].words[0];
527                                  int    mem_stride      =           (operand>>5) & 3;
528                                 _trans_value_t  *mem_reg=&registers[(operand>>0) & 7];
529                                 udi_ubit32_t    saved_mem_reg = mem_reg->words[0];
530
531                                 if( pio_stride > 0 )
532                                         pio_stride = 1<<(tran_size+pio_stride-1);
533                                 if( mem_stride > 0 )
534                                         mem_stride = 1<<(tran_size+mem_stride-1);
535                         
536                                 LOG("REP_%s_IND %i IO=%x+%i %s Mem=%x+%i",
537                                         (dir_is_out ? "OUT": "IN"), cnt,
538                                         pio_ofs, pio_stride,
539                                         caMEM_MODES[mode>>3], saved_mem_reg, mem_stride
540                                         );
541
542                                 while( cnt -- )
543                                 {
544                                         if( dir_is_out )
545                                                 _read_mem(gcb,buf,mem_ptr, mode, tran_size,
546                                                         mem_reg, &tmpval);
547                                         pio_handle->IOFunc(pio_handle->ChildID, pio_handle->RegSet,
548                                                 pio_ofs, tran_size, &tmpval, dir_is_out);
549                                         if( !dir_is_out )
550                                                 _write_mem(gcb,buf,mem_ptr, mode, tran_size,
551                                                         mem_reg, &tmpval);
552                                         pio_ofs += pio_stride;
553                                         if( mode != UDI_PIO_DIRECT )
554                                                 mem_reg->words[0] += mem_stride;
555                                 }
556                                 if( mode != UDI_PIO_DIRECT )
557                                         mem_reg->words[0] = saved_mem_reg;
558                                 
559                                 break; }
560                         case UDI_PIO_DELAY:
561                                 LOG("DELAY %i", operand);
562                                 Log_Notice("UDI", "udi_pio_trans - TODO: DELAY");
563                                 break;
564                         case UDI_PIO_BARRIER:
565                                 LOG("BARRIER");
566                                 Log_Notice("UDI", "udi_pio_trans - TODO: BARRIER");
567                                 break;
568                         case UDI_PIO_SYNC:
569                                 LOG("SYNC");
570                                 Log_Notice("UDI", "udi_pio_trans - TODO: SYNC");
571                                 break;
572                         case UDI_PIO_SYNC_OUT:
573                                 LOG("SYNC_OUT");
574                                 Log_Notice("UDI", "udi_pio_trans - TODO: SYNC_OUT");
575                                 break;
576                         case UDI_PIO_DEBUG:
577                                 LOG("DEBUG %x", operand);
578                                 // nop
579                                 break;
580                         case UDI_PIO_END:
581                                 ASSERTC(operand, <, 8);
582                                 ASSERTC(tran_size, <=, UDI_PIO_2BYTE);
583                                 if( tran_size == UDI_PIO_2BYTE )
584                                         ret_status = registers[operand].words[0] & 0xFFFF;
585                                 else
586                                         ret_status = registers[operand].words[0] & 0xFF;
587                                 goto end;
588                         case UDI_PIO_END_IMM:
589                                 ASSERTC(tran_size, ==, UDI_PIO_2BYTE);
590                                 ret_status = operand;
591                                 goto end;
592                         default:
593                                 Log_Error("UDI", "udi_pio_trans - Class C %x unimplemented",
594                                         pio_op);
595                                 goto error;
596                         }
597                 }
598         }
599         
600         if( ip == pio_handle->nTransOps ) {
601                 Log_Notice("UDI", "udi_pio_trans - %p: Overran transaction list",
602                         ops);
603         }
604 end:
605         callback(gcb, NULL, UDI_OK, ret_status);
606         return ;
607 error:
608         callback(gcb, NULL, UDI_STAT_HW_PROBLEM, 0);
609 }
610
611 void udi_pio_probe(udi_pio_probe_call_t *callback, udi_cb_t *gcb,
612         udi_pio_handle_t pio_handle, void *mem_ptr, udi_ubit32_t pio_offset,
613         udi_ubit8_t tran_size, udi_ubit8_t direction)
614 {
615         UNIMPLEMENTED();
616 }
617

UCC git Repository :: git.ucc.asn.au