10:34 <d1b2> <.jer_emy> I just read that whole RFC. Wow I am keen to use that when it lands

10:37 <galibert[m]> We all are :-)

21:40 <whitequark[cis]> agg: do you think there should be an LFSR implementation in the standard library?

21:40 <whitequark[cis]> (and if so, can I somehow motivate you to add one? ^^)

21:44 <adamgreig[m]> Oh yea

21:44 <adamgreig[m]> I'd be happy to. I'll ponder what it might do

21:45 <whitequark[cis]> I would be really happy to merge one!

21:45 <adamgreig[m]> Generating the standard sequences like prbs-7/9/... is obvious and very easy

21:45 <adamgreig[m]> Supporting a custom polynomial is probably worth doing too

21:46 <whitequark[cis]> yes

21:46 <adamgreig[m]> Don't know if there's any motivation to do parallel generation of words and such, vs a straightforward bit at a time generator

21:46 <adamgreig[m]> My guess is 95% of users just want one of the standard prbs sequences

21:46 <whitequark[cis]> Glasgow uses parallel words

21:46 <adamgreig[m]> The other thing that's nice to have is a receiver that counts errors

21:46 <whitequark[cis]> to test a 8-bit wide comm channel

21:47 <adamgreig[m]> Ah cool well there you go

21:47 <adamgreig[m]> Makes sense, and I guess you don't want to model it as 8 separate 1bit links

21:47 <whitequark[cis]> yes

21:48 <adamgreig[m]> So you generate 8 sequential bits of prbs and des/ser them essentially?

21:48 <whitequark[cis]> yep!

21:48 <adamgreig[m]> Can do the same thing as the CRC to generate them in parallel in each clock cycle

21:48 <adamgreig[m]> I guess the receiver would work the same way too but warrants a touch more thought maybe

21:49 <whitequark[cis]> yep

21:49 <adamgreig[m]> Cool, I'll ponder and write up an rfc

21:49 <whitequark[cis]> there is more use for word-wide LFSR

21:49 <whitequark[cis]> for example, generating noise (e.g. for electronic music)

21:50 <adamgreig[m]> For noise generation you maybe want a different or controllable distribution

21:50 <whitequark[cis]> it's really common to use LFSRs in practice

21:50 <whitequark[cis]> Yamaha FM chips (Sound Blaster in PC world) do this

21:50 <adamgreig[m]> Do they then shape the noise at all?

21:51 <whitequark[cis]> lemme look at the verilog

21:51 <whitequark[cis]> (people have reverse engineered the thing fully)

21:51 <adamgreig[m]> You can combine parallel lfsr words to generate white noise for instance

21:51 <adamgreig[m]> If there's a suspicious adder tree summing up bits, it might be that :p

21:52 <whitequark[cis]> https://github.com/jotego/jtopl/blob/master/hdl/jtopl.v

21:52 <adamgreig[m]> Somewhere in migen days I have a very wide parallel lfsr with a slightly interesting generator matrix where each word feeds an adder tree, paired bits sum to 2-bit signed words, they're summed to 3-bit, etc etc until you get an 8 bit sample that's quite well normally distributed

21:52 <whitequark[cis]> https://github.com/jotego/jtopl/blob/master/hdl/jtopl_noise.v

21:53 <whitequark[cis]> https://github.com/jotego/jtopl/blob/6d4eb84552160800debdc06fa543d9963799273b/hdl/jtopl_pg_rhy.v

21:53 <whitequark[cis]> this is how the noise is used

21:54 <adamgreig[m]> Not doing the same trick, at least

21:54 <adamgreig[m]> The white noise generation is probably out of scope of the lfsr rfc but might make a nice example or use case

21:54 <whitequark[cis]> ah, actually this uses bit at a time

21:55 <whitequark[cis]> not word at a time

23:56 <whitequark[cis]> adamgreig: interesting: https://github.com/GlasgowEmbedded/glasgow/pull/372/files#r1278640697

23:59 <adamgreig[m]> oh, neat