Re: GTE - The hardware timestamping engine
On 3/23/21 3:06 AM, Thierry Reding wrote: > On Tue, Mar 23, 2021 at 10:08:00AM +0100, Linus Walleij wrote: >> On Mon, Mar 22, 2021 at 9:17 PM Dipen Patel wrote: >> >>> My follow-up concerns on both Linus's and Kent's feedback: >>> >>> 1. Please correct me if I am wrong, lineevent in the gpiolib* is only >>> serves the userspace clients. >>> 1.a What about kernel drivers wanting to use this feature for monitoring its >>> GPIO lines, see gyroscope example somewhere below. In that regards, >>> lineevent implementation is not sufficient. >>> 1.b Are you also implying to extend lineevent implementation to kernel >>> drivers? >> >> I was talking about lineevent because you mentioned things like >> motors and robotics, and those things are traditionally not run in >> kernelspace because they are not generic hardware that fit in the >> kernel subsystems. >> >> Normally industrial automatic control tasks are run in a userspace >> thread with some realtime priority. >> >> As Kent says, in-kernel events are exclusively using IRQ as >> mechanism, and should be modeled as IRQs. Then the question >> is how you join the timestamp with the IRQ. GPIO chips are >> just some kind of irqchip in this regard, we reuse the irqchip >> infrastructure in the kernel for all GPIO drivers that generate >> "events" in response to state transitions on digital lines. > > One potential problem I see with this is that Kent's proposal, if I > understand correctly, would supplant the original IRQ of a device with > the GTE IRQ for the corresponding event. I'm not sure that's desirable > because that would require modifying the device tree and would no longer > accurately represent the hardware. Timestamping also sounds like > something that drivers would want to opt into, and requiring people to > update the device tree to achieve this just doesn't seem reasonable. > > This proposal would also only work if there's a 1:1 correspondence > between hardware IRQ and GTE IRQ. However, as Dipen mentioned, the GTE > events can be configured with a threshold, so a GTE IRQ might only > trigger every, say, 5th hardware IRQ. I'm not sure if those are common > use-cases, though. > > Obviously if we don't integrate this with IRQs directly, it becomes a > bit more difficult to relate the captured timestamps to the events > across subsystem boundaries. I'm not sure how this would be solved > properly. If the events are sufficiently rare, and it's certain that > none will be missed, then it should be possible to just pull a timestamp > from the timestamp FIFO for each event. > > All of that said, I wonder if perhaps hierarchical IRQ domains can > somehow be used for this. We did something similar on Tegra not too long > ago for wake events, which are basically IRQs exposed by a parent IRQ > chip that allows waking up from system sleep. There are some > similarities between that and GTE in that the wake events also map to a > subset of GPIOs and IRQs and provide additional functionalities on top. > Possibly similarities just ends there, since these wakes are actually an events, it would make sense for them to be implemented in hierarchical IRQ domains. GTE does not generate event or be a cause of generating any event besides its own IRQ. > I managed to mess up the implementation and Marc stepped in to clean > things up, so Cc'ing him since he's clearly more familiar with the topic > than I am. > > Thierry >
Re: GTE - The hardware timestamping engine
On Tue, 23 Mar 2021 10:06:39 +, Thierry Reding wrote: [...] > Obviously if we don't integrate this with IRQs directly, it becomes a > bit more difficult to relate the captured timestamps to the events > across subsystem boundaries. I'm not sure how this would be solved > properly. If the events are sufficiently rare, and it's certain that > none will be missed, then it should be possible to just pull a timestamp > from the timestamp FIFO for each event. > > All of that said, I wonder if perhaps hierarchical IRQ domains can > somehow be used for this. We did something similar on Tegra not too long > ago for wake events, which are basically IRQs exposed by a parent IRQ > chip that allows waking up from system sleep. There are some > similarities between that and GTE in that the wake events also map to a > subset of GPIOs and IRQs and provide additional functionalities on top. > > I managed to mess up the implementation and Marc stepped in to clean > things up, so Cc'ing him since he's clearly more familiar with the topic > than I am. Sure, but I'm pretty clueless when it comes to what this GTE thing does (it has a fast car ring to it, which isn't a selling point for me... ;-). If, as I understand it, it is supposed to collect timestamps on signalling of IRQs, you could make it part of the kernel's view of the interrupt path by "pushing" a domain on top of the IRQ stack, triggering the configuration/timestamping of this interrupt. What is completely unclear to me is how you extract information from it. The IRQ doesn't really give you an interface to extract a lot of information aside from an interrupt count and what is defined as the interrupt state. A timestamp doesn't really count as state, so you'd need to invent something new here. Thanks, M. -- Without deviation from the norm, progress is not possible.
Re: GTE - The hardware timestamping engine
On 3/23/21 3:06 AM, Thierry Reding wrote: > On Tue, Mar 23, 2021 at 10:08:00AM +0100, Linus Walleij wrote: >> On Mon, Mar 22, 2021 at 9:17 PM Dipen Patel wrote: >> >>> My follow-up concerns on both Linus's and Kent's feedback: >>> >>> 1. Please correct me if I am wrong, lineevent in the gpiolib* is only >>> serves the userspace clients. >>> 1.a What about kernel drivers wanting to use this feature for monitoring its >>> GPIO lines, see gyroscope example somewhere below. In that regards, >>> lineevent implementation is not sufficient. >>> 1.b Are you also implying to extend lineevent implementation to kernel >>> drivers? >> >> I was talking about lineevent because you mentioned things like >> motors and robotics, and those things are traditionally not run in >> kernelspace because they are not generic hardware that fit in the >> kernel subsystems. >> >> Normally industrial automatic control tasks are run in a userspace >> thread with some realtime priority. >> >> As Kent says, in-kernel events are exclusively using IRQ as >> mechanism, and should be modeled as IRQs. Then the question >> is how you join the timestamp with the IRQ. GPIO chips are >> just some kind of irqchip in this regard, we reuse the irqchip >> infrastructure in the kernel for all GPIO drivers that generate >> "events" in response to state transitions on digital lines. > > One potential problem I see with this is that Kent's proposal, if I > understand correctly, would supplant the original IRQ of a device with > the GTE IRQ for the corresponding event. I'm not sure that's desirable > because that would require modifying the device tree and would no longer > accurately represent the hardware. Timestamping also sounds like > something that drivers would want to opt into, and requiring people to > update the device tree to achieve this just doesn't seem reasonable. > > This proposal would also only work if there's a 1:1 correspondence > between hardware IRQ and GTE IRQ. However, as Dipen mentioned, the GTE > events can be configured with a threshold, so a GTE IRQ might only > trigger every, say, 5th hardware IRQ. I'm not sure if those are common > use-cases, though. > > Obviously if we don't integrate this with IRQs directly, it becomes a > bit more difficult to relate the captured timestamps to the events > across subsystem boundaries. I'm not sure how this would be solved > properly. If the events are sufficiently rare, and it's certain that > none will be missed, then it should be possible to just pull a timestamp > from the timestamp FIFO for each event. > Just to clarify, I am getting impression that GTE is viewed or made to be viewed as "event" generating device, which it is not. You can consider GTE as "person in a middle" type of device which can monitor configured events and on seeing state change, it will just record timestamp and store it. I agree with Thierry's point. > All of that said, I wonder if perhaps hierarchical IRQ domains can > somehow be used for this. We did something similar on Tegra not too long > ago for wake events, which are basically IRQs exposed by a parent IRQ > chip that allows waking up from system sleep. There are some > similarities between that and GTE in that the wake events also map to a > subset of GPIOs and IRQs and provide additional functionalities on top. > > I managed to mess up the implementation and Marc stepped in to clean > things up, so Cc'ing him since he's clearly more familiar with the topic > than I am. > > Thierry >
Re: GTE - The hardware timestamping engine
On 3/23/21 2:08 AM, Linus Walleij wrote: > On Mon, Mar 22, 2021 at 9:17 PM Dipen Patel wrote: > >> My follow-up concerns on both Linus's and Kent's feedback: >> >> 1. Please correct me if I am wrong, lineevent in the gpiolib* is only >> serves the userspace clients. >> 1.a What about kernel drivers wanting to use this feature for monitoring its >> GPIO lines, see gyroscope example somewhere below. In that regards, >> lineevent implementation is not sufficient. >> 1.b Are you also implying to extend lineevent implementation to kernel >> drivers? > > I was talking about lineevent because you mentioned things like > motors and robotics, and those things are traditionally not run in > kernelspace because they are not generic hardware that fit in the > kernel subsystems. > > Normally industrial automatic control tasks are run in a userspace > thread with some realtime priority. > I mentioned those two use cases as illustration purpose as GTE is not just restricted to robotics and vehicles. I agree that those applications run mostly from userspace with RT priority but there most certainly some kernel drivers they interact and it may want to use GTE, for example, BMI088 devices mostly used in drones and robotics, it could be extended to use GTE for its GPIO hw timestamping, GPIO is used to indicate data ready. > As Kent says, in-kernel events are exclusively using IRQ as > mechanism, and should be modeled as IRQs. Then the question > is how you join the timestamp with the IRQ. GPIO chips are > just some kind of irqchip in this regard, we reuse the irqchip > infrastructure in the kernel for all GPIO drivers that generate > "events" in response to state transitions on digital lines. > And certainly you will also want to use this timestamp for IIO devices? If it is just GPIOs and IRQs today, it will be gyroscopes and accelerometers tomorrow, am I right? >> >> Gyroscope, accelerometers or any IIO are built on top of i2c/spi and/or >> GPIOs. >> So they are covered as long as they serve as client to GTE framework, For >> example, if gyroscope uses GPIO as an interrupt to indicate frame >> ready, GTE could timestamp that GPIO as well any IRQs like i2c transaction >> complete IRQ. To this to happen, gycroscope then register itself with >> GTE framework and enable required signals that it interfaces/interested with. > > I think there are IIO devices that provide their own > hardware timestamp and as such they might want to use that, > so the mechanism need to be generic enough that a certain > hardware timestamp can be selected sooner or later. > But let's not overcomplicate things for now. > I agree, above BMI088 has its own timestamping engine. I have to look into that aspect for bringing its TS engine into GTE framework as one of the possible off-chip provides besides in-chip GTEs. We can defer that part for later. Thanks for pointing that out. > Yours, > Linus Walleij >
Re: GTE - The hardware timestamping engine
On Tue, Mar 23, 2021 at 10:03:18AM +0100, Thierry Reding wrote: > I agree. My understanding is the the TSC is basically an SoC-wide clock > that can be (and is) used by several hardware blocks. There's an > interface for software to read out the value, but it's part of a block > called TKE (time-keeping engine, if I recall correctly) that implements > various clock sources and watchdog functionality. ... > Anyway, I think given that the GTE doesn't provide that clock itself but > rather just a means of taking a snapshot of that clock and stamping > certain events with that, it makes more sense to provide that clock from > the TKE driver. It sounds like TKE + GTE together act like a PHC, and GTE doesn't need/want its own SW interface. Thanks, Richard
Re: GTE - The hardware timestamping engine
On Tue, Mar 23, 2021 at 10:08:00AM +0100, Linus Walleij wrote: > On Mon, Mar 22, 2021 at 9:17 PM Dipen Patel wrote: > > > My follow-up concerns on both Linus's and Kent's feedback: > > > > 1. Please correct me if I am wrong, lineevent in the gpiolib* is only > > serves the userspace clients. > > 1.a What about kernel drivers wanting to use this feature for monitoring its > > GPIO lines, see gyroscope example somewhere below. In that regards, > > lineevent implementation is not sufficient. > > 1.b Are you also implying to extend lineevent implementation to kernel > > drivers? > > I was talking about lineevent because you mentioned things like > motors and robotics, and those things are traditionally not run in > kernelspace because they are not generic hardware that fit in the > kernel subsystems. > > Normally industrial automatic control tasks are run in a userspace > thread with some realtime priority. > > As Kent says, in-kernel events are exclusively using IRQ as > mechanism, and should be modeled as IRQs. Then the question > is how you join the timestamp with the IRQ. GPIO chips are > just some kind of irqchip in this regard, we reuse the irqchip > infrastructure in the kernel for all GPIO drivers that generate > "events" in response to state transitions on digital lines. One potential problem I see with this is that Kent's proposal, if I understand correctly, would supplant the original IRQ of a device with the GTE IRQ for the corresponding event. I'm not sure that's desirable because that would require modifying the device tree and would no longer accurately represent the hardware. Timestamping also sounds like something that drivers would want to opt into, and requiring people to update the device tree to achieve this just doesn't seem reasonable. This proposal would also only work if there's a 1:1 correspondence between hardware IRQ and GTE IRQ. However, as Dipen mentioned, the GTE events can be configured with a threshold, so a GTE IRQ might only trigger every, say, 5th hardware IRQ. I'm not sure if those are common use-cases, though. Obviously if we don't integrate this with IRQs directly, it becomes a bit more difficult to relate the captured timestamps to the events across subsystem boundaries. I'm not sure how this would be solved properly. If the events are sufficiently rare, and it's certain that none will be missed, then it should be possible to just pull a timestamp from the timestamp FIFO for each event. All of that said, I wonder if perhaps hierarchical IRQ domains can somehow be used for this. We did something similar on Tegra not too long ago for wake events, which are basically IRQs exposed by a parent IRQ chip that allows waking up from system sleep. There are some similarities between that and GTE in that the wake events also map to a subset of GPIOs and IRQs and provide additional functionalities on top. I managed to mess up the implementation and Marc stepped in to clean things up, so Cc'ing him since he's clearly more familiar with the topic than I am. Thierry signature.asc Description: PGP signature
Re: GTE - The hardware timestamping engine
On Mon, Mar 22, 2021 at 9:17 PM Dipen Patel wrote: > My follow-up concerns on both Linus's and Kent's feedback: > > 1. Please correct me if I am wrong, lineevent in the gpiolib* is only > serves the userspace clients. > 1.a What about kernel drivers wanting to use this feature for monitoring its > GPIO lines, see gyroscope example somewhere below. In that regards, > lineevent implementation is not sufficient. > 1.b Are you also implying to extend lineevent implementation to kernel > drivers? I was talking about lineevent because you mentioned things like motors and robotics, and those things are traditionally not run in kernelspace because they are not generic hardware that fit in the kernel subsystems. Normally industrial automatic control tasks are run in a userspace thread with some realtime priority. As Kent says, in-kernel events are exclusively using IRQ as mechanism, and should be modeled as IRQs. Then the question is how you join the timestamp with the IRQ. GPIO chips are just some kind of irqchip in this regard, we reuse the irqchip infrastructure in the kernel for all GPIO drivers that generate "events" in response to state transitions on digital lines. > >> And certainly you will also want to use this timestamp for > >> IIO devices? If it is just GPIOs and IRQs today, it will be > >> gyroscopes and accelerometers tomorrow, am I right? > >> > > Gyroscope, accelerometers or any IIO are built on top of i2c/spi and/or GPIOs. > So they are covered as long as they serve as client to GTE framework, For > example, if gyroscope uses GPIO as an interrupt to indicate frame > ready, GTE could timestamp that GPIO as well any IRQs like i2c transaction > complete IRQ. To this to happen, gycroscope then register itself with > GTE framework and enable required signals that it interfaces/interested with. I think there are IIO devices that provide their own hardware timestamp and as such they might want to use that, so the mechanism need to be generic enough that a certain hardware timestamp can be selected sooner or later. But let's not overcomplicate things for now. Yours, Linus Walleij
Re: GTE - The hardware timestamping engine
On Mon, Mar 22, 2021 at 01:33:38PM -0700, Dipen Patel wrote: > Hi Richard, > > Thanks for your input and time. Please see below follow up. > > On 3/20/21 8:38 AM, Richard Cochran wrote: > > On Sat, Mar 20, 2021 at 01:44:20PM +0100, Arnd Bergmann wrote: > >> Adding Richard Cochran as well, for drivers/ptp/, he may be able to > >> identify whether this should be integrated into that framework in some > >> form. > > > > I'm not familiar with the GTE, but it sounds like it is a (free > > running?) clock with time stamping inputs. If so, then it could > > expose a PHC. That gets you functionality: > > > > - clock_gettime() and friends > > - comparison ioctl between GTE clock and CLOCK_REALTIME > > - time stamping channels with programmable input selection > > > GTE gets or rather records the timestamps from the TSC > (timestamp system coutner) so its not attached to GTE as any > one can access TSC, so not sure if we really need to implement PHC > and/or clock_* and friends for the GTE. I believe burden to find correlation > between various clock domains should be on the clients, consider below > example. I agree. My understanding is the the TSC is basically an SoC-wide clock that can be (and is) used by several hardware blocks. There's an interface for software to read out the value, but it's part of a block called TKE (time-keeping engine, if I recall correctly) that implements various clock sources and watchdog functionality. As a matter of fact, I recall typing up a driver for that at some point but I don't recall if I ever sent it out or what became of it. I can't find it upstream at least. Anyway, I think given that the GTE doesn't provide that clock itself but rather just a means of taking a snapshot of that clock and stamping certain events with that, it makes more sense to provide that clock from the TKE driver. Thierry signature.asc Description: PGP signature
Re: GTE - The hardware timestamping engine
On Mon, Mar 22, 2021 at 09:09:50PM -0700, Dipen Patel wrote: > > > On 3/22/21 7:59 PM, Kent Gibson wrote: > > On Mon, Mar 22, 2021 at 06:53:10PM -0700, Dipen Patel wrote: > >> > >> > >> On 3/22/21 5:32 PM, Kent Gibson wrote: > >>> On Mon, Mar 22, 2021 at 01:21:46PM -0700, Dipen Patel wrote: > Hi Linus and Kent, > > > > > [snip] > > > >>> In response to all your comments above... > >>> > >>> Firstly, I'm not suggesting that other kernel modules would use the > >>> cdev lineevents, only that they would use the same mechanism that > >>> gpiolib-cdev would use to timestamp the lineevents for userspace. > >>> > >> Sure, I just wanted to mention the different scenarios and wanted to know > >> how can we fit all those together. Having said that, shouldn't this serve > >> an opportunity to extend the linevent framework to accommodate kernel > >> drivers as a clients? > >> > >> If we can't, then there is a risk of duplicating lineevent mechanism in all > >> of those kernel drivers or at least in GTE framework/infrastructure as far > >> as GPIO related GTE part is concerned. > >> > > > > In-kernel the lineevents are just IRQs so anything needing a "lineevent" > > can request the IRQ directly. Or am I missing something? > > > > In the GPIO context, I meant we can extend line_event_timestamp to kernel > drivers as well in that way, both userspace and kernel drivers requesting > particular GPIO for the hardware timestamp would be managed by same > lineevent_* infrastructure from the gpiolib. Something like lineevent_create > version of the kernel drivers, so if they need hardware timestamp on the > GPIO line, they can request with some flags. In that way, GTE can leverage > linevent* codes from gpiolib to cover its both the GPIO related use cases i.e. > userspace app and kernel drivers. > I still don't see what that gives you that is better than an IRQ and a function to provide the timestamp for that IRQ. What specific features of a lineevent are you after? The gpiolib-cdev code is there to provide a palettable API for userspace, and the bulk of that code is specific to the userspace API. Reusing that code for clients within the kernel is just introducing pointless overhead when they can get what they need more directly. There may be a case for some additional gpiolib/irq helper functions, but I don't see gpiolib-cdev as a good fit for that role. > >>> As to that mechanism, my current thinking is that the approach of > >>> associating GTE event FIFO entries with particular physical IRQ events is > >>> problematic, as keeping the two in sync would be difficult, if not > >>> impossible. > >>> > >>> A more robust approach is to ignore the physical IRQs and instead service > >>> the GTE event FIFO, generating IRQs from those events in software - > >>> essentially a pre-timestamped IRQ. The IRQ framework could provide the > >>> timestamping functionality, equivalent to line_event_timestamp(), for > >>> the IRQ handler/thread and in this case provide the timestamp from the GTE > >>> event. > >>> > >> > >> I have not fully understood above two paragraphs (except about > >> lineevent_event_timestamp related part). > >> > >> I have no idea what it means to "ignore the physical IRQs and service the > >> GTE event FIFO". Just like GPIO clients, there could be IRQ clients which > >> want to monitor certain IRQ line, like ethernet driver wanted to retrieve > >> timestamp for its IRQ line and so on. > >> > > > > I mean that in the IRQ framework, rather than enabling the physical IRQ > > line it would leave that masked and would instead enable the FIFO line to > > service the FIFO, configure the GTE to generate the events for that > > line, and then generate IRQs in response to the FIFO events. > > That way the client requesting the IRQ is guaranteed to only receive an > > IRQ that corresponds to a GTE FIFO event and the timestamp stored in the > > IRQ framework would match. > > > > I do not think we need to do such things, for example, below is > the rough sequence how GTE can notify its clients be it GPIO or IRQ > lines. I believe this will also help understand better ongoing GPIO > discussions. > > 1. Configure GTE FIFO watermark or threshold, lets assume 1, i.e >generate GTE interrupt when FIFO depth is 1. > 2. In the GTE ISR or ISR thread, drain internal FIFO entries > 3. Through GTE driver's internal mapping, identify which IRQ or >GPIO number this entry belongs to. (This is possible as GTE >has predefined bits for each supported signals, for example GTE >supports 40 GPIOs and 352 IRQ lines, and it has multliple GTE instances >which can take care all of them) > 4. GTE driver pushes the event data (in this case it will be timestamp and >direction of the event ie.rising or falling) to the GTE generic framework > 5. GTE framework will store per event data to its per client/event sw FIFO > 6. wake up any sleeping client thread > 7. Points 3 to 6 are happening in GTE ISR
Re: GTE - The hardware timestamping engine
On 3/22/21 7:59 PM, Kent Gibson wrote: > On Mon, Mar 22, 2021 at 06:53:10PM -0700, Dipen Patel wrote: >> >> >> On 3/22/21 5:32 PM, Kent Gibson wrote: >>> On Mon, Mar 22, 2021 at 01:21:46PM -0700, Dipen Patel wrote: Hi Linus and Kent, > > [snip] > >>> In response to all your comments above... >>> >>> Firstly, I'm not suggesting that other kernel modules would use the >>> cdev lineevents, only that they would use the same mechanism that >>> gpiolib-cdev would use to timestamp the lineevents for userspace. >>> >> Sure, I just wanted to mention the different scenarios and wanted to know >> how can we fit all those together. Having said that, shouldn't this serve >> an opportunity to extend the linevent framework to accommodate kernel >> drivers as a clients? >> >> If we can't, then there is a risk of duplicating lineevent mechanism in all >> of those kernel drivers or at least in GTE framework/infrastructure as far >> as GPIO related GTE part is concerned. >> > > In-kernel the lineevents are just IRQs so anything needing a "lineevent" > can request the IRQ directly. Or am I missing something? > In the GPIO context, I meant we can extend line_event_timestamp to kernel drivers as well in that way, both userspace and kernel drivers requesting particular GPIO for the hardware timestamp would be managed by same lineevent_* infrastructure from the gpiolib. Something like lineevent_create version of the kernel drivers, so if they need hardware timestamp on the GPIO line, they can request with some flags. In that way, GTE can leverage linevent* codes from gpiolib to cover its both the GPIO related use cases i.e. userspace app and kernel drivers. >>> As to that mechanism, my current thinking is that the approach of >>> associating GTE event FIFO entries with particular physical IRQ events is >>> problematic, as keeping the two in sync would be difficult, if not >>> impossible. >>> >>> A more robust approach is to ignore the physical IRQs and instead service >>> the GTE event FIFO, generating IRQs from those events in software - >>> essentially a pre-timestamped IRQ. The IRQ framework could provide the >>> timestamping functionality, equivalent to line_event_timestamp(), for >>> the IRQ handler/thread and in this case provide the timestamp from the GTE >>> event. >>> >> >> I have not fully understood above two paragraphs (except about >> lineevent_event_timestamp related part). >> >> I have no idea what it means to "ignore the physical IRQs and service the >> GTE event FIFO". Just like GPIO clients, there could be IRQ clients which >> want to monitor certain IRQ line, like ethernet driver wanted to retrieve >> timestamp for its IRQ line and so on. >> > > I mean that in the IRQ framework, rather than enabling the physical IRQ > line it would leave that masked and would instead enable the FIFO line to > service the FIFO, configure the GTE to generate the events for that > line, and then generate IRQs in response to the FIFO events. > That way the client requesting the IRQ is guaranteed to only receive an > IRQ that corresponds to a GTE FIFO event and the timestamp stored in the > IRQ framework would match. > I do not think we need to do such things, for example, below is the rough sequence how GTE can notify its clients be it GPIO or IRQ lines. I believe this will also help understand better ongoing GPIO discussions. 1. Configure GTE FIFO watermark or threshold, lets assume 1, i.e generate GTE interrupt when FIFO depth is 1. 2. In the GTE ISR or ISR thread, drain internal FIFO entries 3. Through GTE driver's internal mapping, identify which IRQ or GPIO number this entry belongs to. (This is possible as GTE has predefined bits for each supported signals, for example GTE supports 40 GPIOs and 352 IRQ lines, and it has multliple GTE instances which can take care all of them) 4. GTE driver pushes the event data (in this case it will be timestamp and direction of the event ie.rising or falling) to the GTE generic framework 5. GTE framework will store per event data to its per client/event sw FIFO 6. wake up any sleeping client thread 7. Points 3 to 6 are happening in GTE ISR context. 8. gte_retrieve_event (which can block if no event) at later convenient time do whatever it wants with it. We can extend it to non blocking version where some sort of client callbacks can be implemented. > And that is what I mean by this being an IRQ feature. > We need feedback from the IRQ guys as to whether that makes sense to > them. > > Cheers, > Kent. > Best Regards, Dipen Patel
Re: GTE - The hardware timestamping engine
On Mon, Mar 22, 2021 at 06:53:10PM -0700, Dipen Patel wrote: > > > On 3/22/21 5:32 PM, Kent Gibson wrote: > > On Mon, Mar 22, 2021 at 01:21:46PM -0700, Dipen Patel wrote: > >> Hi Linus and Kent, > >> [snip] > > In response to all your comments above... > > > > Firstly, I'm not suggesting that other kernel modules would use the > > cdev lineevents, only that they would use the same mechanism that > > gpiolib-cdev would use to timestamp the lineevents for userspace. > > > Sure, I just wanted to mention the different scenarios and wanted to know > how can we fit all those together. Having said that, shouldn't this serve > an opportunity to extend the linevent framework to accommodate kernel > drivers as a clients? > > If we can't, then there is a risk of duplicating lineevent mechanism in all > of those kernel drivers or at least in GTE framework/infrastructure as far > as GPIO related GTE part is concerned. > In-kernel the lineevents are just IRQs so anything needing a "lineevent" can request the IRQ directly. Or am I missing something? > > As to that mechanism, my current thinking is that the approach of > > associating GTE event FIFO entries with particular physical IRQ events is > > problematic, as keeping the two in sync would be difficult, if not > > impossible. > > > > A more robust approach is to ignore the physical IRQs and instead service > > the GTE event FIFO, generating IRQs from those events in software - > > essentially a pre-timestamped IRQ. The IRQ framework could provide the > > timestamping functionality, equivalent to line_event_timestamp(), for > > the IRQ handler/thread and in this case provide the timestamp from the GTE > > event. > > > > I have not fully understood above two paragraphs (except about > lineevent_event_timestamp related part). > > I have no idea what it means to "ignore the physical IRQs and service the > GTE event FIFO". Just like GPIO clients, there could be IRQ clients which > want to monitor certain IRQ line, like ethernet driver wanted to retrieve > timestamp for its IRQ line and so on. > I mean that in the IRQ framework, rather than enabling the physical IRQ line it would leave that masked and would instead enable the FIFO line to service the FIFO, configure the GTE to generate the events for that line, and then generate IRQs in response to the FIFO events. That way the client requesting the IRQ is guaranteed to only receive an IRQ that corresponds to a GTE FIFO event and the timestamp stored in the IRQ framework would match. And that is what I mean by this being an IRQ feature. We need feedback from the IRQ guys as to whether that makes sense to them. Cheers, Kent.
Re: GTE - The hardware timestamping engine
On 3/22/21 5:32 PM, Kent Gibson wrote:
> On Mon, Mar 22, 2021 at 01:21:46PM -0700, Dipen Patel wrote:
>> Hi Linus and Kent,
>>
>> Thanks you so much for your valuable inputs and time, Please see below, my
>> follow ups.
>>
>> On 3/21/21 11:00 PM, Kent Gibson wrote:
>>> On Sat, Mar 20, 2021 at 12:56:36PM +0100, Linus Walleij wrote:
Hi Dipen,
thanks for your mail!
I involved some other kernel people to get some discussion.
I think Kent Gibson can be of great help because he is using
GPIOs with high precision.
>>>
>>> Actually I just extended the cdev uAPI to provide the REALTIME option,
>>> which was the event clock until we changed to MONOTONIC in Linux 5.7,
>>> as there were some users that were requiring the REALTIME clock.
>>>
We actually discussed this a bit when adding support for
realtime timestamps.
On Wed, Mar 17, 2021 at 11:29 PM Dipen Patel wrote:
> Nvidia Tegra SoCs have generic timestamping engine (GTE) hardware module
> which
> can monitor SoC signals like IRQ lines and GPIO lines for state change,
> upon
> detecting the change, it can timestamp and store in its internal hardware
> FIFO.
> The advantage of the GTE module can be realized in applications like
> robotics
> or autonomous vehicle where it can help record events with precise
> timestamp.
That sounds very useful.
>>>
>>> Indeed - it could remove the latency and jitter that results from
>>> timestamping events in the IRQ handler.
>>>
Certainly the kernel shall be able to handle this.
>
> For GPIO:
>
> 1. GPIO has to be configured as input and IRQ must be enabled.
> 2. Ask GPIO controller driver to set corresponding timestamp bit in the
> specified GPIO config register.
> 3. Translate GPIO specified by the client to its internal bitmap.
> 3.a For example, If client specifies GPIO line 31, it could be bit 13 of
> GTE
> register.
> 4. Set internal bits to enable monitoring in GTE module
> 5. Additionally GTE driver can open up lanes for the user space
> application
> as a client and can send timestamping events directly to the
> application.
I have some concerns:
1. GPIO should for all professional applications be used with the character
device /dev/gpiochipN, under no circumstances shall the old sysfs
ABI be used for this. In this case it is necessary because the
character device provides events in a FIFO to userspace, which is
what we need.
>>>
>>> The cdev uAPI would certainly be the most sensible place to expose
>>> this to userspace - its line events being a direct analog to what the GTE
>>> provides.
>>>
The timestamp provided to userspace is an opaque 64bit
unsigned value. I suppose we assume it is monotonic but
you can actually augment the semantics for your specific
stamp, as long as 64 bits is gonna work.
2. The timestamp for the chardev is currently obtained in
drivers/gpio/gpiolib-cdev.c like this:
static u64 line_event_timestamp(struct line *line)
{
if (test_bit(FLAG_EVENT_CLOCK_REALTIME, >desc->flags))
return ktime_get_real_ns();
return ktime_get_ns();
}
What you want to do is to add a new flag for hardware timestamps
and use that if available. FLAG_EVENT_CLOCK_HARDWARE?
FLAG_EVENT_CLOCK_NATIVE?
>>>
>>> HARDWARE looks better to me, as NATIVE is more vague.
>>>
Then you need to figure out a mechanism so we can obtain
the right timestamp from the hardware event right here,
you can hook into the GPIO driver if need be, we can
figure out the gpio_chip for a certain line for sure.
>>>
>>> Firstly, line_event_timestamp() is called from the IRQ handler context.
>>> That is obviously more constraining than if it were only called from the
>>> IRQ thread. If the GTE is providing the timestamp then that could be
>>> put off until the IRQ thread.
>>> So you probably want to refactor line_event_timestamp() into two flavours
>>> - one for IRQ handler that returns 0 if HARDWARE is set, and the other for
>>> IRQ thread, where there is already a fallback call to
>>> line_event_timestamp() for the nested threaded interrupt case, that gets
>>> the timestamp from the GTE.
>>>
>>
>> My follow-up concerns on both Linus's and Kent's feedback:
>>
>> 1. Please correct me if I am wrong, lineevent in the gpiolib* is only
>> serves the userspace clients.
>> 1.a What about kernel drivers wanting to use this feature for monitoring its
>> GPIO lines, see gyroscope example somewhere below. In that regards,
>> lineevent implementation is not sufficient.
>> 1.b Are you also implying to extend lineevent implementation to kernel
>> drivers?
>> 2. For both above cases 1.a and 1.b, gpiolib* then would
Re: GTE - The hardware timestamping engine
On Mon, Mar 22, 2021 at 01:21:46PM -0700, Dipen Patel wrote:
> Hi Linus and Kent,
>
> Thanks you so much for your valuable inputs and time, Please see below, my
> follow ups.
>
> On 3/21/21 11:00 PM, Kent Gibson wrote:
> > On Sat, Mar 20, 2021 at 12:56:36PM +0100, Linus Walleij wrote:
> >> Hi Dipen,
> >>
> >> thanks for your mail!
> >>
> >> I involved some other kernel people to get some discussion.
> >> I think Kent Gibson can be of great help because he is using
> >> GPIOs with high precision.
> >>
> >
> > Actually I just extended the cdev uAPI to provide the REALTIME option,
> > which was the event clock until we changed to MONOTONIC in Linux 5.7,
> > as there were some users that were requiring the REALTIME clock.
> >
> >> We actually discussed this a bit when adding support for
> >> realtime timestamps.
> >>
> >> On Wed, Mar 17, 2021 at 11:29 PM Dipen Patel wrote:
> >>
> >>> Nvidia Tegra SoCs have generic timestamping engine (GTE) hardware module
> >>> which
> >>> can monitor SoC signals like IRQ lines and GPIO lines for state change,
> >>> upon
> >>> detecting the change, it can timestamp and store in its internal hardware
> >>> FIFO.
> >>> The advantage of the GTE module can be realized in applications like
> >>> robotics
> >>> or autonomous vehicle where it can help record events with precise
> >>> timestamp.
> >>
> >> That sounds very useful.
> >>
> >
> > Indeed - it could remove the latency and jitter that results from
> > timestamping events in the IRQ handler.
> >
> >> Certainly the kernel shall be able to handle this.
> >>
> >>>
> >>> For GPIO:
> >>>
> >>> 1. GPIO has to be configured as input and IRQ must be enabled.
> >>> 2. Ask GPIO controller driver to set corresponding timestamp bit in the
> >>> specified GPIO config register.
> >>> 3. Translate GPIO specified by the client to its internal bitmap.
> >>> 3.a For example, If client specifies GPIO line 31, it could be bit 13 of
> >>> GTE
> >>> register.
> >>> 4. Set internal bits to enable monitoring in GTE module
> >>> 5. Additionally GTE driver can open up lanes for the user space
> >>> application
> >>> as a client and can send timestamping events directly to the
> >>> application.
> >>
> >> I have some concerns:
> >>
> >> 1. GPIO should for all professional applications be used with the character
> >> device /dev/gpiochipN, under no circumstances shall the old sysfs
> >> ABI be used for this. In this case it is necessary because the
> >> character device provides events in a FIFO to userspace, which is
> >> what we need.
> >>
> >
> > The cdev uAPI would certainly be the most sensible place to expose
> > this to userspace - its line events being a direct analog to what the GTE
> > provides.
> >
> >> The timestamp provided to userspace is an opaque 64bit
> >> unsigned value. I suppose we assume it is monotonic but
> >> you can actually augment the semantics for your specific
> >> stamp, as long as 64 bits is gonna work.
> >>
> >> 2. The timestamp for the chardev is currently obtained in
> >> drivers/gpio/gpiolib-cdev.c like this:
> >>
> >> static u64 line_event_timestamp(struct line *line)
> >> {
> >> if (test_bit(FLAG_EVENT_CLOCK_REALTIME, >desc->flags))
> >> return ktime_get_real_ns();
> >>
> >> return ktime_get_ns();
> >> }
> >>
> >> What you want to do is to add a new flag for hardware timestamps
> >> and use that if available. FLAG_EVENT_CLOCK_HARDWARE?
> >> FLAG_EVENT_CLOCK_NATIVE?
> >>
> >
> > HARDWARE looks better to me, as NATIVE is more vague.
> >
> >> Then you need to figure out a mechanism so we can obtain
> >> the right timestamp from the hardware event right here,
> >> you can hook into the GPIO driver if need be, we can
> >> figure out the gpio_chip for a certain line for sure.
> >>
> >
> > Firstly, line_event_timestamp() is called from the IRQ handler context.
> > That is obviously more constraining than if it were only called from the
> > IRQ thread. If the GTE is providing the timestamp then that could be
> > put off until the IRQ thread.
> > So you probably want to refactor line_event_timestamp() into two flavours
> > - one for IRQ handler that returns 0 if HARDWARE is set, and the other for
> > IRQ thread, where there is already a fallback call to
> > line_event_timestamp() for the nested threaded interrupt case, that gets
> > the timestamp from the GTE.
> >
>
> My follow-up concerns on both Linus's and Kent's feedback:
>
> 1. Please correct me if I am wrong, lineevent in the gpiolib* is only
> serves the userspace clients.
> 1.a What about kernel drivers wanting to use this feature for monitoring its
> GPIO lines, see gyroscope example somewhere below. In that regards,
> lineevent implementation is not sufficient.
> 1.b Are you also implying to extend lineevent implementation to kernel
> drivers?
> 2. For both above cases 1.a and 1.b, gpiolib* then would become holder
> of all the GTE related
Re: GTE - The hardware timestamping engine
Hi Richard, Thanks for your input and time. Please see below follow up. On 3/20/21 8:38 AM, Richard Cochran wrote: > On Sat, Mar 20, 2021 at 01:44:20PM +0100, Arnd Bergmann wrote: >> Adding Richard Cochran as well, for drivers/ptp/, he may be able to >> identify whether this should be integrated into that framework in some >> form. > > I'm not familiar with the GTE, but it sounds like it is a (free > running?) clock with time stamping inputs. If so, then it could > expose a PHC. That gets you functionality: > > - clock_gettime() and friends > - comparison ioctl between GTE clock and CLOCK_REALTIME > - time stamping channels with programmable input selection > GTE gets or rather records the timestamps from the TSC (timestamp system coutner) so its not attached to GTE as any one can access TSC, so not sure if we really need to implement PHC and/or clock_* and friends for the GTE. I believe burden to find correlation between various clock domains should be on the clients, consider below example. Networking client has access to both PTP and GTE, it would be its job to find the correlations if that is at all needed based on whatever use case that client serves. GTE in above may come in picture if said client has some GPIO configured and wants timestamp on it. Sorry if I misunderstood anything, you can elaborate more as I am also interested in how GTE can fit in PTP framework and which usecase it can help doing so. > The mentioned applications (robotics and autonomous vehicle, so near > and dear to my heart) surely already use the PHC API for dealing with > network and system time sources, and so exposing the GTE as a PHC > means that user space programs will have a consistent API. > > [ The only drawback I can see is the naming of the C language > identifiers in include/uapi/linux/ptp_clock.h. If that bothers > people, then these can be changed to something more generic while > keeping compatibility aliases. ] > > Thanks, > Richard > Thanks, Best Regards, Dipen Patel
Re: GTE - The hardware timestamping engine
Hi Linus and Kent,
Thanks you so much for your valuable inputs and time, Please see below, my
follow ups.
On 3/21/21 11:00 PM, Kent Gibson wrote:
> On Sat, Mar 20, 2021 at 12:56:36PM +0100, Linus Walleij wrote:
>> Hi Dipen,
>>
>> thanks for your mail!
>>
>> I involved some other kernel people to get some discussion.
>> I think Kent Gibson can be of great help because he is using
>> GPIOs with high precision.
>>
>
> Actually I just extended the cdev uAPI to provide the REALTIME option,
> which was the event clock until we changed to MONOTONIC in Linux 5.7,
> as there were some users that were requiring the REALTIME clock.
>
>> We actually discussed this a bit when adding support for
>> realtime timestamps.
>>
>> On Wed, Mar 17, 2021 at 11:29 PM Dipen Patel wrote:
>>
>>> Nvidia Tegra SoCs have generic timestamping engine (GTE) hardware module
>>> which
>>> can monitor SoC signals like IRQ lines and GPIO lines for state change, upon
>>> detecting the change, it can timestamp and store in its internal hardware
>>> FIFO.
>>> The advantage of the GTE module can be realized in applications like
>>> robotics
>>> or autonomous vehicle where it can help record events with precise
>>> timestamp.
>>
>> That sounds very useful.
>>
>
> Indeed - it could remove the latency and jitter that results from
> timestamping events in the IRQ handler.
>
>> Certainly the kernel shall be able to handle this.
>>
>>>
>>> For GPIO:
>>>
>>> 1. GPIO has to be configured as input and IRQ must be enabled.
>>> 2. Ask GPIO controller driver to set corresponding timestamp bit in the
>>> specified GPIO config register.
>>> 3. Translate GPIO specified by the client to its internal bitmap.
>>> 3.a For example, If client specifies GPIO line 31, it could be bit 13 of GTE
>>> register.
>>> 4. Set internal bits to enable monitoring in GTE module
>>> 5. Additionally GTE driver can open up lanes for the user space application
>>> as a client and can send timestamping events directly to the
>>> application.
>>
>> I have some concerns:
>>
>> 1. GPIO should for all professional applications be used with the character
>> device /dev/gpiochipN, under no circumstances shall the old sysfs
>> ABI be used for this. In this case it is necessary because the
>> character device provides events in a FIFO to userspace, which is
>> what we need.
>>
>
> The cdev uAPI would certainly be the most sensible place to expose
> this to userspace - its line events being a direct analog to what the GTE
> provides.
>
>> The timestamp provided to userspace is an opaque 64bit
>> unsigned value. I suppose we assume it is monotonic but
>> you can actually augment the semantics for your specific
>> stamp, as long as 64 bits is gonna work.
>>
>> 2. The timestamp for the chardev is currently obtained in
>> drivers/gpio/gpiolib-cdev.c like this:
>>
>> static u64 line_event_timestamp(struct line *line)
>> {
>> if (test_bit(FLAG_EVENT_CLOCK_REALTIME, >desc->flags))
>> return ktime_get_real_ns();
>>
>> return ktime_get_ns();
>> }
>>
>> What you want to do is to add a new flag for hardware timestamps
>> and use that if available. FLAG_EVENT_CLOCK_HARDWARE?
>> FLAG_EVENT_CLOCK_NATIVE?
>>
>
> HARDWARE looks better to me, as NATIVE is more vague.
>
>> Then you need to figure out a mechanism so we can obtain
>> the right timestamp from the hardware event right here,
>> you can hook into the GPIO driver if need be, we can
>> figure out the gpio_chip for a certain line for sure.
>>
>
> Firstly, line_event_timestamp() is called from the IRQ handler context.
> That is obviously more constraining than if it were only called from the
> IRQ thread. If the GTE is providing the timestamp then that could be
> put off until the IRQ thread.
> So you probably want to refactor line_event_timestamp() into two flavours
> - one for IRQ handler that returns 0 if HARDWARE is set, and the other for
> IRQ thread, where there is already a fallback call to
> line_event_timestamp() for the nested threaded interrupt case, that gets
> the timestamp from the GTE.
>
My follow-up concerns on both Linus's and Kent's feedback:
1. Please correct me if I am wrong, lineevent in the gpiolib* is only
serves the userspace clients.
1.a What about kernel drivers wanting to use this feature for monitoring its
GPIO lines, see gyroscope example somewhere below. In that regards,
lineevent implementation is not sufficient.
1.b Are you also implying to extend lineevent implementation to kernel
drivers?
2. For both above cases 1.a and 1.b, gpiolib* then would become holder
of all the GTE related datastructures per userspace or kernel clients,
is this acceptable? In another words, gpilib-cdev framework will become
client to GTE framework on behalf of those drivers. I believe we
can embed gte related data to per lineevent structures.
3. I believe Kent touched on this, but double confirming, there will be a
Re: GTE - The hardware timestamping engine
On Sat, Mar 20, 2021 at 12:56:36PM +0100, Linus Walleij wrote:
> Hi Dipen,
>
> thanks for your mail!
>
> I involved some other kernel people to get some discussion.
> I think Kent Gibson can be of great help because he is using
> GPIOs with high precision.
>
Actually I just extended the cdev uAPI to provide the REALTIME option,
which was the event clock until we changed to MONOTONIC in Linux 5.7,
as there were some users that were requiring the REALTIME clock.
> We actually discussed this a bit when adding support for
> realtime timestamps.
>
> On Wed, Mar 17, 2021 at 11:29 PM Dipen Patel wrote:
>
> > Nvidia Tegra SoCs have generic timestamping engine (GTE) hardware module
> > which
> > can monitor SoC signals like IRQ lines and GPIO lines for state change, upon
> > detecting the change, it can timestamp and store in its internal hardware
> > FIFO.
> > The advantage of the GTE module can be realized in applications like
> > robotics
> > or autonomous vehicle where it can help record events with precise
> > timestamp.
>
> That sounds very useful.
>
Indeed - it could remove the latency and jitter that results from
timestamping events in the IRQ handler.
> Certainly the kernel shall be able to handle this.
>
> >
> > For GPIO:
> >
> > 1. GPIO has to be configured as input and IRQ must be enabled.
> > 2. Ask GPIO controller driver to set corresponding timestamp bit in the
> > specified GPIO config register.
> > 3. Translate GPIO specified by the client to its internal bitmap.
> > 3.a For example, If client specifies GPIO line 31, it could be bit 13 of GTE
> > register.
> > 4. Set internal bits to enable monitoring in GTE module
> > 5. Additionally GTE driver can open up lanes for the user space application
> > as a client and can send timestamping events directly to the
> > application.
>
> I have some concerns:
>
> 1. GPIO should for all professional applications be used with the character
> device /dev/gpiochipN, under no circumstances shall the old sysfs
> ABI be used for this. In this case it is necessary because the
> character device provides events in a FIFO to userspace, which is
> what we need.
>
The cdev uAPI would certainly be the most sensible place to expose
this to userspace - its line events being a direct analog to what the GTE
provides.
> The timestamp provided to userspace is an opaque 64bit
> unsigned value. I suppose we assume it is monotonic but
> you can actually augment the semantics for your specific
> stamp, as long as 64 bits is gonna work.
>
> 2. The timestamp for the chardev is currently obtained in
> drivers/gpio/gpiolib-cdev.c like this:
>
> static u64 line_event_timestamp(struct line *line)
> {
> if (test_bit(FLAG_EVENT_CLOCK_REALTIME, >desc->flags))
> return ktime_get_real_ns();
>
> return ktime_get_ns();
> }
>
> What you want to do is to add a new flag for hardware timestamps
> and use that if available. FLAG_EVENT_CLOCK_HARDWARE?
> FLAG_EVENT_CLOCK_NATIVE?
>
HARDWARE looks better to me, as NATIVE is more vague.
> Then you need to figure out a mechanism so we can obtain
> the right timestamp from the hardware event right here,
> you can hook into the GPIO driver if need be, we can
> figure out the gpio_chip for a certain line for sure.
>
Firstly, line_event_timestamp() is called from the IRQ handler context.
That is obviously more constraining than if it were only called from the
IRQ thread. If the GTE is providing the timestamp then that could be
put off until the IRQ thread.
So you probably want to refactor line_event_timestamp() into two flavours
- one for IRQ handler that returns 0 if HARDWARE is set, and the other for
IRQ thread, where there is already a fallback call to
line_event_timestamp() for the nested threaded interrupt case, that gets
the timestamp from the GTE.
But my primary concern here would be keeping the two event FIFOs (GTE and
cdev) in sync. Masking and unmasking in hardware and the kernel needs to
be coordinated to prevent races that would result in sync loss.
So this probably needs to be configured in the GTE driver via the irq
path, rather than pinctrl?
Is every event detected by the GTE guaranteed to trigger an interrupt in
the kernel?
How to handle GTE FIFO overflows? Can they be detected or prevented?
> So you first need to augment the userspace
> ABI and the character device code to add this. See
> commit 26d060e47e25f2c715a1b2c48fea391f67907a30
> "gpiolib: cdev: allow edge event timestamps to be configured as REALTIME"
> by Kent Gibson to see what needs to be done.
>
You should also extend gpio_v2_line_flags_validate() to disallow setting
of multiple event clock flags, similar to the bias flag checks.
Currently there is only the one event clock flag, so no need to check.
> 3. Also patch tools/gpio/gpio-event-mon.c to support this flag and use that
> for prototyping and proof of concept.
>
The corresponding commit for the REALTIME
Re: GTE - The hardware timestamping engine
On Sat, Mar 20, 2021 at 01:44:20PM +0100, Arnd Bergmann wrote: > Adding Richard Cochran as well, for drivers/ptp/, he may be able to > identify whether this should be integrated into that framework in some > form. I'm not familiar with the GTE, but it sounds like it is a (free running?) clock with time stamping inputs. If so, then it could expose a PHC. That gets you functionality: - clock_gettime() and friends - comparison ioctl between GTE clock and CLOCK_REALTIME - time stamping channels with programmable input selection The mentioned applications (robotics and autonomous vehicle, so near and dear to my heart) surely already use the PHC API for dealing with network and system time sources, and so exposing the GTE as a PHC means that user space programs will have a consistent API. [ The only drawback I can see is the naming of the C language identifiers in include/uapi/linux/ptp_clock.h. If that bothers people, then these can be changed to something more generic while keeping compatibility aliases. ] Thanks, Richard
Re: GTE - The hardware timestamping engine
On Sat, Mar 20, 2021 at 12:56 PM Linus Walleij wrote:
>
> Hi Dipen,
>
> thanks for your mail!
>
> I involved some other kernel people to get some discussion.
> I think Kent Gibson can be of great help because he is using
> GPIOs with high precision.
>
> We actually discussed this a bit when adding support for
> realtime timestamps.
Adding Richard Cochran as well, for drivers/ptp/, he may be able to
identify whether this should be integrated into that framework in some
form.
fullquote below
> On Wed, Mar 17, 2021 at 11:29 PM Dipen Patel wrote:
>
> > Nvidia Tegra SoCs have generic timestamping engine (GTE) hardware module
> > which
> > can monitor SoC signals like IRQ lines and GPIO lines for state change, upon
> > detecting the change, it can timestamp and store in its internal hardware
> > FIFO.
> > The advantage of the GTE module can be realized in applications like
> > robotics
> > or autonomous vehicle where it can help record events with precise
> > timestamp.
>
> That sounds very useful.
>
> Certainly the kernel shall be able to handle this.
>
> >
> > For GPIO:
> >
> > 1. GPIO has to be configured as input and IRQ must be enabled.
> > 2. Ask GPIO controller driver to set corresponding timestamp bit in the
> > specified GPIO config register.
> > 3. Translate GPIO specified by the client to its internal bitmap.
> > 3.a For example, If client specifies GPIO line 31, it could be bit 13 of GTE
> > register.
> > 4. Set internal bits to enable monitoring in GTE module
> > 5. Additionally GTE driver can open up lanes for the user space application
> > as a client and can send timestamping events directly to the
> > application.
>
> I have some concerns:
>
> 1. GPIO should for all professional applications be used with the character
> device /dev/gpiochipN, under no circumstances shall the old sysfs
> ABI be used for this. In this case it is necessary because the
> character device provides events in a FIFO to userspace, which is
> what we need.
>
> The timestamp provided to userspace is an opaque 64bit
> unsigned value. I suppose we assume it is monotonic but
> you can actually augment the semantics for your specific
> stamp, as long as 64 bits is gonna work.
>
> 2. The timestamp for the chardev is currently obtained in
> drivers/gpio/gpiolib-cdev.c like this:
>
> static u64 line_event_timestamp(struct line *line)
> {
> if (test_bit(FLAG_EVENT_CLOCK_REALTIME, >desc->flags))
> return ktime_get_real_ns();
>
> return ktime_get_ns();
> }
>
> What you want to do is to add a new flag for hardware timestamps
> and use that if available. FLAG_EVENT_CLOCK_HARDWARE?
> FLAG_EVENT_CLOCK_NATIVE?
>
> Then you need to figure out a mechanism so we can obtain
> the right timestamp from the hardware event right here,
> you can hook into the GPIO driver if need be, we can
> figure out the gpio_chip for a certain line for sure.
>
> So you first need to augment the userspace
> ABI and the character device code to add this. See
> commit 26d060e47e25f2c715a1b2c48fea391f67907a30
> "gpiolib: cdev: allow edge event timestamps to be configured as REALTIME"
> by Kent Gibson to see what needs to be done.
>
> 3. Also patch tools/gpio/gpio-event-mon.c to support this flag and use that
> for prototyping and proof of concept.
>
> >
> > For IRQ:
> >
>
> Marc Zyngier and/or Thomas Gleixner know this stuff.
>
> It does make sense to add some infrastructure so that GPIO events
> and IRQs can use the same timestamping hardware.
>
> And certainly you will also want to use this timestamp for
> IIO devices? If it is just GPIOs and IRQs today, it will be
> gyroscopes and accelerometers tomorrow, am I right?
>
> Yours,
> Linus Walleij
Re: GTE - The hardware timestamping engine
Hi Dipen,
thanks for your mail!
I involved some other kernel people to get some discussion.
I think Kent Gibson can be of great help because he is using
GPIOs with high precision.
We actually discussed this a bit when adding support for
realtime timestamps.
On Wed, Mar 17, 2021 at 11:29 PM Dipen Patel wrote:
> Nvidia Tegra SoCs have generic timestamping engine (GTE) hardware module which
> can monitor SoC signals like IRQ lines and GPIO lines for state change, upon
> detecting the change, it can timestamp and store in its internal hardware
> FIFO.
> The advantage of the GTE module can be realized in applications like robotics
> or autonomous vehicle where it can help record events with precise timestamp.
That sounds very useful.
Certainly the kernel shall be able to handle this.
>
> For GPIO:
>
> 1. GPIO has to be configured as input and IRQ must be enabled.
> 2. Ask GPIO controller driver to set corresponding timestamp bit in the
> specified GPIO config register.
> 3. Translate GPIO specified by the client to its internal bitmap.
> 3.a For example, If client specifies GPIO line 31, it could be bit 13 of GTE
> register.
> 4. Set internal bits to enable monitoring in GTE module
> 5. Additionally GTE driver can open up lanes for the user space application
> as a client and can send timestamping events directly to the application.
I have some concerns:
1. GPIO should for all professional applications be used with the character
device /dev/gpiochipN, under no circumstances shall the old sysfs
ABI be used for this. In this case it is necessary because the
character device provides events in a FIFO to userspace, which is
what we need.
The timestamp provided to userspace is an opaque 64bit
unsigned value. I suppose we assume it is monotonic but
you can actually augment the semantics for your specific
stamp, as long as 64 bits is gonna work.
2. The timestamp for the chardev is currently obtained in
drivers/gpio/gpiolib-cdev.c like this:
static u64 line_event_timestamp(struct line *line)
{
if (test_bit(FLAG_EVENT_CLOCK_REALTIME, >desc->flags))
return ktime_get_real_ns();
return ktime_get_ns();
}
What you want to do is to add a new flag for hardware timestamps
and use that if available. FLAG_EVENT_CLOCK_HARDWARE?
FLAG_EVENT_CLOCK_NATIVE?
Then you need to figure out a mechanism so we can obtain
the right timestamp from the hardware event right here,
you can hook into the GPIO driver if need be, we can
figure out the gpio_chip for a certain line for sure.
So you first need to augment the userspace
ABI and the character device code to add this. See
commit 26d060e47e25f2c715a1b2c48fea391f67907a30
"gpiolib: cdev: allow edge event timestamps to be configured as REALTIME"
by Kent Gibson to see what needs to be done.
3. Also patch tools/gpio/gpio-event-mon.c to support this flag and use that
for prototyping and proof of concept.
>
> For IRQ:
>
Marc Zyngier and/or Thomas Gleixner know this stuff.
It does make sense to add some infrastructure so that GPIO events
and IRQs can use the same timestamping hardware.
And certainly you will also want to use this timestamp for
IIO devices? If it is just GPIOs and IRQs today, it will be
gyroscopes and accelerometers tomorrow, am I right?
Yours,
Linus Walleij
