C++ DEB2函数代码示例

static void handle_lab(struct i2c_algo_pcf_data *adap, const int *status)
{
	DEB2(printk(KERN_INFO
		"i2c-algo-pcf.o: lost arbitration (CSR 0x%02x)\n",
		 *status));

	/* Cleanup from LAB -- reset and enable ESO.
	 * This resets the PCF8584; since we've lost the bus, no
	 * further attempts should be made by callers to clean up
	 * (no i2c_stop() etc.)
	 */
	set_pcf(adap, 1, I2C_PCF_PIN);
	set_pcf(adap, 1, I2C_PCF_ESO);

	/* We pause for a time period sufficient for any running
	 * I2C transaction to complete -- the arbitration logic won't
	 * work properly until the next START is seen.
	 * It is assumed the bus driver or client has set a proper value.
	 *
	 * REVISIT: should probably use msleep instead of mdelay if we
	 * know we can sleep.
	 */
	if (adap->lab_mdelay)
		mdelay(adap->lab_mdelay);

	DEB2(printk(KERN_INFO
		"i2c-algo-pcf.o: reset LAB condition (CSR 0x%02x)\n",
		get_pcf(adap, 1)));
}

static void handle_lab(struct i2c_algo_pcf_data *adap, const int *status)
{
	DEB2(printk(KERN_INFO
		"i2c-algo-pcf.o: lost arbitration (CSR 0x%02x)\n",
		*status));
	/*
                                             
                                                         
                                                          
                        
  */
	set_pcf(adap, 1, I2C_PCF_PIN);
	set_pcf(adap, 1, I2C_PCF_ESO);
	/*
                                                         
                                                              
                                               
                                                                  
   
                                                               
                      
  */
	if (adap->lab_mdelay)
		mdelay(adap->lab_mdelay);

	DEB2(printk(KERN_INFO
		"i2c-algo-pcf.o: reset LAB condition (CSR 0x%02x)\n",
		get_pcf(adap, 1)));
}

/* Called when the module is loaded.  This function starts the
 * cascade of calls up through the heirarchy of i2c modules (i.e. up to the
 *  algorithm layer and into to the core layer)
 */
static int __init iic_avalanche_init(void)
{

	struct iic_avalanche *piic = &iic_avalanche_priv_data;

	DEB2(printk(KERN_INFO "Initialize Avalanche IIC adapter module\n"));




        iic_avalanche_priv_data.iic_clock = avalanche_get_vbus_freq(); /* Clock frequency on the peripheral bus */ 

	iic_avalanche_data.data = (void *)piic;
	init_waitqueue_head(&iic_wait);
	if (iic_hw_resrc_init() == 0) {

                DEB2(printk("calling add bus\n"));

		if (i2c_avalanche_add_bus(&iic_avalanche_ops) < 0)
			return -ENODEV;
	} else {
		return -ENODEV;
	}
	DEB2(printk(KERN_INFO " found device at %#x irq %d.\n",
		piic->iic_base, piic->iic_irq));
	return 0;
}

/*
 * This should perform the 'PCF8584 initialization sequence' as described
 * in the Philips IC12 data book (1995, Aug 29).
 * There should be a 30 clock cycle wait after reset, I assume this
 * has been fulfilled.
 * There should be a delay at the end equal to the longest I2C message
 * to synchronize the BB-bit (in multimaster systems). How long is
 * this? I assume 1 second is always long enough.
 *
 * vdovikin: added detect code for PCF8584
 */
static int pcf_init_8584 (struct i2c_algo_pcf_data *adap)
{
	unsigned char temp;

	DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: PCF state 0x%02x\n",
				get_pcf(adap, 1)));

	/* S1=0x80: S0 selected, serial interface off */
	set_pcf(adap, 1, I2C_PCF_PIN);
	/*
	 * check to see S1 now used as R/W ctrl -
	 * PCF8584 does that when ESO is zero
	 */
	if (((temp = get_pcf(adap, 1)) & 0x7f) != (0)) {
		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S0 (0x%02x).\n", temp));
		return -ENXIO; /* definitely not PCF8584 */
	}

	/* load own address in S0, effective address is (own << 1) */
	i2c_outb(adap, get_own(adap));
	/* check it's really written */
	if ((temp = i2c_inb(adap)) != get_own(adap)) {
		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't set S0 (0x%02x).\n", temp));
		return -ENXIO;
	}

	/* S1=0xA0, next byte in S2 */
	set_pcf(adap, 1, I2C_PCF_PIN | I2C_PCF_ES1);
	/* check to see S2 now selected */
	if (((temp = get_pcf(adap, 1)) & 0x7f) != I2C_PCF_ES1) {
		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S2 (0x%02x).\n", temp));
		return -ENXIO;
	}

	/* load clock register S2 */
	i2c_outb(adap, get_clock(adap));
	/* check it's really written, the only 5 lowest bits does matter */
	if (((temp = i2c_inb(adap)) & 0x1f) != get_clock(adap)) {
		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't set S2 (0x%02x).\n", temp));
		return -ENXIO;
	}

	/* Enable serial interface, idle, S0 selected */
	set_pcf(adap, 1, I2C_PCF_IDLE);

	/* check to see PCF is really idled and we can access status register */
	if ((temp = get_pcf(adap, 1)) != (I2C_PCF_PIN | I2C_PCF_BB)) {
		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S1` (0x%02x).\n", temp));
		return -ENXIO;
	}

	printk(KERN_DEBUG "i2c-algo-pcf.o: detected and initialized PCF8584.\n");

	return 0;
}

static int pcf_init_8584 (struct i2c_algo_pcf_data *adap)
{
	unsigned char temp;

	DEB3(printk(KERN_DEBUG "i2c-algo-pcf.o: PCF state 0x%02x\n",
				get_pcf(adap, 1)));

	/*                                            */
	set_pcf(adap, 1, I2C_PCF_PIN);
	/*
                                          
                                      
  */
	if (((temp = get_pcf(adap, 1)) & 0x7f) != (0)) {
		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S0 (0x%02x).\n", temp));
		return -ENXIO; /*                        */
	}

	/*                                                         */
	i2c_outb(adap, get_own(adap));
	/*                           */
	if ((temp = i2c_inb(adap)) != get_own(adap)) {
		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't set S0 (0x%02x).\n", temp));
		return -ENXIO;
	}

	/*                          */
	set_pcf(adap, 1, I2C_PCF_PIN | I2C_PCF_ES1);
	/*                              */
	if (((temp = get_pcf(adap, 1)) & 0x7f) != I2C_PCF_ES1) {
		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S2 (0x%02x).\n", temp));
		return -ENXIO;
	}

	/*                        */
	i2c_outb(adap, get_clock(adap));
	/*                                                               */
	if (((temp = i2c_inb(adap)) & 0x1f) != get_clock(adap)) {
		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't set S2 (0x%02x).\n", temp));
		return -ENXIO;
	}

	/*                                            */
	set_pcf(adap, 1, I2C_PCF_IDLE);

	/*                                                                    */
	if ((temp = get_pcf(adap, 1)) != (I2C_PCF_PIN | I2C_PCF_BB)) {
		DEB2(printk(KERN_ERR "i2c-algo-pcf.o: PCF detection failed -- can't select S1` (0x%02x).\n", temp));
		return -ENXIO;
	}

	printk(KERN_DEBUG "i2c-algo-pcf.o: detected and initialized PCF8584.\n");

	return 0;
}

static int
mlib_read_mthd (mlib_desc * desc)
{
  char sig[5];
  unsigned char hi, lo;
  int len;

  if (!mlib_chkdesc (desc))
    return 0;

  if (!mlib_rdstr (desc, sig, 4))
    return 0;

  if (strcmp (sig, "MThd"))
    {
      mlib_seterr ("Invalid header signature (!= MThd)");
      return 0;
    }

  if (mlib_rdint32 (desc, &len))

    if (mlib_rdint16 (desc, &desc->hdr.MThd_fmt))
      DEB2 (printf ("Header: Format %d\n", desc->hdr.MThd_fmt));

  if (mlib_rdint16 (desc, &desc->hdr.MThd_ntrk))
    DEB2 (printf ("Header: ntrks %d\n", desc->hdr.MThd_ntrk));

  if (mlib_rdbyte (desc, &hi))
    if (mlib_rdbyte (desc, &lo))

      if (hi & 0x80)		/* Negative */
	{
	  DEB2 (printf ("SMPTE timing: format = %d, resolution = %d\n",
			(char) hi, lo));
	  desc->hdr.time_mode = TIME_SMPTE;
	  desc->hdr.SMPTE_format = (char) hi;
	  desc->hdr.SMPTE_resolution = lo;
	}
      else
	{
	  desc->hdr.time_mode = TIME_MIDI;
	  desc->hdr.division = (hi << 8) + lo;
	  DEB2 (printf ("Midi timing: timebase = %d ppqn\n",
			desc->hdr.division));
	}

  desc->curr_trk = -1;
  desc->trk_offs = 0;
  desc->next_trk_offs = 4 + 4 + len;;

  return mlib_seek (desc, desc->trk_offs);	/* Point to the first track */
}

//
// Description: The registered interrupt handler
//
static void iic_ibmocp_handler(int this_irq, void *dev_id, struct pt_regs *regs) 
{
   int ret;
   struct iic_regs *iic;
   struct iic_ibm *priv_data = dev_id;
   iic = (struct iic_regs *) priv_data->iic_base;
   iic_pending = 1;
   DEB2(printk("iic_ibmocp_handler: in interrupt handler\n"));
   // Read status register
   ret = readb((int) &(iic->sts));
   DEB2(printk("iic_ibmocp_handler: status = %x\n", ret));
   // Clear status register.  See IBM PPC 405 reference manual for details
   writeb(0x0a, (int) &(iic->sts));
   wake_up_interruptible(&(iic_wait[priv_data->index]));
}

static int pcf_sendbytes(struct i2c_adapter *i2c_adap, const char *buf,
			 int count, int last)
{
	struct i2c_algo_pcf_data *adap = i2c_adap->algo_data;
	int wrcount, status, timeout;

	for (wrcount=0; wrcount<count; ++wrcount) {
		DEB2(dev_dbg(&i2c_adap->dev, "i2c_write: writing %2.2X\n",
				buf[wrcount] & 0xff));
		i2c_outb(adap, buf[wrcount]);
		timeout = wait_for_pin(adap, &status);
		if (timeout) {
			if (timeout == -EINTR)
				return -EINTR; /* arbitration lost */

			i2c_stop(adap);
			dev_err(&i2c_adap->dev, "i2c_write: error - timeout.\n");
			return -EREMOTEIO; /* got a better one ?? */
		}
		if (status & I2C_PCF_LRB) {
			i2c_stop(adap);
			dev_err(&i2c_adap->dev, "i2c_write: error - no ack.\n");
			return -EREMOTEIO; /* got a better one ?? */
		}
	}
	if (last)
		i2c_stop(adap);
	else
		i2c_repstart(adap);

	return wrcount;
}

static void iic_avalanche_handler(int this_irq, void *dev_id, struct pt_regs *regs)
{

   iic_pending = 1;

   DEB2(printk("iic_avalanche_handler: in interrupt handler\n"));
   wake_up_interruptible(&iic_wait);
}

static void pca_stop(struct i2c_algo_pca_data *adap)
{
	int sta = pca_get_con(adap);
	DEB2("=== STOP\n");
	sta |= I2C_PCA_CON_STO;
	sta &= ~(I2C_PCA_CON_STA|I2C_PCA_CON_SI);
	pca_set_con(adap, sta);
}

static int pca_repeated_start(struct i2c_algo_pca_data *adap)
{
	int sta = pca_get_con(adap);
	DEB2("=== REPEATED START\n");
	sta |= I2C_PCA_CON_STA;
	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI);
	pca_set_con(adap, sta);
	return pca_wait(adap);
}

/*
 * Generate a start condition on the i2c bus.
 *
 * returns after the start condition has occured
 */
static void pca_start(struct i2c_algo_pca_data *adap)
{
	int sta = pca_get_con(adap);
	DEB2("=== START\n");
	sta |= I2C_PCA_CON_STA;
	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_SI);
	pca_set_con(adap, sta);
	pca_wait(adap);
}

static int pca_tx_byte(struct i2c_algo_pca_data *adap,
		       __u8 b)
{
	int sta = pca_get_con(adap);
	DEB2("=== WRITE %#04x\n", b);
	pca_outw(adap, I2C_PCA_DAT, b);

	sta &= ~(I2C_PCA_CON_STO|I2C_PCA_CON_STA|I2C_PCA_CON_SI);
	pca_set_con(adap, sta);

	return pca_wait(adap);
}

static int wait_for_pin(struct i2c_algo_pcf_data *adap, int *status) {

    int timeout = DEF_TIMEOUT;

    *status = get_pcf(adap, 1);
#ifndef STUB_I2C
    while (timeout-- && (*status & I2C_PCF_PIN)) {
        adap->waitforpin();
        *status = get_pcf(adap, 1);
    }
    if (*status & I2C_PCF_LAB) {
        DEB2(printk(KERN_INFO 
            "i2c-algo-pcf.o: lost arbitration (CSR 0x%02x)\n",
             *status));
        /* Cleanup from LAB-- reset and enable ESO.
         * This resets the PCF8584; since we've lost the bus, no
         * further attempts should be made by callers to clean up 
         * (no i2c_stop() etc.)
         */
        set_pcf(adap, 1, I2C_PCF_PIN);
        set_pcf(adap, 1, I2C_PCF_ESO);
        /* TODO: we should pause for a time period sufficient for any
         * running I2C transaction to complete-- the arbitration
         * logic won't work properly until the next START is seen.
         */
        DEB2(printk(KERN_INFO 
            "i2c-algo-pcf.o: reset LAB condition (CSR 0x%02x)\n", 
            get_pcf(adap,1)));
        return(-EINTR);
    }
#endif
    if (timeout <= 0)
        return(-1);
    else
        return(0);
}

/*
 * registering functions to load algorithms at runtime
 */
int i2c_pcf_add_bus(struct i2c_adapter *adap)
{
	struct i2c_algo_pcf_data *pcf_adap = adap->algo_data;
	int rval;

	DEB2(dev_dbg(&adap->dev, "hw routines registered.\n"));

	/* register new adapter to i2c module... */
	adap->algo = &pcf_algo;

	if ((rval = pcf_init_8584(pcf_adap)))
		return rval;

	rval = i2c_add_adapter(adap);

	return rval;
}