diff --git a/doc/manuals/vty/sgsn_vty_additions.xml b/doc/manuals/vty/sgsn_vty_additions.xml
index dd26dba..660b695 100644
--- a/doc/manuals/vty/sgsn_vty_additions.xml
+++ b/doc/manuals/vty/sgsn_vty_additions.xml
@@ -1,113 +1,6 @@
 <vtydoc xmlns='urn:osmocom:xml:libosmocore:vty:doc:1.0'>
-    <node id='26'>
-    <child_of nodeid='4' />
-    <name>SGSN Configuration Node</name>
-    <description>Configure the remote GGSN, access-control and other
-    attributes of the SGSN</description>
-	<command id='gtp local-ip A.B.C.D'>
-	<description>
-		Configure the local IP address to which the SGSN should
-		bind for the Gp interface (towards the GGSNs).
-
-		Please note that in case you would like to run the GGSN
-		on the same machine as the SGSN, you can not run both on
-		the same IP address.  It is suggested to use 127.0.0.1
-		for the SGSN and 127.0.0.2 for the GGSN in such
-		situations.
-	</description>
-	</command>
-	<command id='ggsn &lt;0-255&gt; remote-ip A.B.C.D'>
-	<description>
-		Configure a static GGSN with a given numeric identifier
-		to use the specified remote IP address.
-	</description>
-	</command>
-	<command id='ggsn &lt;0-255&gt; gtp-version (0|1)'>
-	<description>
-		Configure whether to use GTPv0 or GTPv1 towards the
-		specified GSSN number.
-	</description>
-	</command>
-	<command id='ggsn dynamic'>
-	<description>
-		Enable dynamic resolving of GGSNs based on DNS resolving
-		the APN name like in a GRX-style setup.  Changing this
-		setting requires a re-start of the SGSN.
-	</description>
-	</command>
-	<command id='grx-dns-add A.B.C.D'>
-	<description>
-		Use the specified IP address for DNS-resolving the AP
-		names to GGSN IP addresses
-	</description>
-	</command>
-	<command id='apn APNAME ggsn &lt;0-255&gt;'>
-	<description>
-		Map the given APN Name to the given GGSN number.
-	</description>
-	</command>
-	<command id='apn APNAME imsi-prefx IMSIPRE ggsn &lt;0-255&gt;'>
-	<description>
-		Map the given APN Name to the given GGSN number _only_
-		if the IMSI matches the given prefix.
-	</description>
-	</command>
-	<command id='imsi-acl (add|del) IMSI'>
-	<description>
-		Add or delete the given IMSI to/from the global Access
-		Control List.
-	</description>
-	</command>
-	<command id='auth-policy (accept-all|closed|acl-only|remote)'>
-	<description>
-		Configure the Authorization policy of the SGSN.  This
-		setting determines which subscribers are permitted to
-		register to the network.
-	</description>
-	</command>
-	<command id='gsup remote-ip A.B.C.D'>
-	<description>
-		Set the IP address of the HLR (gateway) for the GSUP protocol.
-		This setting only applies if auth-policy remote is used.
-	</description>
-	</command>
-	<command id='gsup oap-id &lt;0-65535&gt;'>
-	<description>
-		Set the OAP client ID for authentication on the GSUP
-		protocol.
-		This setting only applies if auth-policy remote is used.
-	</description>
-	</command>
-	<command id='gsup oap-k K'>
-	<description>
-		Set the OAP shared secret key K for authentication on
-		the GSUP protocol.
-		This setting only applies if auth-policy remote is used.
-	</description>
-	</command>
-	<command id='gsup oap-opc OPC'>
-	<description>
-		Set the OAP shared secret OPC for authentication on the
-		GSUP protocol.
-		This setting only applies if auth-policy remote is used.
-	</description>
-	</command>
-	<command id='access-point-name NAME'>
-	<description>
-		Globally allow the given APN name for all subscribers.
-	</description>
-	</command>
-	<command id='cdr filename NAME'>
-	<description>
-		Set the file name for the call-data-record file,
-		logging the data usage of each subscriber.
-	</description>
-	</command>
-	<command id='cdr interval &lt;1-2147483647&gt;'>
-	<description>
-		Set the interval (in secodnds) for the call-data-record
-		file.
-	</description>
-	</command>
+    <node id='config-sgsn'>
+	    <description>Configure the remote GGSN, access-control and other
+	    attributes of the SGSN</description>
     </node>
 </vtydoc>
