0,0 → 1,94 |
All functions are stdcall unless mentioned otherwise. |
|
=== Disk === |
The kernel exports the functions 'DiskAdd', 'DiskMediaChanged', 'DiskDel' for |
drivers. They must be called in the following order: DiskAdd, then zero or |
more DiskMediaChanged, then optionally DiskDel. The driver must not call |
two functions in parallel, including two calls to DiskMediaChanged. |
|
void* DiskAdd(DISKFUNC* functions, const char* name, void* userdata, int flags); |
; The pointer 'functions' must be valid at least until the disk will be deleted |
; (until DISKFUNC.close is called). |
; The pointer 'name' can be invalid after this function returns. |
; It should point to ASCIIZ-string without leading '/' in latin lowercase and |
; digits, like 'usbhd0'. |
; The value 'userdata' is any pointer-sized data, passed as is to all |
; callbacks. |
DISK_NO_INSERT_NOTIFICATION = 1 |
; The bitfield 'flags' has currently only one bit defined. If it is set, the |
; driver will never call DiskMediaChanged(hDisk, true), so the kernel must scan |
; for media insertion when the operation is requested. |
struc DISKFUNC |
{ |
.strucsize dd ? |
.close dd ? |
; void close(void* userdata); |
; Optional. |
; The last function that is called for the given disk. The kernel calls it when |
; the kernel has finished all operations with the disk and it is safe to free |
; all driver-specific data identified by 'userdata'. |
.closemedia dd ? |
; void closemedia(void* userdata); |
; Optional. |
; The kernel calls this function when it finished all processing with the |
; current media. If media is removed, the driver should decline all requests |
; to that media with DISK_STATUS_NO_MEDIA, even if new media is inserted, |
; until this function is called. If media is removed, a new call to |
; DiskMediaChanged(hDisk, true) is not allowed until this function is called. |
.querymedia dd ? |
; int querymedia(void* userdata, DISKMEDIAINFO* info); |
; return value: 0 = success, otherwise = error |
.read dd ? |
; int read(void* userdata, void* buffer, __int64 startsector, |
; int* numsectors); |
; return value: 0 = success, otherwise = error |
.write dd ? |
; int write(void* userdata, const void* buffer, __int64 startsector, |
; int* numsectors); |
; Optional. |
; return value: 0 = success, otherwise = error |
.flush dd ? |
; int flush(void* userdata); |
; Optional. |
; Flushes the hardware cache, if it exists. Note that a driver should not |
; implement a software cache for read/write, since they are called from the |
; kernel cache manager. |
} |
struc DISKMEDIAINFO |
{ |
.flags dd ? |
DISK_MEDIA_READONLY = 1 |
.sectorsize dd ? |
.capacity dq ? |
} |
void DiskDel(void* hDisk); |
; This function informs the kernel that the disk should be deleted from the |
; system. This function removes the disk from the global file system; however, |
; it is possible that active operations with the disk are still running. When |
; the disk is actually removed, the kernel calls the 'close' function, which |
; can free all device-related resources. |
void DiskMediaChanged(void* hDisk, int newstate); |
; This function informs the kernel that a media has been inserted, removed or |
; changed. 'newstate' should be zero if currently there is no media inserted |
; and nonzero in the other case. This function must not be called with nonzero |
; 'newstate' from any of callbacks. This function must not be called if another |
; call to this function is active. |
|
=== Timers === |
Timers allow to schedule a function call to some time in the future, once |
or periodically. A timer function can do anything, including adding/removing |
other timers and itself, but it should not run time-consuming tasks, since that |
would block the processing thread for a long time; for such tasks it is |
recommended to create new thread. |
|
void* TimerHS(unsigned int deltaStart, unsigned int interval, |
void* timerFunc, void* userData); |
; Registers a timer which is activated in (deltaStart == 0 ? deltaStart : |
; interval) 1/100ths of second starting from the current time. If interval |
; is zero, this timer is automatically deleted when activated. Otherwise, |
; this timer will be activated every (interval) 1/100ths of second from the |
; first activation. Activated timer calls timerFunc(userData) as stdcall. |
; Returned value: NULL = failed, otherwise = timer handle which can be passed |
; to CancelTimerHS. |
void CancelTimerHS(void* hTimer); |
; Cancels previously registered timer. |