SMSC/MicroChip LAN9303 three port ethernet switch
-------------------------------------------------

Required properties:

- compatible: should be
  - "smsc,lan9303-i2c" for I2C managed mode
    or
  - "smsc,lan9303-mdio" for mdio managed mode

Optional properties:

- reset-gpios: GPIO to be used to reset the whole device
- reset-duration: reset duration in milliseconds, defaults to 200 ms

Subnodes:

The integrated switch subnode should be specified according to the binding
described in dsa/dsa.txt. The CPU port of this switch is always port 0.

Note: always use 'reg = <0/1/2>;' for the three DSA ports, even if the device is
configured to use 1/2/3 instead. This hardware configuration will be
auto-detected and mapped accordingly.

Example:

I2C managed mode:

	master: masterdevice@X {

		fixed-link { /* RMII fixed link to LAN9303 */
			speed = <100>;
			full-duplex;
		};
	};

	switch: switch@a {
		compatible = "smsc,lan9303-i2c";
		reg = <0xa>;
		reset-gpios = <&gpio7 6 GPIO_ACTIVE_LOW>;
		reset-duration = <200>;

		ports {
			#address-cells = <1>;
			#size-cells = <0>;

			port@0 { /* RMII fixed link to master */
				reg = <0>;
				label = "cpu";
				ethernet = <&master>;
			};

			port@1 { /* external port 1 */
				reg = <1>;
				label = "lan1";
			};

			port@2 { /* external port 2 */
				reg = <2>;
				label = "lan2";
			};
		};
	};

MDIO managed mode:

	master: masterdevice@X {
		phy-handle = <&switch>;

		mdio {
			#address-cells = <1>;
			#size-cells = <0>;

			switch: switch-phy@0 {
				compatible = "smsc,lan9303-mdio";
				reg = <0>;
				reset-gpios = <&gpio7 6 GPIO_ACTIVE_LOW>;
				reset-duration = <100>;

				ports {
					#address-cells = <1>;
					#size-cells = <0>;

					port@0 {
						reg = <0>;
						label = "cpu";
						ethernet = <&master>;
					};

					port@1 { /* external port 1 */
						reg = <1>;
						label = "lan1";
					};

					port@2 { /* external port 2 */
						reg = <2>;
						label = "lan2";
					};
				};
			};
		};
	};
