Example #1
0
PRIVATE void Console_scrollDown(void) {

    /* move every line i to line i-1 */
    for(int i = 1; i < vgaHeight; i++) {

        char* src   = (char*) vgaRam + ((i) * vgaWidth * 2);
        char* dest  = (char*) vgaRam + ((i - 1) * vgaWidth * 2);
        Memory_copy(dest, src, vgaWidth * 2);

    }

    /* clear last row */
    cursorY = vgaHeight - 1;
    Console_clearLine(cursorY);

}
/*!
 *  @brief  Linux specific function to close the driver.
 */
static
long SyslinkMemMgrDrv_ioctl (struct file *  filp,
                             unsigned int   cmd,
                             unsigned long  args)
{
    int                     osStatus = 0;
    Int32                   status = MEMMGR_SUCCESS;
    SyslinkMemMgrDrv_CmdArgs       *dstArgs  = (SyslinkMemMgrDrv_CmdArgs *) args;
    Int32                   ret;
    UInt32                  size;
    SyslinkMemMgrDrv_CmdArgs       cargs;

    GT_3trace (curTrace, GT_ENTER, "SyslinkMemMgrDrv_ioctl",
               filp, cmd, args);

    /* Copy the full args from user-side */
    ret = copy_from_user (&cargs,
                          dstArgs,
                          sizeof (SyslinkMemMgrDrv_CmdArgs));
    GT_assert (curTrace, (ret == 0));

    switch (cmd) {

        case CMD_MEMMGR_CREATE:
        {
            Ptr     params = NULL;
            if (cargs.args.create.type == SyslinkMemMgr_TYPE_SHAREDMEM) {
                size = sizeof(SyslinkMemMgr_SharedMemory_Params);
                params = Memory_alloc (NULL,
                                       size,
                                       0,
                                       NULL);
                Memory_copy(params,
                            cargs.args.create.params,
                            size);
            }
            if (params != NULL) {
                cargs.args.create.handle = SyslinkMemMgr_create (params);
                GT_assert (curTrace, (cargs.args.create.handle != NULL));

                Memory_free (NULL, params, size);
            }
        }
        break;

        case CMD_MEMMGR_DELETE:
        {
            status = SyslinkMemMgr_delete (&cargs.args.deleteInstance.handle);
            GT_assert (curTrace, (status >= 0));
        }
        break;

        /* params init for ShMem implementation */
        case CMD_MEMMGR_SHAREDMEM_PARAMS_INIT  :
        {
            SyslinkMemMgr_SharedMemory_Params params;

            SyslinkMemMgr_SharedMemory_Params_init(&params);
            ret = copy_to_user (cargs.args.ParamsInit.params,
                                &params,
                                sizeof (SyslinkMemMgr_SharedMemory_Params));
            GT_assert (curTrace, (ret == 0));
#if !defined(SYSLINK_BUILD_OPTIMIZE)
            if (ret != 0) {
                GT_1trace (curTrace,
                           GT_1CLASS,
                           "    SyslinkMemMgrDrv_ioctl: copy_to_user call"
                           " failed\n"
                           "        status [%d]",
                           ret);
                osStatus = -EFAULT;
            }
#endif /* !defined(SYSLINK_BUILD_OPTIMIZE) */
        }
        break;

        default:
        {
            /* This does not impact return status of this function, so retVal
             * comment is not used.
             */
            status = MEMMGR_E_INVALIDARG;
            GT_setFailureReason (curTrace,
                                 GT_4CLASS,
                                 "SyslinkMemMgrDrv_ioctl",
                                 status,
                                 "Unsupported ioctl command specified");
        }
        break;
    }

    cargs.apiStatus = status;

    /* Copy the full args to the user-side. */
    ret = copy_to_user (dstArgs,
                        &cargs,
                        sizeof (SyslinkMemMgrDrv_CmdArgs));
    GT_assert (curTrace, (ret == 0));

    GT_1trace (curTrace, GT_LEAVE, "SyslinkMemMgrDrv_ioctl", osStatus);

    /*! @retval 0 Operation successfully completed. */
    return osStatus;
}