struct uiscmdrsp cmdrsp[SIZEOF_CMDRSP];
 };
 
-/**
+/*
  *     visor_copy_fragsinfo_from_skb(
  *     @skb_in: skbuff that we are pulling the frags from
  *     @firstfraglen: length of first fragment in skb
        .write = enable_ints_write,
 };
 
-/**
+/*
  *     visornic_serverdown_complete - IOPART went down, pause device
  *     @work: Work queue it was scheduled on
  *
        devdata->server_down_complete_func = NULL;
 }
 
-/**
+/*
  *     visornic_serverdown - Command has notified us that IOPART is down
  *     @devdata: device that is being managed by IOPART
  *
        return err;
 }
 
-/**
+/*
  *     alloc_rcv_buf   - alloc rcv buffer to be given to the IO Partition.
  *     @netdev: network adapter the rcv bufs are attached too.
  *
        return skb;
 }
 
-/**
+/*
  *     post_skb        - post a skb to the IO Partition.
  *     @cmdrsp: cmdrsp packet to be send to the IO Partition
  *     @devdata: visornic_devdata to post the skb too
        }
 }
 
-/**
+/*
  *     send_enbdis     - send NET_RCV_ENBDIS to IO Partition
  *     @netdev: netdevice we are enable/disable, used as context
  *              return value
                devdata->chstat.sent_enbdis++;
 }
 
-/**
+/*
  *     visornic_disable_with_timeout - Disable network adapter
  *     @netdev: netdevice to disable
  *     @timeout: timeout to wait for disable
        return 0;
 }
 
-/**
+/*
  *     init_rcv_bufs  -- initialize receive bufs and send them to the IO Part
  *     @netdev: struct netdevice
  *     @devdata: visornic_devdata
        return 0;
 }
 
-/**
+/*
  *     visornic_enable_with_timeout    - send enable to IO Part
  *     @netdev: struct net_device
  *     @timeout: Time to wait for the ACK from the enable
        return 0;
 }
 
-/**
+/*
  *     visornic_timeout_reset  - handle xmit timeout resets
  *     @work   work item that scheduled the work
  *
        rtnl_unlock();
 }
 
-/**
+/*
  *     visornic_open - Enable the visornic device and mark the queue started
  *     @netdev: netdevice to start
  *
        return 0;
 }
 
-/**
+/*
  *     visornic_close - Disables the visornic device and stops the queues
  *     @netdev: netdevice to start
  *
        return 0;
 }
 
-/**
+/*
  *     devdata_xmits_outstanding - compute outstanding xmits
  *     @devdata: visornic_devdata for device
  *
                + devdata->chstat.sent_xmit + 1);
 }
 
-/**
+/*
  *     vnic_hit_high_watermark
  *     @devdata: indicates visornic device we are checking
  *     @high_watermark: max num of unacked xmits we will tolerate,
        return (devdata_xmits_outstanding(devdata) >= high_watermark);
 }
 
-/**
+/*
  *     vnic_hit_low_watermark
  *     @devdata: indicates visornic device we are checking
  *     @low_watermark: we will wait until the num of unacked xmits
        return (devdata_xmits_outstanding(devdata) <= low_watermark);
 }
 
-/**
+/*
  *     visornic_xmit - send a packet to the IO Partition
  *     @skb: Packet to be sent
  *     @netdev: net device the packet is being sent from
        return NETDEV_TX_OK;
 }
 
-/**
+/*
  *     visornic_get_stats - returns net_stats of the visornic device
  *     @netdev: netdevice
  *
        return &devdata->net_stats;
 }
 
-/**
+/*
  *     visornic_change_mtu - changes mtu of device.
  *     @netdev: netdevice
  *     @new_mtu: value of new mtu
        return -EINVAL;
 }
 
-/**
+/*
  *     visornic_set_multi - changes mtu of device.
  *     @netdev: netdevice
  *
        devdata->old_flags = netdev->flags;
 }
 
-/**
+/*
  *     visornic_xmit_timeout - request to timeout the xmit
  *     @netdev
  *
        spin_unlock_irqrestore(&devdata->priv_lock, flags);
 }
 
-/**
+/*
  *     repost_return   - repost rcv bufs that have come back
  *     @cmdrsp: io channel command struct to post
  *     @devdata: visornic devdata for the device
        return status;
 }
 
-/**
+/*
  *     visornic_rx - Handle receive packets coming back from IO Part
  *     @cmdrsp: Receive packet returned from IO Part
  *
        return 1;
 }
 
-/**
+/*
  *     devdata_initialize      - Initialize devdata structure
  *     @devdata: visornic_devdata structure to initialize
  *     #dev: visorbus_deviced it belongs to
        return devdata;
 }
 
-/**
+/*
  *     devdata_release - Frees up references in devdata
  *     @devdata: struct to clean up
  *
        .read = info_debugfs_read,
 };
 
-/**
+/*
  *     send_rcv_posts_if_needed
  *     @devdata: visornic device
  *
        devdata->num_rcv_bufs_could_not_alloc -= rcv_bufs_allocated;
 }
 
-/**
+/*
  *     drain_resp_queue  - drains and ignores all messages from the resp queue
  *     @cmdrsp: io channel command response message
  *     @devdata: visornic device to drain
                ;
 }
 
-/**
+/*
  *     service_resp_queue      - drains the response queue
  *     @cmdrsp: io channel command response message
  *     @devdata: visornic device to drain
        return rx_count;
 }
 
-/**
+/*
  *     poll_for_irq    - Checks the status of the response queue.
  *     @v: void pointer to the visronic devdata
  *
        mod_timer(&devdata->irq_poll_timer, msecs_to_jiffies(2));
 }
 
-/**
+/*
  *     visornic_probe  - probe function for visornic devices
  *     @dev: The visor device discovered
  *
        return err;
 }
 
-/**
+/*
  *     host_side_disappeared   - IO part is gone.
  *     @devdata: device object
  *
        spin_unlock_irqrestore(&devdata->priv_lock, flags);
 }
 
-/**
+/*
  *     visornic_remove         - Called when visornic dev goes away
  *     @dev: visornic device that is being removed
  *
        free_netdev(netdev);
 }
 
-/**
+/*
  *     visornic_pause          - Called when IO Part disappears
  *     @dev: visornic device that is being serviced
  *     @complete_func: call when finished.
        return 0;
 }
 
-/**
+/*
  *     visornic_resume         - Called when IO part has recovered
  *     @dev: visornic device that is being serviced
  *     @compelte_func: call when finished
        .channel_interrupt = NULL,
 };
 
-/**
+/*
  *     visornic_init   - Init function
  *
  *     Init function for the visornic driver. Do initial driver setup
        return err;
 }
 
-/**
+/*
  *     visornic_cleanup        - driver exit routine
  *
  *     Unregister driver from the bus and free up memory.