/*
 * Copyright (c) 1998-2001 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 *
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

#include <IOKit/IOLib.h>
#include <IOKit/IOMemoryCursor.h>

#define CPLUSPLUS
typedef long unsigned int uint_t;
#include "floppy.h"
#include "portdef.h"

// kIOMessageMediaStateHasChanged
// call message(kIOMessageMediaStateHasChanged); when state has changed.

extern "C" {
#include <pexpert/pexpert.h>	//This is for debugging purposes ONLY

io_return_t fdsetstat(dev_t dev,
	     dev_flavor_t flavor,
	     dev_status_t data,
	     natural_t count);
             
void ScanForDisketteChange(void);

BSIOStatus
FloppyPluginIO(int unit, BSStorePtr ioStore,
               BSBlockListDescriptorRef blocks,
               MemListDescriptorRef memory,
               BSIORequestBlockPtr parentRequest,
               OptionBits options,
               struct BSErrorList **errors);

int non_bsd_sleep(void *event, unsigned long usec);

}

int org_mklinux_iokit_swim3_busyflag = 0;

// in floppy.cpp
// virtual IOReturn doAsyncReadWrite(IOMemoryDescriptor *buffer,
//                         UInt32 block,UInt32 nblks,
//                         IOStorageCompletion completion) = 0;

IOReturn org_mklinux_iokit_swim3_driver::doEjectMedia(void)
{
    dev_t dev;
    
    dev=(this->busdev->unit << 6);
    if (fdsetstat(dev, (dev_flavor_t)V_EJECT, NULL, 0) == D_SUCCESS)
        return kIOReturnSuccess;
    else
        return kIOReturnError;
}

IOReturn org_mklinux_iokit_swim3_driver::doFormatMedia(UInt64 byteCapacity)
{
    /* @@@ WRITE ME! @@@*/
    return kIOReturnUnsupported;
}

UInt32 org_mklinux_iokit_swim3_driver::doGetFormatCapacities(UInt64 * capacities,
                        UInt32 capacitiesMaxCount)
{
    /* @@@ WRITE ME! @@@*/
    return kIOReturnUnsupported;
}

IOReturn org_mklinux_iokit_swim3_driver::doLockUnlockMedia(bool doLock)
{
    /* @@@ WRITE ME! @@@*/
    return kIOReturnUnsupported;
}

IOReturn org_mklinux_iokit_swim3_driver::doSyncReadWrite(IOMemoryDescriptor *buffer,
                        UInt32 block,UInt32 nblks)
{

#define NOTYETDAG
#ifdef NOTYETDAG    
//#error UNFINISHED
    uint_t Result;
    BSIOStatus retval;
    OptionBits direction;
    char *localbuf;
#define read 1
#define write 0

    /* I assume the higher levels of the I/O Kit handle checking write protection */

    if (!buffer) return kIOReturnIOError;
    direction = (buffer->getDirection() == kIODirectionIn ?
        kBSRead : kBSWrite);
    
    localbuf = (char *)IOMalloc(nblks * 512);

    while (org_mklinux_iokit_swim3_busyflag == 1) {
        non_bsd_sleep((char *) &org_mklinux_iokit_swim3_busyflag, 10);
    }
    org_mklinux_iokit_swim3_busyflag = 1;
    
    retval = FloppyPluginIO(this->busdev->unit, &Result, nblks,
        (MemListDescriptorRef)localbuf, block * 512,
        direction == read ? kBSRead : kBSWrite, 0); 

    if (Result == nblks) {
        if (buffer->writeBytes(0, (const void *)localbuf, nblks * 512) ==
            (nblks * 512)) {
                IOFree(localbuf, nblks * 512);
                return kIOReturnSuccess;
        }
    }
    /* Partial read, write, or copy */
    IOFree(localbuf, nblks * 512);
    return kIOReturnIOError;
#else
    return kIOReturnIOError;
    return kIOReturnUnsupported;
#endif // NOTYETDAG
}

// virtual IOReturn doSynchronizeCache(void) = 0;
// virtual char * getAdditionalDeviceInfoString(void) = 0;
// virtual char * getProductString(void) = 0;
// virtual char * getRevisionString(void) = 0;
// virtual char * getVendorString(void) = 0;
// virtual bool init(OSDictionary * properties);

extern "C"
{
OSStatus
 FloppyPluginGetInfo(BSStorePtr infoStore,
                     struct BSStoreMPIInfo *info);
}
IOReturn org_mklinux_iokit_swim3_driver::reportBlockSize(UInt64 *blockSize)
{
    struct BSStoreMPIInfo info;
#if 0
    BSStorePtr infoStore;
#endif
    OSStatus ret;

    ret=FloppyPluginGetInfo(NULL, &info);

    *blockSize=info.writeBlockSize;

    if (ret == E_BSSuccess)
        return kIOReturnSuccess;
    else
        return kIOReturnError;
}

IOReturn org_mklinux_iokit_swim3_driver::reportEjectability(bool *isEjectable)
{
    *isEjectable=1;
    return kIOReturnSuccess;
}

IOReturn org_mklinux_iokit_swim3_driver::reportLockability(bool *isLockable)
{
    *isLockable=0;
    return kIOReturnSuccess;
}

IOReturn org_mklinux_iokit_swim3_driver::reportMaxReadTransfer(UInt64 blockSize,UInt64 *max)
{
    /* It's the same for floppies, so why screw with two functions? */
    return reportMaxWriteTransfer(blockSize, max);
}

IOReturn org_mklinux_iokit_swim3_driver::reportMaxValidBlock(UInt64 *maxBlock)
{
    struct BSStoreMPIInfo info;
#if 0
    BSStorePtr infoStore;
#endif
    OSStatus ret;

    ret=FloppyPluginGetInfo(NULL, &info);

    *maxBlock=info.storeSize / info.writeBlockSize;

    if (ret == E_BSSuccess)
        return kIOReturnSuccess;
    else
        return kIOReturnError;
}


IOReturn org_mklinux_iokit_swim3_driver::reportMaxWriteTransfer(UInt64 blockSize,UInt64 *max)
{

    *max=MAX_PHYS / blockSize;

    return kIOReturnSuccess;
}

IOReturn org_mklinux_iokit_swim3_driver::reportMediaState(bool *mediaPresent,bool *changedState)
{
    struct BSStoreMPIInfo info;
#if 0
    BSStorePtr infoStore;
#endif
    OSStatus ret;
    
    IOLog("Polling swim3\n");
    ScanForDisketteChange();
    ret=FloppyPluginGetInfo(NULL, &info);
    
    if (info.curState == kBSOnline)
        *mediaPresent = true;
    else
        *mediaPresent = false;

    if (media_present != *mediaPresent)
        *changedState = true;
    else
        *changedState = false;

    media_present = *mediaPresent;

    IOLog("mediaPresent = %s, changedState = %s\n",
        (*mediaPresent == true) ? "true" : "false",
        (*changedState == true) ? "true" : "false");

    if (ret == E_BSSuccess)
        return kIOReturnSuccess;
    else
        return kIOReturnError;
}

IOReturn org_mklinux_iokit_swim3_driver::reportPollRequirements(bool *pollRequired,
                    bool *pollIsExpensive)
{
/* @@@ Should this really be true?  I mean, we already have a polling
   thread.  Shouldn't we just notify upstream somehow?  Seems obvious,
   but it isn't obvious how to do it outside of the usual families
   (SCSI, ATA, etc.) @@@ */
*pollRequired=true;
*pollIsExpensive=false;
return kIOReturnSuccess;
}

IOReturn org_mklinux_iokit_swim3_driver::reportRemovability(bool *isRemovable)
{
*isRemovable=true;
return kIOReturnSuccess;
}

IOReturn org_mklinux_iokit_swim3_driver::reportWriteProtection(bool *isWriteProtected)
{
    struct BSStoreMPIInfo info;
#if 0
    BSStorePtr infoStore;
#endif
    OSStatus ret;

    ret=FloppyPluginGetInfo(NULL, &info);

    if (!info.isWriteable)
        *isWriteProtected = true;
    else
        *isWriteProtected = false;

    if (ret == E_BSSuccess)
        return kIOReturnSuccess;
    else
        return kIOReturnError;
}