drivers/staging/most/hdm-dim2/dim2_hal.c

   1 /*
   2  * dim2_hal.c - DIM2 HAL implementation
   3  * (MediaLB, Device Interface Macro IP, OS62420)
   4  *
   5  * Copyright (C) 2015, Microchip Technology Germany II GmbH & Co. KG
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * This file is licensed under GPLv2.
  13  */
  14
  15 /* Author: Andrey Shvetsov <andrey.shvetsov@k2l.de> */
  16
  17 #include "dim2_hal.h"
  18 #include "dim2_errors.h"
  19 #include "dim2_reg.h"
  20 #include <linux/stddef.h>
  21
  22
  23 /*
  24  * The number of frames per sub-buffer for synchronous channels.
  25  * Allowed values: 1, 2, 4, 8, 16, 32, 64.
  26  */
  27 #define FRAMES_PER_SUBBUFF 16
  28
  29 /*
  30  * Size factor for synchronous DBR buffer.
  31  * Minimal value is 4*FRAMES_PER_SUBBUFF.
  32  */
  33 #define SYNC_DBR_FACTOR (4u * (u16)FRAMES_PER_SUBBUFF)
  34
  35 /*
  36  * Size factor for isochronous DBR buffer.
  37  * Minimal value is 3.
  38  */
  39 #define ISOC_DBR_FACTOR 3u
  40
  41 /*
  42  * Number of 32-bit units for DBR map.
  43  *
  44  * 1: block size is 512, max allocation is 16K
  45  * 2: block size is 256, max allocation is 8K
  46  * 4: block size is 128, max allocation is 4K
  47  * 8: block size is 64, max allocation is 2K
  48  *
  49  * Min allocated space is block size.
  50  * Max possible allocated space is 32 blocks.
  51  */
  52 #define DBR_MAP_SIZE 2
  53
  54
  55 /* -------------------------------------------------------------------------- */
  56 /* not configurable area */
  57
  58 #define CDT 0x00
  59 #define ADT 0x40
  60 #define MLB_CAT 0x80
  61 #define AHB_CAT 0x88
  62
  63 #define DBR_SIZE  (16*1024) /* specified by IP */
  64 #define DBR_BLOCK_SIZE  (DBR_SIZE / 32 / DBR_MAP_SIZE)
  65
  66
  67 /* -------------------------------------------------------------------------- */
  68 /* generic helper functions and macros */
  69
  70 #define MLBC0_FCNT_VAL_MACRO(n) MLBC0_FCNT_VAL_ ## n ## FPSB
  71 #define MLBC0_FCNT_VAL(fpsb) MLBC0_FCNT_VAL_MACRO(fpsb)
  72
  73 static inline u32 bit_mask(u8 position)
  74 {
  75         return (u32)1 << position;
  76 }
  77
  78 static inline bool dim_on_error(u8 error_id, const char *error_message)
  79 {
  80         DIMCB_OnError(error_id, error_message);
  81         return false;
  82 }
  83
  84
  85 /* -------------------------------------------------------------------------- */
  86 /* types and local variables */
  87
  88 struct lld_global_vars_t {
  89         bool dim_is_initialized;
  90         bool mcm_is_initialized;
  91         struct dim2_regs *dim2; /* DIM2 core base address */
  92         u32 dbr_map[DBR_MAP_SIZE];
  93 };
  94
  95 static struct lld_global_vars_t g = { false };
  96
  97
  98 /* -------------------------------------------------------------------------- */
  99
 100 static int dbr_get_mask_size(u16 size)
 101 {
 102         int i;
 103
 104         for (i = 0; i < 6; i++)
 105                 if (size <= (DBR_BLOCK_SIZE << i))
 106                         return 1 << i;
 107         return 0;
 108 }
 109
 110 /**
 111  * Allocates DBR memory.
 112  * @param size Allocating memory size.
 113  * @return Offset in DBR memory by success or DBR_SIZE if out of memory.
 114  */
 115 static int alloc_dbr(u16 size)
 116 {
 117         int mask_size;
 118         int i, block_idx = 0;
 119
 120         if (size <= 0)
 121                 return DBR_SIZE; /* out of memory */
 122
 123         mask_size = dbr_get_mask_size(size);
 124         if (mask_size == 0)
 125                 return DBR_SIZE; /* out of memory */
 126
 127         for (i = 0; i < DBR_MAP_SIZE; i++) {
 128                 u32 const blocks = (size + DBR_BLOCK_SIZE - 1) / DBR_BLOCK_SIZE;
 129                 u32 mask = ~((~(u32)0) << blocks);
 130
 131                 do {
 132                         if ((g.dbr_map[i] & mask) == 0) {
 133                                 g.dbr_map[i] |= mask;
 134                                 return block_idx * DBR_BLOCK_SIZE;
 135                         }
 136                         block_idx += mask_size;
 137                         /* do shift left with 2 steps for case mask_size == 32 */
 138                         mask <<= mask_size - 1;
 139                 } while ((mask <<= 1) != 0);
 140         }
 141
 142         return DBR_SIZE; /* out of memory */
 143 }
 144
 145 static void free_dbr(int offs, int size)
 146 {
 147         int block_idx = offs / DBR_BLOCK_SIZE;
 148         u32 const blocks = (size + DBR_BLOCK_SIZE - 1) / DBR_BLOCK_SIZE;
 149         u32 mask = ~((~(u32)0) << blocks);
 150
 151         mask <<= block_idx % 32;
 152         g.dbr_map[block_idx / 32] &= ~mask;
 153 }
 154
 155 /* -------------------------------------------------------------------------- */
 156
 157 static u32 dim2_read_ctr(u32 ctr_addr, u16 mdat_idx)
 158 {
 159         DIMCB_IoWrite(&g.dim2->MADR, ctr_addr);
 160
 161         /* wait till transfer is completed */
 162         while ((DIMCB_IoRead(&g.dim2->MCTL) & 1) != 1)
 163                 continue;
 164
 165         DIMCB_IoWrite(&g.dim2->MCTL, 0);   /* clear transfer complete */
 166
 167         return DIMCB_IoRead((&g.dim2->MDAT0) + mdat_idx);
 168 }
 169
 170 static void dim2_write_ctr_mask(u32 ctr_addr, const u32 *mask, const u32 *value)
 171 {
 172         enum { MADR_WNR_BIT = 31 };
 173
 174         DIMCB_IoWrite(&g.dim2->MCTL, 0);   /* clear transfer complete */
 175
 176         if (mask[0] != 0)
 177                 DIMCB_IoWrite(&g.dim2->MDAT0, value[0]);
 178         if (mask[1] != 0)
 179                 DIMCB_IoWrite(&g.dim2->MDAT1, value[1]);
 180         if (mask[2] != 0)
 181                 DIMCB_IoWrite(&g.dim2->MDAT2, value[2]);
 182         if (mask[3] != 0)
 183                 DIMCB_IoWrite(&g.dim2->MDAT3, value[3]);
 184
 185         DIMCB_IoWrite(&g.dim2->MDWE0, mask[0]);
 186         DIMCB_IoWrite(&g.dim2->MDWE1, mask[1]);
 187         DIMCB_IoWrite(&g.dim2->MDWE2, mask[2]);
 188         DIMCB_IoWrite(&g.dim2->MDWE3, mask[3]);
 189
 190         DIMCB_IoWrite(&g.dim2->MADR, bit_mask(MADR_WNR_BIT) | ctr_addr);
 191
 192         /* wait till transfer is completed */
 193         while ((DIMCB_IoRead(&g.dim2->MCTL) & 1) != 1)
 194                 continue;
 195
 196         DIMCB_IoWrite(&g.dim2->MCTL, 0);   /* clear transfer complete */
 197 }
 198
 199 static inline void dim2_write_ctr(u32 ctr_addr, const u32 *value)
 200 {
 201         u32 const mask[4] = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
 202
 203         dim2_write_ctr_mask(ctr_addr, mask, value);
 204 }
 205
 206 static inline void dim2_clear_ctr(u32 ctr_addr)
 207 {
 208         u32 const value[4] = { 0, 0, 0, 0 };
 209
 210         dim2_write_ctr(ctr_addr, value);
 211 }
 212
 213 static void dim2_configure_cat(u8 cat_base, u8 ch_addr, u8 ch_type,
 214                                bool read_not_write, bool sync_mfe)
 215 {
 216         u16 const cat =
 217                 (read_not_write << CAT_RNW_BIT) |
 218                 (ch_type << CAT_CT_SHIFT) |
 219                 (ch_addr << CAT_CL_SHIFT) |
 220                 (sync_mfe << CAT_MFE_BIT) |
 221                 (false << CAT_MT_BIT) |
 222                 (true << CAT_CE_BIT);
 223         u8 const ctr_addr = cat_base + ch_addr / 8;
 224         u8 const idx = (ch_addr % 8) / 2;
 225         u8 const shift = (ch_addr % 2) * 16;
 226         u32 mask[4] = { 0, 0, 0, 0 };
 227         u32 value[4] = { 0, 0, 0, 0 };
 228
 229         mask[idx] = (u32)0xFFFF << shift;
 230         value[idx] = cat << shift;
 231         dim2_write_ctr_mask(ctr_addr, mask, value);
 232 }
 233
 234 static void dim2_clear_cat(u8 cat_base, u8 ch_addr)
 235 {
 236         u8 const ctr_addr = cat_base + ch_addr / 8;
 237         u8 const idx = (ch_addr % 8) / 2;
 238         u8 const shift = (ch_addr % 2) * 16;
 239         u32 mask[4] = { 0, 0, 0, 0 };
 240         u32 value[4] = { 0, 0, 0, 0 };
 241
 242         mask[idx] = (u32)0xFFFF << shift;
 243         dim2_write_ctr_mask(ctr_addr, mask, value);
 244 }
 245
 246 static void dim2_configure_cdt(u8 ch_addr, u16 dbr_address, u16 hw_buffer_size,
 247                                u16 packet_length)
 248 {
 249         u32 cdt[4] = { 0, 0, 0, 0 };
 250
 251         if (packet_length)
 252                 cdt[1] = ((packet_length - 1) << CDT1_BS_ISOC_SHIFT);
 253
 254         cdt[3] =
 255                 ((hw_buffer_size - 1) << CDT3_BD_SHIFT) |
 256                 (dbr_address << CDT3_BA_SHIFT);
 257         dim2_write_ctr(CDT + ch_addr, cdt);
 258 }
 259
 260 static void dim2_clear_cdt(u8 ch_addr)
 261 {
 262         u32 cdt[4] = { 0, 0, 0, 0 };
 263
 264         dim2_write_ctr(CDT + ch_addr, cdt);
 265 }
 266
 267 static void dim2_configure_adt(u8 ch_addr)
 268 {
 269         u32 adt[4] = { 0, 0, 0, 0 };
 270
 271         adt[0] =
 272                 (true << ADT0_CE_BIT) |
 273                 (true << ADT0_LE_BIT) |
 274                 (0 << ADT0_PG_BIT);
 275
 276         dim2_write_ctr(ADT + ch_addr, adt);
 277 }
 278
 279 static void dim2_clear_adt(u8 ch_addr)
 280 {
 281         u32 adt[4] = { 0, 0, 0, 0 };
 282
 283         dim2_write_ctr(ADT + ch_addr, adt);
 284 }
 285
 286 static void dim2_start_ctrl_async(u8 ch_addr, u8 idx, u32 buf_addr,
 287                                   u16 buffer_size)
 288 {
 289         u8 const shift = idx * 16;
 290
 291         u32 mask[4] = { 0, 0, 0, 0 };
 292         u32 adt[4] = { 0, 0, 0, 0 };
 293
 294         mask[1] =
 295                 bit_mask(ADT1_PS_BIT + shift) |
 296                 bit_mask(ADT1_RDY_BIT + shift) |
 297                 (ADT1_CTRL_ASYNC_BD_MASK << (ADT1_BD_SHIFT + shift));
 298         adt[1] =
 299                 (true << (ADT1_PS_BIT + shift)) |
 300                 (true << (ADT1_RDY_BIT + shift)) |
 301                 ((buffer_size - 1) << (ADT1_BD_SHIFT + shift));
 302
 303         mask[idx + 2] = 0xFFFFFFFF;
 304         adt[idx + 2] = buf_addr;
 305
 306         dim2_write_ctr_mask(ADT + ch_addr, mask, adt);
 307 }
 308
 309 static void dim2_start_isoc_sync(u8 ch_addr, u8 idx, u32 buf_addr,
 310                                  u16 buffer_size)
 311 {
 312         u8 const shift = idx * 16;
 313
 314         u32 mask[4] = { 0, 0, 0, 0 };
 315         u32 adt[4] = { 0, 0, 0, 0 };
 316
 317         mask[1] =
 318                 bit_mask(ADT1_RDY_BIT + shift) |
 319                 (ADT1_ISOC_SYNC_BD_MASK << (ADT1_BD_SHIFT + shift));
 320         adt[1] =
 321                 (true << (ADT1_RDY_BIT + shift)) |
 322                 ((buffer_size - 1) << (ADT1_BD_SHIFT + shift));
 323
 324         mask[idx + 2] = 0xFFFFFFFF;
 325         adt[idx + 2] = buf_addr;
 326
 327         dim2_write_ctr_mask(ADT + ch_addr, mask, adt);
 328 }
 329
 330
 331 static void dim2_clear_ctram(void)
 332 {
 333         u32 ctr_addr;
 334
 335         for (ctr_addr = 0; ctr_addr < 0x90; ctr_addr++)
 336                 dim2_clear_ctr(ctr_addr);
 337 }
 338
 339 static void dim2_configure_channel(
 340         u8 ch_addr, u8 type, u8 is_tx, u16 dbr_address, u16 hw_buffer_size,
 341         u16 packet_length, bool sync_mfe)
 342 {
 343         dim2_configure_cdt(ch_addr, dbr_address, hw_buffer_size, packet_length);
 344         dim2_configure_cat(MLB_CAT, ch_addr, type, is_tx ? 1 : 0, sync_mfe);
 345
 346         dim2_configure_adt(ch_addr);
 347         dim2_configure_cat(AHB_CAT, ch_addr, type, is_tx ? 0 : 1, sync_mfe);
 348
 349         /* unmask interrupt for used channel, enable mlb_sys_int[0] interrupt */
 350         DIMCB_IoWrite(&g.dim2->ACMR0,
 351                       DIMCB_IoRead(&g.dim2->ACMR0) | bit_mask(ch_addr));
 352 }
 353
 354 static void dim2_clear_channel(u8 ch_addr)
 355 {
 356         /* mask interrupt for used channel, disable mlb_sys_int[0] interrupt */
 357         DIMCB_IoWrite(&g.dim2->ACMR0,
 358                       DIMCB_IoRead(&g.dim2->ACMR0) & ~bit_mask(ch_addr));
 359
 360         dim2_clear_cat(AHB_CAT, ch_addr);
 361         dim2_clear_adt(ch_addr);
 362
 363         dim2_clear_cat(MLB_CAT, ch_addr);
 364         dim2_clear_cdt(ch_addr);
 365 }
 366
 367 /* -------------------------------------------------------------------------- */
 368 /* channel state helpers */
 369
 370 static void state_init(struct int_ch_state *state)
 371 {
 372         state->request_counter = 0;
 373         state->service_counter = 0;
 374
 375         state->idx1 = 0;
 376         state->idx2 = 0;
 377         state->level = 0;
 378 }
 379
 380 /* -------------------------------------------------------------------------- */
 381 /* macro helper functions */
 382
 383 static inline bool check_channel_address(u32 ch_address)
 384 {
 385         return ch_address > 0 && (ch_address % 2) == 0 &&
 386                (ch_address / 2) <= (u32)CAT_CL_MASK;
 387 }
 388
 389 static inline bool check_packet_length(u32 packet_length)
 390 {
 391         u16 const max_size = ((u16)CDT3_BD_ISOC_MASK + 1u) / ISOC_DBR_FACTOR;
 392
 393         if (packet_length <= 0)
 394                 return false; /* too small */
 395
 396         if (packet_length > max_size)
 397                 return false; /* too big */
 398
 399         if (packet_length - 1u > (u32)CDT1_BS_ISOC_MASK)
 400                 return false; /* too big */
 401
 402         return true;
 403 }
 404
 405 static inline bool check_bytes_per_frame(u32 bytes_per_frame)
 406 {
 407         u16 const max_size = ((u16)CDT3_BD_MASK + 1u) / SYNC_DBR_FACTOR;
 408
 409         if (bytes_per_frame <= 0)
 410                 return false; /* too small */
 411
 412         if (bytes_per_frame > max_size)
 413                 return false; /* too big */
 414
 415         return true;
 416 }
 417
 418 static inline u16 norm_ctrl_async_buffer_size(u16 buf_size)
 419 {
 420         u16 const max_size = (u16)ADT1_CTRL_ASYNC_BD_MASK + 1u;
 421
 422         if (buf_size > max_size)
 423                 return max_size;
 424
 425         return buf_size;
 426 }
 427
 428 static inline u16 norm_isoc_buffer_size(u16 buf_size, u16 packet_length)
 429 {
 430         u16 n;
 431         u16 const max_size = (u16)ADT1_ISOC_SYNC_BD_MASK + 1u;
 432
 433         if (buf_size > max_size)
 434                 buf_size = max_size;
 435
 436         n = buf_size / packet_length;
 437
 438         if (n < 2u)
 439                 return 0; /* too small buffer for given packet_length */
 440
 441         return packet_length * n;
 442 }
 443
 444 static inline u16 norm_sync_buffer_size(u16 buf_size, u16 bytes_per_frame)
 445 {
 446         u16 n;
 447         u16 const max_size = (u16)ADT1_ISOC_SYNC_BD_MASK + 1u;
 448         u32 const unit = bytes_per_frame * (u16)FRAMES_PER_SUBBUFF;
 449
 450         if (buf_size > max_size)
 451                 buf_size = max_size;
 452
 453         n = buf_size / unit;
 454
 455         if (n < 1u)
 456                 return 0; /* too small buffer for given bytes_per_frame */
 457
 458         return unit * n;
 459 }
 460
 461 static void dim2_cleanup(void)
 462 {
 463         /* disable MediaLB */
 464         DIMCB_IoWrite(&g.dim2->MLBC0, false << MLBC0_MLBEN_BIT);
 465
 466         dim2_clear_ctram();
 467
 468         /* disable mlb_int interrupt */
 469         DIMCB_IoWrite(&g.dim2->MIEN, 0);
 470
 471         /* clear status for all dma channels */
 472         DIMCB_IoWrite(&g.dim2->ACSR0, 0xFFFFFFFF);
 473         DIMCB_IoWrite(&g.dim2->ACSR1, 0xFFFFFFFF);
 474
 475         /* mask interrupts for all channels */
 476         DIMCB_IoWrite(&g.dim2->ACMR0, 0);
 477         DIMCB_IoWrite(&g.dim2->ACMR1, 0);
 478 }
 479
 480 static void dim2_initialize(bool enable_6pin, u8 mlb_clock)
 481 {
 482         dim2_cleanup();
 483
 484         /* configure and enable MediaLB */
 485         DIMCB_IoWrite(&g.dim2->MLBC0,
 486                       enable_6pin << MLBC0_MLBPEN_BIT |
 487                       mlb_clock << MLBC0_MLBCLK_SHIFT |
 488                       MLBC0_FCNT_VAL(FRAMES_PER_SUBBUFF) << MLBC0_FCNT_SHIFT |
 489                       true << MLBC0_MLBEN_BIT);
 490
 491         /* activate all HBI channels */
 492         DIMCB_IoWrite(&g.dim2->HCMR0, 0xFFFFFFFF);
 493         DIMCB_IoWrite(&g.dim2->HCMR1, 0xFFFFFFFF);
 494
 495         /* enable HBI */
 496         DIMCB_IoWrite(&g.dim2->HCTL, bit_mask(HCTL_EN_BIT));
 497
 498         /* configure DMA */
 499         DIMCB_IoWrite(&g.dim2->ACTL,
 500                       ACTL_DMA_MODE_VAL_DMA_MODE_1 << ACTL_DMA_MODE_BIT |
 501                       true << ACTL_SCE_BIT);
 502
 503 #if 0
 504         DIMCB_IoWrite(&g.dim2->MIEN,
 505                       bit_mask(MIEN_CTX_BREAK_BIT) |
 506                       bit_mask(MIEN_CTX_PE_BIT) |
 507                       bit_mask(MIEN_CTX_DONE_BIT) |
 508                       bit_mask(MIEN_CRX_BREAK_BIT) |
 509                       bit_mask(MIEN_CRX_PE_BIT) |
 510                       bit_mask(MIEN_CRX_DONE_BIT) |
 511                       bit_mask(MIEN_ATX_BREAK_BIT) |
 512                       bit_mask(MIEN_ATX_PE_BIT) |
 513                       bit_mask(MIEN_ATX_DONE_BIT) |
 514                       bit_mask(MIEN_ARX_BREAK_BIT) |
 515                       bit_mask(MIEN_ARX_PE_BIT) |
 516                       bit_mask(MIEN_ARX_DONE_BIT));
 517 #endif
 518 }
 519
 520 static bool dim2_is_mlb_locked(void)
 521 {
 522         u32 const mask0 = bit_mask(MLBC0_MLBLK_BIT);
 523         u32 const mask1 = bit_mask(MLBC1_CLKMERR_BIT) |
 524                           bit_mask(MLBC1_LOCKERR_BIT);
 525         u32 const c1 = DIMCB_IoRead(&g.dim2->MLBC1);
 526         u32 const nda_mask = (u32)MLBC1_NDA_MASK << MLBC1_NDA_SHIFT;
 527
 528         DIMCB_IoWrite(&g.dim2->MLBC1, c1 & nda_mask);
 529         return (DIMCB_IoRead(&g.dim2->MLBC1) & mask1) == 0 &&
 530                (DIMCB_IoRead(&g.dim2->MLBC0) & mask0) != 0;
 531 }
 532
 533
 534 /* -------------------------------------------------------------------------- */
 535 /* channel help routines */
 536
 537 static inline bool service_channel(u8 ch_addr, u8 idx)
 538 {
 539         u8 const shift = idx * 16;
 540         u32 const adt1 = dim2_read_ctr(ADT + ch_addr, 1);
 541
 542         if (((adt1 >> (ADT1_DNE_BIT + shift)) & 1) == 0)
 543                 return false;
 544
 545         {
 546                 u32 mask[4] = { 0, 0, 0, 0 };
 547                 u32 adt_w[4] = { 0, 0, 0, 0 };
 548
 549                 mask[1] =
 550                         bit_mask(ADT1_DNE_BIT + shift) |
 551                         bit_mask(ADT1_ERR_BIT + shift) |
 552                         bit_mask(ADT1_RDY_BIT + shift);
 553                 dim2_write_ctr_mask(ADT + ch_addr, mask, adt_w);
 554         }
 555
 556         /* clear channel status bit */
 557         DIMCB_IoWrite(&g.dim2->ACSR0, bit_mask(ch_addr));
 558
 559         return true;
 560 }
 561
 562
 563 /* -------------------------------------------------------------------------- */
 564 /* channel init routines */
 565
 566 static void isoc_init(struct dim_channel *ch, u8 ch_addr, u16 packet_length)
 567 {
 568         state_init(&ch->state);
 569
 570         ch->addr = ch_addr;
 571
 572         ch->packet_length = packet_length;
 573         ch->bytes_per_frame = 0;
 574         ch->done_sw_buffers_number = 0;
 575 }
 576
 577 static void sync_init(struct dim_channel *ch, u8 ch_addr, u16 bytes_per_frame)
 578 {
 579         state_init(&ch->state);
 580
 581         ch->addr = ch_addr;
 582
 583         ch->packet_length = 0;
 584         ch->bytes_per_frame = bytes_per_frame;
 585         ch->done_sw_buffers_number = 0;
 586 }
 587
 588 static void channel_init(struct dim_channel *ch, u8 ch_addr)
 589 {
 590         state_init(&ch->state);
 591
 592         ch->addr = ch_addr;
 593
 594         ch->packet_length = 0;
 595         ch->bytes_per_frame = 0;
 596         ch->done_sw_buffers_number = 0;
 597 }
 598
 599 /* returns true if channel interrupt state is cleared */
 600 static bool channel_service_interrupt(struct dim_channel *ch)
 601 {
 602         struct int_ch_state *const state = &ch->state;
 603
 604         if (!service_channel(ch->addr, state->idx2))
 605                 return false;
 606
 607         state->idx2 ^= 1;
 608         state->request_counter++;
 609         return true;
 610 }
 611
 612 static bool channel_start(struct dim_channel *ch, u32 buf_addr, u16 buf_size)
 613 {
 614         struct int_ch_state *const state = &ch->state;
 615
 616         if (buf_size <= 0)
 617                 return dim_on_error(DIM_ERR_BAD_BUFFER_SIZE, "Bad buffer size");
 618
 619         if (ch->packet_length == 0 && ch->bytes_per_frame == 0 &&
 620             buf_size != norm_ctrl_async_buffer_size(buf_size))
 621                 return dim_on_error(DIM_ERR_BAD_BUFFER_SIZE,
 622                                     "Bad control/async buffer size");
 623
 624         if (ch->packet_length &&
 625             buf_size != norm_isoc_buffer_size(buf_size, ch->packet_length))
 626                 return dim_on_error(DIM_ERR_BAD_BUFFER_SIZE,
 627                                     "Bad isochronous buffer size");
 628
 629         if (ch->bytes_per_frame &&
 630             buf_size != norm_sync_buffer_size(buf_size, ch->bytes_per_frame))
 631                 return dim_on_error(DIM_ERR_BAD_BUFFER_SIZE,
 632                                     "Bad synchronous buffer size");
 633
 634         if (state->level >= 2u)
 635                 return dim_on_error(DIM_ERR_OVERFLOW, "Channel overflow");
 636
 637         ++state->level;
 638
 639         if (ch->packet_length || ch->bytes_per_frame)
 640                 dim2_start_isoc_sync(ch->addr, state->idx1, buf_addr, buf_size);
 641         else
 642                 dim2_start_ctrl_async(ch->addr, state->idx1, buf_addr, buf_size);
 643         state->idx1 ^= 1;
 644
 645         return true;
 646 }
 647
 648 static u8 channel_service(struct dim_channel *ch)
 649 {
 650         struct int_ch_state *const state = &ch->state;
 651
 652         if (state->service_counter != state->request_counter) {
 653                 state->service_counter++;
 654                 if (state->level == 0)
 655                         return DIM_ERR_UNDERFLOW;
 656
 657                 --state->level;
 658                 ch->done_sw_buffers_number++;
 659         }
 660
 661         return DIM_NO_ERROR;
 662 }
 663
 664 static bool channel_detach_buffers(struct dim_channel *ch, u16 buffers_number)
 665 {
 666         if (buffers_number > ch->done_sw_buffers_number)
 667                 return dim_on_error(DIM_ERR_UNDERFLOW, "Channel underflow");
 668
 669         ch->done_sw_buffers_number -= buffers_number;
 670         return true;
 671 }
 672
 673
 674 /* -------------------------------------------------------------------------- */
 675 /* API */
 676
 677 u8 DIM_Startup(void *dim_base_address, u32 mlb_clock)
 678 {
 679         g.dim_is_initialized = false;
 680
 681         if (!dim_base_address)
 682                 return DIM_INIT_ERR_DIM_ADDR;
 683
 684         /* MediaLB clock: 0 - 256 fs, 1 - 512 fs, 2 - 1024 fs, 3 - 2048 fs */
 685         /* MediaLB clock: 4 - 3072 fs, 5 - 4096 fs, 6 - 6144 fs, 7 - 8192 fs */
 686         if (mlb_clock >= 8)
 687                 return DIM_INIT_ERR_MLB_CLOCK;
 688
 689         g.dim2 = dim_base_address;
 690         g.dbr_map[0] = g.dbr_map[1] = 0;
 691
 692         dim2_initialize(mlb_clock >= 3, mlb_clock);
 693
 694         g.dim_is_initialized = true;
 695
 696         return DIM_NO_ERROR;
 697 }
 698
 699 void DIM_Shutdown(void)
 700 {
 701         g.dim_is_initialized = false;
 702         dim2_cleanup();
 703 }
 704
 705 bool DIM_GetLockState(void)
 706 {
 707         return dim2_is_mlb_locked();
 708 }
 709
 710 static u8 init_ctrl_async(struct dim_channel *ch, u8 type, u8 is_tx,
 711                           u16 ch_address, u16 hw_buffer_size)
 712 {
 713         if (!g.dim_is_initialized || !ch)
 714                 return DIM_ERR_DRIVER_NOT_INITIALIZED;
 715
 716         if (!check_channel_address(ch_address))
 717                 return DIM_INIT_ERR_CHANNEL_ADDRESS;
 718
 719         ch->dbr_size = hw_buffer_size;
 720         ch->dbr_addr = alloc_dbr(ch->dbr_size);
 721         if (ch->dbr_addr >= DBR_SIZE)
 722                 return DIM_INIT_ERR_OUT_OF_MEMORY;
 723
 724         channel_init(ch, ch_address / 2);
 725
 726         dim2_configure_channel(ch->addr, type, is_tx,
 727                                ch->dbr_addr, ch->dbr_size, 0, false);
 728
 729         return DIM_NO_ERROR;
 730 }
 731
 732 u16 DIM_NormCtrlAsyncBufferSize(u16 buf_size)
 733 {
 734         return norm_ctrl_async_buffer_size(buf_size);
 735 }
 736
 737 /**
 738  * Retrieves maximal possible correct buffer size for isochronous data type
 739  * conform to given packet length and not bigger than given buffer size.
 740  *
 741  * Returns non-zero correct buffer size or zero by error.
 742  */
 743 u16 DIM_NormIsocBufferSize(u16 buf_size, u16 packet_length)
 744 {
 745         if (!check_packet_length(packet_length))
 746                 return 0;
 747
 748         return norm_isoc_buffer_size(buf_size, packet_length);
 749 }
 750
 751 /**
 752  * Retrieves maximal possible correct buffer size for synchronous data type
 753  * conform to given bytes per frame and not bigger than given buffer size.
 754  *
 755  * Returns non-zero correct buffer size or zero by error.
 756  */
 757 u16 DIM_NormSyncBufferSize(u16 buf_size, u16 bytes_per_frame)
 758 {
 759         if (!check_bytes_per_frame(bytes_per_frame))
 760                 return 0;
 761
 762         return norm_sync_buffer_size(buf_size, bytes_per_frame);
 763 }
 764
 765 u8 DIM_InitControl(struct dim_channel *ch, u8 is_tx, u16 ch_address,
 766                    u16 max_buffer_size)
 767 {
 768         return init_ctrl_async(ch, CAT_CT_VAL_CONTROL, is_tx, ch_address,
 769                                max_buffer_size * 2);
 770 }
 771
 772 u8 DIM_InitAsync(struct dim_channel *ch, u8 is_tx, u16 ch_address,
 773                  u16 max_buffer_size)
 774 {
 775         return init_ctrl_async(ch, CAT_CT_VAL_ASYNC, is_tx, ch_address,
 776                                max_buffer_size * 2);
 777 }
 778
 779 u8 DIM_InitIsoc(struct dim_channel *ch, u8 is_tx, u16 ch_address,
 780                 u16 packet_length)
 781 {
 782         if (!g.dim_is_initialized || !ch)
 783                 return DIM_ERR_DRIVER_NOT_INITIALIZED;
 784
 785         if (!check_channel_address(ch_address))
 786                 return DIM_INIT_ERR_CHANNEL_ADDRESS;
 787
 788         if (!check_packet_length(packet_length))
 789                 return DIM_ERR_BAD_CONFIG;
 790
 791         ch->dbr_size = packet_length * ISOC_DBR_FACTOR;
 792         ch->dbr_addr = alloc_dbr(ch->dbr_size);
 793         if (ch->dbr_addr >= DBR_SIZE)
 794                 return DIM_INIT_ERR_OUT_OF_MEMORY;
 795
 796         isoc_init(ch, ch_address / 2, packet_length);
 797
 798         dim2_configure_channel(ch->addr, CAT_CT_VAL_ISOC, is_tx, ch->dbr_addr,
 799                                ch->dbr_size, packet_length, false);
 800
 801         return DIM_NO_ERROR;
 802 }
 803
 804 u8 DIM_InitSync(struct dim_channel *ch, u8 is_tx, u16 ch_address,
 805                 u16 bytes_per_frame)
 806 {
 807         if (!g.dim_is_initialized || !ch)
 808                 return DIM_ERR_DRIVER_NOT_INITIALIZED;
 809
 810         if (!check_channel_address(ch_address))
 811                 return DIM_INIT_ERR_CHANNEL_ADDRESS;
 812
 813         if (!check_bytes_per_frame(bytes_per_frame))
 814                 return DIM_ERR_BAD_CONFIG;
 815
 816         ch->dbr_size = bytes_per_frame * SYNC_DBR_FACTOR;
 817         ch->dbr_addr = alloc_dbr(ch->dbr_size);
 818         if (ch->dbr_addr >= DBR_SIZE)
 819                 return DIM_INIT_ERR_OUT_OF_MEMORY;
 820
 821         sync_init(ch, ch_address / 2, bytes_per_frame);
 822
 823         dim2_configure_channel(ch->addr, CAT_CT_VAL_SYNC, is_tx,
 824                                ch->dbr_addr, ch->dbr_size, 0, true);
 825
 826         return DIM_NO_ERROR;
 827 }
 828
 829 u8 DIM_DestroyChannel(struct dim_channel *ch)
 830 {
 831         if (!g.dim_is_initialized || !ch)
 832                 return DIM_ERR_DRIVER_NOT_INITIALIZED;
 833
 834         dim2_clear_channel(ch->addr);
 835         if (ch->dbr_addr < DBR_SIZE)
 836                 free_dbr(ch->dbr_addr, ch->dbr_size);
 837         ch->dbr_addr = DBR_SIZE;
 838
 839         return DIM_NO_ERROR;
 840 }
 841
 842 void DIM_ServiceIrq(struct dim_channel *const *channels)
 843 {
 844         bool state_changed;
 845
 846         if (!g.dim_is_initialized) {
 847                 dim_on_error(DIM_ERR_DRIVER_NOT_INITIALIZED,
 848                              "DIM is not initialized");
 849                 return;
 850         }
 851
 852         if (!channels) {
 853                 dim_on_error(DIM_ERR_DRIVER_NOT_INITIALIZED, "Bad channels");
 854                 return;
 855         }
 856
 857         /*
 858          * Use while-loop and a flag to make sure the age is changed back at least once,
 859          * otherwise the interrupt may never come if CPU generates interrupt on changing age.
 860          *
 861          * This cycle runs not more than number of channels, because service_interrupts
 862          * routine doesn't start the channel again.
 863          */
 864         do {
 865                 struct dim_channel *const *ch = channels;
 866
 867                 state_changed = false;
 868
 869                 while (*ch) {
 870                         state_changed |= channel_service_interrupt(*ch);
 871                         ++ch;
 872                 }
 873         } while (state_changed);
 874
 875         /* clear pending Interrupts */
 876         DIMCB_IoWrite(&g.dim2->MS0, 0);
 877         DIMCB_IoWrite(&g.dim2->MS1, 0);
 878 }
 879
 880 u8 DIM_ServiceChannel(struct dim_channel *ch)
 881 {
 882         if (!g.dim_is_initialized || !ch)
 883                 return DIM_ERR_DRIVER_NOT_INITIALIZED;
 884
 885         return channel_service(ch);
 886 }
 887
 888 struct dim_ch_state_t *DIM_GetChannelState(struct dim_channel *ch,
 889                 struct dim_ch_state_t *state_ptr)
 890 {
 891         if (!ch || !state_ptr)
 892                 return NULL;
 893
 894         state_ptr->ready = ch->state.level < 2;
 895         state_ptr->done_buffers = ch->done_sw_buffers_number;
 896
 897         return state_ptr;
 898 }
 899
 900 bool DIM_EnqueueBuffer(struct dim_channel *ch, u32 buffer_addr, u16 buffer_size)
 901 {
 902         if (!ch)
 903                 return dim_on_error(DIM_ERR_DRIVER_NOT_INITIALIZED, "Bad channel");
 904
 905         return channel_start(ch, buffer_addr, buffer_size);
 906 }
 907
 908 bool DIM_DetachBuffers(struct dim_channel *ch, u16 buffers_number)
 909 {
 910         if (!ch)
 911                 return dim_on_error(DIM_ERR_DRIVER_NOT_INITIALIZED, "Bad channel");
 912
 913         return channel_detach_buffers(ch, buffers_number);
 914 }
 915
 916 u32 DIM_ReadRegister(u8 register_index)
 917 {
 918         return DIMCB_IoRead((u32 *)g.dim2 + register_index);
 919 }