diff --git a/ChangeLog b/ChangeLog
index 4011512..2fc2d01 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -15,12 +15,13 @@
      provided. Full list of renamings in scripts/data_files/rename-1.3-2.0.txt
    * Headers are now found in the 'mbedtls' directory (previously 'polarssl').
    * The following _init() functions that could return errors have
-     been split into an _init() that returns void and another function:
+     been split into an _init() that returns void and another function that
+     should generally called shortly after init and can return errors:
      mbedtls_ssl_init() -> mbedtls_ssl_setup()
      mbedtls_ccm_init() -> mbedtls_ccm_setkey()
      mbedtls_gcm_init() -> mbedtls_gcm_setkey()
-     mbedtls_hmac_drbg_init() -> mbedtls_hmac_drbg_init(_buf)()
-     mbedtls_ctr_drbg_init()  -> mbedtls_ctr_drbg_init(_buf)()
+     mbedtls_hmac_drbg_init() -> mbedtls_hmac_drbg_seed(_buf)()
+     mbedtls_ctr_drbg_init()  -> mbedtls_ctr_drbg_seed()
    * mbedtls_ssl_set_ca_chain() lost its last argument (peer_cn), now set
      using mbedtls_ssl_set_hostname().
    * mbedtls_ssl_set_session_cached() changed prototype (only one context
