Home | History | Annotate | Line # | Download | only in ic
      1 /*	$NetBSD: icp_ioctl.c,v 1.23 2022/01/21 21:40:31 andvar Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2003 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Jason R. Thorpe of Wasabi Systems, Inc.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 /*
     33  *       Copyright (c) 2000-01 Intel Corporation
     34  *       All Rights Reserved
     35  *
     36  * Redistribution and use in source and binary forms, with or without
     37  * modification, are permitted provided that the following conditions
     38  * are met:
     39  * 1. Redistributions of source code must retain the above copyright
     40  *    notice, this list of conditions, and the following disclaimer,
     41  *    without modification, immediately at the beginning of the file.
     42  * 2. Redistributions in binary form must reproduce the above copyright
     43  *    notice, this list of conditions and the following disclaimer in the
     44  *    documentation and/or other materials provided with the distribution.
     45  * 3. The name of the author may not be used to endorse or promote products
     46  *    derived from this software without specific prior written permission.
     47  *
     48  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     49  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     50  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     51  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
     52  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     53  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     54  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     55  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     56  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     57  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     58  * SUCH DAMAGE.
     59  */
     60 
     61 /*
     62  * icp_ioctl.c: Ioctl interface for the ICP-Vortex management tools.
     63  *
     64  * Based on ICP's FreeBSD "iir" driver ioctl interface, written by
     65  * Achim Leubner <achim.leubner (at) intel.com>.
     66  *
     67  * This is intended to be ABI-compatible with the ioctl interface for
     68  * other OSs.
     69  */
     70 
     71 #include <sys/cdefs.h>
     72 __KERNEL_RCSID(0, "$NetBSD: icp_ioctl.c,v 1.23 2022/01/21 21:40:31 andvar Exp $");
     73 
     74 #include <sys/param.h>
     75 #include <sys/systm.h>
     76 #include <sys/kernel.h>
     77 #include <sys/device.h>
     78 #include <sys/proc.h>
     79 #include <sys/conf.h>
     80 #include <sys/ioctl.h>
     81 #include <sys/kauth.h>
     82 
     83 #include <sys/bus.h>
     84 
     85 #include <dev/ic/icpreg.h>
     86 #include <dev/ic/icpvar.h>
     87 
     88 #include "ioconf.h"
     89 
     90 /* These are simply the same as ICP's "iir" driver for FreeBSD. */
     91 #define	ICP_DRIVER_VERSION		1
     92 #define	ICP_DRIVER_SUBVERSION		3
     93 
     94 static dev_type_open(icpopen);
     95 static dev_type_ioctl(icpioctl);
     96 
     97 const struct cdevsw icp_cdevsw = {
     98 	.d_open = icpopen,
     99 	.d_close = nullclose,
    100 	.d_read = noread,
    101 	.d_write = nowrite,
    102 	.d_ioctl = icpioctl,
    103 	.d_stop = nostop,
    104 	.d_tty = notty,
    105 	.d_poll = nopoll,
    106 	.d_mmap = nommap,
    107 	.d_kqfilter = nokqfilter,
    108 	.d_discard = nodiscard,
    109 	.d_flag = D_OTHER
    110 };
    111 
    112 kmutex_t icp_ioctl_mutex;
    113 
    114 static int
    115 icpopen(dev_t dev, int flag, int mode, struct lwp *l)
    116 {
    117 
    118 	if (device_lookup(&icp_cd, minor(dev)) == NULL)
    119 		return (ENXIO);
    120 
    121 	return (0);
    122 }
    123 
    124 static int
    125 icpioctl(dev_t dev, u_long cmd, void *data, int flag,
    126     struct lwp *l)
    127 {
    128 	int error = 0;
    129 
    130 	mutex_enter(&icp_ioctl_mutex);
    131 
    132 	switch (cmd) {
    133 	case GDT_IOCTL_GENERAL:
    134 	    {
    135 		struct icp_softc *icp;
    136 		gdt_ucmd_t *ucmd = (void *) data;
    137 
    138 		error = kauth_authorize_device_passthru(l->l_cred, dev,
    139 		    KAUTH_REQ_DEVICE_RAWIO_PASSTHRU_ALL, data);
    140 		if (error)
    141 			break;
    142 
    143 		icp = device_lookup_private(&icp_cd, ucmd->io_node);
    144 		if (icp == NULL) {
    145 			error = ENXIO;
    146 			break;
    147 		}
    148 
    149 		error = icp_ucmd(icp, ucmd);
    150 		break;
    151 	    }
    152 
    153 	case GDT_IOCTL_DRVERS:
    154 		*(int *) data =
    155 		    (ICP_DRIVER_VERSION << 8) | ICP_DRIVER_SUBVERSION;
    156 		break;
    157 
    158 	case GDT_IOCTL_CTRTYPE:
    159 	    {
    160 		struct icp_softc *icp;
    161 		gdt_ctrt_t *ctrt = (void *) data;
    162 
    163 		icp = device_lookup_private(&icp_cd, ctrt->io_node);
    164 		if (icp == NULL) {
    165 			error = ENXIO;
    166 			break;
    167 		}
    168 
    169 		/* XXX magic numbers */
    170 		ctrt->oem_id = 0x8000;
    171 		ctrt->type = 0xfd;
    172 		ctrt->info = (icp->icp_pci_bus << 8) | (icp->icp_pci_device << 3);
    173 		ctrt->ext_type = 0x6000 | icp->icp_pci_subdevice_id;
    174 		ctrt->device_id = icp->icp_pci_device_id;
    175 		ctrt->sub_device_id = icp->icp_pci_subdevice_id;
    176 		break;
    177 	    }
    178 
    179 	case GDT_IOCTL_OSVERS:
    180 	    {
    181 		gdt_osv_t *osv = (void *) data;
    182 
    183 		osv->oscode = 12;
    184 
    185 		/*
    186 		 * __NetBSD_Version__ is encoded thusly:
    187 		 *
    188 		 *	MMmmrrpp00
    189 		 *
    190 		 * M = major version
    191 		 * m = minor version
    192 		 * r = release ["",A-Z[A-Z] but numeric]
    193 		 * p = patchlevel
    194 		 *
    195 		 * Since the ABI is not supposed to change between
    196 		 * patchlevels of the same major/minor version, we
    197 		 * will encode major/minor/release into the returned
    198 		 * data.
    199 		 */
    200 
    201 		osv->version = __NetBSD_Version__ / 100000000;
    202 		osv->subversion = (__NetBSD_Version__ / 1000000) % 100;
    203 		osv->revision = (__NetBSD_Version__ / 10000) % 100;
    204 
    205 		strcpy(osv->name, ostype);
    206 		break;
    207 	    }
    208 
    209 	case GDT_IOCTL_CTRCNT:
    210 		*(int *) data = icp_count;
    211 		break;
    212 
    213 	case GDT_IOCTL_EVENT:
    214 	    {
    215 		struct icp_softc *icp;
    216 		gdt_event_t *evt = (void *) data;
    217 		gdt_evt_str *e = &evt->dvr;
    218 		int s;
    219 
    220 		icp = device_lookup_private(&icp_cd, minor(dev));
    221 
    222 		switch (evt->erase) {
    223 		case 0xff:
    224 			switch (evt->dvr.event_source) {
    225 			case GDT_ES_TEST:
    226 				e->event_data.size =
    227 				    sizeof(e->event_data.eu.test);
    228 				break;
    229 
    230 			case GDT_ES_DRIVER:
    231 				e->event_data.size =
    232 				    sizeof(e->event_data.eu.driver);
    233 				break;
    234 
    235 			case GDT_ES_SYNC:
    236 				e->event_data.size =
    237 				    sizeof(e->event_data.eu.sync);
    238 				break;
    239 
    240 			default:
    241 				e->event_data.size =
    242 				    sizeof(e->event_data.eu.async);
    243 				break;
    244 			}
    245 			s = splbio();
    246 			icp_store_event(icp, e->event_source, e->event_idx,
    247 			    &e->event_data);
    248 			splx(s);
    249 			break;
    250 
    251 		case 0xfe:
    252 			s = splbio();
    253 			icp_clear_events(icp);
    254 			splx(s);
    255 			break;
    256 
    257 		case 0:
    258 			evt->handle = icp_read_event(icp, evt->handle, e);
    259 			break;
    260 
    261 		default:
    262 			icp_readapp_event(icp, (u_int8_t) evt->erase, e);
    263 			break;
    264 		}
    265 		break;
    266 	    }
    267 
    268 	case GDT_IOCTL_STATIST:
    269 		memcpy(&icp_stats, data, sizeof(gdt_statist_t));
    270 		break;
    271 
    272 
    273 	case GDT_IOCTL_RESCAN:
    274 	    {
    275 		struct icp_softc *icp;
    276 		gdt_rescan_t *rsc = (void *) data;
    277 
    278 		icp = device_lookup_private(&icp_cd, rsc->io_node);
    279 		if (icp == NULL) {
    280 			error = ENXIO;
    281 			break;
    282 		}
    283 
    284 		error = icp_freeze(icp);
    285 		if (error)
    286 			break;
    287 		if (rsc->flag == 0)
    288 			icp_rescan_all(icp);
    289 		else
    290 			icp_rescan(icp, rsc->hdr_no);
    291 		icp_unfreeze(icp);
    292 		break;
    293 	    }
    294 
    295 	default:
    296 		error = ENOTTY;
    297 	}
    298 
    299 	mutex_exit(&icp_ioctl_mutex);
    300 
    301 	return (error);
    302 }
    303