<?xml version="1.0" encoding="UTF-8"?>
<!--
  ~ Copyright 2015 Open Networking Laboratory
  ~
  ~ Licensed under the Apache License, Version 2.0 (the "License");
  ~ you may not use this file except in compliance with the License.
  ~ You may obtain a copy of the License at
  ~
  ~     http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing, software
  ~ distributed under the License is distributed on an "AS IS" BASIS,
  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  ~ See the License for the specific language governing permissions and
  ~ limitations under the License.
  -->
<drivers>
    <driver name="default"
            manufacturer="ON.Lab" hwVersion="0.0.1" swVersion="0.0.1">
        <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                   impl="org.onosproject.driver.pipeline.DefaultSingleTablePipeline"/>
        <behaviour api="org.onosproject.openflow.controller.driver.OpenFlowSwitchDriver"
                   impl="org.onosproject.driver.handshaker.DefaultSwitchHandshaker"/>
    </driver>
    <driver name="ovs" extends="default"
            manufacturer="Nicira, Inc\." hwVersion="Open vSwitch" swVersion="2\..*">
        <behaviour api="org.onosproject.openflow.controller.driver.OpenFlowSwitchDriver"
                   impl="org.onosproject.driver.handshaker.NiciraSwitchHandshaker"/>
    </driver>
    <driver name="ovs-corsa" extends="ovs"
            manufacturer="Corsa" hwVersion="emulation" swVersion="0.0.0">
        <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                   impl="org.onosproject.driver.pipeline.OVSCorsaPipeline"/>
    </driver>
    <driver name="spring-open-cpqd" extends="default"
            manufacturer="Stanford University, Ericsson Research and CPqD Research" 
            hwVersion="OpenFlow 1.3 Reference Userspace Switch" swVersion=".*">
        <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                   impl="org.onosproject.driver.pipeline.SpringOpenTTP"/>
    </driver>
    <driver name="spring-open" extends="default"
            manufacturer="Dell " hwVersion="OpenFlow switch HW ver. 1.0" 
            swVersion="OpenFlow switch SW ver. 1.0 and 1.3">
        <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                   impl="org.onosproject.driver.pipeline.SpringOpenTTPDell"/>
    </driver>
    <driver name="linc-oe" extends="default"
            manufacturer="FlowForwarding.org" hwVersion="Unknown" 
            swVersion="LINC-OE OpenFlow Software Switch 1.1">
        <behaviour api="org.onosproject.openflow.controller.driver.OpenFlowSwitchDriver"
                   impl="org.onosproject.driver.handshaker.OFOpticalSwitchImplLINC13"/>
    </driver>
    <driver name="corsa"
            manufacturer="Corsa" hwVersion="Corsa Element" swVersion="2.3.1">
        <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                   impl="org.onosproject.driver.pipeline.CorsaPipeline"/>
        <behaviour api="org.onosproject.openflow.controller.driver.OpenFlowSwitchDriver"
                   impl="org.onosproject.driver.handshaker.CorsaSwitchHandshaker"/>
    </driver>
    <driver name="ofdpa" extends="default"
            manufacturer="Broadcom Corp." hwVersion="OF-DPA 2.0-EA1" swVersion="OF-DPA 2.0-EA1">
        <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                   impl="org.onosproject.driver.pipeline.OFDPA1Pipeline"/>
    </driver>
    <driver name="pmc-olt" extends="default"
            manufacturer="Big Switch Networks" hwVersion="ivs 0.5" swVersion="ivs 0.5">
        <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                   impl="org.onosproject.driver.pipeline.OLTPipeline"/>
    </driver>
    <!--  The SoftRouter driver is meant to be used by any software/NPU based
       ~  switch that wishes to implement a simple 2-table router. To use this
       ~  driver, configure ONOS with the dpid of the device, or extend the
       ~  driver declaration with the manufacturer/hwVersion/swVersion of the
       ~  device (see 'noviflow' example).
      -->
    <driver name="softrouter" extends="default"
            manufacturer="Various" hwVersion="various" swVersion="0.0.0">
        <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                   impl="org.onosproject.driver.pipeline.SoftRouterPipeline"/>
    </driver>
    <driver name="centec-V350" extends="default"
            manufacturer=".*Centec.*" hwVersion=".*" swVersion="3.1.*">
        <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                   impl="org.onosproject.driver.pipeline.CentecV350Pipeline"/>
    </driver>
    <driver name="pica" extends="default"
            manufacturer="Pica8, Inc." hwVersion="ly2" swVersion="PicOS 2.6">
        <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                   impl="org.onosproject.driver.pipeline.PicaPipeline"/>
    </driver>
    <driver name="noviflow" extends="softrouter"
            manufacturer="NoviFlow Inc" hwVersion="NS1132" swVersion="NW250.4.4">
    </driver>
    <!--  Emulation of the ofdpa pipeline using a CPqD OF 1.3 software switch.
       ~  To use this driver, configure ONOS with the dpid of the device.
      -->
    <driver name="ofdpa-cpqd" extends="default"
            manufacturer="ONF"
            hwVersion="OF1.3 Software Switch from CPqD" swVersion="for Group Chaining">
        <behaviour api="org.onosproject.net.behaviour.Pipeliner"
                   impl="org.onosproject.driver.pipeline.CpqdOFDPA1Pipeline"/>
    </driver>
</drivers>

