tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

ALSA: sparc/cs4231: Use guard() for spin locks

Clean up the code using guard() for spin locks.

Merely code refactoring, and no behavior change.

Signed-off-by: Takashi Iwai <tiwai@suse.de>

Takashi Iwai 4baca4bf 4c680628

+68 -136
+68 -136
sound/sparc/cs4231.c
··· 357 357 358 358 static void snd_cs4231_mce_up(struct snd_cs4231 *chip) 359 359 { 360 - unsigned long flags; 361 360 int timeout; 362 361 363 - spin_lock_irqsave(&chip->lock, flags); 362 + guard(spinlock_irqsave)(&chip->lock); 364 363 snd_cs4231_ready(chip); 365 364 #ifdef CONFIG_SND_DEBUG 366 365 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT) ··· 375 376 if (!(timeout & CS4231_MCE)) 376 377 __cs4231_writeb(chip, chip->mce_bit | (timeout & 0x1f), 377 378 CS4231U(chip, REGSEL)); 378 - spin_unlock_irqrestore(&chip->lock, flags); 379 379 } 380 380 381 381 static void snd_cs4231_mce_down(struct snd_cs4231 *chip) ··· 484 486 { 485 487 unsigned int what = 0; 486 488 struct snd_pcm_substream *s; 487 - unsigned long flags; 488 489 489 490 snd_pcm_group_for_each_entry(s, substream) { 490 491 if (s == chip->playback_substream) { ··· 495 498 } 496 499 } 497 500 498 - spin_lock_irqsave(&chip->lock, flags); 501 + guard(spinlock_irqsave)(&chip->lock); 499 502 if (cmd == SNDRV_PCM_TRIGGER_START) { 500 503 cs4231_dma_trigger(substream, what, 1); 501 504 chip->image[CS4231_IFACE_CTRL] |= what; ··· 505 508 } 506 509 snd_cs4231_out(chip, CS4231_IFACE_CTRL, 507 510 chip->image[CS4231_IFACE_CTRL]); 508 - spin_unlock_irqrestore(&chip->lock, flags); 509 511 break; 510 512 } 511 513 default: ··· 560 564 561 565 static void snd_cs4231_calibrate_mute(struct snd_cs4231 *chip, int mute) 562 566 { 563 - unsigned long flags; 564 - 565 567 mute = mute ? 1 : 0; 566 - spin_lock_irqsave(&chip->lock, flags); 567 - if (chip->calibrate_mute == mute) { 568 - spin_unlock_irqrestore(&chip->lock, flags); 568 + guard(spinlock_irqsave)(&chip->lock); 569 + if (chip->calibrate_mute == mute) 569 570 return; 570 - } 571 + 571 572 if (!mute) { 572 573 snd_cs4231_dout(chip, CS4231_LEFT_INPUT, 573 574 chip->image[CS4231_LEFT_INPUT]); ··· 592 599 snd_cs4231_dout(chip, CS4231_MONO_CTRL, 593 600 mute ? 0xc0 : chip->image[CS4231_MONO_CTRL]); 594 601 chip->calibrate_mute = mute; 595 - spin_unlock_irqrestore(&chip->lock, flags); 596 602 } 597 603 598 604 static void snd_cs4231_playback_format(struct snd_cs4231 *chip, 599 605 struct snd_pcm_hw_params *params, 600 606 unsigned char pdfr) 601 607 { 602 - unsigned long flags; 603 - 604 608 guard(mutex)(&chip->mce_mutex); 605 609 snd_cs4231_calibrate_mute(chip, 1); 606 610 607 611 snd_cs4231_mce_up(chip); 608 612 609 - spin_lock_irqsave(&chip->lock, flags); 610 - snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, 611 - (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) ? 612 - (pdfr & 0xf0) | (chip->image[CS4231_REC_FORMAT] & 0x0f) : 613 - pdfr); 614 - spin_unlock_irqrestore(&chip->lock, flags); 613 + scoped_guard(spinlock_irqsave, &chip->lock) { 614 + snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, 615 + (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) ? 616 + (pdfr & 0xf0) | (chip->image[CS4231_REC_FORMAT] & 0x0f) : 617 + pdfr); 618 + } 615 619 616 620 snd_cs4231_mce_down(chip); 617 621 ··· 657 667 658 668 static int snd_cs4231_timer_start(struct snd_timer *timer) 659 669 { 660 - unsigned long flags; 661 670 unsigned int ticks; 662 671 struct snd_cs4231 *chip = snd_timer_chip(timer); 663 672 664 - spin_lock_irqsave(&chip->lock, flags); 673 + guard(spinlock_irqsave)(&chip->lock); 665 674 ticks = timer->sticks; 666 675 if ((chip->image[CS4231_ALT_FEATURE_1] & CS4231_TIMER_ENABLE) == 0 || 667 676 (unsigned char)(ticks >> 8) != chip->image[CS4231_TIMER_HIGH] || ··· 675 686 chip->image[CS4231_ALT_FEATURE_1] | 676 687 CS4231_TIMER_ENABLE); 677 688 } 678 - spin_unlock_irqrestore(&chip->lock, flags); 679 689 680 690 return 0; 681 691 } 682 692 683 693 static int snd_cs4231_timer_stop(struct snd_timer *timer) 684 694 { 685 - unsigned long flags; 686 695 struct snd_cs4231 *chip = snd_timer_chip(timer); 687 696 688 - spin_lock_irqsave(&chip->lock, flags); 697 + guard(spinlock_irqsave)(&chip->lock); 689 698 chip->image[CS4231_ALT_FEATURE_1] &= ~CS4231_TIMER_ENABLE; 690 699 snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, 691 700 chip->image[CS4231_ALT_FEATURE_1]); 692 - spin_unlock_irqrestore(&chip->lock, flags); 693 701 694 702 return 0; 695 703 } 696 704 697 705 static void snd_cs4231_init(struct snd_cs4231 *chip) 698 706 { 699 - unsigned long flags; 700 - 701 707 snd_cs4231_mce_down(chip); 702 708 703 709 #ifdef SNDRV_DEBUG_MCE 704 710 pr_debug("init: (1)\n"); 705 711 #endif 706 712 snd_cs4231_mce_up(chip); 707 - spin_lock_irqsave(&chip->lock, flags); 708 - chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE | 709 - CS4231_PLAYBACK_PIO | 710 - CS4231_RECORD_ENABLE | 711 - CS4231_RECORD_PIO | 712 - CS4231_CALIB_MODE); 713 - chip->image[CS4231_IFACE_CTRL] |= CS4231_AUTOCALIB; 714 - snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]); 715 - spin_unlock_irqrestore(&chip->lock, flags); 713 + scoped_guard(spinlock_irqsave, &chip->lock) { 714 + chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE | 715 + CS4231_PLAYBACK_PIO | 716 + CS4231_RECORD_ENABLE | 717 + CS4231_RECORD_PIO | 718 + CS4231_CALIB_MODE); 719 + chip->image[CS4231_IFACE_CTRL] |= CS4231_AUTOCALIB; 720 + snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]); 721 + } 716 722 snd_cs4231_mce_down(chip); 717 723 718 724 #ifdef SNDRV_DEBUG_MCE ··· 715 731 #endif 716 732 717 733 snd_cs4231_mce_up(chip); 718 - spin_lock_irqsave(&chip->lock, flags); 719 - snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, 720 - chip->image[CS4231_ALT_FEATURE_1]); 721 - spin_unlock_irqrestore(&chip->lock, flags); 734 + scoped_guard(spinlock_irqsave, &chip->lock) { 735 + snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, 736 + chip->image[CS4231_ALT_FEATURE_1]); 737 + } 722 738 snd_cs4231_mce_down(chip); 723 739 724 740 #ifdef SNDRV_DEBUG_MCE ··· 726 742 chip->image[CS4231_ALT_FEATURE_1]); 727 743 #endif 728 744 729 - spin_lock_irqsave(&chip->lock, flags); 730 - snd_cs4231_out(chip, CS4231_ALT_FEATURE_2, 731 - chip->image[CS4231_ALT_FEATURE_2]); 732 - spin_unlock_irqrestore(&chip->lock, flags); 745 + scoped_guard(spinlock_irqsave, &chip->lock) { 746 + snd_cs4231_out(chip, CS4231_ALT_FEATURE_2, 747 + chip->image[CS4231_ALT_FEATURE_2]); 748 + } 733 749 734 750 snd_cs4231_mce_up(chip); 735 - spin_lock_irqsave(&chip->lock, flags); 736 - snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, 737 - chip->image[CS4231_PLAYBK_FORMAT]); 738 - spin_unlock_irqrestore(&chip->lock, flags); 751 + scoped_guard(spinlock_irqsave, &chip->lock) { 752 + snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, 753 + chip->image[CS4231_PLAYBK_FORMAT]); 754 + } 739 755 snd_cs4231_mce_down(chip); 740 756 741 757 #ifdef SNDRV_DEBUG_MCE ··· 743 759 #endif 744 760 745 761 snd_cs4231_mce_up(chip); 746 - spin_lock_irqsave(&chip->lock, flags); 747 - snd_cs4231_out(chip, CS4231_REC_FORMAT, chip->image[CS4231_REC_FORMAT]); 748 - spin_unlock_irqrestore(&chip->lock, flags); 762 + scoped_guard(spinlock_irqsave, &chip->lock) { 763 + snd_cs4231_out(chip, CS4231_REC_FORMAT, chip->image[CS4231_REC_FORMAT]); 764 + } 749 765 snd_cs4231_mce_down(chip); 750 766 751 767 #ifdef SNDRV_DEBUG_MCE ··· 755 771 756 772 static int snd_cs4231_open(struct snd_cs4231 *chip, unsigned int mode) 757 773 { 758 - unsigned long flags; 759 - 760 774 guard(mutex)(&chip->open_mutex); 761 775 if ((chip->mode & mode)) 762 776 return -EAGAIN; ··· 763 781 return 0; 764 782 } 765 783 /* ok. now enable and ack CODEC IRQ */ 766 - spin_lock_irqsave(&chip->lock, flags); 784 + guard(spinlock_irqsave)(&chip->lock); 767 785 snd_cs4231_out(chip, CS4231_IRQ_STATUS, CS4231_PLAYBACK_IRQ | 768 786 CS4231_RECORD_IRQ | 769 787 CS4231_TIMER_IRQ); ··· 775 793 CS4231_RECORD_IRQ | 776 794 CS4231_TIMER_IRQ); 777 795 snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0); 778 - 779 - spin_unlock_irqrestore(&chip->lock, flags); 780 796 781 797 chip->mode = mode; 782 798 return 0; ··· 876 896 { 877 897 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); 878 898 struct snd_pcm_runtime *runtime = substream->runtime; 879 - unsigned long flags; 880 - int ret = 0; 881 899 882 - spin_lock_irqsave(&chip->lock, flags); 900 + guard(spinlock_irqsave)(&chip->lock); 883 901 884 902 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE | 885 903 CS4231_PLAYBACK_PIO); 886 904 887 - if (WARN_ON(runtime->period_size > 0xffff + 1)) { 888 - ret = -EINVAL; 889 - goto out; 890 - } 905 + if (WARN_ON(runtime->period_size > 0xffff + 1)) 906 + return -EINVAL; 891 907 892 908 chip->p_periods_sent = 0; 893 909 894 - out: 895 - spin_unlock_irqrestore(&chip->lock, flags); 896 - 897 - return ret; 910 + return 0; 898 911 } 899 912 900 913 static int snd_cs4231_capture_hw_params(struct snd_pcm_substream *substream, ··· 907 934 static int snd_cs4231_capture_prepare(struct snd_pcm_substream *substream) 908 935 { 909 936 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); 910 - unsigned long flags; 911 937 912 - spin_lock_irqsave(&chip->lock, flags); 938 + guard(spinlock_irqsave)(&chip->lock); 913 939 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_RECORD_ENABLE | 914 940 CS4231_RECORD_PIO); 915 941 916 942 917 943 chip->c_periods_sent = 0; 918 - spin_unlock_irqrestore(&chip->lock, flags); 919 944 920 945 return 0; 921 946 } 922 947 923 948 static void snd_cs4231_overrange(struct snd_cs4231 *chip) 924 949 { 925 - unsigned long flags; 926 950 unsigned char res; 927 951 928 - spin_lock_irqsave(&chip->lock, flags); 952 + guard(spinlock_irqsave)(&chip->lock); 929 953 res = snd_cs4231_in(chip, CS4231_TEST_INIT); 930 - spin_unlock_irqrestore(&chip->lock, flags); 931 954 932 955 /* detect overrange only above 0dB; may be user selectable? */ 933 956 if (res & (0x08 | 0x02)) ··· 982 1013 983 1014 static int snd_cs4231_probe(struct snd_cs4231 *chip) 984 1015 { 985 - unsigned long flags; 986 1016 int i; 987 1017 int id = 0; 988 1018 int vers = 0; ··· 992 1024 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT) 993 1025 msleep(2); 994 1026 else { 995 - spin_lock_irqsave(&chip->lock, flags); 1027 + guard(spinlock_irqsave)(&chip->lock); 996 1028 snd_cs4231_out(chip, CS4231_MISC_INFO, CS4231_MODE2); 997 1029 id = snd_cs4231_in(chip, CS4231_MISC_INFO) & 0x0f; 998 1030 vers = snd_cs4231_in(chip, CS4231_VERSION); 999 - spin_unlock_irqrestore(&chip->lock, flags); 1000 1031 if (id == 0x0a) 1001 1032 break; /* this is valid value */ 1002 1033 } ··· 1005 1038 if (id != 0x0a) 1006 1039 return -ENODEV; /* no valid device found */ 1007 1040 1008 - spin_lock_irqsave(&chip->lock, flags); 1009 - 1010 - /* clear any pendings IRQ */ 1011 - __cs4231_readb(chip, CS4231U(chip, STATUS)); 1012 - __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); 1013 - mb(); 1014 - 1015 - spin_unlock_irqrestore(&chip->lock, flags); 1041 + scoped_guard(spinlock_irqsave, &chip->lock) { 1042 + /* clear any pendings IRQ */ 1043 + __cs4231_readb(chip, CS4231U(chip, STATUS)); 1044 + __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); 1045 + mb(); 1046 + } 1016 1047 1017 1048 chip->image[CS4231_MISC_INFO] = CS4231_MODE2; 1018 1049 chip->image[CS4231_IFACE_CTRL] = ··· 1024 1059 1025 1060 snd_cs4231_mce_down(chip); 1026 1061 1027 - spin_lock_irqsave(&chip->lock, flags); 1028 - 1029 - for (i = 0; i < 32; i++) /* ok.. fill all CS4231 registers */ 1030 - snd_cs4231_out(chip, i, *ptr++); 1031 - 1032 - spin_unlock_irqrestore(&chip->lock, flags); 1062 + scoped_guard(spinlock_irqsave, &chip->lock) { 1063 + for (i = 0; i < 32; i++) /* ok.. fill all CS4231 registers */ 1064 + snd_cs4231_out(chip, i, *ptr++); 1065 + } 1033 1066 1034 1067 snd_cs4231_mce_up(chip); 1035 1068 ··· 1236 1273 struct snd_ctl_elem_value *ucontrol) 1237 1274 { 1238 1275 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); 1239 - unsigned long flags; 1240 1276 1241 - spin_lock_irqsave(&chip->lock, flags); 1277 + guard(spinlock_irqsave)(&chip->lock); 1242 1278 ucontrol->value.enumerated.item[0] = 1243 1279 (chip->image[CS4231_LEFT_INPUT] & CS4231_MIXS_ALL) >> 6; 1244 1280 ucontrol->value.enumerated.item[1] = 1245 1281 (chip->image[CS4231_RIGHT_INPUT] & CS4231_MIXS_ALL) >> 6; 1246 - spin_unlock_irqrestore(&chip->lock, flags); 1247 1282 1248 1283 return 0; 1249 1284 } ··· 1250 1289 struct snd_ctl_elem_value *ucontrol) 1251 1290 { 1252 1291 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); 1253 - unsigned long flags; 1254 1292 unsigned short left, right; 1255 1293 int change; 1256 1294 ··· 1259 1299 left = ucontrol->value.enumerated.item[0] << 6; 1260 1300 right = ucontrol->value.enumerated.item[1] << 6; 1261 1301 1262 - spin_lock_irqsave(&chip->lock, flags); 1302 + guard(spinlock_irqsave)(&chip->lock); 1263 1303 1264 1304 left = (chip->image[CS4231_LEFT_INPUT] & ~CS4231_MIXS_ALL) | left; 1265 1305 right = (chip->image[CS4231_RIGHT_INPUT] & ~CS4231_MIXS_ALL) | right; ··· 1267 1307 right != chip->image[CS4231_RIGHT_INPUT]; 1268 1308 snd_cs4231_out(chip, CS4231_LEFT_INPUT, left); 1269 1309 snd_cs4231_out(chip, CS4231_RIGHT_INPUT, right); 1270 - 1271 - spin_unlock_irqrestore(&chip->lock, flags); 1272 1310 1273 1311 return change; 1274 1312 } ··· 1289 1331 struct snd_ctl_elem_value *ucontrol) 1290 1332 { 1291 1333 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); 1292 - unsigned long flags; 1293 1334 int reg = kcontrol->private_value & 0xff; 1294 1335 int shift = (kcontrol->private_value >> 8) & 0xff; 1295 1336 int mask = (kcontrol->private_value >> 16) & 0xff; 1296 1337 int invert = (kcontrol->private_value >> 24) & 0xff; 1297 1338 1298 - spin_lock_irqsave(&chip->lock, flags); 1339 + guard(spinlock_irqsave)(&chip->lock); 1299 1340 1300 1341 ucontrol->value.integer.value[0] = (chip->image[reg] >> shift) & mask; 1301 - 1302 - spin_unlock_irqrestore(&chip->lock, flags); 1303 1342 1304 1343 if (invert) 1305 1344 ucontrol->value.integer.value[0] = ··· 1309 1354 struct snd_ctl_elem_value *ucontrol) 1310 1355 { 1311 1356 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); 1312 - unsigned long flags; 1313 1357 int reg = kcontrol->private_value & 0xff; 1314 1358 int shift = (kcontrol->private_value >> 8) & 0xff; 1315 1359 int mask = (kcontrol->private_value >> 16) & 0xff; ··· 1321 1367 val = mask - val; 1322 1368 val <<= shift; 1323 1369 1324 - spin_lock_irqsave(&chip->lock, flags); 1370 + guard(spinlock_irqsave)(&chip->lock); 1325 1371 1326 1372 val = (chip->image[reg] & ~(mask << shift)) | val; 1327 1373 change = val != chip->image[reg]; 1328 1374 snd_cs4231_out(chip, reg, val); 1329 - 1330 - spin_unlock_irqrestore(&chip->lock, flags); 1331 1375 1332 1376 return change; 1333 1377 } ··· 1348 1396 struct snd_ctl_elem_value *ucontrol) 1349 1397 { 1350 1398 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); 1351 - unsigned long flags; 1352 1399 int left_reg = kcontrol->private_value & 0xff; 1353 1400 int right_reg = (kcontrol->private_value >> 8) & 0xff; 1354 1401 int shift_left = (kcontrol->private_value >> 16) & 0x07; ··· 1355 1404 int mask = (kcontrol->private_value >> 24) & 0xff; 1356 1405 int invert = (kcontrol->private_value >> 22) & 1; 1357 1406 1358 - spin_lock_irqsave(&chip->lock, flags); 1407 + guard(spinlock_irqsave)(&chip->lock); 1359 1408 1360 1409 ucontrol->value.integer.value[0] = 1361 1410 (chip->image[left_reg] >> shift_left) & mask; 1362 1411 ucontrol->value.integer.value[1] = 1363 1412 (chip->image[right_reg] >> shift_right) & mask; 1364 - 1365 - spin_unlock_irqrestore(&chip->lock, flags); 1366 1413 1367 1414 if (invert) { 1368 1415 ucontrol->value.integer.value[0] = ··· 1376 1427 struct snd_ctl_elem_value *ucontrol) 1377 1428 { 1378 1429 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); 1379 - unsigned long flags; 1380 1430 int left_reg = kcontrol->private_value & 0xff; 1381 1431 int right_reg = (kcontrol->private_value >> 8) & 0xff; 1382 1432 int shift_left = (kcontrol->private_value >> 16) & 0x07; ··· 1394 1446 val1 <<= shift_left; 1395 1447 val2 <<= shift_right; 1396 1448 1397 - spin_lock_irqsave(&chip->lock, flags); 1449 + guard(spinlock_irqsave)(&chip->lock); 1398 1450 1399 1451 val1 = (chip->image[left_reg] & ~(mask << shift_left)) | val1; 1400 1452 val2 = (chip->image[right_reg] & ~(mask << shift_right)) | val2; ··· 1402 1454 change |= val2 != chip->image[right_reg]; 1403 1455 snd_cs4231_out(chip, left_reg, val1); 1404 1456 snd_cs4231_out(chip, right_reg, val2); 1405 - 1406 - spin_unlock_irqrestore(&chip->lock, flags); 1407 1457 1408 1458 return change; 1409 1459 } ··· 1547 1601 1548 1602 static irqreturn_t snd_cs4231_sbus_interrupt(int irq, void *dev_id) 1549 1603 { 1550 - unsigned long flags; 1551 1604 unsigned char status; 1552 1605 u32 csr; 1553 1606 struct snd_cs4231 *chip = dev_id; ··· 1583 1638 snd_cs4231_overrange(chip); 1584 1639 1585 1640 /* ACK the CS4231 interrupt. */ 1586 - spin_lock_irqsave(&chip->lock, flags); 1641 + guard(spinlock_irqsave)(&chip->lock); 1587 1642 snd_cs4231_outm(chip, CS4231_IRQ_STATUS, ~CS4231_ALL_IRQS | ~status, 0); 1588 - spin_unlock_irqrestore(&chip->lock, flags); 1589 1643 1590 1644 return IRQ_HANDLED; 1591 1645 } ··· 1596 1652 static int sbus_dma_request(struct cs4231_dma_control *dma_cont, 1597 1653 dma_addr_t bus_addr, size_t len) 1598 1654 { 1599 - unsigned long flags; 1600 1655 u32 test, csr; 1601 - int err; 1602 1656 struct sbus_dma_info *base = &dma_cont->sbus_info; 1603 1657 1604 1658 if (len >= (1 << 24)) 1605 1659 return -EINVAL; 1606 - spin_lock_irqsave(&base->lock, flags); 1660 + guard(spinlock_irqsave)(&base->lock); 1607 1661 csr = sbus_readl(base->regs + APCCSR); 1608 - err = -EINVAL; 1609 1662 test = APC_CDMA_READY; 1610 1663 if (base->dir == APC_PLAY) 1611 1664 test = APC_PDMA_READY; 1612 1665 if (!(csr & test)) 1613 - goto out; 1614 - err = -EBUSY; 1666 + return -EINVAL; 1615 1667 test = APC_XINT_CNVA; 1616 1668 if (base->dir == APC_PLAY) 1617 1669 test = APC_XINT_PNVA; 1618 1670 if (!(csr & test)) 1619 - goto out; 1620 - err = 0; 1671 + return -EBUSY; 1621 1672 sbus_writel(bus_addr, base->regs + base->dir + APCNVA); 1622 1673 sbus_writel(len, base->regs + base->dir + APCNC); 1623 - out: 1624 - spin_unlock_irqrestore(&base->lock, flags); 1625 - return err; 1674 + return 0; 1626 1675 } 1627 1676 1628 1677 static void sbus_dma_prepare(struct cs4231_dma_control *dma_cont, int d) 1629 1678 { 1630 - unsigned long flags; 1631 1679 u32 csr, test; 1632 1680 struct sbus_dma_info *base = &dma_cont->sbus_info; 1633 1681 1634 - spin_lock_irqsave(&base->lock, flags); 1682 + guard(spinlock_irqsave)(&base->lock); 1635 1683 csr = sbus_readl(base->regs + APCCSR); 1636 1684 test = APC_GENL_INT | APC_PLAY_INT | APC_XINT_ENA | 1637 1685 APC_XINT_PLAY | APC_XINT_PEMP | APC_XINT_GENL | ··· 1633 1697 APC_XINT_CAPT | APC_XINT_CEMP | APC_XINT_GENL; 1634 1698 csr |= test; 1635 1699 sbus_writel(csr, base->regs + APCCSR); 1636 - spin_unlock_irqrestore(&base->lock, flags); 1637 1700 } 1638 1701 1639 1702 static void sbus_dma_enable(struct cs4231_dma_control *dma_cont, int on) 1640 1703 { 1641 - unsigned long flags; 1642 1704 u32 csr, shift; 1643 1705 struct sbus_dma_info *base = &dma_cont->sbus_info; 1644 1706 1645 - spin_lock_irqsave(&base->lock, flags); 1707 + guard(spinlock_irqsave)(&base->lock); 1646 1708 if (!on) { 1647 1709 sbus_writel(0, base->regs + base->dir + APCNC); 1648 1710 sbus_writel(0, base->regs + base->dir + APCNVA); ··· 1665 1731 else 1666 1732 csr &= ~(APC_CDMA_READY << shift); 1667 1733 sbus_writel(csr, base->regs + APCCSR); 1668 - 1669 - spin_unlock_irqrestore(&base->lock, flags); 1670 1734 } 1671 1735 1672 1736 static unsigned int sbus_dma_addr(struct cs4231_dma_control *dma_cont)