1/*
   2 * Driver for Alauda-based card readers
   3 *
   4 * Current development and maintenance by:
   5 *   (c) 2005 Daniel Drake <dsd@gentoo.org>
   6 *
   7 * The 'Alauda' is a chip manufacturered by RATOC for OEM use.
   8 *
   9 * Alauda implements a vendor-specific command set to access two media reader
  10 * ports (XD, SmartMedia). This driver converts SCSI commands to the commands
  11 * which are accepted by these devices.
  12 *
  13 * The driver was developed through reverse-engineering, with the help of the
  14 * sddr09 driver which has many similarities, and with some help from the
  15 * (very old) vendor-supplied GPL sma03 driver.
  16 *
  17 * For protocol info, see http://alauda.sourceforge.net
  18 *
  19 * This program is free software; you can redistribute it and/or modify it
  20 * under the terms of the GNU General Public License as published by the
  21 * Free Software Foundation; either version 2, or (at your option) any
  22 * later version.
  23 *
  24 * This program is distributed in the hope that it will be useful, but
  25 * WITHOUT ANY WARRANTY; without even the implied warranty of
  26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27 * General Public License for more details.
  28 *
  29 * You should have received a copy of the GNU General Public License along
  30 * with this program; if not, write to the Free Software Foundation, Inc.,
  31 * 675 Mass Ave, Cambridge, MA 02139, USA.
  32 */
  33
  34#include <linux/module.h>
  35#include <linux/slab.h>
  36
  37#include <scsi/scsi.h>
  38#include <scsi/scsi_cmnd.h>
  39#include <scsi/scsi_device.h>
  40
  41#include "usb.h"
  42#include "transport.h"
  43#include "protocol.h"
  44#include "debug.h"
  45#include "scsiglue.h"
  46
  47#define DRV_NAME "ums-alauda"
  48
  49MODULE_DESCRIPTION("Driver for Alauda-based card readers");
  50MODULE_AUTHOR("Daniel Drake <dsd@gentoo.org>");
  51MODULE_LICENSE("GPL");
  52
  53/*
  54 * Status bytes
  55 */
  56#define ALAUDA_STATUS_ERROR		0x01
  57#define ALAUDA_STATUS_READY		0x40
  58
  59/*
  60 * Control opcodes (for request field)
  61 */
  62#define ALAUDA_GET_XD_MEDIA_STATUS	0x08
  63#define ALAUDA_GET_SM_MEDIA_STATUS	0x98
  64#define ALAUDA_ACK_XD_MEDIA_CHANGE	0x0a
  65#define ALAUDA_ACK_SM_MEDIA_CHANGE	0x9a
  66#define ALAUDA_GET_XD_MEDIA_SIG		0x86
  67#define ALAUDA_GET_SM_MEDIA_SIG		0x96
  68
  69/*
  70 * Bulk command identity (byte 0)
  71 */
  72#define ALAUDA_BULK_CMD			0x40
  73
  74/*
  75 * Bulk opcodes (byte 1)
  76 */
  77#define ALAUDA_BULK_GET_REDU_DATA	0x85
  78#define ALAUDA_BULK_READ_BLOCK		0x94
  79#define ALAUDA_BULK_ERASE_BLOCK		0xa3
  80#define ALAUDA_BULK_WRITE_BLOCK		0xb4
  81#define ALAUDA_BULK_GET_STATUS2		0xb7
  82#define ALAUDA_BULK_RESET_MEDIA		0xe0
  83
  84/*
  85 * Port to operate on (byte 8)
  86 */
  87#define ALAUDA_PORT_XD			0x00
  88#define ALAUDA_PORT_SM			0x01
  89
  90/*
  91 * LBA and PBA are unsigned ints. Special values.
  92 */
  93#define UNDEF    0xffff
  94#define SPARE    0xfffe
  95#define UNUSABLE 0xfffd
  96
  97struct alauda_media_info {
  98	unsigned long capacity;		/* total media size in bytes */
  99	unsigned int pagesize;		/* page size in bytes */
 100	unsigned int blocksize;		/* number of pages per block */
 101	unsigned int uzonesize;		/* number of usable blocks per zone */
 102	unsigned int zonesize;		/* number of blocks per zone */
 103	unsigned int blockmask;		/* mask to get page from address */
 104
 105	unsigned char pageshift;
 106	unsigned char blockshift;
 107	unsigned char zoneshift;
 108
 109	u16 **lba_to_pba;		/* logical to physical block map */
 110	u16 **pba_to_lba;		/* physical to logical block map */
 111};
 112
 113struct alauda_info {
 114	struct alauda_media_info port[2];
 115	int wr_ep;			/* endpoint to write data out of */
 116
 117	unsigned char sense_key;
 118	unsigned long sense_asc;	/* additional sense code */
 119	unsigned long sense_ascq;	/* additional sense code qualifier */
 120};
 121
 122#define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) )
 123#define LSB_of(s) ((s)&0xFF)
 124#define MSB_of(s) ((s)>>8)
 125
 126#define MEDIA_PORT(us) us->srb->device->lun
 127#define MEDIA_INFO(us) ((struct alauda_info *)us->extra)->port[MEDIA_PORT(us)]
 128
 129#define PBA_LO(pba) ((pba & 0xF) << 5)
 130#define PBA_HI(pba) (pba >> 3)
 131#define PBA_ZONE(pba) (pba >> 11)
 132
 133static int init_alauda(struct us_data *us);
 134
 135
 136/*
 137 * The table of devices
 138 */
 139#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
 140		    vendorName, productName, useProtocol, useTransport, \
 141		    initFunction, flags) \
 142{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
 143  .driver_info = (flags) }
 144
 145static struct usb_device_id alauda_usb_ids[] = {
 146#	include "unusual_alauda.h"
 147	{ }		/* Terminating entry */
 148};
 149MODULE_DEVICE_TABLE(usb, alauda_usb_ids);
 150
 151#undef UNUSUAL_DEV
 152
 153/*
 154 * The flags table
 155 */
 156#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
 157		    vendor_name, product_name, use_protocol, use_transport, \
 158		    init_function, Flags) \
 159{ \
 160	.vendorName = vendor_name,	\
 161	.productName = product_name,	\
 162	.useProtocol = use_protocol,	\
 163	.useTransport = use_transport,	\
 164	.initFunction = init_function,	\
 165}
 166
 167static struct us_unusual_dev alauda_unusual_dev_list[] = {
 168#	include "unusual_alauda.h"
 169	{ }		/* Terminating entry */
 170};
 171
 172#undef UNUSUAL_DEV
 173
 174
 175/*
 176 * Media handling
 177 */
 178
 179struct alauda_card_info {
 180	unsigned char id;		/* id byte */
 181	unsigned char chipshift;	/* 1<<cs bytes total capacity */
 182	unsigned char pageshift;	/* 1<<ps bytes in a page */
 183	unsigned char blockshift;	/* 1<<bs pages per block */
 184	unsigned char zoneshift;	/* 1<<zs blocks per zone */
 185};
 186
 187static struct alauda_card_info alauda_card_ids[] = {
 188	/* NAND flash */
 189	{ 0x6e, 20, 8, 4, 8},	/* 1 MB */
 190	{ 0xe8, 20, 8, 4, 8},	/* 1 MB */
 191	{ 0xec, 20, 8, 4, 8},	/* 1 MB */
 192	{ 0x64, 21, 8, 4, 9}, 	/* 2 MB */
 193	{ 0xea, 21, 8, 4, 9},	/* 2 MB */
 194	{ 0x6b, 22, 9, 4, 9},	/* 4 MB */
 195	{ 0xe3, 22, 9, 4, 9},	/* 4 MB */
 196	{ 0xe5, 22, 9, 4, 9},	/* 4 MB */
 197	{ 0xe6, 23, 9, 4, 10},	/* 8 MB */
 198	{ 0x73, 24, 9, 5, 10},	/* 16 MB */
 199	{ 0x75, 25, 9, 5, 10},	/* 32 MB */
 200	{ 0x76, 26, 9, 5, 10},	/* 64 MB */
 201	{ 0x79, 27, 9, 5, 10},	/* 128 MB */
 202	{ 0x71, 28, 9, 5, 10},	/* 256 MB */
 203
 204	/* MASK ROM */
 205	{ 0x5d, 21, 9, 4, 8},	/* 2 MB */
 206	{ 0xd5, 22, 9, 4, 9},	/* 4 MB */
 207	{ 0xd6, 23, 9, 4, 10},	/* 8 MB */
 208	{ 0x57, 24, 9, 4, 11},	/* 16 MB */
 209	{ 0x58, 25, 9, 4, 12},	/* 32 MB */
 210	{ 0,}
 211};
 212
 213static struct alauda_card_info *alauda_card_find_id(unsigned char id)
 214{
 215	int i;
 216
 217	for (i = 0; alauda_card_ids[i].id != 0; i++)
 218		if (alauda_card_ids[i].id == id)
 219			return &(alauda_card_ids[i]);
 220	return NULL;
 221}
 222
 223/*
 224 * ECC computation.
 225 */
 226
 227static unsigned char parity[256];
 228static unsigned char ecc2[256];
 229
 230static void nand_init_ecc(void)
 231{
 232	int i, j, a;
 233
 234	parity[0] = 0;
 235	for (i = 1; i < 256; i++)
 236		parity[i] = (parity[i&(i-1)] ^ 1);
 237
 238	for (i = 0; i < 256; i++) {
 239		a = 0;
 240		for (j = 0; j < 8; j++) {
 241			if (i & (1<<j)) {
 242				if ((j & 1) == 0)
 243					a ^= 0x04;
 244				if ((j & 2) == 0)
 245					a ^= 0x10;
 246				if ((j & 4) == 0)
 247					a ^= 0x40;
 248			}
 249		}
 250		ecc2[i] = ~(a ^ (a<<1) ^ (parity[i] ? 0xa8 : 0));
 251	}
 252}
 253
 254/* compute 3-byte ecc on 256 bytes */
 255static void nand_compute_ecc(unsigned char *data, unsigned char *ecc)
 256{
 257	int i, j, a;
 258	unsigned char par = 0, bit, bits[8] = {0};
 259
 260	/* collect 16 checksum bits */
 261	for (i = 0; i < 256; i++) {
 262		par ^= data[i];
 263		bit = parity[data[i]];
 264		for (j = 0; j < 8; j++)
 265			if ((i & (1<<j)) == 0)
 266				bits[j] ^= bit;
 267	}
 268
 269	/* put 4+4+4 = 12 bits in the ecc */
 270	a = (bits[3] << 6) + (bits[2] << 4) + (bits[1] << 2) + bits[0];
 271	ecc[0] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0));
 272
 273	a = (bits[7] << 6) + (bits[6] << 4) + (bits[5] << 2) + bits[4];
 274	ecc[1] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0));
 275
 276	ecc[2] = ecc2[par];
 277}
 278
 279static int nand_compare_ecc(unsigned char *data, unsigned char *ecc)
 280{
 281	return (data[0] == ecc[0] && data[1] == ecc[1] && data[2] == ecc[2]);
 282}
 283
 284static void nand_store_ecc(unsigned char *data, unsigned char *ecc)
 285{
 286	memcpy(data, ecc, 3);
 287}
 288
 289/*
 290 * Alauda driver
 291 */
 292
 293/*
 294 * Forget our PBA <---> LBA mappings for a particular port
 295 */
 296static void alauda_free_maps (struct alauda_media_info *media_info)
 297{
 298	unsigned int shift = media_info->zoneshift
 299		+ media_info->blockshift + media_info->pageshift;
 300	unsigned int num_zones = media_info->capacity >> shift;
 301	unsigned int i;
 302
 303	if (media_info->lba_to_pba != NULL)
 304		for (i = 0; i < num_zones; i++) {
 305			kfree(media_info->lba_to_pba[i]);
 306			media_info->lba_to_pba[i] = NULL;
 307		}
 308
 309	if (media_info->pba_to_lba != NULL)
 310		for (i = 0; i < num_zones; i++) {
 311			kfree(media_info->pba_to_lba[i]);
 312			media_info->pba_to_lba[i] = NULL;
 313		}
 314}
 315
 316/*
 317 * Returns 2 bytes of status data
 318 * The first byte describes media status, and second byte describes door status
 319 */
 320static int alauda_get_media_status(struct us_data *us, unsigned char *data)
 321{
 322	int rc;
 323	unsigned char command;
 324
 325	if (MEDIA_PORT(us) == ALAUDA_PORT_XD)
 326		command = ALAUDA_GET_XD_MEDIA_STATUS;
 327	else
 328		command = ALAUDA_GET_SM_MEDIA_STATUS;
 329
 330	rc = usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe,
 331		command, 0xc0, 0, 1, data, 2);
 332
 333	usb_stor_dbg(us, "Media status %02X %02X\n", data[0], data[1]);
 334
 335	return rc;
 336}
 337
 338/*
 339 * Clears the "media was changed" bit so that we know when it changes again
 340 * in the future.
 341 */
 342static int alauda_ack_media(struct us_data *us)
 343{
 344	unsigned char command;
 345
 346	if (MEDIA_PORT(us) == ALAUDA_PORT_XD)
 347		command = ALAUDA_ACK_XD_MEDIA_CHANGE;
 348	else
 349		command = ALAUDA_ACK_SM_MEDIA_CHANGE;
 350
 351	return usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
 352		command, 0x40, 0, 1, NULL, 0);
 353}
 354
 355/*
 356 * Retrieves a 4-byte media signature, which indicates manufacturer, capacity,
 357 * and some other details.
 358 */
 359static int alauda_get_media_signature(struct us_data *us, unsigned char *data)
 360{
 361	unsigned char command;
 362
 363	if (MEDIA_PORT(us) == ALAUDA_PORT_XD)
 364		command = ALAUDA_GET_XD_MEDIA_SIG;
 365	else
 366		command = ALAUDA_GET_SM_MEDIA_SIG;
 367
 368	return usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe,
 369		command, 0xc0, 0, 0, data, 4);
 370}
 371
 372/*
 373 * Resets the media status (but not the whole device?)
 374 */
 375static int alauda_reset_media(struct us_data *us)
 376{
 377	unsigned char *command = us->iobuf;
 378
 379	memset(command, 0, 9);
 380	command[0] = ALAUDA_BULK_CMD;
 381	command[1] = ALAUDA_BULK_RESET_MEDIA;
 382	command[8] = MEDIA_PORT(us);
 383
 384	return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
 385		command, 9, NULL);
 386}
 387
 388/*
 389 * Examines the media and deduces capacity, etc.
 390 */
 391static int alauda_init_media(struct us_data *us)
 392{
 393	unsigned char *data = us->iobuf;
 394	int ready = 0;
 395	struct alauda_card_info *media_info;
 396	unsigned int num_zones;
 397
 398	while (ready == 0) {
 399		msleep(20);
 400
 401		if (alauda_get_media_status(us, data) != USB_STOR_XFER_GOOD)
 402			return USB_STOR_TRANSPORT_ERROR;
 403
 404		if (data[0] & 0x10)
 405			ready = 1;
 406	}
 407
 408	usb_stor_dbg(us, "We are ready for action!\n");
 409
 410	if (alauda_ack_media(us) != USB_STOR_XFER_GOOD)
 411		return USB_STOR_TRANSPORT_ERROR;
 412
 413	msleep(10);
 414
 415	if (alauda_get_media_status(us, data) != USB_STOR_XFER_GOOD)
 416		return USB_STOR_TRANSPORT_ERROR;
 417
 418	if (data[0] != 0x14) {
 419		usb_stor_dbg(us, "Media not ready after ack\n");
 420		return USB_STOR_TRANSPORT_ERROR;
 421	}
 422
 423	if (alauda_get_media_signature(us, data) != USB_STOR_XFER_GOOD)
 424		return USB_STOR_TRANSPORT_ERROR;
 425
 426	usb_stor_dbg(us, "Media signature: %4ph\n", data);
 427	media_info = alauda_card_find_id(data[1]);
 428	if (media_info == NULL) {
 429		pr_warn("alauda_init_media: Unrecognised media signature: %4ph\n",
 430			data);
 431		return USB_STOR_TRANSPORT_ERROR;
 432	}
 433
 434	MEDIA_INFO(us).capacity = 1 << media_info->chipshift;
 435	usb_stor_dbg(us, "Found media with capacity: %ldMB\n",
 436		     MEDIA_INFO(us).capacity >> 20);
 437
 438	MEDIA_INFO(us).pageshift = media_info->pageshift;
 439	MEDIA_INFO(us).blockshift = media_info->blockshift;
 440	MEDIA_INFO(us).zoneshift = media_info->zoneshift;
 441
 442	MEDIA_INFO(us).pagesize = 1 << media_info->pageshift;
 443	MEDIA_INFO(us).blocksize = 1 << media_info->blockshift;
 444	MEDIA_INFO(us).zonesize = 1 << media_info->zoneshift;
 445
 446	MEDIA_INFO(us).uzonesize = ((1 << media_info->zoneshift) / 128) * 125;
 447	MEDIA_INFO(us).blockmask = MEDIA_INFO(us).blocksize - 1;
 448
 449	num_zones = MEDIA_INFO(us).capacity >> (MEDIA_INFO(us).zoneshift
 450		+ MEDIA_INFO(us).blockshift + MEDIA_INFO(us).pageshift);
 451	MEDIA_INFO(us).pba_to_lba = kcalloc(num_zones, sizeof(u16*), GFP_NOIO);
 452	MEDIA_INFO(us).lba_to_pba = kcalloc(num_zones, sizeof(u16*), GFP_NOIO);
 453
 454	if (alauda_reset_media(us) != USB_STOR_XFER_GOOD)
 455		return USB_STOR_TRANSPORT_ERROR;
 456
 457	return USB_STOR_TRANSPORT_GOOD;
 458}
 459
 460/*
 461 * Examines the media status and does the right thing when the media has gone,
 462 * appeared, or changed.
 463 */
 464static int alauda_check_media(struct us_data *us)
 465{
 466	struct alauda_info *info = (struct alauda_info *) us->extra;
 467	unsigned char status[2];
 468	int rc;
 469
 470	rc = alauda_get_media_status(us, status);
 471
 472	/* Check for no media or door open */
 473	if ((status[0] & 0x80) || ((status[0] & 0x1F) == 0x10)
 474		|| ((status[1] & 0x01) == 0)) {
 475		usb_stor_dbg(us, "No media, or door open\n");
 476		alauda_free_maps(&MEDIA_INFO(us));
 477		info->sense_key = 0x02;
 478		info->sense_asc = 0x3A;
 479		info->sense_ascq = 0x00;
 480		return USB_STOR_TRANSPORT_FAILED;
 481	}
 482
 483	/* Check for media change */
 484	if (status[0] & 0x08) {
 485		usb_stor_dbg(us, "Media change detected\n");
 486		alauda_free_maps(&MEDIA_INFO(us));
 487		alauda_init_media(us);
 488
 489		info->sense_key = UNIT_ATTENTION;
 490		info->sense_asc = 0x28;
 491		info->sense_ascq = 0x00;
 492		return USB_STOR_TRANSPORT_FAILED;
 493	}
 494
 495	return USB_STOR_TRANSPORT_GOOD;
 496}
 497
 498/*
 499 * Checks the status from the 2nd status register
 500 * Returns 3 bytes of status data, only the first is known
 501 */
 502static int alauda_check_status2(struct us_data *us)
 503{
 504	int rc;
 505	unsigned char command[] = {
 506		ALAUDA_BULK_CMD, ALAUDA_BULK_GET_STATUS2,
 507		0, 0, 0, 0, 3, 0, MEDIA_PORT(us)
 508	};
 509	unsigned char data[3];
 510
 511	rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
 512		command, 9, NULL);
 513	if (rc != USB_STOR_XFER_GOOD)
 514		return rc;
 515
 516	rc = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
 517		data, 3, NULL);
 518	if (rc != USB_STOR_XFER_GOOD)
 519		return rc;
 520
 521	usb_stor_dbg(us, "%3ph\n", data);
 522	if (data[0] & ALAUDA_STATUS_ERROR)
 523		return USB_STOR_XFER_ERROR;
 524
 525	return USB_STOR_XFER_GOOD;
 526}
 527
 528/*
 529 * Gets the redundancy data for the first page of a PBA
 530 * Returns 16 bytes.
 531 */
 532static int alauda_get_redu_data(struct us_data *us, u16 pba, unsigned char *data)
 533{
 534	int rc;
 535	unsigned char command[] = {
 536		ALAUDA_BULK_CMD, ALAUDA_BULK_GET_REDU_DATA,
 537		PBA_HI(pba), PBA_ZONE(pba), 0, PBA_LO(pba), 0, 0, MEDIA_PORT(us)
 538	};
 539
 540	rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
 541		command, 9, NULL);
 542	if (rc != USB_STOR_XFER_GOOD)
 543		return rc;
 544
 545	return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
 546		data, 16, NULL);
 547}
 548
 549/*
 550 * Finds the first unused PBA in a zone
 551 * Returns the absolute PBA of an unused PBA, or 0 if none found.
 552 */
 553static u16 alauda_find_unused_pba(struct alauda_media_info *info,
 554	unsigned int zone)
 555{
 556	u16 *pba_to_lba = info->pba_to_lba[zone];
 557	unsigned int i;
 558
 559	for (i = 0; i < info->zonesize; i++)
 560		if (pba_to_lba[i] == UNDEF)
 561			return (zone << info->zoneshift) + i;
 562
 563	return 0;
 564}
 565
 566/*
 567 * Reads the redundancy data for all PBA's in a zone
 568 * Produces lba <--> pba mappings
 569 */
 570static int alauda_read_map(struct us_data *us, unsigned int zone)
 571{
 572	unsigned char *data = us->iobuf;
 573	int result;
 574	int i, j;
 575	unsigned int zonesize = MEDIA_INFO(us).zonesize;
 576	unsigned int uzonesize = MEDIA_INFO(us).uzonesize;
 577	unsigned int lba_offset, lba_real, blocknum;
 578	unsigned int zone_base_lba = zone * uzonesize;
 579	unsigned int zone_base_pba = zone * zonesize;
 580	u16 *lba_to_pba = kcalloc(zonesize, sizeof(u16), GFP_NOIO);
 581	u16 *pba_to_lba = kcalloc(zonesize, sizeof(u16), GFP_NOIO);
 582	if (lba_to_pba == NULL || pba_to_lba == NULL) {
 583		result = USB_STOR_TRANSPORT_ERROR;
 584		goto error;
 585	}
 586
 587	usb_stor_dbg(us, "Mapping blocks for zone %d\n", zone);
 588
 589	/* 1024 PBA's per zone */
 590	for (i = 0; i < zonesize; i++)
 591		lba_to_pba[i] = pba_to_lba[i] = UNDEF;
 592
 593	for (i = 0; i < zonesize; i++) {
 594		blocknum = zone_base_pba + i;
 595
 596		result = alauda_get_redu_data(us, blocknum, data);
 597		if (result != USB_STOR_XFER_GOOD) {
 598			result = USB_STOR_TRANSPORT_ERROR;
 599			goto error;
 600		}
 601
 602		/* special PBAs have control field 0^16 */
 603		for (j = 0; j < 16; j++)
 604			if (data[j] != 0)
 605				goto nonz;
 606		pba_to_lba[i] = UNUSABLE;
 607		usb_stor_dbg(us, "PBA %d has no logical mapping\n", blocknum);
 608		continue;
 609
 610	nonz:
 611		/* unwritten PBAs have control field FF^16 */
 612		for (j = 0; j < 16; j++)
 613			if (data[j] != 0xff)
 614				goto nonff;
 615		continue;
 616
 617	nonff:
 618		/* normal PBAs start with six FFs */
 619		if (j < 6) {
 620			usb_stor_dbg(us, "PBA %d has no logical mapping: reserved area = %02X%02X%02X%02X data status %02X block status %02X\n",
 621				     blocknum,
 622				     data[0], data[1], data[2], data[3],
 623				     data[4], data[5]);
 624			pba_to_lba[i] = UNUSABLE;
 625			continue;
 626		}
 627
 628		if ((data[6] >> 4) != 0x01) {
 629			usb_stor_dbg(us, "PBA %d has invalid address field %02X%02X/%02X%02X\n",
 630				     blocknum, data[6], data[7],
 631				     data[11], data[12]);
 632			pba_to_lba[i] = UNUSABLE;
 633			continue;
 634		}
 635
 636		/* check even parity */
 637		if (parity[data[6] ^ data[7]]) {
 638			printk(KERN_WARNING
 639			       "alauda_read_map: Bad parity in LBA for block %d"
 640			       " (%02X %02X)\n", i, data[6], data[7]);
 641			pba_to_lba[i] = UNUSABLE;
 642			continue;
 643		}
 644
 645		lba_offset = short_pack(data[7], data[6]);
 646		lba_offset = (lba_offset & 0x07FF) >> 1;
 647		lba_real = lba_offset + zone_base_lba;
 648
 649		/*
 650		 * Every 1024 physical blocks ("zone"), the LBA numbers
 651		 * go back to zero, but are within a higher block of LBA's.
 652		 * Also, there is a maximum of 1000 LBA's per zone.
 653		 * In other words, in PBA 1024-2047 you will find LBA 0-999
 654		 * which are really LBA 1000-1999. This allows for 24 bad
 655		 * or special physical blocks per zone.
 656		 */
 657
 658		if (lba_offset >= uzonesize) {
 659			printk(KERN_WARNING
 660			       "alauda_read_map: Bad low LBA %d for block %d\n",
 661			       lba_real, blocknum);
 662			continue;
 663		}
 664
 665		if (lba_to_pba[lba_offset] != UNDEF) {
 666			printk(KERN_WARNING
 667			       "alauda_read_map: "
 668			       "LBA %d seen for PBA %d and %d\n",
 669			       lba_real, lba_to_pba[lba_offset], blocknum);
 670			continue;
 671		}
 672
 673		pba_to_lba[i] = lba_real;
 674		lba_to_pba[lba_offset] = blocknum;
 675		continue;
 676	}
 677
 678	MEDIA_INFO(us).lba_to_pba[zone] = lba_to_pba;
 679	MEDIA_INFO(us).pba_to_lba[zone] = pba_to_lba;
 680	result = 0;
 681	goto out;
 682
 683error:
 684	kfree(lba_to_pba);
 685	kfree(pba_to_lba);
 686out:
 687	return result;
 688}
 689
 690/*
 691 * Checks to see whether we have already mapped a certain zone
 692 * If we haven't, the map is generated
 693 */
 694static void alauda_ensure_map_for_zone(struct us_data *us, unsigned int zone)
 695{
 696	if (MEDIA_INFO(us).lba_to_pba[zone] == NULL
 697		|| MEDIA_INFO(us).pba_to_lba[zone] == NULL)
 698		alauda_read_map(us, zone);
 699}
 700
 701/*
 702 * Erases an entire block
 703 */
 704static int alauda_erase_block(struct us_data *us, u16 pba)
 705{
 706	int rc;
 707	unsigned char command[] = {
 708		ALAUDA_BULK_CMD, ALAUDA_BULK_ERASE_BLOCK, PBA_HI(pba),
 709		PBA_ZONE(pba), 0, PBA_LO(pba), 0x02, 0, MEDIA_PORT(us)
 710	};
 711	unsigned char buf[2];
 712
 713	usb_stor_dbg(us, "Erasing PBA %d\n", pba);
 714
 715	rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
 716		command, 9, NULL);
 717	if (rc != USB_STOR_XFER_GOOD)
 718		return rc;
 719
 720	rc = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
 721		buf, 2, NULL);
 722	if (rc != USB_STOR_XFER_GOOD)
 723		return rc;
 724
 725	usb_stor_dbg(us, "Erase result: %02X %02X\n", buf[0], buf[1]);
 726	return rc;
 727}
 728
 729/*
 730 * Reads data from a certain offset page inside a PBA, including interleaved
 731 * redundancy data. Returns (pagesize+64)*pages bytes in data.
 732 */
 733static int alauda_read_block_raw(struct us_data *us, u16 pba,
 734		unsigned int page, unsigned int pages, unsigned char *data)
 735{
 736	int rc;
 737	unsigned char command[] = {
 738		ALAUDA_BULK_CMD, ALAUDA_BULK_READ_BLOCK, PBA_HI(pba),
 739		PBA_ZONE(pba), 0, PBA_LO(pba) + page, pages, 0, MEDIA_PORT(us)
 740	};
 741
 742	usb_stor_dbg(us, "pba %d page %d count %d\n", pba, page, pages);
 743
 744	rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
 745		command, 9, NULL);
 746	if (rc != USB_STOR_XFER_GOOD)
 747		return rc;
 748
 749	return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
 750		data, (MEDIA_INFO(us).pagesize + 64) * pages, NULL);
 751}
 752
 753/*
 754 * Reads data from a certain offset page inside a PBA, excluding redundancy
 755 * data. Returns pagesize*pages bytes in data. Note that data must be big enough
 756 * to hold (pagesize+64)*pages bytes of data, but you can ignore those 'extra'
 757 * trailing bytes outside this function.
 758 */
 759static int alauda_read_block(struct us_data *us, u16 pba,
 760		unsigned int page, unsigned int pages, unsigned char *data)
 761{
 762	int i, rc;
 763	unsigned int pagesize = MEDIA_INFO(us).pagesize;
 764
 765	rc = alauda_read_block_raw(us, pba, page, pages, data);
 766	if (rc != USB_STOR_XFER_GOOD)
 767		return rc;
 768
 769	/* Cut out the redundancy data */
 770	for (i = 0; i < pages; i++) {
 771		int dest_offset = i * pagesize;
 772		int src_offset = i * (pagesize + 64);
 773		memmove(data + dest_offset, data + src_offset, pagesize);
 774	}
 775
 776	return rc;
 777}
 778
 779/*
 780 * Writes an entire block of data and checks status after write.
 781 * Redundancy data must be already included in data. Data should be
 782 * (pagesize+64)*blocksize bytes in length.
 783 */
 784static int alauda_write_block(struct us_data *us, u16 pba, unsigned char *data)
 785{
 786	int rc;
 787	struct alauda_info *info = (struct alauda_info *) us->extra;
 788	unsigned char command[] = {
 789		ALAUDA_BULK_CMD, ALAUDA_BULK_WRITE_BLOCK, PBA_HI(pba),
 790		PBA_ZONE(pba), 0, PBA_LO(pba), 32, 0, MEDIA_PORT(us)
 791	};
 792
 793	usb_stor_dbg(us, "pba %d\n", pba);
 794
 795	rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
 796		command, 9, NULL);
 797	if (rc != USB_STOR_XFER_GOOD)
 798		return rc;
 799
 800	rc = usb_stor_bulk_transfer_buf(us, info->wr_ep, data,
 801		(MEDIA_INFO(us).pagesize + 64) * MEDIA_INFO(us).blocksize,
 802		NULL);
 803	if (rc != USB_STOR_XFER_GOOD)
 804		return rc;
 805
 806	return alauda_check_status2(us);
 807}
 808
 809/*
 810 * Write some data to a specific LBA.
 811 */
 812static int alauda_write_lba(struct us_data *us, u16 lba,
 813		 unsigned int page, unsigned int pages,
 814		 unsigned char *ptr, unsigned char *blockbuffer)
 815{
 816	u16 pba, lbap, new_pba;
 817	unsigned char *bptr, *cptr, *xptr;
 818	unsigned char ecc[3];
 819	int i, result;
 820	unsigned int uzonesize = MEDIA_INFO(us).uzonesize;
 821	unsigned int zonesize = MEDIA_INFO(us).zonesize;
 822	unsigned int pagesize = MEDIA_INFO(us).pagesize;
 823	unsigned int blocksize = MEDIA_INFO(us).blocksize;
 824	unsigned int lba_offset = lba % uzonesize;
 825	unsigned int new_pba_offset;
 826	unsigned int zone = lba / uzonesize;
 827
 828	alauda_ensure_map_for_zone(us, zone);
 829
 830	pba = MEDIA_INFO(us).lba_to_pba[zone][lba_offset];
 831	if (pba == 1) {
 832		/* Maybe it is impossible to write to PBA 1.
 833		   Fake success, but don't do anything. */
 
 
 834		printk(KERN_WARNING
 835		       "alauda_write_lba: avoid writing to pba 1\n");
 836		return USB_STOR_TRANSPORT_GOOD;
 837	}
 838
 839	new_pba = alauda_find_unused_pba(&MEDIA_INFO(us), zone);
 840	if (!new_pba) {
 841		printk(KERN_WARNING
 842		       "alauda_write_lba: Out of unused blocks\n");
 843		return USB_STOR_TRANSPORT_ERROR;
 844	}
 845
 846	/* read old contents */
 847	if (pba != UNDEF) {
 848		result = alauda_read_block_raw(us, pba, 0,
 849			blocksize, blockbuffer);
 850		if (result != USB_STOR_XFER_GOOD)
 851			return result;
 852	} else {
 853		memset(blockbuffer, 0, blocksize * (pagesize + 64));
 854	}
 855
 856	lbap = (lba_offset << 1) | 0x1000;
 857	if (parity[MSB_of(lbap) ^ LSB_of(lbap)])
 858		lbap ^= 1;
 859
 860	/* check old contents and fill lba */
 861	for (i = 0; i < blocksize; i++) {
 862		bptr = blockbuffer + (i * (pagesize + 64));
 863		cptr = bptr + pagesize;
 864		nand_compute_ecc(bptr, ecc);
 865		if (!nand_compare_ecc(cptr+13, ecc)) {
 866			usb_stor_dbg(us, "Warning: bad ecc in page %d- of pba %d\n",
 867				     i, pba);
 868			nand_store_ecc(cptr+13, ecc);
 869		}
 870		nand_compute_ecc(bptr + (pagesize / 2), ecc);
 871		if (!nand_compare_ecc(cptr+8, ecc)) {
 872			usb_stor_dbg(us, "Warning: bad ecc in page %d+ of pba %d\n",
 873				     i, pba);
 874			nand_store_ecc(cptr+8, ecc);
 875		}
 876		cptr[6] = cptr[11] = MSB_of(lbap);
 877		cptr[7] = cptr[12] = LSB_of(lbap);
 878	}
 879
 880	/* copy in new stuff and compute ECC */
 881	xptr = ptr;
 882	for (i = page; i < page+pages; i++) {
 883		bptr = blockbuffer + (i * (pagesize + 64));
 884		cptr = bptr + pagesize;
 885		memcpy(bptr, xptr, pagesize);
 886		xptr += pagesize;
 887		nand_compute_ecc(bptr, ecc);
 888		nand_store_ecc(cptr+13, ecc);
 889		nand_compute_ecc(bptr + (pagesize / 2), ecc);
 890		nand_store_ecc(cptr+8, ecc);
 891	}
 892
 893	result = alauda_write_block(us, new_pba, blockbuffer);
 894	if (result != USB_STOR_XFER_GOOD)
 895		return result;
 896
 897	new_pba_offset = new_pba - (zone * zonesize);
 898	MEDIA_INFO(us).pba_to_lba[zone][new_pba_offset] = lba;
 899	MEDIA_INFO(us).lba_to_pba[zone][lba_offset] = new_pba;
 900	usb_stor_dbg(us, "Remapped LBA %d to PBA %d\n", lba, new_pba);
 901
 902	if (pba != UNDEF) {
 903		unsigned int pba_offset = pba - (zone * zonesize);
 904		result = alauda_erase_block(us, pba);
 905		if (result != USB_STOR_XFER_GOOD)
 906			return result;
 907		MEDIA_INFO(us).pba_to_lba[zone][pba_offset] = UNDEF;
 908	}
 909
 910	return USB_STOR_TRANSPORT_GOOD;
 911}
 912
 913/*
 914 * Read data from a specific sector address
 915 */
 916static int alauda_read_data(struct us_data *us, unsigned long address,
 917		unsigned int sectors)
 918{
 919	unsigned char *buffer;
 920	u16 lba, max_lba;
 921	unsigned int page, len, offset;
 922	unsigned int blockshift = MEDIA_INFO(us).blockshift;
 923	unsigned int pageshift = MEDIA_INFO(us).pageshift;
 924	unsigned int blocksize = MEDIA_INFO(us).blocksize;
 925	unsigned int pagesize = MEDIA_INFO(us).pagesize;
 926	unsigned int uzonesize = MEDIA_INFO(us).uzonesize;
 927	struct scatterlist *sg;
 928	int result;
 929
 930	/*
 931	 * Since we only read in one block at a time, we have to create
 932	 * a bounce buffer and move the data a piece at a time between the
 933	 * bounce buffer and the actual transfer buffer.
 934	 * We make this buffer big enough to hold temporary redundancy data,
 935	 * which we use when reading the data blocks.
 936	 */
 937
 938	len = min(sectors, blocksize) * (pagesize + 64);
 939	buffer = kmalloc(len, GFP_NOIO);
 940	if (buffer == NULL) {
 941		printk(KERN_WARNING "alauda_read_data: Out of memory\n");
 942		return USB_STOR_TRANSPORT_ERROR;
 943	}
 944
 945	/* Figure out the initial LBA and page */
 946	lba = address >> blockshift;
 947	page = (address & MEDIA_INFO(us).blockmask);
 948	max_lba = MEDIA_INFO(us).capacity >> (blockshift + pageshift);
 949
 950	result = USB_STOR_TRANSPORT_GOOD;
 951	offset = 0;
 952	sg = NULL;
 953
 954	while (sectors > 0) {
 955		unsigned int zone = lba / uzonesize; /* integer division */
 956		unsigned int lba_offset = lba - (zone * uzonesize);
 957		unsigned int pages;
 958		u16 pba;
 959		alauda_ensure_map_for_zone(us, zone);
 960
 961		/* Not overflowing capacity? */
 962		if (lba >= max_lba) {
 963			usb_stor_dbg(us, "Error: Requested lba %u exceeds maximum %u\n",
 964				     lba, max_lba);
 965			result = USB_STOR_TRANSPORT_ERROR;
 966			break;
 967		}
 968
 969		/* Find number of pages we can read in this block */
 970		pages = min(sectors, blocksize - page);
 971		len = pages << pageshift;
 972
 973		/* Find where this lba lives on disk */
 974		pba = MEDIA_INFO(us).lba_to_pba[zone][lba_offset];
 975
 976		if (pba == UNDEF) {	/* this lba was never written */
 977			usb_stor_dbg(us, "Read %d zero pages (LBA %d) page %d\n",
 978				     pages, lba, page);
 979
 980			/* This is not really an error. It just means
 981			   that the block has never been written.
 982			   Instead of returning USB_STOR_TRANSPORT_ERROR
 983			   it is better to return all zero data. */
 
 
 984
 985			memset(buffer, 0, len);
 986		} else {
 987			usb_stor_dbg(us, "Read %d pages, from PBA %d (LBA %d) page %d\n",
 988				     pages, pba, lba, page);
 989
 990			result = alauda_read_block(us, pba, page, pages, buffer);
 991			if (result != USB_STOR_TRANSPORT_GOOD)
 992				break;
 993		}
 994
 995		/* Store the data in the transfer buffer */
 996		usb_stor_access_xfer_buf(buffer, len, us->srb,
 997				&sg, &offset, TO_XFER_BUF);
 998
 999		page = 0;
1000		lba++;
1001		sectors -= pages;
1002	}
1003
1004	kfree(buffer);
1005	return result;
1006}
1007
1008/*
1009 * Write data to a specific sector address
1010 */
1011static int alauda_write_data(struct us_data *us, unsigned long address,
1012		unsigned int sectors)
1013{
1014	unsigned char *buffer, *blockbuffer;
1015	unsigned int page, len, offset;
1016	unsigned int blockshift = MEDIA_INFO(us).blockshift;
1017	unsigned int pageshift = MEDIA_INFO(us).pageshift;
1018	unsigned int blocksize = MEDIA_INFO(us).blocksize;
1019	unsigned int pagesize = MEDIA_INFO(us).pagesize;
1020	struct scatterlist *sg;
1021	u16 lba, max_lba;
1022	int result;
1023
1024	/*
1025	 * Since we don't write the user data directly to the device,
1026	 * we have to create a bounce buffer and move the data a piece
1027	 * at a time between the bounce buffer and the actual transfer buffer.
1028	 */
1029
1030	len = min(sectors, blocksize) * pagesize;
1031	buffer = kmalloc(len, GFP_NOIO);
1032	if (buffer == NULL) {
1033		printk(KERN_WARNING "alauda_write_data: Out of memory\n");
1034		return USB_STOR_TRANSPORT_ERROR;
1035	}
1036
1037	/*
1038	 * We also need a temporary block buffer, where we read in the old data,
1039	 * overwrite parts with the new data, and manipulate the redundancy data
1040	 */
1041	blockbuffer = kmalloc((pagesize + 64) * blocksize, GFP_NOIO);
1042	if (blockbuffer == NULL) {
1043		printk(KERN_WARNING "alauda_write_data: Out of memory\n");
1044		kfree(buffer);
1045		return USB_STOR_TRANSPORT_ERROR;
1046	}
1047
1048	/* Figure out the initial LBA and page */
1049	lba = address >> blockshift;
1050	page = (address & MEDIA_INFO(us).blockmask);
1051	max_lba = MEDIA_INFO(us).capacity >> (pageshift + blockshift);
1052
1053	result = USB_STOR_TRANSPORT_GOOD;
1054	offset = 0;
1055	sg = NULL;
1056
1057	while (sectors > 0) {
1058		/* Write as many sectors as possible in this block */
1059		unsigned int pages = min(sectors, blocksize - page);
1060		len = pages << pageshift;
1061
1062		/* Not overflowing capacity? */
1063		if (lba >= max_lba) {
1064			usb_stor_dbg(us, "Requested lba %u exceeds maximum %u\n",
1065				     lba, max_lba);
1066			result = USB_STOR_TRANSPORT_ERROR;
1067			break;
1068		}
1069
1070		/* Get the data from the transfer buffer */
1071		usb_stor_access_xfer_buf(buffer, len, us->srb,
1072				&sg, &offset, FROM_XFER_BUF);
1073
1074		result = alauda_write_lba(us, lba, page, pages, buffer,
1075			blockbuffer);
1076		if (result != USB_STOR_TRANSPORT_GOOD)
1077			break;
1078
1079		page = 0;
1080		lba++;
1081		sectors -= pages;
1082	}
1083
1084	kfree(buffer);
1085	kfree(blockbuffer);
1086	return result;
1087}
1088
1089/*
1090 * Our interface with the rest of the world
1091 */
1092
1093static void alauda_info_destructor(void *extra)
1094{
1095	struct alauda_info *info = (struct alauda_info *) extra;
1096	int port;
1097
1098	if (!info)
1099		return;
1100
1101	for (port = 0; port < 2; port++) {
1102		struct alauda_media_info *media_info = &info->port[port];
1103
1104		alauda_free_maps(media_info);
1105		kfree(media_info->lba_to_pba);
1106		kfree(media_info->pba_to_lba);
1107	}
1108}
1109
1110/*
1111 * Initialize alauda_info struct and find the data-write endpoint
1112 */
1113static int init_alauda(struct us_data *us)
1114{
1115	struct alauda_info *info;
1116	struct usb_host_interface *altsetting = us->pusb_intf->cur_altsetting;
1117	nand_init_ecc();
1118
1119	us->extra = kzalloc(sizeof(struct alauda_info), GFP_NOIO);
1120	if (!us->extra)
1121		return USB_STOR_TRANSPORT_ERROR;
1122
1123	info = (struct alauda_info *) us->extra;
1124	us->extra_destructor = alauda_info_destructor;
1125
1126	info->wr_ep = usb_sndbulkpipe(us->pusb_dev,
1127		altsetting->endpoint[0].desc.bEndpointAddress
1128		& USB_ENDPOINT_NUMBER_MASK);
1129
1130	return USB_STOR_TRANSPORT_GOOD;
1131}
1132
1133static int alauda_transport(struct scsi_cmnd *srb, struct us_data *us)
1134{
1135	int rc;
1136	struct alauda_info *info = (struct alauda_info *) us->extra;
1137	unsigned char *ptr = us->iobuf;
1138	static unsigned char inquiry_response[36] = {
1139		0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
1140	};
1141
1142	if (srb->cmnd[0] == INQUIRY) {
1143		usb_stor_dbg(us, "INQUIRY - Returning bogus response\n");
1144		memcpy(ptr, inquiry_response, sizeof(inquiry_response));
1145		fill_inquiry_response(us, ptr, 36);
1146		return USB_STOR_TRANSPORT_GOOD;
1147	}
1148
1149	if (srb->cmnd[0] == TEST_UNIT_READY) {
1150		usb_stor_dbg(us, "TEST_UNIT_READY\n");
1151		return alauda_check_media(us);
1152	}
1153
1154	if (srb->cmnd[0] == READ_CAPACITY) {
1155		unsigned int num_zones;
1156		unsigned long capacity;
1157
1158		rc = alauda_check_media(us);
1159		if (rc != USB_STOR_TRANSPORT_GOOD)
1160			return rc;
1161
1162		num_zones = MEDIA_INFO(us).capacity >> (MEDIA_INFO(us).zoneshift
1163			+ MEDIA_INFO(us).blockshift + MEDIA_INFO(us).pageshift);
1164
1165		capacity = num_zones * MEDIA_INFO(us).uzonesize
1166			* MEDIA_INFO(us).blocksize;
1167
1168		/* Report capacity and page size */
1169		((__be32 *) ptr)[0] = cpu_to_be32(capacity - 1);
1170		((__be32 *) ptr)[1] = cpu_to_be32(512);
1171
1172		usb_stor_set_xfer_buf(ptr, 8, srb);
1173		return USB_STOR_TRANSPORT_GOOD;
1174	}
1175
1176	if (srb->cmnd[0] == READ_10) {
1177		unsigned int page, pages;
1178
1179		rc = alauda_check_media(us);
1180		if (rc != USB_STOR_TRANSPORT_GOOD)
1181			return rc;
1182
1183		page = short_pack(srb->cmnd[3], srb->cmnd[2]);
1184		page <<= 16;
1185		page |= short_pack(srb->cmnd[5], srb->cmnd[4]);
1186		pages = short_pack(srb->cmnd[8], srb->cmnd[7]);
1187
1188		usb_stor_dbg(us, "READ_10: page %d pagect %d\n", page, pages);
1189
1190		return alauda_read_data(us, page, pages);
1191	}
1192
1193	if (srb->cmnd[0] == WRITE_10) {
1194		unsigned int page, pages;
1195
1196		rc = alauda_check_media(us);
1197		if (rc != USB_STOR_TRANSPORT_GOOD)
1198			return rc;
1199
1200		page = short_pack(srb->cmnd[3], srb->cmnd[2]);
1201		page <<= 16;
1202		page |= short_pack(srb->cmnd[5], srb->cmnd[4]);
1203		pages = short_pack(srb->cmnd[8], srb->cmnd[7]);
1204
1205		usb_stor_dbg(us, "WRITE_10: page %d pagect %d\n", page, pages);
1206
1207		return alauda_write_data(us, page, pages);
1208	}
1209
1210	if (srb->cmnd[0] == REQUEST_SENSE) {
1211		usb_stor_dbg(us, "REQUEST_SENSE\n");
1212
1213		memset(ptr, 0, 18);
1214		ptr[0] = 0xF0;
1215		ptr[2] = info->sense_key;
1216		ptr[7] = 11;
1217		ptr[12] = info->sense_asc;
1218		ptr[13] = info->sense_ascq;
1219		usb_stor_set_xfer_buf(ptr, 18, srb);
1220
1221		return USB_STOR_TRANSPORT_GOOD;
1222	}
1223
1224	if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
1225		/* sure.  whatever.  not like we can stop the user from popping
1226		   the media out of the device (no locking doors, etc) */
 
 
1227		return USB_STOR_TRANSPORT_GOOD;
1228	}
1229
1230	usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n",
1231		     srb->cmnd[0], srb->cmnd[0]);
1232	info->sense_key = 0x05;
1233	info->sense_asc = 0x20;
1234	info->sense_ascq = 0x00;
1235	return USB_STOR_TRANSPORT_FAILED;
1236}
1237
1238static struct scsi_host_template alauda_host_template;
1239
1240static int alauda_probe(struct usb_interface *intf,
1241			 const struct usb_device_id *id)
1242{
1243	struct us_data *us;
1244	int result;
1245
1246	result = usb_stor_probe1(&us, intf, id,
1247			(id - alauda_usb_ids) + alauda_unusual_dev_list,
1248			&alauda_host_template);
1249	if (result)
1250		return result;
1251
1252	us->transport_name  = "Alauda Control/Bulk";
1253	us->transport = alauda_transport;
1254	us->transport_reset = usb_stor_Bulk_reset;
1255	us->max_lun = 1;
1256
1257	result = usb_stor_probe2(us);
1258	return result;
1259}
1260
1261static struct usb_driver alauda_driver = {
1262	.name =		DRV_NAME,
1263	.probe =	alauda_probe,
1264	.disconnect =	usb_stor_disconnect,
1265	.suspend =	usb_stor_suspend,
1266	.resume =	usb_stor_resume,
1267	.reset_resume =	usb_stor_reset_resume,
1268	.pre_reset =	usb_stor_pre_reset,
1269	.post_reset =	usb_stor_post_reset,
1270	.id_table =	alauda_usb_ids,
1271	.soft_unbind =	1,
1272	.no_dynamic_id = 1,
1273};
1274
1275module_usb_stor_driver(alauda_driver, alauda_host_template, DRV_NAME);