diff --git a/java_gen/codegen.py b/java_gen/codegen.py
index b84556c..d94d78a 100644
--- a/java_gen/codegen.py
+++ b/java_gen/codegen.py
@@ -50,7 +50,7 @@
         shutil.rmtree(basedir)
     os.makedirs(basedir)
     copy_prewrite_tree(basedir)
-
+    java_model.adjust_ir()
     gen = JavaGenerator(basedir)
     gen.create_of_interfaces()
     gen.create_of_classes()
diff --git a/java_gen/java_model.py b/java_gen/java_model.py
index 13a0d09..c074189 100644
--- a/java_gen/java_model.py
+++ b/java_gen/java_model.py
@@ -46,8 +46,99 @@
 import java_gen.java_type as java_type
 from java_gen.java_type import erase_type_annotation
 
+# Key is modified name of error code; value is OFErrorType value string
+error_type_map = {}
+
+def adjust_ir():
+    """
+    For Java we change of_error_message to combine the 16-bit type and code
+    fields into a single 32-bit code field and we combine the per-error-type
+    code enums into a single ofp_error_code enum. This enables the generated
+    OFErrorMsg class to have a getCode method that can return all supported
+    error codes. Otherwise we'd need to do something like having per-error-type
+    subclasses of OFErrorMsg that had a getCode that returned the different
+    error codes for each error type, which would be less convenient for clients
+    and would also entail changing the LOXI OF input files and impacting other
+    language backends.
+    """
+    for version in of_g.target_version_list:
+        of_protocol = of_g.ir[version]
+        error_type = find(lambda e: e.name == "ofp_error_type", of_protocol.enums)
+        if error_type == None:
+            raise Exception("ofp_error_type enum not found; OF version: " + str(version))
+        error_code_entries = []
+        # For each error type value look up the corresponding error code enum.
+        # Add those values to the combined entries for the new ofp_error_code
+        # enum. The name of the new value is formed by concatenating the name
+        # of the error type value with the name of the old error code value.
+        for error_type_entry in error_type.entries:
+            # Strip off the OFPxx prefix
+            prefix_length = error_type_entry.name.find('_')
+            if prefix_length < 0:
+                raise Exception("OFPET prefix not found for ofp_error_type value " + error_type_entry.name + "; OF version: " + str(version))
+            error_type_entry_name = error_type_entry.name[prefix_length+1:]
+            if error_type_entry_name == "EXPERIMENTER":
+                # There isn't an error code enum defined for the experimenter error type
+                # FIXME: Need to add support for the message ofp_error_experimenter_msg format
+                continue
+            # The per-error-type code enums follow a naming conventions where
+            # the middle part of the enum name is the same as the name of the
+            # error type value (except lower-case).
+            error_code_enum_name = "ofp_" + error_type_entry_name.lower() + "_code"
+            # Look up the error code enum from the IR
+            error_code_enum = None
+            for i, enum in enumerate(of_protocol.enums):
+                if enum.name == error_code_enum_name:
+                    error_code_enum = enum
+                    # We don't want to generate code for the per-error-type
+                    # enum so remove it from the IR
+                    del of_protocol.enums[i]
+                    break
+            if error_code_enum == None:
+                raise Exception("Error code enum not found: " + error_code_enum_name + "; OF version: " + str(version))
+            for error_code_entry in error_code_enum.entries:
+                # Strip off the prefix from the entry name
+                prefix_length = error_code_entry.name.find('_')
+                if prefix_length < 0:
+                    raise Exception("Prefix not found for error code value " + error_code_entry.name + "; OF version: " + str(version))
+                error_code_entry_name = error_code_entry.name[prefix_length+1:]
+                # Combine the entry type name and the error code name
+                error_code_entry_name = error_type_entry_name + "_" + error_code_entry_name
+                # Combine the entry type value and the error code value
+                error_code_entry_value = (error_type_entry.value << 16) + error_code_entry.value
+                # Add the enum entry to the combined ofp_error_code
+                # Note that the "OFPEC" prefix is arbitrary. It will be stripped
+                # off again during Java code generation, but there needs to be
+                # some/any prefix
+                error_code_entries.append(OFEnumEntry("OFPEC_" + error_code_entry_name, error_code_entry_value, {}))
+                error_type_map[error_code_entry_name] = error_type_entry_name
+        # We've collected all of the entries. Now we can add the enum to the IR
+        of_protocol.enums.append(OFEnum("ofp_error_code", error_code_entries, {'wire_type': 'uint32_t'}))
+
+        # We also need to patch the of_error_msg class to combine the 16-bit error
+        # type and code fields into a single 32-bit error code field
+        error_msg = find(lambda c: c.name == "of_error_msg", of_protocol.classes)
+        if error_msg == None:
+            raise Exception("of_error_msg class not found; OF version: " + str(version))
+        err_type_index = None
+        for i, member in enumerate(error_msg.members):
+            if member.name == "err_type":
+                # Keep track of the error type index so we can remove it once
+                # we've finished iterating
+                err_type_index = i
+            elif member.name == 'code':
+                # Change the code to be a 32-bit ofp_error_code enum value
+                error_msg.members[i] = OFDataMember("code", "ofp_error_code")
+        if err_type_index == None:
+            raise Exception("err_type member of of_error_msg not found; OF version: " + str(version))
+        del error_msg.members[err_type_index]
+
+
+def gen_error_type(enum_entry):
+    return "OFErrorType." + error_type_map[enum_entry.name]
+
 class JavaModel(object):
-    enum_blacklist = set(("OFDefinitions",))
+    enum_blacklist = set(("OFDefinitions", "OFPortNo"))
     enum_entry_blacklist = defaultdict(lambda: set(), OFFlowWildcards=set([ "NW_DST_BITS", "NW_SRC_BITS", "NW_SRC_SHIFT", "NW_DST_SHIFT" ]))
     # OFUint structs are there for god-knows what in loci. We certainly don't need them.
     interface_blacklist = set( ("OFUint8", "OFUint32",))
@@ -166,6 +257,7 @@
     enum_metadata_map = defaultdict(lambda: JavaModel.OFEnumMetadata((), None),
             OFPortFeatures = OFEnumMetadata((OFEnumPropertyMetadata("PortSpeed", java_type.port_speed, gen_port_speed),), None),
             OFPortState = OFEnumMetadata((OFEnumPropertyMetadata("StpState", java_type.boolean, gen_stp_state),), None),
+            OFErrorCode = OFEnumMetadata((OFEnumPropertyMetadata("ErrorType", java_type.error_type, gen_error_type),), None),
     )
 
     @property
diff --git a/java_gen/java_type.py b/java_gen/java_type.py
index 1dfb265..913992b 100644
--- a/java_gen/java_type.py
+++ b/java_gen/java_type.py
@@ -312,6 +312,8 @@
 
 
 port_speed = JType("PortSpeed")
+error_type = JType("OFErrorType")
+
 boolean = JType("boolean")
 
 generic_t = JType("T")
diff --git a/java_gen/templates/const.java b/java_gen/templates/const.java
index 2cd0101..413c946 100644
--- a/java_gen/templates/const.java
+++ b/java_gen/templates/const.java
@@ -36,7 +36,6 @@
 //:: include("_imports.java", msg=enum)
 
 public enum ${class_name} {
-
 //:: for i, entry in enumerate(enum.entries):
 //::    if enum.metadata.properties:
 //::        params = "({})".format(", ".join(entry.constructor_params))