static int
acd_init_writer(device_t dev, int test_write)
{
int8_t ccb[16];
bzero(ccb, sizeof(ccb));
ccb[0] = ATAPI_REZERO;
ata_atapicmd(dev, ccb, NULL, 0, ATA_R_QUIET, 60);
ccb[0] = ATAPI_SEND_OPC_INFO;
ccb[1] = 0x01;
ata_atapicmd(dev, ccb, NULL, 0, ATA_R_QUIET, 30);
return 0;
}
static int
acd_flush(device_t dev)
{
int8_t ccb[16] = { ATAPI_SYNCHRONIZE_CACHE, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0 };
return ata_atapicmd(dev, ccb, NULL, 0, ATA_R_QUIET, 60);
}
static int
acd_play(device_t dev, int start, int end)
{
int8_t ccb[16];
bzero(ccb, sizeof(ccb));
ccb[0] = ATAPI_PLAY_MSF;
lba2msf(start, &ccb[3], &ccb[4], &ccb[5]);
lba2msf(end, &ccb[6], &ccb[7], &ccb[8]);
return ata_atapicmd(dev, ccb, NULL, 0, 0, 10);
}
static int
acd_fixate(device_t dev, int multisession)
{
struct acd_softc *cdp = device_get_ivars(dev);
int8_t ccb[16] = { ATAPI_CLOSE_TRACK, 0x01, 0x02, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0 };
int timeout = 5*60*2;
int error, dummy;
struct write_param param;
if ((error = acd_mode_sense(dev, ATAPI_CDROM_WRITE_PARAMETERS_PAGE,
(caddr_t)¶m, sizeof(param))))
return error;
param.data_length = 0;
if (multisession)
param.session_type = CDR_SESS_MULTI;
else
param.session_type = CDR_SESS_NONE;
if ((error = acd_mode_select(dev, (caddr_t)¶m, param.page_length + 10)))
return error;
error = ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
if (error)
return error;
/* some drives just return ready, wait for the expected fixate time */
if ((error = acd_test_ready(dev)) != EBUSY) {
timeout = timeout / (cdp->cap.cur_write_speed / 177);
pause("acdfix", timeout * hz / 2);
return acd_test_ready(dev);
}
while (timeout-- > 0) {
if ((error = acd_get_progress(dev, &dummy)))
return error;
if ((error = acd_test_ready(dev)) != EBUSY)
return error;
pause("acdcld", hz / 2);
}
return EIO;
}
static int
afd_sense(device_t dev)
{
struct ata_device *atadev = device_get_softc(dev);
struct afd_softc *fdp = device_get_ivars(dev);
struct afd_capacity capacity;
struct afd_capacity_big capacity_big;
struct afd_capabilities capabilities;
int8_t ccb1[16] = { ATAPI_READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0 };
int8_t ccb2[16] = { ATAPI_READ_CAPACITY_16, 0x10, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, sizeof(struct afd_capacity_big) & 0xff, 0, 0 };
int8_t ccb3[16] = { ATAPI_MODE_SENSE_BIG, 0, ATAPI_REWRITEABLE_CAP_PAGE,
0, 0, 0, 0, sizeof(struct afd_capabilities) >> 8,
sizeof(struct afd_capabilities) & 0xff,
0, 0, 0, 0, 0, 0, 0 };
int timeout = 20;
int error, count;
fdp->mediasize = 0;
/* wait for device to get ready */
while ((error = afd_test_ready(dev)) && timeout--) {
DELAY(100000);
}
if (error == EBUSY)
return 1;
/* The IOMEGA Clik! doesn't support reading the cap page, fake it */
if (!strncmp(atadev->param.model, "IOMEGA Clik!", 12)) {
fdp->heads = 1;
fdp->sectors = 2;
fdp->mediasize = 39441 * 1024;
fdp->sectorsize = 512;
afd_test_ready(dev);
return 0;
}
/* get drive capacity */
if (!ata_atapicmd(dev, ccb1, (caddr_t)&capacity,
sizeof(struct afd_capacity), ATA_R_READ, 30)) {
fdp->heads = 16;
fdp->sectors = 63;
fdp->sectorsize = be32toh(capacity.blocksize);
fdp->mediasize = (u_int64_t)be32toh(capacity.capacity)*fdp->sectorsize;
afd_test_ready(dev);
return 0;
}
/* get drive capacity big */
if (!ata_atapicmd(dev, ccb2, (caddr_t)&capacity_big,
sizeof(struct afd_capacity_big),
ATA_R_READ | ATA_R_QUIET, 30)) {
fdp->heads = 16;
fdp->sectors = 63;
fdp->sectorsize = be32toh(capacity_big.blocksize);
fdp->mediasize = be64toh(capacity_big.capacity)*fdp->sectorsize;
afd_test_ready(dev);
return 0;
}
/* get drive capabilities, some bugridden drives needs this repeated */
for (count = 0 ; count < 5 ; count++) {
if (!ata_atapicmd(dev, ccb3, (caddr_t)&capabilities,
sizeof(struct afd_capabilities), ATA_R_READ, 30) &&
capabilities.page_code == ATAPI_REWRITEABLE_CAP_PAGE) {
fdp->heads = capabilities.heads;
fdp->sectors = capabilities.sectors;
fdp->sectorsize = be16toh(capabilities.sector_size);
fdp->mediasize = be16toh(capabilities.cylinders) *
fdp->heads * fdp->sectors * fdp->sectorsize;
if (!capabilities.medium_type)
fdp->mediasize = 0;
return 0;
}
}
return 1;
}
static int
afd_prevent_allow(device_t dev, int lock)
{
struct ata_device *atadev = device_get_softc(dev);
int8_t ccb[16] = { ATAPI_PREVENT_ALLOW, 0, 0, 0, lock,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
if (!strncmp(atadev->param.model, "IOMEGA Clik!", 12))
return 0;
return ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
}
static int
afd_test_ready(device_t dev)
{
int8_t ccb[16] = { ATAPI_TEST_UNIT_READY, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
return ata_atapicmd(dev, ccb, NULL, 0, 0, 30);
}
static void
acd_read_toc(device_t dev)
{
struct ata_device *atadev = device_get_softc(dev);
struct acd_softc *cdp = device_get_ivars(dev);
struct g_provider *pp;
u_int32_t sizes[2];
int8_t ccb[16];
int track, ntracks, len;
atadev->flags &= ~ATA_D_MEDIA_CHANGED;
bzero(&cdp->toc, sizeof(cdp->toc));
cdp->disk_size = -1; /* hack for GEOM SOS */
if (acd_test_ready(dev))
return;
bzero(ccb, sizeof(ccb));
len = sizeof(struct ioc_toc_header) + sizeof(struct cd_toc_entry);
ccb[0] = ATAPI_READ_TOC;
ccb[7] = len>>8;
ccb[8] = len;
if (ata_atapicmd(dev, ccb, (caddr_t)&cdp->toc, len,
ATA_R_READ | ATA_R_QUIET, 30)) {
bzero(&cdp->toc, sizeof(cdp->toc));
return;
}
ntracks = cdp->toc.hdr.ending_track - cdp->toc.hdr.starting_track + 1;
if (ntracks <= 0 || ntracks > MAXTRK) {
bzero(&cdp->toc, sizeof(cdp->toc));
return;
}
len = sizeof(struct ioc_toc_header)+(ntracks+1)*sizeof(struct cd_toc_entry);
bzero(ccb, sizeof(ccb));
ccb[0] = ATAPI_READ_TOC;
ccb[7] = len>>8;
ccb[8] = len;
if (ata_atapicmd(dev, ccb, (caddr_t)&cdp->toc, len,
ATA_R_READ | ATA_R_QUIET, 30)) {
bzero(&cdp->toc, sizeof(cdp->toc));
return;
}
cdp->toc.hdr.len = ntohs(cdp->toc.hdr.len);
cdp->block_size = (cdp->toc.tab[0].control & 4) ? 2048 : 2352;
acd_set_ioparm(dev);
bzero(ccb, sizeof(ccb));
ccb[0] = ATAPI_READ_CAPACITY;
if (ata_atapicmd(dev, ccb, (caddr_t)sizes, sizeof(sizes),
ATA_R_READ | ATA_R_QUIET, 30)) {
bzero(&cdp->toc, sizeof(cdp->toc));
return;
}
cdp->disk_size = ntohl(sizes[0]) + 1;
for (track = 1; track <= ntracks; track ++) {
if (cdp->pp[track] != NULL)
continue;
pp = g_new_providerf(cdp->gp, "acd%dt%02d", device_get_unit(dev),track);
pp->index = track;
cdp->pp[track] = pp;
g_error_provider(pp, 0);
}
for (; track < MAXTRK; track ++) {
if (cdp->pp[track] == NULL)
continue;
cdp->pp[track]->flags |= G_PF_WITHER;
g_orphan_provider(cdp->pp[track], ENXIO);
cdp->pp[track] = NULL;
}
#ifdef ACD_DEBUG
if (cdp->disk_size && cdp->toc.hdr.ending_track) {
device_printf(dev, "(%d sectors (%d bytes)), %d tracks ",
cdp->disk_size, cdp->block_size,
cdp->toc.hdr.ending_track-cdp->toc.hdr.starting_track+1);
if (cdp->toc.tab[0].control & 4)
printf("%dMB\n", cdp->disk_size * cdp->block_size / 1048576);
else
printf("%d:%d audio\n",
cdp->disk_size / 75 / 60, cdp->disk_size / 75 % 60);
}
#endif
}
static int
acd_geom_ioctl(struct g_provider *pp, u_long cmd, void *addr, int fflag, struct thread *td)
{
device_t dev = pp->geom->softc;
struct ata_device *atadev = device_get_softc(dev);
struct acd_softc *cdp = device_get_ivars(dev);
int error = 0, nocopyout = 0;
if (!cdp)
return ENXIO;
if (atadev->flags & ATA_D_MEDIA_CHANGED) {
switch (cmd) {
case CDIOCRESET:
acd_test_ready(dev);
break;
default:
acd_read_toc(dev);
acd_prevent_allow(dev, 1);
cdp->flags |= F_LOCKED;
break;
}
}
switch (cmd) {
case CDIOCRESUME:
error = acd_pause_resume(dev, 1);
break;
case CDIOCPAUSE:
error = acd_pause_resume(dev, 0);
break;
case CDIOCSTART:
error = acd_start_stop(dev, 1);
break;
case CDIOCSTOP:
error = acd_start_stop(dev, 0);
break;
case CDIOCALLOW:
error = acd_prevent_allow(dev, 0);
cdp->flags &= ~F_LOCKED;
break;
case CDIOCPREVENT:
error = acd_prevent_allow(dev, 1);
cdp->flags |= F_LOCKED;
break;
/*
* XXXRW: Why does this require privilege?
*/
case CDIOCRESET:
error = priv_check(td, PRIV_DRIVER);
if (error)
break;
error = acd_test_ready(dev);
break;
case CDIOCEJECT:
if (pp->acr != 1) {
error = EBUSY;
break;
}
error = acd_tray(dev, 0);
break;
case CDIOCCLOSE:
if (pp->acr != 1)
break;
error = acd_tray(dev, 1);
break;
case CDIOREADTOCHEADER:
if (!cdp->toc.hdr.ending_track) {
error = EIO;
break;
}
bcopy(&cdp->toc.hdr, addr, sizeof(cdp->toc.hdr));
break;
case CDIOREADTOCENTRYS:
{
struct ioc_read_toc_entry *te = (struct ioc_read_toc_entry *)addr;
struct toc *toc = &cdp->toc;
int starting_track = te->starting_track;
int len;
if (!toc->hdr.ending_track) {
error = EIO;
break;
}
if (te->data_len < sizeof(toc->tab[0]) ||
(te->data_len % sizeof(toc->tab[0])) != 0 ||
(te->address_format != CD_MSF_FORMAT &&
te->address_format != CD_LBA_FORMAT)) {
error = EINVAL;
break;
}
if (!starting_track)
starting_track = toc->hdr.starting_track;
else if (starting_track == 170)
starting_track = toc->hdr.ending_track + 1;
else if (starting_track < toc->hdr.starting_track ||
starting_track > toc->hdr.ending_track + 1) {
error = EINVAL;
break;
}
len = ((toc->hdr.ending_track + 1 - starting_track) + 1) *
sizeof(toc->tab[0]);
if (te->data_len < len)
len = te->data_len;
if (len > sizeof(toc->tab)) {
error = EINVAL;
break;
}
if (te->address_format == CD_MSF_FORMAT) {
struct cd_toc_entry *entry;
if (!(toc = malloc(sizeof(struct toc), M_ACD, M_NOWAIT))) {
error = ENOMEM;
break;
}
bcopy(&cdp->toc, toc, sizeof(struct toc));
entry = toc->tab + (toc->hdr.ending_track + 1 -
toc->hdr.starting_track) + 1;
while (--entry >= toc->tab) {
lba2msf(ntohl(entry->addr.lba), &entry->addr.msf.minute,
&entry->addr.msf.second, &entry->addr.msf.frame);
entry->addr_type = CD_MSF_FORMAT;
}
}
error = copyout(toc->tab + starting_track - toc->hdr.starting_track,
te->data, len);
if (te->address_format == CD_MSF_FORMAT)
free(toc, M_ACD);
}
break;
case CDIOREADTOCENTRY:
{
struct ioc_read_toc_single_entry *te =
(struct ioc_read_toc_single_entry *)addr;
struct toc *toc = &cdp->toc;
u_char track = te->track;
if (!toc->hdr.ending_track) {
error = EIO;
break;
}
if (te->address_format != CD_MSF_FORMAT &&
te->address_format != CD_LBA_FORMAT) {
error = EINVAL;
break;
}
if (!track)
track = toc->hdr.starting_track;
else if (track == 170)
track = toc->hdr.ending_track + 1;
else if (track < toc->hdr.starting_track ||
track > toc->hdr.ending_track + 1) {
error = EINVAL;
break;
}
if (te->address_format == CD_MSF_FORMAT) {
struct cd_toc_entry *entry;
if (!(toc = malloc(sizeof(struct toc), M_ACD, M_NOWAIT))) {
error = ENOMEM;
break;
}
bcopy(&cdp->toc, toc, sizeof(struct toc));
entry = toc->tab + (track - toc->hdr.starting_track);
lba2msf(ntohl(entry->addr.lba), &entry->addr.msf.minute,
&entry->addr.msf.second, &entry->addr.msf.frame);
}
bcopy(toc->tab + track - toc->hdr.starting_track,
&te->entry, sizeof(struct cd_toc_entry));
if (te->address_format == CD_MSF_FORMAT)
free(toc, M_ACD);
}
break;
#if __FreeBSD_version > 600008
case CDIOCREADSUBCHANNEL_SYSSPACE:
nocopyout = 1;
/* FALLTHROUGH */
#endif
case CDIOCREADSUBCHANNEL:
{
struct ioc_read_subchannel *args =
(struct ioc_read_subchannel *)addr;
u_int8_t format;
int8_t ccb[16] = { ATAPI_READ_SUBCHANNEL, 0, 0x40, 1, 0, 0, 0,
sizeof(cdp->subchan)>>8, sizeof(cdp->subchan),
0, 0, 0, 0, 0, 0, 0 };
if (args->data_len > sizeof(struct cd_sub_channel_info) ||
args->data_len < sizeof(struct cd_sub_channel_header)) {
error = EINVAL;
break;
}
format = args->data_format;
if ((format != CD_CURRENT_POSITION) &&
(format != CD_MEDIA_CATALOG) && (format != CD_TRACK_INFO)) {
error = EINVAL;
break;
}
ccb[1] = args->address_format & CD_MSF_FORMAT;
if ((error = ata_atapicmd(dev, ccb, (caddr_t)&cdp->subchan,
sizeof(cdp->subchan), ATA_R_READ, 10)))
break;
if ((format == CD_MEDIA_CATALOG) || (format == CD_TRACK_INFO)) {
if (cdp->subchan.header.audio_status == 0x11) {
error = EINVAL;
break;
}
ccb[3] = format;
if (format == CD_TRACK_INFO)
ccb[6] = args->track;
if ((error = ata_atapicmd(dev, ccb, (caddr_t)&cdp->subchan,
sizeof(cdp->subchan),ATA_R_READ,10))){
break;
}
}
if (nocopyout == 0) {
error = copyout(&cdp->subchan, args->data, args->data_len);
} else {
error = 0;
bcopy(&cdp->subchan, args->data, args->data_len);
}
}
break;
case CDIOCPLAYMSF:
{
struct ioc_play_msf *args = (struct ioc_play_msf *)addr;
error =
acd_play(dev,
msf2lba(args->start_m, args->start_s, args->start_f),
msf2lba(args->end_m, args->end_s, args->end_f));
}
break;
case CDIOCPLAYBLOCKS:
{
struct ioc_play_blocks *args = (struct ioc_play_blocks *)addr;
error = acd_play(dev, args->blk, args->blk + args->len);
}
break;
case CDIOCPLAYTRACKS:
{
struct ioc_play_track *args = (struct ioc_play_track *)addr;
int t1, t2;
if (!cdp->toc.hdr.ending_track) {
error = EIO;
break;
}
if (args->end_track < cdp->toc.hdr.ending_track + 1)
++args->end_track;
if (args->end_track > cdp->toc.hdr.ending_track + 1)
args->end_track = cdp->toc.hdr.ending_track + 1;
t1 = args->start_track - cdp->toc.hdr.starting_track;
t2 = args->end_track - cdp->toc.hdr.starting_track;
if (t1 < 0 || t2 < 0 ||
t1 > (cdp->toc.hdr.ending_track-cdp->toc.hdr.starting_track)) {
error = EINVAL;
break;
}
error = acd_play(dev, ntohl(cdp->toc.tab[t1].addr.lba),
ntohl(cdp->toc.tab[t2].addr.lba));
}
break;
case CDIOCGETVOL:
{
struct ioc_vol *arg = (struct ioc_vol *)addr;
if ((error = acd_mode_sense(dev, ATAPI_CDROM_AUDIO_PAGE,
(caddr_t)&cdp->au, sizeof(cdp->au))))
break;
if (cdp->au.page_code != ATAPI_CDROM_AUDIO_PAGE) {
error = EIO;
break;
}
arg->vol[0] = cdp->au.port[0].volume;
arg->vol[1] = cdp->au.port[1].volume;
arg->vol[2] = cdp->au.port[2].volume;
arg->vol[3] = cdp->au.port[3].volume;
}
break;
case CDIOCSETVOL:
{
struct ioc_vol *arg = (struct ioc_vol *)addr;
if ((error = acd_mode_sense(dev, ATAPI_CDROM_AUDIO_PAGE,
(caddr_t)&cdp->au, sizeof(cdp->au))))
break;
if (cdp->au.page_code != ATAPI_CDROM_AUDIO_PAGE) {
error = EIO;
break;
}
if ((error = acd_mode_sense(dev, ATAPI_CDROM_AUDIO_PAGE_MASK,
(caddr_t)&cdp->aumask,
sizeof(cdp->aumask))))
break;
cdp->au.data_length = 0;
cdp->au.port[0].channels = CHANNEL_0;
cdp->au.port[1].channels = CHANNEL_1;
cdp->au.port[0].volume = arg->vol[0] & cdp->aumask.port[0].volume;
cdp->au.port[1].volume = arg->vol[1] & cdp->aumask.port[1].volume;
cdp->au.port[2].volume = arg->vol[2] & cdp->aumask.port[2].volume;
cdp->au.port[3].volume = arg->vol[3] & cdp->aumask.port[3].volume;
error = acd_mode_select(dev, (caddr_t)&cdp->au, sizeof(cdp->au));
}
break;
case CDIOCSETPATCH:
{
struct ioc_patch *arg = (struct ioc_patch *)addr;
error = acd_setchan(dev, arg->patch[0], arg->patch[1],
arg->patch[2], arg->patch[3]);
}
break;
case CDIOCSETMONO:
error = acd_setchan(dev, CHANNEL_0|CHANNEL_1, CHANNEL_0|CHANNEL_1, 0,0);
break;
case CDIOCSETSTEREO:
error = acd_setchan(dev, CHANNEL_0, CHANNEL_1, 0, 0);
break;
case CDIOCSETMUTE:
error = acd_setchan(dev, 0, 0, 0, 0);
break;
case CDIOCSETLEFT:
error = acd_setchan(dev, CHANNEL_0, CHANNEL_0, 0, 0);
break;
case CDIOCSETRIGHT:
error = acd_setchan(dev, CHANNEL_1, CHANNEL_1, 0, 0);
break;
case CDRIOCBLANK:
error = acd_blank(dev, (*(int *)addr));
break;
case CDRIOCNEXTWRITEABLEADDR:
{
struct acd_track_info track_info;
if ((error = acd_read_track_info(dev, 0xff, &track_info)))
break;
if (!track_info.nwa_valid) {
error = EINVAL;
break;
}
*(int*)addr = track_info.next_writeable_addr;
}
break;
case CDRIOCINITWRITER:
error = acd_init_writer(dev, (*(int *)addr));
break;
case CDRIOCINITTRACK:
error = acd_init_track(dev, (struct cdr_track *)addr);
break;
case CDRIOCFLUSH:
error = acd_flush(dev);
break;
case CDRIOCFIXATE:
error = acd_fixate(dev, (*(int *)addr));
break;
case CDRIOCREADSPEED:
{
int speed = *(int *)addr;
/* Preserve old behavior: units in multiples of CDROM speed */
if (speed < 177)
speed *= 177;
error = acd_set_speed(dev, speed, CDR_MAX_SPEED);
}
break;
case CDRIOCWRITESPEED:
{
int speed = *(int *)addr;
if (speed < 177)
speed *= 177;
error = acd_set_speed(dev, CDR_MAX_SPEED, speed);
}
break;
case CDRIOCGETBLOCKSIZE:
*(int *)addr = cdp->block_size;
break;
case CDRIOCSETBLOCKSIZE:
cdp->block_size = *(int *)addr;
pp->sectorsize = cdp->block_size; /* hack for GEOM SOS */
acd_set_ioparm(dev);
break;
case CDRIOCGETPROGRESS:
error = acd_get_progress(dev, (int *)addr);
break;
case CDRIOCSENDCUE:
error = acd_send_cue(dev, (struct cdr_cuesheet *)addr);
break;
case CDRIOCREADFORMATCAPS:
error = acd_read_format_caps(dev, (struct cdr_format_capacities *)addr);
break;
case CDRIOCFORMAT:
error = acd_format(dev, (struct cdr_format_params *)addr);
break;
case DVDIOCREPORTKEY:
if (cdp->cap.media & MST_READ_DVDROM)
error = acd_report_key(dev, (struct dvd_authinfo *)addr);
else
error = EINVAL;
break;
case DVDIOCSENDKEY:
if (cdp->cap.media & MST_READ_DVDROM)
error = acd_send_key(dev, (struct dvd_authinfo *)addr);
else
error = EINVAL;
break;
case DVDIOCREADSTRUCTURE:
if (cdp->cap.media & MST_READ_DVDROM)
error = acd_read_structure(dev, (struct dvd_struct *)addr);
else
error = EINVAL;
break;
default:
error = ata_device_ioctl(dev, cmd, addr);
}
return error;
}
static int
acd_geom_access(struct g_provider *pp, int dr, int dw, int de)
{
device_t dev = pp->geom->softc;
struct acd_softc *cdp = device_get_ivars(dev);
struct ata_request *request;
int8_t ccb[16] = { ATAPI_TEST_UNIT_READY, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int timeout = 60, track;
if (!(request = ata_alloc_request()))
return ENOMEM;
/* wait if drive is not finished loading the medium */
while (timeout--) {
request->dev = dev;
bcopy(ccb, request->u.atapi.ccb, 16);
request->flags = ATA_R_ATAPI;
request->timeout = ATA_REQUEST_TIMEOUT;
ata_queue_request(request);
if (!request->error &&
(request->u.atapi.sense.key == 2 ||
request->u.atapi.sense.key == 7) &&
request->u.atapi.sense.asc == 4 &&
request->u.atapi.sense.ascq == 1)
pause("acdld", hz / 2);
else
break;
}
ata_free_request(request);
if (pp->acr == 0) {
acd_prevent_allow(dev, 1);
cdp->flags |= F_LOCKED;
acd_read_toc(dev);
}
if (dr + pp->acr == 0) {
acd_prevent_allow(dev, 0);
cdp->flags &= ~F_LOCKED;
}
if ((track = pp->index)) {
pp->sectorsize = (cdp->toc.tab[track - 1].control & 4) ? 2048 : 2352;
pp->mediasize = ntohl(cdp->toc.tab[track].addr.lba) -
ntohl(cdp->toc.tab[track - 1].addr.lba);
}
else {
pp->sectorsize = cdp->block_size;
pp->mediasize = cdp->disk_size;
}
pp->mediasize *= pp->sectorsize;
return 0;
}
