Logo TIB AV-Portal Logo TIB AV-Portal

Subclassing in Newbus

Video in TIB AV-Portal: Subclassing in Newbus

Formal Metadata

Subclassing in Newbus
realizing newbus' potential
Title of Series
CC Attribution 3.0 Unported:
You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor.
Release Date

Content Metadata

Subject Area
A brief tutorial for the subclassing part of the FreeBSD configuration system (known for years as newbus). The author will present work bringing this power to legacy portions of the system, as well as suggestions for future work in this fruitful area. This lecture will present a background of the FreeBSD driver system. The subclassing part of this system is radically under-documented. A companion document for this lecture will amplify the current documentation and provide additional examples to illustrate the power of the subclassing system. The lecture will then shift to reviewing the work the author has done to use these techniques to help map items in the kernel device tree to device nodes in the devfs tree.
PDF Slides Free processes Computer animation projects Flash bits potential
polymorphic binding functionality Super widgets code routine The list part Kapsel number Types objects objects spaces aerodynamic design Recursive message-based Abstract classes data types Context font polymorphic Super coma bits Kapsel programs open subsets CAN-bus Types means message-based Computer animation topology different classes BUS objects Recursive
states visualization programs variance data management mechanisms different BUS framework classes systems polymorphic Arm screens namespacing CIs effects bits instance mechanisms hierarchy Types data management interfaces configuration input Router implementation Super mud Integrationen PCI infinity regular approximate events number versions topology bridges hierarchy spaces Direct configuration interruptions platforms surjections information Super runtime interfaces code coma attitudes system call approximate patterns Allocation Computer animation visualisation software functions topology life classes BUS objects protocols Windows libraries report
software engineers Slides Virtual Home Environment functionality machine 3rd coma system call programs signatures mathematics kernel Computer animation URN functions interfaces testing BUS table Type Safety Router data types
polymorphic conic Actions code water open subsets clients part total mathematics Types different objects BUS aerodynamic design vertices Recursive extent Abstract Type Safety systems classes exception polymorphic PCI bits part Kapsel several open subsets Types message-based means macros interfaces progress Recursive Super services maximal Continuation drivers PCI smart rules objects topology bridges Direct testing Gamma protocols CAMS message-based macros platforms data types matchings Super information interfaces smart coma gute applications kernel Computer animation software topology classes BUS objects table protocols Abstract
binding Actions runtime user interfaces unit CAD routine argument part heads sun mechanisms different BUS information model extent curves Allocation descriptions classes systems man screens Arm reps point CIs binding The list bits several message-based interfaces different website sort WAN point Slides topological functionality Super regression trees drivers PCI The list number topology mazes structure protocols Sum macros addresses modules addition Super interfaces smart coma 6th system call Pointer Computer animation topology classes protocols Fingerabdr├╝cke
binding code corresponds time CAD routine instance part Arm mathematics Em's systems classes area mapping binding moment inner The list instance Now orders saturation points website sort Representation fitness Slides real print drivers smart training attributes second topology Hardware information Super code smart mathematics objects kernel Computer animation topology vertices classes BUS
Slides flow lines time drivers The list functions sun number Dogs topology bridges different Hardware BUS classes Serialization unit Super mapping namespacing programming The list coma bits routine drivers mathematics CAN-bus category number kernel Computer animation topology classes Right BUS
Barriers code 3rd translation sets heads automatische Ableitung Dogs different bridges configuration Em's BUS spaces processes platforms matchings PCI bits attitudes CAN-bus Types Computer animation topology interfaces Right BUS Hacker Barriers spaces
mobile key code PCI Stream bits heads HIP heads Computer animation Hardware ring spaces BUS Barriers
point track Slides functionality overhead code time singularities routine branch PowerPC part van completion different Em's law model systems Installer PDF information Blocks binding bits measures kernel Pointer Computer animation BUS cycle table
registry point Slides flow PINs Super visualization CAD approximate programs attributes different Em's Direct information response mapping reps interfaces binding bits hierarchy Computer animation URN orders classes Right Board WAN
binding Serialization information law workstation CAD code drivers instance Arm mathematics goodness Computer animation topology CRM naturally URN orders classes Sum BUS protocols
choose 3 o'clock at this would started my name's 1 Washington be talking today about subclassing above I have been on the through the project for a lot a were profusion I'm doing flash stuff is my day job and Dutch and go talked about NuBus the original talk that I had given for the title of a given today and for the talk was unlocking new busses potential but as I was working on the slides in very and talk about actually think that
I I really need a title and how I learned to stop worrying and love NuBus because of NuBus never was designed completely and it started out really good very simple and people add things to it over the years and I'm surprised that died hasn't killed somebody over that and talk a little bit
about you know what exactly new busses today but before I get into that I'll give you a little bit of background on what object-oriented is and because 2 explained subclassing to explain that a little bit and then assume everybody in this basically familiar with a concept I'll just touch on them briefly on and then talk about how and the different ways that you specialize new on and then do a comparison and with and that all talk about some about 100 busses typically used and on give a few examples of places that a code the tree that could be improved or more that might need a little work so
with that the what is object-oriented programming that's all this stuff it's dynamic dispatch which means different classes can call the same naming 2 different functions call its encapsulation so you hide the data for your class and a little anybody else C it's subtype polymorphism meaning you can treat a generic object on like you can everything else so the classic example of this is in a good way you have a bunch of widgets on the treated as the during as a collection of widgets and you call like a parody and expose routine on them when they need pain object delegation or inheritance that means you can on specialized as part of your parent class so that's on again you have to reimplement everything and then finally what's called open recursion on had actually with this 1 up when I was putting together the talk on and that's just a fancy way of saying you can refer to sell for this or something like that as well as I refer to an objects super class someone and all these things are put together you may have a number of other things as well message passing on type safety are the features that go into object-oriented stuff over the years on it's become rather than grab bag of things so the what's new
but this is kind of a visual approximation of NuBus as we have in the treated it we've got lots of you know these windows are open and those are close we've got the state and the object is clearly stats nicely things are almost the same at each layer all and by the way we've got big will interact on top and I don't know why that is but we do a seriously
NuBus is reduced eastern contrary configuration method mechanism it's built on top of k obj which is nothing more than in late binding of 4 named calls are written in C and that way we can have extensible interfaces define different protocols for when you're bringing up a bus bringing up a device probing devices it's their attaching it catching at different interesting events in the devices life like suspend resume may be shut down it also manages the namespace so you can have a number different devices that are all you are like and you'll get it teach you walk up and you get your 0 and you are 1 new ought to even if some of the attachments might be to an internal or nicer about x 86 it's not really ICA anymore but the software calls it that on PCI bus or Cottbus or whatever all that it abstracted and you get a nice place names these manager which dovetails nicely with the next thing that it does you have polymorphic attached and that's just a long way of saying that on new bus drivers arm of a particular name can attach to multiple devices all the name is a name space so it doesn't have to be we don't wind up with devices will also like bed ISO or a PC card at PCI all of them were just add so that that's a nice on it's 1 the the the framework has a number of reporting hurts we have a program called of info that let you list the device hierarchy resource information about the resources that it's are used on the resource mechanism is on bundled into a NuBus so that when new busses new types of busses implements the resource management they can just make use of the library routines that we have so and it's very hierarchical if you don't know how to get something usually ask your parents and if your parent doesn't know how to get something you ask all the way up the tree and all that so that will of summarizing a little bit more on the bus provides say abstracted way to call methods and we have a hierarchical different edge of hierarchies built into the new bus system the main 1 being the device instance tree which starts out a nexus and goes all the way down to the individual we've drivers through a number of bus drivers the we have ways to specialized classes so that when you're implementing PC card or sorry which is very much a PCI bus and if you will do does you can just say 0 use all the implementation from the CIA and Amendment you will do to us but there's a little bit of data inheritance although it's really more for kind of as a side effect of i've lots it's not really the purpose of hours I Mars exist so that a bus inputs state say state about a child and that that state can be on queried in a regular way so moves with better on this screen earlier today this is a typical device tree you start with a nexus here on the whole bunch of stuff on the work online you can see it turns out that these PCI this is a CPI is PC Irish things and USB is over here somewhere doesn't and I really going to talk too much about it on so you need to see the details but this is from a typical system it's kind of crazy alone the class hierarchy that we have and is very flat because when started there's not really a notion of any kind of hierarchy you have 1 layer and that was it you were class and you wouldn't stuff now for PCI PCI bridges but we we have inheritance so different platforms implement their own version of PCI or the PCI Bridge and we have a lot of most from open From PC on that implement their own bridge and everything else is like 1 D so this is literally as all the places in the tree or we use subclassing now and when I realized that I thought hey I can like I can use this for a few years we made better use of subclassing we could solve the other problems we have traded a unfortunately
and we don't have type safety in the function calls you have to get the function call exactly right and if you don't you have weird hard to diagnose but it's so the way that most of the drivers do it is they declare the device and the method of the C functions they put it in another method table and then and hope for the best but for a anybody that knows the probe signature you'll notice that the probe signatures wrong the scopal compiled just fine but you get a warning for so if you try to use values that are you think being passed in it won't work so but it would be less lessened to say well I know I have a lot of food programs so I can have the device probity I know that that is the proper signature I can acquire like that put it in here now if you have a signature mismatch the compiler great but it's not completely safe because any of what if I put attach here and probe here I there would that would only work if there was not all of the they had the same signature but we wouldn't catch it if they did so and
we don't have type safety and this slide summarizes all of that it turns out that we can make things safer and the future that the signatures match on it won't solve the particular probe verses attached because they have the same signature on a but if we have applied this differs from we can make them much more safer so this is my machine at home and it's done cranking through make universe and open this that and the name the 64 kernel with this change compiles and its generic I'm and also compiles lent so pretty confident that will work
so back How does new fast match up with object-oriented programming as well it matches up OK we have dynamic dispatch we have encapsulation and because we've got everything goes into a soft seen that hides it nicely and is generally no exposed functions and although some busses break that rule unfortunately PCI is a big 1 the breaks it we can have subclasses of were of subtype polymorphism I mean where you can override methods from 1 type of class to another some delegations open recursion not really begin of classes of objects but nobody really uses that all in the system of metazoan axis really act as objects accepted the really lowest layer of message passing yes that's 1 of the busses big strength abstract shouldn't do a little bit and type safety and not really right now so
what are the different ways that you can subclass in new alone it turns out that there are basically 3 that you can do to or available for and drivers and busses and the 3rd 1 joy only available for busses and only to a limited extent on so the 1st 1 of these is direct and inheritance and this is something that we don't do much in the tree right now except for various classes of PCI in this you say I am a new type of through I'm a bar that type through using the defined class macro 1 of the nice things about new busses that you can have single or multiple of you know inheritance I think we define to 5 and it would be relatively easy to have more just like in public inheritance in C + + 4 methods it inherits all the interface of the parents and allowing you to override them if you desire or keep the parents of a class the same but of generally tree it's only used to deal with particular quirks of different platforms or PCI Bridge it's not really used in our trees to to the the to any extent of progress is the 1 big exception where we add a lot of code that isn't all relevant to PCI and that is very relevant to cops in Cottbus we PCA doesn't have a notion of what's called a service which is the information the Cottbus but has on each of the cards to and I it's describe resources it uses describe what voltages it needs to be powered on with and so forth on so the next thing that we have entries an interface inheritance and really that's more of objects can implement an interface and we have about 30 different interfaces in the tree are the most common for dealing with some device Sorbus attachment and the way we use it in the tree at best thought of as a protocol all I want to attach the device and so I called so before I do that I call and Drivers probe routine it says yes I understand this device the Boston goes of OK I will attach it out and it can I do that water and it can probe all the items 1st or it can probe 1 attach 1 and the clients I don't need to be written so they don't care and fortunately all of them the in the tree down don't really care but it is up to the client devices to implement new protocols in this properly and because and we have no automated tools to test we know that they're not implemented properly when the kernel doesn't group or other device doesn't work so that's 1 of the weaknesses and that we have a new on 1 nice things though is that you not constrained to just implement 1 interface you can implement as many different faces you want you can implement all of them are part of them as your driver needs and which is very flexible so we have several devices in the tree that implement bus and devices protocols as well as 2 or 3 others for isolates the all in and see for as the cards or what have all her in and in my for 5 attachment or network drivers another 1 of and this arrangement gives us a nice separation we don't have a big tables that we can add things to anymore so that insulates drivers from change effectively unfortunately I it can be hard to change the protocol in a meaningful way you have to be very careful when you change meaning of something if you want probe but to do something new you have look at existing behavior and then figure out the new behavior you want and look at all the different drivers in the tree to see if any of them violated but it so changing the protocol can become kind of difficult finally the blossoming we
have a new busses data inheritance but that's a very limited extent right now we have 5 hours on methods to get and set i bars and and a number of macros excessive macros for the different bus values so in PCI you're you're not writing is very complicated gets Ivanov for the vendor and having positive it succeeded or not you just copy CID inventor and wraps it all up and returns it to card mixed takes advantage of this by adding a couple additional I've hours of its own that it uses but alone really there's not a lot of this doesn't really help you a lot if you trying to do data inheritance so so here's a quick example and the green on the screen is kind of hard to read for which I apologize almost trying to match the look of the website and I get a website with with very good on the screen so we've got the methods for the device that would be defined for the in the up in the file and we've got lots of a little structure that defines what the name devices how big of a soft seat allocate Florida and some of the methods that go along with it and then we've got an the macro the ties it all together that says this plus the p will attached to PC card and you know the description of the on devices here here's a day of class to use and here's a function and a function pointer to the call on around argument for that function to call and device is the module is loaded almost nobody uses those last 2 things that they can come in very handy that if we were to look at the same thing for ISA which I didn't include as a slide it will look much the same except I still would be here and the naming convention would put ice of there here here but it would share the same day of class on even if you didn't even if you have static classes of all the definitions there is only 1 that gets used this is just an allocation convenience for all very but but the interesting thing here is this device would still be it would be EP for everybody and and NuBus provides the routines to manage all the 1st EP unit I've seen your EP 0 you the 2nd EP URI P 1 on that also provides some mechanisms for saying 0 on that this address I want to have the P 3 years yourself so the so to summarize briefly model drivers driver attachments and have the same name the interface defines a protocol between different parts of the tree drivers and subclass other drivers but you have to coordinate the subclass driver has to understand how the parent drivers does all its things the and sometimes for driver attachments rather than make use of subclassing we have long lists of drivers show you an example of that here in a minute and I have the last point said the same way twice
so is a couple examples today yeah keyboard in the system and you know it attach somewhere in the system if it's it's the keyboard or attach often controller which and what action to something in the ISA-bus British army but to the nexus or at today's CPI something doesn't really matter same thing for years the keyboard together and you keyboard 0 attached to the head of USB bus which eventually went up arms this is really nice very simple but some major problems with this so if you look at them the message here by separate keyboard keyboard 1 isn't much 0 and keyboard 0 is that AT keyboard 0 and keyboard to you is that you keyboard 0 well that's runtime how do I figure this out you can look at the message but the message might disappear you could look at for a lot of sort of R and D message . bit which works great unless you put in the USB after that that was captured on more you unplug USB and put in something else in and if you work in debt and you'll see nothing I mean you can you can grab around and find that AT keyboard is there but it doesn't tell you what it's associated with so
propose a solution to this on and we'll see how well that actually works out the in the 1st
part on the keyboard is unknown to new but so will create a dummy node on attention to nexus for the keyboard marks I will create a keyboard on class that corresponds to the depth keyboard entries will be a new keyboard bead-based class that anything that's a keyboard and the system will derive from and I will go through and change all the drivers in the system that are keyboards to derive from this thankfully there's only 5 on the list of them up here and will change right now some of the drivers and don't have a device is a device to associated with them so when we get them but we need to make sure that we plan that information through to where we actually create the driver so graphically it looks like this we create base class on the keyboard we had a keyboard monks put to keyword marks in the training and then when we attach these instances we also attach a new device to you know yeah you have that's a that's a good question I the reason for that is I don't think of it before the time of the honestly that's the that's the real reason of but the other reason is traditionally in the tree there's been a correspondence between the module name the NuBus name and the thing you interact with in the system so we would get so the 3 of those if we called everything keyboard was keyboard zeros keyboard to you can the can yeah you would see that you will see that so you would you would know about as and you would you'd be able to interact with them through keyboard 0 and that would show up there but if you want to know what devices to add to your kernel you wouldn't have devised kbd you'd have to node and device a kbd that silently doesn't tell you that it's there and implements so so that's that's why I say that I came up with the solution but yeah we could we could do it in a way warrant there's there's another way out that from what I talk about TTY 0 seconds that we could potentially do instead of which would be the don't supplies at all and going create these things but at the moment add an attribute to the A. T. keyboard that says I'm at this device or have a generic way of saying that these devices are associated with this piece of hardware but then by devices I mean these nodes and slashing death are serviced by this hard purely an advisory hey this is here the sort of thing we don't necessarily trying to manage lifetimes and such with that but back and thought that all the way through there's probably some dragons and there's 1 any other questions that and to yours you can you think the yeah so so I'm looking the code that I wrote for the so the changes are easy in just drivers and for the keyboard attach to create a keyboard attached devices that passes the device so it keeps book and there's only 1 place that would attach these new and so this is what they need base class would look like I just new to print child routine so in print everything out the the keyboard driver is kind of almost nothing there which also suggests that perhaps is not the right way to go you know why haven't whether driver just there for a name and a node to associate site use the keyboard attached teams but er wrote these new routines to well on the keyboard attached keyboard attached if you want to read through that you can see my slides online so another area that we could deal with that there's kind of messing with NuBus right now as the TTY there's no real common naming convention so if it's the you are trying provides a TTY why you 0 2 t y you want of all and also CUA 0 and CUA 1 for the calling in all of the USB did wise or 1 together the TTY capital you our and they mostly matched to the devices that you put them in order to accept but if you got a multiport 0 you wind up with funky names like TTY you 0 . 3 4 the forth poured onto the 1st multiport card and what didn't and that doesn't map well to 2 new NuBus and there's 15 drivers in the tree so we've got
kind of a situation that would like this where yet uses the bus but it just doesn't seem to be put together quite right you you look at it and you go something's wrong with this so the 1 of the proposed
solutions would be to do the same thing that I did see people where we create a new TTY new but have base class struggle TTY classes from that create another 1 for potentially for an US failure reuse the same name and then we would connect the TTY to that but since we don't have a unified namespace on you run into a problem where you have a disconnect between the the port numbers and the names of them again you could use different Ventura find stuff which would be an improvement but it still would be kind of a bit of a dog's breakfast as people I like to say so we could do that and you would wind up with Devon flow adding a device equals whatever to the TTY thing but as I was by analyzing the slides I realized it would be a lot simpler just out of property here said device equals whatever and then you would know the mapping to devise you wouldn't have to insert all this extra stuff we just need to have a list of things that did that course realizing this and it also made me realize OK if I talk about that another talk much about by subclassing because the devices really get into it would be just become a resource that the and so we would not and that might be a better frankly a better way to to deal with this mess the I the other methods John and I were talking about jumbled and I were talking about this the other nite he said well you could just force you come for all of those 0 devices that's another way to deal with it but then you run into the mismatch 0 you UConn 0 attached great which of the 20 drivers was that for a cut down kernel how do I know which 1 to use and the only way to really know that is you have to look at Devon tho output and try to match things up and they don't and again multiport would break the name also and another thing way that John I talked about was well the other way to avoid this without having a device equals whatever would be to change the TTY names and was probably I should just probably stop talking about that right now because we change the TTY names in every all 5 major release and you know since since 3 I think we change them like 3 or 4 times and then 1 of the you know the 2 that's complaints I hear about previous why can I get x to work on my and so hardware and why do you keep changing the you know it's so so in my has a lot of attachment in the trees every driver adds a new attachment those centralized list to know where things are and if we didn't say in my D Base class we can make things simple and this is just again going to the same sort of on the stuff that we went through before on but natural bias much so that would be 1 way we could use you by subclassing in the tree that would not be invasive and but and I could say that I don't think it would be a bias what over what's that some in CV but there's 5 different drivers in the tree that implemented in NMC bridge the
and so we've got some a a chance you know we've
got all these different drivers alone we could in the in and see that so we could say well MMC attaches bridges attached to in and see but that's I think a little bit the wrong way around but I like dogs did is calling them all babies rather than having the different 1 joint have 1 particular 1 on your platform they don't seem to have a unique name so why for a given you need so this would be solved the way having you know thought about what does suggested 15 minutes ago I think that's probably I'm a better way to approach this and you wanted to know what kind of device you're using but on any given platform there's only once you don't have to so this would be a perfect match for that as and 1 of the things I found what was looking through this so an interesting problem in and the creates got and where it uses like a option to look like a new ah sorry to Dubai space translations and and looking into the code is let me scratching my head a little bit that you there's 3 different implementations for the want ads barriers the other 2 dogs and 1 that Indian modification and the others general in the tree we do any modification the bus space where and why would 1 type a bus attachment need the barriers and the other not can be scratching my head and trying to figure that out so this is a different set of methods that do that and this is the different OK so we have the barrier here nobody here and so on Indian manipulation here and if you look at the other problem to get the right offsets stuff I I
like I'm looking at this code I was wondering what's wrong with this picture and all I don't have the answer key for this so I don't even know what to say about this
so only yeah that's what the scratching my head a little bit so I thought I'd toss it into the talk and see if I the something here we need to to do something about and also getting ready to go off and implement another attachment to for the whole winter as the HCI on device that's on on mobile and hoping to be able to use the FTI 1 because it should just be in the tth re anyway that's all I
have of my talk I guess I around a little bit short of does anybody have any questions that the John work on it you know want and you will end up with a so you're so that you're suggesting that we place just the NuBus name and hello OK and then how do we map keyboard 0 2 that with the new and different pretty different approach has it would also right how does X know which keywords to open for how we can figure that OK so the installer solve the problem for us is the answer certainly be West of a hassle to to to do we would still need to pass the name and to the creation routine so we have some some stuff to work on they're just you yes this is the 1st all it was so and this is to you can make it and a method of a so the suggestion is to make and add a new NuBus method that we keep track of which module the device T. came from and you could then couldn't you right all OK if you will and the other and again that's actually that's and that's a good idea we we could very much to that Brooks the device equals block the new information so we we use the model to use and yeah we should talk that's another interesting and you would buy would base I would do it basically is treating it as a resource on on the device so that all the resource code that's printing that but the different yeah yeah yeah that needs to be cleaned up as well so this is something you know things are a bit of a mess and that's
why I put this slide don't think that this will out yes no the I you how to do what was a performance like in your branch when you did that they a this yeah only on the slowest 386 and we have you know what the instruction cycle time approach any kind of overhead for that you have to stay will a lot of those and taken out over the years much to on Scott's should in the really suffered that for that particular lunch a few times however so while so yeah I don't know don't how I know power PC uses that to implement on different the EM dispatch for the difference the difference between what and the old Macintosh which is called something else in the kernel I can't remember right now but of Minorities there what's your have experience with that of what's the to have what's the overhead like in using it for that again is that something you been able measure or is that know we've done it and the thing booted doesn't feel is slow OK so it's not and that the question that and I I we use the so was really saying that the the the common for everybody else in the room was that on for relocatable code it's actually faster to cultural function pointer has to go through the got table again this that makes that makes good sense and any other questions or comments discussion point yes you know what you were what we will not that I know of but this is the crowded tend to have to be easy to add I think and like right but the part of the problem is that KDD 0 to uncover new at all so it's it's allocated but by find the system but you see little JRC we have this on the
slide judges in the cave
81 is allocated 1st for a keyboard marks and and keyboard 0 is allocated and then keyboard to so that suggests that in a some reservation going on that we might you might be able to tap into but I don't think there's a good interface to do that right now we should probably add 1 it's not yeah we don't we don't have a good mapping that the the exact problem I have with different TTY from a different boards and when everybody comes up in a different order because it's a little faster and a little slower 0 I didn't have that when put in or you know I rearrange a little bit and now to get to my noticeboard it's it's to tip the you know you column 3 instead you come to our 1 or something know it's this the rest of the the problem with that is if I see devices through this path before with these attributes on I gave at this names that is I would have done so you can but it was a very the and this is what is the the this was the yeah we don't really have a registry and a lot of people consider this a big feature and I was this all of this is this is the from the yeah that's another not so feature a lot of people like really like so in so yeah there's not a good solution to the sound problem and we probably need 1 you know I would I would agree with that anything else at this point a other questions this is what so many of the story of well I to this for the keyboards people are couple lukewarm response I would say for my solution and I'm going I was planning on implementing it for 42 wise but of there might be better ways that we talked about during the talk and then as you came in late at but I think we were you were here for that we were talking about the adding a device entry in Devon flow so that we can associate a device the was something in such data that the user can interact with so that you can look up and map that and on and so forth of and this program by the use of the fact that the the war and this is this is what you don't know what you think of the way in which From here to here is that expects you to go so you the the yeah I would agree I totally agree it's it's a pain for me and on how users start every day and I'm annoyed by it every day and the work of of of of of your of your could be the yet at the time of day is it all right in the global reason I chose to attack keyboard was there were on 5 or
5 devices are needed to touch and I wanted to get it right with this before I went and touch the 20 devices that are so far in you know we have we where we have 20 different drivers implement USB serial in archery we find that the sum of you there was no need for or you can alter the catch and SUSY still run see them today OK all also in a I also have an e-mail yes so there's of some both the objective nature of is the only the if you want and here were this is done I OK so there they're not so that they don't implement the sth CI protocol in the laws here usual labeled some other things that instruments and tools which will be called upon to station on the you can't you have a datasheet orders the Linux driver for the whole get that's good to keep in mind that that's a good piece of information OK if there are no more questions I think will call the will have