| Message ID | 20221216053313.2974826-6-danishanwar@ti.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | Introduce PRU remoteproc consumer API | expand |
Hi Roger, Can you please review this patch. Thanks, Danish. On 16/12/22 11:03, MD Danish Anwar wrote: > From: Roger Quadros <rogerq@ti.com> > > Some firmwares expect the OS drivers to configure the CTABLE > entries publishing dynamically allocated memory regions. For > example, the PRU Ethernet firmwares use the C28 and C30 entries > for retrieving the Shared RAM and System SRAM (OCMC) areas > allocated by the PRU Ethernet client driver. > > Provide a way for users to do that through a new API, > pru_rproc_set_ctable(). The API returns 0 on success and > a negative value on error. > > NOTE: > The programmable CTABLE entries are typically re-programmed by > the PRU firmwares when dealing with a certain block of memory > during block processing. This API provides an interface to the > PRU client drivers to publish a dynamically allocated memory > block with the PRU firmware using a CTABLE entry instead of a > negotiated address in shared memory. Additional synchronization > may be needed between the PRU client drivers and firmwares if > different addresses needs to be published at run-time reusing > the same CTABLE entry. > > CTABLE for stands for "constant table". > Each CTable entry just holds the upper address bits so PRU can > reference to external memory with larger address bits. > > For use case please see > prueth_sw_emac_config() in "drivers/net/ethernet/ti/prueth_switch.c" > > /* Set in constant table C28 of PRUn to ICSS Shared memory */ > pru_rproc_set_ctable(prueth->pru0, PRU_C28, sharedramaddr); > pru_rproc_set_ctable(prueth->pru1, PRU_C28, sharedramaddr); > > /* Set in constant table C30 of PRUn to OCMC memory */ > pru_rproc_set_ctable(prueth->pru0, PRU_C30, ocmcaddr); > pru_rproc_set_ctable(prueth->pru1, PRU_C30, ocmcaddr); > > Signed-off-by: Andrew F. Davis <afd@ti.com> > Signed-off-by: Suman Anna <s-anna@ti.com> > Signed-off-by: Roger Quadros <rogerq@ti.com> > Signed-off-by: Grzegorz Jaszczyk <grzegorz.jaszczyk@linaro.org> > Signed-off-by: MD Danish Anwar <danishanwar@ti.com> > --- > drivers/remoteproc/pru_rproc.c | 59 ++++++++++++++++++++++++++++++++++ > include/linux/pruss.h | 22 +++++++++++++ > 2 files changed, 81 insertions(+) > > diff --git a/drivers/remoteproc/pru_rproc.c b/drivers/remoteproc/pru_rproc.c > index 8e2fbe392ef3..176186882acf 100644 > --- a/drivers/remoteproc/pru_rproc.c > +++ b/drivers/remoteproc/pru_rproc.c > @@ -120,6 +120,7 @@ struct pru_private_data { > * @mapped_irq: virtual interrupt numbers of created fw specific mapping > * @pru_interrupt_map: pointer to interrupt mapping description (firmware) > * @pru_interrupt_map_sz: pru_interrupt_map size > + * @rmw_lock: lock for read, modify, write operations on registers > * @dbg_single_step: debug state variable to set PRU into single step mode > * @dbg_continuous: debug state variable to restore PRU execution mode > * @evt_count: number of mapped events > @@ -137,6 +138,7 @@ struct pru_rproc { > unsigned int *mapped_irq; > struct pru_irq_rsc *pru_interrupt_map; > size_t pru_interrupt_map_sz; > + spinlock_t rmw_lock; > u32 dbg_single_step; > u32 dbg_continuous; > u8 evt_count; > @@ -153,6 +155,23 @@ void pru_control_write_reg(struct pru_rproc *pru, unsigned int reg, u32 val) > writel_relaxed(val, pru->mem_regions[PRU_IOMEM_CTRL].va + reg); > } > > +static inline > +void pru_control_set_reg(struct pru_rproc *pru, unsigned int reg, > + u32 mask, u32 set) > +{ > + u32 val; > + unsigned long flags; > + > + spin_lock_irqsave(&pru->rmw_lock, flags); > + > + val = pru_control_read_reg(pru, reg); > + val &= ~mask; > + val |= (set & mask); > + pru_control_write_reg(pru, reg, val); > + > + spin_unlock_irqrestore(&pru->rmw_lock, flags); > +} > + > static struct rproc *__pru_rproc_get(struct device_node *np, int index) > { > struct rproc *rproc; > @@ -269,6 +288,45 @@ void pru_rproc_put(struct rproc *rproc) > } > EXPORT_SYMBOL_GPL(pru_rproc_put); > > +/** > + * pru_rproc_set_ctable() - set the constant table index for the PRU > + * @rproc: the rproc instance of the PRU > + * @c: constant table index to set > + * @addr: physical address to set it to > + * > + * Return: 0 on success, or errno in error case. > + */ > +int pru_rproc_set_ctable(struct rproc *rproc, enum pru_ctable_idx c, u32 addr) > +{ > + struct pru_rproc *pru = rproc->priv; > + unsigned int reg; > + u32 mask, set; > + u16 idx; > + u16 idx_mask; > + > + if (IS_ERR_OR_NULL(rproc)) > + return -EINVAL; > + > + if (!rproc->dev.parent || !is_pru_rproc(rproc->dev.parent)) > + return -ENODEV; > + > + /* pointer is 16 bit and index is 8-bit so mask out the rest */ > + idx_mask = (c >= PRU_C28) ? 0xFFFF : 0xFF; > + > + /* ctable uses bit 8 and upwards only */ > + idx = (addr >> 8) & idx_mask; > + > + /* configurable ctable (i.e. C24) starts at PRU_CTRL_CTBIR0 */ > + reg = PRU_CTRL_CTBIR0 + 4 * (c >> 1); > + mask = idx_mask << (16 * (c & 1)); > + set = idx << (16 * (c & 1)); > + > + pru_control_set_reg(pru, reg, mask, set); > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(pru_rproc_set_ctable); > + > static inline u32 pru_debug_read_reg(struct pru_rproc *pru, unsigned int reg) > { > return readl_relaxed(pru->mem_regions[PRU_IOMEM_DEBUG].va + reg); > @@ -940,6 +998,7 @@ static int pru_rproc_probe(struct platform_device *pdev) > pru->rproc = rproc; > pru->fw_name = fw_name; > pru->client_np = NULL; > + spin_lock_init(&pru->rmw_lock); > mutex_init(&pru->lock); > > for (i = 0; i < ARRAY_SIZE(mem_names); i++) { > diff --git a/include/linux/pruss.h b/include/linux/pruss.h > index 6ea737e995e9..a6bc3df92fee 100644 > --- a/include/linux/pruss.h > +++ b/include/linux/pruss.h > @@ -28,13 +28,29 @@ enum pruss_pru_id { > PRUSS_NUM_PRUS, > }; > > +/* > + * enum pru_ctable_idx - Configurable Constant table index identifiers > + */ > +enum pru_ctable_idx { > + PRU_C24 = 0, > + PRU_C25, > + PRU_C26, > + PRU_C27, > + PRU_C28, > + PRU_C29, > + PRU_C30, > + PRU_C31, > +}; > + > struct device_node; > +struct rproc; > > #if IS_ENABLED(CONFIG_PRU_REMOTEPROC) > > struct rproc *pru_rproc_get(struct device_node *np, int index, > enum pruss_pru_id *pru_id); > void pru_rproc_put(struct rproc *rproc); > +int pru_rproc_set_ctable(struct rproc *rproc, enum pru_ctable_idx c, u32 addr); > > #else > > @@ -46,6 +62,12 @@ pru_rproc_get(struct device_node *np, int index, enum pruss_pru_id *pru_id) > > static inline void pru_rproc_put(struct rproc *rproc) { } > > +static inline int pru_rproc_set_ctable(struct rproc *rproc, > + enum pru_ctable_idx c, u32 addr) > +{ > + return -EOPNOTSUPP; > +} > + > #endif /* CONFIG_PRU_REMOTEPROC */ > > static inline bool is_pru_rproc(struct device *dev)
Hi Danish, On 23/12/2022 12:58, Md Danish Anwar wrote: > Hi Roger, > > Can you please review this patch. I am the author of that patch so my review tag will be kind or worthless. ;) cheers, -roger > > Thanks, > Danish. > > On 16/12/22 11:03, MD Danish Anwar wrote: >> From: Roger Quadros <rogerq@ti.com> >> >> Some firmwares expect the OS drivers to configure the CTABLE >> entries publishing dynamically allocated memory regions. For >> example, the PRU Ethernet firmwares use the C28 and C30 entries >> for retrieving the Shared RAM and System SRAM (OCMC) areas >> allocated by the PRU Ethernet client driver. >> >> Provide a way for users to do that through a new API, >> pru_rproc_set_ctable(). The API returns 0 on success and >> a negative value on error. >> >> NOTE: >> The programmable CTABLE entries are typically re-programmed by >> the PRU firmwares when dealing with a certain block of memory >> during block processing. This API provides an interface to the >> PRU client drivers to publish a dynamically allocated memory >> block with the PRU firmware using a CTABLE entry instead of a >> negotiated address in shared memory. Additional synchronization >> may be needed between the PRU client drivers and firmwares if >> different addresses needs to be published at run-time reusing >> the same CTABLE entry. >> >> CTABLE for stands for "constant table". >> Each CTable entry just holds the upper address bits so PRU can >> reference to external memory with larger address bits. >> >> For use case please see >> prueth_sw_emac_config() in "drivers/net/ethernet/ti/prueth_switch.c" >> >> /* Set in constant table C28 of PRUn to ICSS Shared memory */ >> pru_rproc_set_ctable(prueth->pru0, PRU_C28, sharedramaddr); >> pru_rproc_set_ctable(prueth->pru1, PRU_C28, sharedramaddr); >> >> /* Set in constant table C30 of PRUn to OCMC memory */ >> pru_rproc_set_ctable(prueth->pru0, PRU_C30, ocmcaddr); >> pru_rproc_set_ctable(prueth->pru1, PRU_C30, ocmcaddr); >> >> Signed-off-by: Andrew F. Davis <afd@ti.com> >> Signed-off-by: Suman Anna <s-anna@ti.com> >> Signed-off-by: Roger Quadros <rogerq@ti.com> >> Signed-off-by: Grzegorz Jaszczyk <grzegorz.jaszczyk@linaro.org> >> Signed-off-by: MD Danish Anwar <danishanwar@ti.com> >> --- >> drivers/remoteproc/pru_rproc.c | 59 ++++++++++++++++++++++++++++++++++ >> include/linux/pruss.h | 22 +++++++++++++ >> 2 files changed, 81 insertions(+) >> >> diff --git a/drivers/remoteproc/pru_rproc.c b/drivers/remoteproc/pru_rproc.c >> index 8e2fbe392ef3..176186882acf 100644 >> --- a/drivers/remoteproc/pru_rproc.c >> +++ b/drivers/remoteproc/pru_rproc.c >> @@ -120,6 +120,7 @@ struct pru_private_data { >> * @mapped_irq: virtual interrupt numbers of created fw specific mapping >> * @pru_interrupt_map: pointer to interrupt mapping description (firmware) >> * @pru_interrupt_map_sz: pru_interrupt_map size >> + * @rmw_lock: lock for read, modify, write operations on registers >> * @dbg_single_step: debug state variable to set PRU into single step mode >> * @dbg_continuous: debug state variable to restore PRU execution mode >> * @evt_count: number of mapped events >> @@ -137,6 +138,7 @@ struct pru_rproc { >> unsigned int *mapped_irq; >> struct pru_irq_rsc *pru_interrupt_map; >> size_t pru_interrupt_map_sz; >> + spinlock_t rmw_lock; >> u32 dbg_single_step; >> u32 dbg_continuous; >> u8 evt_count; >> @@ -153,6 +155,23 @@ void pru_control_write_reg(struct pru_rproc *pru, unsigned int reg, u32 val) >> writel_relaxed(val, pru->mem_regions[PRU_IOMEM_CTRL].va + reg); >> } >> >> +static inline >> +void pru_control_set_reg(struct pru_rproc *pru, unsigned int reg, >> + u32 mask, u32 set) >> +{ >> + u32 val; >> + unsigned long flags; >> + >> + spin_lock_irqsave(&pru->rmw_lock, flags); >> + >> + val = pru_control_read_reg(pru, reg); >> + val &= ~mask; >> + val |= (set & mask); >> + pru_control_write_reg(pru, reg, val); >> + >> + spin_unlock_irqrestore(&pru->rmw_lock, flags); >> +} >> + >> static struct rproc *__pru_rproc_get(struct device_node *np, int index) >> { >> struct rproc *rproc; >> @@ -269,6 +288,45 @@ void pru_rproc_put(struct rproc *rproc) >> } >> EXPORT_SYMBOL_GPL(pru_rproc_put); >> >> +/** >> + * pru_rproc_set_ctable() - set the constant table index for the PRU >> + * @rproc: the rproc instance of the PRU >> + * @c: constant table index to set >> + * @addr: physical address to set it to >> + * >> + * Return: 0 on success, or errno in error case. >> + */ >> +int pru_rproc_set_ctable(struct rproc *rproc, enum pru_ctable_idx c, u32 addr) >> +{ >> + struct pru_rproc *pru = rproc->priv; >> + unsigned int reg; >> + u32 mask, set; >> + u16 idx; >> + u16 idx_mask; >> + >> + if (IS_ERR_OR_NULL(rproc)) >> + return -EINVAL; >> + >> + if (!rproc->dev.parent || !is_pru_rproc(rproc->dev.parent)) >> + return -ENODEV; >> + >> + /* pointer is 16 bit and index is 8-bit so mask out the rest */ >> + idx_mask = (c >= PRU_C28) ? 0xFFFF : 0xFF; >> + >> + /* ctable uses bit 8 and upwards only */ >> + idx = (addr >> 8) & idx_mask; >> + >> + /* configurable ctable (i.e. C24) starts at PRU_CTRL_CTBIR0 */ >> + reg = PRU_CTRL_CTBIR0 + 4 * (c >> 1); >> + mask = idx_mask << (16 * (c & 1)); >> + set = idx << (16 * (c & 1)); >> + >> + pru_control_set_reg(pru, reg, mask, set); >> + >> + return 0; >> +} >> +EXPORT_SYMBOL_GPL(pru_rproc_set_ctable); >> + >> static inline u32 pru_debug_read_reg(struct pru_rproc *pru, unsigned int reg) >> { >> return readl_relaxed(pru->mem_regions[PRU_IOMEM_DEBUG].va + reg); >> @@ -940,6 +998,7 @@ static int pru_rproc_probe(struct platform_device *pdev) >> pru->rproc = rproc; >> pru->fw_name = fw_name; >> pru->client_np = NULL; >> + spin_lock_init(&pru->rmw_lock); >> mutex_init(&pru->lock); >> >> for (i = 0; i < ARRAY_SIZE(mem_names); i++) { >> diff --git a/include/linux/pruss.h b/include/linux/pruss.h >> index 6ea737e995e9..a6bc3df92fee 100644 >> --- a/include/linux/pruss.h >> +++ b/include/linux/pruss.h >> @@ -28,13 +28,29 @@ enum pruss_pru_id { >> PRUSS_NUM_PRUS, >> }; >> >> +/* >> + * enum pru_ctable_idx - Configurable Constant table index identifiers >> + */ >> +enum pru_ctable_idx { >> + PRU_C24 = 0, >> + PRU_C25, >> + PRU_C26, >> + PRU_C27, >> + PRU_C28, >> + PRU_C29, >> + PRU_C30, >> + PRU_C31, >> +}; >> + >> struct device_node; >> +struct rproc; >> >> #if IS_ENABLED(CONFIG_PRU_REMOTEPROC) >> >> struct rproc *pru_rproc_get(struct device_node *np, int index, >> enum pruss_pru_id *pru_id); >> void pru_rproc_put(struct rproc *rproc); >> +int pru_rproc_set_ctable(struct rproc *rproc, enum pru_ctable_idx c, u32 addr); >> >> #else >> >> @@ -46,6 +62,12 @@ pru_rproc_get(struct device_node *np, int index, enum pruss_pru_id *pru_id) >> >> static inline void pru_rproc_put(struct rproc *rproc) { } >> >> +static inline int pru_rproc_set_ctable(struct rproc *rproc, >> + enum pru_ctable_idx c, u32 addr) >> +{ >> + return -EOPNOTSUPP; >> +} >> + >> #endif /* CONFIG_PRU_REMOTEPROC */ >> >> static inline bool is_pru_rproc(struct device *dev)
diff --git a/drivers/remoteproc/pru_rproc.c b/drivers/remoteproc/pru_rproc.c index 8e2fbe392ef3..176186882acf 100644 --- a/drivers/remoteproc/pru_rproc.c +++ b/drivers/remoteproc/pru_rproc.c @@ -120,6 +120,7 @@ struct pru_private_data { * @mapped_irq: virtual interrupt numbers of created fw specific mapping * @pru_interrupt_map: pointer to interrupt mapping description (firmware) * @pru_interrupt_map_sz: pru_interrupt_map size + * @rmw_lock: lock for read, modify, write operations on registers * @dbg_single_step: debug state variable to set PRU into single step mode * @dbg_continuous: debug state variable to restore PRU execution mode * @evt_count: number of mapped events @@ -137,6 +138,7 @@ struct pru_rproc { unsigned int *mapped_irq; struct pru_irq_rsc *pru_interrupt_map; size_t pru_interrupt_map_sz; + spinlock_t rmw_lock; u32 dbg_single_step; u32 dbg_continuous; u8 evt_count; @@ -153,6 +155,23 @@ void pru_control_write_reg(struct pru_rproc *pru, unsigned int reg, u32 val) writel_relaxed(val, pru->mem_regions[PRU_IOMEM_CTRL].va + reg); } +static inline +void pru_control_set_reg(struct pru_rproc *pru, unsigned int reg, + u32 mask, u32 set) +{ + u32 val; + unsigned long flags; + + spin_lock_irqsave(&pru->rmw_lock, flags); + + val = pru_control_read_reg(pru, reg); + val &= ~mask; + val |= (set & mask); + pru_control_write_reg(pru, reg, val); + + spin_unlock_irqrestore(&pru->rmw_lock, flags); +} + static struct rproc *__pru_rproc_get(struct device_node *np, int index) { struct rproc *rproc; @@ -269,6 +288,45 @@ void pru_rproc_put(struct rproc *rproc) } EXPORT_SYMBOL_GPL(pru_rproc_put); +/** + * pru_rproc_set_ctable() - set the constant table index for the PRU + * @rproc: the rproc instance of the PRU + * @c: constant table index to set + * @addr: physical address to set it to + * + * Return: 0 on success, or errno in error case. + */ +int pru_rproc_set_ctable(struct rproc *rproc, enum pru_ctable_idx c, u32 addr) +{ + struct pru_rproc *pru = rproc->priv; + unsigned int reg; + u32 mask, set; + u16 idx; + u16 idx_mask; + + if (IS_ERR_OR_NULL(rproc)) + return -EINVAL; + + if (!rproc->dev.parent || !is_pru_rproc(rproc->dev.parent)) + return -ENODEV; + + /* pointer is 16 bit and index is 8-bit so mask out the rest */ + idx_mask = (c >= PRU_C28) ? 0xFFFF : 0xFF; + + /* ctable uses bit 8 and upwards only */ + idx = (addr >> 8) & idx_mask; + + /* configurable ctable (i.e. C24) starts at PRU_CTRL_CTBIR0 */ + reg = PRU_CTRL_CTBIR0 + 4 * (c >> 1); + mask = idx_mask << (16 * (c & 1)); + set = idx << (16 * (c & 1)); + + pru_control_set_reg(pru, reg, mask, set); + + return 0; +} +EXPORT_SYMBOL_GPL(pru_rproc_set_ctable); + static inline u32 pru_debug_read_reg(struct pru_rproc *pru, unsigned int reg) { return readl_relaxed(pru->mem_regions[PRU_IOMEM_DEBUG].va + reg); @@ -940,6 +998,7 @@ static int pru_rproc_probe(struct platform_device *pdev) pru->rproc = rproc; pru->fw_name = fw_name; pru->client_np = NULL; + spin_lock_init(&pru->rmw_lock); mutex_init(&pru->lock); for (i = 0; i < ARRAY_SIZE(mem_names); i++) { diff --git a/include/linux/pruss.h b/include/linux/pruss.h index 6ea737e995e9..a6bc3df92fee 100644 --- a/include/linux/pruss.h +++ b/include/linux/pruss.h @@ -28,13 +28,29 @@ enum pruss_pru_id { PRUSS_NUM_PRUS, }; +/* + * enum pru_ctable_idx - Configurable Constant table index identifiers + */ +enum pru_ctable_idx { + PRU_C24 = 0, + PRU_C25, + PRU_C26, + PRU_C27, + PRU_C28, + PRU_C29, + PRU_C30, + PRU_C31, +}; + struct device_node; +struct rproc; #if IS_ENABLED(CONFIG_PRU_REMOTEPROC) struct rproc *pru_rproc_get(struct device_node *np, int index, enum pruss_pru_id *pru_id); void pru_rproc_put(struct rproc *rproc); +int pru_rproc_set_ctable(struct rproc *rproc, enum pru_ctable_idx c, u32 addr); #else @@ -46,6 +62,12 @@ pru_rproc_get(struct device_node *np, int index, enum pruss_pru_id *pru_id) static inline void pru_rproc_put(struct rproc *rproc) { } +static inline int pru_rproc_set_ctable(struct rproc *rproc, + enum pru_ctable_idx c, u32 addr) +{ + return -EOPNOTSUPP; +} + #endif /* CONFIG_PRU_REMOTEPROC */ static inline bool is_pru_rproc(struct device *dev)