Merge branch 'master' of https://github.com/RT-Thread/rt-thread

Author: BernardXiong

components/drivers/core/device.c

@@ -13,6 +13,8 @@
  * 2013-07-09     Grissiom     add ref_count support
  * 2016-04-02     Bernard      fix the open_flag initialization issue.
  * 2021-03-19     Meco Man     remove rt_device_init_all()
+ * 2024-09-15     milo         fix log format issue
+ *                             fix reopen with a different oflag issue
  */
 
 #include <rtthread.h>
@@ -195,8 +197,8 @@ rt_err_t rt_device_init(rt_device_t dev)
             result = device_init(dev);
             if (result != RT_EOK)
             {
-                LOG_E("To initialize device:%s failed. The error code is %d",
-                      dev->parent.name, result);
+                LOG_E("To initialize device:%.*s failed. The error code is %d",
+                      RT_NAME_MAX, dev->parent.name, result);
             }
             else
             {
@@ -233,8 +235,8 @@ rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag)
             result = device_init(dev);
             if (result != RT_EOK)
             {
-                LOG_E("To initialize device:%s failed. The error code is %d",
-                      dev->parent.name, result);
+                LOG_E("To initialize device:%.*s failed. The error code is %d",
+                      RT_NAME_MAX, dev->parent.name, result);
 
                 return result;
             }
@@ -252,7 +254,7 @@ rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag)
 
     /* device is not opened or opened by other oflag, call device_open interface */
     if (!(dev->open_flag & RT_DEVICE_OFLAG_OPEN) ||
-         ((dev->open_flag & RT_DEVICE_OFLAG_MASK) != (oflag & RT_DEVICE_OFLAG_MASK)))
+         ((dev->open_flag & RT_DEVICE_OFLAG_MASK) != ((oflag & RT_DEVICE_OFLAG_MASK) | RT_DEVICE_OFLAG_OPEN)))
     {
         if (device_open != RT_NULL)
         {

components/drivers/include/drivers/adc.h

@@ -14,20 +14,75 @@
 #define __ADC_H__
 
 #include <rtthread.h>
+/**
+ * @addtogroup  Drivers          RTTHREAD Driver
+ * @defgroup    ADC           ADC
+ *
+ * @brief       ADC driver api
+ *
+ * <b>Example</b>
+ * @code {.c}
+ * #define ADC_DEV_NAME        "adc1"      
+ * #define ADC_DEV_CHANNEL     5    
+ * #define REFER_VOLTAGE       330         
+ * #define CONVERT_BITS        (1 << 12)   
+ * 
+ * static int adc_vol_sample(int argc, char *argv[])
+ * {
+ *     rt_adc_device_t adc_dev;
+ *     rt_uint32_t value, vol;
+ * 
+ *     rt_err_t ret = RT_EOK;
+ * 
+ *     adc_dev = (rt_adc_device_t)rt_device_find(ADC_DEV_NAME);
+ *     if (adc_dev == RT_NULL)
+ *     {
+ *         rt_kprintf("adc sample run failed! can't find %s device!\n", ADC_DEV_NAME);
+ *         return RT_ERROR;
+ *     }
+ * 
+ *     ret = rt_adc_enable(adc_dev, ADC_DEV_CHANNEL);
+ * 
+ *     value = rt_adc_read(adc_dev, ADC_DEV_CHANNEL);
+ *     rt_kprintf("the value is :%d \n", value);
+ * 
+ *     vol = value * REFER_VOLTAGE / CONVERT_BITS;
+ *     rt_kprintf("the voltage is :%d.%02d \n", vol / 100, vol % 100);
+ * 
+ *     ret = rt_adc_disable(adc_dev, ADC_DEV_CHANNEL);
+ * 
+ *     return ret;
+ * }
+ * MSH_CMD_EXPORT(adc_vol_sample, adc voltage convert sample);
+ *       
+ * @endcode
+ *
+ * @ingroup     Drivers
+ */
+
 
+/*!
+ * @addtogroup ADC
+ * @{
+ */
 #define RT_ADC_INTERN_CH_TEMPER     (-1)
 #define RT_ADC_INTERN_CH_VREF       (-2)
 #define RT_ADC_INTERN_CH_VBAT       (-3)
 
 struct rt_adc_device;
+/**
+ * @brief Configure the adc device
+ */
 struct rt_adc_ops
 {
     rt_err_t (*enabled)(struct rt_adc_device *device, rt_int8_t channel, rt_bool_t enabled);
     rt_err_t (*convert)(struct rt_adc_device *device, rt_int8_t channel, rt_uint32_t *value);
     rt_uint8_t (*get_resolution)(struct rt_adc_device *device);
     rt_int16_t (*get_vref) (struct rt_adc_device *device);
 };
-
+/**
+ * @brief adc device
+ */
 struct rt_adc_device
 {
     struct rt_device parent;
@@ -43,10 +98,51 @@ typedef enum
     RT_ADC_CMD_GET_VREF = RT_DEVICE_CTRL_BASE(ADC) + 4, /* get reference voltage */
 } rt_adc_cmd_t;
 
+/**
+ * @brief register the adc device
+ * @param adc adc device
+ * @param name device name
+ * @param ops device ops
+ * @param user_data device private data
+ * @return rt_err_t        error code
+ * @ingroup  ADC
+ */
 rt_err_t rt_hw_adc_register(rt_adc_device_t adc,const char *name, const struct rt_adc_ops *ops, const void *user_data);
+
+/**
+ * @brief read the adc value
+ * @param dev adc device
+ * @param channel adc channel
+ * @return rt_uint32_t adc value
+ * @ingroup  ADC
+ */
 rt_uint32_t rt_adc_read(rt_adc_device_t dev, rt_int8_t channel);
+
+/**
+ * @brief enable the adc channel
+ * @param dev adc device
+ * @param channel adc channel
+ * @return rt_err_t error code
+ * @ingroup  ADC
+ */
 rt_err_t rt_adc_enable(rt_adc_device_t dev, rt_int8_t channel);
+
+/**
+ * @brief disable the adc channel
+ * @param dev adc device
+ * @param channel adc channel
+ * @return rt_err_t error code
+ * @ingroup  ADC
+ */
 rt_err_t rt_adc_disable(rt_adc_device_t dev, rt_int8_t channel);
+
+/**
+ * @brief get the adc resolution
+ * @param dev adc device
+ * @param channel adc channel
+ * @return rt_int16_t adc resolution
+ * @ingroup  ADC
+ */
 rt_int16_t rt_adc_voltage(rt_adc_device_t dev, rt_int8_t channel);
 
 #endif /* __ADC_H__ */

components/drivers/include/drivers/pic.h

@@ -148,6 +148,7 @@ void rt_pic_default_name(struct rt_pic *pic);
 struct rt_pic *rt_pic_dynamic_cast(void *ptr);
 
 rt_err_t rt_pic_linear_irq(struct rt_pic *pic, rt_size_t irq_nr);
+rt_err_t rt_pic_cancel_irq(struct rt_pic *pic);
 
 int rt_pic_config_ipi(struct rt_pic *pic, int ipi_index, int hwirq);
 int rt_pic_config_irq(struct rt_pic *pic, int irq_index, int hwirq);

components/drivers/ofw/fdt.c

@@ -85,15 +85,15 @@ rt_uint64_t rt_fdt_translate_address(void *fdt, int nodeoffset, rt_uint64_t addr
 
         if (parent >= 0)
         {
-            ranges = fdt_getprop(fdt, nodeoffset, "ranges", &length);
+            ranges = fdt_getprop(fdt, parent, "ranges", &length);
         }
 
         if (ranges && length > 0)
         {
-            local.addr_cells = fdt_address_cells(fdt, nodeoffset);
-            local.size_cells = fdt_size_cells(fdt, nodeoffset);
-            cpu.addr_cells = fdt_io_addr_cells(fdt, nodeoffset);
-            cpu.size_cells = fdt_io_size_cells(fdt, nodeoffset);
+            local.addr_cells = fdt_address_cells(fdt, parent);
+            local.size_cells = fdt_size_cells(fdt, parent);
+            cpu.addr_cells = fdt_io_addr_cells(fdt, parent);
+            cpu.size_cells = fdt_io_size_cells(fdt, parent);
 
             group_len = local.addr_cells + cpu.addr_cells + local.size_cells;
 
@@ -105,7 +105,7 @@ rt_uint64_t rt_fdt_translate_address(void *fdt, int nodeoffset, rt_uint64_t addr
 
                 if (local.addr <= address && local.addr + local.size > address)
                 {
-                    ret += address - cpu.addr;
+                    ret = address - local.addr + cpu.addr;
                     break;
                 }
 
@@ -247,9 +247,9 @@ static rt_err_t fdt_reserved_memory_reg(int nodeoffset, const char *uname)
 
                 rt_bool_t is_nomap = fdt_getprop(_fdt, nodeoffset, "no-map", RT_NULL) ? RT_TRUE : RT_FALSE;
                 base = rt_fdt_translate_address(_fdt, nodeoffset, base);
-                rt_memblock_reserve_memory(uname, base, base + size, is_nomap);
 
-                len -= t_len;
+                rt_memblock_reserve_memory(fdt_get_name(_fdt, nodeoffset, RT_NULL),
+                        base, base + size, is_nomap);
             }
         }
     }

components/drivers/pic/Kconfig

@@ -1,6 +1,7 @@
 menuconfig RT_USING_PIC
     bool "Using Programmable Interrupt Controller (PIC)"
-    select RT_USING_BITMAP
+    select RT_USING_ADT
+    select RT_USING_ADT_BITMAP
     depends on RT_USING_DM
     default n
 
@@ -22,12 +23,31 @@ config RT_PIC_ARM_GIC
     select RT_USING_OFW
     default n
 
+config RT_PIC_ARM_GIC_V2M
+    bool "ARM GIC V2M" if RT_PIC_ARM_GIC && RT_PCI_MSI
+    depends on RT_USING_OFW
+    default n
+
 config RT_PIC_ARM_GIC_V3
     bool "ARM GICv3"
     depends on RT_USING_PIC
     select RT_USING_OFW
     default n
 
+config RT_PIC_ARM_GIC_V3_ITS
+    bool "ARM GICv3 ITS (Interrupt Translation Service)" if RT_PIC_ARM_GIC_V3 && RT_PCI_MSI
+    depends on RT_USING_OFW
+    select RT_USING_ADT_REF
+    default n
+
+config RT_PIC_ARM_GIC_V3_ITS_IRQ_MAX
+    int "IRQ maximum used"
+    depends on RT_PIC_ARM_GIC_V3_ITS
+    default 127 if ARCH_CPU_64BIT
+    default 63
+    help
+      Recommended to be based on the bit length (full bits) of maximum usage.
+
 config RT_PIC_ARM_GIC_MAX_NR
     int
     depends on RT_USING_PIC

components/drivers/pic/SConscript

@@ -16,9 +16,15 @@ if GetDepend(['RT_PIC_ARM_GIC']) or GetDepend(['RT_PIC_ARM_GIC_V3']):
 if GetDepend(['RT_PIC_ARM_GIC']):
     src += ['pic-gicv2.c']
 
+if GetDepend(['RT_PIC_ARM_GIC_V2M']):
+    src += ['pic-gicv2m.c']
+
 if GetDepend(['RT_PIC_ARM_GIC_V3']):
     src += ['pic-gicv3.c']
 
+if GetDepend(['RT_PIC_ARM_GIC_V3_ITS']):
+    src += ['pic-gicv3-its.c']
+
 group = DefineGroup('DeviceDrivers', src, depend = [''], CPPPATH = CPPPATH)
 
 Return('group')

components/drivers/pic/pic-gic-common.h

@@ -8,10 +8,14 @@
  * 2023-01-30     GuEe-GUI     first version
  */
 
-#ifndef __IRQ_GIC_COMMON_H__
-#define __IRQ_GIC_COMMON_H__
+#ifndef __PIC_GIC_COMMON_H__
+#define __PIC_GIC_COMMON_H__
 
 #include <rtdef.h>
+
+#ifdef RT_PCI_MSI
+#include <drivers/pci_msi.h>
+#endif
 #include <drivers/ofw.h>
 
 #define GIC_SGI_NR  16
@@ -52,4 +56,4 @@ rt_err_t gicv2m_ofw_probe(struct rt_ofw_node *ic_np, const struct rt_ofw_node_id
 rt_err_t gicv3_its_ofw_probe(struct rt_ofw_node *ic_np, const struct rt_ofw_node_id *id);
 #endif
 
-#endif /* __IRQ_GIC_COMMON_H__ */
+#endif /* __PIC_GIC_COMMON_H__ */

components/drivers/pic/pic-gicv2.c

@@ -128,6 +128,8 @@ static void gicv2_cpu_init(struct gicv2 *gic)
 
 #ifdef ARCH_SUPPORT_HYP
     _gicv2_eoi_mode_ns = RT_TRUE;
+#else
+    _gicv2_eoi_mode_ns = !!rt_ofw_bootargs_select("pic.gicv2_eoimode", 0);
 #endif
 
     if (_gicv2_eoi_mode_ns)