static int dspi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
{
struct chip_data *chip;
struct fsl_dspi *dspi = spi_master_get_devdata(spi->master);
unsigned char br = 0, pbr = 0, fmsz = 0;
/* Only alloc on first setup */
chip = spi_get_ctldata(spi);
if (chip == NULL) {
chip = kcalloc(1, sizeof(struct chip_data), GFP_KERNEL);
if (!chip)
return -ENOMEM;
}
chip->mcr_val = SPI_MCR_MASTER | SPI_MCR_PCSIS |
SPI_MCR_CLR_TXF | SPI_MCR_CLR_RXF;
if ((spi->bits_per_word >= 4) && (spi->bits_per_word <= 16)) {
fmsz = spi->bits_per_word - 1;
} else {
pr_err("Invalid wordsize\n");
kfree(chip);
return -ENODEV;
}
chip->void_write_data = 0;
hz_to_spi_baud(&pbr, &br,
spi->max_speed_hz, clk_get_rate(dspi->clk));
chip->ctar_val = SPI_CTAR_FMSZ(fmsz)
| SPI_CTAR_CPOL(spi->mode & SPI_CPOL ? 1 : 0)
| SPI_CTAR_CPHA(spi->mode & SPI_CPHA ? 1 : 0)
| SPI_CTAR_LSBFE(spi->mode & SPI_LSB_FIRST ? 1 : 0)
| SPI_CTAR_PBR(pbr)
| SPI_CTAR_BR(br);
spi_set_ctldata(spi, chip);
return 0;
}
static int __init bfspi_init( void ) {
int status, ret;
int i, msz;
dev_t dev = 0;
struct bfspi_data *mbfspi;
int baud;
#if 1
wrcount = rdcount = 0;
baud = hz_to_spi_baud((u32)spibaud*1000);
if (baud <= 4)
baud = 48;
if (cardno < 0)
cardno = 0;
if (spimode > 3)
spimode = 0;
msz = sizeof( struct bfspi_data);
/* Allocate driver data */
for (i=0; i < MAX_BFSPI_CLIENT; i++) {
bfspi[i] = kzalloc(sizeof(struct bfspi_data), GFP_KERNEL);
if (!bfspi[i]) {
while (--i >= 0) {
kfree(bfspi[i]);
}
return -ENOMEM;
}
}
//BUILD_BUG_ON(N_BFSPI_MINORS > 256);
PRINTK("\nkern>> INIT: alloc bfspi device cardno: %d!, baud: %d, mode: %d\n", cardno, spibaud, spimode);
if ((ret = alloc_chrdev_region(&dev, 1, MAX_BFSPI_CLIENT, "bfspi")) < 0)
{
PRINTK("kern>> INIT: alloc bfspi device Failure to alloc chardev!\n");
return ret;
}
BFSPI_MAJOR = MAJOR(dev);
bfspi_class = class_create(THIS_MODULE, "bfspi");
if (IS_ERR(bfspi_class)) {
unregister_chrdev_region(dev, 1);
PRINTK("kern>> INIT: alloc bfspi device Failure to register chardev!\n");
return PTR_ERR(bfspi_class);
}
/* Initialize the driver data */
//bfspi->spi = spi;
//INIT_LIST_HEAD(&bfspi->device_entry);
/* If we can allocate a minor number, hook up this device.
* Reusing minors is fine so long as udev or mdev is working.
*/
mutex_lock(&device_list_lock);
for (i=0; i < MAX_BFSPI_CLIENT; i++) {
mbfspi = bfspi[i];
//minor = find_first_zero_bit(minors, N_BFSPI_MINORS);
//if (minor < N_BFSPI_MINORS) {
struct device *device;
spin_lock_init(&mbfspi->spi_lock);
mutex_init(&mbfspi->buf_lock);
cdev_init(&mbfspi->cdev, &bfspi_fops);
mbfspi->cdev.owner = THIS_MODULE;
mbfspi->cardno = cardno;
portno = mbfspi->portno = i+1;
mbfspi->devt = MKDEV(BFSPI_MAJOR, i+1);
cdev_add(&mbfspi->cdev, mbfspi->devt, 1);
device = device_create(bfspi_class, NULL, mbfspi->devt, NULL,
"bfspi%d.%d", cardno, portno);
status = IS_ERR(device) ? PTR_ERR(device) : 0;
if (status == 0)
PRINTK("kern>> init: allocate %d bfspi%d.%d Succses!\n", BFSPI_MAJOR, cardno, portno);
}
mutex_unlock(&device_list_lock);
#endif
//if (spibaud <= 0)
// spibaud = 10;
bfspi_hardware_init(baud, ((1 << SPI_NCSA) | (1 << SPI_NCSB)));
//bfspi_reset(RESET_BIT);
return status;
}
