![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nf_scsidrv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src|
Return to nf_scsidrv.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
2: * Hatari - nf_scsidrv.c
3: *
4: * Copyright (C) 2015-2016 by Uwe Seimet
5: *
6: * This file is distributed under the GNU General Public License, version 2
7: * or at your option any later version. Read the file gpl.txt for details.
8: *
9: * nf_scsidrv.c - Implementation of the host system part of a SCSI Driver
10: * (Linux only), based on the Linux SG driver version 3. The corresponding
11: * TOS binary and its source code can be downloaded from
12: * http://hddriver.seimet.de/en/downloads.html, where you can also find
13: * information on the open SCSI Driver standard.
14: */
15: const char NfScsiDrv_fileid[] = "Hatari nf_scsidrv.c : " __DATE__ " " __TIME__;
16:
17: #if defined(__linux__)
18:
19: #include "config.h"
20: #include <stdlib.h>
21: #include <unistd.h>
22: #include <fcntl.h>
23: #if HAVE_UDEV
24: #include <libudev.h>
25: #endif
26: #include <sys/ioctl.h>
27: #include <scsi/sg.h>
28: #include "stMemory.h"
29: #include "log.h"
30: #include "gemdos_defines.h"
31: #include "nf_scsidrv.h"
32:
33: // The driver interface version, 1.02
34: #define INTERFACE_VERSION 0x0102
35: // Maximum is 20 characters
36: #define BUS_NAME "Linux Generic SCSI"
37: // The SG driver supports cAllCmds
38: #define BUS_FEATURES 0x02
39: // The transfer length may depend on the device, 65536 should always be safe
40: #define BUS_TRANSFER_LEN 65536
41: // The maximum number of SCSI Driver handles, must be the same as in the stub
42: #define SCSI_MAX_HANDLES 32
43:
44:
45: typedef struct
46: {
47: int fd;
48: int id_lo;
49: int error;
50: } HANDLE_META_DATA;
51:
52: static HANDLE_META_DATA handle_meta_data[SCSI_MAX_HANDLES];
53:
54: #if HAVE_UDEV
55: static struct udev *udev;
56: static struct udev_monitor *mon;
57: static int udev_mon_fd;
58: static struct timeval tv;
59: #endif
60:
61: static Uint32 read_stack_long(Uint32 *stack)
62: {
63: Uint32 value = STMemory_ReadLong(*stack);
64:
65: *stack += SIZE_LONG;
66:
67: return value;
68: }
69:
70: static void *read_stack_pointer(Uint32 *stack)
71: {
72: Uint32 ptr = read_stack_long(stack);
73: return ptr ? STMemory_STAddrToPointer(ptr) : 0;
74: }
75:
76: static void write_long(Uint32 addr, Uint32 value)
77: {
78: STMemory_WriteLong(addr, value);
79: }
80:
81: static void write_word(Uint32 addr, Uint16 value)
82: {
83: STMemory_WriteWord(addr, value);
84: }
85:
86: // Sets the error status
87: static void set_error(Uint32 handle, int errbit)
88: {
89: Uint32 i;
90: for (i = 0; i < SCSI_MAX_HANDLES; i++)
91: {
92: if (handle != i && handle_meta_data[i].fd &&
93: handle_meta_data[i].id_lo == handle_meta_data[handle].id_lo)
94: {
95: handle_meta_data[i].error |= errbit;
96: }
97: }
98: }
99:
100: // udev-based check for media change. When udev is active media change messages
101: // are handled globally by udev, i.e. that media changes cannot directly be
102: // detected by the SCSI Driver. The SCSI Driver has to query udev instead.
103: static bool check_mchg_udev(void)
104: {
105: bool changed = false;
106:
107: #if HAVE_UDEV
108: fd_set udevFds;
109: int ret;
110:
111: FD_ZERO(&udevFds);
112: FD_SET(udev_mon_fd, &udevFds);
113:
114: ret = select(udev_mon_fd + 1, &udevFds, 0, 0, &tv);
115: if (ret > 0 && FD_ISSET(udev_mon_fd, &udevFds))
116: {
117: struct udev_device *dev = udev_monitor_receive_device(mon);
118: while (dev)
119: {
120: if (!changed)
121: {
122: const char *dev_type = udev_device_get_devtype(dev);
123: const char *action = udev_device_get_action(dev);
124: if (!strcmp("disk", dev_type) && !strcmp("change", action))
125: {
126: LOG_TRACE(TRACE_SCSIDRV, ": %s has been changed",
127: udev_device_get_devnode(dev));
128:
129: // TODO Determine sg device name from block device name and
130: // only report media change for the actually affected device
131:
132: changed = true;
133: }
134: }
135:
136: // Process all pending events
137: dev = udev_monitor_receive_device(mon);
138: }
139: }
140: #endif
141:
142: return changed;
143: }
144:
145: // Checks whether a device exists by checking for the device file name
146: static int check_device_file(Uint32 id)
147: {
148: char device_file[16];
149: sprintf(device_file, "/dev/sg%d", id);
150:
151: if (!access(device_file, R_OK | W_OK))
152: {
153: LOG_TRACE(TRACE_SCSIDRV, ", device file %s is accessible",
154: device_file);
155:
156: return 0;
157: }
158: else
159: {
160: LOG_TRACE(TRACE_SCSIDRV, ", device file %s is inaccessible",
161: device_file);
162:
163: return -1;
164: }
165: }
166:
167: static int scsidrv_interface_version(Uint32 stack)
168: {
169: return INTERFACE_VERSION;
170: }
171:
172: static int scsidrv_interface_features(Uint32 stack)
173: {
174: char *busName = read_stack_pointer(&stack);
175: Uint32 features = read_stack_long(&stack);
176: Uint32 transferLen = read_stack_long(&stack);
177:
178: strncpy(busName, BUS_NAME, 20);
179: write_word(features, BUS_FEATURES);
180: write_long(transferLen, BUS_TRANSFER_LEN);
181:
182: return 0;
183: }
184:
185: // SCSI Driver: InquireBus()
186: static int scsidrv_inquire_bus(Uint32 stack)
187: {
188: Uint32 id = read_stack_long(&stack);
189: char device_file[16];
190:
191: LOG_TRACE(TRACE_SCSIDRV, "scsidrv_inquire_bus: id=%d", id);
192:
193: sprintf(device_file, "/dev/sg%d", id);
194:
195: while (!access(device_file, F_OK))
196: {
197: if (!check_device_file(id))
198: {
199: return id;
200: }
201:
202: sprintf(device_file, "/dev/sg%d", ++id);
203: }
204:
205: return -1;
206: }
207:
208: // SCSI Driver: Open()
209: static int scsidrv_open(Uint32 stack)
210: {
211: char device_file[16];
212: Uint32 handle;
213: Uint32 id;
214: int fd;
215:
216: #if HAVE_UDEV
217: if (!udev)
218: {
219: udev = udev_new();
220: if (!udev)
221: {
222: return -1;
223: }
224:
225: mon = udev_monitor_new_from_netlink(udev, "udev");
226: udev_monitor_filter_add_match_subsystem_devtype(mon, "block", NULL);
227: udev_monitor_enable_receiving(mon);
228: udev_mon_fd = udev_monitor_get_fd(mon);
229:
230: tv.tv_sec = 0;
231: tv.tv_usec = 0;
232: }
233: #endif
234:
235: handle = read_stack_long(&stack);
236: id = read_stack_long(&stack);
237:
238: LOG_TRACE(TRACE_SCSIDRV, "scsidrv_open: handle=%d, id=%d", handle, id);
239:
240: if (handle >= SCSI_MAX_HANDLES || handle_meta_data[handle].fd ||
241: check_device_file(id))
242: {
243: return GEMDOS_ENHNDL;
244: }
245:
246: sprintf(device_file, "/dev/sg%d", id);
247:
248: fd = open(device_file, O_RDWR | O_NONBLOCK);
249: if (fd < 0)
250: {
251: return fd;
252: }
253:
254: handle_meta_data[handle].fd = fd;
255: handle_meta_data[handle].id_lo = id;
256: handle_meta_data[handle].error = 0;
257:
258: return 0;
259: }
260:
261: // SCSI Driver: Close()
262: static int scsidrv_close(Uint32 stack)
263: {
264: Uint32 handle = read_stack_long(&stack);
265:
266: LOG_TRACE(TRACE_SCSIDRV, "scsidrv_close: handle=%d", handle);
267:
268: if (handle >= SCSI_MAX_HANDLES || !handle_meta_data[handle].fd)
269: {
270: return GEMDOS_ENHNDL;
271: }
272:
273: close(handle_meta_data[handle].fd);
274:
275: handle_meta_data[handle].fd = 0;
276:
277: return 0;
278: }
279:
280: // SCSI Driver: In() and Out()
281: static int scsidrv_inout(Uint32 stack)
282: {
283: Uint32 handle = read_stack_long(&stack);
284: Uint32 dir = read_stack_long(&stack);
285: unsigned char *cmd = read_stack_pointer(&stack);
286: Uint32 cmd_len = read_stack_long(&stack);
287: unsigned char *buffer = read_stack_pointer(&stack);
288: Uint32 transfer_len = read_stack_long(&stack);
289: unsigned char *sense_buffer = read_stack_pointer(&stack);
290: Uint32 timeout;
291: int status;
292:
293: if (sense_buffer)
294: {
295: memset(sense_buffer, 0, 18);
296: }
297: timeout = read_stack_long(&stack);
298:
299: if (LOG_TRACE_LEVEL(TRACE_SCSIDRV))
300: {
301: LOG_TRACE_PRINT(
302: "scsidrv_inout: handle=%d, dir=%d, cmd_len=%d, buffer=%p,\n"
303: " transfer_len=%d, sense_buffer=%p, timeout=%d,\n"
304: " cmd=",
305: handle, dir, cmd_len, buffer, transfer_len, sense_buffer,
306: timeout);
307:
308: Uint32 i;
309: for (i = 0; i < cmd_len; i++)
310: {
311: char str[8];
312: sprintf(str, i ? ":$%02X" : "$%02X", cmd[i]);
313: LOG_TRACE_PRINT("%s", str);
314: }
315: }
316:
317: if (handle >= SCSI_MAX_HANDLES || !handle_meta_data[handle].fd)
318: {
319: return GEMDOS_ENHNDL;
320: }
321:
322: // No explicit LUN support, the SG driver maps LUNs to device files
323: if (cmd[1] & 0xe0)
324: {
325: if (sense_buffer)
326: {
327: // Sense Key and ASC
328: sense_buffer[2] = 0x05;
329: sense_buffer[12] = 0x25;
330:
331: LOG_TRACE(TRACE_SCSIDRV,
332: "\n Sense Key=$%02X, ASC=$%02X, ASCQ=$00",
333: sense_buffer[2], sense_buffer[12]);
334: }
335:
336: return 2;
337: }
338:
339: if (check_mchg_udev())
340: {
341: // cErrMediach for all open handles
342: Uint32 i;
343: for (i = 0; i < SCSI_MAX_HANDLES; i++)
344: {
345: if (handle_meta_data[i].fd)
346: {
347: handle_meta_data[i].error |= 1;
348: }
349: }
350:
351: if (sense_buffer)
352: {
353: // Sense Key and ASC
354: sense_buffer[2] = 0x06;
355: sense_buffer[12] = 0x28;
356: }
357:
358: status = 2;
359: }
360: else
361: {
362: struct sg_io_hdr io_hdr;
363: memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
364:
365: io_hdr.interface_id = 'S';
366:
367: io_hdr.dxfer_direction = dir ? SG_DXFER_TO_DEV : SG_DXFER_FROM_DEV;
368: if (!transfer_len)
369: {
370: io_hdr.dxfer_direction = SG_DXFER_NONE;
371: }
372:
373: io_hdr.dxferp = buffer;
374: io_hdr.dxfer_len = transfer_len;
375:
376: io_hdr.sbp = sense_buffer;
377: io_hdr.mx_sb_len = 18;
378:
379: io_hdr.cmdp = cmd;
380: io_hdr.cmd_len = cmd_len;
381:
382: io_hdr.timeout = timeout;
383:
384: status = ioctl(handle_meta_data[handle].fd,
385: SG_IO, &io_hdr) < 0 ? -1 : io_hdr.status;
386: }
387:
388: if (status > 0 && sense_buffer)
389: {
390: LOG_TRACE(TRACE_SCSIDRV,
391: "\n Sense Key=$%02X, ASC=$%02X, ASCQ=$%02X",
392: sense_buffer[2], sense_buffer[12], sense_buffer[13]);
393:
394: if (status == 2)
395: {
396: // Automatic media change and reset handling for
397: // SCSI Driver version 1.0.1
398: if ((sense_buffer[2] & 0x0f) && !sense_buffer[13])
399: {
400: if (sense_buffer[12] == 0x28)
401: {
402: // cErrMediach
403: set_error(handle, 1);
404: }
405: else if (sense_buffer[12] == 0x29)
406: {
407: // cErrReset
408: set_error(handle, 2);
409: }
410: }
411: }
412: }
413:
414: return status;
415: }
416:
417: // SCSI Driver: Error()
418: static int scsidrv_error(Uint32 stack)
419: {
420: Uint32 handle = read_stack_long(&stack);
421: Uint32 rwflag = read_stack_long(&stack);
422: Uint32 errnum = read_stack_long(&stack);
423: int errbit;
424:
425: LOG_TRACE(TRACE_SCSIDRV, "scsidrv_error: handle=%d, rwflag=%d, errno=%d",
426: handle, rwflag, errnum);
427:
428: if (handle >= SCSI_MAX_HANDLES || !handle_meta_data[handle].fd)
429: {
430: return GEMDOS_ENHNDL;
431: }
432:
433: errbit = 1 << errnum;
434:
435: if (rwflag)
436: {
437: set_error(handle, errbit);
438:
439: return 0;
440: }
441: else
442: {
443: int status = handle_meta_data[handle].error & errbit;
444: handle_meta_data[handle].error &= ~errbit;
445:
446: return status;
447: }
448: }
449:
450: // SCSI Driver: CheckDev()
451: static int scsidrv_check_dev(Uint32 stack)
452: {
453: Uint32 id = read_stack_long(&stack);
454:
455: LOG_TRACE(TRACE_SCSIDRV, "scsidrv_check_dev: id=%d", id);
456:
457: return check_device_file(id);
458: }
459:
460: static const struct
461: {
462: int (*cb)(Uint32 stack);
463: } operations[] =
464: {
465: { scsidrv_interface_version },
466: { scsidrv_interface_features },
467: { scsidrv_inquire_bus },
468: { scsidrv_open },
469: { scsidrv_close },
470: { scsidrv_inout },
471: { scsidrv_error },
472: { scsidrv_check_dev }
473: };
474:
475: bool nf_scsidrv(Uint32 stack, Uint32 subid, Uint32 *retval)
476: {
477: if (subid >= ARRAY_SIZE(operations))
478: {
479: *retval = -1;
480:
481: LOG_TRACE(TRACE_SCSIDRV,
482: "ERROR: Invalid SCSI Driver operation %d requested\n", subid);
483: }
484: else
485: {
486: *retval = operations[subid].cb(stack);
487:
488: LOG_TRACE(TRACE_SCSIDRV, " -> %d\n", *retval);
489: }
490:
491: return true;
492: }
493:
494: void nf_scsidrv_reset()
495: {
496: int i;
497: for (i = 0; i < SCSI_MAX_HANDLES; i++)
498: {
499: if (handle_meta_data[i].fd)
500: {
501: close(handle_meta_data[i].fd);
502:
503: handle_meta_data[i].fd = 0;
504: }
505: }
506: }
507:
508: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.