2 * Marvell 88E61xx switch driver
4 * Copyright (c) 2014 Claudio Leite <leitec@staticky.com>
6 * Based on code (c) 2008 Felix Fietkau <nbd@openwrt.org>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License v2 as published by the
10 * Free Software Foundation
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/list.h>
17 #include <linux/mii.h>
18 #include <linux/phy.h>
20 #include <linux/of_mdio.h>
21 #include <linux/delay.h>
22 #include <linux/switch.h>
23 #include <linux/device.h>
24 #include <linux/platform_device.h>
28 MODULE_DESCRIPTION("Marvell 88E61xx Switch driver");
29 MODULE_AUTHOR("Claudio Leite <leitec@staticky.com>");
30 MODULE_LICENSE("GPL v2");
31 MODULE_ALIAS("platform:mvsw61xx");
34 * Register access is done through direct or indirect addressing,
35 * depending on how the switch is physically connected.
37 * Direct addressing: all port and global registers directly
38 * accessible via an address/register pair
40 * Indirect addressing: switch is mapped at a single address,
41 * port and global registers accessible via a single command/data
46 mvsw61xx_wait_mask_raw(struct mii_bus
*bus
, int addr
,
47 int reg
, u16 mask
, u16 val
)
53 r
= bus
->read(bus
, addr
, reg
);
54 if ((r
& mask
) == val
)
62 r16(struct mii_bus
*bus
, bool indirect
, int base_addr
, int addr
, int reg
)
67 return bus
->read(bus
, addr
, reg
);
69 /* Indirect read: First, make sure switch is free */
70 mvsw61xx_wait_mask_raw(bus
, base_addr
, MV_INDIRECT_REG_CMD
,
71 MV_INDIRECT_INPROGRESS
, 0);
73 /* Load address and request read */
74 ind_addr
= MV_INDIRECT_READ
| (addr
<< MV_INDIRECT_ADDR_S
) | reg
;
75 bus
->write(bus
, base_addr
, MV_INDIRECT_REG_CMD
,
78 /* Wait until it's ready */
79 mvsw61xx_wait_mask_raw(bus
, base_addr
, MV_INDIRECT_REG_CMD
,
80 MV_INDIRECT_INPROGRESS
, 0);
82 /* Read the requested data */
83 return bus
->read(bus
, base_addr
, MV_INDIRECT_REG_DATA
);
87 w16(struct mii_bus
*bus
, bool indirect
, int base_addr
, int addr
,
93 bus
->write(bus
, addr
, reg
, val
);
97 /* Indirect write: First, make sure switch is free */
98 mvsw61xx_wait_mask_raw(bus
, base_addr
, MV_INDIRECT_REG_CMD
,
99 MV_INDIRECT_INPROGRESS
, 0);
101 /* Load the data to be written */
102 bus
->write(bus
, base_addr
, MV_INDIRECT_REG_DATA
, val
);
104 /* Wait again for switch to be free */
105 mvsw61xx_wait_mask_raw(bus
, base_addr
, MV_INDIRECT_REG_CMD
,
106 MV_INDIRECT_INPROGRESS
, 0);
108 /* Load address, and issue write command */
109 ind_addr
= MV_INDIRECT_WRITE
| (addr
<< MV_INDIRECT_ADDR_S
) | reg
;
110 bus
->write(bus
, base_addr
, MV_INDIRECT_REG_CMD
,
114 /* swconfig support */
117 sr16(struct switch_dev
*dev
, int addr
, int reg
)
119 struct mvsw61xx_state
*state
= get_state(dev
);
121 return r16(state
->bus
, state
->is_indirect
, state
->base_addr
, addr
, reg
);
125 sw16(struct switch_dev
*dev
, int addr
, int reg
, u16 val
)
127 struct mvsw61xx_state
*state
= get_state(dev
);
129 w16(state
->bus
, state
->is_indirect
, state
->base_addr
, addr
, reg
, val
);
133 mvsw61xx_wait_mask_s(struct switch_dev
*dev
, int addr
,
134 int reg
, u16 mask
, u16 val
)
140 r
= sr16(dev
, addr
, reg
) & mask
;
149 mvsw61xx_get_port_mask(struct switch_dev
*dev
,
150 const struct switch_attr
*attr
, struct switch_val
*val
)
152 struct mvsw61xx_state
*state
= get_state(dev
);
153 char *buf
= state
->buf
;
157 port
= val
->port_vlan
;
158 reg
= sr16(dev
, MV_PORTREG(VLANMAP
, port
)) & MV_PORTS_MASK
;
160 len
= sprintf(buf
, "0x%04x: ", reg
);
162 for (i
= 0; i
< MV_PORTS
; i
++) {
164 len
+= sprintf(buf
+ len
, "%d ", i
);
166 len
+= sprintf(buf
+ len
, "(%d) ", i
);
175 mvsw61xx_get_port_qmode(struct switch_dev
*dev
,
176 const struct switch_attr
*attr
, struct switch_val
*val
)
178 struct mvsw61xx_state
*state
= get_state(dev
);
180 val
->value
.i
= state
->ports
[val
->port_vlan
].qmode
;
186 mvsw61xx_set_port_qmode(struct switch_dev
*dev
,
187 const struct switch_attr
*attr
, struct switch_val
*val
)
189 struct mvsw61xx_state
*state
= get_state(dev
);
191 state
->ports
[val
->port_vlan
].qmode
= val
->value
.i
;
197 mvsw61xx_get_pvid(struct switch_dev
*dev
, int port
, int *val
)
199 struct mvsw61xx_state
*state
= get_state(dev
);
201 *val
= state
->ports
[port
].pvid
;
207 mvsw61xx_set_pvid(struct switch_dev
*dev
, int port
, int val
)
209 struct mvsw61xx_state
*state
= get_state(dev
);
211 if (val
< 0 || val
>= MV_VLANS
)
214 state
->ports
[port
].pvid
= (u16
)val
;
220 mvsw61xx_get_port_status(struct switch_dev
*dev
,
221 const struct switch_attr
*attr
, struct switch_val
*val
)
223 struct mvsw61xx_state
*state
= get_state(dev
);
224 char *buf
= state
->buf
;
228 status
= sr16(dev
, MV_PORTREG(STATUS
, val
->port_vlan
));
229 speed
= (status
& MV_PORT_STATUS_SPEED_MASK
) >>
230 MV_PORT_STATUS_SPEED_SHIFT
;
232 len
= sprintf(buf
, "link: ");
233 if (status
& MV_PORT_STATUS_LINK
) {
234 len
+= sprintf(buf
+ len
, "up, speed: ");
237 case MV_PORT_STATUS_SPEED_10
:
238 len
+= sprintf(buf
+ len
, "10");
240 case MV_PORT_STATUS_SPEED_100
:
241 len
+= sprintf(buf
+ len
, "100");
243 case MV_PORT_STATUS_SPEED_1000
:
244 len
+= sprintf(buf
+ len
, "1000");
248 len
+= sprintf(buf
+ len
, " Mbps, duplex: ");
250 if (status
& MV_PORT_STATUS_FDX
)
251 len
+= sprintf(buf
+ len
, "full");
253 len
+= sprintf(buf
+ len
, "half");
255 len
+= sprintf(buf
+ len
, "down");
264 mvsw61xx_get_port_speed(struct switch_dev
*dev
,
265 const struct switch_attr
*attr
, struct switch_val
*val
)
269 status
= sr16(dev
, MV_PORTREG(STATUS
, val
->port_vlan
));
270 speed
= (status
& MV_PORT_STATUS_SPEED_MASK
) >>
271 MV_PORT_STATUS_SPEED_SHIFT
;
275 if (status
& MV_PORT_STATUS_LINK
) {
277 case MV_PORT_STATUS_SPEED_10
:
280 case MV_PORT_STATUS_SPEED_100
:
283 case MV_PORT_STATUS_SPEED_1000
:
292 static int mvsw61xx_get_vlan_ports(struct switch_dev
*dev
,
293 struct switch_val
*val
)
295 struct mvsw61xx_state
*state
= get_state(dev
);
298 vno
= val
->port_vlan
;
300 if (vno
<= 0 || vno
>= dev
->vlans
)
303 for (i
= 0, j
= 0; i
< dev
->ports
; i
++) {
304 if (state
->vlans
[vno
].mask
& (1 << i
)) {
305 val
->value
.ports
[j
].id
= i
;
307 mode
= (state
->vlans
[vno
].port_mode
>> (i
* 4)) & 0xf;
308 if (mode
== MV_VTUCTL_EGRESS_TAGGED
)
309 val
->value
.ports
[j
].flags
=
310 (1 << SWITCH_PORT_FLAG_TAGGED
);
312 val
->value
.ports
[j
].flags
= 0;
323 static int mvsw61xx_set_vlan_ports(struct switch_dev
*dev
,
324 struct switch_val
*val
)
326 struct mvsw61xx_state
*state
= get_state(dev
);
327 int i
, mode
, pno
, vno
;
329 vno
= val
->port_vlan
;
331 if (vno
<= 0 || vno
>= dev
->vlans
)
334 state
->vlans
[vno
].mask
= 0;
335 state
->vlans
[vno
].port_mode
= 0;
337 if(state
->vlans
[vno
].vid
== 0)
338 state
->vlans
[vno
].vid
= vno
;
340 for (i
= 0; i
< val
->len
; i
++) {
341 pno
= val
->value
.ports
[i
].id
;
343 state
->vlans
[vno
].mask
|= (1 << pno
);
344 if (val
->value
.ports
[i
].flags
&
345 (1 << SWITCH_PORT_FLAG_TAGGED
))
346 mode
= MV_VTUCTL_EGRESS_TAGGED
;
348 mode
= MV_VTUCTL_EGRESS_UNTAGGED
;
350 state
->vlans
[vno
].port_mode
|= mode
<< (pno
* 4);
354 * DISCARD is nonzero, so it must be explicitly
355 * set on ports not in the VLAN.
357 for (i
= 0; i
< dev
->ports
; i
++)
358 if (!(state
->vlans
[vno
].mask
& (1 << i
)))
359 state
->vlans
[vno
].port_mode
|=
360 MV_VTUCTL_DISCARD
<< (i
* 4);
365 static int mvsw61xx_get_vlan_port_based(struct switch_dev
*dev
,
366 const struct switch_attr
*attr
, struct switch_val
*val
)
368 struct mvsw61xx_state
*state
= get_state(dev
);
369 int vno
= val
->port_vlan
;
371 if (vno
<= 0 || vno
>= dev
->vlans
)
374 if (state
->vlans
[vno
].port_based
)
382 static int mvsw61xx_set_vlan_port_based(struct switch_dev
*dev
,
383 const struct switch_attr
*attr
, struct switch_val
*val
)
385 struct mvsw61xx_state
*state
= get_state(dev
);
386 int vno
= val
->port_vlan
;
388 if (vno
<= 0 || vno
>= dev
->vlans
)
391 if (val
->value
.i
== 1)
392 state
->vlans
[vno
].port_based
= true;
394 state
->vlans
[vno
].port_based
= false;
399 static int mvsw61xx_get_vid(struct switch_dev
*dev
,
400 const struct switch_attr
*attr
, struct switch_val
*val
)
402 struct mvsw61xx_state
*state
= get_state(dev
);
403 int vno
= val
->port_vlan
;
405 if (vno
<= 0 || vno
>= dev
->vlans
)
408 val
->value
.i
= state
->vlans
[vno
].vid
;
413 static int mvsw61xx_set_vid(struct switch_dev
*dev
,
414 const struct switch_attr
*attr
, struct switch_val
*val
)
416 struct mvsw61xx_state
*state
= get_state(dev
);
417 int vno
= val
->port_vlan
;
419 if (vno
<= 0 || vno
>= dev
->vlans
)
422 state
->vlans
[vno
].vid
= val
->value
.i
;
427 static int mvsw61xx_get_enable_vlan(struct switch_dev
*dev
,
428 const struct switch_attr
*attr
, struct switch_val
*val
)
430 struct mvsw61xx_state
*state
= get_state(dev
);
432 val
->value
.i
= state
->vlan_enabled
;
437 static int mvsw61xx_set_enable_vlan(struct switch_dev
*dev
,
438 const struct switch_attr
*attr
, struct switch_val
*val
)
440 struct mvsw61xx_state
*state
= get_state(dev
);
442 state
->vlan_enabled
= val
->value
.i
;
447 static int mvsw61xx_vtu_program(struct switch_dev
*dev
)
449 struct mvsw61xx_state
*state
= get_state(dev
);
454 mvsw61xx_wait_mask_s(dev
, MV_GLOBALREG(VTU_OP
),
455 MV_VTUOP_INPROGRESS
, 0);
456 sw16(dev
, MV_GLOBALREG(VTU_OP
),
457 MV_VTUOP_INPROGRESS
| MV_VTUOP_VALID
);
459 /* Write VLAN table */
460 for (i
= 1; i
< dev
->vlans
; i
++) {
461 if (state
->vlans
[i
].mask
== 0 ||
462 state
->vlans
[i
].vid
== 0 ||
463 state
->vlans
[i
].port_based
== true)
466 mvsw61xx_wait_mask_s(dev
, MV_GLOBALREG(VTU_OP
),
467 MV_VTUOP_INPROGRESS
, 0);
469 sw16(dev
, MV_GLOBALREG(VTU_VID
),
470 MV_VTUOP_VALID
| state
->vlans
[i
].vid
);
472 v1
= (u16
)(state
->vlans
[i
].port_mode
& 0xffff);
473 v2
= (u16
)((state
->vlans
[i
].port_mode
>> 16) & 0xffff);
475 sw16(dev
, MV_GLOBALREG(VTU_DATA1
), v1
);
476 sw16(dev
, MV_GLOBALREG(VTU_DATA2
), v2
);
478 sw16(dev
, MV_GLOBALREG(VTU_OP
),
479 MV_VTUOP_INPROGRESS
| MV_VTUOP_LOAD
);
480 mvsw61xx_wait_mask_s(dev
, MV_GLOBALREG(VTU_OP
),
481 MV_VTUOP_INPROGRESS
, 0);
487 static void mvsw61xx_vlan_port_config(struct switch_dev
*dev
, int vno
)
489 struct mvsw61xx_state
*state
= get_state(dev
);
492 for (i
= 0; i
< dev
->ports
; i
++) {
493 if (!(state
->vlans
[vno
].mask
& (1 << i
)))
496 mode
= (state
->vlans
[vno
].port_mode
>> (i
* 4)) & 0xf;
498 if(mode
!= MV_VTUCTL_EGRESS_TAGGED
)
499 state
->ports
[i
].pvid
= state
->vlans
[vno
].vid
;
501 if (state
->vlans
[vno
].port_based
)
502 state
->ports
[i
].mask
|= state
->vlans
[vno
].mask
;
504 state
->ports
[i
].qmode
= MV_8021Q_MODE_SECURE
;
508 static int mvsw61xx_update_state(struct switch_dev
*dev
)
510 struct mvsw61xx_state
*state
= get_state(dev
);
514 if (!state
->registered
)
517 mvsw61xx_vtu_program(dev
);
520 * Set 802.1q-only mode if vlan_enabled is true.
522 * Without this, even if 802.1q is enabled for
523 * a port/VLAN, it still depends on the port-based
524 * VLAN mask being set.
526 * With this setting, port-based VLANs are still
527 * functional, provided the VID is not in the VTU.
529 reg
= sr16(dev
, MV_GLOBAL2REG(SDET_POLARITY
));
531 if (state
->vlan_enabled
)
532 reg
|= MV_8021Q_VLAN_ONLY
;
534 reg
&= ~MV_8021Q_VLAN_ONLY
;
536 sw16(dev
, MV_GLOBAL2REG(SDET_POLARITY
), reg
);
539 * Set port-based VLAN masks on each port
540 * based only on VLAN definitions known to
541 * the driver (i.e. in state).
543 * This means any pre-existing port mapping is
544 * wiped out once our driver is initialized.
546 for (i
= 0; i
< dev
->ports
; i
++) {
547 state
->ports
[i
].mask
= 0;
548 state
->ports
[i
].qmode
= MV_8021Q_MODE_DISABLE
;
551 for (i
= 0; i
< dev
->vlans
; i
++)
552 mvsw61xx_vlan_port_config(dev
, i
);
554 for (i
= 0; i
< dev
->ports
; i
++) {
555 reg
= sr16(dev
, MV_PORTREG(VLANID
, i
)) & ~MV_PVID_MASK
;
556 reg
|= state
->ports
[i
].pvid
;
557 sw16(dev
, MV_PORTREG(VLANID
, i
), reg
);
559 state
->ports
[i
].mask
&= ~(1 << i
);
561 reg
= sr16(dev
, MV_PORTREG(VLANMAP
, i
)) & ~MV_PORTS_MASK
;
562 reg
|= state
->ports
[i
].mask
;
563 sw16(dev
, MV_PORTREG(VLANMAP
, i
), reg
);
565 reg
= sr16(dev
, MV_PORTREG(CONTROL2
, i
)) &
567 reg
|= state
->ports
[i
].qmode
<< MV_8021Q_MODE_SHIFT
;
568 sw16(dev
, MV_PORTREG(CONTROL2
, i
), reg
);
574 static int mvsw61xx_apply(struct switch_dev
*dev
)
576 return mvsw61xx_update_state(dev
);
579 static int mvsw61xx_reset(struct switch_dev
*dev
)
581 struct mvsw61xx_state
*state
= get_state(dev
);
585 /* Disable all ports before reset */
586 for (i
= 0; i
< dev
->ports
; i
++) {
587 reg
= sr16(dev
, MV_PORTREG(CONTROL
, i
)) &
588 ~MV_PORTCTRL_ENABLED
;
589 sw16(dev
, MV_PORTREG(CONTROL
, i
), reg
);
592 reg
= sr16(dev
, MV_GLOBALREG(CONTROL
)) | MV_CONTROL_RESET
;
594 sw16(dev
, MV_GLOBALREG(CONTROL
), reg
);
595 if (mvsw61xx_wait_mask_s(dev
, MV_GLOBALREG(CONTROL
),
596 MV_CONTROL_RESET
, 0) < 0)
599 for (i
= 0; i
< dev
->ports
; i
++) {
600 state
->ports
[i
].qmode
= 0;
601 state
->ports
[i
].mask
= 0;
602 state
->ports
[i
].pvid
= 0;
604 /* Force flow control off */
605 reg
= sr16(dev
, MV_PORTREG(FORCE
, i
)) & ~MV_FORCE_FC_MASK
;
606 reg
|= MV_FORCE_FC_DISABLE
;
607 sw16(dev
, MV_PORTREG(FORCE
, i
), reg
);
609 /* Set port association vector */
610 sw16(dev
, MV_PORTREG(ASSOC
, i
), (1 << i
));
613 for (i
= 0; i
< dev
->vlans
; i
++) {
614 state
->vlans
[i
].port_based
= false;
615 state
->vlans
[i
].mask
= 0;
616 state
->vlans
[i
].vid
= 0;
617 state
->vlans
[i
].port_mode
= 0;
620 state
->vlan_enabled
= 0;
622 mvsw61xx_update_state(dev
);
624 /* Re-enable ports */
625 for (i
= 0; i
< dev
->ports
; i
++) {
626 reg
= sr16(dev
, MV_PORTREG(CONTROL
, i
)) |
628 sw16(dev
, MV_PORTREG(CONTROL
, i
), reg
);
635 MVSW61XX_ENABLE_VLAN
,
639 MVSW61XX_VLAN_PORT_BASED
,
646 MVSW61XX_PORT_STATUS
,
650 static const struct switch_attr mvsw61xx_global
[] = {
651 [MVSW61XX_ENABLE_VLAN
] = {
652 .id
= MVSW61XX_ENABLE_VLAN
,
653 .type
= SWITCH_TYPE_INT
,
654 .name
= "enable_vlan",
655 .description
= "Enable 802.1q VLAN support",
656 .get
= mvsw61xx_get_enable_vlan
,
657 .set
= mvsw61xx_set_enable_vlan
,
661 static const struct switch_attr mvsw61xx_vlan
[] = {
662 [MVSW61XX_VLAN_PORT_BASED
] = {
663 .id
= MVSW61XX_VLAN_PORT_BASED
,
664 .type
= SWITCH_TYPE_INT
,
665 .name
= "port_based",
666 .description
= "Use port-based (non-802.1q) VLAN only",
667 .get
= mvsw61xx_get_vlan_port_based
,
668 .set
= mvsw61xx_set_vlan_port_based
,
670 [MVSW61XX_VLAN_ID
] = {
671 .id
= MVSW61XX_VLAN_ID
,
672 .type
= SWITCH_TYPE_INT
,
674 .description
= "Get/set VLAN ID",
675 .get
= mvsw61xx_get_vid
,
676 .set
= mvsw61xx_set_vid
,
680 static const struct switch_attr mvsw61xx_port
[] = {
681 [MVSW61XX_PORT_MASK
] = {
682 .id
= MVSW61XX_PORT_MASK
,
683 .type
= SWITCH_TYPE_STRING
,
684 .description
= "Port-based VLAN mask",
686 .get
= mvsw61xx_get_port_mask
,
689 [MVSW61XX_PORT_QMODE
] = {
690 .id
= MVSW61XX_PORT_QMODE
,
691 .type
= SWITCH_TYPE_INT
,
692 .description
= "802.1q mode: 0=off/1=fallback/2=check/3=secure",
694 .get
= mvsw61xx_get_port_qmode
,
695 .set
= mvsw61xx_set_port_qmode
,
697 [MVSW61XX_PORT_STATUS
] = {
698 .id
= MVSW61XX_PORT_STATUS
,
699 .type
= SWITCH_TYPE_STRING
,
700 .description
= "Return port status",
702 .get
= mvsw61xx_get_port_status
,
705 [MVSW61XX_PORT_LINK
] = {
706 .id
= MVSW61XX_PORT_LINK
,
707 .type
= SWITCH_TYPE_INT
,
708 .description
= "Get link speed",
710 .get
= mvsw61xx_get_port_speed
,
715 static const struct switch_dev_ops mvsw61xx_ops
= {
717 .attr
= mvsw61xx_global
,
718 .n_attr
= ARRAY_SIZE(mvsw61xx_global
),
721 .attr
= mvsw61xx_vlan
,
722 .n_attr
= ARRAY_SIZE(mvsw61xx_vlan
),
725 .attr
= mvsw61xx_port
,
726 .n_attr
= ARRAY_SIZE(mvsw61xx_port
),
728 .get_port_pvid
= mvsw61xx_get_pvid
,
729 .set_port_pvid
= mvsw61xx_set_pvid
,
730 .get_vlan_ports
= mvsw61xx_get_vlan_ports
,
731 .set_vlan_ports
= mvsw61xx_set_vlan_ports
,
732 .apply_config
= mvsw61xx_apply
,
733 .reset_switch
= mvsw61xx_reset
,
736 /* end swconfig stuff */
738 static int mvsw61xx_probe(struct platform_device
*pdev
)
740 struct mvsw61xx_state
*state
;
741 struct device_node
*np
= pdev
->dev
.of_node
;
742 struct device_node
*mdio
;
747 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
751 mdio
= of_parse_phandle(np
, "mii-bus", 0);
753 dev_err(&pdev
->dev
, "Couldn't get MII bus handle\n");
758 state
->bus
= of_mdio_find_bus(mdio
);
760 dev_err(&pdev
->dev
, "Couldn't find MII bus from handle\n");
765 state
->is_indirect
= of_property_read_bool(np
, "is-indirect");
767 if (state
->is_indirect
) {
768 if (of_property_read_u32(np
, "reg", &val
)) {
769 dev_err(&pdev
->dev
, "Switch address not specified\n");
774 state
->base_addr
= val
;
776 state
->base_addr
= MV_BASE
;
779 reg
= r16(state
->bus
, state
->is_indirect
, state
->base_addr
,
780 MV_PORTREG(IDENT
, 0)) & MV_IDENT_MASK
;
781 if (reg
!= MV_IDENT_VALUE
) {
782 dev_err(&pdev
->dev
, "No switch found at 0x%02x\n",
788 platform_set_drvdata(pdev
, state
);
789 dev_info(&pdev
->dev
, "Found %s at %s:%02x\n", MV_IDENT_STR
,
790 state
->bus
->id
, state
->base_addr
);
792 dev_info(&pdev
->dev
, "Using %sdirect addressing\n",
793 (state
->is_indirect
? "in" : ""));
795 if (of_property_read_u32(np
, "cpu-port-0", &val
)) {
796 dev_err(&pdev
->dev
, "CPU port not set\n");
801 state
->cpu_port0
= val
;
803 if (!of_property_read_u32(np
, "cpu-port-1", &val
))
804 state
->cpu_port1
= val
;
806 state
->cpu_port1
= -1;
808 state
->dev
.vlans
= MV_VLANS
;
809 state
->dev
.cpu_port
= state
->cpu_port0
;
810 state
->dev
.ports
= MV_PORTS
;
811 state
->dev
.name
= MV_IDENT_STR
;
812 state
->dev
.ops
= &mvsw61xx_ops
;
813 state
->dev
.alias
= dev_name(&pdev
->dev
);
815 err
= register_switch(&state
->dev
, NULL
);
819 state
->registered
= true;
828 mvsw61xx_remove(struct platform_device
*pdev
)
830 struct mvsw61xx_state
*state
= platform_get_drvdata(pdev
);
832 if (state
->registered
)
833 unregister_switch(&state
->dev
);
840 static const struct of_device_id mvsw61xx_match
[] = {
841 { .compatible
= "marvell,88e6171" },
844 MODULE_DEVICE_TABLE(of
, mvsw61xx_match
);
846 static struct platform_driver mvsw61xx_driver
= {
847 .probe
= mvsw61xx_probe
,
848 .remove
= mvsw61xx_remove
,
851 .of_match_table
= of_match_ptr(mvsw61xx_match
),
852 .owner
= THIS_MODULE
,
856 static int __init
mvsw61xx_module_init(void)
858 return platform_driver_register(&mvsw61xx_driver
);
860 late_initcall(mvsw61xx_module_init
);
862 static void __exit
mvsw61xx_module_exit(void)
864 platform_driver_unregister(&mvsw61xx_driver
);
866 module_exit(mvsw61xx_module_exit
);