Lines Matching refs:raw_cmd
409 static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
911 raw_cmd = NULL;
1070 if (raw_cmd->length == 0) {
1073 raw_cmd->fullcmd, raw_cmd->cmd_count, false);
1078 if (((unsigned long)raw_cmd->kernel_data) % 512) {
1079 pr_info("non aligned address: %p\n", raw_cmd->kernel_data);
1087 if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
1088 (raw_cmd->flags & FD_RAW_READ) ?
1099 fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
1100 fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
1102 fd_set_dma_addr(raw_cmd->kernel_data);
1103 fd_set_dma_count(raw_cmd->length);
1210 if (raw_cmd->rate & 0x40) {
1211 switch (raw_cmd->rate & 3) {
1297 switch (raw_cmd->rate & 0x03) {
1367 if ((raw_cmd->rate & 3) == fdc_state[current_fdc].dtr)
1371 fdc_outb(raw_cmd->rate & 3, current_fdc, FD_DCR);
1378 fdc_state[current_fdc].dtr = raw_cmd->rate & 3;
1490 flags = raw_cmd->flags;
1517 for (i = 0; i < raw_cmd->cmd_count; i++)
1518 r |= output_byte(current_fdc, raw_cmd->fullcmd[i]);
1603 disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
1618 (raw_cmd->flags & FD_RAW_NEED_DISK) &&
1619 (drive_state[current_drive].track <= NO_TRACK || drive_state[current_drive].track == raw_cmd->track)) {
1622 if (raw_cmd->track)
1623 track = raw_cmd->track - 1;
1628 raw_cmd->flags |= FD_RAW_NEED_SEEK;
1634 if (raw_cmd->track != drive_state[current_drive].track &&
1635 (raw_cmd->flags & FD_RAW_NEED_SEEK))
1636 track = raw_cmd->track;
1905 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
1939 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1945 if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
1947 fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
1952 if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
1957 if ((raw_cmd->flags & FD_RAW_READ) ||
1958 (raw_cmd->flags & FD_RAW_WRITE))
2148 raw_cmd = &default_raw_cmd;
2149 raw_cmd->track = track;
2151 raw_cmd->flags = (FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2153 raw_cmd->rate = _floppy->rate & 0x43;
2154 raw_cmd->cmd_count = NR_F;
2155 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_FORMAT);
2156 raw_cmd->cmd[DR_SELECT] = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
2157 raw_cmd->cmd[F_SIZECODE] = FD_SIZECODE(_floppy);
2158 raw_cmd->cmd[F_SECT_PER_TRACK] = _floppy->sect << 2 >> raw_cmd->cmd[F_SIZECODE];
2159 raw_cmd->cmd[F_GAP] = _floppy->fmt_gap;
2160 raw_cmd->cmd[F_FILL] = FD_FILL_BYTE;
2162 raw_cmd->kernel_data = floppy_track_buffer;
2163 raw_cmd->length = 4 * raw_cmd->cmd[F_SECT_PER_TRACK];
2165 if (!raw_cmd->cmd[F_SECT_PER_TRACK])
2169 head_shift = (raw_cmd->cmd[F_SECT_PER_TRACK] + 5) / 6;
2176 % raw_cmd->cmd[F_SECT_PER_TRACK];
2184 for (count = 0; count < raw_cmd->cmd[F_SECT_PER_TRACK]; ++count) {
2188 here[count].size = raw_cmd->cmd[F_SIZECODE];
2191 for (count = 1; count <= raw_cmd->cmd[F_SECT_PER_TRACK]; ++count) {
2193 n = (n + il) % raw_cmd->cmd[F_SECT_PER_TRACK];
2196 if (n >= raw_cmd->cmd[F_SECT_PER_TRACK]) {
2197 n -= raw_cmd->cmd[F_SECT_PER_TRACK];
2204 for (count = 0; count < raw_cmd->cmd[F_SECT_PER_TRACK]; count++)
2333 ssize = DIV_ROUND_UP(1 << raw_cmd->cmd[SIZECODE], 4);
2340 if (raw_cmd->cmd[COMMAND] & 0x80)
2345 nr_sectors = (((reply_buffer[R_TRACK] - raw_cmd->cmd[TRACK]) * heads +
2346 reply_buffer[R_HEAD] - raw_cmd->cmd[HEAD]) * raw_cmd->cmd[SECT_PER_TRACK] +
2347 reply_buffer[R_SECTOR] - raw_cmd->cmd[SECTOR] + eoc) << raw_cmd->cmd[SIZECODE] >> 2;
2354 raw_cmd->cmd[SECTOR]);
2356 raw_cmd->cmd[HEAD]);
2358 raw_cmd->cmd[TRACK]);
2361 raw_cmd->cmd[SECT_PER_TRACK], fsector_t, ssize);
2399 if (CT(raw_cmd->cmd[COMMAND]) != FD_READ ||
2400 raw_cmd->kernel_data == bio_data(current_req->bio)) {
2403 } else if (CT(raw_cmd->cmd[COMMAND]) == FD_READ) {
2404 buffer_track = raw_cmd->track;
2462 if (current_count_sectors <= 0 && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE &&
2468 if (remaining > blk_rq_bytes(current_req) && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {
2503 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)
2505 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE)
2512 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)
2530 * transfer length: We use raw_cmd->cmd[SECT_PER_TRACK]. Unfortunately, this
2539 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {
2540 raw_cmd->cmd[COMMAND] &= ~0x80; /* switch off multiple track mode */
2542 hard_sectors = raw_cmd->length >> (7 + raw_cmd->cmd[SIZECODE]);
2543 end_sector = raw_cmd->cmd[SECTOR] + hard_sectors - 1;
2544 if (end_sector > raw_cmd->cmd[SECT_PER_TRACK]) {
2546 end_sector, raw_cmd->cmd[SECT_PER_TRACK]);
2549 raw_cmd->cmd[SECT_PER_TRACK] = end_sector;
2550 /* make sure raw_cmd->cmd[SECT_PER_TRACK]
2578 raw_cmd = &default_raw_cmd;
2579 raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
2580 raw_cmd->cmd_count = NR_RW;
2582 raw_cmd->flags |= FD_RAW_READ;
2583 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_READ);
2585 raw_cmd->flags |= FD_RAW_WRITE;
2586 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_WRITE);
2594 raw_cmd->cmd[TRACK] = (int)blk_rq_pos(current_req) / max_sector;
2596 if (_floppy->track && raw_cmd->cmd[TRACK] >= _floppy->track) {
2603 raw_cmd->cmd[HEAD] = fsector_t / _floppy->sect;
2611 if ((_floppy->rate & FD_2M) && (!raw_cmd->cmd[TRACK]) && (!raw_cmd->cmd[HEAD])) {
2619 raw_cmd->cmd[SIZECODE] = 2;
2621 raw_cmd->cmd[SIZECODE] = FD_SIZECODE(_floppy);
2622 raw_cmd->rate = _floppy->rate & 0x43;
2624 (raw_cmd->cmd[TRACK] || raw_cmd->cmd[HEAD]) && raw_cmd->rate == 2)
2625 raw_cmd->rate = 1;
2627 if (raw_cmd->cmd[SIZECODE])
2628 raw_cmd->cmd[SIZECODE2] = 0xff;
2630 raw_cmd->cmd[SIZECODE2] = 0x80;
2631 raw_cmd->track = raw_cmd->cmd[TRACK] << STRETCH(_floppy);
2632 raw_cmd->cmd[DR_SELECT] = UNIT(current_drive) + PH_HEAD(_floppy, raw_cmd->cmd[HEAD]);
2633 raw_cmd->cmd[GAP] = _floppy->gap;
2634 ssize = DIV_ROUND_UP(1 << raw_cmd->cmd[SIZECODE], 4);
2635 raw_cmd->cmd[SECT_PER_TRACK] = _floppy->sect << 2 >> raw_cmd->cmd[SIZECODE];
2636 raw_cmd->cmd[SECTOR] = ((fsector_t % _floppy->sect) << 2 >> raw_cmd->cmd[SIZECODE]) +
2644 raw_cmd->cmd[SECT_PER_TRACK]++;
2646 raw_cmd->cmd[SECTOR]--;
2651 raw_cmd->cmd[SIZECODE]--;
2654 raw_cmd->cmd[SECTOR]++;
2655 raw_cmd->cmd[SECT_PER_TRACK]++;
2658 max_sector = raw_cmd->cmd[HEAD] * _floppy->sect + tracksize;
2659 } else if (!raw_cmd->cmd[TRACK] && !raw_cmd->cmd[HEAD] && !(_floppy->rate & FD_2M) && probing) {
2661 } else if (!raw_cmd->cmd[HEAD] && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {
2669 if ((raw_cmd->track == buffer_track) &&
2673 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ) {
2678 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {
2687 raw_cmd->flags &= ~FD_RAW_WRITE;
2688 raw_cmd->flags |= FD_RAW_READ;
2689 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_READ);
2727 raw_cmd->kernel_data = bio_data(current_req->bio);
2728 raw_cmd->length = current_count_sectors << 9;
2729 if (raw_cmd->length == 0) {
2740 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)
2744 if (buffer_track != raw_cmd->track || /* bad track */
2748 ((CT(raw_cmd->cmd[COMMAND]) == FD_READ ||
2757 raw_cmd->kernel_data = floppy_track_buffer +
2760 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {
2767 buffer_track = raw_cmd->track;
2777 raw_cmd->length = in_sector_offset + current_count_sectors;
2778 raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2779 raw_cmd->length <<= 9;
2780 if ((raw_cmd->length < current_count_sectors << 9) ||
2781 (raw_cmd->kernel_data != bio_data(current_req->bio) &&
2782 CT(raw_cmd->cmd[COMMAND]) == FD_WRITE &&
2783 (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2785 raw_cmd->length % (128 << raw_cmd->cmd[SIZECODE]) ||
2786 raw_cmd->length <= 0 || current_count_sectors <= 0) {
2788 raw_cmd->length, current_count_sectors);
2789 if (raw_cmd->kernel_data != bio_data(current_req->bio))
2791 (int)((raw_cmd->kernel_data -
2796 pr_info("ssize=%x SIZECODE=%d\n", ssize, raw_cmd->cmd[SIZECODE]);
2798 raw_cmd->cmd[COMMAND], raw_cmd->cmd[SECTOR],
2799 raw_cmd->cmd[HEAD], raw_cmd->cmd[TRACK]);
2807 if (raw_cmd->kernel_data != bio_data(current_req->bio)) {
2808 if (raw_cmd->kernel_data < floppy_track_buffer ||
2810 raw_cmd->length < 0 ||
2811 raw_cmd->kernel_data + raw_cmd->length >
2815 fsector_t, buffer_min, raw_cmd->length >> 9);
2818 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)
2820 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE)
2824 } else if (raw_cmd->length > blk_rq_bytes(current_req) ||
2828 } else if (raw_cmd->length < current_count_sectors << 9) {
2830 pr_info("bytes=%ld\n", raw_cmd->length >> 9);
2833 if (raw_cmd->length == 0) {
2884 raw_cmd = &default_raw_cmd;
2885 raw_cmd->flags = 0;
2981 raw_cmd = &default_raw_cmd;
2982 raw_cmd->flags = flag;
2983 raw_cmd->track = 0;
2984 raw_cmd->cmd_count = 0;
3078 raw_cmd->flags |= FD_RAW_FAILURE;
3079 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3081 raw_cmd->reply_count = inr;
3082 if (raw_cmd->reply_count > FD_RAW_REPLY_SIZE)
3083 raw_cmd->reply_count = 0;
3084 for (i = 0; i < raw_cmd->reply_count; i++)
3085 raw_cmd->reply[i] = reply_buffer[i];
3087 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3090 raw_cmd->length = fd_get_dma_residue();
3094 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3095 (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3096 raw_cmd->flags |= FD_RAW_FAILURE;
3099 raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3101 raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3102 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3105 if (raw_cmd->next &&
3106 (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3107 !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3108 ((raw_cmd->flags & FD_RAW_FAILURE) ||
3109 !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3110 raw_cmd = raw_cmd->next;
3258 raw_cmd = my_raw_cmd;
3262 "calling disk change from raw_cmd ioctl\n");
3325 /* check for zero in raw_cmd->cmd[F_SECT_PER_TRACK] */
4626 raw_cmd = NULL;