Drivers FSP

Posted on  by



  • Choose a tag to compare
  • Choose a tag to compare
Drivers

Product Details. Introducing Mystery FSP MX-7 Driver Shaft. A long shaft that can swing unexpectedly. High- performance shaft excellent in flight distance performance and directionality that has both flexibility and high robustness that does not lose even high head speed. Triple-biasing structure using 5 framing cloth and PAN-based high resilient sheet arranged on the entire length. A file system driver can map the user buffers into kernel memory space before posting to the FSP so the buffers can be accessed later by a system worker thread (FSP). The method commonly used by file system drivers is to lock the user buffers in the FSP because the memory pages can always be mapped later by the system worker thread.

  • Ian Abbott A Freeway Service Patrol driver was killed in Woodside, Calif. On Tuesday, June 23, 2020 when a lumber truck crashed into the FSP vehicle on Interstate Highway 280. A lumber truck was traveling south when it left the road and crashed into the FSP truck and the driver. FSP drivers help motorists during commute hours by providing gas, for example, to motorists who run out.
  • Mini Driver Async RS232 Extender over CATx - Multipoint, DB25 Female to Terminal Block ITEM# ME771A-FSP-R2 Extend async RS-232 data beyond the 50 ft limitation over CATx at data rates up to 115.2 kbps and reach distances up to 3 miles in point to point or multipoint environments.
  • News & Events 40 Amp, 3400 Watt Electric Vehicle Charger for Lithium Ion Applications with CAN and IP66 Rating with New Option for 72V batteries (5584Vo). 40 Amp, 3400 Watt Electric Vehicle Charger for Lithium.

renesas-fsp-development released this Oct 28, 2020 · 6 commits to master since this release

Release Notes

Flexible Software Package (FSP) for Renesas RA MCU Family, version 2.1.0.

Download the FSP with e2 studio Installer for this release, setup_fsp_v2_1_0_e2s_v2020-10.exe, from here.

If using IAR or Keil MDK, download the Renesas Advanced Smart Configurator for this release, setup_fsp_v2_1_0_rasc_v2020-11.exe, from here.

All installers are available in the Assets section of this release.

Refer to the README.md in the FSP root folder for setup instructions, hardware details, and related links.

Tools

Features Added

  • RA6T1 MCU support added.
  • RSSK-RA6T1 Board support added.
  • Motor control middleware added:
    • rm_motor_current
    • rm_motor_driver
    • rm_motor_estimate
    • rm_motor_sensorless
    • rm_motor_speed
  • Added support for using AWS HTTPS Client in FSP projects.
  • USB composite support added:
    • PMSC + PCDC
    • PCDC + PHID
    • PMSC + PHID
    • PCDC + PCDC
  • New BSP API has been added to change OctaSPI Clock at run time. Added fix to clear dummy cycle register when switching from OPI to SPI mode.
  • More hardware acceleration added to mbed-crypto:
    • Added support for AES GCM for 128 and 256 bit keys
    • Added ECDH support
  • Renesas Advanced Smart Configurator (RASC) added tooling support for RA6M4 Arm® TrustZone® for Keil MDK tool and IAR Embedded Workbench.

Third Party Software

These third party software solutions are included alongside FSP.

Bug Fixes

  • R_BLE_L2CAP_RegisterCfPsm() API would get stuck in an infinite loop when registering L2CAP callback function.
  • Disable the use of WiFi API functions WIFI_Scan(), WIFI_Ping(), SOCKETS_GetHostByName(), WIFI_GetMAC(), and WIFI_GetIP() during an active socket connection when using one UART. All open sockets must be closed before these functions are called.
  • Fixed an issue causing LittleFS configuration properties to be applied incorrectly.
  • Exporting a wrapped persistent AES256 key and then re-importing it after destroying the key handle for AES GCM usage did not work.
  • Updated WiFi scan results parser to handle large number of access points without the WIFI_Scan() call returning a failure.
  • Added option in Virtual EEPROM to configure the physical start address. Projects currently using a non-default start address will need to update the RA Configuration editor for the rm_vee_flash module, and re-generate their project content.
  • SSI would generate two TX_EMPTY callbacks per write. Now it generates only one.

Known Issues

  • Issue
    Due to the changes in Linker SCAT file format in FSP 2.x, please ensure that a Keil MDK pack version 2.x is used with FSP 2.x. Failure to do so will cause linker errors. For existing projects based on FSP 1.x please continue to use Keil MDK pack 1.x
  • Issue
    Renesas Advanced Smart Configurator (RASC) for IAR EWARM and Keil MDK work flow has been changed in the 2020-11 version onwards. Refer to the RASC quick start guide attached to this release for the details.
  • Issue
    When debugging a Non Secure project in IAR EWARM, it is necessary to force a hardware reset to pick up the correct reset vector. This can be done by adding the following to the Options | Debugger | Extra Options dialog in EWARM: --drv_vector_table_base=0x0
  • Issue
    When debugging a 'flat' (non-TrustZone) project in IAR EWARM with a device that supports TrustZone, the device partition sizes are always reported as needing to be updated. This can be worked around by unchecking the 'Use macro file(s)' check box in the Options | Debugger | Setup dialog in EWARM and setting device partition sizes manually (if required) with the Renesas Device Partition Manager.
  • Issue
    When building TrustZone secure projects with the IAR compiler using -O1 (Low) optimization, there is a linker error from bsp_security.c.
    Workaround
    Build with -Oh (High, Balanced) optimization. Select the project or the file bsp_security.c and select 'High' and 'Balanced' from Options | C/C++ Compiler | Optimizations. Check 'Override inherited settings' to change the setting for bsp_security.c only.
  • Issue
    mbedTLS can run on RA6M4 using software crypto only.
  • Issue
    USB_VBUS pin (P4_07) is not available to configure through the pin configurator for the RA4W1.
    Workaround
    Use the R_IOPORT_PinCfg() function to configure the USB_VBUS pin (P4_07).
  • Issue
    Mbed Crypto is currently not thread safe when being used standalone (ie: as top of stack) in a FreeRTOS project.
    Workaround
    The user should add a mutex around calls to Mbed Crypto.
  • Issue
    In some cases GCC is removing debug information for functions in a Secure project. This is being actively investigated.
  • Issue
    When creating services for a custom profile in the R_BLE Custom Profile RA (QE) View, if you create multiple services with the same UUID or the same abbreviation, the GUI may behave incorrectly.
    Workaround
    Do not use duplicate UUIDs or abbreviation.
  • Issue
    USB driver jumps to the default hander when closing either USB IP0 or USB IP1 module by calling R_USB_Close function while HMSC and PCDC are working.
  • Issue
    The USB driver does not work properly when the USB interrupt priority level is higher priority than the configMAX_SYSCALL_INTERRUPT_PRIORITY macro value.
    Workaround
    Specify a lower priority for the USB interrupt priority than the configMAX_SYSCALL_INTERRUPT_PRIORITY macro value.
  • Issue
    In the write completion event of PCDC + PCDC composite class, 'USB_CLASS_PCDC2' is not set to the member 'type' of 'usb_event_info' structure.
    Workaround
    Please use the member 'pipe' in 'usb_event_info' structure to determine the PCDC channel number after the write event is completed in PCDC + PCDC.
  • Issue
    An error is output when selecting DMA feature in RA configuration of USB composite class. Please ignore this error.
  • Issue
    Dividers >= 20 for Bus Timing > QSPKCLK Divisor are off by 1.
    Workaround
    When selecting a divider >= 20 for Bus Timing > QSPKCLK Divisor, select the next available smaller divider. Do not select the maximum divider of 48.

Knowledge Base

MD5 Checksums

  • FSP_Packs_v2.1.0.zip dd2f3366bff68fcbad0c2add3a6bf035
  • FSP_Packs_v2.1.0.exe b40ff9df82a35ba77b087afc85df04bf
  • fsp_documentation_v2.1.0.zip dd0e13ea93a84249e63e5ec8dc326398
  • setup_fsp_v2_1_0_e2s_v2020-10.exe 4f3c83f3ab5b767e7aa805b11225a075
  • setup_fsp_v2_1_0_rasc_v2020-11.exe 2f987d6a46269e9c7306358ee30dd41d
  • MDK_Device_Packs_v2.1.0.zip 88e3d2a6393777d0302f8219f3995375
  • rasc_quick_start_fsp_v2_1_0_rasc_v2020-11.zip d2118374b488025d8c48b89fb71dd963
FSP_Packs_v2.1.0.exe51.8 MB
MDK_Device_Packs_v2.1.0.zip1.37 MB
rasc_quick_start_fsp_v2_1_0_rasc_v2020-11.zip141 KB
setup_fsp_v2_1_0_rasc_v2020-11.exe545 MB
-->

Most of the file operations performed by a file system driver are usually completed in the user's thread context. These operations include all of the synchronous file I/O calls to the file system. In these cases, all of the work is done inline. The operation might block in the kernel, but the work is performed on the same thread. File systems on Windows often call this work using the user's thread context as the File System Dispatch (FSD). Most of the time, a file system will try to complete its work in the FSD.

Drivers FSP

There are some cases where an application does not want to block (asynchronous reads or asynchronous writes, for example). In these cases, the file I/O operation needs to be dispatched to a system worker thread for completion. File systems on Windows often call this work using a system worker thread context as the File System Process (FSP). The following example of an asynchronous IRP_MJ_WRITE request sent to a network mini-redirector illustrates a case where the FSP needs to be used.

To execute an asynchronous IRP_MJ_WRITE request, RDBSS or a network mini-redirector needs to acquire the file object's FCB resource (a synchronization object used for changing the file object). When the FCB resource is already held by another thread and RDBSS or the network mini-redirector try to acquire the FCB resource in the user's thread context (the FSD), this operation will block. Asynchronous requests to a file system are not supposed to block. For asynchronous requests (IRP_MJ_WRITE request, for example), a file system driver will first check if the needed resource is available (the FCB resource for a network mini-redirector, for example). If the resource is not available, then the file system driver posts the request to a work queue for later completion by a system worker thread (the FSP) and the file system returns STATUS_PENDING from the FSD thread. To the user application, the FSD will return STATUS_PENDING immediately, while the actual work will be handled by a system worker thread in the FSP.

Several tasks must be completed before a file system driver posts work to the FSP. The file system driver needs to capture the security context from the user's thread in the FSD since the work will be completed by a system worker thread. RDBSS does this automatically in the RxFsdPostRequest routine for network mini-redirectors. This routine is called by RDBSS whenever a network mini-redirector returns STATUS_PENDING with the PostRequest member of the RX_CONTEXT structure set to TRUE. If work is posted to a work queue, the file system driver must also make sure that the user buffers will be available for later use by the system worker thread. There are two methods to accomplish this task:

  1. A file system driver can map the user buffers into kernel memory space before posting to the FSP so the buffers can be accessed later by a system worker thread (FSP). The method commonly used by file system drivers is to lock the user buffers in the FSP because the memory pages can always be mapped later by the system worker thread.

  2. A file system can save the thread of the calling process from the FSP and the system worker thread can attach to this calling process while in the FSP. Using the KeStackAttachProcess, the system worker thread would attach to the user's calling process and access the user buffers and then detach from the user's calling process using KeUnstackDetachProcess when the work is done.

RDBSS will automatically lock user buffers using method 1 in the RxFsdPostRequest routine for a number of IRP requests as long as the RX_CONTEXT_FLAG_NO_PREPOSTING_NEEDED bit is not set in the Flags member of the RX_CONTEXT structure. User buffers will be locked for the following requests:

Fsp Drivers

  • IRP_MJ_DIRECTORY_CONTROL with a minor function of IRP_MN_QUERY_DIRECTORY

  • IRP_MJ_QUERY_EA

  • IRP_MJ_READ as long as the minor function does not include IRP_MN_MDL

  • IRP_MJ_SET_EA Download Ec Printer drivers.

  • IRP_MJ_WRITE as long as the minor function does not include IRP_MN_MDL

Method 2 is commonly used for processing IRPs that use METHOD_NEITHER when only a small amount of information is normally passed and returned. These IRPs would include the following:

  • IRP_MJ_DEVICE_CONTROL

  • IRP_MJ_FILE_SYSTEM_CONTROL

  • IRP_MJ_INTERNAL_DEVICE_CONTROL

Drivers Spread

RDBSS only supports asynchronous calls for the MrxLowIoSubmit array of operations. If a network mini-redirector wants to implement other operations (MRxQueryFileInfo, for example) as an asynchronous call, the network mini-redirector needs to post the request to the FSP. If a network mini-redirector receives a request for MrxQueryFileInfo with the RX_CONTEXT_ASYNC_OPERATION bit set in the Flags member of the RX_CONTEXT structure, the network mini-redirector would need to post this request to the FSP for asynchronous operation. In the operation of the MrxQueryFileInfo routine, the network mini-redirector would first need to capture the security context of the user's thread and map the user buffers into kernel space (or set the system worker thread to attach to the user's calling process while executing in the FSP). Then the network mini-redirector would set the PostRequest member of the RX_CONTEXT structure to TRUE and return STATUS_PENDING from the FSD. The work would be dispatched by RDBSS to a work queue for operation by a system worker thread (the FSP).