diff --git a/doc/manuals/vty/sgsn_vty_additions.xml b/doc/manuals/vty/sgsn_vty_additions.xml
new file mode 100644
index 0000000..c9de19a
--- /dev/null
+++ b/doc/manuals/vty/sgsn_vty_additions.xml
@@ -0,0 +1,113 @@
+<vtydoc xmlns='urn:osmocom:xml:libosmocore:vty:doc:1.0'>
+    <node id='21'>
+    <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>
+</vtydoc>
