Function _sys_timer_start

kernel/cellos/src/sys_timer.cpp:230–314

}

error_code _sys_timer_start(ppu_thread &ppu, u32 timer_id, u64 base_time,
                            u64 period) {
  ppu.state += cpu_flag::wait;

  (period ? sys_timer.warning : sys_timer.trace)(
      "_sys_timer_start(timer_id=0x%x, base_time=0x%llx, period=0x%llx)",
      timer_id, base_time, period);

  const u64 start_time = get_guest_system_time();

  if (period && period < 100) {
    // Invalid periodic timer
    return CELL_EINVAL;
  }

  const auto timer = idm::check<lv2_obj, lv2_timer>(
      timer_id, [&](lv2_timer &timer) -> CellError {
        std::lock_guard lock(timer.mutex);

        // LV2 Disassembly: Simple nullptr check (assignment test, do not use
        // lv2_obj::check here)
        if (!timer.port) {
          return CELL_ENOTCONN;
        }

        timer.check_unlocked(start_time);
        if (timer.state != SYS_TIMER_STATE_STOP) {
          return CELL_EBUSY;
        }

        if (!period && start_time >= base_time) {
          // Invalid oneshot
          return CELL_ETIMEDOUT;
        }

        const u64 expire =
            period == 0 ? base_time : // oneshot
                base_time == 0
                ? rx::add_saturate(start_time, period)
                :
                // periodic timer with no base (using start time as base)
                start_time < rx::add_saturate(base_time, period)
                ? rx::add_saturate(base_time, period)
                :
                // periodic with base time over start time
                [&]() -> u64 // periodic timer base before start time (align to
                             // be at least a period over start time)
        {
          // Optimized from a loop in LV2:
          // do
          // {
          // 	  base_time += period;
          // }
          // while (base_time < start_time);

          const u64 start_time_with_base_time_reminder = rx::add_saturate(
              start_time - start_time % period, base_time % period);