static LONG bios_4(WORD r_w, UBYTE *adr, WORD numb, WORD first, WORD drive, LONG lfirst)
{
    LONG ret;
    KDEBUG(("BIOS rwabs(rw = %d, addr = 0x%08lx, count = 0x%04x, "
            "sect = 0x%04x, dev = 0x%04x, lsect = 0x%08lx)",
            r_w, adr, numb, first, drive, lfirst));
    ret = lrwabs(r_w, adr, numb, first, drive, lfirst);
    KDEBUG((" = 0x%08lx\n", ret));
    return ret;
}

/*
 *  xmgetmd - get an MD
 *
 *  To create a single pool for all osmem requests, MDs are grouped in
 *  blocks of 3 called MDBLOCKs which occupy 58 bytes.  MDBLOCKs are
 *  handled as follows:
 *    . they are linked in a chain, initially empty
 *    . when the first MD is required, an MDBLOCK is obtained via
 *      xmgetblk() and put on the chain, and the first slot is allocated
 *    . MDs are obtained from existing partially-used MDBLOCKS
 *    . when an MDBLOCK is full, it is removed from the chain
 *    . when an MD in a full MDBLOCK is freed, the MDBLOCK is put back
 *      on the chain
 *    . when the MDBLOCK is totally unused, it is put back on the normal
 *      free chain
 */
MD *xmgetmd(void)
{
    MDBLOCK *mdb = mdbroot;
    MD *md;
    WORD i, avail;

    if (!mdb)
    {
        mdb = MGET(MDBLOCK);
        if (!mdb)
            return NULL;

        /* initialise new MDBLOCK */
        mdb->mdb_next = NULL;
        for (i = 0; i < MDS_PER_BLOCK; i++)
            mdb->entry[i].index = -1;   /* unused */
        mdbroot = mdb;
        KDEBUG(("xmgetmd(): got new MDBLOCK at %p\n",mdb));
    }

    /*
     * allocate MD from MDBLOCK
     */
    for (i = 0, avail = 0, md = NULL; i < MDS_PER_BLOCK; i++)
    {
        if (mdb->entry[i].index < 0)
        {
            if (!md)                /* not yet allocated */
            {
                mdb->entry[i].index = i;
                md = &mdb->entry[i].md;
                KDEBUG(("xmgetmd(): got MD at %p\n",md));
            }
            else avail++;
        }
    }

    if (!md)
    {
        KDEBUG(("xmgetmd(): MDBLOCK at %p is invalid, no free entries\n",mdb));
        return NULL;
    }

    /*
     * remove full MDBLOCK from mdb chain
     */
    if (avail == 0)
    {
        KDEBUG(("xmgetmd(): MDBLOCK at %p is now full\n",mdb));
        if (unlink_mdblock(mdb) == 0)
            KDEBUG(("xmgetmd(): removed MDBLOCK at %p from mdb chain\n",mdb));
    }

    return md;
}

static void run_auto_program(const char* filename)
{
    char path[30];

    strcpy(path, "\\AUTO\\");
    strcat(path, filename);

    KDEBUG(("Loading %s ...\n", path));
    trap1_pexec(PE_LOADGO, path, "", default_env);  /* Pexec */
    KDEBUG(("[OK]\n"));
}

void Line::mousePressEvent(QMouseEvent *e)
{
#if 0
  int x, y;
#endif
  QPainter paint;

  KDEBUG(KDEBUG_INFO, 3000, "RubberLine::mousePressEvent() handler called\n");

  if (isActive()) {
    if (drawing) {
      KDEBUG(KDEBUG_INFO, 3000, "Line: Warning button press received while drawing\n");
    }
    else {
      startx= (e->pos()).x();
      starty= (e->pos()).y();
      activeButton= e->button();
      lastx= startx;
      lasty= starty;
      drawing= TRUE;
    }
  }

#if 0
  // This code used to allow multi segment lines (badly)
  // It is being replaced by a seperate polyline tool.
  else if (isActive() && (e->button() == RightButton) && drawing) {
    x= (e->pos()).x();
    y= (e->pos()).y();

    // Erase old line
    paint.begin(canvas->zoomedPixmap());
    paint.setPen(leftpen);
    paint.setRasterOp(XorROP);
    paint.drawLine(startx, starty, lastx, lasty);
    paint.setRasterOp(CopyROP);
    // Draw new line
    paint.drawLine(startx, starty, lastx, lasty);
    paint.end();

    startx= x;
    starty= y;
    lastx= startx;
    lasty= starty;
  }

  canvas->repaint(0);
#endif
  
  if (!isActive()) {
KDEBUG(KDEBUG_WARN, 3000, "Line: Warning event received when inactive (ignoring)\n");
  }
}

static int download_client_probe(struct platform_device *pdev)
{
	int ret = -1;
	struct download_client *download_client_data;
	struct m4sensorhub_data *m4sensorhub = m4sensorhub_client_get_drvdata();

	if (!m4sensorhub) {
		printk(KERN_WARNING "m4sensorhub is null\n");
		return -EFAULT;
	}

	download_client_data =
		kzalloc(sizeof(*download_client_data), GFP_KERNEL);
	if (!download_client_data)
		return -ENOMEM;

	download_client_data->m4sensorhub = m4sensorhub;
	platform_set_drvdata(pdev, download_client_data);

	ret = misc_register(&download_client_miscdrv);
	if (ret < 0) {
		KDEBUG(M4SH_ERROR, "Error registering %s driver\n",
				 DOWNLOAD_CLIENT_DRIVER_NAME);
		goto free_memory;
	}
	misc_download_data = download_client_data;
	ret = m4sensorhub_register_initcall(download_driver_init,
						download_client_data);
	if (ret < 0) {
		KDEBUG(M4SH_ERROR, "Unable to register init function "
			"for download client = %d\n", ret);
		goto unregister_misc_device;
	}
	init_waitqueue_head(&download_wq);
	atomic_set(&m4_dlcmd_resp_ready, false);
	atomic_set(&download_client_entry, 0);

	KDEBUG(M4SH_INFO, "Initialized %s driver\n",
		DOWNLOAD_CLIENT_DRIVER_NAME);
	return 0;

unregister_misc_device:
	misc_download_data = NULL;
	misc_deregister(&download_client_miscdrv);
free_memory:
	platform_set_drvdata(pdev, NULL);
	download_client_data->m4sensorhub = NULL;
	kfree(download_client_data);
	download_client_data = NULL;
	return ret;
}

void Pen::mousePressEvent(QMouseEvent *e)
{
  int x,y;
  QPainter painter1;
  QPainter painter2;
  QWMatrix m;

  KDEBUG(KDEBUG_INFO, 3000, "Pen::mousePressEvent() handler called\n");
  
  if (isActive()) {
    if (drawing) {
      KDEBUG(KDEBUG_INFO, 3000, "Pen: Warning button press received while drawing\n");
    }
    x= (e->pos()).x();
    y= (e->pos()).y();
    activeButton= e->button();

    m.scale((float) 100/(canvas->zoom()), (float) 100/(canvas->zoom()));

    painter1.begin(canvas->pixmap());

    if (activeButton == LeftButton)
      painter1.setPen(leftpen);
    else
      painter1.setPen(rightpen);
    painter1.setWorldMatrix(m);

    painter2.begin(canvas->zoomedPixmap());

    if (activeButton == LeftButton)
      painter2.setPen(leftpen);
    else
      painter2.setPen(rightpen);

    painter1.drawPoint(x, y);
    painter2.drawPoint(x, y);

    painter1.end();
    painter2.end();

    canvas->repaint(0);
    lastx= x;
    lasty= y;
    drawing= TRUE;
  } 
  if (!isActive()) {
    KDEBUG(KDEBUG_WARN, 3000, "Warning event received when inactive (ignoring)\n");
  }
}

/*
 * wait for access to IDE registers
 */
static int wait_for_not_BSY(volatile struct IDE *interface,LONG timeout)
{
    LONG next = hz_200 + timeout;

    KDEBUG(("wait_for_not_BSY(0x%08lx, %ld)\n", (ULONG)interface, timeout));

    DELAY_400NS;
    while(hz_200 < next) {
        if ((IDE_READ_ALT_STATUS() & IDE_STATUS_BSY) == 0)
            return 0;
    }

    KDEBUG(("Timeout in wait_for_not_BSY(%p,%ld)\n",interface,timeout));
    return 1;
}

static int display_client_open(struct inode *inode, struct file *file)
{
	int ret = -EFAULT;
	KDEBUG(M4SH_DEBUG, "%s:\n", __func__);
	if (global_display_data) {
		ret = nonseekable_open(inode, file);
		if (ret >= 0) {
			file->private_data = global_display_data;
			ret = 0;
		}
	}
	if (ret)
		KDEBUG(M4SH_ERROR, "%s: failed, err=%d\n", __func__, -ret);
	return ret;
}

static int download_client_close(struct inode *inode, struct file *file)
{
	int entry = atomic_dec_return(&download_client_entry);
	file->private_data = NULL;
	KDEBUG(M4SH_DEBUG, "%s: entry = %d\n", __func__, entry);
	return 0;
}

static int ach_ch_open(struct inode *inode, struct file *file)
{
    int ret = 0;
    struct ach_ch_device *device;

    /* Synchronize to protect refcounting */
    if (rt_mutex_lock_interruptible(&ctrl_data.lock)) {
        ret = -ERESTARTSYS;
        goto out;
    }

    device = &ctrl_data.devices[iminor(inode)];

    if (unlikely(device->minor != iminor(inode))) {
        printk(KERN_ERR "ach: Internal data problem\n");
        ret = -ERESTARTSYS;
        goto out_unlock;
    }

    file->private_data = ach_ch_file_alloc(device);

    if (!file->private_data) {
        printk(KERN_ERR "ach: Failed allocating file data\n");
        ret = -ENOBUFS;
        goto out_unlock;
    }

    KDEBUG( "ach: opened device %s\n", ach_ch_device_name(device) );

out_unlock:
    rt_mutex_unlock(&ctrl_data.lock);
out:
    return ret;
}

void net_habitue_device_SC101::prepareAndDoAsyncReadWrite(OSData *addr, IOMemoryDescriptor *buffer, UInt32 block, UInt32 nblks, IOStorageCompletion completion)
{
  bool isWrite = (buffer->getDirection() == kIODirectionOut);
  const OSSymbol *ioMaxKey = (isWrite ? gSC101DeviceIOMaxWriteSizeKey : gSC101DeviceIOMaxReadSizeKey);
  UInt64 ioMaxSize = OSDynamicCast(OSNumber, getProperty(ioMaxKey))->unsigned64BitValue();
  UInt64 ioSize = (nblks * SECTOR_SIZE);
  
#if WRITEPROTECT
  if (isWrite)
    panic();
#endif

  if (ioSize > ioMaxSize || ioSize & (ioSize - 1))
  {
    KDEBUG("%s size=%llu, deblocking", (isWrite ? "write" : "read"), ioSize);
    deblock(addr, buffer, block, nblks, completion);
    return;
  }
  
  outstanding_io *io = IONewZero(outstanding_io, 1);
  io->addr = addr;
  io->buffer = buffer;
  io->block = block;
  io->nblks = nblks;
  io->completion = completion;
  io->attempt = 0;
  io->timeout_ms = getNextTimeoutMS(io->attempt, isWrite);
  
  io->addr->retain();
  
  getWorkLoop()->runAction(OSMemberFunctionCast(Action, this, &net_habitue_device_SC101::submitIO), this, io);
}

static int m4pas_driver_init(struct init_calldata *p_arg)
{
	struct iio_dev *iio = p_arg->p_data;
	struct m4pas_driver_data *dd = iio_priv(iio);
	int err = 0;

	mutex_lock(&(dd->mutex));

	dd->m4 = p_arg->p_m4sensorhub_data;
	if (dd->m4 == NULL) {
		m4pas_err("%s: M4 sensor data is NULL.\n", __func__);
		err = -ENODATA;
		goto m4pas_driver_init_fail;
	}

	err = m4sensorhub_irq_register(dd->m4,
		M4SH_IRQ_PASSIVE_BUFFER_FULL, m4pas_isr, iio, 1);
	if (err < 0) {
		m4pas_err("%s: Failed to register M4 IRQ.\n", __func__);
		goto m4pas_driver_init_fail;
	}

	err = m4sensorhub_panic_register(dd->m4, PANICHDL_PASSIVE_RESTORE,
					 m4pas_panic_restore, dd);
	if (err < 0)
		KDEBUG(M4SH_ERROR, "Passive panic callback register failed\n");
	goto m4pas_driver_init_exit;

m4pas_driver_init_fail:
	m4pas_err("%s: Init failed with error code %d.\n", __func__, err);
m4pas_driver_init_exit:
	mutex_unlock(&(dd->mutex));
	return err;
}

/* Sync M4 clock with current kernel time */
static int m4_display_sync_clock(void)
{
	int retry = 0;
	do {
		u32 m4_time = m4_display_get_clock();
		u32 kernel_time = m4_display_get_kernel_clock();
		u32 diff_time = m4_time > kernel_time \
			? m4_time-kernel_time : kernel_time-m4_time;
#ifdef	DEBUG_CLOCK
		print_time("M4 :", m4_time);
		print_time("KNL:", kernel_time);
#endif
		/* it needs adjust M4 time if different large than 1 second */
		if (diff_time < 2) {
			if (retry) {
				print_time("Synced M4 clock to", m4_time);
				m4_notify_clock_change();
			}
			return 0;
		}
		m4_display_set_clock(kernel_time);
	} while (retry++ < SYNC_CLOCK_RETRY_TIMES);
	KDEBUG(M4SH_ERROR, "%s: Failed to sync M4 clock!\n",  __func__);
	return -EIO;
}

// uiAddr = addr
static int do_spi_erase(unsigned int  addr, unsigned int uiChip)
{
	unsigned int uiRet;
	uiRet = spi_flash_info[uiChip].pfErase(uiChip, addr);
	KDEBUG("do_spi_erase: addr=%x;\n", addr);
	return 0;
}

// uiAddr = from; pucBuffer = to; uiLen = size
static unsigned int do_spi_read(unsigned int from, unsigned int to, unsigned int size, unsigned int uiChip)
{
	unsigned int uiRet;
	uiRet = spi_flash_info[uiChip].pfRead(uiChip, from, size, (unsigned char*)to);
	KDEBUG("do_spi_read: from=%x; to=%x; size=%x; uiRet=%x\n", from, to, size, uiRet);
	return 0;
}

void ns_net_rx(struct sk_buff *skb, struct net_device *dev)
{
   struct nano_pci_card *card = (struct nano_pci_card *)dev;

   if(down_interruptible(&card->sem)) {
      kfree_skb(skb);
      return;
   }

   if(skb_queue_len(&card->rx_queue)>300) {
      up(&card->sem);
      KDEBUG(ERROR, "more then 300 pkt's in rx queue; dropping frame of size %d",skb->len);
      kfree_skb(skb);
      return;
   }

   if(!test_bit(DEVST_OPEN, &card->devst)) {
      kfree_skb(skb);
      up(&card->sem);
      return;
   }

   skb_queue_tail(&card->rx_queue, skb);
   up(&card->sem);
   card->status.irq_count++;
   wake_up_interruptible(&card->rx_waitqueue);
   return;
}

// SPI Flash Erase Block
unsigned int spi_block_erase(unsigned int uiChip, unsigned int uiAddr)
{
	KDEBUG("spi_block_erase: uiChip=%x; uiAddr=%x\n", uiChip, uiAddr);
	unsigned int uiRet;
	uiRet = ComSrlCmd_BE(uiChip, uiAddr);
	return uiRet;
}

// Chip Erase (CE) Sequence (Command 60 or C7)
unsigned int ComSrlCmd_CE(unsigned char ucChip)
{
	SeqCmd_Order(ucChip,  IOWIDTH_SINGLE, SPICMD_WREN);
	SeqCmd_Order(ucChip,  IOWIDTH_SINGLE, SPICMD_CE);	
	KDEBUG("ComSrlCmd_CE: ucChip=%x; SPICMD_CE=%x\n", ucChip, SPICMD_CE);
	return spiFlashReady(ucChip);
}

// Block Erase (BE) Sequence (Command D8)
unsigned int ComSrlCmd_BE(unsigned char ucChip, unsigned int uiAddr)
{
	SeqCmd_Order(ucChip,  IOWIDTH_SINGLE, SPICMD_WREN);
	SeqCmd_Write(ucChip,  IOWIDTH_SINGLE, SPICMD_BE, uiAddr, 3);	
	KDEBUG("ComSrlCmd_BE: ucChip=%x; uiBlock=%x; uiBlockSize=%x; SPICMD_BE=%x\n", ucChip, uiAddr, spi_flash_info[ucChip].block_size, SPICMD_BE);
	return spiFlashReady(ucChip);
}

// Sector Erase (SE) Sequence (Command 20)
unsigned int ComSrlCmd_SE(unsigned char ucChip, unsigned int uiAddr)
{
	SeqCmd_Order(ucChip,  IOWIDTH_SINGLE, SPICMD_WREN);
	SeqCmd_Write(ucChip,  IOWIDTH_SINGLE, SPICMD_SE, uiAddr, 3);
	KDEBUG("ComSrlCmd_SE: ucChip=%x; uiSector=%x; uiSectorSize=%x; SPICMD_SE=%x\n", ucChip, uiAddr, spi_flash_info[ucChip].sector_size, SPICMD_SE);	
	return spiFlashReady(ucChip);
}