In my experience, context-sensitive languages and linear bounded automata are frequently skipped or breezed over in computability theory courses, and are even left out of some notable text books, although finite and pushdown automata receive a lot of attention. Surely there must be a good reason for why LBAs are given less focus than their counterparts?
With "appropriate" modifications we can turn these classes into complexity classes; Finite Automata into $NC^1$, CFL into LogCFL, and LBA into PSPACE.
It should now be quite clear why we are interested in the first two more than LBA. The first two naturally fit into the usual definition of feasible computation. But PSPACE does not.
Well, ask your professor why he did it. I can only guess.
They are not as interesting as Turing complete models and PDA because they are in the void of uselessness* they share, of course, with their language equivalent: not as powerful as possible, but already very much intractable.
Another reason might be that not as much is known (guessing here) about them, but that might come down to a chicken-egg-problem.
It is unclear weather $NLBA = DLBA$, so that might pose problems for didactics. Also, typical proofs (e.g. accepted language, model equivalences) are much harder than for other models.
(*) deliberate exaggeration
It seems that not just CSG but also CFG, ... are out of fashion these days. I think these days automata and PDA are usually thought in computability/complexity theory courses (if at all) and there they are included not for their own sake but to introduce Turing Machines.
Grammars are probably interesting for compiler theory but not so much for computability/complexity to be included in an introductionary undergrad course. There are too many topics that one would like to cover but a one semester course is just too short and we have to select and many of these topics which we cannot cover because of time restrictions are way more interesting than LBA.
Regular expressions and CFGs are used in practice for parsing code (that is, programming languages). The reason is that there are very efficient algorithms for parsing them. LBAs, on the other hand, are too powerful to actually use in that context.
One historical origin of automata theory is the subject of compiler construction. For the reason mentioned above, only regular languages and CFGs are useful for constructing compilers (notwithstanding the fact that attributive grammars are not really CFGs, and that CFG parsing algorithms don't really parse the entire class of CFGs). LBAs might have been invented by Chomsky as some intermediate level of complexity between the mundane and "English". So perhaps the proper place to teach them is in linguistics courses rather than computer science ones!