* When a failure reason code is received, one can assume that the channel
  * is not connected.
  */
-typedef void (*xpc_channel_func) (enum xp_retval reason, partid_t partid,
+typedef void (*xpc_channel_func) (enum xp_retval reason, short partid,
                                  int ch_number, void *data, void *key);
 
 /*
  *
  * All other reason codes indicate failure.
  */
-typedef void (*xpc_notify_func) (enum xp_retval reason, partid_t partid,
+typedef void (*xpc_notify_func) (enum xp_retval reason, short partid,
                                 int ch_number, void *key);
 
 /*
 struct xpc_interface {
        void (*connect) (int);
        void (*disconnect) (int);
-       enum xp_retval (*allocate) (partid_t, int, u32, void **);
-       enum xp_retval (*send) (partid_t, int, void *);
-       enum xp_retval (*send_notify) (partid_t, int, void *,
+       enum xp_retval (*allocate) (short, int, u32, void **);
+       enum xp_retval (*send) (short, int, void *);
+       enum xp_retval (*send_notify) (short, int, void *,
                                        xpc_notify_func, void *);
-       void (*received) (partid_t, int, void *);
-       enum xp_retval (*partid_to_nasids) (partid_t, void *);
+       void (*received) (short, int, void *);
+       enum xp_retval (*partid_to_nasids) (short, void *);
 };
 
 extern struct xpc_interface xpc_interface;
 
 extern void xpc_set_interface(void (*)(int),
                              void (*)(int),
-                             enum xp_retval (*)(partid_t, int, u32, void **),
-                             enum xp_retval (*)(partid_t, int, void *),
-                             enum xp_retval (*)(partid_t, int, void *,
+                             enum xp_retval (*)(short, int, u32, void **),
+                             enum xp_retval (*)(short, int, void *),
+                             enum xp_retval (*)(short, int, void *,
                                                  xpc_notify_func, void *),
-                             void (*)(partid_t, int, void *),
-                             enum xp_retval (*)(partid_t, void *));
+                             void (*)(short, int, void *),
+                             enum xp_retval (*)(short, void *));
 extern void xpc_clear_interface(void);
 
 extern enum xp_retval xpc_connect(int, xpc_channel_func, void *, u16,
 extern void xpc_disconnect(int);
 
 static inline enum xp_retval
-xpc_allocate(partid_t partid, int ch_number, u32 flags, void **payload)
+xpc_allocate(short partid, int ch_number, u32 flags, void **payload)
 {
        return xpc_interface.allocate(partid, ch_number, flags, payload);
 }
 
 static inline enum xp_retval
-xpc_send(partid_t partid, int ch_number, void *payload)
+xpc_send(short partid, int ch_number, void *payload)
 {
        return xpc_interface.send(partid, ch_number, payload);
 }
 
 static inline enum xp_retval
-xpc_send_notify(partid_t partid, int ch_number, void *payload,
+xpc_send_notify(short partid, int ch_number, void *payload,
                xpc_notify_func func, void *key)
 {
        return xpc_interface.send_notify(partid, ch_number, payload, func, key);
 }
 
 static inline void
-xpc_received(partid_t partid, int ch_number, void *payload)
+xpc_received(short partid, int ch_number, void *payload)
 {
        return xpc_interface.received(partid, ch_number, payload);
 }
 
 static inline enum xp_retval
-xpc_partid_to_nasids(partid_t partid, void *nasids)
+xpc_partid_to_nasids(short partid, void *nasids)
 {
        return xpc_interface.partid_to_nasids(partid, nasids);
 }
 
 struct xpc_interface xpc_interface = {
        (void (*)(int))xpc_notloaded,
        (void (*)(int))xpc_notloaded,
-       (enum xp_retval(*)(partid_t, int, u32, void **))xpc_notloaded,
-       (enum xp_retval(*)(partid_t, int, void *))xpc_notloaded,
-       (enum xp_retval(*)(partid_t, int, void *, xpc_notify_func, void *))
+       (enum xp_retval(*)(short, int, u32, void **))xpc_notloaded,
+       (enum xp_retval(*)(short, int, void *))xpc_notloaded,
+       (enum xp_retval(*)(short, int, void *, xpc_notify_func, void *))
            xpc_notloaded,
-       (void (*)(partid_t, int, void *))xpc_notloaded,
-       (enum xp_retval(*)(partid_t, void *))xpc_notloaded
+       (void (*)(short, int, void *))xpc_notloaded,
+       (enum xp_retval(*)(short, void *))xpc_notloaded
 };
 EXPORT_SYMBOL_GPL(xpc_interface);
 
 void
 xpc_set_interface(void (*connect) (int),
                  void (*disconnect) (int),
-                 enum xp_retval (*allocate) (partid_t, int, u32, void **),
-                 enum xp_retval (*send) (partid_t, int, void *),
-                 enum xp_retval (*send_notify) (partid_t, int, void *,
+                 enum xp_retval (*allocate) (short, int, u32, void **),
+                 enum xp_retval (*send) (short, int, void *),
+                 enum xp_retval (*send_notify) (short, int, void *,
                                                  xpc_notify_func, void *),
-                 void (*received) (partid_t, int, void *),
-                 enum xp_retval (*partid_to_nasids) (partid_t, void *))
+                 void (*received) (short, int, void *),
+                 enum xp_retval (*partid_to_nasids) (short, void *))
 {
        xpc_interface.connect = connect;
        xpc_interface.disconnect = disconnect;
 {
        xpc_interface.connect = (void (*)(int))xpc_notloaded;
        xpc_interface.disconnect = (void (*)(int))xpc_notloaded;
-       xpc_interface.allocate = (enum xp_retval(*)(partid_t, int, u32,
+       xpc_interface.allocate = (enum xp_retval(*)(short, int, u32,
                                                     void **))xpc_notloaded;
-       xpc_interface.send = (enum xp_retval(*)(partid_t, int, void *))
+       xpc_interface.send = (enum xp_retval(*)(short, int, void *))
            xpc_notloaded;
-       xpc_interface.send_notify = (enum xp_retval(*)(partid_t, int, void *,
+       xpc_interface.send_notify = (enum xp_retval(*)(short, int, void *,
                                                        xpc_notify_func,
                                                        void *))xpc_notloaded;
-       xpc_interface.received = (void (*)(partid_t, int, void *))
+       xpc_interface.received = (void (*)(short, int, void *))
            xpc_notloaded;
-       xpc_interface.partid_to_nasids = (enum xp_retval(*)(partid_t, void *))
+       xpc_interface.partid_to_nasids = (enum xp_retval(*)(short, void *))
            xpc_notloaded;
 }
 EXPORT_SYMBOL_GPL(xpc_clear_interface);
 
                        (_version >= _XPC_VERSION(3, 1))
 
 static inline int
-xpc_hb_allowed(partid_t partid, struct xpc_vars *vars)
+xpc_hb_allowed(short partid, struct xpc_vars *vars)
 {
        return ((vars->heartbeating_to_mask & (1UL << partid)) != 0);
 }
 
 static inline void
-xpc_allow_hb(partid_t partid, struct xpc_vars *vars)
+xpc_allow_hb(short partid, struct xpc_vars *vars)
 {
        u64 old_mask, new_mask;
 
 }
 
 static inline void
-xpc_disallow_hb(partid_t partid, struct xpc_vars *vars)
+xpc_disallow_hb(short partid, struct xpc_vars *vars)
 {
        u64 old_mask, new_mask;
 
  *     messages.
  */
 struct xpc_channel {
-       partid_t partid;        /* ID of remote partition connected */
+       short partid;           /* ID of remote partition connected */
        spinlock_t lock;        /* lock for updating this structure */
        u32 flags;              /* general flags */
 
 /* interval in seconds to print 'waiting disengagement' messages */
 #define XPC_DISENGAGE_PRINTMSG_INTERVAL                10
 
-#define XPC_PARTID(_p) ((partid_t) ((_p) - &xpc_partitions[0]))
+#define XPC_PARTID(_p) ((short)((_p) - &xpc_partitions[0]))
 
 /* found in xp_main.c */
 extern struct xpc_registration xpc_registrations[];
 extern void xpc_check_remote_hb(void);
 extern void xpc_deactivate_partition(const int, struct xpc_partition *,
                                     enum xp_retval);
-extern enum xp_retval xpc_initiate_partid_to_nasids(partid_t, void *);
+extern enum xp_retval xpc_initiate_partid_to_nasids(short, void *);
 
 /* found in xpc_channel.c */
 extern void xpc_initiate_connect(int);
 extern void xpc_initiate_disconnect(int);
-extern enum xp_retval xpc_initiate_allocate(partid_t, int, u32, void **);
-extern enum xp_retval xpc_initiate_send(partid_t, int, void *);
-extern enum xp_retval xpc_initiate_send_notify(partid_t, int, void *,
+extern enum xp_retval xpc_initiate_allocate(short, int, u32, void **);
+extern enum xp_retval xpc_initiate_send(short, int, void *);
+extern enum xp_retval xpc_initiate_send_notify(short, int, void *,
                                               xpc_notify_func, void *);
-extern void xpc_initiate_received(partid_t, int, void *);
+extern void xpc_initiate_received(short, int, void *);
 extern enum xp_retval xpc_setup_infrastructure(struct xpc_partition *);
 extern enum xp_retval xpc_pull_remote_vars_part(struct xpc_partition *);
 extern void xpc_process_channel_activity(struct xpc_partition *);
 
  * Set up the initial values for the XPartition Communication channels.
  */
 static void
-xpc_initialize_channels(struct xpc_partition *part, partid_t partid)
+xpc_initialize_channels(struct xpc_partition *part, short partid)
 {
        int ch_number;
        struct xpc_channel *ch;
 {
        int ret, cpuid;
        struct timer_list *timer;
-       partid_t partid = XPC_PARTID(part);
+       short partid = XPC_PARTID(part);
 
        /*
         * Zero out MOST of the entry for this partition. Only the fields
            (struct xpc_vars_part *)L1_CACHE_ALIGN((u64)buffer);
        struct xpc_vars_part *pulled_entry;
        u64 remote_entry_cacheline_pa, remote_entry_pa;
-       partid_t partid = XPC_PARTID(part);
+       short partid = XPC_PARTID(part);
        enum xp_retval ret;
 
        /* pull the cacheline that contains the variables we're interested in */
 void
 xpc_teardown_infrastructure(struct xpc_partition *part)
 {
-       partid_t partid = XPC_PARTID(part);
+       short partid = XPC_PARTID(part);
 
        /*
         * We start off by making this partition inaccessible to local
 void
 xpc_initiate_connect(int ch_number)
 {
-       partid_t partid;
+       short partid;
        struct xpc_partition *part;
        struct xpc_channel *ch;
 
 xpc_initiate_disconnect(int ch_number)
 {
        unsigned long irq_flags;
-       partid_t partid;
+       short partid;
        struct xpc_partition *part;
        struct xpc_channel *ch;
 
  *               return) in which the user-defined message is constructed.
  */
 enum xp_retval
-xpc_initiate_allocate(partid_t partid, int ch_number, u32 flags, void **payload)
+xpc_initiate_allocate(short partid, int ch_number, u32 flags, void **payload)
 {
        struct xpc_partition *part = &xpc_partitions[partid];
        enum xp_retval ret = xpUnknownReason;
  *                     xpc_initiate_allocate().
  */
 enum xp_retval
-xpc_initiate_send(partid_t partid, int ch_number, void *payload)
+xpc_initiate_send(short partid, int ch_number, void *payload)
 {
        struct xpc_partition *part = &xpc_partitions[partid];
        struct xpc_msg *msg = XPC_MSG_ADDRESS(payload);
  *     key - user-defined key to be passed to the function when it's called.
  */
 enum xp_retval
-xpc_initiate_send_notify(partid_t partid, int ch_number, void *payload,
+xpc_initiate_send_notify(short partid, int ch_number, void *payload,
                         xpc_notify_func func, void *key)
 {
        struct xpc_partition *part = &xpc_partitions[partid];
  *                     xpc_initiate_allocate().
  */
 void
-xpc_initiate_received(partid_t partid, int ch_number, void *payload)
+xpc_initiate_received(short partid, int ch_number, void *payload)
 {
        struct xpc_partition *part = &xpc_partitions[partid];
        struct xpc_channel *ch;
 
 static int
 xpc_activating(void *__partid)
 {
-       partid_t partid = (u64)__partid;
+       short partid = (u64)__partid;
        struct xpc_partition *part = &xpc_partitions[partid];
        unsigned long irq_flags;
 
 void
 xpc_activate_partition(struct xpc_partition *part)
 {
-       partid_t partid = XPC_PARTID(part);
+       short partid = XPC_PARTID(part);
        unsigned long irq_flags;
        struct task_struct *kthread;
 
 irqreturn_t
 xpc_notify_IRQ_handler(int irq, void *dev_id)
 {
-       partid_t partid = (partid_t) (u64)dev_id;
+       short partid = (short)(u64)dev_id;
        struct xpc_partition *part = &xpc_partitions[partid];
 
        DBUG_ON(partid <= 0 || partid >= XP_MAX_PARTITIONS);
 static int
 xpc_kthread_start(void *args)
 {
-       partid_t partid = XPC_UNPACK_ARG1(args);
+       short partid = XPC_UNPACK_ARG1(args);
        u16 ch_number = XPC_UNPACK_ARG2(args);
        struct xpc_partition *part = &xpc_partitions[partid];
        struct xpc_channel *ch;
 xpc_disconnect_wait(int ch_number)
 {
        unsigned long irq_flags;
-       partid_t partid;
+       short partid;
        struct xpc_partition *part;
        struct xpc_channel *ch;
        int wakeup_channel_mgr;
 static void
 xpc_do_exit(enum xp_retval reason)
 {
-       partid_t partid;
+       short partid;
        int active_part_count, printed_waiting_msg = 0;
        struct xpc_partition *part;
        unsigned long printmsg_time, disengage_request_timeout = 0;
 xpc_die_disengage(void)
 {
        struct xpc_partition *part;
-       partid_t partid;
+       short partid;
        unsigned long engaged;
        long time, printmsg_time, disengage_request_timeout;
 
 xpc_init(void)
 {
        int ret;
-       partid_t partid;
+       short partid;
        struct xpc_partition *part;
        struct task_struct *kthread;
        size_t buf_size;
 
 {
        struct xpc_vars *remote_vars;
        struct xpc_partition *part;
-       partid_t partid;
+       short partid;
        bte_result_t bres;
 
        remote_vars = (struct xpc_vars *)xpc_remote_copy_buffer;
        int reactivate = 0;
        int stamp_diff;
        struct timespec remote_rp_stamp = { 0, 0 };
-       partid_t partid;
+       short partid;
        struct xpc_partition *part;
        enum xp_retval ret;
 
 int
 xpc_partition_disengaged(struct xpc_partition *part)
 {
-       partid_t partid = XPC_PARTID(part);
+       short partid = XPC_PARTID(part);
        int disengaged;
 
        disengaged = (xpc_partition_engaged(1UL << partid) == 0);
        int max_regions;
        int nasid;
        struct xpc_rsvd_page *rp;
-       partid_t partid;
+       short partid;
        struct xpc_partition *part;
        u64 *discovered_nasids;
        enum xp_retval ret;
  * remote partition's reserved page.
  */
 enum xp_retval
-xpc_initiate_partid_to_nasids(partid_t partid, void *nasid_mask)
+xpc_initiate_partid_to_nasids(short partid, void *nasid_mask)
 {
        struct xpc_partition *part;
        u64 part_nasid_pa;
 
  * Packet was recevied by XPC and forwarded to us.
  */
 static void
-xpnet_receive(partid_t partid, int channel, struct xpnet_message *msg)
+xpnet_receive(short partid, int channel, struct xpnet_message *msg)
 {
        struct sk_buff *skb;
        bte_result_t bret;
  * state or message reception on a connection.
  */
 static void
-xpnet_connection_activity(enum xp_retval reason, partid_t partid, int channel,
+xpnet_connection_activity(enum xp_retval reason, short partid, int channel,
                          void *data, void *key)
 {
        long bp;
  * release the skb and then release our pending message structure.
  */
 static void
-xpnet_send_completed(enum xp_retval reason, partid_t partid, int channel,
+xpnet_send_completed(enum xp_retval reason, short partid, int channel,
                     void *__qm)
 {
        struct xpnet_pending_msg *queued_msg = (struct xpnet_pending_msg *)__qm;
        u64 start_addr, end_addr;
        long dp;
        u8 second_mac_octet;
-       partid_t dest_partid;
+       short dest_partid;
        struct xpnet_dev_private *priv;
        u16 embedded_bytes;