int (*freeze)(struct ccwgroup_device *);
        int (*thaw) (struct ccwgroup_device *);
        int (*restore)(struct ccwgroup_device *);
+       int (*control_event_handler)(struct qeth_card *card,
+                                       struct qeth_ipa_cmd *cmd);
 };
 
 struct qeth_vlan_vid {
 int qeth_send_control_data(struct qeth_card *, int, struct qeth_cmd_buffer *,
        int (*reply_cb)(struct qeth_card *, struct qeth_reply*, unsigned long),
        void *reply_param);
-void qeth_bridge_state_change(struct qeth_card *card, struct qeth_ipa_cmd *cmd);
-void qeth_bridgeport_query_support(struct qeth_card *card);
 int qeth_bridgeport_query_ports(struct qeth_card *card,
        enum qeth_sbp_roles *role, enum qeth_sbp_states *state);
 int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role);
 int qeth_bridgeport_an_set(struct qeth_card *card, int enable);
-void qeth_bridge_host_event(struct qeth_card *card, struct qeth_ipa_cmd *cmd);
 int qeth_get_priority_queue(struct qeth_card *, struct sk_buff *, int, int);
 int qeth_get_elements_no(struct qeth_card *, struct sk_buff *, int);
 int qeth_get_elements_for_frags(struct sk_buff *);
 
 static int qeth_init_qdio_out_buf(struct qeth_qdio_out_q *, int);
 
 struct workqueue_struct *qeth_wq;
+EXPORT_SYMBOL_GPL(qeth_wq);
 
 static void qeth_close_dev_handler(struct work_struct *work)
 {
                                qeth_schedule_recovery(card);
                                return NULL;
                        case IPA_CMD_SETBRIDGEPORT:
-                               if (cmd->data.sbp.hdr.command_code ==
-                                       IPA_SBP_BRIDGE_PORT_STATE_CHANGE) {
-                                       qeth_bridge_state_change(card, cmd);
-                                       return NULL;
-                               } else
-                                       return cmd;
                        case IPA_CMD_ADDRESS_CHANGE_NOTIF:
-                               qeth_bridge_host_event(card, cmd);
-                               return NULL;
+                               if (card->discipline->control_event_handler
+                                                               (card, cmd))
+                                       return cmd;
+                               else
+                                       return NULL;
                        case IPA_CMD_MODCCID:
                                return cmd;
                        case IPA_CMD_REGISTER_LOCAL_ADDR:
                qeth_query_setadapterparms(card);
        if (qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST))
                qeth_query_setdiagass(card);
-       qeth_bridgeport_query_support(card);
-       if (card->options.sbp.supported_funcs)
-               dev_info(&card->gdev->dev,
-               "The device represents a HiperSockets Bridge Capable Port\n");
        return 0;
 out:
        dev_warn(&card->gdev->dev, "The qeth device driver failed to recover "
 
                                            unsigned long));
 static void qeth_l2_set_multicast_list(struct net_device *);
 static int qeth_l2_recover(void *);
+static void qeth_bridgeport_query_support(struct qeth_card *card);
+static void qeth_bridge_state_change(struct qeth_card *card,
+                                       struct qeth_ipa_cmd *cmd);
+static void qeth_bridge_host_event(struct qeth_card *card,
+                                       struct qeth_ipa_cmd *cmd);
 
 static int qeth_l2_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
                rc = -ENODEV;
                goto out_remove;
        }
+       qeth_bridgeport_query_support(card);
+       if (card->options.sbp.supported_funcs)
+               dev_info(&card->gdev->dev,
+               "The device represents a HiperSockets Bridge Capable Port\n");
        qeth_trace_features(card);
 
        if (!card->dev && qeth_l2_setup_netdev(card)) {
        return rc;
 }
 
+/* Returns zero if the command is successfully "consumed" */
+static int qeth_l2_control_event(struct qeth_card *card,
+                                       struct qeth_ipa_cmd *cmd)
+{
+       switch (cmd->hdr.command) {
+       case IPA_CMD_SETBRIDGEPORT:
+               if (cmd->data.sbp.hdr.command_code ==
+                               IPA_SBP_BRIDGE_PORT_STATE_CHANGE) {
+                       qeth_bridge_state_change(card, cmd);
+                       return 0;
+               } else
+                       return 1;
+       case IPA_CMD_ADDRESS_CHANGE_NOTIF:
+               qeth_bridge_host_event(card, cmd);
+               return 0;
+       default:
+               return 1;
+       }
+}
+
 struct qeth_discipline qeth_l2_discipline = {
        .start_poll = qeth_qdio_start_poll,
        .input_handler = (qdio_handler_t *) qeth_qdio_input_handler,
        .freeze = qeth_l2_pm_suspend,
        .thaw = qeth_l2_pm_resume,
        .restore = qeth_l2_pm_resume,
+       .control_event_handler = qeth_l2_control_event,
 };
 EXPORT_SYMBOL_GPL(qeth_l2_discipline);
 
        kfree(data);
 }
 
-void qeth_bridge_state_change(struct qeth_card *card, struct qeth_ipa_cmd *cmd)
+static void qeth_bridge_state_change(struct qeth_card *card,
+                                       struct qeth_ipa_cmd *cmd)
 {
        struct qeth_sbp_state_change *qports =
                 &cmd->data.sbp.data.state_change;
                        sizeof(struct qeth_sbp_state_change) + extrasize);
        queue_work(qeth_wq, &data->worker);
 }
-EXPORT_SYMBOL(qeth_bridge_state_change);
 
 struct qeth_bridge_host_data {
        struct work_struct worker;
        kfree(data);
 }
 
-void qeth_bridge_host_event(struct qeth_card *card, struct qeth_ipa_cmd *cmd)
+static void qeth_bridge_host_event(struct qeth_card *card,
+                                       struct qeth_ipa_cmd *cmd)
 {
        struct qeth_ipacmd_addr_change *hostevs =
                 &cmd->data.addrchange;
                        sizeof(struct qeth_ipacmd_addr_change) + extrasize);
        queue_work(qeth_wq, &data->worker);
 }
-EXPORT_SYMBOL(qeth_bridge_host_event);
 
 /* SETBRIDGEPORT support; sending commands */
 
  * Sets bitmask of supported setbridgeport subfunctions in the qeth_card
  * strucutre: card->options.sbp.supported_funcs.
  */
-void qeth_bridgeport_query_support(struct qeth_card *card)
+static void qeth_bridgeport_query_support(struct qeth_card *card)
 {
        struct qeth_cmd_buffer *iob;
        struct qeth_ipa_cmd *cmd;
        }
        card->options.sbp.supported_funcs = cbctl.data.supported;
 }
-EXPORT_SYMBOL_GPL(qeth_bridgeport_query_support);
 
 static int qeth_bridgeport_query_ports_cb(struct qeth_card *card,
        struct qeth_reply *reply, unsigned long data)
 
        return rc;
 }
 
+/* Returns zero if the command is successfully "consumed" */
+static int qeth_l3_control_event(struct qeth_card *card,
+                                       struct qeth_ipa_cmd *cmd)
+{
+       return 1;
+}
+
 struct qeth_discipline qeth_l3_discipline = {
        .start_poll = qeth_qdio_start_poll,
        .input_handler = (qdio_handler_t *) qeth_qdio_input_handler,
        .freeze = qeth_l3_pm_suspend,
        .thaw = qeth_l3_pm_resume,
        .restore = qeth_l3_pm_resume,
+       .control_event_handler = qeth_l3_control_event,
 };
 EXPORT_SYMBOL_GPL(qeth_l3_discipline);