forked from KolibriOS/kolibrios
99 lines
4.5 KiB
Plaintext
99 lines
4.5 KiB
Plaintext
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.
|
|
.adjust_cache_size dd ?
|
|
; unsigned int adjust_cache_size(unsigned int suggested_size);
|
|
; Optional.
|
|
; Returns the cache size for this device in bytes. 0 = disable cache.
|
|
}
|
|
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.
|