Creating IBIS-AMI Models and Optimizing SerDes Design with SerDes Toolbox - MATLAB
Video Player is loading.
Current Time 0:00
Duration 18:22
Loaded: 0.90%
Stream Type LIVE
Remaining Time 18:22
 
1x
  • Chapters
  • descriptions off, selected
  • en (Main), selected
    Video length is 18:22

    Creating IBIS-AMI Models and Optimizing SerDes Design with SerDes Toolbox

    Explore the creation of IBIS-AMI models using SerDes Toolbox™ in MATLAB®, covering setup, equalization, and analysis for optimized SerDes design in this detailed tutorial. In this video, we delve into the advanced capabilities of the SerDes Toolbox, showcasing the streamlined process of designing and analyzing a SerDes system. The focus of this video is on the practical application of the SerDes Designer app, which facilitates the creation of accurate IBIS-AMI models for both transmitters and receivers directly from Simulink®.

    Through practical examples, viewers learn to configure blocks like Feed Forward Equalization (FFE) for the transmitter and Continuous Time Linear Equalization (CTLE) and Decision Feedback Equalization (DFE)/Clock Data Recovery (CDR) for the receiver. The video highlights the flexibility of the app in configuring these blocks, demonstrating adjustments in tap weights and modes for FFE, as well as setting up multiple CTLE curves to match specific design requirements.

    Transitioning from the app, the video shows how to export the designed SerDes system into a Simulink® model for time-domain analysis. This step is critical for evaluating the system's performance under realistic conditions and making necessary adjustments before finalizing the IBIS-AMI models. The export functionality seamlessly integrates the configured SerDes system into Simulink, including the setup of stimulus blocks and eye diagram scopes for comprehensive analysis.

    By the end of this video, viewers will have gained insights into the efficient design and analysis of SerDes systems using the SerDes Toolbox. The video not only emphasizes the practical aspects of creating IBIS-AMI models but also highlights the extensive resources available for further customization and optimization. For those looking to deepen their understanding of SerDes system design and the creation of compliant IBIS-AMI models, this video serves as an essential guide, illustrating the powerful capabilities of the SerDes Toolbox in streamlining complex design processes.

    Learn more about SerDes Toolbox

    Published: 6 Jan 2021

    Welcome to MATLAB mini session. Mike Mayer will be presenting an example to demonstrate efficient design with SerDes and export IBIS-AMI model.

    What I'm going to show you today is an example of creating an IBIS-AMI model with SerDes Toolbox. And just for the sake of example here, since we have a short time, it's going to assume you understand the architecture of the device you're trying to model. And then you're going to create that and create an IBIS-AMI model for that.

    So without further ado here, I'm going to share. And somebody can tell me when they see MATLAB.

    Yeah.

    OK, good. So SerDes toolbox has an app that comes with it called SerDes Designer. And that is where you typically start and where we'll start today. And this app allows you to floorplan the equalization algorithms for Rx that you could then use to make your IBIS-AMI model.

    So it's a pretty simple app. There's an area up on the tool strip for configuration. And some of these are the Symbol Time and Samples per Symbol. Those are setting up the analysis conditions. They're not going to affect the model in any way, just the conditions under which you analyze. Same with the target bit error rate.

    Modulation you have NRZ, Pam3, and Pam4. These do affect the model obviously, as well as the analysis. And then you can have Differential or Single ended signaling, which again will affect the model as well as how things are analyzed. Those typically are things you set based on the particular interface for your modeling.

    And then the floor planning area is what, in IBIS-AMI terms, would be called the analog channel. So it's the analog output of the transmitter, a simple channel model, and then input into the receiver. And actually, the analog out and analog in end up in the IBIS file itself. They're not part of the compiled DLL. They're the analog model part of the IBIS file. And then what you add is equalization. And that actually is what gets compiled into the IBIS-AMI models in the DLLs.

    So let's say just for the sake of example here, we've got a transmitter that has an FFE. And so we just click on our blocks we have here. And for the sake of example, let's say we have a CTLE in the receiver and a DFE/CDR.

    We have other blocks here in the block library. AGC, so Automatic Gain Control, variable gain amplifier, saturating amplifier, and a CDR by itself, and then a pass through block. We don't have time to talk about that. But for customization purposes, if you're trying to do something that isn't here, that's very custom in Simulink, it's handy to put down a pass through block and then fill it in in Simulink essentially. But we'll just stick with the standard blocks here.

    And for all these blocks there's configuration. So for example, the FFE, let's say, we know how many taps. By default here, down below and left, there's a vector. And these are the taps.

    So the largest value here will be considered the main tap. Anything to the left of it are pre cursor taps. To the right are post cursor.

    So if we say, well, we only have two post cursor taps, it's easy enough, to just delete one of those zeros. And now we've got a two post cursor tap FFE. So you can configure that that way. The mode is fixed or off. So you can set that.

    The CTLE has a little more configuration possibility. One, when you're setting up the curves, you can have more than one curve. The easy way, if you can configure this way, you can use the gain at DC, the gain at the peaking frequency, and the peaking frequency itself to set.

    There are actually three different ways to do that, based on whether you're specifying the gain attitude, or the difference between what it calls peeking gain, the difference between the DC gain and AC gain. And then again, you can have vectors here. So there are nine elements in each of these. These are nine different CTLE curves.

    And the nice thing about the CTLE, if you are configuring it based on either you've got the data here-- we'll look at a more complex one later-- but there is a plot that you can add that has those curves. So you can see directly as you're configuring it what you've got. So if I change one of these, change the gain on one of them, I'll see over here on the gain that it updated, changed it. So I can set these based on data I have.

    If I have something more complicated than that, like for instance, transfer functions, one of the specification methods here is gain pole zero matrix. And in this mode, you have a matrix where every row has the gain at DC and then pole zero pairs. So you can still have multiple configurations but now you can get the gain poles in zero safe from transfer function data.

    In fact, we have resources on that. There's a video, there's some other materials. There's an example with a product of how to take transfer function data turn it into a gain pole zero matrix. So those are the ways you can configure the curves.

    The modes are adapt, which means the CTLE is going to look at the pulse response to the channel and pick the best curve based on looking at what the-- it's really a signal-to-noise ratio of the eyes, which curve gives the best eye. Or off or fixed. Fixed meaning the user can choose which configuration. Whereas, adapt, of course, it's choosing it automatically.

    Then the DFE/CDR is the taps again. So you can change this vector to add taps or remove taps. And then you have the min and max tap values here for configuration.

    Then once you've got things configured, you can also look at, of course, the statistical eye, all these things. This app does a statistical analysis, where it's taking the pulse response to the channel and generating the statistical eye from that. And using-- we call it the hula hoop algorithm to determine where the clock would be because all you've got is a statistical eye.

    It's linear time invariant so we can't really model a CDR in time in this mode. But we can look at the pulse response and figure out the ideal, most likely clock position. And then that's what gets used here in the analysis. That's why you see a clock PDF here.

    And so you could look at the eye. You can look at the pulse response. And it shows you with equalization and without equalization. So it's easy to compare the two. There's a report which is handy for looking at some measurements. And you can take these things and move them around.

    So for example, I can put the report in another spot so I can see other plots and the report. But it measures the eye height, the eye width, the area. It does the COM calculation, vertical eye closure. And then since the CTLE was in adapt mode, it says, which of the configurations it selected. And the DFE/CDR was in adapt mode so it said, well, here are the top settings. Again, by looking at the pulse response, it said these would be the tap settings that the DFE would settle on if it was running in a time domain simulation.

    So the idea is you can floorplan your blocks, configure them, do some simple analysis here to make sure everything is working right. Then in order to export to IBIS-AMI, we do that from Simulink. So you need to go from here to Simulink. And up in the upper right here, there's an Export button.

    I already did that. It takes a minute. And also, it takes a minute for Simulink to compile before it simulates. But what you get in Simulink is a Simulink model that is essentially the same thing that you just had in the app here. And I'll put them a little bit so we can see both.

    In Simulink, there's a configuration block, which if you look at what's in it, it's everything that was in this configuration tool strip. The Symbol Time, Samples for Symbol, all that set up. If you look at the Tx, it's a block. But underneath that it has the FFE. And the Rx is a block. And underneath that we have the CTLE and the DFE/CDR.

    And the analog channel here is the analog out, the analog in, and our simple channel model. So everything that was in the app is in Simulink. In addition, it's got a stimulus block because now we can run a time domain simulation. And then there's this eye diagram scope at the end.

    So I'm just going to run this. And it's going to run a time domain simulation. And it also is going to run the same statistical analysis that the app ran. So we'll see here when the simulation is done that we'll have multiple windows here of results.

    So this eye diagram is the accumulating form in an eye diagram scope. It's the block here at the end, outside of the Rx. Then this other window, top four plots show the plots the app did. It's the same statistical analysis, the same things you get from there are taking the time domain results and showing you the results in the same form that you would get in statistical. So you have the eye with the clock.

    I only ran 2,000 bits here because of time. So the CDR didn't have time to actually settle fully. So the clock TDF looks a little bit odd. But it also has the same eye measurements. So you can run the same and look at the same results from the statistical domain and from the time domain.

    You can do that analysis here from configuration. You can also look at the data in the IBIS model. So we've got the IBIS-AMI Manager. And it shows you the IBIS file that's going to be created. And a lot of this data comes from the analog models. And you'll see it's going to have the algorithmic model keyword, which is how we point to the compiled model.

    There's an AMI Tx tab, which is the IBIS-AMI parameters that control that serdes Tx And we have the FFE. And our block has a mode parameter and the tapweights parameter. You can modify them here if you want to change their ranges or change their default values. So the AMI file/model will have that.

    You can add parameters. There's a lot of customization that can be done. If you have a different set of controls, for example, for your FFE you can do that.

    And then the Rx, of course, has a CTLE and its parameters, the DFE/CDR and all its parameters. So again, if you're having to customize, your parameters could have different names, different whatever. You can customize there.

    And we'll look back at Simulink for a second here. We actually export, which is this first tab. What's going to happen is, if we look at Tx again, there's an init block. This actually is a piece of code that got automatically generated when we exported to Simulink. And that will compile into the init call in the IBIS-AMI model.

    And everything in here, which has the wave in, wave out, that's the time domain part. So that will compile and become the get wave call in the IBIS-AMI model. So we have both the init and get wave.

    And if you go over and look at the receiver, you'll see the same thing. There's an init block for the receiver and then the blocks that become the get wave. And if we look at init, it's actually a function.

    And there's code here. It's actually a function. It's returning the Impulse response. But if you look down in the middle, there's a section here where if you need to-- for example, you want to use a different adaptation algorithm for the CTLE, or some other kind of customization. You can add code here that will get compiled into the init. And because it's between these special comments, if you have to refresh things and rebuild this, whatever code you put there is preserved. So you don't lose it.

    Above it, what's happening here in init, is it's instantiating a CTLE. This is the Rx. And then setting its parameters, it's instantiating a DFE/CDR setting its parameters. And then you could have code here to do things. And then it's calling each one with the impulse response. So it can do its adaptation and return the impulse response with equalization included.

    So it's doing everything that an IBIS-AMI init call is supposed to do. And so that's how we can compile and have both the init and the get wave in our model.

    So go back to our IBIS-AMI Manager. So the way we export, we have some controls here to say, are we exporting both the Tx and Rx, or are we exporting the I/O model? If you look at, say, DDR5, you might combine the models instead of a separate receiver and transmitter model. Re-drivers and re-timers, that's the keywords to link a receiver and transmitter together to be a re-driver or re-timer. You can name them.

    For the corners in the analog model, you can set how much the min and max are off in percentage from the typical. You can say whether they're both init and get wave, or one or the other only, for both the Rx and Tx. Ignore bits is an IBIS-AMI parameter that says, we're going not start accumulating in time domain until that many bits have simulated so that the CDR and the DFE have time to stabilize and they're at a stable steady state condition.

    And then you can say what you're going to export, whether all the files or not. You hit the Export button. It uses MATLAB Coder and Simulink Coder. And then if you have a supported compiler, C compiler on your machine, it will compile into a DLL.

    And what you end up with, which I have an example here. There's an IBIS file that it writes out that has models that came from those analog models. There's the Rx AMI file, which has all the parameters.

    Here's the CTLE and its parameters. And there's Tx AMI file, again, with the FFE parameters. And then we have the DLL for the Rx and the DLL for the Tx.

    So it's a complete set of files written out, ready to go there. They're IBIS-AMI standard. They'll run in any AMI simulator. And at this point you're good to go. You can take those and run them in any simulator.

    So I think we're within time. And that is probably the briefest overview of that process we can give. There's a lot more that could be said. Especially if you're customizing things, there's a lot more to be done. But there are a lot of resources available. And obviously, we're happy if somebody wants to know more about it to talk about that.

    That concludes this session. Thank you for watching. For this example and more, please visit the SerDes Toolbox product page at mathworks.com. Thank you.