1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Marvell International Ltd.
3 * Copyright(c) 2018 Semihalf.
7 #include <rte_ethdev_driver.h>
8 #include <rte_kvargs.h>
9 #include <rte_bus_vdev.h>
13 #include <linux/ethtool.h>
14 #include <linux/sockios.h>
16 #include <net/if_arp.h>
17 #include <sys/ioctl.h>
18 #include <sys/socket.h>
20 #include <sys/types.h>
22 #include <rte_mvep_common.h>
24 #include "mvneta_rxtx.h"
27 #define MVNETA_IFACE_NAME_ARG "iface"
29 #define MVNETA_RX_OFFLOADS (DEV_RX_OFFLOAD_JUMBO_FRAME | \
30 DEV_RX_OFFLOAD_CHECKSUM)
32 /** Port Tx offloads capabilities */
33 #define MVNETA_TX_OFFLOADS (DEV_TX_OFFLOAD_IPV4_CKSUM | \
34 DEV_TX_OFFLOAD_UDP_CKSUM | \
35 DEV_TX_OFFLOAD_TCP_CKSUM | \
36 DEV_TX_OFFLOAD_MULTI_SEGS)
38 #define MVNETA_PKT_SIZE_MAX (16382 - MV_MH_SIZE) /* 9700B */
39 #define MVNETA_DEFAULT_MTU 1500
41 #define MVNETA_MAC_ADDRS_MAX 256 /*16 UC, 256 IP, 256 MC/BC */
42 /** Maximum length of a match string */
43 #define MVNETA_MATCH_LEN 16
47 static const char * const valid_args[] = {
48 MVNETA_IFACE_NAME_ARG,
52 struct mvneta_ifnames {
53 const char *names[NETA_NUM_ETH_PPIO];
57 static int mvneta_dev_num;
60 * Deinitialize packet processor.
63 mvneta_neta_deinit(void)
69 * Initialize packet processor.
72 * 0 on success, negative error value otherwise.
75 mvneta_neta_init(void)
81 * Callback used by rte_kvargs_process() during argument parsing.
84 * Pointer to the parsed key (unused).
86 * Pointer to the parsed value.
88 * Pointer to the extra arguments which contains address of the
89 * table of pointers to parsed interface names.
95 mvneta_ifnames_get(const char *key __rte_unused, const char *value,
98 struct mvneta_ifnames *ifnames = extra_args;
100 ifnames->names[ifnames->idx++] = value;
106 * Ethernet device configuration.
108 * Prepare the driver for a given number of TX and RX queues and
109 * configure RSS if supported.
112 * Pointer to Ethernet device structure.
115 * 0 on success, negative error value otherwise.
118 mvneta_dev_configure(struct rte_eth_dev *dev)
120 struct mvneta_priv *priv = dev->data->dev_private;
121 struct neta_ppio_params *ppio_params;
123 if (dev->data->dev_conf.rxmode.mq_mode != ETH_MQ_RX_NONE) {
124 MVNETA_LOG(INFO, "Unsupported RSS and rx multi queue mode %d",
125 dev->data->dev_conf.rxmode.mq_mode);
126 if (dev->data->nb_rx_queues > 1)
130 if (dev->data->dev_conf.rxmode.split_hdr_size) {
131 MVNETA_LOG(INFO, "Split headers not supported");
135 if (dev->data->dev_conf.rxmode.offloads & DEV_RX_OFFLOAD_JUMBO_FRAME)
136 dev->data->mtu = dev->data->dev_conf.rxmode.max_rx_pkt_len -
137 MRVL_NETA_ETH_HDRS_LEN;
139 if (dev->data->dev_conf.txmode.offloads & DEV_TX_OFFLOAD_MULTI_SEGS)
142 ppio_params = &priv->ppio_params;
143 ppio_params->outqs_params.num_outqs = dev->data->nb_tx_queues;
144 /* Default: 1 TC, no QoS supported. */
145 ppio_params->inqs_params.num_tcs = 1;
146 ppio_params->inqs_params.tcs_params[0].pkt_offset = MRVL_NETA_PKT_OFFS;
147 priv->ppio_id = dev->data->port_id;
153 * DPDK callback to get information about the device.
156 * Pointer to Ethernet device structure (unused).
158 * Info structure output buffer.
161 mvneta_dev_infos_get(struct rte_eth_dev *dev __rte_unused,
162 struct rte_eth_dev_info *info)
164 info->speed_capa = ETH_LINK_SPEED_10M |
165 ETH_LINK_SPEED_100M |
169 info->max_rx_queues = MRVL_NETA_RXQ_MAX;
170 info->max_tx_queues = MRVL_NETA_TXQ_MAX;
171 info->max_mac_addrs = MVNETA_MAC_ADDRS_MAX;
173 info->rx_desc_lim.nb_max = MRVL_NETA_RXD_MAX;
174 info->rx_desc_lim.nb_min = MRVL_NETA_RXD_MIN;
175 info->rx_desc_lim.nb_align = MRVL_NETA_RXD_ALIGN;
177 info->tx_desc_lim.nb_max = MRVL_NETA_TXD_MAX;
178 info->tx_desc_lim.nb_min = MRVL_NETA_TXD_MIN;
179 info->tx_desc_lim.nb_align = MRVL_NETA_TXD_ALIGN;
181 info->rx_offload_capa = MVNETA_RX_OFFLOADS;
182 info->rx_queue_offload_capa = MVNETA_RX_OFFLOADS;
184 info->tx_offload_capa = MVNETA_TX_OFFLOADS;
185 info->tx_queue_offload_capa = MVNETA_TX_OFFLOADS;
187 /* By default packets are dropped if no descriptors are available */
188 info->default_rxconf.rx_drop_en = 1;
189 /* Deferred tx queue start is not supported */
190 info->default_txconf.tx_deferred_start = 0;
191 info->default_txconf.offloads = 0;
193 info->max_rx_pktlen = MVNETA_PKT_SIZE_MAX;
197 * Return supported packet types.
200 * Pointer to Ethernet device structure (unused).
203 * Const pointer to the table with supported packet types.
205 static const uint32_t *
206 mvneta_dev_supported_ptypes_get(struct rte_eth_dev *dev __rte_unused)
208 static const uint32_t ptypes[] = {
210 RTE_PTYPE_L2_ETHER_VLAN,
221 * DPDK callback to change the MTU.
223 * Setting the MTU affects hardware MRU (packets larger than the MRU
227 * Pointer to Ethernet device structure.
232 * 0 on success, negative error value otherwise.
235 mvneta_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
237 struct mvneta_priv *priv = dev->data->dev_private;
238 uint16_t mbuf_data_size = 0; /* SW buffer size */
242 mru = MRVL_NETA_MTU_TO_MRU(mtu);
244 * min_rx_buf_size is equal to mbuf data size
245 * if pmd didn't set it differently
247 mbuf_data_size = dev->data->min_rx_buf_size - RTE_PKTMBUF_HEADROOM;
249 * - setting mru greater than the mbuf size resulting in
250 * hw and sw buffer size mismatch
251 * - setting mtu that requires the support of scattered packets
252 * when this feature has not been enabled/supported so far.
254 if (!dev->data->scattered_rx &&
255 (mru + MRVL_NETA_PKT_OFFS > mbuf_data_size)) {
256 mru = mbuf_data_size - MRVL_NETA_PKT_OFFS;
257 mtu = MRVL_NETA_MRU_TO_MTU(mru);
258 MVNETA_LOG(WARNING, "MTU too big, max MTU possible limitted by"
259 " current mbuf size: %u. Set MTU to %u, MRU to %u",
260 mbuf_data_size, mtu, mru);
263 if (mtu < ETHER_MIN_MTU || mru > MVNETA_PKT_SIZE_MAX) {
264 MVNETA_LOG(ERR, "Invalid MTU [%u] or MRU [%u]", mtu, mru);
268 dev->data->mtu = mtu;
269 dev->data->dev_conf.rxmode.max_rx_pkt_len = mru - MV_MH_SIZE;
272 /* It is OK. New MTU will be set later on mvneta_dev_start */
275 ret = neta_ppio_set_mru(priv->ppio, mru);
277 MVNETA_LOG(ERR, "Failed to change MRU");
281 ret = neta_ppio_set_mtu(priv->ppio, mtu);
283 MVNETA_LOG(ERR, "Failed to change MTU");
286 MVNETA_LOG(INFO, "MTU changed to %u, MRU = %u", mtu, mru);
292 * DPDK callback to bring the link up.
295 * Pointer to Ethernet device structure.
298 * 0 on success, negative error value otherwise.
301 mvneta_dev_set_link_up(struct rte_eth_dev *dev)
303 struct mvneta_priv *priv = dev->data->dev_private;
308 return neta_ppio_enable(priv->ppio);
312 * DPDK callback to bring the link down.
315 * Pointer to Ethernet device structure.
318 * 0 on success, negative error value otherwise.
321 mvneta_dev_set_link_down(struct rte_eth_dev *dev)
323 struct mvneta_priv *priv = dev->data->dev_private;
328 return neta_ppio_disable(priv->ppio);
332 * DPDK callback to start the device.
335 * Pointer to Ethernet device structure.
338 * 0 on success, negative errno value on failure.
341 mvneta_dev_start(struct rte_eth_dev *dev)
343 struct mvneta_priv *priv = dev->data->dev_private;
344 char match[MVNETA_MATCH_LEN];
348 return mvneta_dev_set_link_up(dev);
350 snprintf(match, sizeof(match), "%s", dev->data->name);
351 priv->ppio_params.match = match;
352 priv->ppio_params.inqs_params.mtu = dev->data->mtu;
354 ret = neta_ppio_init(&priv->ppio_params, &priv->ppio);
356 MVNETA_LOG(ERR, "Failed to init ppio");
359 priv->ppio_id = priv->ppio->port_id;
362 * In case there are some some stale uc/mc mac addresses flush them
363 * here. It cannot be done during mvneta_dev_close() as port information
364 * is already gone at that point (due to neta_ppio_deinit() in
365 * mvneta_dev_stop()).
367 if (!priv->uc_mc_flushed) {
368 ret = neta_ppio_flush_mac_addrs(priv->ppio, 0, 1);
371 "Failed to flush uc/mc filter list");
374 priv->uc_mc_flushed = 1;
377 ret = mvneta_alloc_rx_bufs(dev);
381 ret = mvneta_mtu_set(dev, dev->data->mtu);
383 MVNETA_LOG(ERR, "Failed to set MTU %d", dev->data->mtu);
387 ret = mvneta_dev_set_link_up(dev);
389 MVNETA_LOG(ERR, "Failed to set link up");
393 /* start tx queues */
394 for (i = 0; i < dev->data->nb_tx_queues; i++)
395 dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
397 mvneta_set_tx_function(dev);
402 MVNETA_LOG(ERR, "Failed to start device");
403 neta_ppio_deinit(priv->ppio);
408 * DPDK callback to stop the device.
411 * Pointer to Ethernet device structure.
414 mvneta_dev_stop(struct rte_eth_dev *dev)
416 struct mvneta_priv *priv = dev->data->dev_private;
421 mvneta_dev_set_link_down(dev);
422 mvneta_flush_queues(dev);
423 neta_ppio_deinit(priv->ppio);
429 * DPDK callback to close the device.
432 * Pointer to Ethernet device structure.
435 mvneta_dev_close(struct rte_eth_dev *dev)
437 struct mvneta_priv *priv = dev->data->dev_private;
441 mvneta_dev_stop(dev);
443 for (i = 0; i < dev->data->nb_rx_queues; i++) {
444 mvneta_rx_queue_release(dev->data->rx_queues[i]);
445 dev->data->rx_queues[i] = NULL;
448 for (i = 0; i < dev->data->nb_tx_queues; i++) {
449 mvneta_tx_queue_release(dev->data->tx_queues[i]);
450 dev->data->tx_queues[i] = NULL;
455 * DPDK callback to retrieve physical link information.
458 * Pointer to Ethernet device structure.
459 * @param wait_to_complete
460 * Wait for request completion (ignored).
463 * 0 on success, negative error value otherwise.
466 mvneta_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
470 * once MUSDK provides necessary API use it here
472 struct mvneta_priv *priv = dev->data->dev_private;
473 struct ethtool_cmd edata;
475 int ret, fd, link_up;
480 edata.cmd = ETHTOOL_GSET;
482 strcpy(req.ifr_name, dev->data->name);
483 req.ifr_data = (void *)&edata;
485 fd = socket(AF_INET, SOCK_DGRAM, 0);
488 ret = ioctl(fd, SIOCETHTOOL, &req);
496 switch (ethtool_cmd_speed(&edata)) {
498 dev->data->dev_link.link_speed = ETH_SPEED_NUM_10M;
501 dev->data->dev_link.link_speed = ETH_SPEED_NUM_100M;
504 dev->data->dev_link.link_speed = ETH_SPEED_NUM_1G;
507 dev->data->dev_link.link_speed = ETH_SPEED_NUM_2_5G;
510 dev->data->dev_link.link_speed = ETH_SPEED_NUM_NONE;
513 dev->data->dev_link.link_duplex = edata.duplex ? ETH_LINK_FULL_DUPLEX :
514 ETH_LINK_HALF_DUPLEX;
515 dev->data->dev_link.link_autoneg = edata.autoneg ? ETH_LINK_AUTONEG :
518 neta_ppio_get_link_state(priv->ppio, &link_up);
519 dev->data->dev_link.link_status = link_up ? ETH_LINK_UP : ETH_LINK_DOWN;
525 * DPDK callback to enable promiscuous mode.
528 * Pointer to Ethernet device structure.
531 mvneta_promiscuous_enable(struct rte_eth_dev *dev)
533 struct mvneta_priv *priv = dev->data->dev_private;
539 neta_ppio_get_promisc(priv->ppio, &en);
541 MVNETA_LOG(INFO, "Promiscuous already enabled");
545 ret = neta_ppio_set_promisc(priv->ppio, 1);
547 MVNETA_LOG(ERR, "Failed to enable promiscuous mode");
551 * DPDK callback to disable allmulticast mode.
554 * Pointer to Ethernet device structure.
557 mvneta_promiscuous_disable(struct rte_eth_dev *dev)
559 struct mvneta_priv *priv = dev->data->dev_private;
565 neta_ppio_get_promisc(priv->ppio, &en);
567 MVNETA_LOG(INFO, "Promiscuous already disabled");
571 ret = neta_ppio_set_promisc(priv->ppio, 0);
573 MVNETA_LOG(ERR, "Failed to disable promiscuous mode");
577 * DPDK callback to remove a MAC address.
580 * Pointer to Ethernet device structure.
585 mvneta_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
587 struct mvneta_priv *priv = dev->data->dev_private;
588 char buf[ETHER_ADDR_FMT_SIZE];
594 ret = neta_ppio_remove_mac_addr(priv->ppio,
595 dev->data->mac_addrs[index].addr_bytes);
597 ether_format_addr(buf, sizeof(buf),
598 &dev->data->mac_addrs[index]);
599 MVNETA_LOG(ERR, "Failed to remove mac %s", buf);
604 * DPDK callback to add a MAC address.
607 * Pointer to Ethernet device structure.
609 * MAC address to register.
613 * VMDq pool index to associate address with (unused).
616 * 0 on success, negative error value otherwise.
619 mvneta_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
620 uint32_t index, uint32_t vmdq __rte_unused)
622 struct mvneta_priv *priv = dev->data->dev_private;
623 char buf[ETHER_ADDR_FMT_SIZE];
627 /* For setting index 0, mrvl_mac_addr_set() should be used.*/
633 ret = neta_ppio_add_mac_addr(priv->ppio, mac_addr->addr_bytes);
635 ether_format_addr(buf, sizeof(buf), mac_addr);
636 MVNETA_LOG(ERR, "Failed to add mac %s", buf);
644 * DPDK callback to set the primary MAC address.
647 * Pointer to Ethernet device structure.
649 * MAC address to register.
652 mvneta_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
654 struct mvneta_priv *priv = dev->data->dev_private;
660 ret = neta_ppio_set_mac_addr(priv->ppio, mac_addr->addr_bytes);
662 char buf[ETHER_ADDR_FMT_SIZE];
663 ether_format_addr(buf, sizeof(buf), mac_addr);
664 MVNETA_LOG(ERR, "Failed to set mac to %s", buf);
670 * DPDK callback to get device statistics.
673 * Pointer to Ethernet device structure.
675 * Stats structure output buffer.
678 * 0 on success, negative error value otherwise.
681 mvneta_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
683 struct mvneta_priv *priv = dev->data->dev_private;
684 struct neta_ppio_statistics ppio_stats;
690 ret = neta_ppio_get_statistics(priv->ppio, &ppio_stats);
692 MVNETA_LOG(ERR, "Failed to update port statistics");
696 stats->ipackets += ppio_stats.rx_packets +
697 ppio_stats.rx_broadcast_packets +
698 ppio_stats.rx_multicast_packets;
699 stats->opackets += ppio_stats.tx_packets +
700 ppio_stats.tx_broadcast_packets +
701 ppio_stats.tx_multicast_packets;
702 stats->ibytes += ppio_stats.rx_bytes;
703 stats->obytes += ppio_stats.tx_bytes;
704 stats->imissed += ppio_stats.rx_discard +
705 ppio_stats.rx_overrun;
707 stats->ierrors = ppio_stats.rx_packets_err +
708 ppio_stats.rx_errors +
709 ppio_stats.rx_crc_error;
710 stats->oerrors = ppio_stats.tx_errors;
715 static const struct eth_dev_ops mvneta_ops = {
716 .dev_configure = mvneta_dev_configure,
717 .dev_start = mvneta_dev_start,
718 .dev_stop = mvneta_dev_stop,
719 .dev_set_link_up = mvneta_dev_set_link_up,
720 .dev_set_link_down = mvneta_dev_set_link_down,
721 .dev_close = mvneta_dev_close,
722 .link_update = mvneta_link_update,
723 .promiscuous_enable = mvneta_promiscuous_enable,
724 .promiscuous_disable = mvneta_promiscuous_disable,
725 .mac_addr_remove = mvneta_mac_addr_remove,
726 .mac_addr_add = mvneta_mac_addr_add,
727 .mac_addr_set = mvneta_mac_addr_set,
728 .mtu_set = mvneta_mtu_set,
729 .stats_get = mvneta_stats_get,
730 .dev_infos_get = mvneta_dev_infos_get,
731 .dev_supported_ptypes_get = mvneta_dev_supported_ptypes_get,
732 .rxq_info_get = mvneta_rxq_info_get,
733 .txq_info_get = mvneta_txq_info_get,
734 .rx_queue_setup = mvneta_rx_queue_setup,
735 .rx_queue_release = mvneta_rx_queue_release,
736 .tx_queue_setup = mvneta_tx_queue_setup,
737 .tx_queue_release = mvneta_tx_queue_release,
741 * Create device representing Ethernet port.
744 * Pointer to the port's name.
747 * 0 on success, negative error value otherwise.
750 mvneta_eth_dev_create(struct rte_vdev_device *vdev, const char *name)
752 int ret, fd = socket(AF_INET, SOCK_DGRAM, 0);
753 struct rte_eth_dev *eth_dev;
754 struct mvneta_priv *priv;
757 eth_dev = rte_eth_dev_allocate(name);
761 priv = rte_zmalloc_socket(name, sizeof(*priv), 0, rte_socket_id());
767 eth_dev->data->mac_addrs =
768 rte_zmalloc("mac_addrs",
769 ETHER_ADDR_LEN * MVNETA_MAC_ADDRS_MAX, 0);
770 if (!eth_dev->data->mac_addrs) {
771 MVNETA_LOG(ERR, "Failed to allocate space for eth addrs");
776 memset(&req, 0, sizeof(req));
777 strcpy(req.ifr_name, name);
778 ret = ioctl(fd, SIOCGIFHWADDR, &req);
782 memcpy(eth_dev->data->mac_addrs[0].addr_bytes,
783 req.ifr_addr.sa_data, ETHER_ADDR_LEN);
785 eth_dev->data->kdrv = RTE_KDRV_NONE;
786 eth_dev->data->dev_private = priv;
787 eth_dev->device = &vdev->device;
788 eth_dev->rx_pkt_burst = mvneta_rx_pkt_burst;
789 mvneta_set_tx_function(eth_dev);
790 eth_dev->dev_ops = &mvneta_ops;
792 rte_eth_dev_probing_finish(eth_dev);
795 rte_free(eth_dev->data->mac_addrs);
799 rte_eth_dev_release_port(eth_dev);
805 * Cleanup previously created device representing Ethernet port.
808 * Pointer to the corresponding rte_eth_dev structure.
811 mvneta_eth_dev_destroy(struct rte_eth_dev *eth_dev)
813 rte_free(eth_dev->data->dev_private);
814 rte_free(eth_dev->data->mac_addrs);
815 rte_eth_dev_release_port(eth_dev);
819 * Cleanup previously created device representing Ethernet port.
822 * Pointer to the port name.
825 mvneta_eth_dev_destroy_name(const char *name)
827 struct rte_eth_dev *eth_dev;
829 eth_dev = rte_eth_dev_allocated(name);
833 mvneta_eth_dev_destroy(eth_dev);
837 * DPDK callback to register the virtual device.
840 * Pointer to the virtual device.
843 * 0 on success, negative error value otherwise.
846 rte_pmd_mvneta_probe(struct rte_vdev_device *vdev)
848 struct rte_kvargs *kvlist;
849 struct mvneta_ifnames ifnames;
854 params = rte_vdev_device_args(vdev);
858 kvlist = rte_kvargs_parse(params, valid_args);
862 ifnum = rte_kvargs_count(kvlist, MVNETA_IFACE_NAME_ARG);
863 if (ifnum > RTE_DIM(ifnames.names))
864 goto out_free_kvlist;
867 rte_kvargs_process(kvlist, MVNETA_IFACE_NAME_ARG,
868 mvneta_ifnames_get, &ifnames);
871 * The below system initialization should be done only once,
872 * on the first provided configuration file
877 MVNETA_LOG(INFO, "Perform MUSDK initializations");
879 ret = rte_mvep_init(MVEP_MOD_T_NETA, kvlist);
881 goto out_free_kvlist;
883 ret = mvneta_neta_init();
885 MVNETA_LOG(ERR, "Failed to init NETA!");
886 rte_mvep_deinit(MVEP_MOD_T_NETA);
887 goto out_free_kvlist;
891 for (i = 0; i < ifnum; i++) {
892 MVNETA_LOG(INFO, "Creating %s", ifnames.names[i]);
893 ret = mvneta_eth_dev_create(vdev, ifnames.names[i]);
897 mvneta_dev_num += ifnum;
899 rte_kvargs_free(kvlist);
904 mvneta_eth_dev_destroy_name(ifnames.names[i]);
906 if (mvneta_dev_num == 0) {
907 mvneta_neta_deinit();
908 rte_mvep_deinit(MVEP_MOD_T_NETA);
911 rte_kvargs_free(kvlist);
917 * DPDK callback to remove virtual device.
920 * Pointer to the removed virtual device.
923 * 0 on success, negative error value otherwise.
926 rte_pmd_mvneta_remove(struct rte_vdev_device *vdev)
931 name = rte_vdev_device_name(vdev);
935 MVNETA_LOG(INFO, "Removing %s", name);
937 RTE_ETH_FOREACH_DEV(i) {
938 if (rte_eth_devices[i].device != &vdev->device)
941 mvneta_eth_dev_destroy(&rte_eth_devices[i]);
945 if (mvneta_dev_num == 0) {
946 MVNETA_LOG(INFO, "Perform MUSDK deinit");
947 mvneta_neta_deinit();
948 rte_mvep_deinit(MVEP_MOD_T_NETA);
954 static struct rte_vdev_driver pmd_mvneta_drv = {
955 .probe = rte_pmd_mvneta_probe,
956 .remove = rte_pmd_mvneta_remove,
959 RTE_PMD_REGISTER_VDEV(net_mvneta, pmd_mvneta_drv);
960 RTE_PMD_REGISTER_PARAM_STRING(net_mvneta, "iface=<ifc>");
962 RTE_INIT(mvneta_init_log)
964 mvneta_logtype = rte_log_register("pmd.net.mvneta");
965 if (mvneta_logtype >= 0)
966 rte_log_set_level(mvneta_logtype, RTE_LOG_NOTICE);